int
real_chk_deop(struct flag_record fr, struct chanset_t *chan, bool botbitch)
{
if (chan && botbitch && channel_botbitch(chan) && !glob_bot(fr))
return 1;
if (chan_deop(fr) || (glob_deop(fr) && !chan_op(fr)))
return 1;
else
return 0;
}
int flagrec_ok(struct flag_record *req, struct flag_record *have)
{
/* FIXME: flag masks with '&' in them won't be subject to
* further tests below. Example: 'o&j'
*/
if (req->match & FR_AND)
return flagrec_eq(req, have);
else if (req->match & FR_OR) {
int hav = have->global;
/* Exception 1 - global +d/+k cant use -|-, unless they are +p */
if (!req->chan && !req->global && !req->udef_global && !req->udef_chan) {
if (!allow_dk_cmds) {
if (glob_party(*have))
return 1;
if (glob_kick(*have) || chan_kick(*have))
return 0; /* +k cant use -|- commands */
if (glob_deop(*have) || chan_deop(*have))
return 0; /* neither can +d's */
}
return 1;
}
/* The +n/+m checks aren't needed anymore because +n/+m
* automatically adds lower flags
*/
if (!require_p && ((hav & USER_OP) || (have->chan & USER_OWNER)))
hav |= USER_PARTY;
if (hav & req->global)
return 1;
if (have->chan & req->chan)
return 1;
if (have->udef_global & req->udef_global)
return 1;
if (have->udef_chan & req->udef_chan)
return 1;
return 0;
}
return 0; /* fr0k3 binding, dont pass it */
}
int flagrec_ok(struct flag_record *req,
struct flag_record *have)
{
if (req->match & FR_AND) {
return flagrec_eq(req, have);
} else if (req->match & FR_OR) {
int hav = have->global;
/* exception 1 - global +d/+k cant use -|-, unless they are +p */
if (!req->chan && !req->global && !req->udef_global &&
!req->udef_chan) {
if (!allow_dk_cmds) {
if (glob_party(*have))
return 1;
if (glob_kick(*have) || chan_kick(*have))
return 0; /* +k cant use -|- commands */
if (glob_deop(*have) || chan_deop(*have))
return 0; /* neither can +d's */
}
return 1;
}
/* the +n/+m checks arent needed anymore since +n/+m
* automatically add lower flags */
if (!require_p && ((hav & USER_OP) || (have->chan & USER_OWNER)))
hav |= USER_PARTY;
if (hav & req->global)
return 1;
if (have->chan & req->chan)
return 1;
if (have->udef_global & req->udef_global)
return 1;
if (have->udef_chan & req->udef_chan)
return 1;
return 0;
}
return 0; /* fr0k3 binding, dont pass it */
}
/* 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_deop(struct chanset_t *chan, char *nick, char *from,
char *who, struct userrec *opu)
{
memberlist *m;
char ch[sizeof chan->name];
char s[UHOSTLEN], s1[UHOSTLEN];
struct userrec *u;
int had_halfop;
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;
}
strcpy(ch, chan->name);
simple_sprintf(s, "%s!%s", m->nick, m->userhost);
simple_sprintf(s1, "%s!%s", nick, from);
u = get_user_by_host(s);
get_user_flagrec(u, &victim, chan->dname);
had_halfop = chan_hasop(m);
/* Flags need to be set correctly right from the beginning now, so that
* add_mode() doesn't get irritated.
*/
m->flags &= ~(CHANOP | SENTDEOP | FAKEOP);
check_tcl_mode(nick, from, opu, chan->dname, "-o", who);
if (!(chan = modebind_refresh(ch, from, &user, s, &victim)) ||
!(m = ismember(chan, who)))
return;
m->flags &= ~WASOP;
if (channel_pending(chan))
return;
if (HALFOP_CANDOMODE('o')) {
int ok = 1;
if (!glob_deop(victim) && !chan_deop(victim)) {
if (channel_protectops(chan) && (glob_master(victim) ||
chan_master(victim) || glob_op(victim) || chan_op(victim)))
ok = 0;
else if (channel_protectfriends(chan) && (glob_friend(victim) ||
chan_friend(victim)))
ok = 0;
}
if ((reversing || !ok) && had_halfop && !match_my_nick(nick) &&
rfc_casecmp(who, nick) && !match_my_nick(who) && !glob_master(user) &&
!chan_master(user) && !glob_bot(user) && ((chan_op(victim) ||
(glob_op(victim) && !chan_deop(victim))) || !channel_bitch(chan)))
add_mode(chan, '+', 'o', who);
}
if (!nick[0])
putlog(LOG_MODES, chan->dname, "TS resync (%s): %s deopped by %s",
chan->dname, who, from);
/* Check for mass deop */
if (nick[0])
detect_chan_flood(nick, from, s1, chan, FLOOD_DEOP, who, 0);
/* Having op hides your +v and +h status -- so now that someone's lost ops,
* check to see if they have +v or +h
*/
if (!(m->flags & (CHANVOICE | CHANHALFOP | STOPWHO))) {
chan->status |= CHAN_PEND;
refresh_who_chan(chan->name);
m->flags |= STOPWHO;
}
/* Was the bot deopped? */
if (match_my_nick(who)) {
/* Cancel any pending kicks and modes */
memberlist *m2;
for (m2 = chan->channel.member; m2 && m2->nick[0]; m2 = m2->next)
m2->flags &= ~(SENTKICK | SENTDEOP | SENTOP | SENTVOICE | SENTDEVOICE);
check_tcl_need(chan->dname, "op");
if (chan->need_op[0])
do_tcl("need-op", chan->need_op);
if (!nick[0])
putlog(LOG_MODES, chan->dname, "TS resync deopped me on %s :(",
chan->dname);
}
if (nick[0])
maybe_revenge(chan, s1, s, REVENGE_DEOP);
}
static void got_op(struct chanset_t *chan, char *nick, char *from,
char *who, struct userrec *opu, struct flag_record *opper)
{
memberlist *m;
char ch[sizeof chan->name];
char s[UHOSTLEN];
struct userrec *u;
int check_chan = 0, 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 opped? */
if (!me_op(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 |= CHANOP;
check_tcl_mode(nick, from, opu, chan->dname, "+o", who);
if (!(chan = modebind_refresh(ch, from, opper, s, &victim)) ||
!(m = ismember(chan, who)))
return;
/* Added new meaning of WASOP:
* In mode binds it means: was the user an op before got (de)opped. A script
* now can use [wasop nick chan] to check if user was op or wasnt.
* (drummer)
*/
m->flags &= ~SENTOP;
if (channel_pending(chan))
return;
if (nick[0] && HALFOP_CANDOMODE('o') && !match_my_nick(who) &&
!match_my_nick(nick)) {
if (channel_bitch(chan) && !(glob_master(*opper) || glob_bot(*opper)) &&
!chan_master(*opper) && !(glob_op(victim) || glob_bot(victim)) &&
!chan_op(victim))
add_mode(chan, '-', 'o', who);
else if ((chan_deop(victim) || (glob_deop(victim) && !chan_op(victim))) &&
!glob_master(*opper) && !chan_master(*opper))
add_mode(chan, '-', 'o', who);
else if (reversing)
add_mode(chan, '-', 'o', who);
} else if (reversing && HALFOP_CANDOMODE('o') && !match_my_nick(who) &&
!match_my_nick(nick))
add_mode(chan, '-', 'o', who);
if (!nick[0] && HALFOP_CANDOMODE('o') && !match_my_nick(who)) {
if (chan_deop(victim) || (glob_deop(victim) && !chan_op(victim))) {
m->flags |= FAKEOP;
add_mode(chan, '-', 'o', who);
} else if (snm > 0 && snm < 7 && !((channel_autoop(chan) ||
glob_autoop(victim) || chan_autoop(victim)) && (chan_op(victim) ||
(glob_op(victim) && !chan_deop(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_wasoptest(victim) || glob_wasoptest(victim) || snm == 2) {
if (!chan_wasop(m)) {
m->flags |= FAKEOP;
add_mode(chan, '-', 'o', who);
}
} else if (!(chan_op(victim) || (glob_op(victim) && !chan_deop(victim)))) {
if (snm == 1 || snm == 4 || (snm == 3 && !chan_wasop(m))) {
add_mode(chan, '-', 'o', who);
m->flags |= FAKEOP;
}
} else if (snm == 4 && !chan_wasop(m)) {
add_mode(chan, '-', 'o', who);
m->flags |= FAKEOP;
}
}
}
m->flags |= WASOP;
if (check_chan)
recheck_channel(chan, 1);
}
