*/
#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 <tre/regex.h>
+
#ifdef HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
-#ifdef HAVE_REGEX_H
-#include <regex.h>
-#endif
+
#define OPSERV_CONF_NAME "services/opserv"
#define KEY_NICK "nick"
#define KEY_JOIN_POLICER "join_policer"
#define KEY_NEW_USER_POLICER "new_user_policer"
+#define KEY_AUTOJOIN_CHANNELS "autojoin_channels"
#define KEY_REASON "reason"
#define KEY_RESERVES "reserves"
#define KEY_IDENT "username" /* for compatibility with 1.0 DBs */
#define KEY_ISSUER "issuer"
#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)
{ "OSMSG_OPALL_DONE", "Opped everyone on $b%s$b." },
{ "OSMSG_HOP_DONE", "Halfopped the requested lusers." },
{ "OSMSG_HOPALL_DONE", "Halfopped everyone on $b%s$b." },
- { "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_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_HIDECHANS", "Channel list omitted for your sanity." },
+ { "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_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_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." },
{ "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." },
{ "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." },
/*
{ "OSMSG_CSEARCH_CHANNEL_INFO", "%s [%d users] %s %s" },
{ "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);
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* */
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;
unsigned long join_flood_moderate;
unsigned long join_flood_moderate_threshold;
unsigned long admin_level;
+ unsigned long silent_level;
} opserv_conf;
struct trusted_host {
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;
int authed : 2, info_space : 2;
unsigned int intra_scmp : 2, intra_dcmp : 2;
unsigned int use_regex : 1;
+ unsigned int silent : 1;
} *discrim_t;
struct discrim_and_source {
typedef enum {
REACT_NOTICE,
REACT_KILL,
- REACT_SILENT,
+// REACT_SILENT,
REACT_GLINE,
REACT_TRACK,
REACT_SHUN
#define opserv_debug(format...) do { if (opserv_conf.debug_channel) send_channel_notice(opserv_conf.debug_channel , opserv , ## format); } while (0)
#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.
*/
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;
}
return 1;
}
+static MODCMD_FUNC(cmd_resetmax)
+{
+ max_clients = dict_size(clients);
+ max_clients_time = now;
+ reply("OSMSG_MAXUSERS_RESET", max_clients);
+ return 1;
+}
+
static MODCMD_FUNC(cmd_rehash)
{
extern char *services_config;
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);
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");
reply("OSMSG_WHOIS_HOST", target->ident, target->hostname);
if (IsFakeHost(target))
reply("OSMSG_WHOIS_FAKEHOST", target->fakehost);
+ 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->modes) {
bpos = 0;
#define buffer_cat(str) (herelen = strlen(str), memcpy(buffer+bpos, str, herelen), bpos += herelen)
#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)
switch (alert->reaction) {
case REACT_NOTICE: reaction = "notice"; break;
case REACT_KILL: reaction = "kill"; break;
- case REACT_SILENT: reaction = "silent"; break;
+// case REACT_SILENT: reaction = "silent"; break;
case REACT_GLINE: reaction = "gline"; break;
case REACT_TRACK: reaction = "track"; break;
case REACT_SHUN: reaction = "shun"; break;
send_message_type(MSG_TYPE_NOXLATE, user, cmd->parent->bot,
"%u allocations in %u slabs totalling %u bytes.",
slab_alloc_count, slab_count, slab_alloc_size);
-/* send_message_type(MSG_TYPE_NOXLATE, user, cmd->parent->bot,
+ send_message_type(MSG_TYPE_NOXLATE, user, cmd->parent->bot,
"%u big allocations totalling %u bytes.",
- */
+ big_alloc_count, big_alloc_size);
return 1;
}
#endif
}
}
+ 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) {
continue;
KickChannelUser(mNode->user, channel, opserv, user_find_message(mNode->user, reason));
}
- timeq_add(now + opserv_conf.purge_lock_delay, opserv_part_channel, channel);
+ timeq_add(now + opserv_conf.purge_lock_delay, opserv_part_channel, channel);
+}
+
+static void
+opserv_channel_check(struct chanNode *newchan)
+{
+ /*char *warning; */
+
+ if (!newchan->join_policer.params) {
+ newchan->join_policer.last_req = now;
+ newchan->join_policer.params = opserv_conf.join_policer_params;
+ }
+ /*
+ if ((warning = dict_find(opserv_chan_warn, newchan->name, NULL))) {
+ global_message_args(MESSAGE_RECIPIENT_OPERS, "OSMSG_CHANNEL_ACTIVITY_WARN", newchan->name, warning);
+ }
+ */
+
+ /* Wait until the join check to shut channels down. */
+ newchan->bad_channel = opserv_bad_channel(newchan->name);
+}
+
+static void
+opserv_channel_delete(struct chanNode *chan)
+{
+ timeq_del(0, opserv_part_channel, chan, TIMEQ_IGNORE_WHEN);
+}
+
+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);
+ 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. */
+ }
+ }
+ }
}
-static void
-opserv_channel_check(struct chanNode *newchan)
+/* 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)
{
- /*char *warning; */
+ timeq_del(0, reroute_timer, NULL, TIMEQ_IGNORE_DATA & TIMEQ_IGNORE_WHEN);
+ timeq_add(now + time, reroute_timer, "run");
+}
- if (!newchan->join_policer.params) {
- newchan->join_policer.last_req = now;
- newchan->join_policer.params = opserv_conf.join_policer_params;
+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);
}
- /*
- 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);
+ 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;
+}
- /* Wait until the join check to shut channels down. */
- newchan->bad_channel = opserv_bad_channel(newchan->name);
+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 void
-opserv_channel_delete(struct chanNode *chan)
+
+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;
int add_reserved(const char *key, void *data, void *extra)
{
+ struct chanNode *chan;
struct record_data *rd = data;
const char *ident, *hostname, *desc;
+ unsigned int i;
struct userNode *reserve;
ident = database_get_data(rd->d.object, KEY_IDENT, RECDB_QSTRING);
if (!ident) {
reserve->modes |= FLAGS_PERSISTENT;
dict_insert(extra, reserve->nick, reserve);
}
+
+ if (autojoin_channels && reserve) {
+ for (i = 0; i < autojoin_channels->used; i++) {
+ chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
+ AddChannelUser(reserve, chan)->modes |= MODE_VOICE;
+ }
+ }
+
return 0;
}
discrim->intra_scmp = 0;
discrim->intra_dcmp = 0;
discrim->use_regex = 0;
+ discrim->silent = 0;
dupmask = strdup(hostmask);
if (split_ircmask(dupmask, &discrim->mask_nick, &discrim->mask_ident, &discrim->mask_host)) {
if (!irc_pton(&discrim->ip_mask, &discrim->ip_mask_bits, discrim->mask_host))
}
*/
+
static int
add_user_alert(const char *key, void *data, UNUSED_ARG(void *extra))
{
reaction = REACT_NOTICE;
else if (!irccasecmp(react, "kill"))
reaction = REACT_KILL;
+ /*
else if (!irccasecmp(react, "silent"))
reaction = REACT_SILENT;
+ */
else if (!irccasecmp(react, "gline"))
reaction = REACT_GLINE;
else if (!irccasecmp(react, "track"))
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)
{
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;
}
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));
switch (alert->reaction) {
case REACT_NOTICE: reaction = "notice"; break;
case REACT_KILL: reaction = "kill"; break;
- case REACT_SILENT: reaction = "silent"; break;
+// case REACT_SILENT: reaction = "silent"; break;
case REACT_GLINE: reaction = "gline"; break;
case REACT_TRACK: reaction = "track"; break;
case REACT_SHUN: reaction = "shun"; break;
discrim->info_space = -1;
discrim->intra_dcmp = 0;
discrim->intra_scmp = 0;
+ discrim->use_regex = 0;
+ discrim->silent = 0;
for (i=0; i<argc; i++) {
if (irccasecmp(argv[i], "log") == 0) {
} 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) {
} 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(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, bot, "MSG_INVALID_BINARY", argv[i]);
goto fail;
}
} else if (irccasecmp(argv[i], "duration") == 0) {
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;
}
}
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;
}
}
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;
}
}
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;
}
}
struct discrim_and_source *das = extra;
if (is_oper_victim(das->source, match, das->discrim->match_opers)) {
- opserv_block(match, das->source->handle_info->handle, das->discrim->reason, das->discrim->duration, 0);
+ opserv_block(match, das->source->handle_info->handle, das->discrim->reason, das->discrim->duration, das->discrim->silent);
}
return 0;
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, 0);
+ 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);
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;
static void
opserv_conf_read(void)
{
+ struct chanNode *chan;
+ unsigned int i;
struct record_data *rd;
dict_t conf_node, child;
const char *str, *str2;
str = database_get_data(conf_node, KEY_ADMIN_LEVEL, RECDB_QSTRING);
opserv_conf.admin_level = str ? strtoul(str, NULL, 0): 800;
+ str = database_get_data(conf_node, KEY_SILENT_LEVEL, RECDB_QSTRING);
+ opserv_conf.silent_level = str ? strtoul(str, NULL, 0): 700;
+
str = database_get_data(conf_node, KEY_UNTRUSTED_MAX, RECDB_QSTRING);
opserv_conf.untrusted_max = str ? strtoul(str, NULL, 0) : 5;
str = database_get_data(conf_node, KEY_PURGE_LOCK_DELAY, RECDB_QSTRING);
str = database_get_data(conf_node, KEY_BLOCK_GLINE_DURATION, RECDB_QSTRING);
opserv_conf.block_gline_duration = str ? ParseInterval(str) : 3600;
+ free_string_list(autojoin_channels);
+ autojoin_channels = database_get_data(conf_node, KEY_AUTOJOIN_CHANNELS, RECDB_STRING_LIST);
+
+ if(autojoin_channels)
+ autojoin_channels = string_list_copy(autojoin_channels);
+
+ if (autojoin_channels && opserv) {
+ for (i = 0; i < autojoin_channels->used; i++) {
+ chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
+ AddChannelUser(opserv, chan)->modes |= MODE_CHANOP;
+ }
+ }
+
str = database_get_data(conf_node, KEY_BLOCK_SHUN_DURATION, RECDB_QSTRING);
opserv_conf.block_shun_duration = str ? ParseInterval(str) : 3600;
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 ... */
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
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);
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);
opserv_define_func("REFRESHS", cmd_refreshs, 600, 0, 0);
opserv_define_func("REHASH", cmd_rehash, 900, 0, 0);
opserv_define_func("REOPEN", cmd_reopen, 900, 0, 0);
+ 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);
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);
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);
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);
}