/* chanserv.c - Channel service bot
- * Copyright 2000-2004 srvx Development Team
+ * Copyright 2000-2006 srvx Development Team
*
* This file is part of srvx.
*
#define KEY_ADJUST_DELAY "adjust_delay"
#define KEY_CHAN_EXPIRE_FREQ "chan_expire_freq"
#define KEY_CHAN_EXPIRE_DELAY "chan_expire_delay"
+#define KEY_DNR_EXPIRE_FREQ "dnr_expire_freq"
#define KEY_MAX_CHAN_USERS "max_chan_users"
#define KEY_MAX_CHAN_BANS "max_chan_bans"
#define KEY_NICK "nick"
#define KEY_EXPIRES "expires"
#define KEY_TRIGGERED "triggered"
-#define CHANNEL_DEFAULT_FLAGS (CHANNEL_OFFCHANNEL)
+#define CHANNEL_DEFAULT_FLAGS (CHANNEL_OFFCHANNEL | CHANNEL_UNREVIEWED)
+#define CHANNEL_PRESERVED_FLAGS (CHANNEL_UNREVIEWED)
#define CHANNEL_DEFAULT_OPTIONS "lmoooanpcnat"
/* Administrative messages */
{ "CSMSG_DNR_SEARCH_RESULTS", "The following do-not-registers were found:" },
{ "CSMSG_DNR_INFO", "$b%s$b is do-not-register (by $b%s$b): %s" },
{ "CSMSG_DNR_INFO_SET", "$b%s$b is do-not-register (set %s by $b%s$b): %s" },
+ { "CSMSG_DNR_INFO_SET_EXPIRES", "$b%s$b is do-not-register (set %s by $b%s$b; expires %s): %s" },
{ "CSMSG_MORE_DNRS", "%d more do-not-register entries skipped." },
{ "CSMSG_DNR_CHANNEL", "Only network staff may register $b%s$b." },
{ "CSMSG_DNR_CHANNEL_MOVE", "Only network staff may move $b%s$b." },
{ "CSMSG_NOREGISTER_CHANNEL", "$b%s$b has been added to the do-not-register list." },
{ "CSMSG_NO_SUCH_DNR", "$b%s$b is not in the do-not-register list." },
{ "CSMSG_DNR_REMOVED", "$b%s$b has been removed from the do-not-register list." },
+ { "CSMSG_DNR_BAD_ACTION", "$b%s$b is not a recognized do-not-register action." },
+ { "CSMSG_DNR_SEARCH_RESULTS", "The following do-not-registers were found:" },
/* Channel unregistration */
{ "CSMSG_UNREG_SUCCESS", "$b%s$b has been unregistered." },
{ "CSMSG_MULTIPLE_OWNERS", "There is more than one owner in %s; please use $bCLVL$b, $bDELOWNER$b and/or $bADDOWNER$b instead." },
{ "CSMSG_TRANSFER_WAIT", "You must wait %s before you can give ownership of $b%s$b to someone else." },
{ "CSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
+ { "CSMSG_CONFIRM_GIVEOWNERSHIP", "To really give ownership to $b%1$s$b, you must use 'giveownership *%1$s %2$s'." },
{ "CSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
/* Ban management */
{ "CSMSG_TOPIC_SET", "Topic is now '%s'." },
{ "CSMSG_NO_TOPIC", "$b%s$b does not have a default topic." },
{ "CSMSG_TOPICMASK_CONFLICT1", "I do not know how to make that topic work with the current topic mask in $b%s$b, which is: %s" },
- { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic at most %d characters and matches the topic mask pattern." },
+ { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic is at most %d characters and matches the topic mask pattern." },
{ "CSMSG_TOPIC_LOCKED", "The %s topic is locked." },
{ "CSMSG_MASK_BUT_NO_TOPIC", "Warning: $b%s$b does not have a default topic, but you just set the topic mask." },
{ "CSMSG_TOPIC_MISMATCH", "Warning: The default topic for $b%s$b does not match the topic mask; changing it anyway." },
{ "CSMSG_SET_TOYS", "$bToys $b %d - %s" },
{ "CSMSG_SET_CTCPREACTION", "$bCTCPReaction$b %d - %s" },
{ "CSMSG_SET_TOPICREFRESH", "$bTopicRefresh$b %d - %s" },
+ { "CSMSG_SET_UNREVIEWED", "$bUnreviewed $b %s" },
{ "CSMSG_USET_NOAUTOOP", "$bNoAutoOp $b %s" },
{ "CSMSG_USET_NOAUTOVOICE", "$bNoAutoVoice $b %s" },
{ "CSMSG_USET_AUTOINVITE", "$bAutoInvite $b %s" },
{ "CSMSG_HELPER_HAS_ACCESS", "%s has access $b%d$b in %s and has $bsecurity override$b enabled." },
{ "CSMSG_LAZY_SMURF_TARGET", "%s is %s ($bIRCOp$b; not logged in)." },
{ "CSMSG_SMURF_TARGET", "%s is %s ($b%s$b)." },
+ { "CSMSG_OPERATOR_TITLE", "IRC operator" },
+ { "CSMSG_UC_H_TITLE", "network helper" },
+ { "CSMSG_LC_H_TITLE", "support helper" },
{ "CSMSG_LAME_SMURF_TARGET", "%s is an IRC operator." },
/* Seen information */
/* Channel configuration */
{ "CSMSG_INVALID_OPTION", "$b%s$b is not a valid %s option." },
+ { "CSMSG_INVALID_CFLAG", "$b%s$b is not a recognized channel flag." },
{ "CSMSG_CHANNEL_OPTIONS", "Channel Options:" },
{ "CSMSG_GREETING_TOO_LONG", "Your greeting ($b%d$b characters) must be shorter than $b%d$b characters." },
unsigned long db_backup_frequency;
unsigned long channel_expire_frequency;
+ unsigned long dnr_expire_frequency;
long info_delay;
unsigned int adjust_delay;
}
static void
-chanserv_ctcp_check(struct userNode *user, struct chanNode *channel, char *text, UNUSED_ARG(struct userNode *bot))
+chanserv_ctcp_check(struct userNode *user, struct chanNode *channel, const char *text, UNUSED_ARG(struct userNode *bot))
{
unsigned int eflags, argc;
char *argv[4];
return;
/* We need to enforce against them; do so. */
eflags = 0;
- argv[0] = text;
+ argv[0] = (char*)text;
argv[1] = user->nick;
argc = 2;
if(GetUserMode(channel, user))
timeq_add(now + chanserv_conf.channel_expire_frequency, expire_channels, NULL);
}
+static void
+expire_dnrs(UNUSED_ARG(void *data))
+{
+ dict_iterator_t it;
+ struct do_not_register *dnr;
+
+ for(it = dict_first(handle_dnrs); it; it = iter_next(it))
+ {
+ dnr = iter_data(it);
+ if(!dnr->expires || dnr->expires > now)
+ continue;
+ dict_remove(handle_dnrs, dnr->chan_name + 1);
+ }
+ for(it = dict_first(plain_dnrs); it; it = iter_next(it))
+ {
+ dnr = iter_data(it);
+ if(!dnr->expires || dnr->expires > now)
+ continue;
+ dict_remove(plain_dnrs, dnr->chan_name);
+ }
+ for(it = dict_first(mask_dnrs); it; it = iter_next(it))
+ {
+ dnr = iter_data(it);
+ if(!dnr->expires || dnr->expires > now)
+ continue;
+ dict_remove(mask_dnrs, dnr->chan_name);
+ }
+
+ if(chanserv_conf.dnr_expire_frequency)
+ timeq_add(now + chanserv_conf.dnr_expire_frequency, expire_dnrs, NULL);
+}
+
static int
protect_user(const struct userNode *victim, const struct userNode *aggressor, struct chanData *channel)
{
}
static struct do_not_register *
-chanserv_add_dnr(const char *chan_name, const char *setter, const char *reason)
+chanserv_add_dnr(const char *chan_name, const char *setter, time_t expires, const char *reason)
{
struct do_not_register *dnr = calloc(1, sizeof(*dnr)+strlen(reason));
safestrncpy(dnr->chan_name, chan_name, sizeof(dnr->chan_name));
safestrncpy(dnr->setter, setter, sizeof(dnr->setter));
strcpy(dnr->reason, reason);
dnr->set = now;
+ dnr->expires = expires;
if(dnr->chan_name[0] == '*')
dict_insert(handle_dnrs, dnr->chan_name+1, dnr);
else if(strpbrk(dnr->chan_name, "*?"))
}
static struct dnrList
-chanserv_find_dnrs(const char *chan_name, const char *handle)
+chanserv_find_dnrs(const char *chan_name, const char *handle, unsigned int max)
{
struct dnrList list;
- dict_iterator_t it;
+ dict_iterator_t it, next;
struct do_not_register *dnr;
dnrList_init(&list);
+
if(handle && (dnr = dict_find(handle_dnrs, handle, NULL)))
- dnrList_append(&list, dnr);
+ {
+ if(dnr->expires && dnr->expires <= now)
+ dict_remove(handle_dnrs, handle);
+ else if(list.used < max)
+ dnrList_append(&list, dnr);
+ }
+
if(chan_name && (dnr = dict_find(plain_dnrs, chan_name, NULL)))
- dnrList_append(&list, dnr);
+ {
+ if(dnr->expires && dnr->expires <= now)
+ dict_remove(plain_dnrs, chan_name);
+ else if(list.used < max)
+ dnrList_append(&list, dnr);
+ }
+
if(chan_name)
- for(it = dict_first(mask_dnrs); it; it = iter_next(it))
- if(match_ircglob(chan_name, iter_key(it)))
- dnrList_append(&list, iter_data(it));
+ {
+ for(it = dict_first(mask_dnrs); it && list.used < max; it = next)
+ {
+ next = iter_next(it);
+ if(!match_ircglob(chan_name, iter_key(it)))
+ continue;
+ dnr = iter_data(it);
+ if(dnr->expires && dnr->expires <= now)
+ dict_remove(mask_dnrs, iter_key(it));
+ else
+ dnrList_append(&list, dnr);
+ }
+ }
+
return list;
}
+static int dnr_print_func(struct do_not_register *dnr, void *extra)
+{
+ struct userNode *user;
+ char buf1[INTERVALLEN];
+ char buf2[INTERVALLEN];
+
+ user = extra;
+ if(dnr->set)
+ strftime(buf1, sizeof(buf1), "%d %b %Y", localtime(&dnr->set));
+ if(dnr->expires)
+ {
+ strftime(buf2, sizeof(buf2), "%d %b %Y", localtime(&dnr->expires));
+ send_message(user, chanserv, "CSMSG_DNR_INFO_SET_EXPIRES", dnr->chan_name, buf1, dnr->setter, buf2, dnr->reason);
+ }
+ else if(dnr->set)
+ {
+ send_message(user, chanserv, "CSMSG_DNR_INFO_SET", dnr->chan_name, buf1, dnr->setter, dnr->reason);
+ }
+ else
+ send_message(user, chanserv, "CSMSG_DNR_INFO", dnr->chan_name, dnr->setter, dnr->reason);
+ return 0;
+}
+
static unsigned int
chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_name, const char *handle)
{
struct dnrList list;
- struct do_not_register *dnr;
unsigned int ii;
- char buf[INTERVALLEN];
- list = chanserv_find_dnrs(chan_name, handle);
+ list = chanserv_find_dnrs(chan_name, handle, UINT_MAX);
for(ii = 0; (ii < list.used) && (ii < 10); ++ii)
- {
- dnr = list.list[ii];
- if(dnr->set)
- {
- strftime(buf, sizeof(buf), "%Y %b %d", localtime(&dnr->set));
- reply("CSMSG_DNR_INFO_SET", dnr->chan_name, buf, dnr->setter, dnr->reason);
- }
- else
- reply("CSMSG_DNR_INFO", dnr->chan_name, dnr->setter, dnr->reason);
- }
+ dnr_print_func(list.list[ii], user);
if(ii < list.used)
reply("CSMSG_MORE_DNRS", list.used - ii);
free(list.list);
struct do_not_register *
chanserv_is_dnr(const char *chan_name, struct handle_info *handle)
{
+ struct dnrList list;
struct do_not_register *dnr;
- dict_iterator_t it;
- if(handle && (dnr = dict_find(handle_dnrs, handle->handle, NULL)))
- return dnr;
- if(chan_name)
+ list = chanserv_find_dnrs(chan_name, handle ? handle->handle : NULL, 1);
+ dnr = list.used ? list.list[0] : NULL;
+ free(list.list);
+ return dnr;
+}
+
+static unsigned int send_dnrs(struct userNode *user, dict_t dict)
+{
+ struct do_not_register *dnr;
+ dict_iterator_t it, next;
+ unsigned int matches = 0;
+
+ for(it = dict_first(dict); it; it = next)
{
- if((dnr = dict_find(plain_dnrs, chan_name, NULL)))
- return dnr;
- for(it = dict_first(mask_dnrs); it; it = iter_next(it))
- if(match_ircglob(chan_name, iter_key(it)))
- return iter_data(it);
+ dnr = iter_data(it);
+ next = iter_next(it);
+ if(dnr->expires && dnr->expires <= now)
+ {
+ dict_remove(dict, iter_key(it));
+ continue;
+ }
+ dnr_print_func(dnr, user);
+ matches++;
}
- return NULL;
+
+ return matches;
}
static CHANSERV_FUNC(cmd_noregister)
{
const char *target;
- struct do_not_register *dnr;
- char buf[INTERVALLEN];
+ time_t expiry, duration;
unsigned int matches;
if(argc < 2)
{
- dict_iterator_t it;
-
reply("CSMSG_DNR_SEARCH_RESULTS");
- matches = 0;
- for(it = dict_first(handle_dnrs); it; it = iter_next(it))
- {
- dnr = iter_data(it);
- if(dnr->set)
- reply("CSMSG_DNR_INFO_SET", dnr->chan_name, intervalString(buf, now - dnr->set, user->handle_info), dnr->setter, dnr->reason);
- else
- reply("CSMSG_DNR_INFO", dnr->chan_name, dnr->setter, dnr->reason);
- matches++;
- }
- for(it = dict_first(plain_dnrs); it; it = iter_next(it))
- {
- dnr = iter_data(it);
- if(dnr->set)
- reply("CSMSG_DNR_INFO_SET", dnr->chan_name, intervalString(buf, now - dnr->set, user->handle_info), dnr->setter, dnr->reason);
- else
- reply("CSMSG_DNR_INFO", dnr->chan_name, dnr->setter, dnr->reason);
- matches++;
- }
- for(it = dict_first(mask_dnrs); it; it = iter_next(it))
- {
- dnr = iter_data(it);
- if(dnr->set)
- reply("CSMSG_DNR_INFO_SET", dnr->chan_name, intervalString(buf, now - dnr->set, user->handle_info), dnr->setter, dnr->reason);
- else
- reply("CSMSG_DNR_INFO", dnr->chan_name, dnr->setter, dnr->reason);
- matches++;
- }
-
+ matches = send_dnrs(user, handle_dnrs);
+ matches += send_dnrs(user, plain_dnrs);
+ matches += send_dnrs(user, mask_dnrs);
if(matches)
reply("MSG_MATCH_COUNT", matches);
else
if(argc > 2)
{
- const char *reason = unsplit_string(argv + 2, argc - 2, NULL);
+ if(argc == 3)
+ {
+ reply("MSG_INVALID_DURATION", argv[2]);
+ return 0;
+ }
+
+ if(!strcmp(argv[2], "0"))
+ expiry = 0;
+ else if((duration = ParseInterval(argv[2])))
+ expiry = now + duration;
+ else
+ {
+ reply("MSG_INVALID_DURATION", argv[2]);
+ return 0;
+ }
+
+ const char *reason = unsplit_string(argv + 3, argc - 3, NULL);
if((*target == '*') && !get_handle_info(target + 1))
{
reply("MSG_HANDLE_UNKNOWN", target + 1);
return 0;
}
- chanserv_add_dnr(target, user->handle_info->handle, reason);
+ chanserv_add_dnr(target, user->handle_info->handle, expiry, reason);
reply("CSMSG_NOREGISTER_CHANNEL", target);
return 1;
}
{
const char *chan_name = argv[1];
- if((chan_name[0] == '*') && dict_find(handle_dnrs, chan_name+1, NULL))
+ if(((chan_name[0] == '*') && dict_remove(handle_dnrs, chan_name+1))
+ || dict_remove(plain_dnrs, chan_name)
+ || dict_remove(mask_dnrs, chan_name))
{
- dict_remove(handle_dnrs, chan_name+1);
reply("CSMSG_DNR_REMOVED", chan_name);
+ return 1;
}
- else if(dict_find(plain_dnrs, chan_name, NULL))
+ reply("CSMSG_NO_SUCH_DNR", chan_name);
+ return 0;
+}
+
+struct dnr_search {
+ struct userNode *source;
+ char *chan_mask;
+ char *setter_mask;
+ char *reason_mask;
+ time_t min_set, max_set;
+ time_t min_expires, max_expires;
+ unsigned int limit;
+};
+
+static int
+dnr_search_matches(const struct do_not_register *dnr, const struct dnr_search *search)
+{
+ return !((dnr->set < search->min_set)
+ || (dnr->set > search->max_set)
+ || (dnr->expires && ((dnr->expires < search->min_expires)
+ || (dnr->expires > search->max_expires)))
+ || (search->chan_mask
+ && !match_ircglob(dnr->chan_name, search->chan_mask))
+ || (search->setter_mask
+ && !match_ircglob(dnr->setter, search->setter_mask))
+ || (search->reason_mask
+ && !match_ircglob(dnr->reason, search->reason_mask)));
+}
+
+static struct dnr_search *
+dnr_search_create(struct userNode *user, struct svccmd *cmd, unsigned int argc, char *argv[])
+{
+ struct dnr_search *discrim;
+ unsigned int ii;
+
+ discrim = calloc(1, sizeof(*discrim));
+ discrim->source = user;
+ discrim->chan_mask = NULL;
+ discrim->setter_mask = NULL;
+ discrim->reason_mask = NULL;
+ discrim->max_set = INT_MAX;
+ discrim->max_expires = INT_MAX;
+ discrim->limit = 50;
+
+ for(ii=0; ii<argc; ++ii)
{
- dict_remove(plain_dnrs, chan_name);
- reply("CSMSG_DNR_REMOVED", chan_name);
+ if(ii == argc - 1)
+ {
+ reply("MSG_MISSING_PARAMS", argv[ii]);
+ goto fail;
+ }
+ else if(0 == irccasecmp(argv[ii], "channel"))
+ {
+ discrim->chan_mask = argv[++ii];
+ }
+ else if(0 == irccasecmp(argv[ii], "setter"))
+ {
+ discrim->setter_mask = argv[++ii];
+ }
+ else if(0 == irccasecmp(argv[ii], "reason"))
+ {
+ discrim->reason_mask = argv[++ii];
+ }
+ else if(0 == irccasecmp(argv[ii], "limit"))
+ {
+ discrim->limit = strtoul(argv[++ii], NULL, 0);
+ }
+ else if(0 == irccasecmp(argv[ii], "set"))
+ {
+ const char *cmp = argv[++ii];
+ if(cmp[0] == '<') {
+ if(cmp[1] == '=')
+ discrim->min_set = now - ParseInterval(cmp + 2);
+ else
+ discrim->min_set = now - (ParseInterval(cmp + 1) - 1);
+ } else if(cmp[0] == '=') {
+ discrim->min_set = discrim->max_set = now - ParseInterval(cmp + 1);
+ } else if(cmp[0] == '>') {
+ if(cmp[1] == '=')
+ discrim->max_set = now - ParseInterval(cmp + 2);
+ else
+ discrim->max_set = now - (ParseInterval(cmp + 1) - 1);
+ } else {
+ discrim->max_set = now - (ParseInterval(cmp) - 1);
+ }
+ }
+ else if(0 == irccasecmp(argv[ii], "expires"))
+ {
+ const char *cmp = argv[++ii];
+ if(cmp[0] == '<') {
+ if(cmp[1] == '=')
+ discrim->max_expires = now + ParseInterval(cmp + 2);
+ else
+ discrim->max_expires = now + (ParseInterval(cmp + 1) - 1);
+ } else if(cmp[0] == '=') {
+ discrim->min_expires = discrim->max_expires = now + ParseInterval(cmp + 1);
+ } else if(cmp[0] == '>') {
+ if(cmp[1] == '=')
+ discrim->min_expires = now + ParseInterval(cmp + 2);
+ else
+ discrim->min_expires = now + (ParseInterval(cmp + 1) - 1);
+ } else {
+ discrim->min_expires = now + (ParseInterval(cmp) - 1);
+ }
+ }
+ else
+ {
+ reply("MSG_INVALID_CRITERIA", argv[ii]);
+ goto fail;
+ }
}
- else if(dict_find(mask_dnrs, chan_name, NULL))
+ return discrim;
+
+ fail:
+ free(discrim);
+ return NULL;
+}
+
+typedef int (*dnr_search_func)(struct do_not_register *match, void *extra);
+
+static unsigned int
+dnr_search(struct dnr_search *discrim, dnr_search_func dsf, void *data)
+{
+ struct do_not_register *dnr;
+ dict_iterator_t next;
+ dict_iterator_t it;
+ unsigned int count;
+ int target_fixed;
+
+ /* Initialize local variables. */
+ count = 0;
+ target_fixed = 0;
+ if(discrim->chan_mask)
{
- dict_remove(mask_dnrs, chan_name);
- reply("CSMSG_DNR_REMOVED", chan_name);
+ int shift = (discrim->chan_mask[0] == '\\' && discrim->chan_mask[1] == '*') ? 2 : 0;
+ if('\0' == discrim->chan_mask[shift + strcspn(discrim->chan_mask+shift, "*?")])
+ target_fixed = 1;
+ }
+
+ if(target_fixed && discrim->chan_mask[0] == '\\' && discrim->chan_mask[1] == '*')
+ {
+ /* Check against account-based DNRs. */
+ dnr = dict_find(handle_dnrs, discrim->chan_mask + 2, NULL);
+ if(dnr && dnr_search_matches(dnr, discrim) && (count++ < discrim->limit))
+ dsf(dnr, data);
+ }
+ else if(target_fixed)
+ {
+ /* Check against channel-based DNRs. */
+ dnr = dict_find(plain_dnrs, discrim->chan_mask, NULL);
+ if(dnr && dnr_search_matches(dnr, discrim) && (count++ < discrim->limit))
+ dsf(dnr, data);
}
else
{
- reply("CSMSG_NO_SUCH_DNR", chan_name);
+ /* Exhaustively search account DNRs. */
+ for(it = dict_first(handle_dnrs); it; it = next)
+ {
+ next = iter_next(it);
+ dnr = iter_data(it);
+ if(dnr_search_matches(dnr, discrim) && (count++ < discrim->limit) && dsf(dnr, data))
+ break;
+ }
+
+ /* Do the same for channel DNRs. */
+ for(it = dict_first(plain_dnrs); it; it = next)
+ {
+ next = iter_next(it);
+ dnr = iter_data(it);
+ if(dnr_search_matches(dnr, discrim) && (count++ < discrim->limit) && dsf(dnr, data))
+ break;
+ }
+
+ /* Do the same for wildcarded channel DNRs. */
+ for(it = dict_first(mask_dnrs); it; it = next)
+ {
+ next = iter_next(it);
+ dnr = iter_data(it);
+ if(dnr_search_matches(dnr, discrim) && (count++ < discrim->limit) && dsf(dnr, data))
+ break;
+ }
+ }
+ return count;
+}
+
+static int
+dnr_remove_func(struct do_not_register *match, void *extra)
+{
+ struct userNode *user;
+ char *chan_name;
+
+ chan_name = alloca(strlen(match->chan_name) + 1);
+ strcpy(chan_name, match->chan_name);
+ user = extra;
+ if(((chan_name[0] == '*') && dict_remove(handle_dnrs, chan_name+1))
+ || dict_remove(plain_dnrs, chan_name)
+ || dict_remove(mask_dnrs, chan_name))
+ {
+ send_message(user, chanserv, "CSMSG_DNR_REMOVED", chan_name);
+ }
+ return 0;
+}
+
+static int
+dnr_count_func(struct do_not_register *match, void *extra)
+{
+ return 0; (void)match; (void)extra;
+}
+
+static MODCMD_FUNC(cmd_dnrsearch)
+{
+ struct dnr_search *discrim;
+ dnr_search_func action;
+ struct svccmd *subcmd;
+ unsigned int matches;
+ char buf[MAXLEN];
+
+ sprintf(buf, "dnrsearch %s", argv[1]);
+ subcmd = dict_find(cmd->parent->commands, buf, NULL);
+ if(!subcmd)
+ {
+ reply("CSMSG_DNR_BAD_ACTION", argv[1]);
+ return 0;
+ }
+ if(!svccmd_can_invoke(user, cmd->parent->bot, subcmd, channel, SVCCMD_NOISY))
+ return 0;
+ if(!irccasecmp(argv[1], "print"))
+ action = dnr_print_func;
+ else if(!irccasecmp(argv[1], "remove"))
+ action = dnr_remove_func;
+ else if(!irccasecmp(argv[1], "count"))
+ action = dnr_count_func;
+ else
+ {
+ reply("CSMSG_DNR_BAD_ACTION", argv[1]);
return 0;
}
+
+ discrim = dnr_search_create(user, cmd, argc-2, argv+2);
+ if(!discrim)
+ return 0;
+
+ if(action == dnr_print_func)
+ reply("CSMSG_DNR_SEARCH_RESULTS");
+ matches = dnr_search(discrim, action, user);
+ if(matches)
+ reply("MSG_MATCH_COUNT", matches);
+ else
+ reply("MSG_NO_MATCHES");
+ free(discrim);
return 1;
}
static CHANSERV_FUNC(cmd_register)
{
- struct mod_chanmode *change;
struct handle_info *handle;
struct chanData *cData;
struct modeNode *mn;
return 0;
}
- if(!IsHelping(user) && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
+ if(!IsHelping(user)
+ && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
{
reply("CSMSG_MUST_BE_OPPED", channel->name);
return 0;
scan_user_presence(add_channel_user(cData, handle, UL_OWNER, 0, NULL), NULL);
cData->modes = chanserv_conf.default_modes;
if(off_channel > 0)
- cData->modes.modes_set |= MODE_REGISTERED;
- change = mod_chanmode_dup(&cData->modes, 1);
- change->args[change->argc].mode = MODE_CHANOP;
- change->args[change->argc].u.member = AddChannelUser(chanserv, channel);
- change->argc++;
- mod_chanmode_announce(chanserv, channel, change);
- mod_chanmode_free(change);
+ cData->modes.modes_set |= MODE_REGISTERED;
+ if (IsOffChannel(cData))
+ {
+ mod_chanmode_announce(chanserv, channel, &cData->modes);
+ }
+ else
+ {
+ struct mod_chanmode *change = mod_chanmode_dup(&cData->modes, 1);
+ change->args[change->argc].mode = MODE_CHANOP;
+ change->args[change->argc].u.member = AddChannelUser(chanserv, channel);
+ change->argc++;
+ mod_chanmode_announce(chanserv, channel, change);
+ mod_chanmode_free(change);
+ }
/* Initialize the channel's max user record. */
cData->max = channel->members.used;
static void
merge_data(struct chanData *source, struct chanData *target)
{
+ /* Use more recent visited and owner-transfer time; use older
+ * registered time. Bitwise or may_opchan. Use higher max.
+ * Do not touch last_refresh, ban count or user counts.
+ */
if(source->visited > target->visited)
target->visited = source->visited;
+ if(source->registered < target->registered)
+ target->registered = source->registered;
+ if(source->ownerTransfer > target->ownerTransfer)
+ target->ownerTransfer = source->ownerTransfer;
+ if(source->may_opchan)
+ target->may_opchan = 1;
+ if(source->max > target->max)
+ target->max = source->max;
}
static void
static CHANSERV_FUNC(cmd_adduser)
{
struct userData *actee;
- struct userData *actor;
+ struct userData *actor, *real_actor;
struct handle_info *handle;
- unsigned short access;
+ unsigned short access, override = 0;
REQUIRE_PARAMS(3);
}
actor = GetChannelUser(channel->channel_info, user->handle_info);
+ real_actor = GetChannelAccess(channel->channel_info, user->handle_info);
+
if(actor->access <= access)
{
reply("CSMSG_NO_BUMP_ACCESS");
return 0;
}
+ /* Trying to add someone with equal/more access? */
+ if (!real_actor || real_actor->access <= access)
+ override = CMD_LOG_OVERRIDE;
+
if(!(handle = modcmd_get_handle_info(user, argv[1])))
return 0;
actee = add_channel_user(channel->channel_info, handle, access, 0, NULL);
scan_user_presence(actee, NULL);
reply("CSMSG_ADDED_USER", handle->handle, channel->name, access);
- return 1;
+ return 1 | override;
}
static CHANSERV_FUNC(cmd_clvl)
{
struct handle_info *handle;
struct userData *victim;
- struct userData *actor;
- unsigned short new_access;
+ struct userData *actor, *real_actor;
+ unsigned short new_access, override = 0;
int privileged = IsHelping(user) && ((user->handle_info->opserv_level >= chanserv_conf.nodelete_level) || !IsProtected(channel->channel_info));
REQUIRE_PARAMS(3);
actor = GetChannelUser(channel->channel_info, user->handle_info);
+ real_actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(!(handle = modcmd_get_handle_info(user, argv[1])))
return 0;
return 0;
}
+ /* Trying to clvl a equal/higher user? */
+ if(!real_actor || (real_actor->access <= victim->access && handle != user->handle_info))
+ override = CMD_LOG_OVERRIDE;
+ /* Trying to clvl someone to equal/higher access? */
+ if(!real_actor || new_access >= real_actor->access)
+ override = CMD_LOG_OVERRIDE;
+ /* Helpers clvling themselves get caught by the "clvl someone to equal/higher access" check.
+ * If they lower their own access it's not a big problem.
+ */
+
victim->access = new_access;
reply("CSMSG_CHANGED_ACCESS", handle->handle, new_access, channel->name);
- return 1;
+ return 1 | override;
}
static CHANSERV_FUNC(cmd_deluser)
{
struct handle_info *handle;
struct userData *victim;
- struct userData *actor;
- unsigned short access;
+ struct userData *actor, *real_actor;
+ unsigned short access, override = 0;
char *chan_name;
REQUIRE_PARAMS(2);
actor = GetChannelUser(channel->channel_info, user->handle_info);
+ real_actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(!(handle = modcmd_get_handle_info(user, argv[argc-1])))
return 0;
return 0;
}
+ /* If people delete themselves it is an override, but they
+ * could've used deleteme so we don't log it as an override
+ */
+ if(!real_actor || (real_actor->access <= victim->access && real_actor != victim))
+ override = CMD_LOG_OVERRIDE;
+
chan_name = strdup(channel->name);
del_channel_user(victim, 1);
reply("CSMSG_DELETED_USER", handle->handle, access, chan_name);
free(chan_name);
- return 1;
+ return 1 | override;
}
static int
cmd_mdel_user(struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, char *mask, struct svccmd *cmd)
{
- struct userData *actor, *uData, *next;
+ struct userData *actor, *real_actor, *uData, *next;
+ unsigned int override = 0;
actor = GetChannelUser(channel->channel_info, user->handle_info);
+ real_actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(min_access > max_access)
{
return 0;
}
+ if(!real_actor || real_actor->access <= max_access)
+ override = CMD_LOG_OVERRIDE;
+
for(uData = channel->channel_info->users; uData; uData = next)
{
next = uData->next;
}
reply("CSMSG_DELETED_USERS", mask, min_access, max_access, channel->name);
- return 1;
+ return 1 | override;
}
static CHANSERV_FUNC(cmd_mdelowner)
}
static int
-cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration)
+cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration, int vacation)
{
struct userData *actor, *uData, *next;
char interval[INTERVALLEN];
unsigned int count;
time_t limit;
- actor = GetChannelUser(channel->channel_info, user->handle_info);
+ actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(min_access > max_access)
{
send_message(user, chanserv, "CSMSG_BAD_RANGE", min_access, max_access);
return 0;
}
- if((actor->access <= max_access) && !IsHelping(user))
+ if(!actor || actor->access <= max_access)
{
send_message(user, chanserv, "CSMSG_NO_ACCESS");
return 0;
{
next = uData->next;
- if((uData->seen > limit) || uData->present)
+ if((uData->seen > limit)
+ || uData->present
+ || (HANDLE_FLAGGED(uData->handle, FROZEN) && !vacation))
continue;
if(((uData->access >= min_access) && (uData->access <= max_access))
{
unsigned long duration;
unsigned short min_level, max_level;
+ int vacation;
REQUIRE_PARAMS(3);
+ vacation = argc > 3 && !strcmp(argv[3], "vacation");
duration = ParseInterval(argv[2]);
if(duration < 60)
{
}
else if(!irccasecmp(argv[1], "users"))
{
- cmd_trim_users(user, channel, 0, 0, duration);
+ cmd_trim_users(user, channel, 0, 0, duration, vacation);
return 1;
}
else if(parse_level_range(&min_level, &max_level, argv[1]))
{
- cmd_trim_users(user, channel, min_level, max_level, duration);
+ cmd_trim_users(user, channel, min_level, max_level, duration, vacation);
return 1;
}
else if((min_level = user_level_from_name(argv[1], UL_OWNER)))
{
- cmd_trim_users(user, channel, min_level, min_level, duration);
+ cmd_trim_users(user, channel, min_level, min_level, duration, vacation);
return 1;
}
else
}
static int
-bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, int *victimCount, struct modeNode **victims)
+bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, unsigned int *victimCount, struct modeNode **victims)
{
unsigned int ii;
if(IsService(mn->user))
continue;
- if(!user_matches_glob(mn->user, ban, 1))
+ if(!user_matches_glob(mn->user, ban, MATCH_USENICK | MATCH_VISIBLE))
continue;
if(protect_user(mn->user, user, channel->channel_info))
{
for(ii = count = 0; ii < bans->used; ++ii)
{
- match[ii] = user_matches_glob(actee, bans->list[ii]->ban, 1);
+ match[ii] = user_matches_glob(actee, bans->list[ii]->ban,
+ MATCH_USENICK | MATCH_VISIBLE);
if(match[ii])
count++;
}
if(!match[ii])
continue;
change->args[count].mode = MODE_REMOVE | MODE_BAN;
- change->args[count++].u.hostmask = bans->list[ii]->ban;
+ change->args[count++].u.hostmask = strdup(bans->list[ii]->ban);
}
+ assert(count == change->argc);
return change;
}
change = find_matching_bans(&channel->banlist, actee, mask);
if(change)
{
+ unsigned int ii;
+
modcmd_chanmode_announce(change);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
acted = 1;
}
while(ban)
{
if(actee)
- for( ; ban && !user_matches_glob(actee, ban->mask, 1);
+ for( ; ban && !user_matches_glob(actee, ban->mask,
+ MATCH_USENICK | MATCH_VISIBLE);
ban = ban->next);
else
for( ; ban && !match_ircglobs(mask, ban->mask);
for(ii=0; ii<channel->banlist.used; ii++)
{
change->args[ii].mode = MODE_REMOVE | MODE_BAN;
- change->args[ii].u.hostmask = channel->banlist.list[ii]->ban;
+ change->args[ii].u.hostmask = strdup(channel->banlist.list[ii]->ban);
}
modcmd_chanmode_announce(change);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
reply("CSMSG_BANS_REMOVED", channel->name);
return 1;
static CHANSERV_FUNC(cmd_open)
{
struct mod_chanmode *change;
+ unsigned int ii;
change = find_matching_bans(&channel->banlist, user, NULL);
if(!change)
change->modes_clear &= ~channel->channel_info->modes.modes_set;
modcmd_chanmode_announce(change);
reply("CSMSG_CHANNEL_OPENED", channel->name);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
return 1;
}
if(IsOper(target))
{
epithet = chanserv_conf.irc_operator_epithet;
- type = "IRCOp";
+ type = user_find_message(user, "CSMSG_OPERATOR_TITLE");
}
else if(IsNetworkHelper(target))
{
epithet = chanserv_conf.network_helper_epithet;
- type = "network helper";
+ type = user_find_message(user, "CSMSG_UC_H_TITLE");
}
else if(IsSupportHelper(target))
{
epithet = chanserv_conf.support_helper_epithet;
- type = "support helper";
+ type = user_find_message(user, "CSMSG_LC_H_TITLE");
}
if(epithet)
{
static CHANSERV_FUNC(cmd_bans)
{
+ struct userNode *search_u = NULL;
struct helpfile_table tbl;
- unsigned int matches = 0, timed = 0, ii;
+ unsigned int matches = 0, timed = 0, search_wilds = 0, ii;
char t_buffer[INTERVALLEN], e_buffer[INTERVALLEN], *search;
const char *msg_never, *triggered, *expires;
struct banData *ban, **bans;
- if(argc > 1)
- search = argv[1];
- else
+ if(argc < 2)
search = NULL;
+ else if(strchr(search = argv[1], '!'))
+ {
+ search = argv[1];
+ search_wilds = search[strcspn(search, "?*")];
+ }
+ else if(!(search_u = GetUserH(search)))
+ reply("MSG_NICK_UNKNOWN", search);
bans = alloca(channel->channel_info->banCount * sizeof(struct banData *));
for(ban = channel->channel_info->bans; ban; ban = ban->next)
{
- if(search && !match_ircglobs(search, ban->mask))
- continue;
+ if(search_u)
+ {
+ if(!user_matches_glob(search_u, ban->mask, MATCH_USENICK | MATCH_VISIBLE))
+ continue;
+ }
+ else if(search)
+ {
+ if(search_wilds ? !match_ircglobs(search, ban->mask) : !match_ircglob(search, ban->mask))
+ continue;
+ }
bans[matches++] = ban;
if(ban->expires)
timed = 1;
static CHANSERV_FUNC(cmd_mode)
{
+ struct userData *uData;
struct mod_chanmode *change;
-
+ short base_oplevel;
+
if(argc < 2)
{
change = &channel->channel_info->modes;
return 1;
}
- change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED);
+ uData = GetChannelUser(channel->channel_info, user->handle_info);
+ if (!uData)
+ base_oplevel = MAXOPLEVEL;
+ else if (uData->access >= UL_OWNER)
+ base_oplevel = 1;
+ else
+ base_oplevel = 1 + UL_OWNER - uData->access;
+ change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED, base_oplevel);
if(!change)
{
reply("MSG_INVALID_MODES", unsplit_string(argv+1, argc-1, NULL));
reply("CSMSG_CHANNEL_USERS", cData->userCount);
reply("CSMSG_CHANNEL_BANS", cData->banCount);
reply("CSMSG_CHANNEL_VISITED", intervalString(buffer, now - cData->visited, user->handle_info));
- reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
privileged = IsStaff(user);
+ if(privileged)
+ reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
if(((uData && uData->access >= UL_COOWNER) || privileged) && cData->registrar)
reply("CSMSG_CHANNEL_REGISTRAR", cData->registrar);
static MODCMD_FUNC(cmd_wipeinfo)
{
struct handle_info *victim;
- struct userData *ud, *actor;
+ struct userData *ud, *actor, *real_actor;
+ unsigned int override = 0;
REQUIRE_PARAMS(2);
actor = GetChannelUser(channel->channel_info, user->handle_info);
+ real_actor = GetChannelAccess(channel->channel_info, user->handle_info);
if(!(victim = modcmd_get_handle_info(user, argv[1])))
return 0;
if(!(ud = GetTrueChannelAccess(channel->channel_info, victim)))
reply("MSG_USER_OUTRANKED", victim->handle);
return 0;
}
+ if((ud != real_actor) && (!real_actor || (ud->access >= real_actor->access)))
+ override = CMD_LOG_OVERRIDE;
if(ud->info)
free(ud->info);
ud->info = NULL;
reply("CSMSG_WIPED_INFO_LINE", argv[1], channel->name);
- return 1;
+ return 1 | override;
}
static CHANSERV_FUNC(cmd_resync)
{
struct suspended *suspended = data;
struct chanNode *channel;
- struct mod_chanmode change;
if(!suspended->expires || (now < suspended->expires))
suspended->revoked = now;
channel = suspended->cData->channel;
suspended->cData->channel = channel;
suspended->cData->flags &= ~CHANNEL_SUSPENDED;
- mod_chanmode_init(&change);
- change.argc = 1;
- change.args[0].mode = MODE_CHANOP;
- change.args[0].u.member = AddChannelUser(chanserv, channel);
- mod_chanmode_announce(chanserv, channel, &change);
+ if(!IsOffChannel(suspended->cData))
+ {
+ struct mod_chanmode change;
+ mod_chanmode_init(&change);
+ change.argc = 1;
+ change.args[0].mode = MODE_CHANOP;
+ change.args[0].u.member = AddChannelUser(chanserv, channel);
+ mod_chanmode_announce(chanserv, channel, &change);
+ }
}
static CHANSERV_FUNC(cmd_csuspend)
search->flags |= CHANNEL_NODELETE;
else if(!irccasecmp(argv[i], "suspended"))
search->flags |= CHANNEL_SUSPENDED;
+ else if(!irccasecmp(argv[i], "unreviewed"))
+ search->flags |= CHANNEL_UNREVIEWED;
else
{
send_message(user, chanserv, "CSMSG_INVALID_CFLAG", argv[i]);
{
memset(&channel->channel_info->modes, 0, sizeof(channel->channel_info->modes));
}
- else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED)))
+ else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED, 0)))
{
reply("CSMSG_INVALID_MODE_LOCK", unsplit_string(argv+1, argc-1, NULL));
return 0;
return 1;
}
+static MODCMD_FUNC(chan_opt_unreviewed)
+{
+ struct chanData *cData = channel->channel_info;
+ int value = (cData->flags & CHANNEL_UNREVIEWED) ? 1 : 0;
+
+ if(argc > 1)
+ {
+ int new_value;
+
+ /* The two directions can have different ACLs. */
+ if(enabled_string(argv[1]))
+ new_value = 1;
+ else if(disabled_string(argv[1]))
+ new_value = 0;
+ else
+ {
+ reply("MSG_INVALID_BINARY", argv[1]);
+ return 0;
+ }
+
+ if (new_value != value)
+ {
+ struct svccmd *subcmd;
+ char subcmd_name[32];
+
+ snprintf(subcmd_name, sizeof(subcmd_name), "%s %s", argv[0], (new_value ? "on" : "off"));
+ subcmd = dict_find(cmd->parent->commands, subcmd_name, NULL);
+ if(!subcmd)
+ {
+ reply("MSG_COMMAND_DISABLED", subcmd_name);
+ return 0;
+ }
+ else if(!svccmd_can_invoke(user, cmd->parent->bot, subcmd, channel, SVCCMD_NOISY))
+ return 0;
+
+ if (new_value)
+ cData->flags |= CHANNEL_UNREVIEWED;
+ else
+ {
+ free(cData->registrar);
+ cData->registrar = strdup(user->handle_info->handle);
+ cData->flags &= ~CHANNEL_UNREVIEWED;
+ }
+ value = new_value;
+ }
+ }
+
+ if(value)
+ reply("CSMSG_SET_UNREVIEWED", user_find_message(user, "MSG_ON"));
+ else
+ reply("CSMSG_SET_UNREVIEWED", user_find_message(user, "MSG_OFF"));
+ return 1;
+}
+
static MODCMD_FUNC(chan_opt_defaults)
{
struct userData *uData;
reply("CSMSG_CONFIRM_DEFAULTS", channel->name, confirm);
return 0;
}
- cData->flags = CHANNEL_DEFAULT_FLAGS;
+ cData->flags = (CHANNEL_DEFAULT_FLAGS & ~CHANNEL_PRESERVED_FLAGS)
+ | (cData->flags & CHANNEL_PRESERVED_FLAGS);
cData->modes = chanserv_conf.default_modes;
for(lvlOpt = 0; lvlOpt < NUM_LEVEL_OPTIONS; ++lvlOpt)
cData->lvlOpts[lvlOpt] = levelOptions[lvlOpt].default_value;
return 0;
}
+ argv[0] = "";
+ argv[1] = buf;
return subcmd->command->func(user, channel, argc - 1, argv + 1, subcmd);
}
static CHANSERV_FUNC(cmd_giveownership)
{
struct handle_info *new_owner_hi;
- struct userData *new_owner, *curr_user;
+ struct userData *new_owner;
+ struct userData *curr_user;
+ struct userData *invoker;
struct chanData *cData = channel->channel_info;
struct do_not_register *dnr;
+ const char *confirm;
unsigned int force;
unsigned short co_access;
char reason[MAXLEN];
}
curr_user = owner;
}
- else if (!force && (now < (time_t)(cData->ownerTransfer + chanserv_conf.giveownership_period)))
+ else if(!force && (now < (time_t)(cData->ownerTransfer + chanserv_conf.giveownership_period)))
{
char delay[INTERVALLEN];
intervalString(delay, cData->ownerTransfer + chanserv_conf.giveownership_period - now, user->handle_info);
new_owner = GetChannelAccess(cData, new_owner_hi);
if(!new_owner)
{
- reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
- return 0;
+ if(force)
+ {
+ new_owner = add_channel_user(cData, new_owner_hi, UL_OWNER - 1, 0, NULL);
+ }
+ else
+ {
+ reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
+ return 0;
+ }
}
if((chanserv_get_owned_count(new_owner_hi) >= chanserv_conf.max_owned) && !force)
{
chanserv_show_dnrs(user, cmd, NULL, new_owner_hi->handle);
return 0;
}
+ invoker = GetChannelUser(cData, user->handle_info);
+ if(invoker->access <= UL_OWNER)
+ {
+ confirm = make_confirmation_string(curr_user);
+ if((argc < 3) || strcmp(argv[2], confirm))
+ {
+ reply("CSMSG_CONFIRM_GIVEOWNERSHIP", new_owner_hi->handle, confirm);
+ return 0;
+ }
+ }
if(new_owner->access >= UL_COOWNER)
co_access = new_owner->access;
else
static CHANSERV_FUNC(cmd_suspend)
{
struct handle_info *hi;
- struct userData *self, *target;
+ struct userData *self, *real_self, *target;
+ unsigned int override = 0;
REQUIRE_PARAMS(2);
if(!(hi = modcmd_get_handle_info(user, argv[1]))) return 0;
self = GetChannelUser(channel->channel_info, user->handle_info);
+ real_self = GetChannelAccess(channel->channel_info, user->handle_info);
if(!(target = GetTrueChannelAccess(channel->channel_info, hi)))
{
reply("CSMSG_NO_CHAN_USER", hi->handle, channel->name);
target->present = 0;
target->seen = now;
}
+ if(!real_self || target->access >= real_self->access)
+ override = CMD_LOG_OVERRIDE;
target->flags |= USER_SUSPENDED;
reply("CSMSG_USER_SUSPENDED", hi->handle, channel->name);
- return 1;
+ return 1 | override;
}
static CHANSERV_FUNC(cmd_unsuspend)
{
struct handle_info *hi;
- struct userData *self, *target;
+ struct userData *self, *real_self, *target;
+ unsigned int override = 0;
REQUIRE_PARAMS(2);
if(!(hi = modcmd_get_handle_info(user, argv[1]))) return 0;
self = GetChannelUser(channel->channel_info, user->handle_info);
+ real_self = GetChannelAccess(channel->channel_info, user->handle_info);
if(!(target = GetTrueChannelAccess(channel->channel_info, hi)))
{
reply("CSMSG_NO_CHAN_USER", hi->handle, channel->name);
reply("CSMSG_NOT_SUSPENDED", hi->handle);
return 0;
}
+ if(!real_self || target->access >= real_self->access)
+ override = CMD_LOG_OVERRIDE;
target->flags &= ~USER_SUSPENDED;
scan_user_presence(target, NULL);
reply("CSMSG_USER_UNSUSPENDED", hi->handle, channel->name);
- return 1;
+ return 1 | override;
}
static MODCMD_FUNC(cmd_deleteme)
unsigned int ii;
for(ii = 0; ii < channel->banlist.used; ii++)
{
- if(user_matches_glob(user, channel->banlist.list[ii]->ban, 1))
+ if(user_matches_glob(user, channel->banlist.list[ii]->ban, MATCH_USENICK))
{
/* Riding a netburst. Naughty. */
KickChannelUser(user, channel, chanserv, "User from far side of netsplit should have been banned - bye.");
{
/* Not joining through a ban. */
for(bData = cData->bans;
- bData && !user_matches_glob(user, bData->mask, 1);
- bData = bData->next);
+ bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
+ bData = bData->next);
if(bData)
{
uData->present = 1;
}
}
+
+ /* If user joining normally (not during burst), apply op or voice,
+ * and send greeting/userinfo as appropriate.
+ */
if(!user->uplink->burst)
{
if(modes)
change.args[0].u.member = mNode;
mod_chanmode_announce(chanserv, channel, &change);
}
- if(greeting && !user->uplink->burst)
+ if(greeting)
send_message_type(4, user, chanserv, "(%s) %s", channel->name, greeting);
if(uData && info)
send_target_message(5, channel->name, chanserv, "[%s] %s", user->nick, uData->info);
|| IsSuspended(channel->channel_info))
continue;
for(jj = 0; jj < channel->banlist.used; ++jj)
- if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
+ if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
break;
if(jj < channel->banlist.used)
continue;
for(ban = channel->channel_info->bans; ban; ban = ban->next)
{
char kick_reason[MAXLEN];
- if(!user_matches_glob(user, ban->mask, 1))
+ if(!user_matches_glob(user, ban->mask, MATCH_USENICK | MATCH_VISIBLE))
continue;
change.args[0].mode = MODE_BAN;
change.args[0].u.hostmask = ban->mask;
{
scan_user_presence(uData, mn->user);
uData->seen = now;
+ if (uData->access >= UL_PRESENT)
+ cData->visited = now;
}
if(IsHelping(mn->user) && IsSupportHelper(mn->user))
if(!bounce)
bounce = mod_chanmode_alloc(change->argc + 1 - ii);
bounce->args[bnc].mode = MODE_REMOVE | MODE_BAN;
- bounce->args[bnc].u.hostmask = ban;
+ bounce->args[bnc].u.hostmask = strdup(ban);
bnc++;
send_message(user, chanserv, "CSMSG_MASK_PROTECTED", ban);
}
{
if((bounce->argc = bnc) || bounce->modes_set || bounce->modes_clear)
mod_chanmode_announce(chanserv, channel, bounce);
+ for(ii = 0; ii < change->argc; ++ii)
+ if(bounce->args[ii].mode == (MODE_REMOVE | MODE_BAN))
+ free((char*)bounce->args[ii].u.hostmask);
mod_chanmode_free(bounce);
}
}
continue;
/* Look for a matching ban already on the channel. */
for(jj = 0; jj < channel->banlist.used; ++jj)
- if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
+ if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
break;
/* Need not act if we found one. */
if(jj < channel->banlist.used)
/* Look for a matching ban in this channel. */
for(bData = channel->channel_info->bans; bData; bData = bData->next)
{
- if(!user_matches_glob(user, bData->mask, 1))
+ if(!user_matches_glob(user, bData->mask, MATCH_USENICK | MATCH_VISIBLE))
continue;
change.args[0].u.hostmask = bData->mask;
mod_chanmode_announce(chanserv, channel, &change);
chanserv_conf.channel_expire_frequency = str ? ParseInterval(str) : 86400;
str = database_get_data(conf_node, KEY_CHAN_EXPIRE_DELAY, RECDB_QSTRING);
chanserv_conf.channel_expire_delay = str ? ParseInterval(str) : 86400*30;
+ str = database_get_data(conf_node, KEY_DNR_EXPIRE_FREQ, RECDB_QSTRING);
+ chanserv_conf.dnr_expire_frequency = str ? ParseInterval(str) : 3600;
str = database_get_data(conf_node, KEY_NODELETE_LEVEL, RECDB_QSTRING);
chanserv_conf.nodelete_level = str ? atoi(str) : 1;
str = database_get_data(conf_node, KEY_MAX_CHAN_USERS, RECDB_QSTRING);
str = "+nt";
safestrncpy(mode_line, str, sizeof(mode_line));
ii = split_line(mode_line, 0, ArrayLength(modes), modes);
- if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE)) && (change->argc < 2))
+ if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE, 0))
+ && (change->argc < 2))
{
chanserv_conf.default_modes = *change;
mod_chanmode_free(change);
else
strlist = alloc_string_list(2);
chanserv_conf.old_ban_names = strlist;
- /* the variable itself is actually declared in proto-common.c; this is equally
- * parse issue. */
str = database_get_data(conf_node, "off_channel", RECDB_QSTRING);
off_channel = str ? atoi(str) : 0;
}
s_expires = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING);
owner = database_get_data(rd->d.object, KEY_OWNER, RECDB_QSTRING);
reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING);
+ if (!reason || !owner)
+ return;
set_time = set ? (time_t)strtoul(set, NULL, 0) : now;
triggered_time = triggered ? (time_t)strtoul(triggered, NULL, 0) : 0;
if(!IsSuspended(cData)
&& (str = database_get_data(channel, KEY_MODES, RECDB_QSTRING))
&& (argc = split_line(str, 0, ArrayLength(argv), argv))
- && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE))) {
+ && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE, 0))) {
cData->modes = *modes;
if(off_channel > 0)
cData->modes.modes_set |= MODE_REGISTERED;
{
const char *setter, *reason, *str;
struct do_not_register *dnr;
+ time_t expiry;
setter = database_get_data(hir->d.object, KEY_DNR_SETTER, RECDB_QSTRING);
if(!setter)
log_module(CS_LOG, LOG_ERROR, "Missing reason for DNR %s.", key);
return;
}
- dnr = chanserv_add_dnr(key, setter, reason);
+ str = database_get_data(hir->d.object, KEY_EXPIRES, RECDB_QSTRING);
+ expiry = str ? (time_t)strtoul(str, NULL, 0) : 0;
+ if(expiry && expiry <= now)
+ return;
+ dnr = chanserv_add_dnr(key, setter, expiry, reason);
if(!dnr)
return;
str = database_get_data(hir->d.object, KEY_DNR_SET, RECDB_QSTRING);
write_dnrs_helper(struct saxdb_context *ctx, struct dict *dnrs)
{
struct do_not_register *dnr;
- dict_iterator_t it;
+ dict_iterator_t it, next;
- for(it = dict_first(dnrs); it; it = iter_next(it))
+ for(it = dict_first(dnrs); it; it = next)
{
+ next = iter_next(it);
dnr = iter_data(it);
+ if(dnr->expires && dnr->expires <= now)
+ {
+ dict_remove(dnrs, iter_key(it));
+ continue;
+ }
saxdb_start_record(ctx, dnr->chan_name, 0);
if(dnr->set)
saxdb_write_int(ctx, KEY_DNR_SET, dnr->set);
+ if(dnr->expires)
+ saxdb_write_int(ctx, KEY_EXPIRES, dnr->expires);
saxdb_write_string(ctx, KEY_DNR_SETTER, dnr->setter);
saxdb_write_string(ctx, KEY_DNR_REASON, dnr->reason);
saxdb_end_record(ctx);
CS_LOG = log_register_type("ChanServ", "file:chanserv.log");
conf_register_reload(chanserv_conf_read);
- reg_server_link_func(handle_server_link);
-
- reg_new_channel_func(handle_new_channel);
- reg_join_func(handle_join);
- reg_part_func(handle_part);
- reg_kick_func(handle_kick);
- reg_topic_func(handle_topic);
- reg_mode_change_func(handle_mode);
- reg_nick_change_func(handle_nick_change);
+ if(nick)
+ {
+ reg_server_link_func(handle_server_link);
+ reg_new_channel_func(handle_new_channel);
+ reg_join_func(handle_join);
+ reg_part_func(handle_part);
+ reg_kick_func(handle_kick);
+ reg_topic_func(handle_topic);
+ reg_mode_change_func(handle_mode);
+ reg_nick_change_func(handle_nick_change);
+ reg_auth_func(handle_auth);
+ }
- reg_auth_func(handle_auth);
reg_handle_rename_func(handle_rename);
reg_unreg_func(handle_unreg);
DEFINE_COMMAND(register, 1, MODCMD_REQUIRE_AUTHED, "flags", "+acceptchan,+helping", NULL);
DEFINE_COMMAND(noregister, 1, MODCMD_REQUIRE_AUTHED, "flags", "+helping", NULL);
DEFINE_COMMAND(allowregister, 2, 0, "template", "noregister", NULL);
+ DEFINE_COMMAND(dnrsearch, 3, 0, "template", "noregister", NULL);
+ modcmd_register(chanserv_module, "dnrsearch print", NULL, 0, 0, NULL);
+ modcmd_register(chanserv_module, "dnrsearch remove", NULL, 0, 0, NULL);
+ modcmd_register(chanserv_module, "dnrsearch count", NULL, 0, 0, NULL);
DEFINE_COMMAND(move, 1, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "template", "register", NULL);
DEFINE_COMMAND(csuspend, 2, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "flags", "+helping", NULL);
DEFINE_COMMAND(cunsuspend, 1, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "flags", "+helping", NULL);
DEFINE_CHANNEL_OPTION(ctcpusers);
DEFINE_CHANNEL_OPTION(ctcpreaction);
DEFINE_CHANNEL_OPTION(inviteme);
+ DEFINE_CHANNEL_OPTION(unreviewed);
+ modcmd_register(chanserv_module, "set unreviewed on", NULL, 0, 0, "flags", "+helping", NULL);
+ modcmd_register(chanserv_module, "set unreviewed off", NULL, 0, 0, "flags", "+oper", NULL);
if(off_channel > 1)
DEFINE_CHANNEL_OPTION(offchannel);
modcmd_register(chanserv_module, "set defaults", chan_opt_defaults, 1, 0, "access", "owner", NULL);
if(nick)
{
const char *modes = conf_get_data("services/chanserv/modes", RECDB_QSTRING);
- chanserv = AddService(nick, modes ? modes : NULL, "Channel Services", NULL);
+ chanserv = AddLocalUser(nick, nick, NULL, "Channel Services", modes);
service_register(chanserv)->trigger = '!';
reg_chanmsg_func('\001', chanserv, chanserv_ctcp_check);
}
if(chanserv_conf.channel_expire_frequency)
timeq_add(now + chanserv_conf.channel_expire_frequency, expire_channels, NULL);
+ if(chanserv_conf.dnr_expire_frequency)
+ timeq_add(now + chanserv_conf.dnr_expire_frequency, expire_dnrs, NULL);
+
if(chanserv_conf.refresh_period)
{
time_t next_refresh;
projects / srvx.git / blobdiff