MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-06-28 14:58:20 +02:00
Code Issues Releases Wiki Activity

Refactor chmode into namespace.

Browse source 
She's still a bit of a mess.
This commit is contained in:
Jason Volk 2016-08-16 20:01:20 -07:00
parent f112111e51
commit 03660fc4b0
43 changed files with 577 additions and 487 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
extensions/chm_adminonly.cc
View file

@ -10,12 +10,14 @@ mapi_hfn_list_av1 adminonly_hfnlist[] = {
{ NULL, NULL }
};
static unsigned int mymode;
static chan::mode::type mymode;
static int
_modinit(void)
{
mymode = cflag_add('A', CHM_D, chm_staff);
using namespace chan::mode;
mymode = add('A', category::D, functor::staff);
if (mymode == 0)
return -1;
@ -25,7 +27,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('A');
chan::mode::orphan('A');
}
DECLARE_MODULE_AV2(chm_adminonly, _modinit, _moddeinit, NULL, NULL, adminonly_hfnlist, NULL, NULL, chm_adminonly_desc);
@ -38,7 +40,7 @@ h_can_join(hook_data_channel *data)
if((chptr->mode.mode & mymode) && !IsAdmin(source_p)) {
sendto_one_numeric(source_p, 519, "%s :Cannot join channel (+A) - you are not an IRC server administrator", chptr->chname);
data->approved = ERR_CUSTOM;
data->approved = chan::mode::ERR_CUSTOM;
}
}

10
extensions/chm_insecure.cc
View file

@ -11,12 +11,14 @@ mapi_hfn_list_av1 sslonly_hfnlist[] = {
{ NULL, NULL }
};
static unsigned int mymode;
static chan::mode::type mymode;
static int
_modinit(void)
{
mymode = cflag_add('U', CHM_D, chm_simple);
using namespace chan::mode;
mymode = add('U', category::D, functor::simple);
if (mymode == 0)
return -1;
@ -27,7 +29,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('U');
chan::mode::orphan('U');
}
DECLARE_MODULE_AV2(chm_insecure, _modinit, _moddeinit, NULL, NULL, sslonly_hfnlist, NULL, NULL, chm_insecure_desc);
@ -41,7 +43,7 @@ h_can_join(hook_data_channel *data)
if(!(chptr->mode.mode & mymode) && !IsSSLClient(source_p)) {
/* XXX This is equal to ERR_THROTTLE */
sendto_one_numeric(source_p, 480, "%s :Cannot join channel (-U) - SSL/TLS required", chptr->chname);
data->approved = ERR_CUSTOM;
data->approved = chan::mode::ERR_CUSTOM;
}
}

8
extensions/chm_nonotice.cc
View file

@ -26,7 +26,7 @@ using namespace ircd;
static const char chm_nonotice_desc[] =
"Adds channel mode +T which blocks notices to the channel.";
static unsigned int mode_nonotice;
static chan::mode::type mode_nonotice;
static void chm_nonotice_process(hook_data_privmsg_channel *);
@ -54,7 +54,9 @@ chm_nonotice_process(hook_data_privmsg_channel *data)
static int
_modinit(void)
{
mode_nonotice = cflag_add('T', CHM_D, chm_simple);
using namespace chan::mode;
mode_nonotice = add('T', category::D, functor::simple);
if (mode_nonotice == 0)
return -1;
@ -64,7 +66,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('T');
chan::mode::orphan('T');
}
DECLARE_MODULE_AV2(chm_nonotice, _modinit, _moddeinit, NULL, NULL, chm_nonotice_hfnlist, NULL, NULL, chm_nonotice_desc);

11
extensions/chm_operonly.cc
View file

@ -1,4 +1,3 @@
using namespace ircd;
static const char chm_operonly_desc[] =
@ -11,12 +10,14 @@ mapi_hfn_list_av1 operonly_hfnlist[] = {
{ NULL, NULL }
};
static unsigned int mymode;
static chan::mode::type mymode;
static int
_modinit(void)
{
mymode = cflag_add('O', CHM_D, chm_staff);
using namespace chan::mode;
mymode = add('O', category::D, functor::staff);
if (mymode == 0)
return -1;
@ -27,7 +28,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('O');
chan::mode::orphan('O');
}
DECLARE_MODULE_AV2(chm_operonly, _modinit, _moddeinit, NULL, NULL, operonly_hfnlist, NULL, NULL, chm_operonly_desc);
@ -40,7 +41,7 @@ h_can_join(hook_data_channel *data)
if((chptr->mode.mode & mymode) && !IsOper(source_p)) {
sendto_one_numeric(source_p, 520, "%s :Cannot join channel (+O) - you are not an IRC operator", chptr->chname);
data->approved = ERR_CUSTOM;
data->approved = chan::mode::ERR_CUSTOM;
}
}

29
extensions/chm_operonly_compat.cc
View file

@ -2,6 +2,7 @@
* Treat cmode +-O as +-iI $o.
*/
using namespace ircd::chan::mode;
using namespace ircd;
static const char chm_operonly_compat[] =
@ -11,16 +12,16 @@ static int _modinit(void);
static void _moddeinit(void);
static void chm_operonly(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type);
const char **parv, int *errors, int dir, char c, type type);
DECLARE_MODULE_AV2(chm_operonly_compat, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, chm_operonly_compat);
static int
_modinit(void)
{
chmode_table['O'].set_func = chm_operonly;
chmode_table['O'].mode_type = 0;
chmode_table['O'].mode_class = ChmClass{CHM_D};
table['O'].type = type(0);
table['O'].category = category::D;
table['O'].set_func = chm_operonly;
return 0;
}
@ -28,25 +29,23 @@ _modinit(void)
static void
_moddeinit(void)
{
chmode_table['O'].set_func = chm_nosuch;
chmode_table['O'].mode_type = 0;
chmode_table['O'].mode_class = ChmClass(0);
table['O'].type = type(0);
table['O'].category = category::D;
table['O'].set_func = functor::nosuch;
}
static void
chm_operonly(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type type)
{
int newparn = 0;
const char *newparv[] = { "$o" };
if (MyClient(source_p)) {
chm_simple(source_p, chptr, alevel, parc, parn, parv,
errors, dir, 'i', MODE_INVITEONLY);
chm_ban(source_p, chptr, alevel, 1, &newparn, newparv,
errors, dir, 'I', CHFL_INVEX);
if (MyClient(source_p))
{
functor::simple(source_p, chptr, alevel, parc, parn, parv, errors, dir, 'i', INVITEONLY);
functor::ban(source_p, chptr, alevel, 1, &newparn, newparv, errors, dir, 'I', INVEX);
} else
chm_nosuch(source_p, chptr, alevel, parc, parn, parv,
errors, dir, c, mode_type);
functor::nosuch(source_p, chptr, alevel, parc, parn, parv, errors, dir, c, type);
}

8
extensions/chm_operpeace.cc
View file

@ -15,12 +15,14 @@ mapi_hfn_list_av1 chm_operpeace_hfnlist[] = {
{ NULL, NULL }
};
static unsigned int mymode;
static chan::mode::type mymode;
static int
_modinit(void)
{
mymode = cflag_add('M', CHM_D, chm_hidden);
using namespace chan::mode;
mymode = add('M', category::D, functor::hidden);
if (mymode == 0)
return -1;
@ -30,7 +32,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('M');
chan::mode::orphan('M');
}
DECLARE_MODULE_AV2(chm_operpeace, _modinit, _moddeinit, NULL, NULL, chm_operpeace_hfnlist, NULL, NULL, chm_operpeace_desc);

25
extensions/chm_quietunreg_compat.cc
View file

@ -3,6 +3,9 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
using namespace mode;
using namespace ircd;
static const char chm_quietunreg_compat_desc[] =
@ -12,16 +15,16 @@ static int _modinit(void);
static void _moddeinit(void);
static void chm_quietunreg(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type);
const char **parv, int *errors, int dir, char c, type type);
DECLARE_MODULE_AV2(chm_quietunreg_compat, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, chm_quietunreg_compat_desc);
static int
_modinit(void)
{
chmode_table['R'].set_func = chm_quietunreg;
chmode_table['R'].mode_type = 0;
chmode_table['R'].mode_class = CHM_D;
table['R'].type = type(0);
table['R'].category = category::D;
table['R'].set_func = chm_quietunreg;
return 0;
}
@ -29,23 +32,21 @@ _modinit(void)
static void
_moddeinit(void)
{
chmode_table['R'].set_func = chm_nosuch;
chmode_table['R'].mode_type = 0;
chmode_table['R'].mode_class = ChmClass(0);
table['R'].type = type(0);
table['R'].category = category(0);
table['R'].set_func = functor::nosuch;
}
static void
chm_quietunreg(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type type)
{
int newparn = 0;
const char *newparv[] = { "$~a" };
if (MyClient(source_p))
chm_ban(source_p, chptr, alevel, 1, &newparn, newparv,
errors, dir, 'q', CHFL_QUIET);
functor::ban(source_p, chptr, alevel, 1, &newparn, newparv, errors, dir, 'q', QUIET);
else
chm_nosuch(source_p, chptr, alevel, parc, parn, parv,
errors, dir, c, mode_type);
functor::nosuch(source_p, chptr, alevel, parc, parn, parv, errors, dir, c, type);
}

6
extensions/chm_spamfilter.cc
View file

@ -108,7 +108,9 @@ struct ConfEntry conf_spamfilter[] =
static
int modinit(void)
{
chm_spamfilter = cflag_add(MODE_SPAMFILTER, CHM_D, chm_simple);
using namespace chan::mode;
chm_spamfilter = add(MODE_SPAMFILTER, category::D, functor::simple);
if(!chm_spamfilter)
return -1;
@ -121,7 +123,7 @@ static
void modfini(void)
{
remove_top_conf("spamfilter");
cflag_orphan(MODE_SPAMFILTER);
chan::mode::orphan(MODE_SPAMFILTER);
}

10
extensions/chm_sslonly.cc
View file

@ -10,12 +10,14 @@ mapi_hfn_list_av1 sslonly_hfnlist[] = {
{ NULL, NULL }
};
static unsigned int mymode;
static chan::mode::type mymode;
static int
_modinit(void)
{
mymode = cflag_add('S', CHM_D, chm_simple);
using namespace chan::mode;
mymode = add('S', category::D, functor::simple);
if (mymode == 0)
return -1;
@ -25,7 +27,7 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('S');
chan::mode::orphan('S');
}
DECLARE_MODULE_AV2(chm_sslonly, _modinit, _moddeinit, NULL, NULL, sslonly_hfnlist, NULL, NULL, chm_sslonly_desc);
@ -39,7 +41,7 @@ h_can_join(hook_data_channel *data)
if((chptr->mode.mode & mymode) && !IsSSLClient(source_p)) {
/* XXX This is equal to ERR_THROTTLE */
sendto_one_numeric(source_p, 480, "%s :Cannot join channel (+S) - SSL/TLS required", chptr->chname);
data->approved = ERR_CUSTOM;
data->approved = chan::mode::ERR_CUSTOM;
}
}

23
extensions/chm_sslonly_compat.cc
View file

@ -2,6 +2,7 @@
* Treat cmode +-S as +-b $~z.
*/
using namespace ircd::chan::mode;
using namespace ircd;
static const char chm_sslonly_compat_desc[] =
@ -11,16 +12,16 @@ static int _modinit(void);
static void _moddeinit(void);
static void chm_sslonly(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type);
const char **parv, int *errors, int dir, char c, type type);
DECLARE_MODULE_AV2(chm_sslonly_compat, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, chm_sslonly_compat_desc);
static int
_modinit(void)
{
chmode_table['S'].set_func = chm_sslonly;
chmode_table['S'].mode_type = 0;
chmode_table['S'].mode_class = ChmClass{CHM_D};
table['S'].type = type(0);
table['S'].set_func = chm_sslonly;
table['S'].category = category::D;
return 0;
}
@ -28,23 +29,21 @@ _modinit(void)
static void
_moddeinit(void)
{
chmode_table['S'].set_func = chm_nosuch;
chmode_table['S'].mode_type = 0;
chmode_table['S'].mode_class = ChmClass(0);
table['S'].type = type(0);
table['S'].category = category(0);
table['S'].set_func = functor::nosuch;
}
static void
chm_sslonly(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type type)
{
int newparn = 0;
const char *newparv[] = { "$~z" };
if (MyClient(source_p))
chm_ban(source_p, chptr, alevel, 1, &newparn, newparv,
errors, dir, 'b', CHFL_BAN);
functor::ban(source_p, chptr, alevel, 1, &newparn, newparv, errors, dir, 'b', BAN);
else
chm_nosuch(source_p, chptr, alevel, parc, parn, parv,
errors, dir, c, mode_type);
functor::nosuch(source_p, chptr, alevel, parc, parn, parv, errors, dir, c, type);
}

16
extensions/extb_account.cc
View file

@ -3,20 +3,23 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Account ($a) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_account(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_account(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_account, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['a'] = eb_account;
ext::table['a'] = eb_account;
return 0;
}
@ -24,17 +27,18 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['a'] = NULL;
ext::table['a'] = NULL;
}
static int eb_account(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
(void)chptr;
/* $a alone matches any logged in user */
if (data == NULL)
return EmptyString(client_p->user->suser) ? EXTBAN_NOMATCH : EXTBAN_MATCH;
return EmptyString(client_p->user->suser) ? NOMATCH : MATCH;
/* $a:MASK matches users logged in under matching account */
return match(data, client_p->user->suser) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return match(data, client_p->user->suser) ? MATCH : NOMATCH;
}

26
extensions/extb_canjoin.cc
View file

@ -4,20 +4,23 @@
* -- nenolod/jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Can join ($j) extban type - matches users who are or are not banned from a specified channel";
static int _modinit(void);
static void _moddeinit(void);
static int eb_canjoin(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_canjoin(const char *data, struct Client *client_p, struct Channel *chptr, mode::type type);
DECLARE_MODULE_AV2(extb_canjoin, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['j'] = eb_canjoin;
ext::table['j'] = eb_canjoin;
return 0;
}
@ -25,38 +28,39 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['j'] = NULL;
ext::table['j'] = NULL;
}
static int eb_canjoin(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
struct Channel *chptr2;
int ret;
static int recurse = 0;
(void)mode_type;
/* don't process a $j in a $j'ed list */
if (recurse)
return EXTBAN_INVALID;
return INVALID;
if (data == NULL)
return EXTBAN_INVALID;
return INVALID;
chptr2 = find_channel(data);
/* must exist, and no point doing this with the same channel */
if (chptr2 == NULL || chptr2 == chptr)
return EXTBAN_INVALID;
return INVALID;
/* require consistent target */
if (chptr->chname[0] == '#' && data[0] == '&')
return EXTBAN_INVALID;
return INVALID;
/* this allows getting some information about ban exceptions
* but +s/+p doesn't seem the right criterion */
#if 0
/* privacy! don't allow +s/+p channels to influence another channel */
if (!PubChannel(chptr2))
return EXTBAN_INVALID;
return INVALID;
#endif
recurse = 1;
ret = is_banned(chptr2, client_p, NULL, NULL, NULL, NULL) == CHFL_BAN ? EXTBAN_MATCH : EXTBAN_NOMATCH;
ret = is_banned(chptr2, client_p, NULL, NULL, NULL, NULL) == CHFL_BAN ? MATCH : NOMATCH;
recurse = 0;
return ret;
}

25
extensions/extb_channel.cc
View file

@ -3,20 +3,23 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Channel ($c) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_channel(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_channel(const char *data, struct Client *client_p, struct Channel *chptr, mode::type type);
DECLARE_MODULE_AV2(extb_channel, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['c'] = eb_channel;
ext::table['c'] = eb_channel;
return 0;
}
@ -24,26 +27,28 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['c'] = NULL;
ext::table['c'] = NULL;
}
static int eb_channel(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
struct Channel *chptr2;
(void)chptr;
(void)mode_type;
if (data == NULL)
return EXTBAN_INVALID;
return INVALID;
chptr2 = find_channel(data);
if (chptr2 == NULL)
return EXTBAN_INVALID;
return INVALID;
/* require consistent target */
if (chptr->chname[0] == '#' && data[0] == '&')
return EXTBAN_INVALID;
return INVALID;
/* privacy! don't allow +s/+p channels to influence another channel */
if (!PubChannel(chptr2) && chptr2 != chptr)
return EXTBAN_INVALID;
return IsMember(client_p, chptr2) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return INVALID;
return IsMember(client_p, chptr2) ? MATCH : NOMATCH;
}

57
extensions/extb_combi.cc
View file

@ -37,19 +37,22 @@
* I suspect it is, but have done no load testing.
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Combination ($&, $|) extban types";
// #define MOD_DEBUG(s) sendto_realops_snomask(SNO_DEBUG, L_NETWIDE, (s))
#define MOD_DEBUG(s)
#define RETURN_INVALID { recursion_depth--; return EXTBAN_INVALID; }
#define RETURN_INVALID { recursion_depth--; return INVALID; }
static int _modinit(void);
static void _moddeinit(void);
static int eb_or(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_and(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_combi(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type, bool is_and);
static int eb_or(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
static int eb_and(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
static int eb_combi(const char *data, struct Client *client_p, struct Channel *chptr, mode::type, bool is_and);
static int recursion_depth = 0;
DECLARE_MODULE_AV2(extb_extended, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
@ -57,8 +60,8 @@ DECLARE_MODULE_AV2(extb_extended, _modinit, _moddeinit, NULL, NULL, NULL, NULL,
static int
_modinit(void)
{
extban_table['&'] = eb_and;
extban_table['|'] = eb_or;
ext::table['&'] = eb_and;
ext::table['|'] = eb_or;
return 0;
}
@ -66,25 +69,27 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['&'] = NULL;
extban_table['|'] = NULL;
ext::table['&'] = NULL;
ext::table['|'] = NULL;
}
static int eb_or(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
return eb_combi(data, client_p, chptr, mode_type, false);
return eb_combi(data, client_p, chptr, type, false);
}
static int eb_and(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
return eb_combi(data, client_p, chptr, mode_type, true);
return eb_combi(data, client_p, chptr, type, true);
}
static int eb_combi(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type, bool is_and)
struct Channel *chptr, mode::type type, bool is_and)
{
using namespace ext;
const char *p, *banend;
bool have_result = false;
int allowed_nodes = 11;
@ -92,12 +97,12 @@ static int eb_combi(const char *data, struct Client *client_p,
if (recursion_depth >= 5) {
MOD_DEBUG("combo invalid: recursion depth too high");
return EXTBAN_INVALID;
return INVALID;
}
if (EmptyString(data)) {
MOD_DEBUG("combo invalid: empty data");
return EXTBAN_INVALID;
return INVALID;
}
datalen = strlen(data);
@ -106,7 +111,7 @@ static int eb_combi(const char *data, struct Client *client_p,
* could overflow the buffer used below, so...
*/
MOD_DEBUG("combo invalid: > BANLEN");
return EXTBAN_INVALID;
return INVALID;
}
banend = data + datalen;
@ -115,7 +120,7 @@ static int eb_combi(const char *data, struct Client *client_p,
banend--;
if (*banend != ')') {
MOD_DEBUG("combo invalid: starting but no closing paren");
return EXTBAN_INVALID;
return INVALID;
}
} else {
p = data;
@ -124,7 +129,7 @@ static int eb_combi(const char *data, struct Client *client_p,
/* Empty combibans are invalid. */
if (banend == p) {
MOD_DEBUG("combo invalid: no data (after removing parens)");
return EXTBAN_INVALID;
return INVALID;
}
/* Implementation note:
@ -142,7 +147,7 @@ static int eb_combi(const char *data, struct Client *client_p,
while (--allowed_nodes) {
bool invert = false;
char *child_data, child_data_buf[BANLEN];
ExtbanFunc f;
ext::func f;
if (*p == '~') {
invert = true;
@ -153,7 +158,7 @@ static int eb_combi(const char *data, struct Client *client_p,
}
}
f = extban_table[(unsigned char) *p++];
f = ext::table[uint8_t(*p++)];
if (!f) {
MOD_DEBUG("combo invalid: non-existant child extban");
RETURN_INVALID;
@ -222,18 +227,18 @@ static int eb_combi(const char *data, struct Client *client_p,
}
if (!have_result) {
int child_result = f(child_data, client_p, chptr, mode_type);
int child_result = f(child_data, client_p, chptr, type);
if (child_result == EXTBAN_INVALID) {
if (child_result == INVALID) {
MOD_DEBUG("combo invalid: child invalid");
RETURN_INVALID;
}
/* Convert child_result to a plain boolean result */
if (invert)
child_result = child_result == EXTBAN_NOMATCH;
child_result = child_result == NOMATCH;
else
child_result = child_result == EXTBAN_MATCH;
child_result = child_result == MATCH;
if (is_and ? !child_result : child_result)
have_result = true;
@ -262,7 +267,7 @@ static int eb_combi(const char *data, struct Client *client_p,
recursion_depth--;
if (is_and)
return have_result ? EXTBAN_NOMATCH : EXTBAN_MATCH;
return have_result ? NOMATCH : MATCH;
else
return have_result ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return have_result ? MATCH : NOMATCH;
}

21
extensions/extb_extgecos.cc
View file

@ -4,20 +4,23 @@
* - nenolod
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Extended mask ($x) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_extended(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_extended(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_extended, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['x'] = eb_extended;
ext::table['x'] = eb_extended;
return 0;
}
@ -25,31 +28,33 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['x'] = NULL;
ext::table['x'] = NULL;
}
static int eb_extended(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
char buf[BUFSIZE];
int ret;
(void)chptr;
if (data == NULL)
return EXTBAN_INVALID;
return INVALID;
snprintf(buf, BUFSIZE, "%s!%s@%s#%s",
client_p->name, client_p->username, client_p->host, client_p->info);
ret = match(data, buf) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
ret = match(data, buf) ? MATCH : NOMATCH;
if (ret == EXTBAN_NOMATCH && IsDynSpoof(client_p))
if (ret == NOMATCH && IsDynSpoof(client_p))
{
snprintf(buf, BUFSIZE, "%s!%s@%s#%s",
client_p->name, client_p->username, client_p->orighost, client_p->info);
ret = match(data, buf) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
ret = match(data, buf) ? MATCH : NOMATCH;
}
return ret;

15
extensions/extb_hostmask.cc
View file

@ -3,32 +3,37 @@
* -- kaniini
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Hostmask ($m) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_hostmask(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_hostmask(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_hostmask, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['m'] = eb_hostmask;
ext::table['m'] = eb_hostmask;
return 0;
}
static void
_moddeinit(void)
{
extban_table['m'] = NULL;
ext::table['m'] = NULL;
}
static int
eb_hostmask(const char *banstr, struct Client *client_p, struct Channel *chptr, long mode_type)
eb_hostmask(const char *banstr, struct Client *client_p, struct Channel *chptr, mode::type type)
{
using namespace ext;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
@ -62,5 +67,5 @@ eb_hostmask(const char *banstr, struct Client *client_p, struct Channel *chptr,
}
#endif
return match(banstr, s) || match(banstr, s2) || (s3 != NULL && match(banstr, s3)) || (s4 != NULL && match(banstr, s4)) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return match(banstr, s) || match(banstr, s2) || (s3 != NULL && match(banstr, s3)) || (s4 != NULL && match(banstr, s4)) ? MATCH : NOMATCH;
}

19
extensions/extb_oper.cc
View file

@ -3,20 +3,23 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Oper ($o) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_oper(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_oper(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_oper, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['o'] = eb_oper;
ext::table['o'] = eb_oper;
return 0;
}
@ -24,25 +27,25 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['o'] = NULL;
ext::table['o'] = NULL;
}
static int eb_oper(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
(void)chptr;
(void)mode_type;
if (data != NULL)
{
struct PrivilegeSet *set = privilegeset_get(data);
if (set != NULL && client_p->localClient->privset == set)
return EXTBAN_MATCH;
return MATCH;
/* $o:admin or whatever */
return HasPrivilege(client_p, data) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return HasPrivilege(client_p, data) ? MATCH : NOMATCH;
}
return IsOper(client_p) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return IsOper(client_p) ? MATCH : NOMATCH;
}

20
extensions/extb_realname.cc
View file

@ -3,20 +3,23 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Realname/GECOS ($r) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_realname(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_realname(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_realname, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['r'] = eb_realname;
ext::table['r'] = eb_realname;
return 0;
}
@ -24,18 +27,19 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['r'] = NULL;
ext::table['r'] = NULL;
}
static int eb_realname(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
(void)chptr;
/* This type is not safe for exceptions */
if (mode_type == CHFL_EXCEPTION || mode_type == CHFL_INVEX)
return EXTBAN_INVALID;
if (type == CHFL_EXCEPTION || type == CHFL_INVEX)
return INVALID;
if (data == NULL)
return EXTBAN_INVALID;
return match(data, client_p->info) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return INVALID;
return match(data, client_p->info) ? MATCH : NOMATCH;
}

20
extensions/extb_server.cc
View file

@ -3,20 +3,23 @@
* -- jilles
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Server ($s) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_server(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_server(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_server, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['s'] = eb_server;
ext::table['s'] = eb_server;
return 0;
}
@ -24,18 +27,19 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['s'] = NULL;
ext::table['s'] = NULL;
}
static int eb_server(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
(void)chptr;
/* This type is not safe for exceptions */
if (mode_type == CHFL_EXCEPTION || mode_type == CHFL_INVEX)
return EXTBAN_INVALID;
if (type == CHFL_EXCEPTION || type == CHFL_INVEX)
return INVALID;
if (data == NULL)
return EXTBAN_INVALID;
return match(data, me.name) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return INVALID;
return match(data, me.name) ? MATCH : NOMATCH;
}

18
extensions/extb_ssl.cc
View file

@ -1,19 +1,22 @@
/* SSL extban type: matches ssl users */
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "SSL/TLS ($z) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_ssl(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_ssl(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_ssl, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['z'] = eb_ssl;
ext::table['z'] = eb_ssl;
return 0;
}
@ -21,16 +24,17 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['z'] = NULL;
ext::table['z'] = NULL;
}
static int eb_ssl(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
(void)chptr;
(void)mode_type;
if (data != NULL)
return EXTBAN_INVALID;
return IsSSLClient(client_p) ? EXTBAN_MATCH : EXTBAN_NOMATCH;
return INVALID;
return IsSSLClient(client_p) ? MATCH : NOMATCH;
}

17
extensions/extb_usermode.cc
View file

@ -3,20 +3,23 @@
* -- nenolod
*/
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ircd;
static const char extb_desc[] = "Usermode ($m) extban type";
static int _modinit(void);
static void _moddeinit(void);
static int eb_usermode(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
static int eb_usermode(const char *data, struct Client *client_p, struct Channel *chptr, mode::type);
DECLARE_MODULE_AV2(extb_usermode, _modinit, _moddeinit, NULL, NULL, NULL, NULL, NULL, extb_desc);
static int
_modinit(void)
{
extban_table['u'] = eb_usermode;
ext::table['u'] = eb_usermode;
return 0;
}
@ -24,12 +27,14 @@ _modinit(void)
static void
_moddeinit(void)
{
extban_table['u'] = NULL;
ext::table['u'] = NULL;
}
static int eb_usermode(const char *data, struct Client *client_p,
struct Channel *chptr, long mode_type)
struct Channel *chptr, mode::type type)
{
using namespace ext;
int dir = MODE_ADD;
unsigned int modes_ack = 0, modes_nak = 0;
const char *p;
@ -38,7 +43,7 @@ static int eb_usermode(const char *data, struct Client *client_p,
/* $m must have a specified mode */
if (data == NULL)
return EXTBAN_INVALID;
return INVALID;
for (p = data; *p != '\0'; p++)
{
@ -67,5 +72,5 @@ static int eb_usermode(const char *data, struct Client *client_p,
return ((client_p->umodes & modes_ack) == modes_ack &&
!(client_p->umodes & modes_nak)) ?
EXTBAN_MATCH : EXTBAN_NOMATCH;
MATCH : NOMATCH;
}

8
extensions/m_roleplay.cc
View file

@ -30,8 +30,10 @@ static unsigned int mymode;
static int
_modinit(void)
{
using namespace chan::mode;
/* initalize the +N cmode */
mymode = cflag_add('N', CHM_D, chm_simple);
mymode = add('N', category::D, functor::simple);
if (mymode == 0)
return -1;
@ -42,7 +44,7 @@ static void
_moddeinit(void)
{
/* orphan the +N cmode on modunload */
cflag_orphan('N');
chan::mode::orphan('N');
}
@ -145,7 +147,7 @@ m_displaymsg(struct MsgBuf *msgbuf_p, struct Client *source_p, const char *chann
return;
}
if(!(chptr->mode.mode & chmode_flags['N']))
if(!(chptr->mode.mode & chan::mode::table['N'].type))
{
sendto_one_numeric(source_p, 573, "%s :Roleplay commands are not enabled on this channel.", chptr->chname);
return;

2
extensions/spamfilter_nicks.cc
View file

@ -344,7 +344,7 @@ void hook_spamfilter_query(hook_data_privmsg_channel *const hook)
static
void hook_channel_join(hook_data_channel_approval *const data)
{
if(~data->chptr->mode.mode & chmode_table[(uint8_t)MODE_SPAMFILTER].mode_type)
if(~data->chptr->mode.mode & chan::mode::table[uint8_t(MODE_SPAMFILTER)].type)
return;
if(!bloom[0])

34
include/ircd/channel.h
View file

@ -40,7 +40,13 @@ namespace ircd {
#define ONLY_CHANOPS CHFL_CHANOP
#define ONLY_CHANOPSVOICED (CHFL_CHANOP|CHFL_VOICE)
/* mode structure for channels */
//TODO: will rm
#define CHFL_BAN 0x10000000 /* ban channel flag */
#define CHFL_EXCEPTION 0x20000000 /* exception to ban channel flag */
#define CHFL_INVEX 0x40000000
#define CHFL_QUIET 0x80000000
// mode structure for channels
struct Mode
{
static constexpr size_t KEYLEN
@ -60,7 +66,7 @@ struct Mode
struct Channel
{
rb_dlink_node node;
struct Mode mode;
Mode mode;
char *mode_lock;
char *topic;
char *topic_info;
@ -116,21 +122,6 @@ struct Ban
rb_dlink_node node;
};
struct mode_letter
{
int mode;
char letter;
};
struct ChModeChange
{
char letter;
const char *arg;
const char *id;
int dir;
int mems;
};
/* can_send results */
#define CAN_SEND_NO 0
#define CAN_SEND_NONOP 1
@ -146,10 +137,11 @@ struct ChModeChange
#define MODE_ADD 1
#define MODE_DEL -1
#define SecretChannel(x) ((x) && ((x)->mode.mode & MODE_SECRET))
#define HiddenChannel(x) ((x) && ((x)->mode.mode & MODE_PRIVATE))
//TODO: will inline
#define SecretChannel(x) ((x) && ((x)->mode.mode & ircd::chan::mode::SECRET))
#define HiddenChannel(x) ((x) && ((x)->mode.mode & ircd::chan::mode::PRIVATE))
#define PubChannel(x) ((!x) || ((x)->mode.mode &\
(MODE_PRIVATE | MODE_SECRET)) == 0)
(ircd::chan::mode::PRIVATE | ircd::chan::mode::SECRET)) == 0)
/* channel visible */
#define ShowChannel(v,c) (PubChannel(c) || IsMember((v),(c)))
@ -212,7 +204,7 @@ extern void init_chcap_usage_counts(void);
extern void set_chcap_usage_counts(struct Client *serv_p);
extern void unset_chcap_usage_counts(struct Client *serv_p);
extern void send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
struct Channel *chptr, struct ChModeChange foo[], int);
struct Channel *chptr, chan::mode::change foo[], int);
void resv_chan_forcepart(const char *name, const char *reason, int temp_time);

177
include/ircd/chmode.h
View file

@ -26,102 +26,121 @@
#pragma once
#define HAVE_IRCD_CHMODE_H
/* something not included in messages.tab
* to change some hooks behaviour when needed
* -- dwr
*/
#define ERR_CUSTOM 1000
/* Maximum mode changes allowed per client, per server is different */
#define MAXMODEPARAMS 4
#define MAXMODEPARAMSSERV 10
#define MODEBUFLEN 200
#ifdef __cplusplus
namespace ircd {
/* Channel mode classification */
typedef enum
{
CHM_A, // Mode has a parameter apropos a list (or no param for xfer)
CHM_B, // Always has a parameter
CHM_C, // Only has a parameter on MODE_ADD
CHM_D, // Never has a parameter
}
ChmClass;
/* Channel mode mask */
#define MODE_PRIVATE 0x00000001
#define MODE_SECRET 0x00000002
#define MODE_MODERATED 0x00000004
#define MODE_TOPICLIMIT 0x00000008
#define MODE_INVITEONLY 0x00000010
#define MODE_NOPRIVMSGS 0x00000020
#define MODE_REGONLY 0x00000040
#define MODE_EXLIMIT 0x00000100 /* exempt from list limits, +b/+e/+I/+q */
#define MODE_PERMANENT 0x00000200 /* permanant channel, +P */
#define MODE_OPMODERATE 0x00000400 /* send rejected messages to ops */
#define MODE_FREEINVITE 0x00000800 /* allow free use of /invite */
#define MODE_FREETARGET 0x00001000 /* can be forwarded to without authorization */
#define MODE_DISFORWARD 0x00002000 /* disable channel forwarding */
#define CHFL_BAN 0x10000000 /* ban channel flag */
#define CHFL_EXCEPTION 0x20000000 /* exception to ban channel flag */
#define CHFL_INVEX 0x40000000
#define CHFL_QUIET 0x80000000
/* extban function results */
#define EXTBAN_INVALID -1 /* invalid mask, false even if negated */
#define EXTBAN_NOMATCH 0 /* valid mask, no match */
#define EXTBAN_MATCH 1 /* matches */
struct Client;
struct Channel;
struct Client;
typedef int (*ExtbanFunc)
(const char *data, struct Client *client_p, struct Channel *chptr, long mode_type);
namespace chan {
namespace mode {
typedef void (*ChmFunc)
(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn, const char **parv, int *errors, int dir, char c, long mode_type);
// Maximum mode changes allowed per client, per server is different
constexpr auto MAXPARAMS = 4;
constexpr auto MAXPARAMSSERV = 10;
constexpr auto BUFLEN = 200;
struct Chm
// something not included in messages.tab to change some hooks behaviour when needed -- dwr
constexpr auto ERR_CUSTOM = 1000;
// Channel mode classification
enum class category
{
ChmFunc set_func;
ChmClass mode_class;
unsigned long mode_type;
A, // Mode has a parameter apropos a list (or no param for xfer)
B, // Always has a parameter
C, // Only has a parameter on MODE_ADD
D, // Never has a parameter
};
enum type : uint
{
PRIVATE = 0x00000001,
SECRET = 0x00000002,
MODERATED = 0x00000004,
TOPICLIMIT = 0x00000008,
INVITEONLY = 0x00000010,
NOPRIVMSGS = 0x00000020,
REGONLY = 0x00000040,
EXLIMIT = 0x00000100, // exempt from list limits, +b/+e/+I/+q
PERMANENT = 0x00000200, // permanant channel, +P
OPMODERATE = 0x00000400, // send rejected messages to ops
FREEINVITE = 0x00000800, // allow free use of /invite
FREETARGET = 0x00001000, // can be forwarded to without authorization
DISFORWARD = 0x00002000, // disable channel forwarding
BAN = 0x10000000,
EXCEPTION = 0x20000000,
INVEX = 0x40000000,
QUIET = 0x80000000,
};
extern struct Chm chmode_table[256];
extern ExtbanFunc extban_table[256];
extern char chmode_arity[2][256];
extern char chmode_class[4][256];
extern int chmode_flags[256];
struct letter
{
enum type type;
char letter;
};
struct change
{
char letter;
const char *arg;
const char *id;
int dir;
int mems;
};
using func = void (*)(Client *, Channel *, int alevel, int parc, int *parn, const char **parv, int *errors, int dir, char c, type type);
struct mode
{
enum type type;
enum category category;
func set_func;
};
extern mode table[256];
extern char arity[2][256];
extern char categories[4][256];
namespace ext
{
// extban function results
enum result
{
INVALID = -1, // invalid mask, false even if negated
NOMATCH = 0, // valid mask, no match
MATCH = 1, // matches
};
using func = int (*)(const char *data, Client *, Channel *, type type);
extern func table[256];
}
#define CHM_FUNCTION(_NAME_) \
void _NAME_(struct Client *source_p, struct Channel *chptr, \
void _NAME_(Client *source_p, Channel *chptr, \
int alevel, int parc, int *parn, const char **parv, \
int *errors, int dir, char c, long mode_type);
int *errors, int dir, char c, type type);
CHM_FUNCTION(chm_nosuch)
CHM_FUNCTION(chm_orphaned)
CHM_FUNCTION(chm_simple)
CHM_FUNCTION(chm_ban)
CHM_FUNCTION(chm_hidden)
CHM_FUNCTION(chm_staff)
CHM_FUNCTION(chm_forward)
CHM_FUNCTION(chm_throttle)
CHM_FUNCTION(chm_key)
CHM_FUNCTION(chm_limit)
CHM_FUNCTION(chm_op)
CHM_FUNCTION(chm_voice)
namespace functor
{
CHM_FUNCTION(nosuch)
CHM_FUNCTION(orphaned)
CHM_FUNCTION(simple)
CHM_FUNCTION(ban)
CHM_FUNCTION(hidden)
CHM_FUNCTION(staff)
CHM_FUNCTION(forward)
CHM_FUNCTION(throttle)
CHM_FUNCTION(key)
CHM_FUNCTION(limit)
CHM_FUNCTION(op)
CHM_FUNCTION(voice)
}
unsigned int cflag_add(const unsigned char c, const ChmClass chmclass, const ChmFunc function);
void cflag_orphan(const unsigned char c);
void chmode_init(void);
type add(const uint8_t &c, const category &category, const func &set_func);
void orphan(const uint8_t &c);
void init(void);
} // namespace mode
} // namespace chan
} // namespace ircd
#endif // __cplusplus

5
include/ircd/stdinc.h
View file

@ -42,13 +42,14 @@ namespace ircd
#include "listener.h"
#include "s_assert.h"
#include "chmode.h"
#include "channel.h"
#include "authproc.h"
#include "bandbi.h"
#include "cache.h"
#include "capability.h"
#include "certfp.h"
#include "channel.h"
#include "chmode.h"
#include "class.h"
#include "client.h"
#include "dns.h"

24
ircd/channel.cc
View file

@ -24,6 +24,8 @@
namespace ircd {
using namespace chan;
struct config_channel_entry ConfigChannel; rb_dlink_list global_channel_list; static rb_bh
*channel_heap; static rb_bh *ban_heap; static rb_bh *topic_heap; static rb_bh *member_heap;
@ -243,7 +245,7 @@ remove_user_from_channel(struct membership *msptr)
if(client_p->servptr == &me)
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
destroy_channel(chptr);
rb_bh_free(member_heap, msptr);
@ -278,7 +280,7 @@ remove_user_from_channels(struct Client *client_p)
if(client_p->servptr == &me)
rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
if(!(chptr->mode.mode & mode::PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
destroy_channel(chptr);
rb_bh_free(member_heap, msptr);
@ -747,7 +749,7 @@ can_join(struct Client *source_p, struct Channel *chptr, const char *key, const
if(forward)
*forward = chptr->mode.forward;
if(chptr->mode.mode & MODE_INVITEONLY)
if(chptr->mode.mode & mode::INVITEONLY)
{
RB_DLINK_FOREACH(invite, source_p->user->invited.head)
{
@ -776,7 +778,7 @@ can_join(struct Client *source_p, struct Channel *chptr, const char *key, const
if(chptr->mode.limit &&
rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
i = ERR_CHANNELISFULL;
if(chptr->mode.mode & MODE_REGONLY && EmptyString(source_p->user->suser))
if(chptr->mode.mode & mode::REGONLY && EmptyString(source_p->user->suser))
i = ERR_NEEDREGGEDNICK;
/* join throttling stuff --nenolod */
else if(chptr->mode.join_num > 0 && chptr->mode.join_time > 0)
@ -836,7 +838,7 @@ can_send(struct Channel *chptr, struct Client *source_p, struct membership *mspt
* they cant send. we dont check bans here because
* theres no possibility of caching them --fl
*/
if(chptr->mode.mode & MODE_NOPRIVMSGS || chptr->mode.mode & MODE_MODERATED)
if(chptr->mode.mode & mode::NOPRIVMSGS || chptr->mode.mode & mode::MODERATED)
moduledata.approved = CAN_SEND_NO;
else
moduledata.approved = CAN_SEND_NONOP;
@ -845,7 +847,7 @@ can_send(struct Channel *chptr, struct Client *source_p, struct membership *mspt
}
}
if(chptr->mode.mode & MODE_MODERATED)
if(chptr->mode.mode & mode::MODERATED)
moduledata.approved = CAN_SEND_NO;
if(MyClient(source_p))
@ -1167,9 +1169,9 @@ channel_modes(struct Channel *chptr, struct Client *client_p)
for (i = 0; i < 256; i++)
{
if(chmode_table[i].set_func == chm_hidden && (!IsOper(client_p) || !IsClient(client_p)))
if(mode::table[i].set_func == mode::functor::hidden && (!IsOper(client_p) || !IsClient(client_p)))
continue;
if(chptr->mode.mode & chmode_flags[i])
if(chptr->mode.mode & mode::table[i].type)
*mbuf++ = i;
}
@ -1231,7 +1233,7 @@ channel_modes(struct Channel *chptr, struct Client *client_p)
*/
void
send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
struct Channel *chptr, struct ChModeChange mode_changes[], int mode_count)
struct Channel *chptr, chan::mode::change mode_changes[], int mode_count)
{
static char modebuf[BUFSIZE];
static char parabuf[BUFSIZE];
@ -1273,7 +1275,7 @@ send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
arglen = strlen(arg);
/* dont even think about it! --fl */
if(arglen > MODEBUFLEN - 5)
if(arglen > mode::BUFLEN - 5)
continue;
}
@ -1284,7 +1286,7 @@ send_cap_mode_changes(struct Client *client_p, struct Client *source_p,
* them as if they were the longest of the nick or uid at all times,
* which even then won't work as we don't always know the uid -A1kmm.
*/
if(arg && ((mc == MAXMODEPARAMSSERV) ||
if(arg && ((mc == mode::MAXPARAMSSERV) ||
((mbl + pbl + arglen + 4) > (BUFSIZE - 3))))
{
if(nc != 0)

255
ircd/chmode.cc
View file

@ -23,7 +23,8 @@
* USA
*/
namespace ircd {
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 */
@ -42,98 +43,99 @@ namespace ircd {
#define MAXMODES_SIMPLE 46 /* a-zA-Z except bqeIov */
static struct ChModeChange mode_changes[BUFSIZE];
static int mode_count;
static int mode_limit;
static int mode_limit_simple;
static int mask_pos;
static int removed_mask_pos;
extern int h_get_channel_access;
static int h_get_channel_access;
mode::change mode_changes[BUFSIZE];
int chmode_flags[256]; // Table of mode flag integers
char chmode_arity[2][256]; // RPL_MYINFO (note that [0] is for 0 OR MORE params)
char chmode_class[4][256]; // RPL_ISUPPORT classification
struct Chm chmode_table[256];
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
static
void chmode_table_init()
#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>chmode_table['X'] = {<sp>handler,<sp>class,<sp>flag<sp>};
// <tab>mode::table['X'] = {<sp>handler,<sp>class,<sp>flag<sp>};
chmode_table['C'] = { 0, CHM_D, 0 };
chmode_table['F'] = { chm_simple, CHM_D, MODE_FREETARGET };
chmode_table['I'] = { chm_ban, CHM_A, CHFL_INVEX };
chmode_table['L'] = { chm_staff, CHM_D, MODE_EXLIMIT };
chmode_table['P'] = { chm_staff, CHM_D, MODE_PERMANENT };
chmode_table['Q'] = { chm_simple, CHM_D, MODE_DISFORWARD };
chmode_table['b'] = { chm_ban, CHM_A, CHFL_BAN };
chmode_table['e'] = { chm_ban, CHM_A, CHFL_EXCEPTION };
chmode_table['f'] = { chm_forward, CHM_C, 0 };
chmode_table['g'] = { chm_simple, CHM_D, MODE_FREEINVITE };
chmode_table['i'] = { chm_simple, CHM_D, MODE_INVITEONLY };
chmode_table['j'] = { chm_throttle, CHM_C, 0 };
chmode_table['k'] = { chm_key, CHM_B, 0 };
chmode_table['l'] = { chm_limit, CHM_C, 0 };
chmode_table['m'] = { chm_simple, CHM_D, MODE_MODERATED };
chmode_table['n'] = { chm_simple, CHM_D, MODE_NOPRIVMSGS };
chmode_table['o'] = { chm_op, CHM_B, 0 };
chmode_table['p'] = { chm_simple, CHM_D, MODE_PRIVATE };
chmode_table['q'] = { chm_ban, CHM_A, CHFL_QUIET };
chmode_table['r'] = { chm_simple, CHM_D, MODE_REGONLY };
chmode_table['s'] = { chm_simple, CHM_D, MODE_SECRET };
chmode_table['t'] = { chm_simple, CHM_D, MODE_TOPICLIMIT };
chmode_table['v'] = { chm_voice, CHM_B, 0 };
chmode_table['z'] = { chm_simple, CHM_D, MODE_OPMODERATE };
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
chmode_init(void)
chan::mode::init()
{
chmode_table_init();
table_init();
/* Reset the state generated by earlier calls to this function */
memset(chmode_flags, '\0', sizeof(chmode_flags));
categories[uint(category::A)][0] = '\0';
categories[uint(category::B)][0] = '\0';
categories[uint(category::C)][0] = '\0';
categories[uint(category::D)][0] = '\0';
chmode_class[CHM_A][0] = '\0';
chmode_class[CHM_B][0] = '\0';
chmode_class[CHM_C][0] = '\0';
chmode_class[CHM_D][0] = '\0';
chmode_arity[0][0] = '\0';
chmode_arity[1][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 |= CHFL_INVEX;
if (!ConfigChannel.use_except) disabled |= CHFL_EXCEPTION;
if (!ConfigChannel.use_forward) disabled |= MODE_FREETARGET | MODE_DISFORWARD;
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(!chmode_table[i].set_func)
if (!table[i].set_func)
{
chmode_table[i].set_func = chm_nosuch;
chmode_table[i].mode_class = CHM_D;
table[i].set_func = functor::nosuch;
table[i].category = category::D;
continue;
}
if(chmode_table[i].mode_type & disabled || chmode_table[i].set_func == chm_nosuch)
if (table[i].type & disabled || table[i].set_func == functor::nosuch)
continue;
const char ch[2] = {char(i), '\0'};
chmode_flags[i] = chmode_table[i].mode_type;
rb_strlcat(chmode_class[chmode_table[i].mode_class], ch, 256);
rb_strlcat(chmode_arity[0], ch, 256);
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-CHM_D mode has parameters, this sets up RPL_MYINFO */
/* Any non-category::D mode has parameters, this sets up RPL_MYINFO */
for (size_t i = 0; i < 3; i++)
rb_strlcat(chmode_arity[1], chmode_class[i], 256);
rb_strlcat(arity[1], categories[i], 256);
}
/*
@ -144,49 +146,55 @@ chmode_init(void)
* 0 if no cflags are available
* side effects - NONE
*/
static unsigned int
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 |= chmode_flags[i];
all_cflags |= table[i].type;
for (my_cflag = 1; my_cflag && (all_cflags & my_cflag);
my_cflag <<= 1);
return my_cflag;
return type(my_cflag);
}
unsigned int
cflag_add(const unsigned char c, const ChmClass mode_class, const ChmFunc function)
mode::type
mode::add(const uint8_t &c,
const category &category,
const func &set_func)
{
if(chmode_table[c].set_func &&
chmode_table[c].set_func != chm_nosuch &&
chmode_table[c].set_func != chm_orphaned)
return 0;
if(table[c].set_func &&
table[c].set_func != functor::nosuch &&
table[c].set_func != functor::orphaned)
return type(0);
if(chmode_table[c].set_func == chm_nosuch)
chmode_table[c].mode_type = find_cflag_slot();
if(table[c].set_func == functor::nosuch)
table[c].type = find_cflag_slot();
if(chmode_table[c].mode_type == 0)
return 0;
if(!table[c].type)
return type(0);
chmode_table[c].set_func = function;
chmode_table[c].mode_class = mode_class;
chmode_init();
table[c].category = category;
table[c].set_func = set_func;
init();
return chmode_table[c].mode_type;
return table[c].type;
}
void
cflag_orphan(const unsigned char c)
mode::orphan(const uint8_t &c)
{
s_assert(chmode_flags[c] != 0);
chmode_table[c].set_func = chm_orphaned;
chmode_init();
s_assert(table[c].type != 0);
table[c].set_func = functor::orphaned;
init();
}
namespace ircd {
int
get_channel_access(struct Client *source_p, struct Channel *chptr, struct membership *msptr, int dir, const char *modestr)
{
@ -264,7 +272,7 @@ add_id(struct Client *source_p, struct Channel *chptr, const char *banid, const
*/
if(MyClient(source_p))
{
if((rb_dlink_list_length(&chptr->banlist) + rb_dlink_list_length(&chptr->exceptlist) + rb_dlink_list_length(&chptr->invexlist) + rb_dlink_list_length(&chptr->quietlist)) >= (unsigned long)(chptr->mode.mode & MODE_EXLIMIT ? ConfigChannel.max_bans_large : ConfigChannel.max_bans))
if((rb_dlink_list_length(&chptr->banlist) + rb_dlink_list_length(&chptr->exceptlist) + rb_dlink_list_length(&chptr->invexlist) + rb_dlink_list_length(&chptr->quietlist)) >= (unsigned long)(chptr->mode.mode & mode::EXLIMIT ? ConfigChannel.max_bans_large : ConfigChannel.max_bans))
{
sendto_one(source_p, form_str(ERR_BANLISTFULL),
me.name, source_p->name, chptr->chname, realban);
@ -301,7 +309,7 @@ add_id(struct Client *source_p, struct Channel *chptr, const char *banid, const
rb_dlinkAdd(actualBan, &actualBan->node, list);
/* invalidate the can_send() cache */
if(mode_type == CHFL_BAN || mode_type == CHFL_QUIET || mode_type == CHFL_EXCEPTION)
if(mode_type == mode::BAN || mode_type == mode::QUIET || mode_type == mode::EXCEPTION)
chptr->bants = rb_current_time();
return true;
@ -331,7 +339,7 @@ del_id(struct Channel *chptr, const char *banid, rb_dlink_list * list, long mode
rb_dlinkDelete(&banptr->node, list);
/* invalidate the can_send() cache */
if(mode_type == CHFL_BAN || mode_type == CHFL_QUIET || mode_type == CHFL_EXCEPTION)
if(mode_type == mode::BAN || mode_type == mode::QUIET || mode_type == mode::EXCEPTION)
chptr->bants = rb_current_time();
return banptr;
@ -523,7 +531,7 @@ check_forward(struct Client *source_p, struct Channel *chptr,
form_str(ERR_NOSUCHCHANNEL), forward);
return false;
}
if(MyClient(source_p) && !(targptr->mode.mode & MODE_FREETARGET))
if(MyClient(source_p) && !(targptr->mode.mode & mode::FREETARGET))
{
if((msptr = find_channel_membership(targptr, source_p)) == NULL ||
get_channel_access(source_p, targptr, msptr, MODE_QUERY, NULL) < CHFL_CHANOP)
@ -587,9 +595,9 @@ fix_key_remote(char *arg)
* The handlers for each specific mode.
*/
void
chm_nosuch(struct Client *source_p, struct Channel *chptr,
mode::functor::nosuch(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(*errors & SM_ERR_UNKNOWN)
return;
@ -598,9 +606,9 @@ chm_nosuch(struct Client *source_p, struct Channel *chptr,
}
void
chm_simple(struct Client *source_p, struct Channel *chptr,
mode::functor::simple(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!allow_mode_change(source_p, chptr, alevel, errors, c))
return;
@ -637,9 +645,9 @@ chm_simple(struct Client *source_p, struct Channel *chptr,
}
void
chm_orphaned(struct Client *source_p, struct Channel *chptr,
mode::functor::orphaned(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(MyClient(source_p))
return;
@ -667,9 +675,9 @@ chm_orphaned(struct Client *source_p, struct Channel *chptr,
}
void
chm_hidden(struct Client *source_p, struct Channel *chptr,
mode::functor::hidden(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!IsOper(source_p) && !IsServer(source_p))
{
@ -714,9 +722,9 @@ chm_hidden(struct Client *source_p, struct Channel *chptr,
}
void
chm_staff(struct Client *source_p, struct Channel *chptr,
mode::functor::staff(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
if(!IsOper(source_p) && !IsServer(source_p))
{
@ -764,9 +772,9 @@ chm_staff(struct Client *source_p, struct Channel *chptr,
}
void
chm_ban(struct Client *source_p, struct Channel *chptr,
mode::functor::ban(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
const char *mask, *raw_mask;
char *forward;
@ -843,8 +851,8 @@ chm_ban(struct Client *source_p, struct Channel *chptr,
/* non-ops cant see +eI lists.. */
/* note that this is still permitted if +e/+I are mlocked. */
if(alevel < CHFL_CHANOP && mode_type != CHFL_BAN &&
mode_type != CHFL_QUIET)
if(alevel < CHFL_CHANOP && mode_type != BAN &&
mode_type != QUIET)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
@ -874,7 +882,7 @@ chm_ban(struct Client *source_p, struct Channel *chptr,
return;
if(MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
if(MyClient(source_p) && (++mode_limit > MAXPARAMS))
return;
raw_mask = parv[(*parn)];
@ -898,7 +906,7 @@ chm_ban(struct Client *source_p, struct Channel *chptr,
* also make sure it will always fit on a line with channel
* name etc.
*/
if(strlen(mask) > MIN(BANLEN, MODEBUFLEN - 5))
if(strlen(mask) > MIN(BANLEN, BUFLEN - 5))
{
sendto_one_numeric(source_p, ERR_INVALIDBAN,
form_str(ERR_INVALIDBAN),
@ -978,7 +986,7 @@ chm_ban(struct Client *source_p, struct Channel *chptr,
else if(dir == MODE_DEL)
{
struct Ban *removed;
static char buf[BANLEN * MAXMODEPARAMS];
static char buf[BANLEN * MAXPARAMS];
int old_removed_mask_pos = removed_mask_pos;
if((removed = del_id(chptr, mask, list, mode_type)) == NULL)
{
@ -1006,9 +1014,9 @@ chm_ban(struct Client *source_p, struct Channel *chptr,
}
void
chm_op(struct Client *source_p, struct Channel *chptr,
mode::functor::op(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
struct membership *mstptr;
const char *opnick;
@ -1046,7 +1054,7 @@ chm_op(struct Client *source_p, struct Channel *chptr,
return;
}
if(MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
if(MyClient(source_p) && (++mode_limit > MAXPARAMS))
return;
if(dir == MODE_ADD)
@ -1082,9 +1090,9 @@ chm_op(struct Client *source_p, struct Channel *chptr,
}
void
chm_voice(struct Client *source_p, struct Channel *chptr,
mode::functor::voice(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
struct membership *mstptr;
const char *opnick;
@ -1122,7 +1130,7 @@ chm_voice(struct Client *source_p, struct Channel *chptr,
return;
}
if(MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
if(MyClient(source_p) && (++mode_limit > MAXPARAMS))
return;
if(dir == MODE_ADD)
@ -1148,9 +1156,9 @@ chm_voice(struct Client *source_p, struct Channel *chptr,
}
void
chm_limit(struct Client *source_p, struct Channel *chptr,
mode::functor::limit(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
const char *lstr;
static char limitstr[30];
@ -1199,9 +1207,9 @@ chm_limit(struct Client *source_p, struct Channel *chptr,
}
void
chm_throttle(struct Client *source_p, struct Channel *chptr,
mode::functor::throttle(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
int joins = 0, timeslice = 0;
@ -1252,9 +1260,9 @@ chm_throttle(struct Client *source_p, struct Channel *chptr,
}
void
chm_forward(struct Client *source_p, struct Channel *chptr,
mode::functor::forward(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
const char *forward;
@ -1328,9 +1336,9 @@ chm_forward(struct Client *source_p, struct Channel *chptr,
}
void
chm_key(struct Client *source_p, struct Channel *chptr,
mode::functor::key(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
const char **parv, int *errors, int dir, char c, type mode_type)
{
char *key;
@ -1405,8 +1413,8 @@ chm_key(struct Client *source_p, struct Channel *chptr,
* Extensively modified to be hotpluggable, 03/09/06 -- nenolod
*/
void
set_channel_mode(struct Client *client_p, struct Client *source_p,
struct Channel *chptr, struct membership *msptr, int parc, const char *parv[])
set_channel_mode(Client *client_p, Client *source_p,
Channel *chptr, membership *msptr, int parc, const char *parv[])
{
static char modebuf[BUFSIZE];
static char parabuf[BUFSIZE];
@ -1420,7 +1428,7 @@ set_channel_mode(struct Client *client_p, struct Client *source_p,
int alevel;
const char *ml = parv[0];
char c;
struct Client *fakesource_p;
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 };
@ -1462,10 +1470,7 @@ set_channel_mode(struct Client *client_p, struct Client *source_p,
dir = MODE_QUERY;
break;
default:
chmode_table[(unsigned char) c].set_func(fakesource_p, chptr, alevel,
parc, &parn, parv,
&errors, dir, c,
chmode_table[(unsigned char) c].mode_type);
mode::table[uint8_t(c)].set_func(fakesource_p, chptr, alevel, parc, &parn, parv, &errors, dir, c, mode::table[uint8_t(c)].type);
break;
}
}
@ -1500,17 +1505,17 @@ set_channel_mode(struct Client *client_p, struct Client *source_p,
{
arglen = strlen(mode_changes[i].arg);
if(arglen > MODEBUFLEN - 5)
if(arglen > mode::BUFLEN - 5)
continue;
}
else
arglen = 0;
/* if we're creeping over MAXMODEPARAMSSERV, or over
/* if we're creeping over mode::MAXPARAMSSERV, or over
* bufsize (4 == +/-,modechar,two spaces) send now.
*/
if(mode_changes[i].arg != NULL &&
((paracount == MAXMODEPARAMSSERV) ||
((paracount == mode::MAXPARAMSSERV) ||
((cur_len + paralen + arglen + 4) > (BUFSIZE - 3))))
{
*mbuf = '\0';

43
ircd/extban.cc
View file

@ -20,16 +20,19 @@
* USA
*/
namespace ircd {
namespace chan = ircd::chan;
namespace mode = chan::mode;
namespace ext = mode::ext;
using namespace ext;
ExtbanFunc extban_table[256] = { NULL };
ext::func ext::table[256] = { NULL };
int
match_extban(const char *banstr, struct Client *client_p, struct Channel *chptr, long mode_type)
ircd::match_extban(const char *banstr, struct Client *client_p, struct Channel *chptr, long mode_type)
{
const char *p;
int invert = 0, result = EXTBAN_INVALID;
ExtbanFunc f;
int invert(0), result(INVALID);
func f;
if (*banstr != '$')
return 0;
@ -39,7 +42,7 @@ match_extban(const char *banstr, struct Client *client_p, struct Channel *chptr,
invert = 1;
p++;
}
f = extban_table[(unsigned char) rfc1459::tolower(*p)];
f = table[uint8_t(rfc1459::tolower(*p))];
if (*p != '\0')
{
p++;
@ -49,29 +52,29 @@ match_extban(const char *banstr, struct Client *client_p, struct Channel *chptr,
p = NULL;
}
if (f != NULL)
result = f(p, client_p, chptr, mode_type);
result = f(p, client_p, chptr, mode::type(mode_type));
else
result = EXTBAN_INVALID;
result = INVALID;
if (invert)
return result == EXTBAN_NOMATCH;
return result == NOMATCH;
else
return result == EXTBAN_MATCH;
return result == MATCH;
}
int
valid_extban(const char *banstr, struct Client *client_p, struct Channel *chptr, long mode_type)
ircd::valid_extban(const char *banstr, struct Client *client_p, struct Channel *chptr, long mode_type)
{
const char *p;
int result = EXTBAN_INVALID;
ExtbanFunc f;
int result(INVALID);
func f;
if (*banstr != '$')
return 0;
p = banstr + 1;
if (*p == '~')
p++;
f = extban_table[(unsigned char) rfc1459::tolower(*p)];
f = table[uint8_t(rfc1459::tolower(*p))];
if (*p != '\0')
{
p++;
@ -81,25 +84,23 @@ valid_extban(const char *banstr, struct Client *client_p, struct Channel *chptr,
p = NULL;
}
if (f != NULL)
result = f(p, client_p, chptr, mode_type);
result = f(p, client_p, chptr, mode::type(mode_type));
else
result = EXTBAN_INVALID;
result = INVALID;
return result != EXTBAN_INVALID;
return result != INVALID;
}
const char *
get_extban_string(void)
ircd::get_extban_string(void)
{
static char e[256];
int i, j;
j = 0;
for (i = 1; i < 256; i++)
if (i == rfc1459::tolower(i) && extban_table[i])
if (i == rfc1459::tolower(i) && table[i])
e[j++] = i;
e[j] = 0;
return e;
}
} // namespace ircd

2
ircd/ircd.cc
View file

@ -635,7 +635,7 @@ charybdis_main(int argc, char * const argv[])
init_reject();
cache::init();
init_monitor();
chmode_init();
chan::mode::init();
init_authd(); /* Start up authd. */
init_dns(); /* Start up DNS query system */

6
ircd/newconf.cc
View file

@ -1866,12 +1866,12 @@ conf_set_channel_autochanmodes(void *data)
break;
default:
if (chmode_table[(unsigned char) *pm].set_func == chm_simple)
if (chan::mode::table[uint8_t(*pm)].set_func == chan::mode::functor::simple)
{
if (what == MODE_ADD)
ConfigChannel.autochanmodes |= chmode_table[(unsigned char) *pm].mode_type;
ConfigChannel.autochanmodes |= chan::mode::table[uint8_t(*pm)].type;
else
ConfigChannel.autochanmodes &= ~chmode_table[(unsigned char) *pm].mode_type;
ConfigChannel.autochanmodes &= ~chan::mode::table[uint8_t(*pm)].type;
}
else
{

4
ircd/s_conf.cc
View file

@ -752,7 +752,7 @@ set_default_conf(void)
ConfigChannel.disable_local_channels = false;
ConfigChannel.displayed_usercount = 3;
ConfigChannel.autochanmodes = MODE_TOPICLIMIT | MODE_NOPRIVMSGS;
ConfigChannel.autochanmodes = chan::mode::TOPICLIMIT | chan::mode::NOPRIVMSGS;
ConfigServerHide.flatten_links = 0;
ConfigServerHide.links_delay = 300;
@ -803,7 +803,7 @@ read_conf(void)
/* Some global values are also loaded here. */
check_class(); /* Make sure classes are valid */
privilegeset_delete_all_illegal();
chmode_init();
chan::mode::init();
}
static void

2
ircd/s_user.cc
View file

@ -1313,7 +1313,7 @@ user_welcome(struct Client *source_p)
sendto_one_numeric(source_p, RPL_YOURHOST, form_str(RPL_YOURHOST),
get_listener_name(source_p->localClient->listener), info::version.c_str());
sendto_one_numeric(source_p, RPL_CREATED, form_str(RPL_CREATED), info::compiled.c_str());
sendto_one_numeric(source_p, RPL_MYINFO, form_str(RPL_MYINFO), me.name, info::version.c_str(), umodebuf, chmode_arity[0], chmode_arity[1]);
sendto_one_numeric(source_p, RPL_MYINFO, form_str(RPL_MYINFO), me.name, info::version.c_str(), umodebuf, chan::mode::arity[0], chan::mode::arity[1]);
show_isupport(source_p);

2
ircd/send.cc
View file

@ -593,7 +593,7 @@ sendto_channel_opmod(struct Client *one, struct Client *source_p,
source_p->name, source_p->username,
source_p->host, command, chptr->chname, text);
if (chptr->mode.mode & MODE_MODERATED)
if (chptr->mode.mode & chan::mode::MODERATED)
rb_linebuf_putmsg(&rb_linebuf_old, NULL, NULL,
":%s %s %s :%s",
use_id(source_p), command, chptr->chname, text);

12
ircd/supported.cc
View file

@ -227,13 +227,15 @@ isupport_umode(const void *ptr)
static const char *
isupport_chanmodes(const void *ptr)
{
using namespace chan::mode;
static char result[80];
snprintf(result, sizeof result, "%s,%s,%s,%s",
chmode_class[CHM_A],
chmode_class[CHM_B],
chmode_class[CHM_C],
chmode_class[CHM_D]);
categories[uint(category::A)],
categories[uint(category::B)],
categories[uint(category::C)],
categories[uint(category::D)]);
return result;
}
@ -302,7 +304,7 @@ isupport_nicklen(const void *ptr)
void
init_isupport(void)
{
static int maxmodes = MAXMODEPARAMS;
static int maxmodes = chan::mode::MAXPARAMS;
static int channellen = LOC_CHANNELLEN;
static int topiclen = TOPICLEN;
static int maxnicklen = NICKLEN - 1;

10
modules/chm_nocolour.cc
View file

@ -27,7 +27,7 @@ static const char chm_nocolour_desc[] =
"Enables channel mode +c that filters colours and formatting from a channel";
static char buf[BUFSIZE];
static unsigned int mode_nocolour;
static chan::mode::type mode_nocolour;
static void chm_nocolour_process(hook_data_privmsg_channel *);
@ -55,7 +55,9 @@ chm_nocolour_process(hook_data_privmsg_channel *data)
static int
_modinit(void)
{
mode_nocolour = cflag_add('c', CHM_D, chm_simple);
using namespace chan::mode;
mode_nocolour = add('c', category::D, functor::simple);
if (mode_nocolour == 0)
return -1;
@ -65,7 +67,9 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('c');
using namespace chan::mode;
orphan('c');
}
DECLARE_MODULE_AV2(chm_nocolour, _modinit, _moddeinit, NULL, NULL, chm_nocolour_hfnlist, NULL, NULL, chm_nocolour_desc);

10
modules/chm_noctcp.cc
View file

@ -26,7 +26,7 @@ using namespace ircd;
static const char chm_noctcp_desc[] =
"Adds channel mode +C, which blocks CTCP messages from a channel (except ACTION)";
static unsigned int mode_noctcp;
static chan::mode::type mode_noctcp;
static void chm_noctcp_process(hook_data_privmsg_channel *);
@ -55,7 +55,9 @@ chm_noctcp_process(hook_data_privmsg_channel *data)
static int
_modinit(void)
{
mode_noctcp = cflag_add('C', CHM_D, chm_simple);
using namespace chan::mode;
mode_noctcp = add('C', category::D, functor::simple);
if (mode_noctcp == 0)
return -1;
@ -65,7 +67,9 @@ _modinit(void)
static void
_moddeinit(void)
{
cflag_orphan('C');
using namespace chan::mode;
orphan('C');
}
DECLARE_MODULE_AV2(chm_noctcp, _modinit, _moddeinit, NULL, NULL, chm_noctcp_hfnlist, NULL, NULL, chm_noctcp_desc);

48
modules/core/m_join.cc
View file

@ -63,9 +63,9 @@ static void remove_our_modes(struct Channel *chptr, struct Client *source_p);
static void remove_ban_list(struct Channel *chptr, struct Client *source_p,
rb_dlink_list * list, char c, int mems);
static char modebuf[MODEBUFLEN];
static char parabuf[MODEBUFLEN];
static const char *para[MAXMODEPARAMS];
static char modebuf[chan::mode::BUFLEN];
static char parabuf[chan::mode::BUFLEN];
static const char *para[chan::mode::MAXPARAMS];
static char *mbuf;
static int pargs;
@ -112,7 +112,7 @@ check_forward(struct Client *source_p, struct Channel *chptr,
if (hash_find_resv(chptr->chname))
return NULL;
/* Don't forward to +Q channel */
if (chptr->mode.mode & MODE_DISFORWARD)
if (chptr->mode.mode & chan::mode::DISFORWARD)
return NULL;
i = can_join(source_p, chptr, key, &next);
@ -249,7 +249,7 @@ m_join(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p
if(moduledata.approved != 0)
{
if(moduledata.approved != ERR_CUSTOM)
if(moduledata.approved != chan::mode::ERR_CUSTOM)
send_join_error(source_p,
moduledata.approved,
name);
@ -297,7 +297,7 @@ m_join(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p
* see extensions/chm_operonly.c for other comments on this
* -- dwr
*/
if(i != ERR_CUSTOM)
if(i != chan::mode::ERR_CUSTOM)
send_join_error(source_p, i, name);
continue;
}
@ -570,10 +570,8 @@ ms_sjoin(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
return;
break;
default:
if(chmode_flags[(int) *s] != 0)
{
mode.mode |= chmode_flags[(int) *s];
}
if(chan::mode::table[uint8_t(*s)].type != 0)
mode.mode |= chan::mode::table[uint8_t(*s)].type;
}
}
@ -625,7 +623,7 @@ ms_sjoin(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
* -- jilles */
if (ConfigChannel.kick_on_split_riding &&
((!HasSentEob(source_p) &&
mode.mode & MODE_INVITEONLY) ||
mode.mode & chan::mode::INVITEONLY) ||
(mode.key[0] != 0 && irccmp(mode.key, oldmode->key) != 0)))
{
struct membership *msptr;
@ -827,10 +825,10 @@ ms_sjoin(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
/* a +ov user.. bleh */
if(fl & CHFL_VOICE)
{
/* its possible the +o has filled up MAXMODEPARAMS, if so, start
/* its possible the +o has filled up chan::mode::MAXPARAMS, if so, start
* a new buffer
*/
if(pargs >= MAXMODEPARAMS)
if(pargs >= chan::mode::MAXPARAMS)
{
*mbuf = '\0';
sendto_channel_local(ALL_MEMBERS, chptr,
@ -854,7 +852,7 @@ ms_sjoin(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
para[pargs++] = target_p->name;
}
if(pargs >= MAXMODEPARAMS)
if(pargs >= chan::mode::MAXPARAMS)
{
*mbuf = '\0';
sendto_channel_local(ALL_MEMBERS, chptr,
@ -899,7 +897,7 @@ ms_sjoin(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
CheckEmpty(para[2]), CheckEmpty(para[3]));
}
if(!joins && !(chptr->mode.mode & MODE_PERMANENT) && isnew)
if(!joins && !(chptr->mode.mode & chan::mode::PERMANENT) && isnew)
{
destroy_channel(chptr);
@ -1024,7 +1022,7 @@ set_final_mode(struct Mode *mode, struct Mode *oldmode)
/* ok, first get a list of modes we need to add */
for (i = 0; i < 256; i++)
{
if((mode->mode & chmode_flags[i]) && !(oldmode->mode & chmode_flags[i]))
if((mode->mode & chan::mode::table[i].type) && !(oldmode->mode & chan::mode::table[i].type))
{
if(dir != MODE_ADD)
{
@ -1038,7 +1036,7 @@ set_final_mode(struct Mode *mode, struct Mode *oldmode)
/* now the ones we need to remove. */
for (i = 0; i < 256; i++)
{
if((oldmode->mode & chmode_flags[i]) && !(mode->mode & chmode_flags[i]))
if((oldmode->mode & chan::mode::table[i].type) && !(mode->mode & chan::mode::table[i].type))
{
if(dir != MODE_DEL)
{
@ -1147,15 +1145,15 @@ remove_our_modes(struct Channel *chptr, struct Client *source_p)
{
struct membership *msptr;
rb_dlink_node *ptr;
char lmodebuf[MODEBUFLEN];
char *lpara[MAXMODEPARAMS];
char lmodebuf[chan::mode::BUFLEN];
char *lpara[chan::mode::MAXPARAMS];
int count = 0;
int i;
mbuf = lmodebuf;
*mbuf++ = '-';
for(i = 0; i < MAXMODEPARAMS; i++)
for(i = 0; i < chan::mode::MAXPARAMS; i++)
lpara[i] = NULL;
RB_DLINK_FOREACH(ptr, chptr->members.head)
@ -1171,7 +1169,7 @@ remove_our_modes(struct Channel *chptr, struct Client *source_p)
/* +ov, might not fit so check. */
if(is_voiced(msptr))
{
if(count >= MAXMODEPARAMS)
if(count >= chan::mode::MAXPARAMS)
{
*mbuf = '\0';
sendto_channel_local(ALL_MEMBERS, chptr,
@ -1185,7 +1183,7 @@ remove_our_modes(struct Channel *chptr, struct Client *source_p)
*mbuf++ = '-';
count = 0;
for(i = 0; i < MAXMODEPARAMS; i++)
for(i = 0; i < chan::mode::MAXPARAMS; i++)
lpara[i] = NULL;
}
@ -1203,7 +1201,7 @@ remove_our_modes(struct Channel *chptr, struct Client *source_p)
else
continue;
if(count >= MAXMODEPARAMS)
if(count >= chan::mode::MAXPARAMS)
{
*mbuf = '\0';
sendto_channel_local(ALL_MEMBERS, chptr,
@ -1214,7 +1212,7 @@ remove_our_modes(struct Channel *chptr, struct Client *source_p)
*mbuf++ = '-';
count = 0;
for(i = 0; i < MAXMODEPARAMS; i++)
for(i = 0; i < chan::mode::MAXPARAMS; i++)
lpara[i] = NULL;
}
}
@ -1265,7 +1263,7 @@ remove_ban_list(struct Channel *chptr, struct Client *source_p,
plen = strlen(banptr->banstr) +
(banptr->forward ? strlen(banptr->forward) + 1 : 0) + 2;
if(count >= MAXMODEPARAMS || (cur_len + plen) > BUFSIZE - 4)
if(count >= chan::mode::MAXPARAMS || (cur_len + plen) > BUFSIZE - 4)
{
/* remove trailing space */
*mbuf = '\0';

8
modules/core/m_message.cc
View file

@ -521,8 +521,8 @@ msg_channel(enum message_type msgtype,
"%s %s :%s", cmdname[msgtype], chptr->chname, text);
}
}
else if(chptr->mode.mode & MODE_OPMODERATE &&
(!(chptr->mode.mode & MODE_NOPRIVMSGS) ||
else if(chptr->mode.mode & chan::mode::OPMODERATE &&
(!(chptr->mode.mode & chan::mode::NOPRIVMSGS) ||
IsMember(source_p, chptr)))
{
if(MyClient(source_p) && !IsOper(source_p) &&
@ -589,8 +589,8 @@ msg_channel_opmod(enum message_type msgtype,
return;
}
if(chptr->mode.mode & MODE_OPMODERATE &&
(!(chptr->mode.mode & MODE_NOPRIVMSGS) ||
if(chptr->mode.mode & chan::mode::OPMODERATE &&
(!(chptr->mode.mode & chan::mode::NOPRIVMSGS) ||
IsMember(source_p, chptr)))
{
if(!flood_attack_channel(msgtype, source_p, chptr, chptr->chname))

6
modules/core/m_mode.cc
View file

@ -345,7 +345,7 @@ ms_bmask(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
tlen = strlen(s);
/* I dont even want to begin parsing this.. */
if(tlen > MODEBUFLEN)
if(tlen > chan::mode::BUFLEN)
break;
if((forward = strchr(s+1, '$')) != NULL)
@ -362,8 +362,8 @@ ms_bmask(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
if(add_id(fakesource_p, chptr, s, forward, banlist, mode_type))
{
/* this new one wont fit.. */
if(mlen + MAXMODEPARAMS + plen + tlen > BUFSIZE - 5 ||
modecount >= MAXMODEPARAMS)
if(mlen + chan::mode::MAXPARAMS + plen + tlen > BUFSIZE - 5 ||
modecount >= chan::mode::MAXPARAMS)
{
*mbuf = '\0';
*(pbuf - 1) = '\0';

6
modules/m_invite.cc
View file

@ -131,7 +131,7 @@ m_invite(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
/* unconditionally require ops, unless the channel is +g */
/* treat remote clients as chanops */
if(MyClient(source_p) && !is_chanop(msptr) &&
!(chptr->mode.mode & MODE_FREEINVITE))
!(chptr->mode.mode & chan::mode::FREEINVITE))
{
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, source_p->name, parv[2]);
@ -141,8 +141,8 @@ m_invite(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source
/* store invites when they could affect the ability to join
* for +l/+j just check if the mode is set, this varies over time
*/
if(chptr->mode.mode & MODE_INVITEONLY ||
(chptr->mode.mode & MODE_REGONLY && EmptyString(target_p->user->suser)) ||
if(chptr->mode.mode & chan::mode::INVITEONLY ||
(chptr->mode.mode & chan::mode::REGONLY && EmptyString(target_p->user->suser)) ||
chptr->mode.limit || chptr->mode.join_num)
store_invite = 1;

4
modules/m_knock.cc
View file

@ -96,7 +96,7 @@ m_knock(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_
return;
}
if(!((chptr->mode.mode & MODE_INVITEONLY) || (*chptr->mode.key) ||
if(!((chptr->mode.mode & chan::mode::INVITEONLY) || (*chptr->mode.key) ||
(chptr->mode.limit &&
rb_dlink_list_length(&chptr->members) >= (unsigned long)chptr->mode.limit)))
{
@ -153,7 +153,7 @@ m_knock(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_
chptr->last_knock = rb_current_time();
if(ConfigChannel.use_knock)
sendto_channel_local(chptr->mode.mode & MODE_FREEINVITE ? ALL_MEMBERS : ONLY_CHANOPS,
sendto_channel_local(chptr->mode.mode & chan::mode::FREEINVITE ? ALL_MEMBERS : ONLY_CHANOPS,
chptr, form_str(RPL_KNOCK),
me.name, name, name, source_p->name,
source_p->username, source_p->host);

2
modules/m_topic.cc
View file

@ -103,7 +103,7 @@ m_topic(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_
return;
}
if(((chptr->mode.mode & MODE_TOPICLIMIT) == 0 ||
if(((chptr->mode.mode & chan::mode::TOPICLIMIT) == 0 ||
get_channel_access(source_p, chptr, msptr, MODE_ADD, NULL) >= CHFL_CHANOP) &&
(!MyClient(source_p) ||
can_send(chptr, source_p, msptr)))