X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=src%2Fchanserv.c;h=f9381870bc3c4567810be2a52b13f7a07f4415d7;hb=52f2d122cb986c1ebcfded6ce43d35fdaf75da44;hp=bac154391bf37a5b0fe5d57a06f7ba3720bf7c34;hpb=1c9294d94d2a9e778ba2e0756bb68e78584325b8;p=srvx.git diff --git a/src/chanserv.c b/src/chanserv.c index bac1543..f938187 100644 --- a/src/chanserv.c +++ b/src/chanserv.c @@ -38,6 +38,7 @@ #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" @@ -114,7 +115,8 @@ #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 */ @@ -134,6 +136,7 @@ static const struct message_entry msgtab[] = { { "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." }, @@ -141,6 +144,8 @@ static const struct message_entry msgtab[] = { { "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." }, @@ -270,6 +275,7 @@ static const struct message_entry msgtab[] = { { "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" }, @@ -489,6 +495,7 @@ static struct unsigned long db_backup_frequency; unsigned long channel_expire_frequency; + unsigned long dnr_expire_frequency; long info_delay; unsigned int adjust_delay; @@ -1387,6 +1394,38 @@ expire_channels(UNUSED_ARG(void *data)) 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) { @@ -1467,13 +1506,14 @@ validate_deop(struct userNode *user, struct chanNode *channel, struct userNode * } 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, "*?")) @@ -1484,44 +1524,80 @@ chanserv_add_dnr(const char *chan_name, const char *setter, const char *reason) } 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); @@ -1531,63 +1607,49 @@ chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_n 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, 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 @@ -1605,13 +1667,29 @@ static CHANSERV_FUNC(cmd_noregister) 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; } @@ -1630,26 +1708,255 @@ static CHANSERV_FUNC(cmd_allowregister) { 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(search->chan_mask, dnr->chan_name)) + || (search->setter_mask + && !match_ircglob(search->setter_mask, dnr->setter)) + || (search->reason_mask + && !match_ircglob(search->reason_mask, dnr->reason))); +} + +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; iichan_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 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 + { + 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; } @@ -2248,7 +2555,7 @@ static CHANSERV_FUNC(cmd_adduser) if(!(handle = modcmd_get_handle_info(user, argv[1]))) return 0; - if((actee = GetChannelAccess(channel->channel_info, handle))) + if((actee = GetTrueChannelAccess(channel->channel_info, handle))) { reply("CSMSG_USER_EXISTS", handle->handle, channel->name, actee->access); return 0; @@ -4175,7 +4482,7 @@ static MODCMD_FUNC(cmd_wipeinfo) reply("MSG_USER_OUTRANKED", victim->handle); return 0; } - if((ud->access >= real_actor->access) && (ud != real_actor)) + if((ud != real_actor) && (!real_actor || (ud->access >= real_actor->access))) override = CMD_LOG_OVERRIDE; if(ud->info) free(ud->info); @@ -4703,6 +5010,8 @@ chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[]) 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]); @@ -5102,6 +5411,60 @@ static MODCMD_FUNC(chan_opt_offchannel) 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; @@ -5123,7 +5486,8 @@ static MODCMD_FUNC(chan_opt_defaults) 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; @@ -5372,6 +5736,8 @@ static CHANSERV_FUNC(cmd_set) return 0; } + argv[0] = ""; + argv[1] = buf; return subcmd->command->func(user, channel, argc - 1, argv + 1, subcmd); } @@ -6512,6 +6878,8 @@ chanserv_conf_read(void) 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); @@ -6972,6 +7340,7 @@ chanserv_dnr_read(const char *key, struct record_data *hir) { 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) @@ -6985,7 +7354,11 @@ chanserv_dnr_read(const char *key, struct record_data *hir) 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); @@ -7179,14 +7552,22 @@ static void 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); @@ -7285,6 +7666,9 @@ init_chanserv(const char *nick) 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); 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); @@ -7400,6 +7784,9 @@ init_chanserv(const char *nick) 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); @@ -7429,6 +7816,9 @@ init_chanserv(const char *nick) 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;