/* modcmd.c - Generalized module command support
- * Copyright 2002-2006 srvx Development Team
+ * Copyright 2002-2007 srvx Development Team
*
* This file is part of srvx.
*
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/
-#include "git-version.h"
#include "chanserv.h"
#include "conf.h"
#include "modcmd.h"
static struct pending_template *pending_templates;
static struct module *modcmd_module;
static struct modcmd *bind_command, *help_command, *version_command;
+unsigned short offchannel_allowed[256] = { 0 };
static const struct message_entry msgtab[] = {
{ "MCMSG_BARE_FLAG", "Flag %.*s must be preceded by a + or -." },
{ "MCMSG_UNKNOWN_FLAG", "Unknown module flag %.*s." },
{ "MCMSG_BAD_OPSERV_LEVEL", "Invalid $O access level %s." },
+ { "MCMSG_BAD_STAFF_LEVEL", "Invalid staff level %s." },
{ "MCMSG_BAD_CHANSERV_LEVEL", "Invalid $C access level %s." },
{ "MCMSG_LEVEL_TOO_LOW", "You cannot set the access requirements for %s (your level is too low.)" },
{ "MCMSG_LEVEL_TOO_HIGH", "You cannot set the access requirements to %s (that is too high)." },
{ "MCMSG_HELPFILE_UNBOUND", "Since that was the last command from module %s on the service, the helpfile for %s was removed." },
{ "MCMSG_NO_HELPFILE", "Module %s does not have a help file." },
{ "MCMSG_HELPFILE_ERROR", "Syntax error reading %s; help contents not changed." },
- { "MCMSG_HELPFILE_READ", "Read %s help database in "FMT_TIME_T".%03lu seconds." },
- { "MCMSG_COMMAND_TIME", "Command $b%s$b finished in "FMT_TIME_T".%06lu seconds." },
+ { "MCMSG_HELPFILE_READ", "Read %s help database in %lu.%03lu seconds." },
+ { "MCMSG_COMMAND_TIME", "Command $b%s$b finished in %lu.%06lu seconds." },
{ "MCMSG_NEED_OPSERV_LEVEL", "You must have $O access of at least $b%u$b." },
+ { "MCMSG_NEED_STAFF_LEVEL", "You must have staff access of at least $b%u$b." },
{ "MCMSG_NEED_CHANSERV_LEVEL", "You must have $C access of at least $b%u$b in the channel." },
{ "MCMSG_NEED_ACCOUNT_FLAGS", "You must have account flags $b%s$b." },
{ "MCMSG_NEED_NOTHING", "Anyone may use the $b%s$b command." },
{ "MCMSG_CURRENT_TRIGGER", "Trigger for $b%s$b is $b%c$b." },
{ "MCMSG_NEW_TRIGGER", "Changed trigger for $b%s$b to $b%c$b." },
{ "MCMSG_SERVICE_PRIVILEGED", "Service $b%s$b privileged: $b%s$b." },
+ { "MCMSG_OFFCHANNEL_IS_ON", "Off-channel use for $b%s$b (trigger $b%c$b) is enabled" },
+ { "MCMSG_OFFCHANNEL_IS_OFF", "Off-channel use for $b%s$b (trigger $b%c$b) is disabled" },
+ { "MCMSG_OFFCHANNEL_ON", "Enabled off-channel use for $b%s$b (trigger $b%c$b)" },
+ { "MCMSG_OFFCHANNEL_OFF", "Disabled off-channel use for $b%s$b (trigger $b%c$b)" },
{ "MCMSG_SERVICE_REMOVED", "Service $b%s$b has been deleted." },
{ "MCMSG_FILE_NOT_OPENED", "Unable to open file $b%s$b for writing." },
{ "MCMSG_MESSAGES_DUMPED", "Messages written to $b%s$b." },
{ "MCMSG_MESSAGE_DUMP_FAILED", "Message dump failed: %s." },
{ "MCMSG_COMMAND_FLAGS", "Command flags are %s (inferred: %s)." },
{ "MCMSG_COMMAND_ACCOUNT_FLAGS", "Requires account flags +%s, prohibits account flags +%s." },
- { "MCMSG_COMMAND_ACCESS_LEVEL", "Requires channel access %d and $O access %d." },
+ { "MCMSG_COMMAND_ACCESS_LEVEL", "Requires channel access %d and $O access %d and staff access %d." },
{ "MCMSG_COMMAND_USES", "%s has been used %d times." },
{ NULL, NULL }
};
static struct modcmd_flag {
const char *name;
unsigned int flag;
-} flags[] = {
+} modcmd_flags[] = {
{ "acceptchan", MODCMD_ACCEPT_CHANNEL },
{ "acceptpluschan", MODCMD_ACCEPT_PCHANNEL },
{ "authed", MODCMD_REQUIRE_AUTHED },
return irccasecmp(fa->name, fb->name);
}
-DEFINE_LIST(svccmd_list, struct svccmd*);
-DEFINE_LIST(module_list, struct module*);
+DEFINE_LIST(svccmd_list, struct svccmd*)
+DEFINE_LIST(module_list, struct module*)
static void
free_service_command(void *data) {
dest->deny_account_flags |= src->deny_account_flags;
if (src->min_opserv_level > dest->min_opserv_level)
dest->min_opserv_level = src->min_opserv_level;
+ if (src->min_staff_level > dest->min_staff_level)
+ dest->min_staff_level = src->min_staff_level;
if (src->min_channel_access > dest->min_channel_access)
dest->min_channel_access = src->min_channel_access;
modcmd_set_effective_flags(dest);
return 0;
}
value++;
- flag = bsearch(value, flags, ArrayLength(flags)-1, sizeof(flags[0]), flags_bsearch);
+ flag = bsearch(value, modcmd_flags, ArrayLength(modcmd_flags)-1, sizeof(modcmd_flags[0]), flags_bsearch);
if (!flag) {
if (user)
send_message(user, bot, "MCMSG_UNKNOWN_FLAG", end, value);
}
cmd->min_opserv_level = newval;
return 1;
+ } else if (!irccasecmp(param, "staff_level") || !irccasecmp(param, "staff_access")) {
+ unsigned int newval = atoi(value);
+ if (newval > 1000) {
+ if (user) {
+ send_message(user, bot, "MCMSG_BAD_STAFF_LEVEL", value);
+ } else {
+ log_module(MAIN_LOG, LOG_ERROR, "Invalid staff level %s (for command %s).", value, cmd->name);
+ }
+ return 0;
+ }
+ cmd->min_staff_level = newval;
+ return 1;
} else if (!irccasecmp(param, "account_flags")) {
return nickserv_modify_handle_flags(user, bot, value, &cmd->req_account_flags, &cmd->deny_account_flags);
} else {
*/
int
svccmd_can_invoke(struct userNode *user, struct userNode *bot, struct svccmd *cmd, struct chanNode *channel, int options) {
+ extern struct userNode *chanserv;
unsigned int uData_checked = 0;
struct userData *uData = NULL;
int rflags = 0, flags = cmd->effective_flags;
return 0;
}
if (flags & MODCMD_REQUIRE_REGCHAN) {
- if (!channel->channel_info) {
+ if (!chanserv) {
+ /* Just use the inferred MODCMD_REQUIRE_CHANNEL. */
+ } else if (!channel->channel_info) {
if (options & SVCCMD_NOISY)
send_message(user, bot, "MCMSG_CHAN_NOT_REGISTERED", channel->name);
return 0;
} else if (IsSuspended(channel->channel_info) && !(flags & MODCMD_IGNORE_CSUSPEND)) {
- /* allow security-override users to always ignore channel suspensions, but flag it as a staff command */
- if (!user->handle_info
- || !HANDLE_FLAGGED(user->handle_info, HELPING)
- || (flags & MODCMD_NEVER_CSUSPEND)) {
+ /* Allow security-override users to ignore most channel
+ * suspensions, but flag that use as a staff command.
+ */
+ if (!IsHelping(user) || (flags & MODCMD_NEVER_CSUSPEND)) {
if (options & SVCCMD_NOISY)
send_message(user, bot, "MCMSG_CHAN_SUSPENDED", channel->name, channel->channel_info->suspended->reason);
return 0;
}
+ if (cmd->min_staff_level > 0 && !staff_has_access(user, bot, cmd->min_staff_level, !(options & SVCCMD_NOISY))) return 0;
rflags |= ACTION_STAFF;
}
}
if (flags & MODCMD_REQUIRE_CHANUSER) {
if (!uData_checked)
uData = _GetChannelUser(channel->channel_info, user->handle_info, 1, 0), uData_checked = 1;
- if (!uData) {
+ if (!chanserv) {
+ /* Assume someone knows what they're doing. */
+ } else if (!uData) {
if (options & SVCCMD_NOISY)
send_message(user, bot, "MCMSG_NO_CHANNEL_ACCESS", channel->name);
return 0;
|| ((flags & MODCMD_REQUIRE_NETWORK_HELPER) && IsNetworkHelper(user))
|| ((flags & MODCMD_REQUIRE_SUPPORT_HELPER) && IsSupportHelper(user))) {
/* allow it */
+ if (cmd->min_staff_level > 0 && !staff_has_access(user, bot, cmd->min_staff_level, !(options & SVCCMD_NOISY))) return 0;
rflags |= ACTION_STAFF;
} else {
if (options & SVCCMD_NOISY)
send_message(user, bot, "MCMSG_MUST_BE_HELPING");
return 0;
}
+ if (cmd->min_staff_level > 0 && !staff_has_access(user, bot, cmd->min_staff_level, !(options & SVCCMD_NOISY))) return 0;
rflags |= ACTION_STAFF;
}
if (cmd->min_opserv_level > 0) {
- if (!oper_has_access(user, bot, cmd->min_opserv_level, !(options & SVCCMD_NOISY)))
- return 0;
+ if (!oper_has_access(user, bot, cmd->min_opserv_level, !(options & SVCCMD_NOISY))) return 0;
+ if (cmd->min_staff_level > 0 && !staff_has_access(user, bot, cmd->min_staff_level, !(options & SVCCMD_NOISY))) return 0;
rflags |= ACTION_STAFF;
}
if (cmd->req_account_flags || cmd->deny_account_flags) {
&& (!(uData = _GetChannelUser(channel->channel_info, user->handle_info, 0, 0))
|| uData->access < cmd->min_channel_access)
&& !(flags & (MODCMD_REQUIRE_STAFF|MODCMD_REQUIRE_HELPING))) {
+ if (cmd->min_staff_level > 0 && !staff_has_access(user, bot, cmd->min_staff_level, !(options & SVCCMD_NOISY))) return 0;
rflags |= ACTION_OVERRIDE;
}
return rflags | ACTION_ALLOW;
log_module(MAIN_LOG, LOG_ERROR, "Alias expansion parse error in %s (near %s; %s.%s arg %d).", arg, end_num, cmd->parent->bot->nick, cmd->name, ii);
return 0;
}
+ if (lbound >= old_argc)
+ return -1;
if (ubound >= old_argc)
ubound = old_argc - 1;
if (lbound < old_argc)
/* Expand the alias arguments, if there are any. */
if (cmd->alias.used) {
char *new_argv[MAXNUMPARAMS];
- argc = svccmd_expand_alias(cmd, argc, argv, new_argv);
- if (!argc) {
- send_message(service->bot, user, "MCMSG_ALIAS_ERROR", cmd->name);
+ int res;
+
+ res = svccmd_expand_alias(cmd, argc, argv, new_argv);
+ if (res < 0) {
+ send_message(user, service->bot, "MSG_MISSING_PARAMS", cmd->name);
+ return 0;
+ } else if (res == 0) {
+ send_message(user, service->bot, "MCMSG_ALIAS_ERROR", cmd->name);
return 0;
}
+ argc = res;
argv = new_argv;
/* Try again to grab a handle to the channel after alias
irc_notice_user(bot,user, "\x01PING\x01");
}
} else if (!irccasecmp(text, "TIME")) {
- struct tm tm;
- localtime_r(&now, &tm);
- strftime(response, sizeof(response), "\x01TIME %a %b %d %H:%M:%S %Y\x01", &tm);
+ time_t feh;
+ feh = now;
+ strftime(response, sizeof(response), "\x01TIME %a %b %d %H:%M:%S %Y\x01", localtime(&feh));
irc_notice_user(bot, user, response);
} else if (!irccasecmp(text, "USERINFO")) {
snprintf(response, sizeof(response), "\x01USERINFO %s\x01", bot->info);
* users, except to add copyright information pertaining
* to changes you make to srvx.
*/
- snprintf(response, sizeof(response), "\x01VERSION %s (%s) %s\x01", PACKAGE_STRING, CODENAME, GIT_VERSION);
+ snprintf(response, sizeof(response), "\x01VERSION %s (%s) GIT Revision: %s\x01", PACKAGE_STRING, CODENAME, git_version);
irc_notice_user(bot, user, response);
}
return;
}
void
-modcmd_chanmsg(struct userNode *user, struct chanNode *chan, const char *text, struct userNode *bot) {
+modcmd_chanmsg(struct userNode *user, struct chanNode *chan, const char *text, struct userNode *bot, unsigned int is_notice) {
struct service *service;
- if (!(service = dict_find(services, bot->nick, NULL))) return;
+ if (!(service = dict_find(services, bot->nick, NULL)))
+ return;
svccmd_invoke(user, service, chan, text, 0);
+ (void)is_notice;
}
struct service *
continue;
} else if (isdigit(argv[arg][1])) {
char *end_num;
+ unsigned int tmp;
- strtoul(argv[arg]+1, &end_num, 10);
+ tmp = strtoul(argv[arg]+1, &end_num, 10);
+ (void)tmp;
switch (end_num[0]) {
case 0:
continue;
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MCMSG_HELPFILE_READ", module->name, stop.tv_sec, stop.tv_usec/1000);
+ reply("MCMSG_HELPFILE_READ", module->name, (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec/1000);
return 1;
}
stop.tv_sec -= 1;
stop.tv_usec += 1000000;
}
- reply("MCMSG_COMMAND_TIME", cmd_text, stop.tv_sec, stop.tv_usec);
+ reply("MCMSG_COMMAND_TIME", cmd_text, (unsigned long)stop.tv_sec, (unsigned long)stop.tv_usec);
return 1;
}
reply("MCMSG_NEED_OPSERV_LEVEL", svccmd->min_opserv_level);
shown_flags |= MODCMD_REQUIRE_OPER | MODCMD_REQUIRE_AUTHED;
}
+ if (svccmd->min_staff_level > 0) { // && (IsNetworkHelper(user) || IsSupportHelper(user) || IsOper(user))
+ reply("MCMSG_NEED_STAFF_LEVEL", svccmd->min_staff_level);
+ shown_flags |= MODCMD_REQUIRE_STAFF | MODCMD_REQUIRE_AUTHED;
+ }
if (svccmd->min_channel_access > 0) {
reply("MCMSG_NEED_CHANSERV_LEVEL", svccmd->min_channel_access);
shown_flags |= MODCMD_REQUIRE_CHANUSER | MODCMD_REQUIRE_REGCHAN | MODCMD_REQUIRE_CHANNEL | MODCMD_REQUIRE_AUTHED;
snprintf(buf1, sizeof(buf1), "%s.%s", target->command->parent->name, target->command->name);
reply("MCMSG_COMMAND_BINDING", target->name, buf1);
}
- for (ii = buf1_used = buf2_used = 0; flags[ii].name; ++ii) {
- if (target->flags & flags[ii].flag) {
+ for (ii = buf1_used = buf2_used = 0; modcmd_flags[ii].name; ++ii) {
+ const struct modcmd_flag *flag = &modcmd_flags[ii];
+ if (target->flags & flag->flag) {
if (buf1_used)
buf1[buf1_used++] = ',';
- len = strlen(flags[ii].name);
- memcpy(buf1 + buf1_used, flags[ii].name, len);
+ len = strlen(flag->name);
+ memcpy(buf1 + buf1_used, flag->name, len);
buf1_used += len;
- } else if (target->effective_flags & flags[ii].flag) {
+ } else if (target->effective_flags & flag->flag) {
if (buf2_used)
buf2[buf2_used++] = ',';
- len = strlen(flags[ii].name);
- memcpy(buf2 + buf2_used, flags[ii].name, len);
+ len = strlen(flag->name);
+ memcpy(buf2 + buf2_used, flag->name, len);
buf2_used += len;
}
}
}
buf1[buf1_used] = buf2[buf2_used] = '\0';
reply("MCMSG_COMMAND_ACCOUNT_FLAGS", buf1, buf2);
- reply("MCMSG_COMMAND_ACCESS_LEVEL", target->min_channel_access, target->min_opserv_level);
+ reply("MCMSG_COMMAND_ACCESS_LEVEL", target->min_channel_access, target->min_opserv_level, target->min_staff_level);
reply("MCMSG_COMMAND_USES", target->name, target->uses);
}
if (argc < 2) {
tbl.length = dict_size(services) + 1;
- tbl.width = 4;
+ tbl.width = 5;
tbl.flags = TABLE_PAD_LEFT;
tbl.contents = calloc(tbl.length, sizeof(tbl.contents[0]));
tbl.contents[0] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
tbl.contents[0][1] = "Commands";
tbl.contents[0][2] = "Priv'd?";
tbl.contents[0][3] = "Trigger";
+ tbl.contents[0][4] = "Offchannel";
extra = calloc(2, tbl.length);
for (ii=1, it=dict_first(services); it; it=iter_next(it), ii++) {
service = iter_data(it);
tbl.contents[ii] = calloc(tbl.width, sizeof(tbl.contents[ii][0]));
tbl.contents[ii][0] = service->bot->nick;
- tbl.contents[ii][1] = strtab(dict_size(service->commands));
+ tbl.contents[ii][1] = (service->commands && dict_size(service->commands) ? strtab(dict_size(service->commands)) : strtab(0));
tbl.contents[ii][2] = service->privileged ? "yes" : "no";
extra[ii*2] = service->trigger;
tbl.contents[ii][3] = extra+ii*2;
+ tbl.contents[ii][4] = offchannel_allowed[(unsigned char)service->trigger] ? "yes" : "no";
}
table_send(cmd->parent->bot, user->nick, 0, 0, tbl);
free(extra);
if (show_opserv_level)
tbl.contents[ii+1][1] = strtab(svccmd->min_opserv_level);
if (show_channel_access) {
- const char *access;
+ const char *access_name;
int flags = svccmd->effective_flags;
if (flags & MODCMD_REQUIRE_HELPING)
- access = "helping";
+ access_name = "helping";
else if (flags & MODCMD_REQUIRE_STAFF) {
if (flags & MODCMD_REQUIRE_OPER)
- access = "oper";
+ access_name = "oper";
else if (flags & MODCMD_REQUIRE_NETWORK_HELPER)
- access = "net.helper";
+ access_name = "net.helper";
else
- access = "staff";
+ access_name = "staff";
} else
- access = strtab(svccmd->min_channel_access);
- tbl.contents[ii+1][1+show_opserv_level] = access;
+ access_name = strtab(svccmd->min_channel_access);
+ tbl.contents[ii+1][1+show_opserv_level] = access_name;
}
}
svccmd_list_clean(&commands);
static MODCMD_FUNC(cmd_service_trigger) {
struct userNode *bogon;
struct service *service;
+ int old_oc = 0;
if (!(service = service_find(argv[1]))) {
reply("MCMSG_UNKNOWN_SERVICE", argv[1]);
reply("MCMSG_NO_TRIGGER", service->bot->nick);
return 1;
}
- if (service->trigger)
+ if (service->trigger) {
+ old_oc = offchannel_allowed[(unsigned char)service->trigger];
+ offchannel_allowed[(unsigned char)service->trigger] = 0;
reg_chanmsg_func(service->trigger, NULL, NULL);
+ }
if (!irccasecmp(argv[2], "none") || !irccasecmp(argv[2], "remove")) {
+ offchannel_allowed[(unsigned char)service->trigger] = 0;
service->trigger = 0;
reply("MCMSG_REMOVED_TRIGGER", service->bot->nick);
} else if ((bogon = get_chanmsg_bot(argv[2][0]))) {
return 1;
} else {
service->trigger = argv[2][0];
+ offchannel_allowed[(unsigned char)service->trigger] = old_oc;
reg_chanmsg_func(service->trigger, service->bot, modcmd_chanmsg);
reply("MCMSG_NEW_TRIGGER", service->bot->nick, service->trigger);
}
return 1;
}
+static MODCMD_FUNC(cmd_service_offchannel) {
+ struct service *service;
+
+ if (!(service = service_find(argv[1]))) {
+ reply("MCMSG_UNKNOWN_SERVICE", argv[1]);
+ return 0;
+ }
+
+ if(!service->trigger) {
+ reply("MCMSG_NO_TRIGGER", service->bot->nick);
+ return 0;
+ }
+
+ if(argc < 3) {
+ if(offchannel_allowed[(unsigned char)service->trigger])
+ reply("MCMSG_OFFCHANNEL_IS_ON", service->bot->nick, service->trigger);
+ else
+ reply("MCMSG_OFFCHANNEL_IS_OFF", service->bot->nick, service->trigger);
+ return 1;
+ }
+
+ if(enabled_string(argv[2])) {
+ offchannel_allowed[(unsigned char)service->trigger] = 1;
+ reply("MCMSG_OFFCHANNEL_ON", service->bot->nick, service->trigger);
+ } else if(disabled_string(argv[2])) {
+ offchannel_allowed[(unsigned char)service->trigger] = 0;
+ reply("MCMSG_OFFCHANNEL_OFF", service->bot->nick, service->trigger);
+ } else {
+ reply("MSG_INVALID_BINARY", argv[2]);
+ return 0;
+ }
+
+ return 1;
+}
+
static MODCMD_FUNC(cmd_service_privileged) {
struct service *service;
const char *newval;
reply("MSG_INTERNAL_FAILURE");
return 0;
}
- if ((res = setjmp(ctx->jbuf)) != 0) {
- ctx->complex.used = 0; /* to avoid false assert()s in close */
- saxdb_close_context(ctx);
- fclose(pf);
+ if ((res = setjmp(*saxdb_jmp_buf(ctx))) != 0) {
+ saxdb_close_context(ctx, 1);
reply("MCMSG_MESSAGE_DUMP_FAILED", strerror(res));
return 0;
} else {
for (it = dict_first(lang_C->messages); it; it = iter_next(it))
saxdb_write_string(ctx, iter_key(it), iter_data(it));
- saxdb_close_context(ctx);
- fclose(pf);
+ saxdb_close_context(ctx, 1);
reply("MCMSG_MESSAGES_DUMPED", fname);
return 1;
}
* command or its accessibility to normal IRC users, except to add
* copyright information pertaining to changes you make to srvx.
*/
- send_message_type(4, user, cmd->parent->bot, "$b"PACKAGE_STRING"$b ("CODENAME"), Built: "__DATE__", "__TIME__". Copyright 2000-2006 srvx Development Team.");
- if (argc > 1)
- send_message_type(4, user, cmd->parent->bot, "%s", GIT_VERSION);
- else
- send_message_type(12, user, cmd->parent->bot, "The srvx Development Team includes Paul Chang, Adrian Dewhurst, Miles Peterson, Michael Poole and others.\nThe srvx Development Team can be reached at http://sf.net/projects/srvx/ or in #srvx on irc.gamesurge.net.");
+ send_message_type(4, user, cmd->parent->bot, "$b"PACKAGE_STRING"$b ("CODENAME"), GIT Revision: %s, Built: "__DATE__", "__TIME__". Copyright 2000-2008 srvx Development Team.", git_version);
+ send_message_type(12, user, cmd->parent->bot, "The srvx Development Team includes Paul Chang, Adrian Dewhurst, Miles Peterson, Michael Poole and others.\nThe srvx Development Team can be reached at http://sf.net/projects/srvx/ or in #srvx on irc.gamesurge.net.\nThis version has been modified by pk910 - visit #srvx @ irc.nextirc.net.\nThis version has been modified by Stricted - visit #dev @ irc.easy-scripting.net.");
return 1;
}
saxdb_write_string_list(ctx, "aliased", &cmd->alias);
if (cmd->min_opserv_level != template->min_opserv_level)
saxdb_write_int(ctx, "oper_access", cmd->min_opserv_level);
+ if (cmd->min_staff_level != template->min_staff_level)
+ saxdb_write_int(ctx, "staff_access", cmd->min_staff_level);
if (cmd->min_channel_access != template->min_channel_access)
saxdb_write_int(ctx, "channel_access", cmd->min_channel_access);
if (cmd->flags != template->flags) {
if (cmd->flags) {
- for (nn=pos=0; flags[nn].name; ++nn) {
- if (cmd->flags & flags[nn].flag) {
+ for (nn=pos=0; modcmd_flags[nn].name; ++nn) {
+ const struct modcmd_flag *flag = &modcmd_flags[nn];
+ if (cmd->flags & flag->flag) {
buf[pos++] = '+';
- len = strlen(flags[nn].name);
- memcpy(buf+pos, flags[nn].name, len);
+ len = strlen(flag->name);
+ memcpy(buf+pos, flag->name, len);
pos += len;
buf[pos++] = ',';
}
saxdb_start_record(ctx, "bots", 1);
for (it = dict_first(services); it; it = iter_next(it)) {
char buff[16];
+ char modes[32];
+
service = iter_data(it);
saxdb_start_record(ctx, service->bot->nick, 1);
if (service->trigger) {
buff[0] = service->trigger;
buff[1] = '\0';
saxdb_write_string(ctx, "trigger", buff);
+ if(offchannel_allowed[(unsigned char)service->trigger])
+ saxdb_write_int(ctx, "offchannel", 1);
}
saxdb_write_string(ctx, "description", service->bot->info);
saxdb_write_string(ctx, "hostname", service->bot->hostname);
+ if (service->bot->modes) {
+ irc_user_modes(service->bot, modes, sizeof(modes));
+ saxdb_write_string(ctx, "modes", modes);
+ }
if (service->privileged)
saxdb_write_string(ctx, "privileged", "1");
saxdb_end_record(ctx);
for (it = dict_first(db); it; it = iter_next(it)) {
struct record_data *rd;
struct service *svc;
- const char *nick, *desc, *hostname;
+ const char *nick, *desc, *hostname, *modes;
rd = iter_data(it);
if (rd->type != RECDB_OBJECT) {
svc = service_find(nick);
desc = database_get_data(rd->d.object, "description", RECDB_QSTRING);
hostname = database_get_data(rd->d.object, "hostname", RECDB_QSTRING);
+ modes = database_get_data(rd->d.object, "modes", RECDB_QSTRING);
if (desc) {
if (!svc)
- svc = service_register(AddLocalUser(nick, nick, hostname, desc, NULL));
+ svc = service_register(AddLocalUser(nick, nick, hostname, desc, modes));
else if (hostname)
strcpy(svc->bot->hostname, hostname);
desc = database_get_data(rd->d.object, "trigger", RECDB_QSTRING);
- if (desc)
+ if (desc) {
svc->trigger = desc[0];
+ desc = database_get_data(rd->d.object, "offchannel", RECDB_QSTRING);
+ if(desc)
+ offchannel_allowed[(unsigned char)svc->trigger] = atoi(desc);
+ }
desc = database_get_data(rd->d.object, "privileged", RECDB_QSTRING);
if (desc && (true_string(desc) || enabled_string(desc)))
svc->privileged = 1;
void
modcmd_init(void) {
- qsort(flags, ArrayLength(flags)-1, sizeof(flags[0]), flags_qsort);
+ qsort(modcmd_flags, ArrayLength(modcmd_flags)-1, sizeof(modcmd_flags[0]), flags_qsort);
modules = dict_new();
dict_set_free_data(modules, free_module);
services = dict_new();
modcmd_register(modcmd_module, "service add", cmd_service_add, 4, 0, "flags", "+oper", NULL);
modcmd_register(modcmd_module, "service rename", cmd_service_rename, 3, 0, "flags", "+oper", NULL);
modcmd_register(modcmd_module, "service trigger", cmd_service_trigger, 2, 0, "flags", "+oper", NULL);
+ modcmd_register(modcmd_module, "service offchannel", cmd_service_offchannel, 2, 0, "flags", "+oper", NULL);
modcmd_register(modcmd_module, "service privileged", cmd_service_privileged, 2, 0, "flags", "+oper", NULL);
modcmd_register(modcmd_module, "service remove", cmd_service_remove, 2, 0, "flags", "+oper", NULL);
modcmd_register(modcmd_module, "dumpmessages", cmd_dump_messages, 1, 0, "oper_level", "1000", NULL);
|| (str = database_get_data(obj, "opserv_level", RECDB_QSTRING))) {
svccmd_configure(svccmd, NULL, service->bot, "oper_access", str);
}
+ if ((str = database_get_data(obj, "staff_access", RECDB_QSTRING))
+ || (str = database_get_data(obj, "staff_level", RECDB_QSTRING))) {
+ svccmd_configure(svccmd, NULL, service->bot, "staff_access", str);
+ }
if ((str = database_get_data(obj, "channel_access", RECDB_QSTRING))
|| (str = database_get_data(obj, "chanserv_level", RECDB_QSTRING))) {
svccmd_configure(svccmd, NULL, service->bot, "channel_access", str);
struct svccmd *svccmd;
svccmd = service_make_alias(service, "stats", "*modcmd.joiner", NULL);
svccmd->min_opserv_level = 101;
+ svccmd = service_make_alias(service, "devnull", "*modcmd.joiner", NULL);
+ svccmd->min_opserv_level = 200;
svccmd = service_make_alias(service, "service", "*modcmd.joiner", NULL);
svccmd->min_opserv_level = 900;
}
projects / srvx.git / blobdiff