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;
}
