From 4ef511ebb86f3dae6aba795099e3a190bec4e534 Mon Sep 17 00:00:00 2001 From: William Pitcock Date: Thu, 10 Dec 2015 02:20:58 -0600 Subject: [PATCH] import marienz's extb_combi module (ref #74) --- extensions/Makefile.in | 1 + extensions/extb_combi.c | 252 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 253 insertions(+) create mode 100644 extensions/extb_combi.c diff --git a/extensions/Makefile.in b/extensions/Makefile.in index 9196b6f6..f885143f 100644 --- a/extensions/Makefile.in +++ b/extensions/Makefile.in @@ -52,6 +52,7 @@ SRCS = \ extb_realname.c \ extb_usermode.c \ extb_extgecos.c \ + extb_combi.c \ force_user_invis.c \ hurt.c \ ip_cloaking.c \ diff --git a/extensions/extb_combi.c b/extensions/extb_combi.c new file mode 100644 index 00000000..6f3ef8dc --- /dev/null +++ b/extensions/extb_combi.c @@ -0,0 +1,252 @@ +/* + * Extban that combines other extbans. + * + * Basic example: + * $&:~a,m:*!*@gateway/web/cgi-irc* + * Which means: match unidentified webchat users. + * ("m" is another new extban type, which just does a normal match). + * + * More complicated example: + * $&:~a,|:(m:*!*@gateway/web/foo,m:*!*@gateway/web/bar) + * Which means: unidentified and using the foo or bar gateway. + * + * Rules: + * + * - Optional pair of parens around data. + * + * - component bans are separated by commas, but commas between + * matching pairs of parens are skipped. + * + * - Unbalanced parens are an error. + * + * - Parens, commas and backslashes can be escaped by backslashes. + * + * - A backslash before any character other than a paren or backslash + * is just a backslash (backslash and character are both used). + * + * - Non-existant extbans are invalid. + * This is primarily for consistency with non-combined bans: + * the ircd does not let you set +b $f unless the 'f' extban is loaded, + * so setting $&:f should be impossible too. + * + * Issues: + * - Backslashes double inside nested bans. + * Hopefully acceptable because they should be rare. + * + * - Is performance good enough? + * I suspect it is, but have done no load testing. + */ + +#include "stdinc.h" +#include "modules.h" +#include "client.h" +#include "ircd.h" + +// #define DEBUG(s) sendto_realops_snomask(SNO_DEBUG, L_NETWIDE, (s)) +#define DEBUG(s) + +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, int is_and); + + +DECLARE_MODULE_AV1(extb_extended, _modinit, _moddeinit, NULL, NULL, NULL, "$Revision: 1 $"); + +static int +_modinit(void) +{ + extban_table['&'] = eb_and; + extban_table['|'] = eb_or; + + return 0; +} + +static void +_moddeinit(void) +{ + extban_table['&'] = NULL; + extban_table['|'] = NULL; +} + +static int eb_or(const char *data, struct Client *client_p, + struct Channel *chptr, long mode_type) +{ + return eb_combi(data, client_p, chptr, mode_type, FALSE); +} + +static int eb_and(const char *data, struct Client *client_p, + struct Channel *chptr, long mode_type) +{ + return eb_combi(data, client_p, chptr, mode_type, TRUE); +} + +static int eb_combi(const char *data, struct Client *client_p, + struct Channel *chptr, long mode_type, int is_and) +{ + const char *p, *banend; + int have_result = FALSE; + size_t datalen; + + if (EmptyString(data)) { + DEBUG("combo invalid: empty data"); + return EXTBAN_INVALID; + } + + datalen = strlen(data); + if (datalen > BANLEN) { + /* I'd be sad if this ever happened, but if it does we + * could overflow the buffer used below, so... + */ + DEBUG("combo invalid: > BANLEN"); + return EXTBAN_INVALID; + } + banend = data + datalen; + + if (data[0] == '(') { + p = data + 1; + banend--; + if (*banend != ')') { + DEBUG("combo invalid: starting but no closing paren"); + return EXTBAN_INVALID; + } + } else { + p = data; + } + + /* Empty combibans are invalid. */ + if (banend == p) { + DEBUG("combo invalid: no data (after removing parens)"); + return EXTBAN_INVALID; + } + + /* Implementation note: + * I want it to be impossible to set a syntactically invalid combi-ban. + * (mismatched parens). + * That is: valid_extban should return false for those. + * Ideally we do not parse the entire ban when actually matching it: + * we can just short-circuit if we already know the ban is valid. + * Unfortunately there is no separate hook or mode_type for validation, + * so we always keep parsing even after we have determined a result. + */ + + while (TRUE) { + int invert = FALSE; + char *child_data, child_data_buf[BANLEN]; + ExtbanFunc f; + + if (*p == '~') { + invert = TRUE; + p++; + if (p == banend) { + DEBUG("combo invalid: no data after ~"); + return EXTBAN_INVALID; + } + } + + f = extban_table[(unsigned char) *p++]; + if (!f) { + DEBUG("combo invalid: non-existant child extban"); + return EXTBAN_INVALID; + } + + if (*p == ':') { + unsigned int parencount = 0; + int escaped = FALSE, done = FALSE; + char *o; + + p++; + + /* Possible optimization: we can skip the actual copy if + * we already have_result. + */ + o = child_data = child_data_buf; + while (TRUE) { + if (p == banend) { + if (parencount) { + DEBUG("combo invalid: EOD while in parens"); + return EXTBAN_INVALID; + } + break; + } + + if (escaped) { + if (*p != '(' && *p != ')' && *p != '\\' && *p != ',') + *o++ = '\\'; + *o++ = *p++; + escaped = FALSE; + } else { + switch (*p) { + case '\\': + escaped = TRUE; + break; + case '(': + parencount++; + *o++ = *p; + break; + case ')': + if (!parencount) { + DEBUG("combo invalid: negative parencount"); + return EXTBAN_INVALID; + } + parencount--; + *o++ = *p; + break; + case ',': + if (parencount) + *o++ = *p; + else + done = TRUE; + break; + default: + *o++ = *p; + break; + } + if (done) + break; + p++; + } + } + *o = '\0'; + } else { + child_data = NULL; + } + + if (!have_result) { + int child_result = f(child_data, client_p, chptr, mode_type); + + if (child_result == EXTBAN_INVALID) { + DEBUG("combo invalid: child invalid"); + return EXTBAN_INVALID; + } + + /* Convert child_result to a plain boolean result */ + if (invert) + child_result = child_result == EXTBAN_NOMATCH; + else + child_result = child_result == EXTBAN_MATCH; + + if (is_and ? !child_result : child_result) + have_result = TRUE; + } + + if (p == banend) + break; + + if (*p++ != ',') { + DEBUG("combo invalid: no ',' after ban"); + return EXTBAN_INVALID; + } + + if (p == banend) { + DEBUG("combo invalid: banend after ','"); + return EXTBAN_INVALID; + } + } + + if (is_and) + return have_result ? EXTBAN_NOMATCH : EXTBAN_MATCH; + else + return have_result ? EXTBAN_MATCH : EXTBAN_NOMATCH; +}