supernets/unrealircd
supernets
/
unrealircd
mirror of git://git.acid.vegas/unrealircd.git
4
Fork 0
Code Issues Activity
unrealircd/src/modules/chanmodes/history.c

800 lines
22 KiB
C
Raw Blame History

/*
* modules/chanmodes/history - Channel History
* (C) Copyright 2009-2019 Bram Matthys (Syzop) and the UnrealIRCd team
* License: GPLv2 or later
*/
#include "unrealircd.h"
ModuleHeader MOD_HEADER
= {
"chanmodes/history",
"1.0",
"Channel Mode +H",
"UnrealIRCd Team",
"unrealircd-6",
};
typedef struct ConfigHistoryExt ConfigHistoryExt;
struct ConfigHistoryExt {
int lines; /**< number of lines */
long time; /**< seconds */
};
typedef struct cfgstruct cfgstruct;
struct cfgstruct {
ConfigHistoryExt playback_on_join; /**< Maximum number of lines & time to playback on-join */
ConfigHistoryExt max_storage_per_channel_registered; /**< Maximum number of lines & time to record for +r channels*/
ConfigHistoryExt max_storage_per_channel_unregistered; /**< Maximum number of lines & time to record for -r channels */
};
typedef struct HistoryChanMode HistoryChanMode;
struct HistoryChanMode {
unsigned int max_lines; /**< Maximum number of messages to record */
unsigned long max_time; /**< Maximum number of time (in seconds) to record */
};
/* Global variables */
Cmode_t EXTMODE_HISTORY = 0L;
static cfgstruct cfg;
static cfgstruct test;
#define HistoryEnabled(channel) (channel->mode.mode & EXTMODE_HISTORY)
/* Forward declarations */
static void init_config(cfgstruct *cfg);
int history_config_test(ConfigFile *, ConfigEntry *, int, int *);
int history_config_posttest(int *);
int history_config_run(ConfigFile *, ConfigEntry *, int);
int history_chanmode_change(Client *client, Channel *channel, MessageTag *mtags, const char *modebuf, const char *parabuf, time_t sendts, int samode, int *destroy_channel);
static int compare_history_modes(HistoryChanMode *a, HistoryChanMode *b);
int history_chanmode_is_ok(Client *client, Channel *channel, char mode, const char *para, int type, int what);
void *history_chanmode_put_param(void *r_in, const char *param);
const char *history_chanmode_get_param(void *r_in);
const char *history_chanmode_conv_param(const char *param, Client *client, Channel *channel);
int history_chanmode_free_param(void *r, int soft);
void *history_chanmode_dup_struct(void *r_in);
int history_chanmode_sjoin_check(Channel *channel, void *ourx, void *theirx);
int history_channel_destroy(Channel *channel, int *should_destroy);
int history_chanmsg(Client *client, Channel *channel, int sendflags, const char *prefix, const char *target, MessageTag *mtags, const char *text, SendType sendtype);
int history_join(Client *client, Channel *channel, MessageTag *mtags);
CMD_OVERRIDE_FUNC(override_mode);
MOD_TEST()
{
init_config(&test);
HookAdd(modinfo->handle, HOOKTYPE_CONFIGTEST, 0, history_config_test);
HookAdd(modinfo->handle, HOOKTYPE_CONFIGPOSTTEST, 0, history_config_posttest);
return MOD_SUCCESS;
}
MOD_INIT()
{
CmodeInfo creq;
ModDataInfo mreq;
MARK_AS_OFFICIAL_MODULE(modinfo);
memset(&creq, 0, sizeof(creq));
creq.paracount = 1;
creq.is_ok = history_chanmode_is_ok;
creq.letter = 'H';
creq.put_param = history_chanmode_put_param;
creq.get_param = history_chanmode_get_param;
creq.conv_param = history_chanmode_conv_param;
creq.free_param = history_chanmode_free_param;
creq.dup_struct = history_chanmode_dup_struct;
creq.sjoin_check = history_chanmode_sjoin_check;
CmodeAdd(modinfo->handle, creq, &EXTMODE_HISTORY);
init_config(&cfg);
HookAdd(modinfo->handle, HOOKTYPE_CONFIGRUN, 0, history_config_run);
HookAdd(modinfo->handle, HOOKTYPE_LOCAL_CHANMODE, 0, history_chanmode_change);
HookAdd(modinfo->handle, HOOKTYPE_REMOTE_CHANMODE, 0, history_chanmode_change);
HookAdd(modinfo->handle, HOOKTYPE_LOCAL_JOIN, 0, history_join);
HookAdd(modinfo->handle, HOOKTYPE_CHANMSG, 0, history_chanmsg);
HookAdd(modinfo->handle, HOOKTYPE_CHANNEL_DESTROY, 1000000, history_channel_destroy);
return MOD_SUCCESS;
}
MOD_LOAD()
{
CommandOverrideAdd(modinfo->handle, "MODE", 0, override_mode);
CommandOverrideAdd(modinfo->handle, "SVSMODE", 0, override_mode);
CommandOverrideAdd(modinfo->handle, "SVS2MODE", 0, override_mode);
CommandOverrideAdd(modinfo->handle, "SAMODE", 0, override_mode);
CommandOverrideAdd(modinfo->handle, "SJOIN", 0, override_mode);
return MOD_SUCCESS;
}
MOD_UNLOAD()
{
return MOD_SUCCESS;
}
static void init_config(cfgstruct *cfg)
{
/* Set default values */
memset(cfg, 0, sizeof(cfgstruct));
cfg->playback_on_join.lines = 15;
cfg->playback_on_join.time = 86400;
cfg->max_storage_per_channel_unregistered.lines = 200;
cfg->max_storage_per_channel_unregistered.time = 86400*31;
cfg->max_storage_per_channel_registered.lines = 5000;
cfg->max_storage_per_channel_registered.time = 86400*31;
}
int history_config_test(ConfigFile *cf, ConfigEntry *ce, int type, int *errs)
{
int errors = 0;
ConfigEntry *cep, *cepp, *cep4, *cep5;
int on_join_lines=0, maximum_storage_lines_registered=0, maximum_storage_lines_unregistered=0;
long on_join_time=0L, maximum_storage_time_registered=0L, maximum_storage_time_unregistered=0L;
/* We only care about set::history */
if ((type != CONFIG_SET) || strcmp(ce->name, "history"))
return 0;
for (cep = ce->items; cep; cep = cep->next)
{
if (!strcmp(cep->name, "channel"))
{
for (cepp = cep->items; cepp; cepp = cepp->next)
{
if (!strcmp(cepp->name, "playback-on-join"))
{
for (cep4 = cepp->items; cep4; cep4 = cep4->next)
{
if (!strcmp(cep4->name, "lines"))
{
int v;
CheckNull(cep4);
v = atoi(cep4->value);
if ((v < 0) || (v > 1000))
{
config_error("%s:%i: set::history::channel::playback-on-join::lines must be between 0 and 1000. "
"Recommended values are 10-50. Got: %d.",
cep4->file->filename, cep4->line_number, v);
errors++;
continue;
}
test.playback_on_join.lines = v;
} else
if (!strcmp(cep4->name, "time"))
{
long v;
CheckNull(cep4);
v = config_checkval(cep4->value, CFG_TIME);
if (v < 0)
{
config_error("%s:%i: set::history::channel::playback-on-join::time must be zero or more.",
cep4->file->filename, cep4->line_number);
errors++;
continue;
}
test.playback_on_join.time = v;
} else
{
config_error_unknown(cep4->file->filename,
cep4->line_number, "set::history::channel::playback-on-join", cep4->name);
errors++;
}
}
} else
if (!strcmp(cepp->name, "max-storage-per-channel"))
{
for (cep4 = cepp->items; cep4; cep4 = cep4->next)
{
if (!strcmp(cep4->name, "registered"))
{
for (cep5 = cep4->items; cep5; cep5 = cep5->next)
{
if (!strcmp(cep5->name, "lines"))
{
int v;
CheckNull(cep5);
v = atoi(cep5->value);
if (v < 1)
{
config_error("%s:%i: set::history::channel::max-storage-per-channel::registered::lines must be a positive number.",
cep5->file->filename, cep5->line_number);
errors++;
continue;
}
test.max_storage_per_channel_registered.lines = v;
} else
if (!strcmp(cep5->name, "time"))
{
long v;
CheckNull(cep5);
v = config_checkval(cep5->value, CFG_TIME);
if (v < 1)
{
config_error("%s:%i: set::history::channel::max-storage-per-channel::registered::time must be a positive number.",
cep5->file->filename, cep5->line_number);
errors++;
continue;
}
test.max_storage_per_channel_registered.time = v;
} else
{
config_error_unknown(cep5->file->filename,
cep5->line_number, "set::history::channel::max-storage-per-channel::registered", cep5->name);
errors++;
}
}
} else
if (!strcmp(cep4->name, "unregistered"))
{
for (cep5 = cep4->items; cep5; cep5 = cep5->next)
{
if (!strcmp(cep5->name, "lines"))
{
int v;
CheckNull(cep5);
v = atoi(cep5->value);
if (v < 1)
{
config_error("%s:%i: set::history::channel::max-storage-per-channel::unregistered::lines must be a positive number.",
cep5->file->filename, cep5->line_number);
errors++;
continue;
}
test.max_storage_per_channel_unregistered.lines = v;
} else
if (!strcmp(cep5->name, "time"))
{
long v;
CheckNull(cep5);
v = config_checkval(cep5->value, CFG_TIME);
if (v < 1)
{
config_error("%s:%i: set::history::channel::max-storage-per-channel::unregistered::time must be a positive number.",
cep5->file->filename, cep5->line_number);
errors++;
continue;
}
test.max_storage_per_channel_unregistered.time = v;
} else
{
config_error_unknown(cep5->file->filename,
cep5->line_number, "set::history::channel::max-storage-per-channel::unregistered", cep5->name);
errors++;
}
}
} else
{
config_error_unknown(cep->file->filename,
cep->line_number, "set::history::max-storage-per-channel", cep->name);
errors++;
}
}
} else
{
/* hmm.. I don't like this method. but I just quickly copied it from CONFIG_ALLOW for now... */
int used = 0;
Hook *h;
for (h = Hooks[HOOKTYPE_CONFIGTEST]; h; h = h->next)
{
int value, errs = 0;
if (h->owner && !(h->owner->flags & MODFLAG_TESTING)
&& !(h->owner->options & MOD_OPT_PERM))
continue;
value = (*(h->func.intfunc))(cf, cepp, CONFIG_SET_HISTORY_CHANNEL, &errs);
if (value == 2)
used = 1;
if (value == 1)
{
used = 1;
break;
}
if (value == -1)
{
used = 1;
errors += errs;
break;
}
if (value == -2)
{
used = 1;
errors += errs;
}
}
if (!used)
{
config_error_unknown(cepp->file->filename,
cepp->line_number, "set::history::channel", cepp->name);
errors++;
}
}
}
} else {
config_error_unknown(cep->file->filename,
cep->line_number, "set::history", cep->name);
errors++;
}
}
*errs = errors;
return errors ? -1 : 1;
}
int history_config_posttest(int *errs)
{
int errors = 0;
/* We could check here for on join lines / on join time being bigger than max storage but..
* not really important.
*/
*errs = errors;
return errors ? -1 : 1;
}
int history_config_run(ConfigFile *cf, ConfigEntry *ce, int type)
{
ConfigEntry *cep, *cepp, *cep4, *cep5;
if ((type != CONFIG_SET) || strcmp(ce->name, "history"))
return 0;
for (cep = ce->items; cep; cep = cep->next)
{
if (!strcmp(cep->name, "channel"))
{
for (cepp = cep->items; cepp; cepp = cepp->next)
{
if (!strcmp(cepp->name, "playback-on-join"))
{
for (cep4 = cepp->items; cep4; cep4 = cep4->next)
{
if (!strcmp(cep4->name, "lines"))
{
cfg.playback_on_join.lines = atoi(cep4->value);
} else
if (!strcmp(cep4->name, "time"))
{
cfg.playback_on_join.time = config_checkval(cep4->value, CFG_TIME);
}
}
} else
if (!strcmp(cepp->name, "max-storage-per-channel"))
{
for (cep4 = cepp->items; cep4; cep4 = cep4->next)
{
if (!strcmp(cep4->name, "registered"))
{
for (cep5 = cep4->items; cep5; cep5 = cep5->next)
{
if (!strcmp(cep5->name, "lines"))
{
cfg.max_storage_per_channel_registered.lines = atoi(cep5->value);
} else
if (!strcmp(cep5->name, "time"))
{
cfg.max_storage_per_channel_registered.time = config_checkval(cep5->value, CFG_TIME);
}
}
} else
if (!strcmp(cep4->name, "unregistered"))
{
for (cep5 = cep4->items; cep5; cep5 = cep5->next)
{
if (!strcmp(cep5->name, "lines"))
{
cfg.max_storage_per_channel_unregistered.lines = atoi(cep5->value);
} else
if (!strcmp(cep5->name, "time"))
{
cfg.max_storage_per_channel_unregistered.time = config_checkval(cep5->value, CFG_TIME);
}
}
}
}
} else
{
Hook *h;
for (h = Hooks[HOOKTYPE_CONFIGRUN]; h; h = h->next)
{
int value = (*(h->func.intfunc))(cf, cepp, CONFIG_SET_HISTORY_CHANNEL);
if (value == 1)
break;
}
}
}
}
}
return 0; /* Retval 0 = trick so other modules can see the same configuration */
}
/** Helper function for .is_ok(), .conv_param() and .put_param().
* @param param: The mode parameter.
* @param lines: The number of lines (the X in +H X:Y)
* @param t: The time value (the Y in +H X:Y)
*/
int history_parse_chanmode(Channel *channel, const char *param, int *lines, long *t)
{
char buf[64], *p, *q;
char contains_non_digit = 0;
/* Work on a copy */
strlcpy(buf, param, sizeof(buf));
/* Initialize, to be safe */
*lines = 0;
*t = 0;
p = strchr(buf, ':');
if (!p)
return 0;
/* Parse lines */
*p++ = '\0';
*lines = atoi(buf);
/* Parse time value */
/* If it is all digits then it is in minutes */
for (q=p; *q; q++)
{
if (!isdigit(*q))
{
contains_non_digit = 1;
break;
}
}
if (contains_non_digit)
*t = config_checkval(p, CFG_TIME);
else
*t = atoi(p) * 60;
/* Sanity checking... */
if (*lines < 1)
return 0;
if (*t < 60)
return 0;
/* Check imposed configuration limits... */
if (!channel || has_channel_mode(channel, 'r'))
{
if (*lines > cfg.max_storage_per_channel_registered.lines)
*lines = cfg.max_storage_per_channel_registered.lines;
if (*t > cfg.max_storage_per_channel_registered.time)
*t = cfg.max_storage_per_channel_registered.time;
} else {
if (*lines > cfg.max_storage_per_channel_unregistered.lines)
*lines = cfg.max_storage_per_channel_unregistered.lines;
if (*t > cfg.max_storage_per_channel_unregistered.time)
*t = cfg.max_storage_per_channel_unregistered.time;
}
return 1;
}
/** Channel Mode +H check:
* Does the user have rights to add/remove this channel mode?
* Is the supplied mode parameter ok?
*/
int history_chanmode_is_ok(Client *client, Channel *channel, char mode, const char *param, int type, int what)
{
if ((type == EXCHK_ACCESS) || (type == EXCHK_ACCESS_ERR))
{
if (IsUser(client) && check_channel_access(client, channel, "oaq"))
return EX_ALLOW;
if (type == EXCHK_ACCESS_ERR) /* can only be due to being halfop */
sendnumeric(client, ERR_NOTFORHALFOPS, 'H');
return EX_DENY;
} else
if (type == EXCHK_PARAM)
{
int lines = 0;
long t = 0L;
if (!history_parse_chanmode(channel, param, &lines, &t))
{
sendnumeric(client, ERR_CANNOTCHANGECHANMODE, 'H', "Invalid syntax for MODE +H. Use +H lines:period. The period must be in minutes (eg: 10) or a time value (eg: 1h).");
return EX_DENY;
}
/* Don't bother about lines/t limits here, we will auto-convert in .conv_param */
return EX_ALLOW;
}
/* fallthrough -- should not be used */
return EX_DENY;
}
static void history_chanmode_helper(char *buf, size_t bufsize, int lines, long t)
{
if ((t % 86400) == 0)
{
/* Can be represented in full days, eg "1d" */
snprintf(buf, bufsize, "%d:%ldd", lines, t / 86400);
} else
if ((t % 3600) == 0)
{
/* Can be represented in hours, eg "8h" */
snprintf(buf, bufsize, "%d:%ldh", lines, t / 3600);
} else
{
/* Otherwise, stick to minutes */
snprintf(buf, bufsize, "%d:%ldm", lines, t / 60);
}
}
/** Convert channel parameter to something proper.
* NOTE: client may be NULL if called for e.g. set::modes-playback-on-join
*/
const char *history_chanmode_conv_param(const char *param, Client *client, Channel *channel)
{
static char buf[64];
int lines = 0;
long t = 0L;
if (!history_parse_chanmode(channel, param, &lines, &t))
return NULL;
history_chanmode_helper(buf, sizeof(buf), lines, t);
return buf;
}
/** Store the +H x:y channel mode */
void *history_chanmode_put_param(void *mode_in, const char *param)
{
HistoryChanMode *h = (HistoryChanMode *)mode_in;
int lines = 0;
long t = 0L;
if (!history_parse_chanmode(NULL, param, &lines, &t))
return NULL;
if (!h)
{
/* Need to create one */
h = safe_alloc(sizeof(HistoryChanMode));
}
h->max_lines = lines;
h->max_time = t;
return (void *)h;
}
/** Retrieve the +H settings (the X:Y string) */
const char *history_chanmode_get_param(void *h_in)
{
HistoryChanMode *h = (HistoryChanMode *)h_in;
static char buf[64];
if (!h_in)
return NULL;
history_chanmode_helper(buf, sizeof(buf), h->max_lines, h->max_time);
return buf;
}
/** Free channel mode */
int history_chanmode_free_param(void *r, int soft)
{
safe_free(r);
return 0;
}
/** Duplicate the channel mode +H settings */
void *history_chanmode_dup_struct(void *r_in)
{
HistoryChanMode *r = (HistoryChanMode *)r_in;
HistoryChanMode *w = safe_alloc(sizeof(HistoryChanMode));
memcpy(w, r, sizeof(HistoryChanMode));
return (void *)w;
}
/** If two servers with an identical creation time stamp connect,
* we have to deal with merging the settings on different sides
* (if they differ at all). That's what we do here.
*/
int history_chanmode_sjoin_check(Channel *channel, void *ourx, void *theirx)
{
HistoryChanMode *our = (HistoryChanMode *)ourx;
HistoryChanMode *their = (HistoryChanMode *)theirx;
if ((our->max_lines == their->max_lines) && (our->max_time == their->max_time))
return EXSJ_SAME;
our->max_lines = MAX(our->max_lines, their->max_lines);
our->max_time = MAX(our->max_time, their->max_time);
return EXSJ_MERGE;
}
/** On channel mode change, communicate the +H limits to the history backend layer */
int history_chanmode_change(Client *client, Channel *channel, MessageTag *mtags, const char *modebuf, const char *parabuf, time_t sendts, int samode, int *destroy_channel)
{
HistoryChanMode *settings;
/* Did anything change, with regards to channel mode H ? */
if (!strchr(modebuf, 'H'))
return 0;
/* If so, grab the settings, and communicate them */
settings = (HistoryChanMode *)GETPARASTRUCT(channel, 'H');
if (settings)
history_set_limit(channel->name, settings->max_lines, settings->max_time);
else
history_destroy(channel->name);
return 0;
}
/** Channel is destroyed (or is it?) */
int history_channel_destroy(Channel *channel, int *should_destroy)
{
if (*should_destroy == 0)
return 0; /* channel will not be destroyed */
history_destroy(channel->name);
return 0;
}
int history_chanmsg(Client *client, Channel *channel, int sendflags, const char *prefix, const char *target, MessageTag *mtags, const char *text, SendType sendtype)
{
char buf[512];
char source[64];
HistoryChanMode *settings;
if (!HistoryEnabled(channel))
return 0;
/* Filter out CTCP / CTCP REPLY */
if ((*text == '\001') && strncmp(text+1, "ACTION", 6))
return 0;
/* Filter out TAGMSG */
if (sendtype == SEND_TYPE_TAGMSG)
return 0;
/* Lazy: if any prefix is addressed (eg: @#channel) then don't record it.
* This so we don't have to check privileges during history playback etc.
*/
if (prefix)
return 0;
if (IsUser(client))
snprintf(source, sizeof(source), "%s!%s@%s", client->name, client->user->username, GetHost(client));
else
strlcpy(source, client->name, sizeof(source));
snprintf(buf, sizeof(buf), ":%s %s %s :%s",
source,
sendtype_to_cmd(sendtype),
channel->name,
text);
history_add(channel->name, mtags, buf);
return 0;
}
int history_join(Client *client, Channel *channel, MessageTag *mtags)
{
/* Only for +H channels */
if (!HistoryEnabled(channel) || !cfg.playback_on_join.lines || !cfg.playback_on_join.time)
return 0;
/* No history-on-join for clients that implement CHATHISTORY,
* they will pull history themselves if they need it.
*/
if (HasCapability(client, "draft/chathistory") /*|| HasCapability(client, "chathistory")*/)
return 0;
if (MyUser(client) && can_receive_history(client))
{
HistoryFilter filter;
HistoryResult *r;
memset(&filter, 0, sizeof(filter));
filter.cmd = HFC_SIMPLE;
filter.last_lines = cfg.playback_on_join.lines;
filter.last_seconds = cfg.playback_on_join.time;
r = history_request(channel->name, &filter);
if (r)
{
history_send_result(client, r);
free_history_result(r);
}
}
return 0;
}
/** Check if a channel went from +r to -r and adjust +H if needed.
* This does not only override "MODE" but also "SAMODE", "SJOIN" and more.
*/
CMD_OVERRIDE_FUNC(override_mode)
{
Channel *channel;
int had_r = 0;
/* We only bother checking for this corner case if the -r
* comes from a server directly linked to us, this normally
* means: we are the server that services are linked to.
*/
if ((IsServer(client) && client->local) ||
(IsUser(client) && client->uplink && client->uplink->local))
{
/* Now check if the channel is currently +r */
if ((parc >= 2) && !BadPtr(parv[1]) && ((channel = find_channel(parv[1]))) &&
has_channel_mode(channel, 'r'))
{
had_r = 1;
}
}
CALL_NEXT_COMMAND_OVERRIDE();
/* If..
* - channel was +r
* - re-lookup the channel and check that it still
* exists (as it may have been destroyed)
* - and is now -r
* - and has +H set
* then...
*/
if (had_r &&
((channel = find_channel(parv[1]))) &&
!has_channel_mode(channel, 'r') &&
HistoryEnabled(channel))
{
/* Check if limit is higher than allowed for unregistered channels */
HistoryChanMode *settings = (HistoryChanMode *)GETPARASTRUCT(channel, 'H');
int changed = 0;
if (!settings)
return; /* Weird */
if (settings->max_lines > cfg.max_storage_per_channel_unregistered.lines)
{
settings->max_lines = cfg.max_storage_per_channel_unregistered.lines;
changed = 1;
}
if (settings->max_time > cfg.max_storage_per_channel_unregistered.time)
{
settings->max_time = cfg.max_storage_per_channel_unregistered.time;
changed = 1;
}
if (changed)
{
MessageTag *mtags = NULL;
const char *params = history_chanmode_get_param(settings);
char modebuf[BUFSIZE], parabuf[BUFSIZE];
int destroy_channel = 0;
if (!params)
return; /* Weird */
strlcpy(modebuf, "+H", sizeof(modebuf));
strlcpy(parabuf, params, sizeof(modebuf));
new_message(&me, NULL, &mtags);
sendto_channel(channel, &me, &me, 0, 0, SEND_LOCAL, mtags,
":%s MODE %s %s %s",
me.name, channel->name, modebuf, parabuf);
sendto_server(NULL, 0, 0, mtags, ":%s MODE %s %s %s %lld",
me.id, channel->name, modebuf, parabuf,
(long long)channel->creationtime);
/* Activate this hook just like cmd_mode.c */
RunHook(HOOKTYPE_REMOTE_CHANMODE, &me, channel, mtags, modebuf, parabuf, 0, 0, &destroy_channel);
free_message_tags(mtags);
*modebuf = *parabuf = '\0';
}
}
}
Reference in New Issue View Git Blame Copy Permalink