#define KEY_WARN "chanwarn"
#define KEY_MAX "max"
#define KEY_TIME "time"
+#define KEY_LAST "last"
#define KEY_MAX_CLIENTS "max_clients"
#define KEY_LIMIT "limit"
#define KEY_EXPIRES "expires"
{ "OSMSG_NO_DEBUG_CHANNEL", "No debug channel has been configured." },
{ "OSMSG_INVITE_DONE", "Invited $b%s$b to $b%s$b." },
{ "OSMSG_ALREADY_THERE", "You are already in $b%s$b." },
+ { "OSMSG_USER_ALREADY_THERE", "%s is already in $b%s$b." },
{ "OSMSG_NOT_THERE", "You not in $b%s$b." },
{ "OSMSG_JOIN_DONE", "I have joined $b%s$b." },
{ "OSMSG_MARK_SET", "Set the MARK." },
{ "OSMSG_OPALL_DONE", "Opped everyone on $b%s$b." },
{ "OSMSG_HOP_DONE", "Halfopped the requested lusers." },
{ "OSMSG_HOPALL_DONE", "Halfopped everyone on $b%s$b." },
+ { "OMSG_BAD_SVSNICK", "$b%s$b is an invalid nickname." },
+
{ "OSMSG_WHOIS_IDENT", "%s (%s@%s) from %d.%d.%d.%d" },
{ "OSMSG_WHOIS_NICK", "Nick : %s" },
{ "OSMSG_WHOIS_HOST", "Host : %s@%s" },
{ "OSMSG_ALERTS_LIST", "$bCurrent $O alerts matching '$b%s$b'$b" },
{ "OSMSG_ALERTS_BAR", "----------------------------------------------" },
{ "OSMSG_ALERTS_HEADER", "Name Action (by Oper)" },
- { "OSMSG_ALERTS_DESC", " Criteria: %s" },
+ { "OSMSG_ALERTS_DESC", " $uCriteria$u: %s" },
+ { "OSMSG_ALERTS_LAST", " $uTriggered$u: %s" },
{ "OSMSG_ALERT_IS", "$b%-20s$b %-6s (by %s)" },
{ "OSMSG_ALERT_END", "----------------End of Alerts-----------------" },
/* routing messages */
typedef struct opservDiscrim {
struct chanNode *channel;
- char *mask_nick, *mask_ident, *mask_host, *mask_info, *mask_version, *server, *reason, *accountmask, *chantarget, *mark, *mask_mark;
+ char *mask_nick, *mask_ident, *mask_host, *mask_info, *mask_version, *server, *reason, *accountmask, *chantarget, *mark, *mask_mark, *modes;
irc_in_addr_t ip_mask;
unsigned long limit;
time_t min_ts, max_ts;
char *text_discrim, *split_discrim;
discrim_t discrim;
opserv_alert_reaction reaction;
+ int last;
};
/* funny type to make it acceptible to dict_set_free_data, far below */
channel = AddChannel(argv[2], now, NULL, NULL, NULL);
}
if (GetUserMode(channel, target)) {
- reply("OSMSG_ALREADY_THERE", channel->name);
+ reply("OSMSG_USER_ALREADY_THERE", target->nick, channel->name);
return 0;
}
irc_svsjoin(opserv, target, channel);
return 1;
}
+static MODCMD_FUNC(cmd_svsnick)
+{
+ struct userNode *target;
+
+ target = GetUserH(argv[1]);
+ if (!target) {
+ reply("MSG_NICK_UNKNOWN", argv[1]);
+ return 0;
+ }
+ if(!is_valid_nick(argv[2])) {
+ reply("OMSG_BAD_SVSNICK", argv[2]);
+ return 0;
+ }
+ irc_svsnick(opserv, target, argv[2]);
+ return 1;
+}
+
static MODCMD_FUNC(cmd_join)
{
struct userNode *bot = cmd->parent->bot;
static MODCMD_FUNC(cmd_svspart)
{
struct userNode *target;
+ struct chanNode *target_channel;
if(!IsChannelName(argv[2])) {
reply("MSG_NOT_CHANNEL_NAME");
return 0;
}
+ if(!(target_channel = GetChannel(argv[2])))
+ {
+ reply("MSG_INVALID_CHANNEL");
+ return 0;
+ }
target = GetUserH(argv[1]);
if (!target) {
reply("MSG_NICK_UNKNOWN", argv[1]);
return 0;
}
- if (!(channel = GetChannel(argv[2]))) {
- reply("OSMSG_NOT_ON_CHANNEL", cmd->parent->bot->nick, channel->name);
- return 0;
- }
-
- if (!GetUserMode(channel, target)) {
- reply("OSMSG_NOT_ON_CHANNEL", cmd->parent->bot->nick, channel->name);
+ if (!GetUserMode(target_channel, target)) {
+ reply("OSMSG_NOT_ON_CHANNEL", cmd->parent->bot->nick, target_channel->name);
return 0;
}
- irc_svspart(opserv, target, channel);
+ irc_svspart(opserv, target, target_channel);
reply("OSMSG_SVSPART_SENT");
return 1;
}
if (IsDeaf(target)) buffer[bpos++] = 'd';
if (target->handle_info) buffer[bpos++] = 'r';
if (IsHiddenHost(target)) buffer[bpos++] = 'x';
+ if (IsBotM(target)) buffer[bpos++] = 'B';
+ if (IsHideChans(target)) buffer[bpos++] = 'n';
+ if (IsHideIdle(target)) buffer[bpos++] = 'I';
+ if (IsXtraOp(target)) buffer[bpos++] = 'X';
if (IsGagged(target)) buffer_cat(" (gagged)");
if (IsRegistering(target)) buffer_cat(" (registered account)");
buffer[bpos] = 0;
dict_iterator_t it;
struct opserv_user_alert *alert;
const char *reaction;
+ char t_buffer[INTERVALLEN];
char *m = NULL;
if(argc > 1)
}
reply("OSMSG_ALERT_IS", iter_key(it), reaction, alert->owner);
reply("OSMSG_ALERTS_DESC", alert->text_discrim);
+ if (alert->last > 0)
+ reply("OSMSG_ALERTS_LAST", intervalString(t_buffer, now - alert->last, user->handle_info));
+ else
+ reply("OSMSG_ALERTS_LAST", "Never");
}
reply("OSMSG_ALERT_END");
return 1;
}
if (checkDefCon(DEFCON_NO_NEW_CLIENTS)) {
- irc_kill(opserv, user, DefConGlineReason);
+ DelUser(user, opserv, 1, DefConGlineReason);
return 0;
}
return(max + 1);
}
else {
- log_module(MAIN_LOG, LOG_ERROR, "routing struct rank_outsideness() couldnt find %s", server);
+ log_module(MAIN_LOG, LOG_WARNING, "routing struct rank_outsideness() couldnt find %s", server);
return 0;
}
}
strcpy(lastserver, servicename);
rptr = find_routeList_server(route, self->uplink->name);
if(!rptr) {
- log_module(MAIN_LOG, LOG_ERROR, "Cannot convert routing map to center: My uplink is not on the map! Marking map as uncentered.");
+ log_module(MAIN_LOG, LOG_WARNING, "Cannot convert routing map to center: My uplink is not on the map! Marking map as uncentered.");
route->centered = false;
return false;
}
/* since it doesnt exist, remove the active setting */
dict_remove(opserv_routing_plan_options, plan_name);
}
- log_module(MAIN_LOG, LOG_ERROR, "activate_routing() couldnt find active routing plan!");
+ log_module(MAIN_LOG, LOG_WARNING, "activate_routing() couldnt find active routing plan!");
return 0;
}
}
char *active;
struct routingPlan *rp;
struct routingPlanServer *rps;
- log_module(MAIN_LOG, LOG_ERROR, "Failed to connect %s to %s: %s", server, source->name, message);
+ log_module(MAIN_LOG, LOG_WARNING, "Failed to connect %s to %s: %s", server, source->name, message);
/* remove the waiting connection n timeq */
routing_delete_connect_timer(server);
/* check if routing is active.. */
}
static struct opserv_user_alert *
-opserv_add_user_alert(struct userNode *req, const char *name, opserv_alert_reaction reaction, const char *text_discrim)
+opserv_add_user_alert(struct userNode *req, const char *name, opserv_alert_reaction reaction, const char *text_discrim, int last)
{
unsigned int wordc;
char *wordv[MAXNUMPARAMS], *discrim_copy;
alert = malloc(sizeof(*alert));
alert->owner = strdup(req->handle_info ? req->handle_info->handle : req->nick);
alert->text_discrim = strdup(text_discrim);
+ alert->last = last;
discrim_copy = strdup(text_discrim); /* save a copy of the discrim */
wordc = split_line(discrim_copy, false, ArrayLength(wordv), wordv);
alert->discrim = opserv_discrim_create(req, opserv, wordc, wordv, 0);
add_user_alert(const char *key, void *data, UNUSED_ARG(void *extra))
{
dict_t alert_dict;
+ char *str;
+ int last = 0;
const char *discrim, *react, *owner;
opserv_alert_reaction reaction;
struct opserv_user_alert *alert;
}
discrim = database_get_data(alert_dict, KEY_DISCRIM, RECDB_QSTRING);
react = database_get_data(alert_dict, KEY_REACTION, RECDB_QSTRING);
+ str = database_get_data(alert_dict, KEY_LAST, RECDB_QSTRING);
+ if (str)
+ last = atoi(str);
+
if (!react || !irccasecmp(react, "notice"))
reaction = REACT_NOTICE;
else if (!irccasecmp(react, "kill"))
log_module(OS_LOG, LOG_ERROR, "Invalid reaction %s for alert %s.", react, key);
return 0;
}
- alert = opserv_add_user_alert(opserv, key, reaction, discrim);
+ alert = opserv_add_user_alert(opserv, key, reaction, discrim, last);
if (!alert) {
log_module(OS_LOG, LOG_ERROR, "Unable to create alert %s from database.", key);
return 0;
saxdb_start_record(ctx, iter_key(it), 0);
saxdb_write_string(ctx, KEY_DISCRIM, alert->text_discrim);
saxdb_write_string(ctx, KEY_OWNER, alert->owner);
+ saxdb_write_int(ctx, KEY_LAST, alert->last);
switch (alert->reaction) {
case REACT_NOTICE: reaction = "notice"; break;
case REACT_KILL: reaction = "kill"; break;
discrim->domain_depth = strtoul(argv[++i], NULL, 0);
} else if (irccasecmp(argv[i], "clones") == 0) {
discrim->min_clones = strtoul(argv[++i], NULL, 0);
+ } else if (irccasecmp(argv[i], "modes") == 0) {
+ discrim->modes = argv[++i];
} else {
send_message(user, bot, "MSG_INVALID_CRITERIA", argv[i]);
goto fail;
{
if(discrim->mask_nick)
{
- int err = regcomp(&discrim->regex_nick, discrim->mask_nick, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ int err = regcomp(&discrim->regex_nick, discrim->mask_nick, REG_EXTENDED|REG_NOSUB);
discrim->has_regex_nick = !err;
if(err)
{
if(discrim->mask_ident)
{
- int err = regcomp(&discrim->regex_ident, discrim->mask_ident, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ int err = regcomp(&discrim->regex_ident, discrim->mask_ident, REG_EXTENDED|REG_NOSUB);
discrim->has_regex_ident = !err;
if(err)
{
if(discrim->mask_host)
{
- int err = regcomp(&discrim->regex_host, discrim->mask_host, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ int err = regcomp(&discrim->regex_host, discrim->mask_host, REG_EXTENDED|REG_NOSUB);
discrim->has_regex_host = !err;
if(err)
{
if(discrim->mask_info)
{
- int err = regcomp(&discrim->regex_info, discrim->mask_info, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ int err = regcomp(&discrim->regex_info, discrim->mask_info, REG_EXTENDED|REG_NOSUB);
discrim->has_regex_info = !err;
if(err)
{
if(discrim->mask_version)
{
- int err = regcomp(&discrim->regex_version, discrim->mask_version, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ int err = regcomp(&discrim->regex_version, discrim->mask_version, REG_EXTENDED|REG_NOSUB);
discrim->has_regex_version = !err;
if(err)
{
return 0;
}
+ if (discrim->modes) {
+ unsigned int ii, matches = 0;
+ for (ii = 0; ii < strlen(discrim->modes); ii++) {
+ switch(discrim->modes[ii]) {
+ case 'O':
+ if(IsOper(user)) matches++;
+ break;
+ case 'o':
+ if(IsOper(user)) matches++;
+ break;
+ case 'i':
+ if(IsInvisible(user)) matches++;
+ break;
+ case 'w':
+ if(IsWallOp(user)) matches++;
+ break;
+ case 's':
+ if(IsServNotice(user)) matches++;
+ break;
+ case 'd':
+ if(IsDeaf(user)) matches++;
+ break;
+ case 'k':
+ if(IsService(user)) matches++;
+ break;
+ case 'g':
+ if(IsGlobal(user)) matches++;
+ break;
+ case 'h':
+ if(IsSetHost(user)) matches++;
+ break;
+ case 'B':
+ if(IsBotM(user)) matches++;
+ break;
+ case 'n':
+ if(IsHideChans(user)) matches++;
+ break;
+ case 'I':
+ if(IsHideIdle(user)) matches++;
+ break;
+ case 'X':
+ if(IsXtraOp(user)) matches++;
+ break;
+ case 'x':
+ if(IsHiddenHost(user)) matches++;
+ break;
+ }
+ }
+ if (matches != strlen(discrim->modes)) return 0;
+ }
+
access = user->handle_info ? user->handle_info->opserv_level : 0;
if ((access < discrim->min_level)
|| (access > discrim->max_level)) {
if (alert->discrim->option_log)
log_module(OS_LOG, LOG_INFO, "Alert %s triggered by user %s!%s@%s (%s).", key, user->nick, user->ident, user->hostname, alert->discrim->reason);
+ alert->last = now;
+
/* Return 1 to halt alert matching, such as when killing the user
that triggered the alert. */
switch (alert->reaction) {
return 0;
}
if (!svccmd_can_invoke(user, opserv_service->bot, subcmd, channel, SVCCMD_NOISY)
- || !opserv_add_user_alert(user, name, reaction, unsplit_string(argv + 3, argc - 3, NULL))) {
+ || !opserv_add_user_alert(user, name, reaction, unsplit_string(argv + 3, argc - 3, NULL), 0)) {
reply("OSMSG_ALERT_ADD_FAILED");
return 0;
}
opserv_define_func("INVITE", cmd_invite, 100, 2, 0);
opserv_define_func("INVITEME", cmd_inviteme, 100, 0, 0);
opserv_define_func("JOIN", cmd_join, 601, 0, 2);
+ opserv_define_func("SVSNICK", cmd_svsnick, 999, 0, 3);
opserv_define_func("SVSJOIN", cmd_svsjoin, 999, 0, 3);
opserv_define_func("SVSPART", cmd_svspart, 999, 0, 3);
opserv_define_func("JUMP", cmd_jump, 900, 0, 2);
projects / irc / evilnet / x3.git / blobdiff