MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-27 01:02:46 +01:00
Code Issues Releases Wiki Activity
construct/ircd/chmode.cc
Jason Volk 052a6c8d22 Refactor snomask.
2016-08-28 01:48:25 -07:00

1349 lines
34 KiB
C++
Raw Blame History

/*
* charybdis: A slightly useful ircd.
* chmode.c: channel mode management
*
* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
* Copyright (C) 1996-2002 Hybrid Development Team
* Copyright (C) 2002-2005 ircd-ratbox development team
* Copyright (C) 2005-2006 charybdis development team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
namespace mode = ircd::chan::mode;
using namespace ircd;
/* bitmasks for error returns, so we send once per call */
#define SM_ERR_NOTS 0x00000001 /* No TS on channel */
#define SM_ERR_NOOPS 0x00000002 /* No chan ops */
#define SM_ERR_UNKNOWN 0x00000004
#define SM_ERR_RPL_C 0x00000008
#define SM_ERR_RPL_B 0x00000010
#define SM_ERR_RPL_E 0x00000020
#define SM_ERR_NOTONCHANNEL 0x00000040 /* Not on channel */
#define SM_ERR_RPL_I 0x00000100
#define SM_ERR_RPL_D 0x00000200
#define SM_ERR_NOPRIVS 0x00000400
#define SM_ERR_RPL_Q 0x00000800
#define SM_ERR_RPL_F 0x00001000
#define SM_ERR_MLOCK 0x00002000
#define MAXMODES_SIMPLE 46 /* a-zA-Z except bqeIov */
static int mode_count;
static int mode_limit;
static int mode_limit_simple;
static int removed_mask_pos;
static int h_get_channel_access;
mode::change mode_changes[BUFSIZE];
mode::mode mode::table[256];
char mode::arity[2][256]; // RPL_MYINFO (note that [0] is for 0 OR MORE params)
char mode::categories[4][256]; // RPL_ISUPPORT classification
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wchar-subscripts"
static void
table_init()
{
using namespace mode;
using namespace functor;
// Leading tab only please:
// <tab>mode::table['X'] = {<sp>handler,<sp>class,<sp>flag<sp>};
table['C'] = { type(0), category::D, nullptr };
table['F'] = { FREETARGET, category::D, simple };
table['I'] = { INVEX, category::A, ban };
table['L'] = { EXLIMIT, category::D, staff };
table['P'] = { PERMANENT, category::D, staff };
table['Q'] = { DISFORWARD, category::D, simple };
table['b'] = { BAN, category::A, ban };
table['e'] = { EXCEPTION, category::A, ban };
table['f'] = { type(0), category::C, forward };
table['g'] = { FREEINVITE, category::D, simple };
table['i'] = { INVITEONLY, category::D, simple };
table['j'] = { type(0), category::C, throttle };
table['k'] = { type(0), category::B, key };
table['l'] = { type(0), category::C, limit };
table['m'] = { MODERATED, category::D, simple };
table['n'] = { NOPRIVMSGS, category::D, simple };
table['o'] = { type(0), category::B, op };
table['p'] = { PRIVATE, category::D, simple };
table['q'] = { QUIET, category::A, ban };
table['r'] = { REGONLY, category::D, simple };
table['s'] = { SECRET, category::D, simple };
table['t'] = { TOPICLIMIT, category::D, simple };
table['v'] = { type(0), category::B, voice };
table['z'] = { OPMODERATE, category::D, simple };
}
#pragma GCC diagnostic pop
/* OPTIMIZE ME! -- dwr
* sure! --jzk */
void
chan::mode::init()
{
table_init();
categories[uint(category::A)][0] = '\0';
categories[uint(category::B)][0] = '\0';
categories[uint(category::C)][0] = '\0';
categories[uint(category::D)][0] = '\0';
arity[0][0] = '\0';
arity[1][0] = '\0';
/* Filter out anything disabled by the configuraton */
unsigned long disabled = 0;
if (!ConfigChannel.use_invex) disabled |= INVEX;
if (!ConfigChannel.use_except) disabled |= EXCEPTION;
if (!ConfigChannel.use_forward) disabled |= FREETARGET | DISFORWARD;
/* Construct the chmode data */
for (size_t i = 0; i < 256; i++)
{
if (!table[i].set_func)
{
table[i].set_func = functor::nosuch;
table[i].category = category::D;
continue;
}
if (table[i].type & disabled || table[i].set_func == functor::nosuch)
continue;
const char ch[2] = { char(i), '\0' };
const auto &cat(table[i].category);
rb_strlcat(categories[uint(cat)], ch, 256);
rb_strlcat(arity[0], ch, 256);
}
/* Any non-category::D mode has parameters, this sets up RPL_MYINFO */
for (size_t i = 0; i < 3; i++)
rb_strlcat(arity[1], categories[i], 256);
}
/*
* find_umode_slot
*
* inputs - NONE
* outputs - an available cflag bitmask or
* 0 if no cflags are available
* side effects - NONE
*/
static mode::type
find_cflag_slot(void)
{
using namespace mode;
unsigned int all_cflags = 0, my_cflag = 0, i;
for (i = 0; i < 256; i++)
all_cflags |= table[i].type;
for (my_cflag = 1; my_cflag && (all_cflags & my_cflag);
my_cflag <<= 1);
return type(my_cflag);
}
mode::type
mode::add(const uint8_t &c,
const category &category,
const func &set_func)
{
if(table[c].set_func &&
table[c].set_func != functor::nosuch &&
table[c].set_func != functor::orphaned)
return type(0);
if(table[c].set_func == functor::nosuch)
table[c].type = find_cflag_slot();
if(!table[c].type)
return type(0);
table[c].category = category;
table[c].set_func = set_func;
init();
return table[c].type;
}
void
mode::orphan(const uint8_t &c)
{
s_assert(table[c].type != 0);
table[c].set_func = functor::orphaned;
init();
}
namespace ircd {
int
chan::get_channel_access(client::client *source_p, chan *chptr, membership *msptr, int dir, const char *modestr)
{
hook_data_channel_approval moduledata;
if(!my(*source_p))
return CHANOP;
moduledata.client = source_p;
moduledata.chptr = chptr;
moduledata.msptr = msptr;
moduledata.target = NULL;
moduledata.approved = (msptr != NULL && is_chanop(msptr)) ? CHANOP : PEON;
moduledata.dir = dir;
moduledata.modestr = modestr;
call_hook(h_get_channel_access, &moduledata);
return moduledata.approved;
}
/* allow_mode_change()
*
* Checks if mlock and chanops permit a mode change.
*
* inputs - client, channel, access level, errors pointer, mode char
* outputs - false on failure, true on success
* side effects - error message sent on failure
*/
static bool
allow_mode_change(client::client *source_p, chan::chan *chptr, int alevel,
int *errors, char c)
{
/* If this mode char is locked, don't allow local users to change it. */
if (my(*source_p) && !chptr->mode_lock.empty() && strchr(chptr->mode_lock.c_str(), c))
{
if (!(*errors & SM_ERR_MLOCK))
sendto_one_numeric(source_p,
ERR_MLOCKRESTRICTED,
form_str(ERR_MLOCKRESTRICTED),
chptr->name.c_str(),
c,
chptr->mode_lock.c_str());
*errors |= SM_ERR_MLOCK;
return false;
}
if(alevel < chan::CHANOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, source_p->name, chptr->name.c_str());
*errors |= SM_ERR_NOOPS;
return false;
}
return true;
}
/* check_forward()
*
* input - client, channel to set mode on, target channel name
* output - true if forwarding should be allowed
* side effects - numeric sent if not allowed
*/
static bool
check_forward(client::client *source_p, chan::chan *chptr, const char *forward)
{
chan::chan *targptr = NULL;
chan::membership *msptr;
if(!chan::valid_name(forward) ||
(my(*source_p) && (strlen(forward) > LOC_CHANNELLEN || hash_find_resv(forward))))
{
sendto_one_numeric(source_p, ERR_BADCHANNAME, form_str(ERR_BADCHANNAME), forward);
return false;
}
/* don't forward to inconsistent target -- jilles */
if(chptr->name[0] == '#' && forward[0] == '&')
{
sendto_one_numeric(source_p, ERR_BADCHANNAME,
form_str(ERR_BADCHANNAME), forward);
return false;
}
if(my(*source_p) && (targptr = chan::get(forward, std::nothrow)) == NULL)
{
sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL,
form_str(ERR_NOSUCHCHANNEL), forward);
return false;
}
if(my(*source_p) && !(targptr->mode.mode & mode::FREETARGET))
{
auto *const msptr(get(targptr->members, *source_p, std::nothrow));
if(!msptr || get_channel_access(source_p, targptr, msptr, MODE_QUERY, NULL) < chan::CHANOP)
{
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name,
source_p->name,
targptr->name.c_str());
return false;
}
}
return true;
}
/* fix_key()
*
* input - key to fix
* output - the same key, fixed
* side effects - anything below ascii 13 is discarded, ':' discarded,
* high ascii is dropped to lower half of ascii table
*/
static char *
fix_key(char *arg)
{
unsigned char *s, *t, c;
for(s = t = (unsigned char *) arg; (c = *s); s++)
{
c &= 0x7f;
if(c != ':' && c != ',' && c > ' ')
*t++ = c;
}
*t = '\0';
return arg;
}
/* fix_key_remote()
*
* input - key to fix
* ouput - the same key, fixed
* side effects - high ascii dropped to lower half of table,
* CR/LF/':' are dropped
*/
static char *
fix_key_remote(char *arg)
{
unsigned char *s, *t, c;
for(s = t = (unsigned char *) arg; (c = *s); s++)
{
c &= 0x7f;
if((c != 0x0a) && (c != ':') && (c != ',') && (c != 0x0d) && (c != ' '))
*t++ = c;
}
*t = '\0';
return arg;
}
/* chm_*()
*
* The handlers for each specific mode.
*/
void
mode::functor::nosuch(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(*errors & SM_ERR_UNKNOWN)
return;
*errors |= SM_ERR_UNKNOWN;
sendto_one(source_p, form_str(ERR_UNKNOWNMODE), me.name, source_p->name, c);
}
void
mode::functor::simple(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
/* setting + */
if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
{
/* if +f is disabled, ignore an attempt to set +QF locally */
if(!ConfigChannel.use_forward && my(*source_p) &&
(c == 'Q' || c == 'F'))
return;
chptr->mode.mode |= mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count++].arg = NULL;
}
else if((dir == MODE_DEL) && (chptr->mode.mode & mode_type))
{
chptr->mode.mode &= ~mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::orphaned(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(my(*source_p))
return;
if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
{
chptr->mode.mode |= mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count++].arg = NULL;
}
else if((dir == MODE_DEL) && (chptr->mode.mode & mode_type))
{
chptr->mode.mode &= ~mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::hidden(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!is(*source_p, umode::OPER) && !is_server(*source_p))
{
if(!(*errors & SM_ERR_NOPRIVS))
sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
*errors |= SM_ERR_NOPRIVS;
return;
}
if(my(*source_p) && !IsOperAdmin(source_p))
{
if(!(*errors & SM_ERR_NOPRIVS))
sendto_one(source_p, form_str(ERR_NOPRIVS), me.name,
source_p->name, "admin");
*errors |= SM_ERR_NOPRIVS;
return;
}
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
/* setting + */
if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
{
chptr->mode.mode |= mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count].mems = ONLY_OPERS;
mode_changes[mode_count++].arg = NULL;
}
else if((dir == MODE_DEL) && (chptr->mode.mode & mode_type))
{
chptr->mode.mode &= ~mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ONLY_OPERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::staff(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!is(*source_p, umode::OPER) && !is_server(*source_p))
{
if(!(*errors & SM_ERR_NOPRIVS))
sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
*errors |= SM_ERR_NOPRIVS;
return;
}
if(my(*source_p) && !IsOperResv(source_p))
{
if(!(*errors & SM_ERR_NOPRIVS))
sendto_one(source_p, form_str(ERR_NOPRIVS), me.name,
source_p->name, "resv");
*errors |= SM_ERR_NOPRIVS;
return;
}
if(!allow_mode_change(source_p, chptr, CHANOP, errors, c))
return;
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
/* setting + */
if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
{
chptr->mode.mode |= mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count++].arg = NULL;
}
else if((dir == MODE_DEL) && (chptr->mode.mode & mode_type))
{
chptr->mode.mode &= ~mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::ban(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
namespace chan = ircd::chan;
const char *mask, *raw_mask;
char *forward;
chan::list *list;
int errorval;
const char *rpl_list_p;
const char *rpl_endlist_p;
int mems;
switch (mode_type)
{
case BAN:
list = &get(*chptr, mode_type);
errorval = SM_ERR_RPL_B;
rpl_list_p = form_str(RPL_BANLIST);
rpl_endlist_p = form_str(RPL_ENDOFBANLIST);
mems = ALL_MEMBERS;
break;
case EXCEPTION:
/* if +e is disabled, allow all but +e locally */
if(!ConfigChannel.use_except && my(*source_p) &&
((dir == MODE_ADD) && (parc > *parn)))
return;
list = &get(*chptr, mode_type);
errorval = SM_ERR_RPL_E;
rpl_list_p = form_str(RPL_EXCEPTLIST);
rpl_endlist_p = form_str(RPL_ENDOFEXCEPTLIST);
if(ConfigChannel.use_except || (dir == MODE_DEL))
mems = ONLY_CHANOPS;
else
mems = ONLY_SERVERS;
break;
case INVEX:
/* if +I is disabled, allow all but +I locally */
if(!ConfigChannel.use_invex && my(*source_p) &&
(dir == MODE_ADD) && (parc > *parn))
return;
list = &get(*chptr, mode_type);
errorval = SM_ERR_RPL_I;
rpl_list_p = form_str(RPL_INVITELIST);
rpl_endlist_p = form_str(RPL_ENDOFINVITELIST);
if(ConfigChannel.use_invex || (dir == MODE_DEL))
mems = ONLY_CHANOPS;
else
mems = ONLY_SERVERS;
break;
case QUIET:
list = &get(*chptr, mode_type);
errorval = SM_ERR_RPL_Q;
rpl_list_p = form_str(RPL_QUIETLIST);
rpl_endlist_p = form_str(RPL_ENDOFQUIETLIST);
mems = ALL_MEMBERS;
break;
default:
sendto_realops_snomask(sno::GENERAL, L_ALL, "chm_ban() called with unknown type!");
return;
}
if(dir == 0 || parc <= *parn)
{
if((*errors & errorval) != 0)
return;
*errors |= errorval;
/* non-ops cant see +eI lists.. */
/* note that this is still permitted if +e/+I are mlocked. */
if(alevel < CHANOP && mode_type != BAN &&
mode_type != QUIET)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, source_p->name, chptr->name.c_str());
*errors |= SM_ERR_NOOPS;
return;
}
for (const auto &ban : *list)
{
char buf[ban::LEN];
if(!ban.forward.empty())
snprintf(buf, sizeof(buf), "%s$%s", ban.banstr.c_str(), ban.forward.c_str());
else
rb_strlcpy(buf, ban.banstr.c_str(), sizeof(buf));
sendto_one(source_p, rpl_list_p,
me.name,
source_p->name,
chptr->name.c_str(),
buf,
ban.who.c_str(),
ban.when);
}
sendto_one(source_p, rpl_endlist_p, me.name, source_p->name, chptr->name.c_str());
return;
}
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if(my(*source_p) && (++mode_limit > MAXPARAMS))
return;
raw_mask = parv[(*parn)];
(*parn)++;
/* empty ban, or starts with ':' which messes up s2s, ignore it */
if(EmptyString(raw_mask) || *raw_mask == ':')
return;
if(!my(*source_p))
{
if(strchr(raw_mask, ' '))
return;
mask = raw_mask;
}
else
mask = pretty_mask(raw_mask);
/* we'd have problems parsing this, hyb6 does it too
* also make sure it will always fit on a line with channel
* name etc.
*/
if(strlen(mask) > MIN(ban::LEN, BUFLEN - 5))
{
sendto_one_numeric(source_p, ERR_INVALIDBAN,
form_str(ERR_INVALIDBAN),
chptr->name.c_str(), c, raw_mask);
return;
}
/* Look for a $ after the first character.
* As the first character, it marks an extban; afterwards
* it delimits a forward channel.
*/
if ((forward = (char *)strchr(mask+1, '$')) != NULL)
{
*forward++ = '\0';
if (*forward == '\0')
forward = NULL;
}
/* if we're adding a NEW id */
if(dir == MODE_ADD)
{
if (*mask == '$' && my(*source_p))
{
if (!valid_extban(mask, source_p, chptr, mode_type))
{
sendto_one_numeric(source_p, ERR_INVALIDBAN,
form_str(ERR_INVALIDBAN),
chptr->name.c_str(), c, raw_mask);
return;
}
}
/* For compatibility, only check the forward channel from
* local clients. Accept any forward channel from servers.
*/
if(forward != NULL && my(*source_p))
{
/* For simplicity and future flexibility, do not
* allow '$' in forwarding targets.
*/
if(!ConfigChannel.use_forward ||
strchr(forward, '$') != NULL)
{
sendto_one_numeric(source_p, ERR_INVALIDBAN,
form_str(ERR_INVALIDBAN),
chptr->name.c_str(), c, raw_mask);
return;
}
/* check_forward() sends its own error message */
if(!check_forward(source_p, chptr, forward))
return;
/* Forwards only make sense for bans. */
if(mode_type != BAN)
{
sendto_one_numeric(source_p, ERR_INVALIDBAN,
form_str(ERR_INVALIDBAN),
chptr->name.c_str(), c, raw_mask);
return;
}
}
/* dont allow local clients to overflow the banlist, dont
* let remote servers set duplicate bans
*/
if(!add(*chptr, mode_type, mask, *source_p, forward?: std::string{}))
return;
if(forward)
forward[-1]= '$';
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = mems;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = mask;
}
else if(dir == MODE_DEL)
{
// When this whole function gets hosed all of this will be better
static char buf[ban::LEN * MAXPARAMS];
const int old_removed_mask_pos(removed_mask_pos);
std::string _mask(mask);
auto it(list->find(_mask));
if (it == end(*list))
{
_mask = raw_mask;
it = list->find(_mask);
}
if (it != end(*list))
{
const auto &ban(*it);
if (!ban.forward.empty())
removed_mask_pos += snprintf(buf + old_removed_mask_pos, sizeof(buf), "%s$%s", ban.banstr.c_str(), ban.forward.c_str()) + 1;
else
removed_mask_pos += rb_strlcpy(buf + old_removed_mask_pos, mask, sizeof(buf)) + 1;
del(*chptr, mode_type, _mask);
}
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = mems;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = buf + old_removed_mask_pos;
}
}
void
mode::functor::op(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
membership *mstptr;
const char *opnick;
client::client *targ_p;
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if((dir == MODE_QUERY) || (parc <= *parn))
return;
opnick = parv[(*parn)];
(*parn)++;
/* empty nick */
if(EmptyString(opnick))
{
sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), "*");
return;
}
if((targ_p = find_chasing(source_p, opnick, NULL)) == NULL)
{
return;
}
mstptr = get(chptr->members, *targ_p, std::nothrow);
if(mstptr == NULL)
{
if(!(*errors & SM_ERR_NOTONCHANNEL) && my(*source_p))
sendto_one_numeric(source_p, ERR_USERNOTINCHANNEL,
form_str(ERR_USERNOTINCHANNEL), opnick, chptr->name.c_str());
*errors |= SM_ERR_NOTONCHANNEL;
return;
}
if(my(*source_p) && (++mode_limit > MAXPARAMS))
return;
if(dir == MODE_ADD)
{
if(targ_p == source_p && mstptr->flags & CHANOP)
return;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = targ_p->id;
mode_changes[mode_count++].arg = targ_p->name;
mstptr->flags |= CHANOP;
}
else
{
if(my(*source_p) && is(*targ_p, umode::SERVICE))
{
sendto_one(source_p, form_str(ERR_ISCHANSERVICE),
me.name, source_p->name, targ_p->name, chptr->name.c_str());
return;
}
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = targ_p->id;
mode_changes[mode_count++].arg = targ_p->name;
mstptr->flags &= ~CHANOP;
}
}
void
mode::functor::voice(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
membership *mstptr;
const char *opnick;
client::client *targ_p;
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if((dir == MODE_QUERY) || parc <= *parn)
return;
opnick = parv[(*parn)];
(*parn)++;
/* empty nick */
if(EmptyString(opnick))
{
sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), "*");
return;
}
if((targ_p = find_chasing(source_p, opnick, NULL)) == NULL)
{
return;
}
mstptr = get(chptr->members, *targ_p, std::nothrow);
if(mstptr == NULL)
{
if(!(*errors & SM_ERR_NOTONCHANNEL) && my(*source_p))
sendto_one_numeric(source_p, ERR_USERNOTINCHANNEL,
form_str(ERR_USERNOTINCHANNEL), opnick, chptr->name.c_str());
*errors |= SM_ERR_NOTONCHANNEL;
return;
}
if(my(*source_p) && (++mode_limit > MAXPARAMS))
return;
if(dir == MODE_ADD)
{
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = targ_p->id;
mode_changes[mode_count++].arg = targ_p->name;
mstptr->flags |= VOICE;
}
else
{
mode_changes[mode_count].letter = 'v';
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = targ_p->id;
mode_changes[mode_count++].arg = targ_p->name;
mstptr->flags &= ~VOICE;
}
}
void
mode::functor::limit(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
const char *lstr;
static char limitstr[30];
int limit;
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if(dir == MODE_QUERY)
return;
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
if((dir == MODE_ADD) && parc > *parn)
{
lstr = parv[(*parn)];
(*parn)++;
if(EmptyString(lstr) || (limit = atoi(lstr)) <= 0)
return;
sprintf(limitstr, "%d", limit);
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = limitstr;
chptr->mode.limit = limit;
}
else if(dir == MODE_DEL)
{
if(!chptr->mode.limit)
return;
chptr->mode.limit = 0;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::throttle(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
int joins = 0, timeslice = 0;
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if(dir == MODE_QUERY)
return;
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
if((dir == MODE_ADD) && parc > *parn)
{
if (sscanf(parv[(*parn)], "%d:%d", &joins, &timeslice) < 2)
return;
if(joins <= 0 || timeslice <= 0)
return;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = parv[(*parn)];
(*parn)++;
chptr->mode.join_num = joins;
chptr->mode.join_time = timeslice;
}
else if(dir == MODE_DEL)
{
if(!chptr->mode.join_num)
return;
chptr->mode.join_num = 0;
chptr->mode.join_time = 0;
chptr->join_count = 0;
chptr->join_delta = 0;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::forward(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
const char *forward;
/* if +f is disabled, ignore local attempts to set it */
if(!ConfigChannel.use_forward && my(*source_p) &&
(dir == MODE_ADD) && (parc > *parn))
return;
if(dir == MODE_QUERY || (dir == MODE_ADD && parc <= *parn))
{
if (!(*errors & SM_ERR_RPL_F))
{
if (*chptr->mode.forward == '\0')
sendto_one_notice(source_p, ":%s has no forward channel", chptr->name.c_str());
else
sendto_one_notice(source_p, ":%s forward channel is %s", chptr->name.c_str(), chptr->mode.forward);
*errors |= SM_ERR_RPL_F;
}
return;
}
#ifndef FORWARD_OPERONLY
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
#else
if(!is(*source_p, umode::OPER) && !is_server(*source_p))
{
if(!(*errors & SM_ERR_NOPRIVS))
sendto_one_numeric(source_p, ERR_NOPRIVILEGES, form_str(ERR_NOPRIVILEGES));
*errors |= SM_ERR_NOPRIVS;
return;
}
#endif
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
if(dir == MODE_ADD && parc > *parn)
{
forward = parv[(*parn)];
(*parn)++;
if(EmptyString(forward))
return;
if(!check_forward(source_p, chptr, forward))
return;
rb_strlcpy(chptr->mode.forward, forward, sizeof(chptr->mode.forward));
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems =
ConfigChannel.use_forward ? ALL_MEMBERS : ONLY_SERVERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = forward;
}
else if(dir == MODE_DEL)
{
if(!(*chptr->mode.forward))
return;
*chptr->mode.forward = '\0';
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = NULL;
}
}
void
mode::functor::key(client::client *source_p, chan *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, type mode_type)
{
char *key;
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
if(dir == MODE_QUERY)
return;
if(my(*source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
if((dir == MODE_ADD) && parc > *parn)
{
key = LOCAL_COPY(parv[(*parn)]);
(*parn)++;
if(my(*source_p))
fix_key(key);
else
fix_key_remote(key);
if(EmptyString(key))
return;
s_assert(key[0] != ' ');
rb_strlcpy(chptr->mode.key, key, sizeof(chptr->mode.key));
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = chptr->mode.key;
}
else if(dir == MODE_DEL)
{
static char splat[] = "*";
int i;
if(parc > *parn)
(*parn)++;
if(!(*chptr->mode.key))
return;
/* hack time. when we get a +k-k mode, the +k arg is
* chptr->mode.key, which the -k sets to \0, so hunt for a
* +k when we get a -k, and set the arg to splat. --anfl
*/
for(i = 0; i < mode_count; i++)
{
if(mode_changes[i].letter == 'k' && mode_changes[i].dir == MODE_ADD)
mode_changes[i].arg = splat;
}
*chptr->mode.key = 0;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_DEL;
mode_changes[mode_count].mems = ALL_MEMBERS;
mode_changes[mode_count].id = NULL;
mode_changes[mode_count++].arg = "*";
}
}
/* set_channel_mode()
*
* inputs - client, source, channel, membership pointer, params
* output -
* side effects - channel modes/memberships are changed, MODE is issued
*
* Extensively modified to be hotpluggable, 03/09/06 -- nenolod
*/
void
chan::set_channel_mode(client::client *client_p, client::client *source_p,
chan *chptr, membership *msptr, int parc, const char *parv[])
{
static char modebuf[BUFSIZE];
static char parabuf[BUFSIZE];
char *mbuf;
char *pbuf;
int cur_len, mlen, paralen, paracount, arglen, len;
int i, j, flags;
int dir = MODE_QUERY;
int parn = 1;
int errors = 0;
int alevel;
const char *ml = parv[0];
char c;
client::client *fakesource_p;
int reauthorized = 0; /* if we change from MODE_QUERY to MODE_ADD/MODE_DEL, then reauth once, ugly but it works */
int flags_list[3] = { ALL_MEMBERS, ONLY_CHANOPS, ONLY_OPERS };
removed_mask_pos = 0;
mode_count = 0;
mode_limit = 0;
mode_limit_simple = 0;
/* Hide connecting server on netburst -- jilles */
if (ConfigServerHide.flatten_links && is_server(*source_p) && !has_id(source_p) && !has_sent_eob(*source_p))
fakesource_p = &me;
else
fakesource_p = source_p;
alevel = get_channel_access(source_p, chptr, msptr, dir, reconstruct_parv(parc, parv));
for(; (c = *ml) != 0; ml++)
{
switch (c)
{
case '+':
dir = MODE_ADD;
if (!reauthorized)
{
alevel = get_channel_access(source_p, chptr, msptr, dir, reconstruct_parv(parc, parv));
reauthorized = 1;
}
break;
case '-':
dir = MODE_DEL;
if (!reauthorized)
{
alevel = get_channel_access(source_p, chptr, msptr, dir, reconstruct_parv(parc, parv));
reauthorized = 1;
}
break;
case '=':
dir = MODE_QUERY;
break;
default:
mode::table[uint8_t(c)].set_func(fakesource_p, chptr, alevel, parc, &parn, parv, &errors, dir, c, mode::table[uint8_t(c)].type);
break;
}
}
/* bail out if we have nothing to do... */
if(!mode_count)
return;
if(is_server(*source_p))
mlen = sprintf(modebuf, ":%s MODE %s ", fakesource_p->name, chptr->name.c_str());
else
mlen = sprintf(modebuf, ":%s!%s@%s MODE %s ",
source_p->name, source_p->username,
source_p->host, chptr->name.c_str());
for(j = 0; j < 3; j++)
{
flags = flags_list[j];
cur_len = mlen;
mbuf = modebuf + mlen;
pbuf = parabuf;
parabuf[0] = '\0';
paracount = paralen = 0;
dir = MODE_QUERY;
for(i = 0; i < mode_count; i++)
{
if(mode_changes[i].letter == 0 || mode_changes[i].mems != flags)
continue;
if(mode_changes[i].arg != NULL)
{
arglen = strlen(mode_changes[i].arg);
if(arglen > mode::BUFLEN - 5)
continue;
}
else
arglen = 0;
/* if we're creeping over mode::MAXPARAMSSERV, or over
* bufsize (4 == +/-,modechar,two spaces) send now.
*/
if(mode_changes[i].arg != NULL &&
((paracount == mode::MAXPARAMSSERV) ||
((cur_len + paralen + arglen + 4) > (BUFSIZE - 3))))
{
*mbuf = '\0';
if(cur_len > mlen)
sendto_channel_local(flags, chptr, "%s %s", modebuf,
parabuf);
else
continue;
paracount = paralen = 0;
cur_len = mlen;
mbuf = modebuf + mlen;
pbuf = parabuf;
parabuf[0] = '\0';
dir = MODE_QUERY;
}
if(dir != mode_changes[i].dir)
{
*mbuf++ = (mode_changes[i].dir == MODE_ADD) ? '+' : '-';
cur_len++;
dir = mode_changes[i].dir;
}
*mbuf++ = mode_changes[i].letter;
cur_len++;
if(mode_changes[i].arg != NULL)
{
paracount++;
len = sprintf(pbuf, "%s ", mode_changes[i].arg);
pbuf += len;
paralen += len;
}
}
if(paralen && parabuf[paralen - 1] == ' ')
parabuf[paralen - 1] = '\0';
*mbuf = '\0';
if(cur_len > mlen)
sendto_channel_local(flags, chptr, "%s %s", modebuf, parabuf);
}
/* only propagate modes originating locally, or if we're hubbing */
if(my(*source_p) || rb_dlink_list_length(&serv_list) > 1)
send_cap_mode_changes(client_p, source_p, chptr, mode_changes, mode_count);
}
/* set_channel_mlock()
*
* inputs - client, source, channel, params
* output -
* side effects - channel mlock is changed / MLOCK is propagated
*/
void
chan::set_channel_mlock(client::client *client_p, client::client *source_p,
chan *chptr, const char *newmlock, bool propagate)
{
chptr->mode_lock = newmlock?: std::string{};
if (propagate)
{
sendto_server(client_p, NULL, CAP_TS6 | CAP_MLOCK, NOCAPS, ":%s MLOCK %ld %s :%s",
source_p->id, (long) chptr->channelts, chptr->name.c_str(),
chptr->mode_lock.c_str());
}
}
} // namespace ircd
Reference in a new issue View git blame Copy permalink