*
* x3 is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/
+#include "config.h"
+#include "chanserv.h"
#include "conf.h"
#include "common.h"
#include "gline.h"
#include <arpa/inet.h>
#endif
-
#define OPSERV_CONF_NAME "services/opserv"
#define KEY_ALERT_CHANNEL "alert_channel"
{ "OSMSG_ALREADY_THERE", "You are 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_SVSJOIN_SENT", "Sent the SVSJOIN." },
{ "OSMSG_SVSPART_SENT", "Sent the SVSPART." },
{ "OSMSG_ALREADY_JOINED", "I am already in $b%s$b." },
{ "OSMSG_NOT_ON_CHANNEL", "$b%s$b does not seem to be on $b%s$b." },
{ "OSMSG_KICKALL_DONE", "I have cleared out %s." },
{ "OSMSG_LEAVING", "Leaving $b%s$b." },
+ { "OSMSG_MARK_INVALID", "Sorry, marks must contain only letters, numbers, and dashes ('-')." },
{ "OSMSG_MODE_SET", "I have set the modes for $b%s$b." },
{ "OSMSG_OP_DONE", "Opped the requested lusers." },
{ "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_WHOIS_CHANNELS", "Channels : %s" },
{ "OSMSG_WHOIS_HIDECHANS", "Channel list omitted for your sanity." },
{ "OSMSG_WHOIS_VERSION", "Version : %s" },
+ { "OSMSG_WHOIS_MARK", "Mark : %s" },
{ "OSMSG_WHOIS_NO_NOTICE", "No_notices : %s" },
{ "OSMSG_UNBAN_DONE", "Ban(s) removed from channel %s." },
{ "OSMSG_CHANNEL_VOICED", "All users on %s voiced." },
{ "OSMSG_USER_SEARCH_BAR", "-------------------------------------------" },
{ "OSMSG_USER_SEARCH_COUNT", "There were %4u matches" },
{ "OSMSG_USER_SEARCH_COUNT_BAR", "------------ Found %4u matches -----------" },
+ { "OSMSG_MARK_NO_MARK", "MARK action requires mark criteria (what do you want to mark them as?)" },
{ "OSMSG_SVSJOIN_NO_TARGET", "SVSJOIN action requires chantarget criteria (where should they join?)" },
{ "OSMSG_SVSPART_NO_TARGET", "SVSPART action requires chantarget criteria (where should they join?)" },
{ "OSMSG_CHANNEL_SEARCH_RESULTS", "The following channels were found:" },
typedef struct opservDiscrim {
struct chanNode *channel;
- char *mask_nick, *mask_ident, *mask_host, *mask_info, *mask_version, *server, *reason, *accountmask, *chantarget;
+ 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;
unsigned int intra_scmp : 2, intra_dcmp : 2;
unsigned int use_regex : 1;
unsigned int silent : 1;
+ unsigned int checkrestrictions : 2;
} *discrim_t;
struct discrim_and_source {
REACT_SHUN,
REACT_SVSJOIN,
REACT_SVSPART,
- REACT_VERSION
+ REACT_VERSION,
+ REACT_MARK
} opserv_alert_reaction;
struct opserv_user_alert {
}
static void
-opserv_svsjoin(struct userNode *target, UNUSED_ARG(char *src_handle), UNUSED_ARG(char *reason), char *channame)
+opserv_mark(struct userNode *target, UNUSED_ARG(char *src_handle), UNUSED_ARG(char *reason), char *mark)
+{
+ if(!mark)
+ return;
+ irc_mark(target, mark);
+}
+
+static void
+opserv_svsjoin(struct userNode *target, UNUSED_ARG(char *src_handle), UNUSED_ARG(char *reason), char *channame, unsigned int checkrestrictions)
{
struct chanNode *channel;
return;
}
+ if (checkrestrictions) {
+ if (trace_check_bans(target, channel) == 1) {
+ return; /* found on lamer list */
+ }
+
+ if (channel->modes & MODE_INVITEONLY) {
+ return; /* channel is invite only */
+ }
+
+ if (channel->limit > 0) {
+ if (channel->members.used >= channel->limit) {
+ return; /* channel is invite on */
+ }
+ }
+
+ if (*channel->key) {
+ return; /* channel is password protected */
+ }
+ }
+
irc_svsjoin(opserv, target, channel);
/* Should we tell the user they got joined? -Rubin*/
}
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;
return 1;
}
+int is_valid_mark(char *mark)
+{
+ char *ptr;
+
+ if(!mark || !*mark)
+ return 0;
+ if(strlen(mark) > MARKLEN)
+ return 0;
+
+ for(ptr = mark; *ptr; ptr++) {
+ if(! (isalnum(*ptr) || *ptr == '-'))
+ return 0;
+ }
+
+ return 1;
+}
+
+static MODCMD_FUNC(cmd_mark)
+{
+ char *mark = argv[2];
+ struct userNode *victim = GetUserH(argv[1]);
+
+ if(!victim)
+ reply("MSG_NICK_UNKNOWN", argv[1]);
+ else if(!is_valid_mark(mark))
+ reply("OSMSG_MARK_INVALID");
+ else {
+ irc_mark(victim, mark);
+ reply("OSMSG_MARK_SET");
+ return 1;
+ }
+ return 0;
+}
+
static MODCMD_FUNC(cmd_op)
{
struct mod_chanmode *change;
if(target->version_reply) {
reply("OSMSG_WHOIS_VERSION", target->version_reply);
}
+ if(target->mark) {
+ reply("OSMSG_WHOIS_MARK", target->mark);
+ }
reply("OSMSG_WHOIS_NO_NOTICE", target->no_notice ? "YES":"NO");
if (target->modes) {
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;
reply("OSMSG_ALERTS_BAR");
for (it = dict_first(opserv_user_alerts); it; it = iter_next(it)) {
alert = iter_data(it);
- if(m && (!match_ircglob(alert->text_discrim, m) && strcasecmp(alert->owner, m)) )
+ if(m && (!match_ircglob(alert->text_discrim, m) && strcasecmp(alert->owner, m) && strcasecmp(iter_key(it), m)))
continue; /* not a match to requested filter */
switch (alert->reaction) {
case REACT_NOTICE: reaction = "notice"; break;
case REACT_SVSJOIN: reaction = "svsjoin"; break;
case REACT_SVSPART: reaction = "svspart"; break;
case REACT_VERSION: reaction = "version"; break;
+ case REACT_MARK: reaction = "mark"; break;
default: reaction = "<unknown>"; break;
}
reply("OSMSG_ALERT_IS", iter_key(it), reaction, alert->owner);
}
if (checkDefCon(DEFCON_NO_NEW_CLIENTS)) {
- irc_kill(opserv, user, DefConGlineReason);
+ DelUser(user, opserv, 1, DefConGlineReason);
return 0;
}
if(text[0] == '\001') {
text++;
cmd = mysep(&text, " ");
- if(!irccasecmp(cmd, "VERSION")) {
+ if(cmd && !irccasecmp(cmd, "VERSION")) {
char *version = mysep(&text, "\n");
if(!version)
version = "";
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;
}
}
/* Delete the existing active route */
wipe_route_list(opserv_route);
+ if(!rp || !rp->servers)
+ return 1;
for(it = dict_first(rp->servers); it; it = iter_next(it)) {
const char* servername = iter_key(it);
struct routingPlanServer *rps = iter_data(it),
return; /* retry_period set to 0, disable */
/* opserv_debug("Reroute timer checking reroute"); */
- log_module(MAIN_LOG, LOG_ERROR, "Reroute timer checking reroute()");
+ log_module(MAIN_LOG, LOG_DEBUG, "Reroute timer checking reroute()");
/* Do the reroute C attempt */
if(data)
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.. */
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);
+ /* Check for missing required criteria or broken records */
if (!alert->discrim || (reaction==REACT_SVSJOIN && !alert->discrim->chantarget) ||
- (reaction==REACT_SVSPART && !alert->discrim->chantarget)) {
+ (reaction==REACT_SVSPART && !alert->discrim->chantarget) ||
+ (reaction==REACT_MARK && !alert->discrim->mark)) {
free(alert->text_discrim);
free(discrim_copy);
free(alert);
reaction = REACT_SVSPART;
else if (!irccasecmp(react, "version"))
reaction = REACT_VERSION;
+ else if (!irccasecmp(react, "mark"))
+ reaction = REACT_MARK;
else {
log_module(OS_LOG, LOG_ERROR, "Invalid reaction %s for alert %s.", react, key);
return 0;
case REACT_SVSJOIN: reaction = "svsjoin"; break;
case REACT_SVSPART: reaction = "svspart"; break;
case REACT_VERSION: reaction = "version"; break;
+ case REACT_MARK: reaction = "mark"; break;
default:
reaction = NULL;
log_module(OS_LOG, LOG_ERROR, "Invalid reaction type %d for alert %s (while writing database).", alert->reaction, iter_key(it));
}
discrim->accountmask = argv[++i];
discrim->authed = 1;
+ } else if (irccasecmp(argv[i], "marked") == 0) {
+ discrim->mask_mark = argv[++i];
} else if (irccasecmp(argv[i], "chantarget") == 0) {
if(!IsChannelName(argv[i+1])) {
send_message(user, bot, "MSG_NOT_CHANNEL_NAME");
goto fail;
}
discrim->chantarget = argv[++i];
+ } else if (irccasecmp(argv[i], "checkrestrictions") == 0) {
+ i++;
+ if (true_string(argv[i])) {
+ discrim->checkrestrictions = 1;
+ } else if (false_string(argv[i])) {
+ discrim->checkrestrictions = 0;
+ } else {
+ send_message(user, bot, "MSG_INVALID_BINARY", argv[i]);
+ goto fail;
+ }
+ } else if (irccasecmp(argv[i], "mark") == 0) {
+ if(!is_valid_mark(argv[i+1])) {
+ send_message(user, bot, "OSMSG_MARK_INVALID");
+ goto fail;
+ }
+ discrim->mark = argv[++i];
} else if (irccasecmp(argv[i], "authed") == 0) {
i++; /* true_string and false_string are macros! */
if (true_string(argv[i])) {
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)
{
|| (discrim->info_space == 0 && user->info[0] == ' ')
|| (discrim->info_space == 1 && user->info[0] != ' ')
|| (discrim->server && !match_ircglob(user->uplink->name, discrim->server))
+ || (discrim->mask_mark && (!user->mark || !match_ircglob(user->mark, discrim->mask_mark)))
|| (discrim->accountmask && (!user->handle_info || !match_ircglob(user->handle_info->handle, discrim->accountmask)))
|| (discrim->ip_mask_bits && !irc_check_mask(&user->ip, &discrim->ip_mask, discrim->ip_mask_bits))
)
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)) {
return 0;
}
+static int
+trace_mark_func(struct userNode *match, void *extra)
+{
+ struct discrim_and_source *das = extra;
+ char *mark = das->discrim->mark;
+
+ if(!mark)
+ return 1;
+ irc_mark(match, mark);
+ return 0;
+}
+
static int
trace_svsjoin_func(struct userNode *match, void *extra)
{
struct discrim_and_source *das = extra;
char *channame = das->discrim->chantarget;
+ int checkrestrictions = das->discrim->checkrestrictions;
struct chanNode *channel;
if(!channame || !IsChannelName(channame)) {
if (!(channel = GetChannel(channame))) {
channel = AddChannel(channame, now, NULL, NULL, NULL);
}
+
+ if (checkrestrictions) {
+ if (trace_check_bans(match, channel) == 1) {
+ return 1; /* found on lamer list */
+ }
+
+ if (channel->modes & MODE_INVITEONLY) {
+ return 1; /* channel is invite only */
+ }
+
+ if (channel->limit > 0) {
+ if (channel->members.used >= channel->limit) {
+ return 1; /* channel is invite on */
+ }
+ }
+
+ if (*channel->key) {
+ return 1; /* channel is password protected */
+ }
+ }
+
if (GetUserMode(channel, match)) {
// reply("OSMSG_ALREADY_THERE", channel->name);
return 1;
action = trace_svspart_func;
else if (!irccasecmp(argv[1], "version"))
action = trace_version_func;
+ else if (!irccasecmp(argv[1], "mark"))
+ action = trace_mark_func;
else {
reply("OSMSG_BAD_ACTION", argv[1]);
return 0;
reply("OSMSG_SVSPART_NO_TARGET");
ret = 0;
}
+ else if (action == trace_mark_func && !das.discrim->mark) {
+ reply("OSMSG_MARK_NO_MARK");
+ ret = 0;
+ }
else {
matches = opserv_discrim_search(das.discrim, action, &das);
opserv_shun(user, alert->owner, alert->discrim->reason, alert->discrim->duration);
return 1;
case REACT_SVSJOIN:
- opserv_svsjoin(user, alert->owner, alert->discrim->reason, alert->discrim->chantarget);
+ opserv_svsjoin(user, alert->owner, alert->discrim->reason, alert->discrim->chantarget, alert->discrim->checkrestrictions);
break;
case REACT_SVSPART:
opserv_svspart(user, alert->owner, alert->discrim->reason, alert->discrim->chantarget);
if(!user->version_reply)
opserv_version(user);
break;
+ case REACT_MARK:
+ opserv_mark(user, alert->owner, alert->discrim->reason, alert->discrim->mark);
+ break;
default:
log_module(OS_LOG, LOG_ERROR, "Invalid reaction type %d for alert %s.", alert->reaction, key);
/* fall through to REACT_NOTICE case */
reaction = REACT_SVSPART;
else if(!irccasecmp(argv[2], "version"))
reaction = REACT_VERSION;
+ else if(!irccasecmp(argv[2], "mark"))
+ reaction = REACT_MARK;
else {
reply("OSMSG_UNKNOWN_REACTION", argv[2]);
return 0;
opserv_define_func("ADDALERT SVSJOIN", NULL, 999, 0, 0);
opserv_define_func("ADDALERT SVSPART", NULL, 999, 0, 0);
opserv_define_func("ADDALERT VERSION", NULL, 999, 0, 0);
+ opserv_define_func("ADDALERT MARK", NULL, 999, 0, 0);
opserv_define_func("ADDBAD", cmd_addbad, 800, 0, 2);
opserv_define_func("ADDEXEMPT", cmd_addexempt, 800, 0, 2);
opserv_define_func("ADDTRUST", cmd_addtrust, 800, 0, 5);
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);
opserv_define_func("KICKBANALL", cmd_kickbanall, 450, 2, 0);
opserv_define_func("LOG", cmd_log, 900, 0, 2);
opserv_define_func("MODE", cmd_mode, 100, 2, 2);
+ opserv_define_func("MARK", cmd_mark, 900, 0, 3);
opserv_define_func("OP", cmd_op, 100, 2, 2);
opserv_define_func("OPALL", cmd_opall, 400, 2, 0);
opserv_define_func("HOP", cmd_hop, 100, 2, 2);
opserv_define_func("TRACE VERSION", NULL, 999, 0, 0);
opserv_define_func("TRACE SVSJOIN", NULL, 999, 0, 0);
opserv_define_func("TRACE SVSPART", NULL, 999, 0, 0);
+ opserv_define_func("TRACE MARK", NULL, 999, 0, 0);
opserv_define_func("UNBAN", cmd_unban, 100, 2, 2);
opserv_define_func("UNGAG", cmd_ungag, 600, 0, 2);
opserv_define_func("UNGLINE", cmd_ungline, 600, 0, 2);
projects / irc / evilnet / x3.git / blobdiff