X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/5b1166fd070aa5309698541178ea12a3adcce16e..da5b7dfc7a674db48cc4bcb478672263b3db714f:/src/opserv.c diff --git a/src/opserv.c b/src/opserv.c index c3942df..2ca906c 100644 --- a/src/opserv.c +++ b/src/opserv.c @@ -19,17 +19,19 @@ */ #include "conf.h" +#include "common.h" #include "gline.h" #include "global.h" #include "nickserv.h" #include "modcmd.h" #include "modules.h" +#include "proto.h" #include "opserv.h" #include "timeq.h" #include "saxdb.h" #include "shun.h" -#include +#include #ifdef HAVE_SYS_TIMES_H #include @@ -85,6 +87,46 @@ #define KEY_ISSUED "issued" #define KEY_ADMIN_LEVEL "admin_level" #define KEY_SILENT_LEVEL "silent_level" +#define KEY_UPLINK "uplink" +#define KEY_SECOND "secondaryuplink" +#define KEY_PORT "port" +#define KEY_KARMA "karma" +#define KEY_OFFLINE "offline" +#define KEY_ROUTINGPLAN "routingplan" +#define KEY_ROUTINGPLAN_OPTIONS "routingplan_options" +#define KEY_DEFCON1 "DefCon1" +#define KEY_DEFCON2 "DefCon2" +#define KEY_DEFCON3 "DefCon3" +#define KEY_DEFCON4 "DefCon4" +#define KEY_DEFCON_LEVEL "DefConLevel" +#define KEY_DEFCON_CHANMODES "DefConChanModes" +#define KEY_DEFCON_SESSION_LIMIT "DefConSessionLimit" +#define KEY_DEFCON_TIMEOUT "DefConTimeOut" +#define KEY_DEFCON_GLOBAL "GlobalOnDefcon" +#define KEY_DEFCON_GLOBAL_MORE "GlobalOnDefconMore" +#define KEY_DEFCON_MESSAGE "DefconMessage" +#define KEY_DEFCON_OFF_MESSAGE "DefConOffMessage" +#define KEY_DEFCON_GLINE_DURATION "DefConGlineExpire" +#define KEY_DEFCON_GLINE_REASON "DefConGlineReason" + +/* Routing karma values: */ +/* What value we start out with when new servers are added: */ +#define KARMA_DEFAULT 10 + /* max, min */ +#define KARMA_MAX 10 +#define KARMA_MIN -10 +/* ping out, reduce karma by this much: */ +#define KARMA_PINGOUT -8 +/* read err, reduce karma by this much: */ +#define KARMA_READERROR -5 +/* every 24 hours everyone gets this much added (so we eventually re-try bad servers) */ +#define KARMA_ENTROPE 1 +/* every 24 hours servers linked for 24 hours get an additional ammount: */ +#define KARMA_RELIABLE 1 +/* How often to run entrope and reliable checks */ +#define KARMA_TIMER 86400 /* 1 day */ + +#define ROUTING_CONNECT_TIMEOUT 30 /* 30 seconds */ #define IDENT_FORMAT "%s [%s@%s/%s]" #define IDENT_DATA(user) user->nick, user->ident, user->hostname, irc_ntoa(&user->ip) @@ -121,7 +163,10 @@ static const struct message_entry msgtab[] = { { "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_NOT_THERE", "You not in $b%s$b." }, { "OSMSG_JOIN_DONE", "I have joined $b%s$b." }, + { "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." }, @@ -132,20 +177,33 @@ static const struct message_entry msgtab[] = { { "OSMSG_HOP_DONE", "Halfopped the requested lusers." }, { "OSMSG_HOPALL_DONE", "Halfopped everyone on $b%s$b." }, { "OSMSG_WHOIS_IDENT", "%s (%s@%s) from %d.%d.%d.%d" }, - { "OSMSG_WHOIS_NICK", "Nick : %s" }, - { "OSMSG_WHOIS_HOST", "Host : %s@%s" }, - { "OSMSG_WHOIS_FAKEHOST", "Fakehost : %s" }, - { "OSMSG_WHOIS_CRYPT_HOST", "Crypt Host : %s" }, - { "OSMSG_WHOIS_CRYPT_IP", "Crypt IP : %s" }, - { "OSMSG_WHOIS_IP", "Real IP : %s" }, - { "OSMSG_WHOIS_MODES", "Modes : +%s " }, - { "OSMSG_WHOIS_INFO", "Info : %s" }, - { "OSMSG_WHOIS_NUMERIC", "Numnick : %s" }, - { "OSMSG_WHOIS_SERVER", "Server : %s" }, - { "OSMSG_WHOIS_NICK_AGE", "Nick Age : %s" }, - { "OSMSG_WHOIS_ACCOUNT", "Account : %s" }, - { "OSMSG_WHOIS_CHANNELS", "Channels : %s" }, + { "OSMSG_WHOIS_NICK", "Nick : %s" }, + { "OSMSG_WHOIS_HOST", "Host : %s@%s" }, + { "OSMSG_WHOIS_FAKEHOST", "Fakehost : %s" }, + { "OSMSG_WHOIS_CRYPT_HOST", "Crypt Host : %s" }, + { "OSMSG_WHOIS_CRYPT_IP", "Crypt IP : %s" }, + { "OSMSG_WHOIS_IP", "Real IP : %s" }, + { "OSMSG_WHOIS_COUNTRY", "Country : %s" }, + { "OSMSG_WHOIS_COUNTRY_CODE","Country Code : %s" }, + { "OSMSG_WHOIS_CITY", "City : %s" }, + { "OSMSG_WHOIS_REGION", "Region/State : %s" }, + { "OSMSG_WHOIS_POSTAL_CODE","Postal Code : %s" }, + { "OSMSG_WHOIS_LATITUDE", "Latitude : %f" }, + { "OSMSG_WHOIS_LONGITUDE", "Longitude : %f" }, + { "OSMSG_WHOIS_MAP", "Map : %s" }, + { "OSMSG_WHOIS_DMA_CODE", "DMA Code : %d" }, + { "OSMSG_WHOIS_AREA_CODE", "Area Code : %d" }, + { "OSMSG_WHOIS_MODES", "Modes : +%s " }, + { "OSMSG_WHOIS_INFO", "Info : %s" }, + { "OSMSG_WHOIS_NUMERIC", "Numnick : %s" }, + { "OSMSG_WHOIS_SERVER", "Server : %s" }, + { "OSMSG_WHOIS_NICK_AGE", "Nick Age : %s" }, + { "OSMSG_WHOIS_ACCOUNT", "Account : %s" }, + { "OSMSG_WHOIS_PRIVS", "IRCd Privs : %s" }, + { "OSMSG_WHOIS_CHANNELS", "Channels : %s" }, { "OSMSG_WHOIS_HIDECHANS", "Channel list omitted for your sanity." }, + { "OSMSG_WHOIS_VERSION", "Version : %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_CHANNEL_DEVOICED", "All voiced users on %s de-voiced." }, @@ -222,6 +280,8 @@ static const struct message_entry msgtab[] = { { "OSMSG_USER_SEARCH_BAR", "-------------------------------------------" }, { "OSMSG_USER_SEARCH_COUNT", "There were %4u matches" }, { "OSMSG_USER_SEARCH_COUNT_BAR", "------------ Found %4u matches -----------" }, + { "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:" }, { "OSMSG_GLINE_SEARCH_RESULTS", "The following glines were found:" }, { "OSMSG_SHUN_SEARCH_RESULTS", "The following shun were found:" }, @@ -241,14 +301,55 @@ static const struct message_entry msgtab[] = { { "OSMSG_ALERT_EXISTS", "An alert named $b%s$b already exists." }, { "OSMSG_UNKNOWN_REACTION", "Unknown alert reaction $b%s$b." }, { "OSMSG_ADDED_ALERT", "Added alert named $b%s$b." }, + { "OSMSG_ALERT_ADD_FAILED", "Unable to add alert. Check syntax, required parts, and access" }, { "OSMSG_REMOVED_ALERT", "Removed alert named $b%s$b." }, { "OSMSG_NO_SUCH_ALERT", "No alert named $b%s$b could be found." }, - { "OSMSG_ALERTS_LIST", "$bCurrent $O alerts$b" }, + { "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_ALERT_IS", "$b%-20s$b %-6s (by %s)" }, { "OSMSG_ALERT_END", "----------------End of Alerts-----------------" }, + /* routing messages */ + { "OSMSG_ROUTINGPLAN_LIST", "$bRouting Plans$b" }, + { "OSMSG_ROUTINGPLAN_BAR", "----------------------------------------------" }, + { "OSMSG_ROUTINGPLAN_END", "-------------End of Routing Plans-------------" }, + { "OSMSG_ROUTINGPLAN_OPTION", "%s is set to %s" }, + { "OSMSG_ROUTINGPLAN_ACTIVE", "Auto routing is active, using plan '%s'." }, + { "OSMSG_ROUTING_ACTIVATION_ERROR", "There was an error activating the routing plan. Check for loops, and make sure the map includes my own uplink." }, + { "OSMSG_ROUTINGPLAN_OPTION_NOT_FOUND", "There is no routing plan option '%s'." }, + { "OSMSG_ROUTINGPLAN_OPTION_NOT_SET", "Option '%s' is not currently set." }, + { "OSMSG_ROUTINGPLAN_NAME", "$b%s:$b" }, + { "OSMSG_ROUTINGPLAN_SERVER"," %s:%d <-- %s[%d/%s] (%s)" }, + { "OSMSG_ADDPLAN_SUCCESS", "Added new routing plan '%s'." }, + { "OSMSG_ADDPLAN_FAILED", "Could not add new plan '%s' (does it already exist?)." }, + { "OSMSG_INVALID_PLAN", "That routing plan name is not valid." }, + { "OSMSG_PLAN_DELETED", "The routing plan was sucessfully deleted." }, + { "OSMSG_PLAN_NOT_FOUND", "There is no routing plan called '%s'." }, + { "OSMSG_PLAN_SERVER_ADDED", "Added %s to the routing plan." }, + { "OSMSG_PLAN_SERVER_DELETED", "The server has been deleted." }, + { "OSMSG_PLAN_SERVER_NOT_FOUND", "The server '%s' was not found in that routing plan." }, + { "OSMSG_ROUTING_DISABLED", "Routing is now disabled." }, + { "OSMSG_DOWNLINKS_FORMAT_A", "%s%s-$b%s$b [%s]" }, + { "OSMSG_DOWNLINKS_FORMAT_B", "$b%s$b (me)" }, + { "OSMSG_ROUTELIST_EMPTY", "No servers in route list" }, + { "OSMSG_ROUTELIST_AS_PLANNED", "Routing plan: Servers as they SHOULD be linked" }, + { "OSMSG_MAP_CENTERED", "map %s centered, Maxdepth:%d" }, + { "OSMSG_NO_SERVERS_MISSING", "No servers are missing." }, + { "OSMSG_CONNECTING_MISSING", "Attempted to connect %d missing servers." }, + { "OSMSG_CONNECT", "->connect %s %d %s" }, + { "OSMSG_SQUIT", "->squit %s" }, + { "OSMSG_COULDNT_FIND_SERVER", "Couldnt find %s, so using %s to link %s" }, + { "OSMSG_INSPECTING_SERVER", "Inspecting server [%s]" }, + { "OSMSG_REROUTING_ACC_MAP", "Rerouting network according to loaded map.." }, + { "OSMSG_REROUTING_NOTCONFIGURED", "You have not configured routing. See $/msg $O help routing$b." }, + { "OSMSG_CONNECTING_MISSING_ONLY", "Connecting missing servers only.." }, + { "OSMSG_NO_ROUTING_NECESSARY", "No rerouting appears necessary." }, + { "OSMSG_TESTING_REROUTE", "Testing Reroute(): Commands not sent to socket.." }, + { "OSMSG_INVALID_DIRECTIVE", "Reroute(): Invalid directive %s", }, + { "OSMSG_UPLINKS_MISSING", "%d servers' uplinks were missing, and were not connected." }, + { "OSMSG_REROUTE_COMPLETE", "Reroute complete: Moved %d, connected %d, total %d changes." }, + /* end of routing */ { "OSMSG_REHASH_COMPLETE", "Completed rehash of configuration database." }, { "OSMSG_REHASH_FAILED", "Rehash of configuration database failed, previous configuration is intact." }, { "OSMSG_REOPEN_COMPLETE", "Closed and reopened all log files." }, @@ -257,6 +358,8 @@ static const struct message_entry msgtab[] = { { "OSMSG_NAME_COLLIDE", "That name is already in use." }, { "OSMSG_SRV_CREATE_FAILED", "Server creation failed -- check log files." }, { "OSMSG_SERVER_JUPED", "Added new jupe server %s." }, + { "OSMSG_INVALID_NUMERIC", "Invalid numeric" }, + { "OSMSG_INVALID_SERVERNAME", "Server name must contain a '.'." }, { "OSMSG_SERVER_NOT_JUPE", "That server is not a juped server." }, { "OSMSG_SERVER_UNJUPED", "Server jupe removed." }, /* @@ -293,11 +396,43 @@ static const struct message_entry msgtab[] = { { "OSMSG_INVALID_REGEX", "Invalid regex: %s: %s (%d)" }, { "OSMSG_TRACK_DISABLED", "Tracking is not currently compiled into X3" }, { "OSMSG_MAXUSERS_RESET", "Max clients has been reset to $b%d$b" }, + + { "OSMSG_DEFCON_INVALID", "DefCon level %d is invalid, please choose a value between 1 and 5" }, + { "OSMSG_DEFCON_ALLOWING_ALL", "DefCon is at level 5 and allowing everything" }, + { "OSMSG_DEFCON_DISALLOWING", "DefCon is at level %d and enforcing:" }, + { "OSMSG_DEFCON_NO_NEW_CHANNELS", "No Channel Registrations" }, + { "OSMSG_DEFCON_NO_NEW_NICKS", "No Nickname/Account Registrations" }, + { "OSMSG_DEFCON_NO_MODE_CHANGE", "No Channel Mode Changes" }, + { "OSMSG_DEFCON_NO_NEW_CLIENTS", "No New Clients" }, + { "OSMSG_DEFCON_FORCE_CHANMODES", "Forcing Channel Mode(s): %s" }, + { "OSMSG_DEFCON_REDUCE_SESSION", "Forcing Reduced Session: %d" }, + { "OSMSG_DEFCON_OPER_ONLY", "Allowing Services Communication With Opers Only" }, + { "OSMSG_DEFCON_SILENT_OPER_ONLY", "Allowing Services Communication With Opers Only AND Silently Ignoring Regular Users" }, + { "OSMSG_DEFCON_GLINE_NEW_CLIENTS", "Glining New Clients" }, + { "OSMSG_DEFCON_SHUN_NEW_CLIENTS", "Shunning New Clients" }, + { "OSMSG_DEFCON_NO_NEW_MEMOS", "Disallowing New Memos" }, + + { "OSMSG_PRIV_UNKNOWN", "Unknown privilege flag %s, see /msg $O HELP PRIVFLAGS for a flag list" }, + { "OSMSG_PRIV_SET", "Privilege flag %s has been %sset" }, + { NULL, NULL } }; #define OPSERV_SYNTAX() svccmd_send_help_brief(user, opserv, cmd) +int DefConLevel = 5; +int DefCon[6]; +int DefConTimeOut; +int GlobalOnDefcon = 0; +int GlobalOnDefconMore = 0; +int DefConGlineExpire; +int DefConModesSet = 0; +unsigned int DefConSessionLimit; +char *DefConChanModes; +char *DefConGlineReason; +char *DefConMessage; +char *DefConOffMessage; + extern void add_track_user(struct userNode *user); typedef int (*discrim_search_func)(struct userNode *match, void *extra); @@ -309,6 +444,9 @@ static dict_t opserv_reserved_nick_dict; /* data is struct userNode* */ static struct string_list *opserv_bad_words; static dict_t opserv_exempt_channels; /* data is not used */ static dict_t opserv_trusted_hosts; /* data is struct trusted_host* */ +static dict_t opserv_routing_plans; /* data is struct routingPlan */ +static dict_t opserv_routing_plan_options; /* data is a dict_t key->val list*/ +static dict_t opserv_waiting_connections; /* data is struct waitingConnection */ static dict_t opserv_hostinfo_dict; /* data is struct opserv_hostinfo* */ static dict_t opserv_user_alerts; /* data is struct opserv_user_alert* */ static dict_t opserv_nick_based_alerts; /* data is struct opserv_user_alert* */ @@ -318,6 +456,7 @@ static struct log_type *OS_LOG; static unsigned int new_user_flood; static char *level_strings[1001]; struct string_list *autojoin_channels; +struct route *opserv_route = NULL; /* Main active routing table from activate_routing()*/ static struct { struct chanNode *debug_channel; @@ -368,14 +507,23 @@ opserv_free_hostinfo(void *data) free(ohi); } +static void +opserv_free_waiting_connection(void *data) +{ + struct waitingConnection *wc = data; + free(wc->server); + free(wc->target); + free(wc); +} + typedef struct opservDiscrim { struct chanNode *channel; - char *mask_nick, *mask_ident, *mask_host, *mask_info, *server, *reason, *accountmask; + char *mask_nick, *mask_ident, *mask_host, *mask_info, *mask_version, *server, *reason, *accountmask, *chantarget; irc_in_addr_t ip_mask; unsigned long limit; time_t min_ts, max_ts; - regex_t regex_nick, regex_ident, regex_host, regex_info; - unsigned int has_regex_nick : 1, has_regex_ident : 1, has_regex_host : 1, has_regex_info : 1; + regex_t regex_nick, regex_ident, regex_host, regex_info, regex_version; + unsigned int has_regex_nick : 1, has_regex_ident : 1, has_regex_host : 1, has_regex_info : 1, has_regex_version : 1; unsigned int min_level, max_level, domain_depth, duration, min_clones, min_channels, max_channels; unsigned char ip_mask_bits; unsigned int match_opers : 1, option_log : 1; @@ -402,10 +550,12 @@ static int ungag_helper_func(struct userNode *match, void *extra); typedef enum { REACT_NOTICE, REACT_KILL, -// REACT_SILENT, REACT_GLINE, REACT_TRACK, - REACT_SHUN + REACT_SHUN, + REACT_SVSJOIN, + REACT_SVSPART, + REACT_VERSION } opserv_alert_reaction; struct opserv_user_alert { @@ -433,6 +583,8 @@ opserv_free_user_alert(void *data) regfree(&alert->discrim->regex_host); if(alert->discrim->has_regex_info) regfree(&alert->discrim->regex_info); + if(alert->discrim->has_regex_version) + regfree(&alert->discrim->regex_version); free(alert->discrim->reason); free(alert->discrim); free(alert); @@ -442,6 +594,212 @@ opserv_free_user_alert(void *data) #define opserv_alert(format...) do { if (opserv_conf.alert_channel) send_channel_notice(opserv_conf.alert_channel , opserv , ## format); } while (0) +char *defconReverseModes(const char *modes) +{ + char *newmodes = NULL; + unsigned int i = 0; + if (!modes) { + return NULL; + } + if (!(newmodes = malloc(sizeof(char) * strlen(modes) + 1))) { + return NULL; + } + for (i = 0; i < strlen(modes); i++) { + if (modes[i] == '+') + newmodes[i] = '-'; + else if (modes[i] == '-') + newmodes[i] = '+'; + else + newmodes[i] = modes[i]; + } + newmodes[i] = '\0'; + return newmodes; +} + +int checkDefCon(int level) +{ + return DefCon[DefConLevel] & level; +} + +void showDefConSettings(struct userNode *user, struct svccmd *cmd) +{ + if (DefConLevel == 5) { + reply("OSMSG_DEFCON_ALLOWING_ALL"); + return; + } else + reply("OSMSG_DEFCON_DISALLOWING", DefConLevel); + + if (checkDefCon(DEFCON_NO_NEW_CHANNELS)) + reply("OSMSG_DEFCON_NO_NEW_CHANNELS"); + + if (checkDefCon(DEFCON_NO_NEW_NICKS)) + reply("OSMSG_DEFCON_NO_NEW_NICKS"); + + if (checkDefCon(DEFCON_NO_MODE_CHANGE)) + reply("OSMSG_DEFCON_NO_MODE_CHANGE"); + + if (checkDefCon(DEFCON_FORCE_CHAN_MODES) && (DefConChanModes)) + reply("OSMSG_DEFCON_FORCE_CHANMODES", DefConChanModes); + + if (checkDefCon(DEFCON_REDUCE_SESSION)) + reply("OSMSG_DEFCON_REDUCE_SESSION", DefConSessionLimit); + + if (checkDefCon(DEFCON_NO_NEW_CLIENTS)) + reply("OSMSG_DEFCON_NO_NEW_CLIENTS"); + + if (checkDefCon(DEFCON_OPER_ONLY)) + reply("OSMSG_DEFCON_OPER_ONLY"); + + if (checkDefCon(DEFCON_SILENT_OPER_ONLY)) + reply("OSMSG_DEFCON_SILENT_OPER_ONLY"); + + if (checkDefCon(DEFCON_GLINE_NEW_CLIENTS)) + reply("OSMSG_DEFCON_GLINE_NEW_CLIENTS"); + + if (checkDefCon(DEFCON_SHUN_NEW_CLIENTS)) + reply("OSMSG_DEFCON_SHUN_NEW_CLIENTS"); + + if (checkDefCon(DEFCON_NO_NEW_MEMOS)) + reply("OSMSG_DEFCON_NO_NEW_MEMOS"); + + return; +} + +void do_mass_mode(char *modes) +{ + dict_iterator_t it; + + if (!modes) + return; + + for (it = dict_first(channels); it; it = iter_next(it)) { + struct chanNode *chan = iter_data(it); + + irc_mode(opserv, chan, modes); + } + +} + +void DefConProcess(struct userNode *user) +{ + char *newmodes; + + if (GlobalOnDefcon) + global_message_args(MESSAGE_RECIPIENT_LUSERS, "DEFCON_NETWORK_CHANGED", DefConLevel); + + if (GlobalOnDefconMore && GlobalOnDefcon) + global_message(MESSAGE_RECIPIENT_LUSERS, DefConMessage); + + if ((DefConLevel == 5) && !GlobalOnDefconMore && !GlobalOnDefcon) + global_message(MESSAGE_RECIPIENT_LUSERS, DefConOffMessage); + + if (user) + global_message_args(MESSAGE_RECIPIENT_OPERS, "DEFCON_OPER_LEVEL_CHANGE", user->nick, DefConLevel); + else + global_message_args(MESSAGE_RECIPIENT_OPERS, "DEFCON_TIMEOUT_LEVEL_CHANGE", DefConLevel); + + if (checkDefCon(DEFCON_FORCE_CHAN_MODES)) { + if (DefConChanModes && !DefConModesSet) { + if (DefConChanModes[0] == '+' || DefConChanModes[0] == '-') { + do_mass_mode(DefConChanModes); + DefConModesSet = 1; + } + } + } else { + if (DefConChanModes && (DefConModesSet != 0)) { + if (DefConChanModes[0] == '+' || DefConChanModes[0] == '-') { + if ((newmodes = defconReverseModes(DefConChanModes))) { + do_mass_mode(newmodes); + free(newmodes); + } + DefConModesSet = 0; + } + } + } + + return; +} + +void +defcon_timeout(UNUSED_ARG(void *data)) +{ + DefConLevel = 5; + DefConProcess(NULL); +} + +static MODCMD_FUNC(cmd_defcon) +{ + if ((argc < 2) || (atoi(argv[1]) == DefConLevel)) { + showDefConSettings(user, cmd); + return 1; + } + + if ((atoi(argv[1]) < 1) || (atoi(argv[1]) > 5)) { + reply("OSMSG_DEFCON_INVALID", atoi(argv[1])); + return 0; + } + + DefConLevel = atoi(argv[1]); + showDefConSettings(user, cmd); + + if (DefConTimeOut > 0) { + timeq_del(0, defcon_timeout, NULL, TIMEQ_IGNORE_DATA & TIMEQ_IGNORE_WHEN); + timeq_add(now + DefConTimeOut, defcon_timeout, NULL); + } + + DefConProcess(user); + return 1; +} + +/* TODO +static MODCMD_FUNC(cmd_privallow) +{ +//privallow servername/username +/-flag (global is set in conf) +} + +static MODCMD_FUNC(cmd_privdissallow) +{ +//privdisallow servername/username +/-flag (global is set in conf) +} + +static MODCMD_FUNC(cmd_privlist) +{ +//privlist servername/user (global with none) +} +*/ + +static MODCMD_FUNC(cmd_privset) +{ + struct userNode *target; + char *flag; + int add = PRIV_ADD; + + flag = argv[2]; + if (*flag == '-') { + add = PRIV_DEL; + flag++; + } else if (*flag == '+') { + add = PRIV_ADD; + flag++; + } + + target = GetUserH(argv[1]); + if (!target) { + reply("MSG_NICK_UNKNOWN", argv[1]); + return 0; + } + + if (check_priv(flag)) { + irc_privs(target, flag, add); + reply("OSMSG_PRIV_SET", argv[2], (add == 1) ? "" : "un"); + } else { + reply("OSMSG_PRIV_UNKNOWN", argv[2]); + return 0; + } + + return 1; +} + /* A lot of these commands are very similar to what ChanServ can do, * but OpServ can do them even on channels that aren't registered. */ @@ -585,9 +943,7 @@ static MODCMD_FUNC(cmd_warn) dict_insert(opserv_chan_warn, strdup(argv[1]), reason); reply("OSMSG_WARN_ADDED", argv[1], reason); if (dict_find(channels, argv[1], NULL)) { - message = alloca(strlen(reason) + strlen(argv[1]) + 55); - sprintf(message, "Channel activity warning for channel %s: %s", argv[1], reason); - global_message(MESSAGE_RECIPIENT_OPERS, message); + global_message_args(MESSAGE_RECIPIENT_OPERS, "OSMSG_CHANNEL_ACTIVITY_WARN" argv[1], reason); } return 1; } @@ -775,6 +1131,10 @@ static MODCMD_FUNC(cmd_jupe) char numeric[COMBO_NUMERIC_LEN+1], srvdesc[SERVERDESCRIPTMAX+1]; num = atoi(argv[2]); + if(num == 0) { + reply("OSMSG_INVALID_NUMERIC"); + return 0; + } if ((num < 64) && !force_n2k) { inttobase64(numeric, num, 1); inttobase64(numeric+1, 64*64-1, 2); @@ -793,6 +1153,10 @@ static MODCMD_FUNC(cmd_jupe) return 0; } snprintf(srvdesc, sizeof(srvdesc), "JUPE %s", unsplit_string(argv+3, argc-3, NULL)); + if(!strchr(argv[1], '.')) { + reply("OSMSG_INVALID_SERVERNAME"); + return 0; + } newsrv = AddServer(self, argv[1], 1, now, now, numeric, srvdesc); if (!newsrv) { reply("OSMSG_SRV_CREATE_FAILED"); @@ -985,6 +1349,57 @@ static MODCMD_FUNC(cmd_refreshg) return 1; } +static void +opserv_version(struct userNode *target) +{ + irc_version_user(opserv, target); +} + +static void +opserv_svsjoin(struct userNode *target, UNUSED_ARG(char *src_handle), UNUSED_ARG(char *reason), char *channame) +{ + struct chanNode *channel; + + if(!channame || !IsChannelName(channame)) { + /* Not a valid channel name. We shouldnt ever get this if we check properly in addalert */ + return; + } + + if (!(channel = GetChannel(channame))) { + channel = AddChannel(channame, now, NULL, NULL, NULL); + } + if (GetUserMode(channel, target)) { + /* already in it */ + return; + } + + irc_svsjoin(opserv, target, channel); + /* Should we tell the user they got joined? -Rubin*/ +} + +static void +opserv_svspart(struct userNode *target, UNUSED_ARG(char *src_handle), UNUSED_ARG(char *reason), char *channame) +{ + struct chanNode *channel; + + if(!channame || !IsChannelName(channame)) { + /* Not a valid channel name. We shouldnt ever get this if we check properly in addalert */ + return; + } + + if (!(channel = GetChannel(channame))) { + /* channel doesnt exist */ + return; + } + + if (!GetUserMode(channel, target)) { + /* not in it */ + return; + } + + irc_svspart(opserv, target, channel); +} + static struct shun * opserv_shun(struct userNode *target, char *src_handle, char *reason, unsigned long duration) { @@ -1081,7 +1496,7 @@ static MODCMD_FUNC(cmd_refreshs) } static void -opserv_ison(struct userNode *tell, struct userNode *target, const char *message) +opserv_ison(struct userNode *bot, struct userNode *tell, struct userNode *target, const char *message) { struct modeNode *mn; unsigned int count, here_len, n, maxlen; @@ -1095,7 +1510,7 @@ opserv_ison(struct userNode *tell, struct userNode *target, const char *message) here_len = strlen(mn->channel->name); if ((count + here_len + 4) > maxlen) { buff[count] = 0; - send_message(tell, opserv, message, buff); + send_message(tell, bot, message, buff); count = 0; } if (mn->modes & MODE_CHANOP) @@ -1110,7 +1525,7 @@ opserv_ison(struct userNode *tell, struct userNode *target, const char *message) } if (count) { buff[count] = 0; - send_message(tell, opserv, message, buff); + send_message(tell, bot, message, buff); } } @@ -1151,6 +1566,33 @@ static MODCMD_FUNC(cmd_invite) return 1; } +static MODCMD_FUNC(cmd_svsjoin) +{ + struct userNode *target; + + + if(!IsChannelName(argv[2])) { + reply("MSG_NOT_CHANNEL_NAME"); + return 0; + } + target = GetUserH(argv[1]); + if (!target) { + reply("MSG_NICK_UNKNOWN", argv[1]); + return 0; + } + + if (!(channel = GetChannel(argv[2]))) { + channel = AddChannel(argv[2], now, NULL, NULL, NULL); + } + if (GetUserMode(channel, target)) { + reply("OSMSG_ALREADY_THERE", channel->name); + return 0; + } + irc_svsjoin(opserv, target, channel); + reply("OSMSG_SVSJOIN_SENT"); + return 1; +} + static MODCMD_FUNC(cmd_join) { struct userNode *bot = cmd->parent->bot; @@ -1317,6 +1759,35 @@ static MODCMD_FUNC(cmd_kickbanall) return 1; } +static MODCMD_FUNC(cmd_svspart) +{ + struct userNode *target; + + if(!IsChannelName(argv[2])) { + reply("MSG_NOT_CHANNEL_NAME"); + 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); + return 0; + } + + irc_svspart(opserv, target, channel); + reply("OSMSG_SVSPART_SENT"); + return 1; +} + static MODCMD_FUNC(cmd_part) { char *reason; @@ -1468,6 +1939,36 @@ static MODCMD_FUNC(cmd_whois) reply("OSMSG_WHOIS_CRYPT_HOST", target->crypthost); reply("OSMSG_WHOIS_CRYPT_IP", target->cryptip); reply("OSMSG_WHOIS_IP", irc_ntoa(&target->ip)); + + if (target->city) { + reply("OSMSG_WHOIS_COUNTRY", target->country_name); + reply("OSMSG_WHOIS_COUNTRY_CODE", target->country_code); + reply("OSMSG_WHOIS_CITY", target->city); + reply("OSMSG_WHOIS_REGION", target->region); + + reply("OSMSG_WHOIS_POSTAL_CODE", target->postal_code); + reply("OSMSG_WHOIS_LATITUDE", target->latitude); + reply("OSMSG_WHOIS_LONGITUDE", target->longitude); + /* Only show a map url if we have a city, latitude and longitude. + * Theres not much point of latitude and longitude coordinates are + * returned but no city, the coordinates are useless. + */ + if (target->latitude && target->longitude && target->city) { + char map_url[MAXLEN]; + snprintf(map_url, sizeof(map_url), "http://www.mapquest.com/maps/map.adp?searchtype=address&formtype=address&latlongtype=decimal&latitude=%f&longitude=%f", + target->latitude, target->longitude); + reply("OSMSG_WHOIS_MAP", map_url); + } + reply("OSMSG_WHOIS_DMA_CODE", target->dma_code); + reply("OSMSG_WHOIS_AREA_CODE", target->area_code); + } else if (target->country_name) { + reply("OSMSG_WHOIS_COUNTRY", target->country_name); + } + if(target->version_reply) { + reply("OSMSG_WHOIS_VERSION", target->version_reply); + } + reply("OSMSG_WHOIS_NO_NOTICE", target->no_notice ? "YES":"NO"); + if (target->modes) { bpos = 0; #define buffer_cat(str) (herelen = strlen(str), memcpy(buffer+bpos, str, herelen), bpos += herelen) @@ -1497,10 +1998,13 @@ static MODCMD_FUNC(cmd_whois) #endif reply("OSMSG_WHOIS_SERVER", target->uplink->name); reply("OSMSG_WHOIS_ACCOUNT", (target->handle_info ? target->handle_info->handle : "Not authenticated")); + + reply("OSMSG_WHOIS_PRIVS", client_report_privs(target)); + intervalString(buffer, now - target->timestamp, user->handle_info); reply("OSMSG_WHOIS_NICK_AGE", buffer); if (target->channels.used <= MAX_CHANNELS_WHOIS) - opserv_ison(user, target, "OSMSG_WHOIS_CHANNELS"); + opserv_ison(cmd->parent->bot, user, target, "OSMSG_WHOIS_CHANNELS"); else reply("OSMSG_WHOIS_HIDECHANS"); return 1; @@ -1820,13 +2324,18 @@ static MODCMD_FUNC(cmd_stats_alerts) { dict_iterator_t it; struct opserv_user_alert *alert; const char *reaction; + char *m = NULL; - reply("OSMSG_ALERTS_LIST"); + if(argc > 1) + m = unsplit_string(argv + 1, argc - 1, NULL); + reply("OSMSG_ALERTS_LIST", m ? m : "*"); reply("OSMSG_ALERTS_BAR"); reply("OSMSG_ALERTS_HEADER"); 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)) ) + continue; /* not a match to requested filter */ switch (alert->reaction) { case REACT_NOTICE: reaction = "notice"; break; case REACT_KILL: reaction = "kill"; break; @@ -1834,6 +2343,9 @@ static MODCMD_FUNC(cmd_stats_alerts) { case REACT_GLINE: reaction = "gline"; break; case REACT_TRACK: reaction = "track"; break; case REACT_SHUN: reaction = "shun"; break; + case REACT_SVSJOIN: reaction = "svsjoin"; break; + case REACT_SVSPART: reaction = "svspart"; break; + case REACT_VERSION: reaction = "version"; break; default: reaction = ""; break; } reply("OSMSG_ALERT_IS", iter_key(it), reaction, alert->owner); @@ -2082,12 +2594,33 @@ opserv_new_user_check(struct userNode *user) } } + if (checkDefCon(DEFCON_NO_NEW_CLIENTS)) { + irc_kill(opserv, user, DefConGlineReason); + return 0; + } + + if ( (checkDefCon(DEFCON_GLINE_NEW_CLIENTS) || checkDefCon(DEFCON_SHUN_NEW_CLIENTS)) && !IsOper(user)) { + char target[IRC_NTOP_MAX_SIZE + 3] = { '*', '@', '\0' }; + + strcpy(target + 2, user->hostname); + if (checkDefCon(DEFCON_GLINE_NEW_CLIENTS)) + gline_add(opserv->nick, target, DefConGlineExpire, DefConGlineReason, now, 1, 0); + else if (checkDefCon(DEFCON_SHUN_NEW_CLIENTS)) + shun_add(opserv->nick, target, DefConGlineExpire, DefConGlineReason, now, 1); + + return 0; + } + /* Only warn or G-line if there's an untrusted max and their IP is sane. */ if (opserv_conf.untrusted_max && irc_in_addr_is_valid(user->ip) && !irc_in_addr_is_loopback(user->ip)) { struct trusted_host *th = dict_find(opserv_trusted_hosts, addr, NULL); unsigned int limit = th ? th->limit : opserv_conf.untrusted_max; + + if (checkDefCon(DEFCON_REDUCE_SESSION) && !th) + limit = DefConSessionLimit; + if (!limit) { /* 0 means unlimited hosts */ } else if (ohi->clients.used == limit) { @@ -2179,9 +2712,7 @@ opserv_channel_check(struct chanNode *newchan) } /* if ((warning = dict_find(opserv_chan_warn, newchan->name, NULL))) { - char message[MAXLEN]; - snprintf(message, sizeof(message), "Channel activity warning for channel %s: %s", newchan->name, warning); - global_message(MESSAGE_RECIPIENT_OPERS, message); + global_message_args(MESSAGE_RECIPIENT_OPERS, "OSMSG_CHANNEL_ACTIVITY_WARN", newchan->name, warning); } */ @@ -2189,105 +2720,1193 @@ opserv_channel_check(struct chanNode *newchan) newchan->bad_channel = opserv_bad_channel(newchan->name); } -static void -opserv_channel_delete(struct chanNode *chan) +static void +opserv_channel_delete(struct chanNode *chan) +{ + timeq_del(0, opserv_part_channel, chan, TIMEQ_IGNORE_WHEN); +} + +static void +opserv_notice_handler(struct userNode *user, struct userNode *bot, char *text, UNUSED_ARG(int server_qualified)) +{ + char *cmd; + /* if its a version reply, do an alert check (only alerts with version=something) */ + if(bot == opserv) { + if(text[0] == '\001') { + text++; + cmd = mysep(&text, " "); + if(!irccasecmp(cmd, "VERSION")) { + char *version = mysep(&text, "\n"); + if(!version) + version = ""; + /* opserv_debug("Opserv got CTCP VERSION Notice from %s: %s", user->nick, version); */ + /* user->version_reply = strdup(version); done in parse-p10.c now */ + dict_foreach(opserv_user_alerts, alert_check_user, user); + } + } + } +} + +static int +opserv_join_check(struct modeNode *mNode) +{ + struct userNode *user = mNode->user; + struct chanNode *channel = mNode->channel; + const char *msg; + + if (IsService(user)) + return 0; + + dict_foreach(opserv_channel_alerts, alert_check_user, user); + + if (channel->bad_channel) { + opserv_debug("Found $b%s$b in bad-word channel $b%s$b; removing the user.", user->nick, channel->name); + if (channel->name[0] != '#') + DelUser(user, opserv, 1, "OSMSG_ILLEGAL_KILL_REASON"); + else if (!GetUserMode(channel, opserv)) + opserv_shutdown_channel(channel, "OSMSG_ILLEGAL_REASON"); + else { + send_message(user, opserv, "OSMSG_ILLEGAL_CHANNEL", channel->name); + msg = user_find_message(user, "OSMSG_ILLEGAL_REASON"); + KickChannelUser(user, channel, opserv, msg); + } + return 1; + } + + if (user->uplink->burst) + return 0; + if (policer_conforms(&channel->join_policer, now, 1.0)) { + channel->join_flooded = 0; + return 0; + } + if (!channel->join_flooded) { + /* Don't moderate the channel unless it is activated and + the number of users in the channel is over the threshold. */ + struct mod_chanmode change; + mod_chanmode_init(&change); + channel->join_flooded = 1; + if (opserv_conf.join_flood_moderate && (channel->members.used > opserv_conf.join_flood_moderate_threshold)) { + if (!GetUserMode(channel, opserv)) { + /* If we aren't in the channel, join it. */ + change.args[0].mode = MODE_CHANOP; + change.args[0].u.member = AddChannelUser(opserv, channel); + change.argc++; + } + if (!(channel->modes & MODE_MODERATED)) + change.modes_set |= MODE_MODERATED; + if (change.modes_set || change.argc) + mod_chanmode_announce(opserv, channel, &change); + send_target_message(0, channel->name, opserv, "OSMSG_FLOOD_MODERATE"); + opserv_alert("Warning: Possible join flood in %s (currently %d users; channel moderated).", channel->name, channel->members.used); + } else { + opserv_alert("Warning: Possible join flood in %s (currently %d users).", channel->name, channel->members.used); + } + } + log_module(OS_LOG, LOG_INFO, "Join to %s during flood: "IDENT_FORMAT, channel->name, IDENT_DATA(user)); + return 0; +} + +static int +opserv_add_bad_word(struct svccmd *cmd, struct userNode *user, const char *new_bad) { + unsigned int bad_idx; + + for (bad_idx = 0; bad_idx < opserv_bad_words->used; ++bad_idx) { + char *orig_bad = opserv_bad_words->list[bad_idx]; + if (irccasestr(new_bad, orig_bad)) { + if (user) + reply("OSMSG_BAD_REDUNDANT", new_bad, orig_bad); + return 0; + } else if (irccasestr(orig_bad, new_bad)) { + if (user) + reply("OSMSG_BAD_GROWING", orig_bad, new_bad); + free(orig_bad); + opserv_bad_words->list[bad_idx] = strdup(new_bad); + for (bad_idx++; bad_idx < opserv_bad_words->used; bad_idx++) { + orig_bad = opserv_bad_words->list[bad_idx]; + if (!irccasestr(orig_bad, new_bad)) + continue; + if (user) + reply("OSMSG_BAD_NUKING", orig_bad); + string_list_delete(opserv_bad_words, bad_idx); + bad_idx--; + free(orig_bad); + } + return 1; + } + } + string_list_append(opserv_bad_words, strdup(new_bad)); + if (user) + reply("OSMSG_ADDED_BAD", new_bad); + return 1; +} + +static int +opserv_routing_plan_add_server(struct routingPlan *rp, const char *name, const char *uplink, const unsigned int port, int karma, const char *second, const unsigned int offline) +{ + struct routingPlanServer *rps; + rps = calloc(1, sizeof(*rps)); + if(!rps) + return 0; + /* duplicate servers replace */ + rps->uplink = strdup(uplink); + if(second) + rps->secondaryuplink = strdup(second); + else + rps->secondaryuplink = NULL; + rps->port = port ? port : 4400; /* lame hardcodede default port. maybe get from config file somewhere? */ + rps->karma = karma; + rps->offline = offline; /* 1 = yes, 0 = no */ + dict_insert(rp->servers, strdup(name), rps); + log_module(OS_LOG, LOG_DEBUG, "Adding rp server %s with uplink %s", name, uplink); + return 1; +} + +static void +free_routing_plan_server(void *data) +{ + struct routingPlanServer *rps = data; + free(rps->uplink); + if(rps->secondaryuplink) + free(rps->secondaryuplink); + free(rps); +} + +struct routingPlan* +opserv_add_routing_plan(const char *name) +{ + struct routingPlan *rp; + rp = calloc(1, sizeof(*rp)); + if (!rp) + return NULL; + if(dict_find(opserv_routing_plans, name, NULL)) + return NULL; /* plan already exists */ + rp->servers = dict_new(); + dict_set_free_data(rp->servers, free_routing_plan_server); + + dict_insert(opserv_routing_plans, strdup(name), rp); + /* TODO: check for duplicate */ + return rp; +} + +static void +free_routing_plan(void *data) +{ + struct routingPlan *rp = data; + /* delete all the servers attached to this plan */ + dict_delete(rp->servers); + /* free the plan struct */ + free(rp); +} + +/************************************************* +* Functions to handle the active routing struct */ + +struct routeList +*find_routeList_server(struct route *route, const char *server) +{ + struct routeList *rptr; + if(!server) + return(NULL); + for(rptr = route->servers;rptr;rptr=rptr->next) { + if(!strcasecmp(rptr->server, server)) + return(rptr); + } + return(NULL); +} + +/* Wipes out the routing structure, freeing properly. + * note: does NOT free itself, we just re-use it usually.*/ +void +wipe_route_list(struct route *route) { + struct routeList *nextptr, *rptr; + if(!route) + return; + for(rptr = opserv_route->servers; rptr; rptr=nextptr) + { + nextptr = rptr->next; + free(rptr->server); + if(rptr->uplink) + free(rptr->uplink); + if(rptr->secondaryuplink) + free(rptr->secondaryuplink); + free(rptr); + } + route->centered = true; + route->count = 0; + route->maxdepth = 0; + route->servers = NULL; +} + + +int +rank_outside_rec(struct route *route, char *server, int count) +{ + struct routeList *rptr; + int n, max = 0; + int i = 0; + if(count > 256) { /* XXX: 256 becomes max # of servers this works with, whats the real #? */ + return -1; + } + for(rptr = route->servers; rptr; rptr = rptr->next) { + i++; + if(!strcasecmp(server, rptr->uplink)) { + log_module(MAIN_LOG, LOG_DEBUG, "%d:%d: rank_outside_rec(%s) calling rank_outside_rec(%s)", count, i, rptr->server, rptr->uplink); + n = rank_outside_rec(route, rptr->server, count +1); + if(n < 0) /* handle error condition */ + return n; + if(n > max) + max = n; + } + } + if((rptr = find_routeList_server(route, server))) { + rptr->outsideness = max; + return(max + 1); + } + else { + log_module(MAIN_LOG, LOG_ERROR, "routing struct rank_outsideness() couldnt find %s", server); + return 0; + } +} + +int +rank_outsideness(struct route *route) +{ + log_module(MAIN_LOG, LOG_DEBUG, "rank_outsideness(): Running..."); + route->maxdepth = rank_outside_rec(route, self->uplink->name, 0) - 1; + if(route->maxdepth < 0) { /* if the rank failed, remove route */ + log_module(MAIN_LOG, LOG_WARNING, "The active routing plan has a loop! auto routing disabled."); + wipe_route_list(route); + return false; + } + return true; +} + + +/* Add servers to the routing structure */ +void +add_routestruct_server(struct route *route, const char *server, unsigned int port, char *uplink, char *secondary) +{ + struct routeList *rptr; + char *hname; + if(find_routeList_server(route, server)) + { + log_module(MAIN_LOG, LOG_WARNING, "Routing structure add server Skipping duplicate [%s]. This should never really be possible.", server); + return; + } + rptr = calloc(1, sizeof(*rptr)); + rptr->server = strdup(server); + rptr->port = port; + if(!uplink) { + hname = conf_get_data("server/hostname", RECDB_QSTRING); + uplink = hname; + } + rptr->uplink = strdup(uplink); + if(secondary) + rptr->secondaryuplink = strdup(secondary); + /* tack this server on the front of the list */ + rptr->next = route->servers; + route->servers = rptr; + route->count++; + +#ifdef notdef /* I dont quite get this. there could be uncentered things + * added after our own uplink, and this function doesnt center + * as it adds. -Rubin */ + /* If the map hasnt been centered yet... */ + if(route->centered == false) { + /* AND we just added our own uplink to it... */ + if(!strcasecmp(server, self->uplink->name)) { + change_route_uplinks(route); /* recenter it, n mark it centered. */ + } + } +#endif +} + +/* Recenter the routing struct around our current uplink */ +int +change_route_uplinks(struct route *route) +{ + struct routeList *rptr; + char lastserver[MAXLEN]; + char nextserver[MAXLEN]; + + if(!route->servers) + return false; /* no map to recenter */ + log_module(MAIN_LOG, LOG_DEBUG, "change_route_uplinks(): running..."); + char *servicename = conf_get_data("server/hostname", RECDB_QSTRING); + 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."); + route->centered = false; + return false; + } + if(!strcasecmp(rptr->uplink, servicename)) { + log_module(MAIN_LOG, LOG_DEBUG, "Already centered"); + } + else { /* else, center it */ + while(rptr) { + strcpy(nextserver, rptr->uplink); + log_module(MAIN_LOG, LOG_DEBUG, "change_route_uplinks() changing %s uplink to %s.", rptr->server, lastserver); + free(rptr->uplink); + rptr->uplink = strdup(lastserver); + strcpy(lastserver, rptr->server); + rptr = find_routeList_server(route, nextserver); + } + } + if(rank_outsideness(route) > 0) { + route->centered = true; + return true; + } + else + return false; +} + +int +activate_routing(struct svccmd *cmd, struct userNode *user, char *plan_name) +{ + static struct routingPlan *rp; + dict_iterator_t it; + char *karma; + + if(plan_name) { /* make this the new active plan */ + if(!strcmp(plan_name, "*")) { + /* disable routing */ + dict_remove(opserv_routing_plan_options, "ACTIVE"); + plan_name = NULL; + } + else { + rp = dict_find(opserv_routing_plans, plan_name, NULL); + if(!rp) { + if(cmd && user) + reply("OSMSG_PLAN_NOT_FOUND", plan_name); + else { + /* 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!"); + return 0; + } + } + } + else { /* find the active plan in settings */ + plan_name = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + } + if(!plan_name) { /* deactivated, or no plan was set active */ + /* TODO: delete routing map if it exists */ + wipe_route_list(opserv_route); + return 1; + } + + karma = dict_find(opserv_routing_plan_options, "KARMA", NULL); + + rp = dict_find(opserv_routing_plans, plan_name, NULL); + + /* this should really be done during opserv init */ + if(!opserv_route) + opserv_route = calloc(1, sizeof(*opserv_route)); + + /* Delete the existing active route */ + wipe_route_list(opserv_route); + + for(it = dict_first(rp->servers); it; it = iter_next(it)) { + const char* servername = iter_key(it); + struct routingPlanServer *rps = iter_data(it), + *rp_uplink, *rp_second = NULL; + char *uplink = rps->uplink; + rp_uplink = dict_find(rp->servers, rps->uplink, NULL); + if(rps->secondaryuplink) + rp_second = dict_find(rp->servers, rps->secondaryuplink, NULL); + + /* If the normal uplink has bad karma, don't use it as a hub, + * switch to the secondary uplink. + */ + if(karma && enabled_string(karma) && rp_uplink && rp_uplink->karma < 0) { + if(rps->secondaryuplink) { + uplink = rps->secondaryuplink; + /* unless the secondary uplinks karma is worse than the uplink. */ + if((rp_second = dict_find(rp->servers, uplink, NULL)) && rp_second->karma < rp_uplink->karma) + uplink = rps->uplink; + } + } + /* + * If _WE_ have bad karma, don't link us to our normal uplink, maybe + * its a bad route. switch to secondary. Important: dont neg karma when we arnt on + * our primary uplink, or we'll get stuck on secondary when THAT link is worse. + */ + if(karma && enabled_string(karma) && (rps->karma < 0 || rps->offline) ) { + if(rps->secondaryuplink) { + uplink = rps->secondaryuplink; + } + } + log_module(MAIN_LOG, LOG_DEBUG, "activate_routing() adding %s:%d %s", servername, rps->port, uplink); + add_routestruct_server(opserv_route, servername, rps->port, uplink, NULL); + } + if(change_route_uplinks(opserv_route)) + return 1; + else if(user) { + reply("OSMSG_ROUTING_ACTIVATION_ERROR"); + activate_routing(cmd, user, "*"); + return 0; + } + return 1; +} + +/******************************************************* + * Functions to handle online route configuration via opserv + */ +static void route_show_option(struct svccmd *cmd, struct userNode *user, char *name) +{ + char *value = dict_find(opserv_routing_plan_options, name, NULL); + if(value) { + if(!strcmp("RETRY_PERIOD", name)) { /* Show as an interval */ + char buff[INTERVALLEN+1]; + reply("OSMSG_ROUTINGPLAN_OPTION", name, intervalString(buff, atoi(value), user->handle_info)); + } + else if(!strcmp("ACTIVE", name)) { + if(opserv_route && opserv_route->servers) + reply("OSMSG_ROUTINGPLAN_ACTIVE", value); + else + reply("OSMSG_ROUTINGPLAN_OPTION_NOT_SET", name); + } + else { + reply("OSMSG_ROUTINGPLAN_OPTION", name, value); + } + } + else { + reply("OSMSG_ROUTINGPLAN_OPTION_NOT_SET", name); + } +} + +static void route_show_options(struct svccmd *cmd, struct userNode *user) +{ + char *options[] = {"ACTIVE", "RETRY_PERIOD", "CONN_PINGOUT", "CONN_READERROR", "KARMA", "DEFAULT_PORT", NULL}; + int i; + for(i = 0; options[i]; i++) { + route_show_option(cmd, user, options[i]); + } +} + +/* called from timeq */ +void routing_connect_timeout(void *data) +{ + struct waitingConnection *wc = data; + struct server *target = GetServerH(wc->target); + if(!target) { + dict_remove(opserv_waiting_connections, wc->server); + return; /* server we wanted to connect new server to is gone, just give up */ + } + routing_handle_connect_failure(target, wc->server, "Connection timed out"); + /* the following invalidates server variable! */ + dict_remove(opserv_waiting_connections, wc->server); +} + +void routing_delete_connect_timer(char *server) +{ + struct waitingConnection *wc = dict_find(opserv_waiting_connections, server, 0); + if(wc) { + timeq_del(0, routing_connect_timeout, wc, TIMEQ_IGNORE_WHEN); + dict_remove(opserv_waiting_connections, server); + } +} + + +void +routing_connect_server(char *server, int port, struct server *to) +{ + struct waitingConnection *wc = calloc(sizeof(*wc), 1); + + wc->server = strdup(server); + wc->target = strdup(to->name); + /* Just to make sure there isn't one left hanging + * if 2 connections are attempted at once.. + * */ + routing_delete_connect_timer(server); + dict_insert(opserv_waiting_connections, strdup(server), wc); + timeq_add(now + ROUTING_CONNECT_TIMEOUT, routing_connect_timeout, wc); + + irc_connect(opserv, server, port, to); +} + +int +routing_connect_one(struct route *route, char *server) +{ + struct routeList *rptr; + struct server *sptr, *suptr; + for(rptr = route->servers; rptr; rptr = rptr->next) { + if(!strcasecmp(rptr->server, server)) { + /* this is the one, connect it */ + suptr = GetServerH(rptr->uplink); + sptr = GetServerH(rptr->server); + if(sptr) + return 1; /* already linked */ + if(suptr) { + routing_connect_server(rptr->server, rptr->port, suptr); + return 1; /* attempted link */ + } + return 0; /* its uplink isnt here to link to */ + } + } + log_module(MAIN_LOG, LOG_DEBUG, "Tried to link %s but its not in the active routing struct!", server); + return 0; /* server wasnt found in active route struct. */ +} + +int routing_connect_children(struct route *route, char *server) +{ + struct routeList *rptr; + struct server *sptr, *suptr; + for(rptr = route->servers; rptr; rptr = rptr->next) { + if(!strcasecmp(rptr->uplink, server)) { + /* this is the one, connect it */ + suptr = GetServerH(rptr->uplink); + sptr = GetServerH(rptr->server); + if(sptr) + continue; /* already linked */ + if(suptr) { + routing_connect_server(rptr->server, rptr->port, suptr); + continue; /* attempted link */ + } + continue; /* its uplink isnt here to link to */ + } + } + return 1; /* server wasnt found in active route struct ?! */ +} + +int reroute(struct route *route, struct userNode *user, struct svccmd *cmd, char *directive) +{ + struct routeList *rptr; + struct server *sptr, *suptr; + int connect = 0, move = 0, missing = 0, i; + char d = toupper(*directive); + + if(!route || !route->servers) { + reply("OSMSG_REROUTING_NOTCONFIGURED"); + return 0; + } + if(user) { + if(d == 'N') { /* normal */ + irc_wallops("%s", "Attempting a reroute of the network according to loaded map..."); + reply("OSMSG_REROUTING_ACC_MAP"); + } + else if(d == 'C') { /* only connect */ + reply("OSMSG_CONNECTING_MISSING_ONLY"); + } + else if(d == 'T') { /* test */ + reply("OSMSG_TESTING_REROUTE"); + } + else + { + reply("OSMSG_INVALID_DIRECTIVE", directive); + return 0; + } + } + for(i = 0; i <= route->maxdepth-1; i++) { + for(rptr = route->servers; rptr; rptr = rptr->next) { + if(rptr->outsideness == i) { + /* debugging */ + if(user && d=='T') + reply("OSMSG_INSPECTING_SERVER", rptr->server); + suptr = GetServerH(rptr->uplink); + if(!suptr) { + if(rptr->secondaryuplink && (suptr = GetServerH(rptr->secondaryuplink))) { + if(user) + reply("OSMSG_COULDNT_FIND_SERVER", rptr->uplink, rptr->secondaryuplink, rptr->server); + } + } + if(suptr) { /* if the proper uplink is connected.. */ + sptr = GetServerH(rptr->server); + if(d == 'C' && sptr) { + continue; /* Already linked */ + } + /* If server is missing or the uplinks are not the same then... */ + else if(!sptr || strcasecmp(sptr->uplink->name, rptr->uplink)) { + if(!sptr) { + connect++; + } + else { /* Server is already connected somewhere */ + if(strcasecmp(sptr->uplink->name, rptr->uplink)) { + if(d != 'T') { /* do it for real */ + irc_squit_route(sptr, "%s issued reroute.", user ? user->nick : opserv->nick); + } + else { /* just pretend */ + reply("OSMSG_SQUIT", rptr->server); + } + move++; + } + } + if(d != 'T') /* do the real thing */ + routing_connect_server(rptr->server, rptr->port, suptr); + else /* just pretend */ + reply("OSMSG_CONNECT", rptr->server, rptr->port, suptr->name); + } + } + else { + log_module(MAIN_LOG, LOG_DEBUG, "server uplink %s was not found, cant connect %s", rptr->uplink, rptr->server); + missing++; + } + } /* outsideness = 1 */ + } /* rptr */ + } /* maxdepth */ + if(user) { /* report on what we did */ + if(!strcasecmp(directive, "C")) { + if(connect > 0) + reply("OSMSG_CONNECTING_MISSING", connect); + else + reply("OSMSG_NO_SERVERS_MISSING"); + } + else { + if(move+connect > 0) + reply("OSMSG_REROUTE_COMPLETE", move, connect, move+connect); + else + reply("OSMSG_NO_ROUTING_NECESSARY"); + if(missing > 0) + reply("OSMSG_UPLINKS_MISSING", missing); + } + } + return(move+connect); +} + +static MODCMD_FUNC(cmd_reroute) { + char* upper; + upper = argv[1]; + if(reroute(opserv_route, user, cmd, upper)) + return 1; + else + return 0; +} + +/* reroute_timer(run) + * run - if it is null, just setup the timer + * but dont run reroute now. otherwise reroute + * and setup timer. + */ +void reroute_timer(void *data) { + if(!opserv_route || !opserv_route->servers) + return; /* no active route */ + char *retry_period = dict_find(opserv_routing_plan_options, "RETRY_PERIOD", NULL); + if(!retry_period) + return; /* retry_period invalid */ + unsigned int freq = atoi(retry_period); + if(freq < 1) + return; /* retry_period set to 0, disable */ + + /* Do the reroute C attempt */ + if(data) + reroute(opserv_route, NULL, NULL, "C"); + + /* Re-add ourselves to the timer queue */ + timeq_add(now + freq, reroute_timer, "run"); +} + +void routing_change_karma(struct routingPlanServer *rps, const char *server, int change) { + + int oldkarma = rps->karma; + rps->karma += change; + if(rps->karma < KARMA_MIN) + rps->karma = KARMA_MIN; + if(rps->karma > KARMA_MAX) + rps->karma = KARMA_MAX; + log_module(MAIN_LOG, LOG_DEBUG, "Changing %s karma by %d. new karma %d.", server, change, rps->karma); + if(oldkarma > 0 && rps->karma < 0) { + /* we just crossed over to negitive */ + log_module(MAIN_LOG, LOG_INFO, "Server %s just went negitive karma!", server); + activate_routing(NULL, NULL, NULL); + } + else if(oldkarma < 0 && rps->karma > 0) { + /* we just crossed over to positive */ + log_module(MAIN_LOG, LOG_INFO, "Server %s just went back positive karma.", server); + activate_routing(NULL, NULL, NULL); + } +} + +void routing_karma_timer(void *data) { + time_t next; + time_t timer_init = data ? atoi(data) : 0; + char buf[MAXLEN]; + + log_module(MAIN_LOG, LOG_DEBUG, "routing_karma_timer() is running. timer_init=%d.", (unsigned int) timer_init); + + /* If theres a time passed in, dont run unless that time is overdue. */ + if(!timer_init || (timer_init < now)) { + if(opserv_route && opserv_route->servers) { + char *active = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + struct routingPlan *rp; + if(active && (rp = dict_find(opserv_routing_plans, active, NULL))) { + dict_iterator_t it; + /* Walk through each server in the active routing plan.. */ + for(it = dict_first(rp->servers); it; it = iter_next(it)) { + struct routingPlanServer *rps = iter_data(it); + struct server *server = GetServerH(iter_key(it)); + /* Give everyone +KARMA_ENTROPE just for nothing */ + routing_change_karma(rps, iter_key(it), KARMA_ENTROPE); + /* give an additonal +KARMA_RELIABLE to servers that + * have been linked at least KARMA_TIMER seconds. */ + if(server && (server->link < (now - KARMA_TIMER) ) ) { + routing_change_karma(rps, iter_key(it), KARMA_RELIABLE); + } + } + } + } + } + if(timer_init > now) /* loading a saved value */ + next = timer_init; + else /* no scheduled timer, or we missed it. start from now */ + next = now + KARMA_TIMER; + /* Save when karma_timer should run again in case we restart before then */ + log_module(MAIN_LOG, LOG_DEBUG, "routing_karma_timer() scheduling self to run again at %d", (unsigned int) next); + sprintf(buf, "%u", (unsigned int) next); + dict_insert(opserv_routing_plan_options, "KARMA_TIMER", strdup(buf)); + /* add a timer to run this again .. */ + timeq_add(next, routing_karma_timer, NULL); +} + +void routing_handle_neg_karma(char *server, char *uplink, int change) +{ + /* if server's primary uplink is uplink, OR, uplink's primary uplink is server, + * then whichever one, gets its karma changed. */ + char *active = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + struct routingPlan *rp; + struct routingPlanServer *rps; + if(!active) + return; + if(!(rp = dict_find(opserv_routing_plans, active, NULL))) + return; + if((rps = dict_find(rp->servers, server, NULL))) { + if(!strcasecmp(rps->uplink, uplink)) { + /* server's uplink is uplink */ + routing_change_karma(rps, server, change); + return; + } + } + if((rps = dict_find(rp->servers, uplink, NULL))) { + if(!strcasecmp(rps->uplink, server)) { + /* uplink's uplink is server */ + routing_change_karma(rps, uplink, change); + return; + } + } +} + +void +routing_handle_squit(char *server, char *uplink, char *message) +{ + log_module(MAIN_LOG, LOG_DEBUG, "Routing_handle_squit(%s, %s)", server, message); + + char *val; + + if(match_ircglob(message, "Ping timeout")) { + routing_handle_neg_karma(server, uplink, KARMA_PINGOUT); + /* if conn_pingout is true, try to reconnect it obaying karma rules. */ + + val = dict_find(opserv_routing_plan_options, "CONN_PINGOUT", 0); + if(val && enabled_string(val)) + routing_connect_one(opserv_route, server); + } + else if(match_ircglob(message, "Read error:*")) { + routing_handle_neg_karma(server, uplink, KARMA_READERROR); + /* if conn_readerror is true, try to reconnect it obaying karma rules. */ + val = dict_find(opserv_routing_plan_options, "CONN_READERROR", 0); + if(val && enabled_string(val)) + routing_connect_one(opserv_route, server); + } + /* Else whats the message (an oper squit it?) dont interfere */ +} + +void +routing_handle_connect(char *server, char *uplink) +{ + char *active; + struct routingPlan *rp; + struct routingPlanServer *rps; + dict_iterator_t it; + + log_module(MAIN_LOG, LOG_DEBUG, "routing_handle_connect(%s, %s)", server, uplink); + /* delete a pending connection timer, if any */ + routing_delete_connect_timer(server); + /* check if routing is active... */ + active = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + if(!active) + return; + rp = dict_find(opserv_routing_plans, active, NULL); + if(!rp) + return; + + /* If its offline, mark it online again.. */ + if((rps = dict_find(rp->servers, server, NULL))) { + if(rps->offline == true) { + rps->offline = false; + if(rps->secondaryuplink) { + /* re-activate to move it back to its primary */ + activate_routing(NULL, NULL, NULL); + } + } + /* if there are any servers missing who have this server as uplink try to connect them. */ + routing_connect_children(opserv_route, server); + } + /* foreach server x3 knows about, if the uplink is this server, call this function on the child. */ + for (it=dict_first(servers); it; it=iter_next(it)) { + struct server *sptr = iter_data(it); + if(sptr && sptr->uplink && !strcasecmp(server, sptr->uplink->name)) { + log_module(MAIN_LOG, LOG_DEBUG, "routing_handle_connect calling self on %s's leaf %s", server, sptr->name); + routing_handle_connect(sptr->name, sptr->uplink->name); + } + } +} + +/* Handle a failed attempt at connecting servers + * - we should only get here regarding servers X3 attempted to link, other + * opers link messages go to them not to us + */ +void +routing_handle_connect_failure(struct server *source, char *server, char *message) +{ + 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); + /* remove the waiting connection n timeq */ + routing_delete_connect_timer(server); + /* check if routing is active.. */ + active = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + if(!active) + return; + rp = dict_find(opserv_routing_plans, active, NULL); + if(!rp) + return; + + if( ((rps = dict_find(rp->servers, server, NULL)) && !strcasecmp(rps->uplink, source->name))) { + /* failed to connect to its primary uplink */ + if(rps->offline == false) { + rps->offline = true; + if(rps->secondaryuplink) { + /* re-activate routing so the secondary + * becomes its uplink, and try again */ + activate_routing(NULL, NULL, NULL); + /* attempt to link it again. */ + routing_connect_one(opserv_route, server); + /* TODO: reconnect any missing servers who + * normally connect to server, using their backups. + * Probably should just issue a reroute C here. */ + } + } + } +} + +/* Delete any existing timers, and start the timer again + * using the passed time for the first run. + * - this is called during a retry_period change + * before it has saved the new value. */ +void reroute_timer_reset(unsigned int time) +{ + timeq_del(0, reroute_timer, NULL, TIMEQ_IGNORE_DATA & TIMEQ_IGNORE_WHEN); + timeq_add(now + time, reroute_timer, "run"); +} + +static MODCMD_FUNC(cmd_routing_set) +{ + char *option = argv[1]; + char *options[] = {"ACTIVE", "RETRY_PERIOD", "CONN_PINGOUT", "CONN_READERROR", "KARMA", "DEFAULT_PORT", NULL}; + int i; + if(argc < 2) { + route_show_options(cmd, user); + } + else { + char *found_option = NULL; + for(i = 0; options[i]; i++) { + if(!strcasecmp(options[i], option)) + found_option = options[i]; + } + if(!found_option) { + reply("OSMSG_ROUTINGPLAN_OPTION_NOT_FOUND", option); + return 0; + } + if(argc > 2) { + char *value = argv[2]; + char buff[MAXLEN]; /* whats the max length of unsigned int as printf'd? */ + if(!strcmp(found_option, "ACTIVE")) { /* must be an existing route. */ + if(disabled_string(value) || false_string(value)) { + /* make none of the maps active */ + activate_routing(cmd, user, "*"); + reply("OSMSG_ROUTING_DISABLED"); + return 1; + } + else if(!activate_routing(cmd, user, value)) { + /* neg reply handled in activate_routing */ + return 0; + } + } + if(!strcmp(found_option, "CONN_READERROR") || !strcmp(found_option, "CONN_PINGOUT") || + !strcmp(found_option, "KARMA") ) { + if( enabled_string(value)) { + value = "ENABLED"; + } + else if( disabled_string(value) ) { + value = "DISABLED"; + } + else { + reply("MSG_INVALID_BINARY", value); + return 0; + } + } + if(!strcmp(found_option, "RETRY_PERIOD")) { + unsigned int duration = ParseInterval(value); + sprintf(buff, "%d", duration); + value = buff; + reroute_timer_reset(duration); + } + /* set the value here */ + dict_remove(opserv_routing_plan_options, found_option); + dict_insert(opserv_routing_plan_options, strdup(found_option), strdup(value)); + route_show_option(cmd, user, found_option); + } + else { + /* show the current value */ + route_show_option(cmd, user, found_option); + } + } + return 1; +} + +static MODCMD_FUNC(cmd_stats_routing_plans) { + dict_iterator_t rpit; + dict_iterator_t it; + struct routingPlan *rp; + reply("OSMSG_ROUTINGPLAN_LIST"); + reply("OSMSG_ROUTINGPLAN_BAR"); + for(rpit = dict_first(opserv_routing_plans); rpit; rpit = iter_next(rpit)) { + const char* name = iter_key(rpit); + rp = iter_data(rpit); + reply("OSMSG_ROUTINGPLAN_NAME", name); + for(it = dict_first(rp->servers); it; it = iter_next(it)) { + const char* servername = iter_key(it); + struct routingPlanServer *rps = iter_data(it); + reply("OSMSG_ROUTINGPLAN_SERVER", servername, rps->port, rps->uplink, rps->karma, rps->offline? "offline" : "online", rps->secondaryuplink ? rps->secondaryuplink : "None"); + } + + } + reply("OSMSG_ROUTINGPLAN_END"); + route_show_options(cmd, user); + return 1; +} + + +static MODCMD_FUNC(cmd_routing_addplan) { - timeq_del(0, opserv_part_channel, chan, TIMEQ_IGNORE_WHEN); + char *name; + name = argv[1]; + /* dont allow things like 'off', 'false', '0' because thats how we disable routing. */ + if(*name && !disabled_string(name) && !false_string(name)) { + if(opserv_add_routing_plan(name)) { + reply("OSMSG_ADDPLAN_SUCCESS", name); + return 1; + } + else { + reply("OSMSG_ADDPLAN_FAILED", name); + return 0; + } + } + else + { + reply("OSMSG_INVALID_PLAN"); + return 0; + } } -static int -opserv_join_check(struct modeNode *mNode) +static MODCMD_FUNC(cmd_routing_delplan) { - struct userNode *user = mNode->user; - struct chanNode *channel = mNode->channel; - const char *msg; - - if (IsService(user)) + char *name = argv[1]; + if( dict_remove(opserv_routing_plans, name) ) { + char *active = dict_find(opserv_routing_plan_options, "ACTIVE", NULL); + if(active && !strcasecmp(active, name)) { + /* if this was the active plan, disable routing */ + activate_routing(cmd, user, "*"); + reply("OSMSG_ROUTING_DISABLED"); + } + reply("OSMSG_PLAN_DELETED"); + return 1; + } + else { + reply("OSMSG_PLAN_NOT_FOUND", name); return 0; + } +} - dict_foreach(opserv_channel_alerts, alert_check_user, user); +static MODCMD_FUNC(cmd_routing_addserver) +{ + char *plan; + char *server; + char *portstr; + char *uplink; + char *second; + unsigned int port; + struct routingPlan *rp; - if (channel->bad_channel) { - opserv_debug("Found $b%s$b in bad-word channel $b%s$b; removing the user.", user->nick, channel->name); - if (channel->name[0] != '#') - DelUser(user, opserv, 1, "OSMSG_ILLEGAL_KILL_REASON"); - else if (!GetUserMode(channel, opserv)) - opserv_shutdown_channel(channel, "OSMSG_ILLEGAL_REASON"); - else { - send_message(user, opserv, "OSMSG_ILLEGAL_CHANNEL", channel->name); - msg = user_find_message(user, "OSMSG_ILLEGAL_REASON"); - KickChannelUser(user, channel, opserv, msg); + plan = argv[1]; + server = strdup(argv[2]); + server = strtok(server, ":"); + portstr = strtok(NULL, ":"); + if(portstr) + port = atoi(portstr); + else { + char *str = dict_find(opserv_routing_plan_options, "DEFAULT_PORT", NULL); + uplink = argv[3]; + port = str ? atoi(str) : 0; + } + uplink = argv[3]; + if(argc > 4) + second = argv[4]; + else + second = NULL; + + if( (rp = dict_find(opserv_routing_plans, plan, 0))) { + char *active; + opserv_routing_plan_add_server(rp, server, uplink, port, KARMA_DEFAULT, second, 0); + reply("OSMSG_PLAN_SERVER_ADDED", server); + if((active = dict_find(opserv_routing_plan_options, "ACTIVE", 0)) && !strcasecmp(plan, active)) { + /* re-activate routing with new info */ + activate_routing(cmd, user, NULL); } + + free(server); return 1; } - - if (user->uplink->burst) - return 0; - if (policer_conforms(&channel->join_policer, now, 1.0)) { - channel->join_flooded = 0; + else { + reply("OSMSG_PLAN_NOT_FOUND", plan); + free(server); return 0; } - if (!channel->join_flooded) { - /* Don't moderate the channel unless it is activated and - the number of users in the channel is over the threshold. */ - struct mod_chanmode change; - mod_chanmode_init(&change); - channel->join_flooded = 1; - if (opserv_conf.join_flood_moderate && (channel->members.used > opserv_conf.join_flood_moderate_threshold)) { - if (!GetUserMode(channel, opserv)) { - /* If we aren't in the channel, join it. */ - change.args[0].mode = MODE_CHANOP; - change.args[0].u.member = AddChannelUser(opserv, channel); - change.argc++; +} + +static MODCMD_FUNC(cmd_routing_delserver) +{ + char *plan; + char *server; + struct routingPlan *rp; + plan = argv[1]; + server = argv[2]; + if( (rp = dict_find(opserv_routing_plans, plan, 0))) { + if(dict_remove(rp->servers, server)) { + char *active; + reply("OSMSG_PLAN_SERVER_DELETED"); + if((active = dict_find(opserv_routing_plan_options, "ACTIVE", 0)) && !strcasecmp(plan, active)) { + /* re-activate routing with new info */ + activate_routing(cmd, user, NULL); } - if (!(channel->modes & MODE_MODERATED)) - change.modes_set |= MODE_MODERATED; - if (change.modes_set || change.argc) - mod_chanmode_announce(opserv, channel, &change); - send_target_message(0, channel->name, opserv, "OSMSG_FLOOD_MODERATE"); - opserv_alert("Warning: Possible join flood in %s (currently %d users; channel moderated).", channel->name, channel->members.used); - } else { - opserv_alert("Warning: Possible join flood in %s (currently %d users).", channel->name, channel->members.used); + + return 1; + } + else { + reply("OSMSG_PLAN_SERVER_NOT_FOUND", server); + return 0; } } - log_module(OS_LOG, LOG_INFO, "Join to %s during flood: "IDENT_FORMAT, channel->name, IDENT_DATA(user)); - return 0; + else { + reply("OSMSG_PLAN_NOT_FOUND", plan); + return 0; + } } -static int -opserv_add_bad_word(struct svccmd *cmd, struct userNode *user, const char *new_bad) { - unsigned int bad_idx; - for (bad_idx = 0; bad_idx < opserv_bad_words->used; ++bad_idx) { - char *orig_bad = opserv_bad_words->list[bad_idx]; - if (irccasestr(new_bad, orig_bad)) { - if (user) - reply("OSMSG_BAD_REDUNDANT", new_bad, orig_bad); - return 0; - } else if (irccasestr(orig_bad, new_bad)) { - if (user) - reply("OSMSG_BAD_GROWING", orig_bad, new_bad); - free(orig_bad); - opserv_bad_words->list[bad_idx] = strdup(new_bad); - for (bad_idx++; bad_idx < opserv_bad_words->used; bad_idx++) { - orig_bad = opserv_bad_words->list[bad_idx]; - if (!irccasestr(orig_bad, new_bad)) - continue; - if (user) - reply("OSMSG_BAD_NUKING", orig_bad); - string_list_delete(opserv_bad_words, bad_idx); - bad_idx--; - free(orig_bad); +/************************************************* + * Functions to deal with 'route map' command */ + +/* Figures out how many downlinks there are for proper + * drawing of the route map */ +int +num_route_downlinks(struct route *route, char *name) +{ + struct routeList *rptr; + int num = 0; + rptr = route->servers; + while(rptr) { + if(!strcasecmp(rptr->uplink, name)) + num++; + rptr = rptr->next; + } + return num; +} + +void +show_route_downlinks(struct svccmd *cmd, struct route *route, struct userNode *user, char *name, char *prevpre, char *arrowchar, int reset) +{ + struct routeList *servPtr; + struct server *sptr; + int j; + char pre[MAXLEN]; + char *nextpre; + char *status; + int num = 0; + static int depth = 0; + + if(reset) + depth = 0; + + nextpre = malloc(MAXLEN); + strcpy(pre, prevpre); + + sptr = GetServerH(name); + if((servPtr = find_routeList_server(route, name))) { + if(!sptr) + status = " "; + else if (!strcasecmp(sptr->uplink->name, servPtr->uplink)) + status = "X"; + else if(servPtr->secondaryuplink && !strcasecmp(sptr->name, servPtr->secondaryuplink)) + status = "/"; + else + status = "!"; + reply("OSMSG_DOWNLINKS_FORMAT_A", pre, arrowchar, name, status); + } + else + reply("OSMSG_DOWNLINKS_FORMAT_B", self->name); + j = num_route_downlinks(route, name); + servPtr = route->servers; + while(servPtr) { + if(!strcasecmp(servPtr->uplink, name)) { + strcpy(nextpre, pre); + if(depth++ > 0) { + if(arrowchar[0] == '`') + strcat(nextpre, " "); + else + strcat(nextpre, "| "); + } + if(j > ++num) { + show_route_downlinks(cmd, route, user, servPtr->server, nextpre, "|", 0); + } + else { + show_route_downlinks(cmd, route, user, servPtr->server, nextpre, "`", 0); } - return 1; } + servPtr = servPtr->next; } - string_list_append(opserv_bad_words, strdup(new_bad)); - if (user) - reply("OSMSG_ADDED_BAD", new_bad); + free(nextpre); +} + +int +show_route_map(struct route *route, struct userNode *user, struct svccmd *cmd) +{ + if(!route || !route->servers) { + reply("OSMSG_ROUTELIST_EMPTY"); + return 0; + } + + char *serviceName = conf_get_data("server/hostname", RECDB_QSTRING); + reply("OSMSG_ROUTELIST_AS_PLANNED"); + show_route_downlinks(cmd, route, user, serviceName, "", "`", 1); + reply("OSMSG_MAP_CENTERED", route->centered ? "is" : "is not", route->maxdepth); + return 1; +} + +static MODCMD_FUNC(cmd_routing_map) +{ + show_route_map(opserv_route, user, cmd); return 1; } + + + +/* End of auto routing functions * + *********************************/ + static MODCMD_FUNC(cmd_addbad) { unsigned int arg, count; @@ -2906,7 +4525,8 @@ opserv_add_user_alert(struct userNode *req, const char *name, opserv_alert_react 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); - if (!alert->discrim) { + if (!alert->discrim || (reaction==REACT_SVSJOIN && !alert->discrim->chantarget) || + (reaction==REACT_SVSPART && !alert->discrim->chantarget)) { free(alert->text_discrim); free(discrim_copy); free(alert); @@ -2946,6 +4566,7 @@ add_chan_warn(const char *key, void *data, UNUSED_ARG(void *extra)) } */ + static int add_user_alert(const char *key, void *data, UNUSED_ARG(void *extra)) { @@ -2974,6 +4595,12 @@ add_user_alert(const char *key, void *data, UNUSED_ARG(void *extra)) reaction = REACT_TRACK; else if (!irccasecmp(react, "shun")) reaction = REACT_SHUN; + else if (!irccasecmp(react, "svsjoin")) + reaction = REACT_SVSJOIN; + else if (!irccasecmp(react, "svspart")) + reaction = REACT_SVSPART; + else if (!irccasecmp(react, "version")) + reaction = REACT_VERSION; else { log_module(OS_LOG, LOG_ERROR, "Invalid reaction %s for alert %s.", react, key); return 0; @@ -3022,6 +4649,54 @@ trusted_host_read(const char *host, void *data, UNUSED_ARG(void *extra)) return 0; } +static int +add_routing_plan_server(const char *name, void *data, void *rp) +{ + struct record_data *rd = data; + const char *uplink, *portstr, *karma, *second, *offline; + + dict_t obj = GET_RECORD_OBJECT(rd); + if(rd->type == RECDB_OBJECT) { + uplink = database_get_data(obj, KEY_UPLINK, RECDB_QSTRING); + second = database_get_data(obj, KEY_SECOND, RECDB_QSTRING); + portstr = database_get_data(obj, KEY_PORT, RECDB_QSTRING); + karma = database_get_data(obj, KEY_KARMA, RECDB_QSTRING); + offline = database_get_data(obj, KEY_OFFLINE, RECDB_QSTRING); + /* create routing plan server named key, with uplink uplink. */ + opserv_routing_plan_add_server(rp, name, uplink, portstr ? atoi(portstr) : 0, + karma ? atoi(karma) : KARMA_DEFAULT, second, + offline ? atoi(offline) : 0); + } + return 0; + +} + +static int +routing_plan_set_option(const char *name, void *data, UNUSED_ARG(void *extra)) +{ + struct record_data *rd = data; + if(rd->type == RECDB_QSTRING) + { + char *value = GET_RECORD_QSTRING(rd); + dict_insert(opserv_routing_plan_options, strdup(name), strdup(value)); + } + return 0; +} + +static int +add_routing_plan(const char *name, void *data, UNUSED_ARG(void *extra)) +{ + struct record_data *rd = data; + struct routingPlan *rp; + + if(rd->type == RECDB_OBJECT) { + dict_t obj = GET_RECORD_OBJECT(rd); + rp = opserv_add_routing_plan(name); + dict_foreach(obj, add_routing_plan_server, rp); + } + return 0; +} + static int opserv_saxdb_read(struct dict *conf_db) { @@ -3074,6 +4749,13 @@ opserv_saxdb_read(struct dict *conf_db) if ((object = database_get_data(conf_db, KEY_WARN, RECDB_OBJECT))) dict_foreach(object, add_chan_warn, NULL); */ + + if ((object = database_get_data(conf_db, KEY_ROUTINGPLAN, RECDB_OBJECT))) + dict_foreach(object, add_routing_plan, NULL); + + if ((object = database_get_data(conf_db, KEY_ROUTINGPLAN_OPTIONS, RECDB_OBJECT))) + dict_foreach(object, routing_plan_set_option, NULL); + return 0; } @@ -3101,6 +4783,42 @@ opserv_saxdb_write(struct saxdb_context *ctx) if (opserv_bad_words->used) { saxdb_write_string_list(ctx, KEY_BAD_WORDS, opserv_bad_words); } + /* routing plan options */ + if (dict_size(opserv_routing_plan_options)) { + saxdb_start_record(ctx, KEY_ROUTINGPLAN_OPTIONS, 1); + for(it = dict_first(opserv_routing_plan_options); it; it = iter_next(it)) { + saxdb_write_string(ctx, iter_key(it), iter_data(it)); + } + saxdb_end_record(ctx); + } + /* routing plans */ + if (dict_size(opserv_routing_plans)) { + dict_iterator_t svrit; + struct routingPlan *rp; + struct routingPlanServer *rps; + saxdb_start_record(ctx, KEY_ROUTINGPLAN, 1); + for (it = dict_first(opserv_routing_plans); it; it = iter_next(it)) { + rp = iter_data(it); + saxdb_start_record(ctx, iter_key(it), 0); + for(svrit = dict_first(rp->servers); svrit; svrit = iter_next(svrit)) { + char buf[MAXLEN]; + rps = iter_data(svrit); + saxdb_start_record(ctx, iter_key(svrit), 0); + saxdb_write_string(ctx, KEY_UPLINK, rps->uplink); + if(rps->secondaryuplink) + saxdb_write_string(ctx, KEY_SECOND, rps->secondaryuplink); + sprintf(buf, "%d", rps->port); + saxdb_write_string(ctx, KEY_PORT, buf); + sprintf(buf, "%d", rps->karma); + saxdb_write_string(ctx, KEY_KARMA, buf); + sprintf(buf, "%d", rps->offline); + saxdb_write_string(ctx, KEY_OFFLINE, buf); + saxdb_end_record(ctx); + } + saxdb_end_record(ctx); + } + saxdb_end_record(ctx); + } /* insert exempt channel names */ if (dict_size(opserv_exempt_channels)) { slist = alloc_string_list(dict_size(opserv_exempt_channels)); @@ -3164,6 +4882,9 @@ opserv_saxdb_write(struct saxdb_context *ctx) case REACT_GLINE: reaction = "gline"; break; case REACT_TRACK: reaction = "track"; break; case REACT_SHUN: reaction = "shun"; break; + case REACT_SVSJOIN: reaction = "svsjoin"; break; + case REACT_SVSPART: reaction = "svspart"; break; + case REACT_VERSION: reaction = "version"; 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)); @@ -3337,12 +5058,14 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int discrim->intra_scmp = 3; else discrim->mask_info = argv[i]; + } else if (irccasecmp(argv[i], "version") == 0) { + discrim->mask_version = argv[++i]; } else if (irccasecmp(argv[i], "server") == 0) { discrim->server = argv[++i]; } else if (irccasecmp(argv[i], "ip") == 0) { j = irc_pton(&discrim->ip_mask, &discrim->ip_mask_bits, argv[++i]); if (!j) { - send_message(user, opserv, "OSMSG_BAD_IP", argv[i]); + send_message(user, bot, "OSMSG_BAD_IP", argv[i]); goto fail; } } else if (irccasecmp(argv[i], "account") == 0) { @@ -3352,6 +5075,12 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int } discrim->accountmask = argv[++i]; discrim->authed = 1; + } 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], "authed") == 0) { i++; /* true_string and false_string are macros! */ if (true_string(argv[i])) { @@ -3385,19 +5114,19 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int } else if (false_string(argv[i])) { discrim->use_regex = 0; } else { - send_message(user, opserv, "MSG_INVALID_BINARY", argv[i]); + send_message(user, bot, "MSG_INVALID_BINARY", argv[i]); goto fail; } } else if (irccasecmp(argv[i], "silent") == 0) { i++; - if(!oper_has_access(user, opserv, opserv_conf.silent_level, 0)) { + if(user != opserv && !oper_has_access(user, opserv, opserv_conf.silent_level, 0)) { goto fail; } else if (true_string(argv[i])) { discrim->silent = 1; } else if (false_string(argv[i])) { discrim->silent = 0; } else { - send_message(user, opserv, "MSG_INVALID_BINARY", argv[i]); + send_message(user, bot, "MSG_INVALID_BINARY", argv[i]); goto fail; } } else if (irccasecmp(argv[i], "duration") == 0) { @@ -3510,6 +5239,9 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int if (discrim->mask_info && !strcmp(discrim->mask_info, "*")) { discrim->mask_info = 0; } + if (discrim->mask_version && !strcmp(discrim->mask_version, "*")) { + discrim->mask_version = 0; + } if (discrim->mask_host && !discrim->mask_host[strspn(discrim->mask_host, "*.")]) { discrim->mask_host = 0; } @@ -3525,7 +5257,7 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int char buff[256]; buff[regerror(err, &discrim->regex_nick, buff, sizeof(buff))] = 0; - send_message(user, opserv, "OSMSG_INVALID_REGEX", discrim->mask_nick, buff, err); + send_message(user, bot, "OSMSG_INVALID_REGEX", discrim->mask_nick, buff, err); goto regfail; } } @@ -3539,7 +5271,7 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int char buff[256]; buff[regerror(err, &discrim->regex_ident, buff, sizeof(buff))] = 0; - send_message(user, opserv, "OSMSG_INVALID_REGEX", discrim->mask_ident, buff, err); + send_message(user, bot, "OSMSG_INVALID_REGEX", discrim->mask_ident, buff, err); goto regfail; } } @@ -3553,7 +5285,7 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int char buff[256]; buff[regerror(err, &discrim->regex_host, buff, sizeof(buff))] = 0; - send_message(user, opserv, "OSMSG_INVALID_REGEX", discrim->mask_host, buff, err); + send_message(user, bot, "OSMSG_INVALID_REGEX", discrim->mask_host, buff, err); goto regfail; } } @@ -3567,7 +5299,21 @@ opserv_discrim_create(struct userNode *user, struct userNode *bot, unsigned int char buff[256]; buff[regerror(err, &discrim->regex_info, buff, sizeof(buff))] = 0; - send_message(user, opserv, "OSMSG_INVALID_REGEX", discrim->mask_info, buff, err); + send_message(user, bot, "OSMSG_INVALID_REGEX", discrim->mask_info, buff, err); + goto regfail; + } + } + + if(discrim->mask_version) + { + int err = regcomp(&discrim->regex_version, discrim->mask_version, REG_EXTENDED|REG_ICASE|REG_NOSUB); + discrim->has_regex_version = !err; + if(err) + { + char buff[256]; + buff[regerror(err, &discrim->regex_version, buff, sizeof(buff))] = 0; + + send_message(user, bot, "OSMSG_INVALID_REGEX", discrim->mask_version, buff, err); goto regfail; } } @@ -3621,7 +5367,8 @@ discrim_match(discrim_t discrim, struct userNode *user) if((discrim->has_regex_nick && regexec(&discrim->regex_nick, user->nick, 0, 0, 0)) || (discrim->has_regex_ident && regexec(&discrim->regex_ident, user->ident, 0, 0, 0)) || (discrim->has_regex_host && regexec(&discrim->regex_host, user->hostname, 0, 0, 0)) - || (discrim->has_regex_info && regexec(&discrim->regex_info, user->info, 0, 0, 0))) { + || (discrim->has_regex_info && regexec(&discrim->regex_info, user->info, 0, 0, 0)) + || (discrim->has_regex_version && (!user->version_reply || regexec(&discrim->regex_version, user->version_reply, 0, 0, 0)))) { return 0; } } @@ -3630,7 +5377,8 @@ discrim_match(discrim_t discrim, struct userNode *user) if ((discrim->mask_nick && !match_ircglob(user->nick, discrim->mask_nick)) || (discrim->mask_ident && !match_ircglob(user->ident, discrim->mask_ident)) || (discrim->mask_host && !match_ircglob(user->hostname, discrim->mask_host)) - || (discrim->mask_info && !match_ircglob(user->info, discrim->mask_info))) { + || (discrim->mask_info && !match_ircglob(user->info, discrim->mask_info)) + || (discrim->mask_version && (!user->version_reply || !match_ircglob(user->version_reply, discrim->mask_version))) ) { return 0; } } @@ -3812,6 +5560,58 @@ trace_kill_func(struct userNode *match, void *extra) return 0; } +static int +trace_svsjoin_func(struct userNode *match, void *extra) +{ + struct discrim_and_source *das = extra; + + char *channame = das->discrim->chantarget; + struct chanNode *channel; + + if(!channame || !IsChannelName(channame)) { + //reply("MSG_NOT_CHANNEL_NAME"); + return 1; + } + + if (!(channel = GetChannel(channame))) { + channel = AddChannel(channame, now, NULL, NULL, NULL); + } + if (GetUserMode(channel, match)) { +// reply("OSMSG_ALREADY_THERE", channel->name); + return 1; + } + irc_svsjoin(opserv, match, channel); + // reply("OSMSG_SVSJOIN_SENT"); + return 0; +} + +static int +trace_svspart_func(struct userNode *match, void *extra) +{ + struct discrim_and_source *das = extra; + char *channame = das->discrim->chantarget; + struct chanNode *channel; + + if(!channame || !IsChannelName(channame)) + return 1; + + if (!(channel = GetChannel(channame))) + return 1; + + if (!GetUserMode(channel, match)) + return 1; + + irc_svspart(opserv, match, channel); + return 0; +} + +static int +trace_version_func(struct userNode *match, UNUSED_ARG(void *extra)) +{ + irc_version_user(opserv, match); + return 0; +} + static int is_gagged(char *mask) { @@ -3921,6 +5721,7 @@ static MODCMD_FUNC(cmd_trace) unsigned int matches; struct svccmd *subcmd; char buf[MAXLEN]; + int ret = 1; sprintf(buf, "trace %s", argv[1]); if (!(subcmd = dict_find(opserv_service->commands, buf, NULL))) { @@ -3943,6 +5744,12 @@ static MODCMD_FUNC(cmd_trace) action = trace_kill_func; else if (!irccasecmp(argv[1], "gag")) action = trace_gag_func; + else if (!irccasecmp(argv[1], "svsjoin")) + action = trace_svsjoin_func; + else if (!irccasecmp(argv[1], "svspart")) + action = trace_svspart_func; + else if (!irccasecmp(argv[1], "version")) + action = trace_version_func; else { reply("OSMSG_BAD_ACTION", argv[1]); return 0; @@ -3980,20 +5787,31 @@ static MODCMD_FUNC(cmd_trace) das.disp_limit = das.discrim->limit; das.discrim->limit = INT_MAX; } - matches = opserv_discrim_search(das.discrim, action, &das); - if (action == trace_domains_func) - dict_foreach(das.dict, opserv_show_hostinfo, &das); + if (action == trace_svsjoin_func && !das.discrim->chantarget) { + reply("OSMSG_SVSJOIN_NO_TARGET"); + ret = 0; + } + else if (action == trace_svspart_func && !das.discrim->chantarget) { + reply("OSMSG_SVSPART_NO_TARGET"); + ret = 0; + } + else { + matches = opserv_discrim_search(das.discrim, action, &das); - if (matches) - { - if(action == trace_print_func) - reply("OSMSG_USER_SEARCH_COUNT_BAR", matches); + if (action == trace_domains_func) + dict_foreach(das.dict, opserv_show_hostinfo, &das); + + if (matches) + { + if(action == trace_print_func) + reply("OSMSG_USER_SEARCH_COUNT_BAR", matches); + else + reply("OSMSG_USER_SEARCH_COUNT", matches); + } else - reply("OSMSG_USER_SEARCH_COUNT", matches); + reply("MSG_NO_MATCHES"); } - else - reply("MSG_NO_MATCHES"); if (das.discrim->channel) UnlockChannel(das.discrim->channel); @@ -4007,10 +5825,12 @@ static MODCMD_FUNC(cmd_trace) regfree(&das.discrim->regex_host); if(das.discrim->has_regex_info) regfree(&das.discrim->regex_info); + if(das.discrim->has_regex_version) + regfree(&das.discrim->regex_version); free(das.discrim); dict_delete(das.dict); - return 1; + return ret; } typedef void (*cdiscrim_search_func)(struct chanNode *match, void *data, struct userNode *bot); @@ -4417,17 +6237,27 @@ alert_check_user(const char *key, void *data, void *extra) case REACT_KILL: DelUser(user, opserv, 1, alert->discrim->reason); return 1; -/* - case REACT_SILENT: - opserv_block(user, alert->owner, alert->discrim->reason, alert->discrim->duration, 1); - return 1; -*/ case REACT_GLINE: opserv_block(user, alert->owner, alert->discrim->reason, alert->discrim->duration, alert->discrim->silent); return 1; case REACT_SHUN: 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); + break; + case REACT_SVSPART: + opserv_svspart(user, alert->owner, alert->discrim->reason, alert->discrim->chantarget); + break; + case REACT_VERSION: + /* Don't auto-version a user who we already have a version on, because the version reply itself + * re-triggers this check... + * TODO: maybe safer if we didn't even check react_version type alerts for the 2nd check? + * sort of like we only look at channel alerts on join. -Rubin + */ + if(!user->version_reply) + opserv_version(user); + break; default: log_module(OS_LOG, LOG_ERROR, "Invalid reaction type %d for alert %s.", alert->reaction, key); /* fall through to REACT_NOTICE case */ @@ -4597,28 +6427,32 @@ static MODCMD_FUNC(cmd_addalert) reaction = REACT_NOTICE; else if (!irccasecmp(argv[2], "kill")) reaction = REACT_KILL; -/* - else if (!irccasecmp(argv[2], "silent")) - reaction = REACT_SILENT; -*/ else if (!irccasecmp(argv[2], "gline")) reaction = REACT_GLINE; else if (!irccasecmp(argv[2], "track")) { #ifndef HAVE_TRACK - send_message(user, opserv, "OSMSG_TRACK_DISABLED"); + reply("OSMSG_TRACK_DISABLED"); return 0; #else reaction = REACT_TRACK; #endif } else if (!irccasecmp(argv[2], "shun")) reaction = REACT_SHUN; + else if(!irccasecmp(argv[2], "svsjoin")) + reaction = REACT_SVSJOIN; + else if(!irccasecmp(argv[2], "svspart")) + reaction = REACT_SVSPART; + else if(!irccasecmp(argv[2], "version")) + reaction = REACT_VERSION; else { reply("OSMSG_UNKNOWN_REACTION", argv[2]); 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))) { + reply("OSMSG_ALERT_ADD_FAILED"); return 0; + } reply("OSMSG_ADDED_ALERT", name); return 1; } @@ -4744,6 +6578,48 @@ opserv_conf_read(void) policer_params_set(pp, "drain-rate", "3"); if ((child = database_get_data(conf_node, KEY_NEW_USER_POLICER, RECDB_OBJECT))) dict_foreach(child, set_policer_param, pp); + + /* Defcon configuration */ + DefCon[0] = 0; + str = database_get_data(conf_node, KEY_DEFCON1, RECDB_QSTRING); + DefCon[1] = str ? atoi(str) : 415; + str = database_get_data(conf_node, KEY_DEFCON2, RECDB_QSTRING); + DefCon[2] = str ? atoi(str) : 159; + str = database_get_data(conf_node, KEY_DEFCON3, RECDB_QSTRING); + DefCon[3] = str ? atoi(str) : 31; + str = database_get_data(conf_node, KEY_DEFCON4, RECDB_QSTRING); + DefCon[4] = str? atoi(str) : 23; + DefCon[5] = 0; + + str = database_get_data(conf_node, KEY_DEFCON_LEVEL, RECDB_QSTRING); + DefConLevel = str ? atoi(str) : 5; + + str = database_get_data(conf_node, KEY_DEFCON_CHANMODES, RECDB_QSTRING); + DefConChanModes = str ? strdup(str) : "+r"; + + str = database_get_data(conf_node, KEY_DEFCON_SESSION_LIMIT, RECDB_QSTRING); + DefConSessionLimit = str ? atoi(str) : 2; + + str = database_get_data(conf_node, KEY_DEFCON_TIMEOUT, RECDB_QSTRING); + DefConTimeOut = str ? ParseInterval(str) : 900; + + str = database_get_data(conf_node, KEY_DEFCON_GLINE_DURATION, RECDB_QSTRING); + DefConGlineExpire = str ? ParseInterval(str) : 300; + + str = database_get_data(conf_node, KEY_DEFCON_GLOBAL, RECDB_QSTRING); + GlobalOnDefcon = str ? atoi(str) : 0; + + str = database_get_data(conf_node, KEY_DEFCON_GLOBAL_MORE, RECDB_QSTRING); + GlobalOnDefconMore = str ? atoi(str) : 0; + + str = database_get_data(conf_node, KEY_DEFCON_MESSAGE, RECDB_QSTRING); + DefConMessage = str ? strdup(str) : "Put your message to send your users here. Dont forget to uncomment GlobalOnDefconMore"; + + str = database_get_data(conf_node, KEY_DEFCON_OFF_MESSAGE, RECDB_QSTRING); + DefConOffMessage = str? strdup(str) : "Services are now back to normal, sorry for any inconvenience"; + + str = database_get_data(conf_node, KEY_DEFCON_GLINE_REASON, RECDB_QSTRING); + DefConGlineReason = str ? strdup(str) : "This network is currently not accepting connections, please try again later"; } /* lame way to export opserv_conf value to nickserv.c ... */ @@ -4759,6 +6635,11 @@ opserv_db_init(void) { dict_delete(opserv_trusted_hosts); opserv_trusted_hosts = dict_new(); dict_set_free_data(opserv_trusted_hosts, free_trusted_host); + + opserv_routing_plan_options = dict_new(); + + opserv_routing_plans = dict_new(); + dict_set_free_data(opserv_routing_plans, free_routing_plan); /* set up opserv_chan_warn dict */ /* alert trace notice channel #x replaces warnings @@ -4828,6 +6709,9 @@ init_opserv(const char *nick) opserv_define_func("ADDALERT SHUN", NULL, 900, 0, 0); opserv_define_func("ADDALERT TRACK", NULL, 900, 0, 0); opserv_define_func("ADDALERT KILL", NULL, 900, 0, 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("ADDBAD", cmd_addbad, 800, 0, 2); opserv_define_func("ADDEXEMPT", cmd_addexempt, 800, 0, 2); opserv_define_func("ADDTRUST", cmd_addtrust, 800, 0, 5); @@ -4847,6 +6731,7 @@ init_opserv(const char *nick) opserv_define_func("DELTRUST", cmd_deltrust, 800, 0, 2); opserv_define_func("DEOP", cmd_deop, 100, 2, 2); opserv_define_func("DEOPALL", cmd_deopall, 400, 2, 0); + opserv_define_func("DEFCON", cmd_defcon, 900, 0, 0); opserv_define_func("DEHOP", cmd_dehop, 100, 2, 2); opserv_define_func("DEHOPALL", cmd_dehopall, 400, 2, 0); opserv_define_func("DEVOICEALL", cmd_devoiceall, 300, 2, 0); @@ -4868,6 +6753,8 @@ init_opserv(const char *nick) 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("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("JUPE", cmd_jupe, 900, 0, 4); opserv_define_func("KICK", cmd_kick, 100, 2, 2); @@ -4880,6 +6767,8 @@ init_opserv(const char *nick) opserv_define_func("OPALL", cmd_opall, 400, 2, 0); opserv_define_func("HOP", cmd_hop, 100, 2, 2); opserv_define_func("HOPALL", cmd_hopall, 400, 2, 0); + opserv_define_func("MAP", cmd_stats_links, 0, 0, 0); + opserv_define_func("PRIVSET", cmd_privset, 900, 0, 3); opserv_define_func("PART", cmd_part, 601, 0, 2); opserv_define_func("QUERY", cmd_query, 0, 0, 0); opserv_define_func("RAW", cmd_raw, 999, 0, 2); @@ -4891,6 +6780,13 @@ init_opserv(const char *nick) opserv_define_func("RESETMAX", cmd_resetmax, 900, 0, 0); opserv_define_func("RESERVE", cmd_reserve, 800, 0, 5); opserv_define_func("RESTART", cmd_restart, 900, 0, 2); + opserv_define_func("ROUTING ADDPLAN", cmd_routing_addplan, 800, 0, 2); + opserv_define_func("ROUTING DELPLAN", cmd_routing_delplan, 800, 0, 2); + opserv_define_func("ROUTING ADDSERVER", cmd_routing_addserver, 800, 0, 4); + opserv_define_func("ROUTING DELSERVER", cmd_routing_delserver, 800, 0, 3); + opserv_define_func("ROUTING MAP", cmd_routing_map, 800, 0, 0); + opserv_define_func("ROUTING SET", cmd_routing_set, 800, 0, 0); + opserv_define_func("REROUTE", cmd_reroute, 800, 0, 2); opserv_define_func("SET", cmd_set, 900, 0, 3); opserv_define_func("SETTIME", cmd_settime, 901, 0, 0); opserv_define_func("STATS ALERTS", cmd_stats_alerts, 0, 0, 0); @@ -4903,6 +6799,7 @@ init_opserv(const char *nick) opserv_define_func("STATS NETWORK", cmd_stats_network, 0, 0, 0); opserv_define_func("STATS NETWORK2", cmd_stats_network2, 0, 0, 0); opserv_define_func("STATS RESERVED", cmd_stats_reserved, 0, 0, 0); + opserv_define_func("STATS ROUTING", cmd_stats_routing_plans, 0, 0, 0); opserv_define_func("STATS TIMEQ", cmd_stats_timeq, 0, 0, 0); opserv_define_func("STATS TRUSTED", cmd_stats_trusted, 0, 0, 0); opserv_define_func("STATS UPLINK", cmd_stats_uplink, 0, 0, 0); @@ -4919,6 +6816,9 @@ init_opserv(const char *nick) opserv_define_func("TRACE SHUN", NULL, 600, 0, 0); opserv_define_func("TRACE GAG", NULL, 600, 0, 0); opserv_define_func("TRACE KILL", NULL, 600, 0, 0); + 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("UNBAN", cmd_unban, 100, 2, 2); opserv_define_func("UNGAG", cmd_ungag, 600, 0, 2); opserv_define_func("UNGLINE", cmd_ungline, 600, 0, 2); @@ -4934,9 +6834,13 @@ init_opserv(const char *nick) opserv_reserved_nick_dict = dict_new(); opserv_hostinfo_dict = dict_new(); + dict_set_free_keys(opserv_hostinfo_dict, free); dict_set_free_data(opserv_hostinfo_dict, opserv_free_hostinfo); + opserv_waiting_connections = dict_new(); + dict_set_free_data(opserv_waiting_connections, opserv_free_waiting_connection); + reg_new_user_func(opserv_new_user_check); reg_nick_change_func(opserv_alert_check_nick); reg_del_user_func(opserv_user_cleanup); @@ -4944,6 +6848,7 @@ init_opserv(const char *nick) reg_del_channel_func(opserv_channel_delete); reg_join_func(opserv_join_check); reg_auth_func(opserv_staff_alert); + reg_notice_func(opserv, opserv_notice_handler); opserv_db_init(); saxdb_register("OpServ", opserv_saxdb_read, opserv_saxdb_write); @@ -4953,6 +6858,11 @@ init_opserv(const char *nick) opserv_service->trigger = '?'; } + /* start auto-routing system */ + reroute_timer(NULL); + /* start the karma timer, using the saved one if available */ + routing_karma_timer(dict_find(opserv_routing_plan_options, "KARMA_TIMER", NULL)); + reg_exit_func(opserv_db_cleanup); message_register_table(msgtab); }