void check_ctcp_ban_flood(char *channel, char *nick) { NickList *Nick = NULL; ChannelList *chan = NULL; for (chan = get_server_channels(from_server); chan; chan = chan->next) if ((Nick = find_nicklist_in_channellist(nick, chan, 0))) break; if (chan && chan->have_op && get_cset_int_var(chan->csets, CTCP_FLOOD_BAN_CSET) && Nick) { if (!Nick->userlist || (Nick->userlist && !(Nick->userlist->flags & ADD_FLOOD))) { if (!nick_isop(Nick) || get_cset_int_var(chan->csets, KICK_OPS_CSET)) { char *ban, *u, *h; u = alloca(strlen(Nick->host)+1); strcpy(u, Nick->host); h = strchr(u, '@'); *h++ = 0; ban = ban_it(Nick->nick, u, h, Nick->ip); if (!ban_is_on_channel(ban, chan) && !eban_is_on_channel(ban, chan)) send_to_server("MODE %s +b %s", chan->channel, ban); } } } }
char *get_cset(char *var, ChannelList *chan, char *value) { int var_index, cnt = 0; var_index = find_cset_variable(cset_array, var, &cnt); if (cnt == 1) { char s[81]; CSetArray *var; var = &(cset_array[var_index]); *s = 0; switch (var->type) { case BOOL_TYPE_VAR: { strcpy(s, get_cset_int_var(chan->csets, var_index)?var_settings[ON] : var_settings[OFF]); if (value) { int val = -1; if (!my_stricmp(value, on)) val = 1; else if (!my_stricmp(value, off)) val = 0; else { if (isdigit((unsigned char)*value)) val = (int)(*value - '0'); } if (val != -1) set_cset_int_var(chan->csets, var_index, val); } break; } case INT_TYPE_VAR: { strncpy(s, ltoa(get_cset_int_var(chan->csets, var_index)), 30); if (value && isdigit((unsigned char)*value)) set_cset_int_var(chan->csets, var_index, my_atol(value)); break; } case STR_TYPE_VAR: { char *t; t = m_strdup(get_cset_str_var(chan->csets, var_index)); if (value) set_cset_str_var(chan->csets, var_index, value); return t; } } return m_strdup(s && *s ? s : empty_string); } return m_strdup(empty_string); }
void get_flood_val(ChannelList *chan, int type, int *flood_count, int *flood_rate) { *flood_count = get_int_var(FLOOD_AFTER_VAR); *flood_rate = get_int_var(FLOOD_RATE_VAR); if (chan) { switch(type) { case JOIN_FLOOD: *flood_count = get_cset_int_var(chan->csets, KICK_ON_JOINFLOOD_CSET); *flood_rate = get_cset_int_var(chan->csets, JOINFLOOD_TIME_CSET); break; case PUBLIC_FLOOD: *flood_count = get_cset_int_var(chan->csets, KICK_ON_PUBFLOOD_CSET); *flood_rate = get_cset_int_var(chan->csets, PUBFLOOD_TIME_CSET); break; case NICK_FLOOD: *flood_count = get_cset_int_var(chan->csets, KICK_ON_NICKFLOOD_CSET); *flood_rate = get_cset_int_var(chan->csets, NICKFLOOD_TIME_CSET); break; case KICK_FLOOD: *flood_count = get_cset_int_var(chan->csets, KICK_ON_KICKFLOOD_CSET); *flood_rate = get_cset_int_var(chan->csets, KICKFLOOD_TIME_CSET); break; case DEOP_FLOOD: *flood_count = get_cset_int_var(chan->csets, KICK_ON_DEOPFLOOD_CSET); *flood_rate = get_cset_int_var(chan->csets, DEOPFLOOD_TIME_CSET); break; default: break; } } else { switch(type) { case CDCC_FLOOD: *flood_count = get_int_var(CDCC_FLOOD_AFTER_VAR); *flood_rate = get_int_var(CDCC_FLOOD_RATE_VAR); break; case CTCP_FLOOD: *flood_count = get_int_var(CTCP_FLOOD_AFTER_VAR); *flood_rate = get_int_var(CTCP_FLOOD_RATE_VAR); case CTCP_ACTION_FLOOD: default: break; } } }
int get_flood_rate(int type, ChannelList * channel) { int flood_rate = get_int_var(FLOOD_RATE_VAR); if (channel) { switch(type) { case JOIN_FLOOD: flood_rate = get_cset_int_var(channel->csets, JOINFLOOD_TIME_CSET); break; case PUBLIC_FLOOD: flood_rate = get_cset_int_var(channel->csets, PUBFLOOD_TIME_CSET); break; case NICK_FLOOD: flood_rate = get_cset_int_var(channel->csets, NICKFLOOD_TIME_CSET); break; case KICK_FLOOD: flood_rate = get_cset_int_var(channel->csets, KICKFLOOD_TIME_CSET); break; case DEOP_FLOOD: flood_rate = get_cset_int_var(channel->csets, DEOPFLOOD_TIME_CSET); break; default: break; } } else { switch(type) { case CDCC_FLOOD: flood_rate = get_int_var(CDCC_FLOOD_RATE_VAR); break; case CTCP_FLOOD: flood_rate = get_int_var(CTCP_FLOOD_RATE_VAR); case CTCP_ACTION_FLOOD: default: break; } } return flood_rate; }
int get_flood_count(int type, ChannelList * channel) { int flood_count = get_int_var(FLOOD_AFTER_VAR); if (channel) { switch(type) { case JOIN_FLOOD: flood_count = get_cset_int_var(channel->csets, KICK_ON_JOINFLOOD_CSET); break; case PUBLIC_FLOOD: flood_count = get_cset_int_var(channel->csets, KICK_ON_PUBFLOOD_CSET); break; case NICK_FLOOD: flood_count = get_cset_int_var(channel->csets, KICK_ON_NICKFLOOD_CSET); break; case KICK_FLOOD: flood_count = get_cset_int_var(channel->csets, KICK_ON_KICKFLOOD_CSET); break; case DEOP_FLOOD: flood_count = get_cset_int_var(channel->csets, KICK_ON_DEOPFLOOD_CSET); break; default: break; } } else { switch(type) { case CDCC_FLOOD: flood_count = get_int_var(CDCC_FLOOD_AFTER_VAR); break; case CTCP_FLOOD: flood_count = get_int_var(CTCP_FLOOD_AFTER_VAR); case CTCP_ACTION_FLOOD: default: break; } } return flood_count; }
void do_logchannel(unsigned long level, ChannelList *chan, char *format, ...) { if (!chan || !get_cset_int_var(chan->csets, CHANNEL_LOG_CSET)) return; if ((chan->log_level & level) && format) { char s[BIG_BUFFER_SIZE+1]; va_list args; va_start(args, format); vsnprintf(s, BIG_BUFFER_SIZE, format, args); va_end(args); add_to_log(chan->msglog_fp, now, s, logfile_line_mangler); } }
void check_hack(char *nick, ChannelList *channel, NickList *ThisNick, char *from) { #ifdef WANT_USERLIST UserList *userptr = NULL; ShitList *shitptr = NULL; #endif WhowasList *check_op = NULL; int flag; if (from && *from && !strchr(from, '.')) return; if (!channel || !are_you_opped(channel->channel) || !nick || !ThisNick || wild_match(nick, get_server_nickname(from_server))) return; if (!(flag = get_cset_int_var(channel->csets, HACKING_CSET))) return; if ((ThisNick->sent_deop) && (now - ThisNick->sent_deop_time < 10)) return; #ifdef WANT_USERLIST userptr = ThisNick->userlist; shitptr = ThisNick->shitlist; #endif check_op = check_whosplitin_buffer(nick, ThisNick->host, channel->channel, 0); if (check_op && check_op->has_ops) return; #ifdef WANT_USERLIST if ( !userptr || (userptr && !check_channel_match(userptr->channels, channel->channel)) || (shitptr && check_channel_match(shitptr->channels, channel->channel))) #endif { switch(flag) { case 1: case 3: if (is_chanop(channel->channel, nick)) add_mode(channel, "o", 0, nick, NULL, get_int_var(NUM_OPMODES_VAR)); ThisNick->sent_deop++; ThisNick->sent_deop_time = now; case 2: if (flag != 1) bitchsay("NetHack detected on %s by %s!%s", channel->channel, nick, ThisNick->host); case 0: default: break; } } }
void check_shit(ChannelList *chan) { ShitList *Bans; if (!chan || !chan->chop || !shitlist_list || chan->server <= -1 || !get_cset_int_var(chan->csets, SHITLIST_CSET)) return; if (!check_channel_match(get_string_var(PROTECT_CHANNELS_VAR), chan->channel)) return; for (Bans = shitlist_list; Bans; Bans = Bans->next) { /* this is a permanent ban */ if (!check_channel_match(Bans->channels, chan->channel)) continue; if ((Bans->level == 4) && !ban_is_on_channel(Bans->filter, chan) && !eban_is_on_channel(Bans->filter, chan)) add_mode(chan, "b", 1, Bans->filter, NULL, get_int_var(NUM_BANMODES_VAR)); } flush_mode_all(chan); }
void check_auto_invite(char *nick, char *userhost) { #ifdef WANT_USERLIST ChannelList *chan = NULL; UserList *tmp = NULL; for (chan = get_server_channels(from_server); chan; chan = chan->next) { if ((tmp = lookup_userlevelc("*", userhost, chan->channel, NULL))) { NickList *n = NULL; n = find_nicklist_in_channellist(nick, chan, 0); if (!n && chan->have_op && get_cset_int_var(chan->csets, AINV_CSET) && (tmp->flags & ADD_INVITE) && get_cset_int_var(chan->csets, AINV_CSET)) { bitchsay("Auto-inviting %s to %s", nick, chan->channel); send_to_server("NOTICE %s :Auto-invite from %s", nick, get_server_nickname(from_server)); send_to_server("INVITE %s %s%s%s", nick, chan->channel, chan->key?space:empty_string, chan->key?chan->key:empty_string); } } tmp = NULL; } #endif }
int BX_flood_prot (char *nick, char *userhost, char *type, int ctcp_type, int ignoretime, char *channel) { ChannelList *chan; NickList *Nick; char tmp[BIG_BUFFER_SIZE+1]; char *uh; int old_window_display; int kick_on_flood = 1; if ((ctcp_type == CDCC_FLOOD || ctcp_type == CTCP_FLOOD || ctcp_type == CTCP_ACTION_FLOOD) && !get_int_var(CTCP_FLOOD_PROTECTION_VAR)) return 0; else if (!get_int_var(FLOOD_PROTECTION_VAR)) return 0; else if (!my_stricmp(nick, get_server_nickname(from_server))) return 0; switch (ctcp_type) { case WALL_FLOOD: case MSG_FLOOD: break; case NOTICE_FLOOD: break; case PUBLIC_FLOOD: if (channel) { if ((chan = lookup_channel(channel, from_server, 0))) { kick_on_flood = get_cset_int_var(chan->csets, PUBFLOOD_CSET); if (kick_on_flood && (Nick = find_nicklist_in_channellist(nick, chan, 0))) { if (chan->have_op && (!Nick->userlist || (Nick->userlist && !(Nick->userlist->flags & ADD_FLOOD)))) if (!nick_isop(Nick) || get_cset_int_var(chan->csets, KICK_OPS_CSET)) send_to_server("KICK %s %s :\002%s\002 flooder", chan->channel, nick, type); } } } break; case CTCP_FLOOD: case CTCP_ACTION_FLOOD: check_ctcp_ban_flood(channel, nick); default: if (get_int_var(FLOOD_KICK_VAR) && kick_on_flood && channel) { for (chan = get_server_channels(from_server); chan; chan = chan->next) { if (chan->have_op && (Nick = find_nicklist_in_channellist(nick, chan, 0))) { if ((!Nick->userlist || (Nick->userlist && !(Nick->userlist->flags & ADD_FLOOD)))) if (!nick_isop(Nick) || get_cset_int_var(chan->csets, KICK_OPS_CSET)) send_to_server("KICK %s %s :\002%s\002 flooder", chan->channel, nick, type); } } } } if (!ignoretime) return 0; uh = clear_server_flags(userhost); sprintf(tmp, "*!*%s", uh); old_window_display = window_display; window_display = 0; ignore_nickname(tmp, ignore_type(type, strlen(type)), 0); window_display = old_window_display; sprintf(tmp, "%d ^IGNORE *!*%s NONE", ignoretime, uh); timercmd("TIMER", tmp, NULL, NULL); bitchsay("Auto-ignoring %s for %d minutes [\002%s\002 flood]", nick, ignoretime/60, type); return 1; }
int BX_is_other_flood(ChannelList *channel, NickList *tmpnick, int type, int *t_flood) { time_t diff = 0, flood_time = 0; int doit = 0; int count = 0; int flood_rate = 0, flood_count = 0; flood_time = now; if (!channel || !tmpnick) return 0; if (isme(tmpnick->nick)) return 0; if (find_name_in_genericlist(tmpnick->nick, no_flood_list, FLOOD_HASHSIZE, 0)) return 0; set_flood(type, flood_time, NO_RESET, tmpnick); switch(type) { case JOIN_FLOOD: if (!get_cset_int_var(channel->csets, JOINFLOOD_CSET)) break; diff = flood_time - tmpnick->jointime; count = tmpnick->joincount; doit = 1; break; case PUBLIC_FLOOD: if (!get_cset_int_var(channel->csets, PUBFLOOD_CSET)) break; diff = flood_time - tmpnick->floodtime; count = tmpnick->floodcount; doit = 1; break; case NICK_FLOOD: if (!get_cset_int_var(channel->csets, NICKFLOOD_CSET)) break; diff = flood_time - tmpnick->nicktime; count = tmpnick->nickcount; doit = 1; break; case DEOP_FLOOD: if (!get_cset_int_var(channel->csets, DEOPFLOOD_CSET)) break; diff = flood_time - tmpnick->doptime; count = tmpnick->dopcount; doit = 1; break; case KICK_FLOOD: if (!get_cset_int_var(channel->csets, KICKFLOOD_CSET)) break; diff = flood_time - tmpnick->kicktime; count = tmpnick->kickcount; doit = 1; break; default: return 0; break; } if (doit) { int is_user = 0; if (!get_int_var(FLOOD_PROTECTION_VAR)) return 0; get_flood_val(channel, type, &flood_count, &flood_rate); if ((tmpnick->userlist && (tmpnick->userlist->flags & ADD_FLOOD))) is_user = 1; if (!is_user && (count >= flood_count)) { int flooded = 0; if (count >= flood_count) { if (!diff || (flood_rate && (diff < flood_rate))) { *t_flood = diff; flooded = 1; do_hook(FLOOD_LIST, "%s %s %s %s", tmpnick->nick, get_flood_types(type),channel?channel->channel:zero, tmpnick->host); } set_flood(type, flood_time, RESET, tmpnick); return flooded; } else if (diff > flood_rate) set_flood(type, flood_time, RESET, tmpnick); } } return 0; }
static void set_cset_var_value(CSetList *tmp, int var_index, char *value) { char *rest; CSetArray *var; var = &(cset_array[var_index]); switch (var->type) { case BOOL_TYPE_VAR: if (value && *value && (value = next_arg(value, &rest))) { if (do_boolean(value, (int *)get_cset_int_var_address(tmp, var_index))) { say("Value must be either ON, OFF, or TOGGLE"); break; } if (var->func) var->func(var, tmp); put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF])); } else put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF])); break; case INT_TYPE_VAR: if (value && *value && (value = next_arg(value, &rest))) { int val; if (!is_number(value)) { say("Value of %s must be numeric!", var->name); break; } if ((val = atoi(value)) < 0) { say("Value of %s must be greater than 0", var->name); break; } set_cset_int_var(tmp, var_index, val); if (var->func) var->func(var, tmp); put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index))); } else put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index))); break; case STR_TYPE_VAR: if (value && *value) { set_cset_str_var(tmp, var_index, value); if (var->func) var->func(var, tmp); put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_str_var(tmp, var_index) )); } else put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, (char *)get_cset_str_var(tmp, var_index))); } }
/* * Protection levels * 1 Reop if de-oped * 2 De-op offender * 3 Kick offender * 4 KickBan offender */ int check_prot(char *from, char *person, ChannelList *chan, BanList *thisban, NickList *n) { NickList *tmp = NULL; NickList *kicker; char *tmp_ban = NULL; char *nick = NULL, *userhost = NULL, *p; if (!from || !*from || !person || !*person || !chan) return 0; if (!my_stricmp(person, from)) return 0; tmp_ban = LOCAL_COPY(person); if ((p = strchr(tmp_ban, '!'))) { nick = tmp_ban; *p++ = 0; userhost = p; } else nick = person; if (!n) { if (!(tmp = find_nicklist_in_channellist(person, chan, 0))) { for (tmp = next_nicklist(chan, NULL); tmp; tmp = next_nicklist(chan, tmp)) { if (wild_match(nick, tmp->nick) && wild_match(userhost, tmp->host) && tmp->userlist) { n = tmp; break; } } } } if (get_cset_int_var(chan->csets, USERLIST_CSET) && chan->chop && ((n && n->userlist) || (tmp && tmp->userlist))) { UserList *user = NULL; time_t current = now; if (n) user = n->userlist; else user = tmp->userlist; if (!user || (user && !check_channel_match(user->channels, chan->channel))) return 0; if (!(kicker = find_nicklist_in_channellist(from, chan, 0))) return 0; if ((user->flags & (PROT_DEOP | PROT_INVITE | PROT_BAN | PROT_KICK | PROT_REOP))) { int do_reop = 0; if (user->flags & PROT_DEOP) { if (!kicker->sent_deop) { if (!kicker->userlist || (kicker->userlist && !(kicker->userlist->flags & PROT_DEOP))) send_to_server("MODE %s -o %s", chan->channel, from); kicker->sent_deop++; } do_reop = 1; } if (user->flags & PROT_INVITE) { if (thisban && !thisban->sent_unban) { thisban->sent_unban++; thisban->sent_unban_time = current; send_to_server("MODE %s -b %s", chan->channel, thisban->ban); send_to_server("INVITE %s %s", n?n->nick:tmp->nick, chan->channel); } } if (user->flags & PROT_BAN) { /* do_reop = 1; */ if (kicker->userlist) send_to_server("MODE %s -o %s", chan->channel, from); else { char *h, *u; u = LOCAL_COPY(kicker->host); h = strchr(u, '@'); *h++ = 0; send_to_server("MODE %s -o+b %s %s", chan->channel, kicker->nick, ban_it(kicker->nick, u, h, kicker->ip)); if (get_int_var(AUTO_UNBAN_VAR)) add_timer(0, empty_string, get_int_var(AUTO_UNBAN_VAR) * 1000, 1, timer_unban, m_sprintf("%d %s %s", from_server, chan->channel, ban_it(kicker->nick, u, h, kicker->ip)), NULL, -1, "auto-unban"); } } if (user->flags & PROT_KICK) { if (kicker && (!kicker->userlist || (kicker->userlist && !(kicker->userlist->flags & PROT_KICK)))) send_to_server("KICK %s %s :\002BitchX\002 Protected User", chan->channel, kicker->nick); } if ((user->flags & PROT_REOP) || do_reop) { /* added by Sergs [email protected] */ if (thisban) { if (thisban->sent_unban_time - current > 30) { thisban->sent_unban++; thisban->sent_unban_time = current; send_to_server("MODE %s -b %s", chan->channel, thisban->ban); } else if (thisban->sent_unban < 3) { thisban->sent_unban++; thisban->sent_unban_time = current; send_to_server("MODE %s -b %s", chan->channel, thisban->ban); } } if (n && (!n->sent_reop || (n->sent_reop_time && (current - n->sent_reop_time > 60)))) { char *u = NULL; malloc_sprintf(&u, "%s %s %s %s %d", chan->channel, n->nick, n->host, "o", from_server); add_timer(0, empty_string, 10 * 1000, 1, delay_opz, u, NULL, -1, "delay-ops"); n->sent_reop++; n->sent_reop_time = current; } } } if ((user->flags & USER_FLAG_PROT) && (p = get_string_var(USER_FLAG_PROT_VAR))) run_user_flag("USER_FLAG_PROT", p, n, kicker); return 1; } return 0; }
NickList *check_auto(char *channel, NickList *nicklist, ChannelList *chan) { ShitList *shitptr = NULL; UserList *userptr = NULL; ChannelList *chan_ptr = NULL; char *ban; if (!channel || !*channel || !nicklist) return NULL; if (!chan) { ChannelList *chan2; chan2 = get_server_channels(from_server); chan_ptr = (ChannelList *) find_in_list((List **)&chan2, channel, 0); } else chan_ptr = chan; if (!chan_ptr) return NULL; if (!chan_ptr->chop) return nicklist; userptr = nicklist->userlist; shitptr = nicklist->shitlist; if (userptr && !check_channel_match(userptr->channels, channel)) userptr = NULL; if (shitptr && (!check_channel_match(shitptr->channels, channel) || isme(nicklist->nick))) shitptr = NULL; if (get_cset_int_var(chan_ptr->csets, SHITLIST_CSET) && shitptr != NULL && userptr == NULL) { char *theshit; time_t current = now; theshit = get_string_var(SHITLIST_REASON_VAR); switch(shitptr->level) { case 0: return nicklist; break; case 1:/* never give opz */ if (nicklist->sent_deop < 4 && nick_isop(nicklist)) { add_mode(chan_ptr, "o", 0, nicklist->nick, NULL, get_int_var(NUM_OPMODES_VAR)); nicklist->sent_deop++; nicklist->sent_deop_time = current; } break; case 2: /* Auto Kick offender */ add_mode(chan_ptr, NULL, 0, nicklist->nick, shitptr->reason?shitptr->reason:theshit, 0); break; case 3: /* kick ban the offender */ case 4: /* perm ban on offender */ if (nicklist->sent_deop < 4 || (nicklist->sent_deop < 4 && shitptr->level == 4)) { send_to_server("MODE %s -o+b %s %s", channel, nicklist->nick, shitptr->filter); nicklist->sent_deop++; nicklist->sent_deop_time = current; if (get_int_var(AUTO_UNBAN_VAR) && shitptr->level != 4) add_timer(0, empty_string, get_int_var(AUTO_UNBAN_VAR) * 1000, 1, timer_unban, m_sprintf("%d %s %s", from_server, channel, shitptr->filter), NULL, -1, "auto-unban"); } if (get_cset_int_var(chan_ptr->csets, KICK_IF_BANNED_CSET)) send_to_server("KICK %s %s :%s", channel, nicklist->nick, (shitptr->reason && *shitptr->reason) ? shitptr->reason : theshit); default: break; } return nicklist; } if (userptr && get_cset_int_var(chan_ptr->csets, USERLIST_CSET)) { char *buffer = NULL; time_t current = now; int done = 0; char *p = NULL; if (get_cset_int_var(chan_ptr->csets, AOP_CSET)) { if ((userptr->flags & ADD_OPS)) { done++; if (!userptr->password && !nicklist->sent_reop && !nick_isop(nicklist)) { nicklist->sent_reop++; nicklist->sent_reop_time = current; if (!(userptr->flags & ADD_IOPS)) { malloc_sprintf(&buffer, "%s %s %s %s %d", channel, nicklist->nick, nicklist->host, "o", from_server); add_timer(0, empty_string, 10 * 1000, 1, delay_opz, buffer, NULL, -1, "delay-ops"); } else send_to_server("MODE %s +o %s", chan_ptr->channel, nicklist->nick); } } else if ((userptr->flags & ADD_VOICE)) { done++; if (!nicklist->sent_voice && !nick_isvoice(nicklist)) { nicklist->sent_voice++; nicklist->sent_voice_time = current; if (!(userptr->flags & ADD_IOPS)) { malloc_sprintf(&buffer, "%s %s %s %s %d", channel, nicklist->nick, nicklist->host, "v", from_server); add_timer(0, empty_string, 10 * 1000, 1, delay_opz, buffer, NULL, -1, "delay-ops"); } else send_to_server("MODE %s +v %s", chan_ptr->channel, nicklist->nick); } } } if ((userptr->flags & USER_FLAG_OPS) && (p = get_string_var(USER_FLAG_OPS_VAR))) { done++; run_user_flag("USER_FLAG_OPS", p, nicklist, NULL); } if (done) return nicklist; } if (get_cset_int_var(chan_ptr->csets, KICK_IF_BANNED_CSET) && check_channel_match(get_string_var(PROTECT_CHANNELS_VAR), chan_ptr->channel)) { char *ipban = NULL; char *u = NULL; if (!nicklist->host) return nicklist; ban = m_3dup(nicklist->nick, "!", nicklist->host); if (nicklist->ip && nicklist->host) { char *user = alloca(strlen(nicklist->host)+1); strcpy(user, nicklist->host); if ((u = strchr(user, '@'))) *u = 0; ipban = m_opendup(nicklist->nick, "!", user, "@", nicklist->ip, NULL); } if (!isme(nicklist->nick) && (!eban_is_on_channel(ban, chan_ptr) && (ban_is_on_channel(ban, chan_ptr) || (ipban && ban_is_on_channel(ipban, chan_ptr)))) ) { new_free(&ban); new_free(&ipban); if (nick_isop(nicklist) && !get_cset_int_var(chan_ptr->csets, KICK_OPS_CSET)) return nicklist; my_send_to_server(from_server, "KICK %s %s :Banned", chan_ptr->channel, nicklist->nick); } new_free(&ban); new_free(&ipban); } return nicklist; }