static struct Membership* membershipFreeList;
/** Freelist for struct Ban*'s */
static struct Ban* free_bans;
+/** Freelist for struct MemberFlood*'s */
+static struct MemberFlood* free_MemberFlood;
/** Number of ban structures allocated. */
static size_t bans_alloc;
/** Number of ban structures in use. */
member->user = who;
member->channel = chptr;
member->status = flags;
+ member->flood = NULL;
SetOpLevel(member, oplevel);
member->next_member = chptr->members;
--(cli_user(member->user))->joined;
+ member->flood = NULL;
+
member->next_member = membershipFreeList;
membershipFreeList = member;
strcat(pbuf, chptr->mode.altchan);
previous_parameter = 1;
}
+ if (*chptr->mode.noflood) {
+ *mbuf++ = 'f';
+ if (previous_parameter)
+ strcat(pbuf, " ");
+ strcat(pbuf, chptr->mode.noflood);
+ previous_parameter = 1;
+ }
if (*chptr->mode.key) {
*mbuf++ = 'k';
if (previous_parameter)
MODE_NOCTCP, 'C',
/* MODE_EXCEPTION, 'e', */
/* MODE_ALTCHAN, 'F', */
+/* MODE_NOFLOOD, 'f', */
MODE_ACCESS, 'a',
MODE_NOAMSGS, 'M',
MODE_NONOTICE, 'N',
bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_CHANOP ? 'o' : 'v';
totalbuflen -= IRCD_MAX(9, tmp) + 1;
}
- } else if (MB_TYPE(mbuf, i) & (MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN)) {
+ } else if (MB_TYPE(mbuf, i) & (MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN | MODE_NOFLOOD)) {
tmp = strlen(MB_STRING(mbuf, i));
if ((totalbuflen - tmp) <= 0) /* don't overflow buffer */
MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
else {
char mode_char;
- switch(MB_TYPE(mbuf, i) & (MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN))
+ switch(MB_TYPE(mbuf, i) & (MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN | MODE_NOFLOOD))
{
case MODE_APASS:
mode_char = 'A';
case MODE_ALTCHAN:
mode_char = 'F';
break;
+ case MODE_NOFLOOD:
+ mode_char = 'f';
+ break;
default:
mode_char = 'b';
break;
else if (MB_TYPE(mbuf, i) & MODE_ALTCHAN)
build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0, ' ');
+ else if ((MB_TYPE(mbuf, i) & (MODE_ADD | MODE_NOFLOOD)) ==
+ (MODE_ADD | MODE_NOFLOOD))
+ build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0, ' ');
}
/* send the messages off to their destination */
build_string(strptr, strptr_i, NumNick(MB_CLIENT(mbuf, i)), ' ');
/* deal with modes that take strings */
- else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN))
+ else if (MB_TYPE(mbuf, i) & (MODE_KEY | MODE_BAN | MODE_EXCEPTION | MODE_APASS | MODE_UPASS | MODE_ALTCHAN | MODE_NOFLOOD))
build_string(strptr, strptr_i, MB_STRING(mbuf, i), 0, ' ');
/*
MODE_ALTCHAN, 'F',
MODE_ACCESS, 'a',
MODE_AUDITORIUM, 'u',
+ MODE_NOFLOOD, 'f',
0x0, 0x0
};
ulong64 add;
int i, bufpos = 0, len;
ulong64 *flag_p;
char *key = 0, limitbuf[20], accessbuf[20];
- char *apass = 0, *upass = 0, *altchan = 0;
+ char *apass = 0, *upass = 0, *altchan = 0, *noflood = 0;
assert(0 != mbuf);
assert(0 != buf);
for (i = 0; i < mbuf->mb_count; i++) { /* find keys and limits */
if (MB_TYPE(mbuf, i) & MODE_ADD) {
- add |= MB_TYPE(mbuf, i) & (MODE_KEY | MODE_LIMIT | MODE_APASS | MODE_UPASS | MODE_ALTCHAN | MODE_ACCESS);
+ add |= MB_TYPE(mbuf, i) & (MODE_KEY | MODE_LIMIT | MODE_APASS | MODE_UPASS | MODE_ALTCHAN | MODE_ACCESS | MODE_NOFLOOD);
if (MB_TYPE(mbuf, i) & MODE_KEY) /* keep strings */
key = MB_STRING(mbuf, i);
apass = MB_STRING(mbuf, i);
else if (MB_TYPE(mbuf, i) & MODE_ALTCHAN)
altchan = MB_STRING(mbuf, i);
+ else if (MB_TYPE(mbuf, i) & MODE_NOFLOOD)
+ noflood = MB_STRING(mbuf, i);
}
}
build_string(buf, &bufpos, apass, 0, ' ');
else if (buf[i] == 'F')
build_string(buf, &bufpos, altchan, 0, ' ');
+ else if (buf[i] == 'f')
+ build_string(buf, &bufpos, noflood, 0, ' ');
}
buf[bufpos] = '\0';
#define DONE_EXCEPTIONLIST 0x400 /**< We've sent the exception list */
#define DONE_ALTCHAN 0x800 /**< We've set the altchan */
#define DONE_ACCESS 0x1000 /**< We've set the access */
+#define DONE_NOFLOOD 0x2000 /**< We've set the noflood options */
struct ParseState {
struct ModeBuf *mbuf;
}
}
+static void
+mode_parse_noflood(struct ParseState *state, ulong64 *flag_p)
+{
+ char *t_str;
+ char *tmp;
+ unsigned int count = 0, time = 0, flags = 0;
+
+ if (state->dir == MODE_ADD) { /* convert arg only if adding noflood */
+ if (MyUser(state->sptr) && state->max_args <= 0) /* too many args? */
+ return;
+
+ if (state->parc <= 0) { /* warn if not enough args */
+ if (MyUser(state->sptr))
+ need_more_params(state->sptr, "MODE +f");
+ return;
+ }
+
+ t_str = state->parv[state->args_used++]; /* grab arg */
+ state->parc--;
+ state->max_args--;
+
+ tmp = t_str;
+
+ if(tmp[0] == '!') {
+ if(state->flags & MODE_PARSE_FORCE) flags |= FLFL_NOFLOOD;
+ else t_str++; //simply ignore if it's not an opmode
+ tmp++;
+ }
+ if(tmp[0] == '+' || tmp[0] == '@') {
+ if(tmp[0] == '+') flags |= FLFL_VOICE;
+ if(tmp[0] == '@') flags |= FLFL_CHANOP;
+ tmp++;
+ }
+ char *p;
+ for(p = tmp; p[0]; p++) {
+ if(p[0] == ':') {
+ char tmpchar = p[0];
+ p[0] = '\0';
+ count = strtoul(tmp,0,10);
+ p[0] = tmpchar;
+ p++;
+ time = strtoul(p,0,10);
+ break;
+ }
+ }
+ if(count <= 0 || time <= 0 || count > 999 || time > 9999) return;
+
+ if (!(state->flags & MODE_PARSE_WIPEOUT) &&
+ (!t_str || t_str == state->chptr->mode.noflood))
+ return;
+ } else
+ t_str = state->chptr->mode.noflood;
+
+ /* If they're not an oper, they can't change modes */
+ if (state->flags & (MODE_PARSE_NOTOPER | MODE_PARSE_NOTMEMBER)) {
+ send_notoper(state);
+ return;
+ }
+
+ /* Can't remove a noflood that's not there */
+ if (state->dir == MODE_DEL && !*state->chptr->mode.noflood)
+ return;
+
+ /* Skip if this is a burst and a lower noflood than this is set already */
+ if ((state->flags & MODE_PARSE_BURST) &&
+ *(state->chptr->mode.noflood))
+ return;
+
+ if (state->done & DONE_NOFLOOD) /* allow noflood to be set only once */
+ return;
+ state->done |= DONE_NOFLOOD;
+
+ if (!state->mbuf)
+ return;
+
+ if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
+ !ircd_strcmp(state->chptr->mode.noflood, t_str))
+ return; /* no change */
+
+ if (state->flags & MODE_PARSE_BOUNCE) {
+ if (*state->chptr->mode.noflood) /* reset old noflood */
+ modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0], state->chptr->mode.noflood, 0);
+ else /* remove new bogus noflood */
+ modebuf_mode_string(state->mbuf, MODE_ADD | flag_p[0], t_str, 0);
+ } else /* send new noflood */
+ modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
+
+ if (state->flags & MODE_PARSE_SET) {
+ if (state->dir == MODE_DEL) /* remove the old noflood */
+ *state->chptr->mode.noflood = '\0';
+ else
+ ircd_strncpy(state->chptr->mode.noflood, t_str, CHANNELLEN);
+ }
+
+ if (state->dir == MODE_ADD) {
+ unsigned int noflood_value = time;
+ noflood_value <<= 10;
+ noflood_value |= count;
+ noflood_value <<= 3;
+ noflood_value |= flags;
+ state->chptr->mode.noflood_value = noflood_value;
+ }
+}
+
static void
mode_parse_quarantine(struct ParseState *state, ulong64 *flag_p)
{
MODE_ALTCHAN, 'F',
MODE_ACCESS, 'a',
MODE_AUDITORIUM, 'u',
+ MODE_NOFLOOD, 'f',
MODE_ADD, '+',
MODE_DEL, '-',
0x0, 0x0
break;
case 'F':
mode_parse_altchan(&state, flag_p);
+ break;
+ case 'f':
+ mode_parse_noflood(&state, flag_p);
break;
case 'Q':
if(IsNetServ(state.sptr) && IsSecurityServ(state.sptr))
if (state.chptr->mode.altchan && !(state.done & DONE_ALTCHAN))
modebuf_mode_string(state.mbuf, MODE_DEL | MODE_ALTCHAN,
state.chptr->mode.altchan, 0);
+ if (state.chptr->mode.noflood && !(state.done & DONE_NOFLOOD))
+ modebuf_mode_string(state.mbuf, MODE_DEL | MODE_NOFLOOD,
+ state.chptr->mode.noflood, 0);
if (*state.chptr->mode.key && !(state.done & DONE_KEY_DEL))
modebuf_mode_string(state.mbuf, MODE_DEL | MODE_KEY,
state.chptr->mode.key, 0);
return 0;
}
+/** Extended flood check.
+ * The channelmode MODE_NOFLOOD prevents users from flooding the channel.
+ *
+ * This function returns 0 if the message may pass and 1 if the message should
+ * be blocked.
+ * For this function to work properly it must be called on every PRIVMSG which
+ * is sent by any user.
+ *
+ * --pk910 2011/7/1
+ */
+int ext_noflood_block(struct Client *cptr, struct Channel *chptr) {
+ if(!chptr->mode.noflood) return 0;
+ struct Membership *member = find_member_link(chptr, cptr);
+ if(!member) return 0; //TODO: we've no check for -n channels implemented, yet
+ //check if this user is really affected by +f
+ unsigned int flags = (chptr->mode.noflood_value & 0x00000007); //0000 0000 0000 0000 0000 0000 0000 0111 = 0x00000007 >> 0
+ unsigned int count = (chptr->mode.noflood_value & 0x00001ff8) >> 3; //0000 0000 0000 0000 0001 1111 1111 1000 = 0x00001ff8 >> 3
+ int time = (chptr->mode.noflood_value & 0x07ffe000) >> 13; //0000 0111 1111 1111 1110 0000 0000 0000 = 0x07ffe000 >> 13
+ if(!(flags & FLFL_NOFLOOD) && HasPriv(cptr, PRIV_FLOOD))
+ return 0;
+ if(!(flags & FLFL_CHANOP) && (member->status & CHFL_CHANOP))
+ return 0;
+ if(!(flags & (FLFL_CHANOP | FLFL_VOICE)) && (member->status & CHFL_VOICE))
+ return 0;
+ int floodcount = 0;
+ struct MemberFlood *floodnode, *prev_floodnode;
+ for (floodnode = member->flood; floodnode; floodnode = floodnode->next_memberflood) {
+ if(floodnode->time + time > CurrentTime) {
+ if(floodcount == 0 && floodnode != member->flood) {
+ //free all before
+ prev_floodnode->next_memberflood = free_MemberFlood;
+ free_MemberFlood = prev_floodnode;
+ member->flood = floodnode;
+ }
+ floodcount++;
+ }
+ prev_floodnode = floodnode;
+ }
+ Debug((DEBUG_INFO, "floodcount: %i", floodcount));
+ if(floodcount >= count) return 1; //blocked!
+ //add a new floodnode :)
+ if(free_MemberFlood) {
+ floodnode = free_MemberFlood;
+ free_MemberFlood = floodnode->next_memberflood;
+ } else
+ floodnode = (struct MemberFlood*) MyMalloc(sizeof(struct MemberFlood));
+ memset(floodnode, 0, sizeof(struct MemberFlood));
+ floodnode->time = CurrentTime;
+ floodnode->next_memberflood = NULL;
+ if(floodcount > 0)
+ prev_floodnode->next_memberflood = floodnode;
+ else
+ member->flood = floodnode;
+ return 0;
+}
+
projects / ircu2.10.12-pk.git / commitdiff