void show_channels(int idx, char *handle)
{
struct userrec *u = NULL;
size_t maxChannelLength = 0;
bd::Array<bd::String> channelNames;
bd::HashTable<bd::String, struct chanset_t*> channels;
bd::String group;
if (handle && handle[0] != '%') {
u = get_user_by_handle(userlist, handle);
} else {
u = dcc[idx].user;
if (handle && handle[0] == '%') {
group = handle + 1;
}
}
for (struct chanset_t* chan = chanset; chan; chan = chan->next) {
struct flag_record fr = { FR_CHAN | FR_GLOBAL, 0, 0, 0 };
const bd::String chname(chan->dname);
// If a group was passed, ensure it matches
if (group.length() && chan->groups->find(group) == chan->groups->npos) {
continue;
}
get_user_flagrec(u, &fr, chan->dname);
if (group.length() || real_chk_op(fr, chan, 0)) {
if (maxChannelLength < chname.length()) {
maxChannelLength = chname.length();
}
channelNames << chname;
channels[chname] = chan;
}
}
if (channelNames.length()) {
char format[120] = "";
simple_snprintf(format, sizeof(format), " %%c%%-%zus %%-s%%-s%%-s%%-s%%-s%%-s\n", (maxChannelLength+2));
if (group.length()) {
dprintf(idx, "group '%s' is in %zu channel%s:\n", group.c_str(), channelNames.length(), (channelNames.length() > 1) ? "s" : "");
} else {
dprintf(idx, "%s %s access to %zu channel%s:\n", handle ? u->handle : "You", handle ? "has" : "have", channelNames.length(), (channelNames.length() > 1) ? "s" : "");
}
for (size_t i = 0; i < channelNames.length(); ++i) {
const bd::String chname(channelNames[i]);
const struct chanset_t* chan = channels[chname];
dprintf(idx, format, !conf.bot->hub && me_op(chan) ? '@' : ' ', chan->dname, ((conf.bot->hub && channel_inactive(chan)) || (!conf.bot->hub && !shouldjoin(chan))) ? "(inactive) " : "",
channel_privchan(chan) ? "(private) " : "", chan->manop ? "(no manop) " : "",
channel_bitch(chan) && !channel_botbitch(chan) ? "(bitch) " : channel_botbitch(chan) ? "(botbitch) " : "",
channel_closed(chan) ? "(closed) " : "", channel_backup(chan) ? "(backup)" : "");
}
} else {
if (group.length()) {
dprintf(idx, "No channels found for group '%s'\n", group.c_str());
} else {
dprintf(idx, "%s %s not have access to any channels.\n", handle ? u->handle : "You", handle ? "does" : "do");
}
}
}
struct chanset_t* find_common_opped_chan(bd::String nick) {
for (struct chanset_t* chan = chanset; chan; chan = chan->next) {
if (channel_active(chan) && (me_op(chan) || me_voice(chan))) {
if (ismember(chan, nick.c_str()))
return chan;
}
}
return NULL;
}
static void got_unexempt(struct chanset_t *chan, char *nick, char *from,
char *who, char *ch, struct userrec *u)
{
masklist *e = chan->channel.exempt, *old = NULL;
masklist *b;
int match = 0;
while (e && e->mask[0] && rfc_casecmp(e->mask, who)) {
old = e;
e = e->next;
}
if (e && e->mask[0]) {
if (old)
old->next = e->next;
else
chan->channel.exempt = e->next;
nfree(e->mask);
nfree(e->who);
nfree(e);
}
check_tcl_mode(nick, from, u, chan->dname, "-e", who);
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return;
if (channel_pending(chan))
return;
if (u_sticky_mask(chan->exempts, who) || u_sticky_mask(global_exempts, who))
add_mode(chan, '+', 'e', who);
/* If exempt was removed by master then leave it else check for bans */
if (!nick[0] && glob_bot(user) && !glob_master(user) && !chan_master(user)) {
b = chan->channel.ban;
while (b->mask[0] && !match) {
if (mask_match(b->mask, who)) {
add_mode(chan, '+', 'e', who);
match = 1;
} else
b = b->next;
}
}
if ((u_equals_mask(global_exempts, who) ||
u_equals_mask(chan->exempts, who)) && me_op(chan) &&
!channel_dynamicexempts(chan) && (!glob_bot(user) ||
!(bot_flags(u) & BOT_SHARE)))
add_mode(chan, '+', 'e', who);
}
/* Report the channel status of every active channel to dcc chat every
* 5 minutes.
*/
static void status_log()
{
masklist *b;
memberlist *m;
struct chanset_t *chan;
char s[20], s2[20];
int chops, halfops, voice, nonops, bans, invites, exempts;
if (!server_online)
return;
for (chan = chanset; chan != NULL; chan = chan->next) {
if (channel_active(chan) && channel_logstatus(chan) &&
!channel_inactive(chan)) {
chops = 0;
voice = 0;
halfops = 0;
for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
if (chan_hasop(m))
chops++;
else if (chan_hashalfop(m))
halfops++;
else if (chan_hasvoice(m))
voice++;
}
nonops = (chan->channel.members - (chops + voice + halfops));
for (bans = 0, b = chan->channel.ban; b->mask[0]; b = b->next)
bans++;
for (exempts = 0, b = chan->channel.exempt; b->mask[0]; b = b->next)
exempts++;
for (invites = 0, b = chan->channel.invite; b->mask[0]; b = b->next)
invites++;
sprintf(s, "%d", exempts);
sprintf(s2, "%d", invites);
putlog(LOG_MISC, chan->dname,
"%s%s (%s) : [m/%d o/%d h/%d v/%d n/%d b/%d e/%s I/%s]",
me_op(chan) ? "@" : me_voice(chan) ? "+" :
me_halfop(chan) ? "%" : "", chan->dname, getchanmode(chan),
chan->channel.members, chops, halfops, voice, nonops, bans,
use_exempts ? s : "-", use_invites ? s2 : "-");
}
}
}
static void irc_report(int idx, int details)
{
struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
char ch[1024], q[256], *p;
int k, l;
struct chanset_t *chan;
strcpy(q, "Channels: ");
k = 10;
for (chan = chanset; chan; chan = chan->next) {
if (idx != DP_STDOUT)
get_user_flagrec(dcc[idx].user, &fr, chan->dname);
if ((idx == DP_STDOUT) || glob_master(fr) || chan_master(fr)) {
p = NULL;
if (!channel_inactive(chan)) {
if (chan->status & CHAN_JUPED)
p = MISC_JUPED;
else if (!(chan->status & CHAN_ACTIVE))
p = MISC_TRYING;
else if (chan->status & CHAN_PEND)
p = MISC_PENDING;
else if ((chan->dname[0] != '+') && !me_op(chan))
p = MISC_WANTOPS;
}
l = simple_sprintf(ch, "%s%s%s%s, ", chan->dname, p ? " (" : "",
p ? p : "", p ? ")" : "");
if ((k + l) > 70) {
dprintf(idx, " %s\n", q);
strcpy(q, " ");
k = 10;
}
k += my_strcpy(q + k, ch);
}
}
if (k > 10) {
q[k - 2] = 0;
dprintf(idx, " %s\n", q);
}
}
static void got_uninvite(struct chanset_t *chan, char *nick, char *from,
char *who, char *ch, struct userrec *u)
{
masklist *inv = chan->channel.invite, *old = NULL;
while (inv->mask[0] && rfc_casecmp(inv->mask, who)) {
old = inv;
inv = inv->next;
}
if (inv->mask[0]) {
if (old)
old->next = inv->next;
else
chan->channel.invite = inv->next;
nfree(inv->mask);
nfree(inv->who);
nfree(inv);
}
check_tcl_mode(nick, from, u, chan->dname, "-I", who);
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return;
if (channel_pending(chan))
return;
if (u_sticky_mask(chan->invites, who) || u_sticky_mask(global_invites, who))
add_mode(chan, '+', 'I', who);
if (!nick[0] && glob_bot(user) && !glob_master(user) && !chan_master(user) &&
(chan->channel.mode & CHANINV))
add_mode(chan, '+', 'I', who);
if ((u_equals_mask(global_invites, who) ||
u_equals_mask(chan->invites, who)) && me_op(chan) &&
!channel_dynamicinvites(chan) && (!glob_bot(user) ||
!(bot_flags(u) & BOT_SHARE)))
add_mode(chan, '+', 'I', who);
}
static void check_expired_chanstuff()
{
masklist *b, *e;
memberlist *m, *n;
char *key, s[UHOSTLEN];
struct chanset_t *chan;
struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
if (!server_online)
return;
for (chan = chanset; chan; chan = chan->next) {
if (channel_active(chan)) {
if (me_op(chan) || me_halfop(chan)) {
if (channel_dynamicbans(chan) && chan->ban_time)
for (b = chan->channel.ban; b->mask[0]; b = b->next)
if (now - b->timer > 60 * chan->ban_time &&
!u_sticky_mask(chan->bans, b->mask) &&
!u_sticky_mask(global_bans, b->mask) &&
expired_mask(chan, b->who)) {
putlog(LOG_MODES, chan->dname,
"(%s) Channel ban on %s expired.", chan->dname, b->mask);
add_mode(chan, '-', 'b', b->mask);
b->timer = now;
}
if (use_exempts && channel_dynamicexempts(chan) && chan->exempt_time)
for (e = chan->channel.exempt; e->mask[0]; e = e->next)
if (now - e->timer > 60 * chan->exempt_time &&
!u_sticky_mask(chan->exempts, e->mask) &&
!u_sticky_mask(global_exempts, e->mask) &&
expired_mask(chan, e->who)) {
/* Check to see if it matches a ban */
int match = 0;
for (b = chan->channel.ban; b->mask[0]; b = b->next)
if (mask_match(b->mask, e->mask)) {
match = 1;
break;
}
/* Leave this extra logging in for now. Can be removed later
* Jason
*/
if (match) {
putlog(LOG_MODES, chan->dname,
"(%s) Channel exemption %s NOT expired. Exempt still set!",
chan->dname, e->mask);
} else {
putlog(LOG_MODES, chan->dname,
"(%s) Channel exemption on %s expired.",
chan->dname, e->mask);
add_mode(chan, '-', 'e', e->mask);
}
e->timer = now;
}
if (use_invites && channel_dynamicinvites(chan) &&
chan->invite_time && !(chan->channel.mode & CHANINV))
for (b = chan->channel.invite; b->mask[0]; b = b->next)
if (now - b->timer > 60 * chan->invite_time &&
!u_sticky_mask(chan->invites, b->mask) &&
!u_sticky_mask(global_invites, b->mask) &&
expired_mask(chan, b->who)) {
putlog(LOG_MODES, chan->dname,
"(%s) Channel invitation on %s expired.",
chan->dname, b->mask);
add_mode(chan, '-', 'I', b->mask);
b->timer = now;
}
if (chan->idle_kick)
for (m = chan->channel.member; m && m->nick[0]; m = m->next)
if (now - m->last >= chan->idle_kick * 60 &&
!match_my_nick(m->nick) && !chan_issplit(m)) {
sprintf(s, "%s!%s", m->nick, m->userhost);
get_user_flagrec(m->user ? m->user : get_user_by_host(s),
&fr, chan->dname);
if ((!(glob_bot(fr) || glob_friend(fr) || (glob_op(fr) &&
!chan_deop(fr)) || chan_friend(fr) || chan_op(fr))) &&
(me_op(chan) || (me_halfop(chan) && !chan_hasop(m)))) {
dprintf(DP_SERVER, "KICK %s %s :idle %d min\n", chan->name,
m->nick, chan->idle_kick);
m->flags |= SENTKICK;
}
}
}
for (m = chan->channel.member; m && m->nick[0]; m = n) {
n = m->next;
if (m->split && now - m->split > wait_split) {
sprintf(s, "%s!%s", m->nick, m->userhost);
check_tcl_sign(m->nick, m->userhost,
m->user ? m->user : get_user_by_host(s),
chan->dname, "lost in the netsplit");
putlog(LOG_JOIN, chan->dname,
"%s (%s) got lost in the net-split.", m->nick, m->userhost);
killmember(chan, m->nick);
}
m = n;
}
check_lonely_channel(chan);
} else if (!channel_inactive(chan) && !channel_pending(chan)) {
key = chan->channel.key[0] ? chan->channel.key : chan->key_prot;
if (key[0])
dprintf(DP_SERVER, "JOIN %s %s\n",
chan->name[0] ? chan->name : chan->dname, key);
else
dprintf(DP_SERVER, "JOIN %s\n",
chan->name[0] ? chan->name : chan->dname);
}
}
}
/* If i'm the only person on the channel, and i'm not op'd,
* might as well leave and rejoin. If i'm NOT the only person
* on the channel, but i'm still not op'd, demand ops.
*/
static void check_lonely_channel(struct chanset_t *chan)
{
memberlist *m;
char s[UHOSTLEN];
int i = 0;
if (channel_pending(chan) || !channel_active(chan) || me_op(chan) ||
channel_inactive(chan) || (chan->channel.mode & CHANANON))
return;
/* Count non-split channel members */
for (m = chan->channel.member; m && m->nick[0]; m = m->next)
if (!chan_issplit(m))
i++;
if (i == 1 && channel_cycle(chan) && !channel_stop_cycle(chan)) {
if (chan->name[0] != '+') { /* Its pointless to cycle + chans for ops */
putlog(LOG_MISC, "*", "Trying to cycle %s to regain ops.", chan->dname);
dprintf(DP_MODE, "PART %s\n", chan->name);
/* If it's a !chan, we need to recreate the channel with !!chan <cybah> */
if (chan->key_prot[0])
dprintf(DP_MODE, "JOIN %s%s %s\n", (chan->dname[0] == '!') ? "!" : "",
chan->dname, chan->key_prot);
else
dprintf(DP_MODE, "JOIN %s%s\n", (chan->dname[0] == '!') ? "!" : "",
chan->dname);
chan->status &= ~CHAN_WHINED;
}
} else if (any_ops(chan)) {
chan->status &= ~CHAN_WHINED;
check_tcl_need(chan->dname, "op");
if (chan->need_op[0])
do_tcl("need-op", chan->need_op);
} else {
/* Other people here, but none are ops. If there are other bots make
* them LEAVE!
*/
int ok = 1;
struct userrec *u;
if (!channel_whined(chan)) {
/* + is opless. Complaining about no ops when without special
* help(services), we cant get them - Raist
*/
if (chan->name[0] != '+' && channel_logstatus(chan))
putlog(LOG_MISC, "*", "%s is active but has no ops :(", chan->dname);
chan->status |= CHAN_WHINED;
}
for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
sprintf(s, "%s!%s", m->nick, m->userhost);
u = get_user_by_host(s);
if (!match_my_nick(m->nick) && (!u || !(u->flags & USER_BOT))) {
ok = 0;
break;
}
}
if (ok && channel_cycle(chan)) {
/* ALL bots! make them LEAVE!!! */
for (m = chan->channel.member; m && m->nick[0]; m = m->next)
if (!match_my_nick(m->nick))
dprintf(DP_SERVER, "PRIVMSG %s :go %s\n", m->nick, chan->dname);
} else {
/* Some humans on channel, but still op-less */
check_tcl_need(chan->dname, "op");
if (chan->need_op[0])
do_tcl("need-op", chan->need_op);
}
}
}
/* Dependant on revenge_mode, punish the offender.
*/
static void punish_badguy(struct chanset_t *chan, char *whobad,
struct userrec *u, char *badnick, char *victim,
int mevictim, int type)
{
char reason[1024], ct[81], *kick_msg;
memberlist *m;
struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
m = ismember(chan, badnick);
if (!m)
return;
get_user_flagrec(u, &fr, chan->dname);
/* Get current time into a string */
egg_strftime(ct, 7, "%d %b", localtime(&now));
/* Put together log and kick messages */
reason[0] = 0;
switch (type) {
case REVENGE_KICK:
kick_msg = IRC_KICK_PROTECT;
simple_sprintf(reason, "kicked %s off %s", victim, chan->dname);
break;
case REVENGE_DEOP:
simple_sprintf(reason, "deopped %s on %s", victim, chan->dname);
kick_msg = IRC_DEOP_PROTECT;
break;
default:
kick_msg = "revenge!";
}
putlog(LOG_MISC, chan->dname, "Punishing %s (%s)", badnick, reason);
/* Set the offender +d */
if ((chan->revenge_mode > 0) && !(chan_deop(fr) || glob_deop(fr))) {
char s[UHOSTLEN], s1[UHOSTLEN];
memberlist *mx = NULL;
/* Removing op */
if (chan_op(fr) || (glob_op(fr) && !chan_deop(fr))) {
fr.match = FR_CHAN;
if (chan_op(fr))
fr.chan &= ~USER_OP;
else
fr.chan |= USER_DEOP;
set_user_flagrec(u, &fr, chan->dname);
putlog(LOG_MISC, "*", "No longer opping %s[%s] (%s)", u->handle, whobad,
reason);
}
/* ... or just setting to deop */
else if (u) {
/* In the user list already, cool :) */
fr.match = FR_CHAN;
fr.chan |= USER_DEOP;
set_user_flagrec(u, &fr, chan->dname);
simple_sprintf(s, "(%s) %s", ct, reason);
putlog(LOG_MISC, "*", "Now deopping %s[%s] (%s)", u->handle, whobad, s);
}
/* ... or creating new user and setting that to deop */
else {
strcpy(s1, whobad);
maskaddr(s1, s, chan->ban_type);
strcpy(s1, badnick);
/* If that handle exists use "badX" (where X is an increasing number)
* instead.
*/
while (get_user_by_handle(userlist, s1)) {
if (!strncmp(s1, "bad", 3)) {
int i;
i = atoi(s1 + 3);
simple_sprintf(s1 + 3, "%d", i + 1);
} else
strcpy(s1, "bad1"); /* Start with '1' */
}
userlist = adduser(userlist, s1, s, "-", 0);
fr.match = FR_CHAN;
fr.chan = USER_DEOP;
fr.udef_chan = 0;
u = get_user_by_handle(userlist, s1);
if ((mx = ismember(chan, badnick)))
mx->user = u;
set_user_flagrec(u, &fr, chan->dname);
simple_sprintf(s, "(%s) %s (%s)", ct, reason, whobad);
set_user(&USERENTRY_COMMENT, u, (void *) s);
putlog(LOG_MISC, "*", "Now deopping %s (%s)", whobad, reason);
}
}
/* Always try to deop the offender */
if (!mevictim)
add_mode(chan, '-', 'o', badnick);
/* Ban. Should be done before kicking. */
if (chan->revenge_mode > 2) {
char s[UHOSTLEN], s1[UHOSTLEN];
splitnick(&whobad);
maskaddr(whobad, s1, chan->ban_type);
simple_sprintf(s, "(%s) %s", ct, reason);
u_addban(chan, s1, botnetnick, s, now + (60 * chan->ban_time), 0);
if (!mevictim && HALFOP_CANDOMODE('b')) {
add_mode(chan, '+', 'b', s1);
flush_mode(chan, QUICK);
}
}
/* Kick the offender */
if (!mevictim && (chan->revenge_mode > 1) && (!channel_dontkickops(chan) ||
(!chan_op(fr) && (!glob_op(fr) || chan_deop(fr)))) &&
!chan_sentkick(m) && (me_op(chan) || (me_halfop(chan) &&
!chan_hasop(m) && (strchr(NOHALFOPS_MODES, 'b') == NULL)))) {
dprintf(DP_MODE, "KICK %s %s :%s\n", chan->name, badnick, kick_msg);
m->flags |= SENTKICK;
}
}
static void got_halfop(struct chanset_t *chan, char *nick, char *from,
char *who, struct userrec *opu,
struct flag_record *opper)
{
memberlist *m;
char s[UHOSTLEN];
char ch[sizeof chan->name];
struct userrec *u;
int check_chan = 0;
int snm = chan->stopnethack_mode;
m = ismember(chan, who);
if (!m) {
if (channel_pending(chan))
return;
putlog(LOG_MISC, chan->dname, CHAN_BADCHANMODE, chan->dname, who);
chan->status |= CHAN_PEND;
refresh_who_chan(chan->name);
return;
}
/* Did *I* just get halfopped? */
if (!me_op(chan) && !me_halfop(chan) && match_my_nick(who))
check_chan = 1;
strcpy(ch, chan->name);
simple_sprintf(s, "%s!%s", m->nick, m->userhost);
if (!m->user)
u = get_user_by_host(s);
else
u = m->user;
get_user_flagrec(u, &victim, chan->dname);
/* Flags need to be set correctly right from the beginning now, so that
* add_mode() doesn't get irritated.
*/
m->flags |= CHANHALFOP;
check_tcl_mode(nick, from, opu, chan->dname, "+h", who);
if (!(chan = modebind_refresh(ch, from, opper, s, &victim)) ||
!(m = ismember(chan, who)))
return;
m->flags &= ~SENTHALFOP;
if (channel_pending(chan))
return;
if (nick[0] && HALFOP_CANDOMODE('h') && !match_my_nick(who) &&
!match_my_nick(nick)) {
if (channel_bitch(chan) && !(glob_master(*opper) || glob_bot(*opper)) &&
!chan_master(*opper) && !(glob_halfop(victim) || glob_op(victim) ||
glob_bot(victim)) && !chan_op(victim) && !chan_halfop(victim))
add_mode(chan, '-', 'h', who);
else if ((chan_dehalfop(victim) || (glob_dehalfop(victim) &&
!chan_halfop(victim))) && !glob_master(*opper) &&
!chan_master(*opper))
add_mode(chan, '-', 'h', who);
else if (reversing)
add_mode(chan, '-', 'h', who);
} else if (reversing && HALFOP_CANDOMODE('h') && !match_my_nick(who) &&
!match_my_nick(nick))
add_mode(chan, '-', 'h', who);
if (!nick[0] && HALFOP_CANDOMODE('h') && !match_my_nick(who)) {
if (chan_dehalfop(victim) || (glob_dehalfop(victim) &&
!chan_halfop(victim))) {
m->flags |= FAKEHALFOP;
add_mode(chan, '-', 'h', who);
} else if (snm > 0 && snm < 7 && !((channel_autohalfop(chan) ||
glob_autohalfop(victim) || chan_autohalfop(victim)) &&
(chan_halfop(victim) || (glob_halfop(victim) &&
!chan_dehalfop(victim)))) && !glob_exempt(victim) &&
!chan_exempt(victim)) {
if (snm == 5)
snm = channel_bitch(chan) ? 1 : 3;
if (snm == 6)
snm = channel_bitch(chan) ? 4 : 2;
if (chan_washalfoptest(victim) || glob_washalfoptest(victim) || snm == 2) {
if (!chan_washalfop(m)) {
m->flags |= FAKEHALFOP;
add_mode(chan, '-', 'h', who);
}
} else if (!(chan_halfop(victim) || (glob_halfop(victim) &&
!chan_dehalfop(victim)))) {
if (snm == 1 || snm == 4 || (snm == 3 && !chan_washalfop(m))) {
add_mode(chan, '-', 'h', who);
m->flags |= FAKEHALFOP;
}
} else if (snm == 4 && !chan_washalfop(m)) {
add_mode(chan, '-', 'h', who);
m->flags |= FAKEHALFOP;
}
}
}
m->flags |= WASHALFOP;
if (check_chan)
recheck_channel(chan, 1);
}
/* Queue a channel mode change
*/
static void real_add_mode(struct chanset_t *chan,
char plus, char mode, char *op)
{
int i, type, modes, l;
masklist *m;
memberlist *mx;
char s[21];
/* Some IRCds do not allow halfops to set certain modes. The modes halfops
* are not allowed to set can be changed in chan.h. */
#ifdef NO_HALFOP_CHANMODES
if (!me_op(chan))
#else
if (HALFOP_CANTDOMODE(mode))
#endif
return;
if (mode == 'o' || mode == 'h' || mode == 'v') {
mx = ismember(chan, op);
if (!mx)
return;
if (plus == '-' && mode == 'o') {
if (chan_sentdeop(mx) || !chan_hasop(mx))
return;
mx->flags |= SENTDEOP;
}
if (plus == '+' && mode == 'o') {
if (chan_sentop(mx) || chan_hasop(mx))
return;
mx->flags |= SENTOP;
}
if (plus == '-' && mode == 'h') {
if (chan_sentdehalfop(mx) || !chan_hashalfop(mx))
return;
mx->flags |= SENTDEHALFOP;
}
if (plus == '+' && mode == 'h') {
if (chan_senthalfop(mx) || chan_hashalfop(mx))
return;
mx->flags |= SENTHALFOP;
}
if (plus == '-' && mode == 'v') {
if (chan_sentdevoice(mx) || !chan_hasvoice(mx))
return;
mx->flags |= SENTDEVOICE;
}
if (plus == '+' && mode == 'v') {
if (chan_sentvoice(mx) || chan_hasvoice(mx))
return;
mx->flags |= SENTVOICE;
}
}
if (chan->compat == 0) {
if (mode == 'e' || mode == 'I')
chan->compat = 2;
else
chan->compat = 1;
} else if (mode == 'e' || mode == 'I') {
if (prevent_mixing && chan->compat == 1)
flush_mode(chan, NORMAL);
} else if (prevent_mixing && chan->compat == 2)
flush_mode(chan, NORMAL);
if (mode == 'o' || mode == 'h' || mode == 'b' || mode == 'v' || mode == 'e' ||
mode == 'I') {
type = (plus == '+' ? PLUS : MINUS) | (mode == 'o' ? CHOP : (mode == 'h' ?
CHHOP : (mode == 'b' ? BAN : (mode == 'v' ? VOICE : (mode == 'e' ?
EXEMPT : INVITE)))));
/*
* FIXME: Some networks remove overlapped bans,
* IRCnet does not (poptix/drummer)
*
* Note: On IRCnet ischanXXX() should be used, otherwise isXXXed().
*/
if ((plus == '-' && ((mode == 'b' && !ischanban(chan, op)) ||
(mode == 'e' && !ischanexempt(chan, op)) ||
(mode == 'I' && !ischaninvite(chan, op)))) || (plus == '+' &&
((mode == 'b' && ischanban(chan, op)) ||
(mode == 'e' && ischanexempt(chan, op)) ||
(mode == 'I' && ischaninvite(chan, op)))))
return;
/* If there are already max_bans bans, max_exempts exemptions,
* max_invites invitations or max_modes +b/+e/+I modes on the
* channel, don't try to add one more.
*/
if (plus == '+' && (mode == 'b' || mode == 'e' || mode == 'I')) {
int bans = 0, exempts = 0, invites = 0;
for (m = chan->channel.ban; m && m->mask[0]; m = m->next)
bans++;
if ((mode == 'b') && (bans >= max_bans))
return;
for (m = chan->channel.exempt; m && m->mask[0]; m = m->next)
exempts++;
if ((mode == 'e') && (exempts >= max_exempts))
return;
for (m = chan->channel.invite; m && m->mask[0]; m = m->next)
invites++;
if ((mode == 'I') && (invites >= max_invites))
return;
if (bans + exempts + invites >= max_modes)
return;
}
/* op-type mode change */
for (i = 0; i < modesperline; i++)
if (chan->cmode[i].type == type && chan->cmode[i].op != NULL &&
!rfc_casecmp(chan->cmode[i].op, op))
return; /* Already in there :- duplicate */
l = strlen(op) + 1;
if (chan->bytes + l > mode_buf_len)
flush_mode(chan, NORMAL);
for (i = 0; i < modesperline; i++)
if (chan->cmode[i].type == 0) {
chan->cmode[i].type = type;
chan->cmode[i].op = (char *) channel_malloc(l);
chan->bytes += l; /* Add 1 for safety */
strcpy(chan->cmode[i].op, op);
break;
}
}
/* +k ? store key */
else if (plus == '+' && mode == 'k') {
if (chan->key)
nfree(chan->key);
chan->key = (char *) channel_malloc(strlen(op) + 1);
if (chan->key)
strcpy(chan->key, op);
}
/* -k ? store removed key */
else if (plus == '-' && mode == 'k') {
if (chan->rmkey)
nfree(chan->rmkey);
chan->rmkey = (char *) channel_malloc(strlen(op) + 1);
if (chan->rmkey)
strcpy(chan->rmkey, op);
}
/* +l ? store limit */
else if (plus == '+' && mode == 'l')
chan->limit = atoi(op);
else {
/* Typical mode changes */
if (plus == '+')
strcpy(s, chan->pls);
else
strcpy(s, chan->mns);
if (!strchr(s, mode)) {
if (plus == '+') {
chan->pls[strlen(chan->pls) + 1] = 0;
chan->pls[strlen(chan->pls)] = mode;
} else {
chan->mns[strlen(chan->mns) + 1] = 0;
chan->mns[strlen(chan->mns)] = mode;
}
}
}
modes = modesperline; /* Check for full buffer. */
for (i = 0; i < modesperline; i++)
if (chan->cmode[i].type)
modes--;
if (include_lk && chan->limit)
modes--;
if (include_lk && chan->rmkey)
modes--;
if (include_lk && chan->key)
modes--;
if (modes < 1)
flush_mode(chan, NORMAL); /* Full buffer! Flush modes. */
}
static int gotmode(char *from, char *origmsg)
{
char *nick, *ch, *op, *chg, *msg;
char s[UHOSTLEN], buf[511];
char ms2[3];
int z;
struct userrec *u;
memberlist *m;
struct chanset_t *chan;
strncpy(buf, origmsg, 510);
buf[510] = 0;
msg = buf;
/* Usermode changes? */
if (msg[0] && (strchr(CHANMETA, msg[0]) != NULL)) {
ch = newsplit(&msg);
chg = newsplit(&msg);
reversing = 0;
chan = findchan(ch);
if (!chan) {
putlog(LOG_MISC, "*", CHAN_FORCEJOIN, ch);
dprintf(DP_SERVER, "PART %s\n", ch);
} else if (channel_active(chan) || channel_pending(chan)) {
z = strlen(msg);
if (msg[--z] == ' ') /* I hate cosmetic bugs :P -poptix */
msg[z] = 0;
putlog(LOG_MODES, chan->dname, "%s: mode change '%s %s' by %s", ch, chg,
msg, from);
u = get_user_by_host(from);
get_user_flagrec(u, &user, ch);
nick = splitnick(&from);
m = ismember(chan, nick);
if (m)
m->last = now;
if (m && channel_active(chan) && (me_op(chan) || (me_halfop(chan) &&
!chan_hasop(m))) && !(glob_friend(user) || chan_friend(user) ||
(channel_dontkickops(chan) && (chan_op(user) || (glob_op(user) &&
!chan_deop(user))))) && !match_my_nick(nick)) {
if (chan_fakeop(m) || chan_fakehalfop(m)) {
putlog(LOG_MODES, ch, CHAN_FAKEMODE, ch);
dprintf(DP_MODE, "KICK %s %s :%s\n", ch, nick, CHAN_FAKEMODE_KICK);
m->flags |= SENTKICK;
reversing = 1;
} else if (!chan_hasop(m) && !chan_hashalfop(m) &&
!channel_nodesynch(chan)) {
putlog(LOG_MODES, ch, CHAN_DESYNCMODE, ch);
dprintf(DP_MODE, "KICK %s %s :%s\n", ch, nick, CHAN_DESYNCMODE_KICK);
m->flags |= SENTKICK;
reversing = 1;
}
}
ms2[0] = '+';
ms2[2] = 0;
while ((ms2[1] = *chg)) {
int todo = 0;
switch (*chg) {
case '+':
ms2[0] = '+';
break;
case '-':
ms2[0] = '-';
break;
case 'i':
todo = CHANINV;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'p':
todo = CHANPRIV;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 's':
todo = CHANSEC;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'm':
todo = CHANMODER;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'c':
todo = CHANNOCLR;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'C':
todo = CHANNOCTCP;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'R':
todo = CHANREGON;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'M':
todo = CHANMODREG;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'r':
todo = CHANLONLY;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'D':
todo = CHANDELJN;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'u':
todo = CHANSTRIP;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'N':
todo = CHANNONOTC;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'T':
todo = CHANNOAMSG;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'd':
todo = CHANINVIS;
break;
case 't':
todo = CHANTOPIC;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'n':
todo = CHANNOMSG;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'a':
todo = CHANANON;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'q':
todo = CHANQUIET;
if (!nick[0] && bounce_modes)
reversing = 1;
break;
case 'l':
if (!nick[0] && bounce_modes)
reversing = 1;
if (ms2[0] == '-') {
check_tcl_mode(nick, from, u, chan->dname, ms2, "");
/* The Tcl proc might have modified/removed the chan or user */
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return 0;
if (channel_active(chan)) {
if (reversing && (chan->channel.maxmembers != 0)) {
simple_sprintf(s, "%d", chan->channel.maxmembers);
add_mode(chan, '+', 'l', s);
} else if ((chan->limit_prot != 0) && !glob_master(user) &&
!chan_master(user) && !match_my_nick(nick)) {
simple_sprintf(s, "%d", chan->limit_prot);
add_mode(chan, '+', 'l', s);
}
}
chan->channel.maxmembers = 0;
} else {
op = newsplit(&msg);
fixcolon(op);
if (op == '\0')
break;
chan->channel.maxmembers = atoi(op);
check_tcl_mode(nick, from, u, chan->dname, ms2,
int_to_base10(chan->channel.maxmembers));
/* The Tcl proc might have modified/removed the chan or user */
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return 0;
if (channel_pending(chan))
break;
if ((reversing && !(chan->mode_pls_prot & CHANLIMIT)) ||
((chan->mode_mns_prot & CHANLIMIT) && !glob_master(user) &&
!chan_master(user)))
add_mode(chan, '-', 'l', "");
if ((chan->limit_prot != chan->channel.maxmembers) &&
(chan->mode_pls_prot & CHANLIMIT) && (chan->limit_prot != 0) &&
!glob_master(user) && !chan_master(user)) {
simple_sprintf(s, "%d", chan->limit_prot);
add_mode(chan, '+', 'l', s);
}
}
break;
case 'k':
if (ms2[0] == '+')
chan->channel.mode |= CHANKEY;
else
chan->channel.mode &= ~CHANKEY;
op = newsplit(&msg);
fixcolon(op);
if (op == '\0') {
break;
}
check_tcl_mode(nick, from, u, chan->dname, ms2, op);
/* The Tcl proc might have modified/removed the chan or user */
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return 0;
if (ms2[0] == '+') {
set_key(chan, op);
if (channel_active(chan))
got_key(chan, nick, from, op);
} else {
if (channel_active(chan)) {
if (reversing && chan->channel.key[0])
add_mode(chan, '+', 'k', chan->channel.key);
else if (chan->key_prot[0] && !glob_master(user) &&
!chan_master(user) && !match_my_nick(nick))
add_mode(chan, '+', 'k', chan->key_prot);
}
set_key(chan, NULL);
}
break;
case 'o':
op = newsplit(&msg);
fixcolon(op);
if (ms2[0] == '+')
got_op(chan, nick, from, op, u, &user);
else
got_deop(chan, nick, from, op, u);
break;
case 'h':
op = newsplit(&msg);
fixcolon(op);
if (ms2[0] == '+')
got_halfop(chan, nick, from, op, u, &user);
else
got_dehalfop(chan, nick, from, op, u);
break;
case 'v':
op = newsplit(&msg);
fixcolon(op);
m = ismember(chan, op);
if (!m) {
if (channel_pending(chan))
break;
putlog(LOG_MISC, chan->dname, CHAN_BADCHANMODE, chan->dname, op);
chan->status |= CHAN_PEND;
refresh_who_chan(chan->name);
} else {
simple_sprintf(s, "%s!%s", m->nick, m->userhost);
get_user_flagrec(m->user ? m->user : get_user_by_host(s),
&victim, chan->dname);
if (ms2[0] == '+') {
m->flags &= ~SENTVOICE;
m->flags |= CHANVOICE;
check_tcl_mode(nick, from, u, chan->dname, ms2, op);
if (!(chan = modebind_refresh(ch, from, &user, s, &victim)))
return 0;
if (channel_active(chan) && !glob_master(user) &&
!chan_master(user) && !match_my_nick(nick)) {
if (chan_quiet(victim) ||
(glob_quiet(victim) && !chan_voice(victim)))
add_mode(chan, '-', 'v', op);
else if (reversing)
add_mode(chan, '-', 'v', op);
}
} else {
m->flags &= ~SENTDEVOICE;
m->flags &= ~CHANVOICE;
check_tcl_mode(nick, from, u, chan->dname, ms2, op);
if (!(chan = modebind_refresh(ch, from, &user, s, &victim)))
return 0;
if (channel_active(chan) && !glob_master(user) &&
!chan_master(user) && !match_my_nick(nick)) {
if ((channel_autovoice(chan) && !chan_quiet(victim) &&
(chan_voice(victim) || glob_voice(victim))) ||
(!chan_quiet(victim) && (glob_gvoice(victim) ||
chan_gvoice(victim))))
add_mode(chan, '+', 'v', op);
else if (reversing)
add_mode(chan, '+', 'v', op);
}
}
}
break;
case 'b':
op = newsplit(&msg);
fixcolon(op);
if (ms2[0] == '+')
got_ban(chan, nick, from, op, ch, u);
else
got_unban(chan, nick, from, op, ch, u);
break;
case 'e':
op = newsplit(&msg);
fixcolon(op);
if (ms2[0] == '+')
got_exempt(chan, nick, from, op, ch, u);
else
got_unexempt(chan, nick, from, op, ch, u);
break;
case 'I':
op = newsplit(&msg);
fixcolon(op);
if (ms2[0] == '+')
got_invite(chan, nick, from, op, ch, u);
else
got_uninvite(chan, nick, from, op, ch, u);
break;
}
if (todo) {
check_tcl_mode(nick, from, u, chan->dname, ms2, "");
if (!(chan = modebind_refresh(ch, from, &user, NULL, NULL)))
return 0;
if (ms2[0] == '+')
chan->channel.mode |= todo;
else
chan->channel.mode &= ~todo;
if (channel_active(chan)) {
if ((((ms2[0] == '+') && (chan->mode_mns_prot & todo)) ||
((ms2[0] == '-') && (chan->mode_pls_prot & todo))) &&
!glob_master(user) && !chan_master(user) &&
!match_my_nick(nick))
add_mode(chan, ms2[0] == '+' ? '-' : '+', *chg, "");
else if (reversing && ((ms2[0] == '+') ||
(chan->mode_pls_prot & todo)) && ((ms2[0] == '-') ||
(chan->mode_mns_prot & todo)))
add_mode(chan, ms2[0] == '+' ? '-' : '+', *chg, "");
}
}
chg++;
}
if (!me_op(chan) && !nick[0])
chan->status |= CHAN_ASKEDMODES;
}
}
return 0;
}
