BUILD : 1.7.6 (463) BUGS : 192, 210, 222, 234 NOTES : 1. Removed +d references from the ptlink protocol code, since they do not timestamp the nicks 2. Memos sent as notification of receipt can not be cancelled. 3. Unreal3.2 supports SVSMODE -b on clearing bans 4. fixed do_kill() not remove the user from the user list 5. /os set sql [on|off] runtime sql toggle 6. Segfaults logged to the services log when DumpCore is disabled 7. fixed RUNGROUP not passed during build time 8. Exceptions now update if the limit is changed 9. Solid-IRCD support 10. Fixed TSMODE warnings when using FANTASY commands 11. Fixed read_int32 warnings (fixes compiling and running under cygwin) - Thats all..

git-svn-id: svn://svn.anope.org/anope/trunk@463 31f1291d-b8d6-0310-a050-a5561fc1590b


git-svn-id: http://anope.svn.sourceforge.net/svnroot/anope/trunk@317 5417fbe8-f217-4b02-8779-1006273d7864

15 files changed, 1857 insertions, 70 deletions

diff --git a/src/Makefile b/src/Makefile
index dd672c721..54929bf50 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -5,14 +5,14 @@ OBJS =  actions.o base64.o botserv.o channels.o chanserv.o commands.o compat.o c
 	memory.o memoserv.o messages.o misc.o modules.o news.o nickserv.o operserv.o \
 	process.o proxy.o send.o servers.o sessions.o slist.o sockutil.o \
 	timeout.o users.o dreamforge.o bahamut.o unreal31.o ultimate2.o ultimate3.o \
-        hybrid.o ptlink.o viagra.o rageircd.o unreal32.o \
+        hybrid.o ptlink.o viagra.o rageircd.o unreal32.o solidircd.o \
 	$(VSNPRINTF_O) $(RDB_OBJ) $(MYSQL_OBJ)
 SRCS =  actions.c base64.c botserv.c channels.c chanserv.c commands.c compat.c converter.c \
         config.c datafiles.c encrypt.c helpserv.c hostserv.c init.c language.c list.c log.c mail.c main.c \
         memory.c memoserv.c messages.c misc.c modules.c news.c nickserv.c operserv.c \
         process.c proxy.c send.c servers.c sessions.c slist.c sockutil.c \
 	dreamforge.c bahamut.c unreal31.c ultimate2.c ultimate3.c \
-        hybrid.c ptlink.c viagra.c rageircd.c unreal32.c \
+        hybrid.c ptlink.c viagra.c rageircd.c unreal32.c solidircd.c \
         timeout.c users.c \
         $(VSNPRINTF_C) $(RDB) $(MYSQL)
 
@@ -23,7 +23,7 @@ INCLUDES = ../include/commands.h ../include/defs.h  ../include/language.h \
 	../include/modules.h ../include/slist.h \
 	../include/dreamforge.h ../include/bahamut.h ../include/ultimate2.h \
 	../include/ultimate3.h ../include/hybrid.h ../include/ptlink.h ../include/unreal31.h \
-	../include/viagra.h ../include/rageircd.h ../include/unreal32.h
+	../include/viagra.h ../include/rageircd.h ../include/unreal32.h ../include/solidircd.h
 
 
 MAKEARGS = 'CFLAGS=${CFLAGS}' 'CC=${CC}' 'ANOPELIBS=${ANOPELIBS}' \
diff --git a/src/botserv.c b/src/botserv.c
index 0c23c4c68..17f922133 100644
--- a/src/botserv.c
+++ b/src/botserv.c
@@ -612,7 +612,7 @@ void load_bs_dbase(void)
     dbFILE *f;
     int c, ver;
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
     BotInfo *bi;
     int failed = 0;
 
@@ -1148,12 +1148,19 @@ static void bot_raw_kick(User * requester, ChannelInfo * ci, char *nick,
 static void bot_raw_mode(User * requester, ChannelInfo * ci, char *mode,
                          char *nick)
 {
-    char *av[3];
-    User *u = finduser(nick);
+    char *av[4];
+    int ac;
+    char buf[BUFSIZE];
+    *buf = '\0';
+    User *u;
+
+    u = finduser(nick);
 
     if (!u || !is_on_chan(ci->c, u))
         return;
 
+    snprintf(buf, BUFSIZE - 1, "%ld", (long int) time(NULL));
+
     if (ircd->protectedumode) {
         if (is_protected(u) && *mode == '-' && (requester != u)) {
             anope_cmd_privmsg(ci->bi->nick, ci->name, "%s",
@@ -1167,12 +1174,22 @@ static void bot_raw_mode(User * requester, ChannelInfo * ci, char *mode,
         && (get_access(u, ci) >= get_access(requester, ci)))
         return;
 
-    av[0] = ci->name;
-    av[1] = mode;
-    av[2] = nick;
+    if (ircdcap->tsmode) {
+        av[0] = ci->name;
+        av[1] = buf;
+        av[2] = mode;
+        av[3] = nick;
+        ac = 4;
+        anope_cmd_mode(ci->bi->nick, av[0], "%s %s", av[2], av[3]);
+    } else {
+        av[0] = ci->name;
+        av[1] = mode;
+        av[2] = nick;
+        ac = 3;
+        anope_cmd_mode(ci->bi->nick, av[0], "%s %s", av[1], av[2]);
+    }
 
-    anope_cmd_mode(ci->bi->nick, av[0], "%s %s", av[1], av[2]);
-    do_cmode(ci->bi->nick, 3, av);
+    do_cmode(ci->bi->nick, ac, av);
 }
 
 /*************************************************************************/
diff --git a/src/chanserv.c b/src/chanserv.c
index 48da2e4b1..e6b4522e2 100644
--- a/src/chanserv.c
+++ b/src/chanserv.c
@@ -636,7 +636,7 @@ void load_cs_dbase(void)
 
     for (i = 0; i < 256 && !failed; i++) {
         int16 tmp16;
-        int32 tmp32;
+        uint32 tmp32;
         int n_levels;
         char *s;
         NickAlias *na;
diff --git a/src/hostserv.c b/src/hostserv.c
index 1dcb087d0..11ee42984 100644
--- a/src/hostserv.c
+++ b/src/hostserv.c
@@ -535,7 +535,7 @@ void load_hs_dbase_v2(dbFILE * f)
     char *nick;
     char *vHost;
     char *creator;
-    int32 time;
+    uint32 time;
 
     while (!failed && (c = getc_db(f)) == 1) {
 
@@ -563,7 +563,7 @@ void load_hs_dbase_v3(dbFILE * f)
     char *vHost;
     char *creator;
     char *vIdent;
-    int32 time;
+    uint32 time;
 
     while (!failed && (c = getc_db(f)) == 1) {
         if (c == 1) {
diff --git a/src/language.c b/src/language.c
index 01e7f00d3..cfde0184d 100644
--- a/src/language.c
+++ b/src/language.c
@@ -66,7 +66,7 @@ static void load_lang(int index, const char *filename)
 {
     char buf[256];
     FILE *f;
-    int num, i;
+    int32 num, i;
 
     if (debug) {
         alog("debug: Loading language %d from file `languages/%s'",
diff --git a/src/main.c b/src/main.c
index 46d03a0ab..f7b4089b7 100644
--- a/src/main.c
+++ b/src/main.c
@@ -397,13 +397,20 @@ void sighandler(int signum)
                  signum);
 #endif
     }
+
+    if (signum == SIGSEGV) {
+        do_backtrace();
+    }
+
     if (started) {
         services_shutdown();
         exit(0);
     } else {
-        alog("%s", quitmsg);
-        if (isatty(2))
+        if (isatty(2)) {
             fprintf(stderr, "%s\n", quitmsg);
+        } else {
+            alog("%s", quitmsg);
+        }
         exit(1);
     }
 }
@@ -554,3 +561,27 @@ int main(int ac, char **av, char **envp)
 }
 
 /*************************************************************************/
+
+void do_backtrace(void)
+{
+#ifdef HAVE_BACKTRACE
+    void *array[50];
+    size_t size;
+    char **strings;
+    int i;
+
+    alog("Backtrace: Segmentation fault detected");
+    alog("Backtrace: report the following lines");
+    alog("Backtrace: Anope version %s %s %s", version_number,
+         version_build, version_flags);
+    size = backtrace(array, 10);
+    strings = backtrace_symbols(array, size);
+    for (i = 1; i < size; i++) {
+        alog("Backtrace(%d): %s", i, strings[i]);
+    }
+    free(strings);
+    alog("Backtrace: complete");
+#else
+    alog("Backtrace: not available on this platform");
+#endif
+}
diff --git a/src/memoserv.c b/src/memoserv.c
index f2da8bab2..a1255f5bc 100644
--- a/src/memoserv.c
+++ b/src/memoserv.c
@@ -361,6 +361,10 @@ void memo_send(User * u, char *name, char *text, int z)
         m->time = time(NULL);
         m->text = sstrdup(text);
         m->flags = MF_UNREAD;
+        /* Set notify sent flag - DrStein */
+        if (z == 2) {
+            m->flags |= MF_NOTIFYS;
+        }
         /* Set receipt request flag */
         if (z == 3)
             m->flags |= MF_RECEIPT;
@@ -446,7 +450,8 @@ static int do_cancel(User * u)
 
         for (i = mi->memocount - 1; i >= 0; i--) {
             if ((mi->memos[i].flags & MF_UNREAD)
-                && !stricmp(mi->memos[i].sender, u->na->nc->display)) {
+                && !stricmp(mi->memos[i].sender, u->na->nc->display)
+                && (!(mi->memos[i].flags & MF_NOTIFYS))) {
                 delmemo(mi, mi->memos[i].number);
                 notice_lang(s_MemoServ, u, MEMO_CANCELLED, name);
                 return MOD_CONT;
diff --git a/src/news.c b/src/news.c
index 9dc4c0adb..7a2b5a898 100644
--- a/src/news.c
+++ b/src/news.c
@@ -156,7 +156,7 @@ void load_news()
     dbFILE *f;
     int i;
     int16 n;
-    int32 tmp32;
+    uint32 tmp32;
 
     if (!(f = open_db(s_OperServ, NewsDBName, "r", NEWS_VERSION)))
         return;
diff --git a/src/nickserv.c b/src/nickserv.c
index 773a1282b..e025b8f75 100644
--- a/src/nickserv.c
+++ b/src/nickserv.c
@@ -374,7 +374,7 @@ void load_old_ns_dbase(void)
     int failed = 0;
 
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
 
     char bufn[NICKMAX], bufp[PASSMAX];
     char *email, *greet, *url, *forbidby, *forbidreason;
@@ -632,7 +632,7 @@ void load_ns_req_db(void)
     dbFILE *f;
     int i, c, ver;
     NickRequest *nr;
-    int32 tmp32;
+    uint32 tmp32;
     int failed = 0;
 
     if (!(f = open_db(s_NickServ, PreNickDBName, "r", PRE_NICK_VERSION)))
@@ -663,7 +663,7 @@ void load_ns_dbase(void)
     NickCore *nc, **nclast, *ncprev;
     int failed = 0;
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
     char *s;
 
     if (!(f = open_db(s_NickServ, NickDBName, "r", NICK_VERSION)))
diff --git a/src/operserv.c b/src/operserv.c
index 025005d44..fcc567541 100644
--- a/src/operserv.c
+++ b/src/operserv.c
@@ -168,12 +168,15 @@ void moduleAddOperServCmds(void) {
     c = createCommand("SZLINE",     do_szline,     is_services_oper,OPER_HELP_SZLINE, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
 
     /* Commands for Services admins: */
-    c = createCommand("SET",        do_set,        is_services_admin,OPER_HELP_SET, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
-    c = createCommand("SET READONLY", NULL,         NULL,OPER_HELP_SET_READONLY, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
-    c = createCommand("SET LOGCHAN",NULL,         NULL,OPER_HELP_SET_LOGCHAN, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
-    c = createCommand("SET DEBUG",  NULL,          NULL,OPER_HELP_SET_DEBUG, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
-    c = createCommand("SET NOEXPIRE",NULL,         NULL,OPER_HELP_SET_NOEXPIRE, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
-    c = createCommand("SET SUPERADMIN",NULL,         NULL,OPER_HELP_SET_SUPERADMIN, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET",            do_set, is_services_admin,OPER_HELP_SET, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET READONLY",   NULL,   NULL,OPER_HELP_SET_READONLY, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET LOGCHAN",    NULL,   NULL,OPER_HELP_SET_LOGCHAN, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET DEBUG",      NULL,   NULL,OPER_HELP_SET_DEBUG, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET NOEXPIRE",   NULL,   NULL,OPER_HELP_SET_NOEXPIRE, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+    c = createCommand("SET SUPERADMIN", NULL,   NULL,OPER_HELP_SET_SUPERADMIN, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+#ifdef USE_MYSQL
+    c = createCommand("SET SQL",        NULL,   NULL,OPER_HELP_SET_SQL, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
+#endif
     c = createCommand("SVSNICK",       do_svsnick,    is_services_admin,OPER_HELP_SVSNICK, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
     c = createCommand("UMODE",     do_operumodes,     is_services_admin,OPER_HELP_UMODE, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
     c = createCommand("NOOP",       do_noop,       is_services_admin,OPER_HELP_NOOP, -1,-1,-1,-1); addCoreCommand(OPERSERV,c);
@@ -377,7 +380,7 @@ static void load_old_akill(void)
     dbFILE *f;
     int i, j;
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
     char buf[NICKMAX], mask2[BUFSIZE], *mask, *s;
     Akill *ak, *entry;
 
@@ -491,7 +494,7 @@ void load_os_dbase(void)
     int16 i, n, ver, c;
     HostCache *hc, **hclast, *hcprev;
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
     char *s;
     int failed = 0;
 
@@ -533,7 +536,7 @@ void load_os_dbase(void)
     }
 
     if (ver >= 7) {
-        int32 tmp32;
+        uint32 tmp32;
         SAFE(read_int32(&maxusercnt, f));
         SAFE(read_int32(&tmp32, f));
         maxusertime = tmp32;
@@ -4466,7 +4469,22 @@ static int do_set(User * u)
         } else {
             notice_lang(s_OperServ, u, OPER_SET_IGNORE_ERROR);
         }
-
+#ifdef USE_MYSQL
+    } else if (stricmp(option, "SQL") == 0) {
+        if (stricmp(setting, "on") == 0) {
+            if (rdb_init()) {
+                notice_lang(s_OperServ, u, OPER_SET_SQL_ON);
+            } else {
+                notice_lang(s_OperServ, u, OPER_SET_SQL_ERROR_INIT);
+            }
+        } else if (stricmp(setting, "off") == 0) {
+            /* could call rdb_close() but that does nothing - TSL */
+            do_mysql = 0;
+            notice_lang(s_OperServ, u, OPER_SET_SQL_OFF);
+        } else {
+            notice_lang(s_OperServ, u, OPER_SET_SQL_ERROR);
+        }
+#endif
     } else if (stricmp(option, "READONLY") == 0) {
         if (stricmp(setting, "on") == 0) {
             readonly = 1;
diff --git a/src/ptlink.c b/src/ptlink.c
index 5f6ea4220..4689fdbef 100644
--- a/src/ptlink.c
+++ b/src/ptlink.c
@@ -54,7 +54,7 @@ IRCDVar ircd[] = {
      NULL,                      /* Mode to unset for an owner */
      "+r",                      /* Mode On Reg          */
      "-r",                      /* Mode on UnReg        */
-     "+d",                      /* Mode on Nick Change  */
+     NULL,                      /* Mode on Nick Change  */
      1,                         /* Supports SGlines     */
      1,                         /* Supports SQlines     */
      1,                         /* Supports SZlines     */
@@ -1378,17 +1378,6 @@ void anope_set_umode(User * user, int ac, char **av)
         case '-':
             add = 0;
             break;
-        case 'd':
-            if (ac == 0) {
-                alog("user: umode +d with no parameter (?) for user %s",
-                     user->nick);
-                break;
-            }
-
-            ac--;
-            av++;
-            user->svid = strtoul(*av, NULL, 0);
-            break;
         case 'o':
             if (add) {
                 opcnt++;
@@ -1560,7 +1549,7 @@ void anope_cmd_svid_umode(char *nick, time_t ts)
 /* nc_change was = 1, and there is no na->status */
 void anope_cmd_nc_change(User * u)
 {
-    common_svsmode(u, "+d", "1");
+    /* Not Supported by this ircd */
 }
 
 /* SVSMODE +d */
diff --git a/src/sessions.c b/src/sessions.c
index 30edad494..939c92afb 100644
--- a/src/sessions.c
+++ b/src/sessions.c
@@ -76,7 +76,7 @@ int16 nexceptions = 0;
 static Session *findsession(const char *host);
 
 static Exception *find_host_exception(const char *host);
-static int exception_add(const char *mask, const int limit,
+static int exception_add(User * u, const char *mask, const int limit,
                          const char *reason, const char *who,
                          const time_t expires);
 
@@ -380,7 +380,7 @@ void load_exceptions()
     int i;
     int16 n;
     int16 tmp16;
-    int32 tmp32;
+    uint32 tmp32;
 
     if (!
         (f = open_db(s_OperServ, ExceptionDBName, "r", EXCEPTION_VERSION)))
@@ -479,16 +479,29 @@ void save_rdb_exceptions()
 /************************ Exception Manipulation *************************/
 /*************************************************************************/
 
-static int exception_add(const char *mask, const int limit,
+static int exception_add(User * u, const char *mask, const int limit,
                          const char *reason, const char *who,
                          const time_t expires)
 {
     int i;
 
     /* Check if an exception already exists for this mask */
-    for (i = 0; i < nexceptions; i++)
-        if (stricmp(mask, exceptions[i].mask) == 0)
-            return 0;
+    for (i = 0; i < nexceptions; i++) {
+        if (!stricmp(mask, exceptions[i].mask)) {
+            if (exceptions[i].limit != limit) {
+                exceptions[i].limit = limit;
+                if (u)
+                    notice_lang(s_OperServ, u, OPER_EXCEPTION_CHANGED,
+                                mask, exceptions[i].limit);
+                return -2;
+            } else {
+                if (u)
+                    notice_lang(s_OperServ, u, OPER_EXCEPTION_EXISTS,
+                                mask);
+                return -1;
+            }
+        }
+    }
 
     nexceptions++;
     exceptions = srealloc(exceptions, sizeof(Exception) * nexceptions);
@@ -626,6 +639,7 @@ int do_exception(User * u)
     char *mask, *reason, *expiry, *limitstr;
     int limit, expires;
     int i;
+    int x;
 
     if (!LimitSessions) {
         notice_lang(s_OperServ, u, OPER_EXCEPTION_DISABLED);
@@ -679,12 +693,13 @@ int do_exception(User * u)
                 return MOD_CONT;
             }
 
-            if (exception_add(mask, limit, reason, u->nick, expires))
+            x = exception_add(u, mask, limit, reason, u->nick, expires);
+
+            if (x == 1) {
                 notice_lang(s_OperServ, u, OPER_EXCEPTION_ADDED, mask,
                             limit);
-            else
-                notice_lang(s_OperServ, u, OPER_EXCEPTION_ALREADY_PRESENT,
-                            mask, limit);
+            }
+
             if (readonly)
                 notice_lang(s_OperServ, u, READ_ONLY_MODE);
         }
diff --git a/src/solidircd.c b/src/solidircd.c
new file mode 100644
index 000000000..4dd736d28
--- /dev/null
+++ b/src/solidircd.c
@@ -0,0 +1,1710 @@
+/* Solid-IRCD functions
+ *
+ * (C) 2003 Anope Team
+ * Contact us at info@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ * Based on the original code of Epona by Lara.
+ * Based on the original code of Services by Andy Church. 
+ * 
+ *
+ */
+
+/*************************************************************************/
+
+#include "services.h"
+#include "pseudo.h"
+
+#ifdef IRC_SOLID
+
+const char version_protocol[] = "Solid-IRCd 3.4.*";
+
+/* Not all ircds use +f for their flood/join throttle system */
+const char flood_mode_char_set[] = "+j";        /* mode char for FLOOD mode on set */
+const char flood_mode_char_remove[] = "-j";     /* mode char for FLOOD mode on remove */
+int UseTSMODE = 0;              /* does send TSMODE but if it doesn't means it won't so this is disabled */
+
+IRCDVar ircd[] = {
+    {"Solid-IRCd 3.4.*",        /* ircd name */
+     "+o",                      /* nickserv mode */
+     "+o",                      /* chanserv mode */
+     "+o",                      /* memoserv mode */
+     "+o",                      /* hostserv mode */
+     "+io",                     /* operserv mode */
+     "+o",                      /* botserv mode  */
+     "+h",                      /* helpserv mode */
+     "+i",                      /* Dev/Null mode */
+     "+io",                     /* Global mode   */
+     "+o",                      /* nickserv alias mode */
+     "+o",                      /* chanserv alias mode */
+     "+o",                      /* memoserv alias mode */
+     "+io",                     /* hostserv alias mode */
+     "+io",                     /* operserv alias mode */
+     "+o",                      /* botserv alias mode  */
+     "+h",                      /* helpserv alias mode */
+     "+i",                      /* Dev/Null alias mode */
+     "+io",                     /* Global alias mode   */
+     "+",                       /* Used by BotServ Bots */
+     2,                         /* Chan Max Symbols     */
+     "-cilmnpstOR",             /* Modes to Remove */
+     "+o",                      /* Channel Umode used by Botserv bots */
+     1,                         /* SVSNICK */
+     1,                         /* Vhost  */
+     0,                         /* Has Owner */
+     NULL,                      /* Mode to set for an owner */
+     NULL,                      /* Mode to unset for an owner */
+     "+rd",                     /* Mode On Reg          */
+     "-r+d",                    /* Mode on UnReg        */
+     "+d",                      /* Mode on Nick Change  */
+     1,                         /* Supports SGlines     */
+     1,                         /* Supports SQlines     */
+     1,                         /* Supports SZlines     */
+     0,                         /* Supports Halfop +h   */
+     3,                         /* Number of server args */
+     0,                         /* Join 2 Set           */
+     0,                         /* Join 2 Message       */
+     1,                         /* Has exceptions +e    */
+     0,                         /* TS Topic Forward     */
+     0,                         /* TS Topci Backward    */
+     0,                         /* Protected Umode      */
+     0,                         /* Has Admin            */
+     1,                         /* Chan SQlines         */
+     1,                         /* Quit on Kill         */
+     1,                         /* SVSMODE unban        */
+     0,                         /* Has Protect          */
+     0,                         /* Reverse              */
+     1,                         /* Chan Reg             */
+     CMODE_r,                   /* Channel Mode         */
+     0,                         /* vidents              */
+     1,                         /* svshold              */
+     1,                         /* time stamp on mode   */
+     1,                         /* NICKIP               */
+     0,                         /* O:LINE               */
+     1,                         /* UMODE               */
+     0,                         /* VHOST ON NICK        */
+     0,                         /* Change RealName      */
+     0,                         /* ChanServ extra       */
+     0,                         /* No Knock             */
+     0,                         /* Admin Only           */
+     DEFAULT_MLOCK,             /* Default MLOCK       */
+     UMODE_v,                   /* Vhost Mode           */
+     1,                         /* +f                   */
+     0,                         /* +L                   */
+     CMODE_j,                   /* Mode */
+     0,                         /* Mode */
+     1,
+     1,                         /* No Knock requires +i */
+     NULL,                      /* CAPAB Chan Modes             */
+     0,                         /* We support TOKENS */
+     1,                         /* TOKENS are CASE inSensitive */
+     0,                         /* TIME STAMPS are BASE64 */
+     1,                         /* +I support */
+     0,                         /* SJOIN ban char */
+     0,                         /* SJOIN except char */
+     }
+    ,
+    {NULL}
+};
+
+IRCDCAPAB ircdcap[] = {
+    {
+     CAPAB_NOQUIT,              /* NOQUIT       */
+     CAPAB_TSMODE,              /* TSMODE       */
+     CAPAB_UNCONNECT,           /* UNCONNECT    */
+     0,                         /* NICKIP       */
+     0,                         /* SJOIN        */
+     0,                         /* ZIP          */
+     CAPAB_BURST,               /* BURST        */
+     0,                         /* TS5          */
+     0,                         /* TS3          */
+     CAPAB_DKEY,                /* DKEY         */
+     0,                         /* PT4          */
+     0,                         /* SCS          */
+     0,                         /* QS           */
+     0,                         /* UID          */
+     0,                         /* KNOCK        */
+     0,                         /* CLIENT       */
+     0,                         /* IPV6         */
+     0,                         /* SSJ5         */
+     0,                         /* SN2          */
+     0,                         /* TOKEN        */
+     0,                         /* VHOST        */
+     0,                         /* SSJ3         */
+     0,                         /* NICK2        */
+     0,                         /* UMODE2       */
+     0,                         /* VL           */
+     0,                         /* TLKEXT       */
+     0,                         /* DODKEY       */
+     CAPAB_DOZIP,               /* DOZIP        */
+     0, 0}
+};
+
+
+void anope_set_umode(User * user, int ac, char **av)
+{
+    int add = 1;                /* 1 if adding modes, 0 if deleting */
+    char *modes = av[0];
+
+    ac--;
+
+    if (debug)
+        alog("debug: Changing mode for %s to %s", user->nick, modes);
+
+    while (*modes) {
+
+        add ? (user->mode |= umodes[(int) *modes]) : (user->mode &=
+                                                      ~umodes[(int)
+                                                              *modes]);
+
+        switch (*modes++) {
+        case '+':
+            add = 1;
+            break;
+        case '-':
+            add = 0;
+            break;
+        case 'a':
+            if (UnRestrictSAdmin) {
+                break;
+            }
+            if (add && !is_services_admin(user)) {
+                common_svsmode(user, "-a", NULL);
+                user->mode &= ~UMODE_a;
+            }
+            break;
+        case 'd':
+            if (ac == 0) {
+                alog("user: umode +d with no parameter (?) for user %s",
+                     user->nick);
+                break;
+            }
+
+            ac--;
+            av++;
+            user->svid = strtoul(*av, NULL, 0);
+            break;
+        case 'o':
+            if (add) {
+                opcnt++;
+
+                if (WallOper)
+                    anope_cmd_global(s_OperServ,
+                                     "\2%s\2 is now an IRC operator.",
+                                     user->nick);
+                display_news(user, NEWS_OPER);
+
+            } else {
+                opcnt--;
+            }
+            break;
+        case 'r':
+            if (add && !nick_identified(user)) {
+                common_svsmode(user, "-r", NULL);
+                user->mode &= ~UMODE_r;
+            }
+            break;
+        case 'v':
+            update_host(user);
+            break;
+        }
+    }
+}
+
+
+unsigned long umodes[128] = {
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused, Unused, Horzontal Tab */
+    0, 0, 0,                    /* Line Feed, Unused, Unused */
+    0, 0, 0,                    /* Carriage Return, Unused, Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused */
+    0, 0, 0,                    /* Unused, Unused, Space */
+    0, 0, 0,                    /* ! " #  */
+    0, 0, 0,                    /* $ % &  */
+    0, 0, 0,                    /* ! ( )  */
+    0, 0, 0,                    /* * + ,  */
+    0, 0, 0,                    /* - . /  */
+    0, 0,                       /* 0 1 */
+    0, 0,                       /* 2 3 */
+    0, 0,                       /* 4 5 */
+    0, 0,                       /* 6 7 */
+    0, 0,                       /* 8 9 */
+    0, 0,                       /* : ; */
+    0, 0, 0,                    /* < = > */
+    0, 0,                       /* ? @ */
+    UMODE_A, 0, UMODE_C,        /* A B C */
+    UMODE_D, 0, UMODE_F,        /* D E F */
+    0, UMODE_H, UMODE_I,        /* G H I */
+    0, UMODE_K, 0,              /* J K L */
+    0, 0, UMODE_O,              /* M N O */
+    0, 0, UMODE_R,              /* P Q R */
+    0, 0, 0,                    /* S T U */
+    0, 0, UMODE_X,              /* V W X */
+    0,                          /* Y */
+    0,                          /* Z */
+    0, 0, 0,                    /* [ \ ] */
+    0, 0, 0,                    /* ^ _ ` */
+    UMODE_a, UMODE_b, UMODE_c,  /* a b c */
+    UMODE_d, UMODE_e, UMODE_f,  /* d e f */
+    UMODE_g, UMODE_h, UMODE_i,  /* g h i */
+    UMODE_j, UMODE_k, 0,        /* j k l */
+    UMODE_m, UMODE_n, UMODE_o,  /* m n o */
+    0, 0, UMODE_r,              /* p q r */
+    UMODE_s, 0, 0,              /* s t u */
+    UMODE_v, 0, UMODE_x,        /* v w x */
+    UMODE_y,                    /* y */
+    UMODE_z,                    /* z */
+    0, 0, 0,                    /* { | } */
+    0, 0                        /* ~ ‚ */
+};
+
+char csmodes[128] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+    0,
+    0,
+    0, 0, 0,
+    'h',
+    0, 0, 0, 0,
+    0,
+
+    'v', 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+    'o', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+CMMode cmmodes[128] = {
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL},     /* BCD */
+    {NULL}, {NULL}, {NULL},     /* EFG */
+    {NULL},                     /* H */
+    {add_invite, del_invite},
+    {NULL},                     /* J */
+    {NULL}, {NULL}, {NULL},     /* KLM */
+    {NULL}, {NULL}, {NULL},     /* NOP */
+    {NULL}, {NULL}, {NULL},     /* QRS */
+    {NULL}, {NULL}, {NULL},     /* TUV */
+    {NULL}, {NULL}, {NULL},     /* WXY */
+    {NULL},                     /* Z */
+    {NULL}, {NULL},             /* (char 91 - 92) */
+    {NULL}, {NULL}, {NULL},     /* (char 93 - 95) */
+    {NULL},                     /* ` (char 96) */
+    {NULL},                     /* a (char 97) */
+    {add_ban, del_ban},
+    {NULL},
+    {NULL},
+    {add_exception, del_exception},
+    {NULL},
+    {NULL},
+    {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL},
+    {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}
+};
+
+
+
+CBMode cbmodes[128] = {
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0},
+    {0},                        /* A */
+    {0},                        /* B */
+    {0},                        /* C */
+    {0},                        /* D */
+    {0},                        /* E */
+    {0},                        /* F */
+    {0},                        /* G */
+    {0},                        /* H */
+    {0},                        /* I */
+    {0},                        /* J */
+    {0},                        /* K */
+    {0},                        /* L */
+    {CMODE_M},
+    {0},                        /* N */
+    {CMODE_O, CBM_NO_USER_MLOCK, NULL, NULL},
+    {0},                        /* P */
+    {0},                        /* Q */
+    {CMODE_R, 0, NULL, NULL},   /* R */
+    {0},                        /* S */
+    {0},                        /* T */
+    {0},                        /* U */
+    {0},                        /* V */
+    {0},                        /* W */
+    {0},                        /* X */
+    {0},                        /* Y */
+    {0},                        /* Z */
+    {0}, {0}, {0}, {0}, {0}, {0},
+    {0},                        /* a */
+    {0},                        /* b */
+    {CMODE_c, 0, NULL, NULL},
+    {0},                        /* d */
+    {0},                        /* e */
+    {0},                        /* f */
+    {0},                        /* g */
+    {0},                        /* h */
+    {CMODE_i, 0, NULL, NULL},
+    {CMODE_j, 0, set_flood, cs_set_flood},      /* j */
+    {CMODE_k, 0, set_key, cs_set_key},
+    {CMODE_l, CBM_MINUS_NO_ARG, set_limit, cs_set_limit},
+    {CMODE_m, 0, NULL, NULL},
+    {CMODE_n, 0, NULL, NULL},
+    {0},                        /* o */
+    {CMODE_p, 0, NULL, NULL},
+    {0},                        /* q */
+    {CMODE_r, CBM_NO_MLOCK, NULL, NULL},
+    {CMODE_s, 0, NULL, NULL},
+    {CMODE_t, 0, NULL, NULL},
+    {0},
+    {0},                        /* v */
+    {0},                        /* w */
+    {0},                        /* x */
+    {0},                        /* y */
+    {0},                        /* z */
+    {0}, {0}, {0}, {0}
+};
+
+CBModeInfo cbmodeinfos[] = {
+    {'c', CMODE_c, 0, NULL, NULL},
+    {'i', CMODE_i, 0, NULL, NULL},
+    {'j', CMODE_j, 0, get_flood, cs_get_flood},
+    {'k', CMODE_k, 0, get_key, cs_get_key},
+    {'l', CMODE_l, CBM_MINUS_NO_ARG, get_limit, cs_get_limit},
+    {'m', CMODE_m, 0, NULL, NULL},
+    {'n', CMODE_n, 0, NULL, NULL},
+    {'p', CMODE_p, 0, NULL, NULL},
+    {'r', CMODE_r, 0, NULL, NULL},
+    {'s', CMODE_s, 0, NULL, NULL},
+    {'t', CMODE_t, 0, NULL, NULL},
+    {'M', CMODE_M, 0, NULL, NULL},
+    {'O', CMODE_O, 0, NULL, NULL},
+    {0}
+};
+
+CUMode cumodes[128] = {
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0},
+
+    {0},
+    {0},                        /* a */
+    {0},                        /* b */
+    {0},                        /* c */
+    {0},                        /* d */
+    {0},                        /* e */
+    {0},                        /* f */
+    {0},                        /* g */
+    {0},                        /* h */
+    {0},                        /* i */
+    {0},                        /* j */
+    {0},                        /* k */
+    {0},                        /* l */
+    {0},                        /* m */
+    {0},                        /* n */
+    {CUS_OP, CUF_PROTECT_BOTSERV, check_valid_op},
+    {0},                        /* p */
+    {0},                        /* q */
+    {0},                        /* r */
+    {0},                        /* s */
+    {0},                        /* t */
+    {0},                        /* u */
+    {CUS_VOICE, 0, NULL},
+    {0},                        /* w */
+    {0},                        /* x */
+    {0},                        /* y */
+    {0},                        /* z */
+    {0}, {0}, {0}, {0}, {0}
+};
+
+
+
+void anope_cmd_mode(char *source, char *dest, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+
+        if (!buf) {
+            return;
+        }
+
+        if (ircdcap->tsmode) {
+            if (uplink_capab & ircdcap->tsmode) {
+                send_cmd(source, "MODE %s 0 %s", dest, buf);
+            } else {
+                send_cmd(source, "MODE %s %s", dest, buf);
+            }
+        } else {
+            send_cmd(source, "MODE %s %s", dest, buf);
+        }
+    }
+}
+
+/* SVSHOLD - set */
+void anope_cmd_svshold(char *nick)
+{
+    send_cmd(ServerName, "SVSHOLD %s %d :%s", nick, NSReleaseTimeout,
+             "Being held for registered user");
+}
+
+/* SVSHOLD - release */
+void anope_cmd_release_svshold(char *nick)
+{
+    send_cmd(ServerName, "SVSHOLD %s 0", nick);
+}
+
+/* SVSMODE -b */
+void anope_cmd_unban(char *name, char *nick)
+{
+    send_cmd(ServerName, "SVSMODE %s -b %s", name, nick);
+}
+
+void anope_cmd_bot_chan_mode(char *nick, char *chan)
+{
+    anope_cmd_mode(nick, chan, "%s %s", ircd->botchanumode, nick);
+}
+
+/* EVENT: SJOIN */
+int anope_event_sjoin(char *source, int ac, char **av)
+{
+    do_sjoin(source, ac, av);
+    return MOD_CONT;
+}
+
+/*
+** NICK - new
+**      source  = NULL
+**	parv[0] = nickname
+**      parv[1] = hopcount
+**      parv[2] = timestamp
+**      parv[3] = modes
+**      parv[4] = username
+**      parv[5] = hostname
+**      parv[6] = server
+**	parv[7] = servicestamp
+**      parv[8] = IP
+**	parv[9] = info
+** NICK - change 
+**      source  = oldnick
+**	parv[0] = new nickname
+**      parv[1] = hopcount
+*/
+int anope_event_nick(char *source, int ac, char **av)
+{
+    User *user;
+
+    if (ac != 2) {
+        user = do_nick(source, av[0], av[4], av[5], av[6], av[9],
+                       strtoul(av[2], NULL, 10), strtoul(av[7], NULL, 0),
+                       strtoul(av[8], NULL, 0), NULL, NULL);
+        if (user) {
+            anope_set_umode(user, 1, &av[3]);
+        }
+    } else {
+        do_nick(source, av[0], NULL, NULL, NULL, NULL,
+                strtoul(av[1], NULL, 10), 0, 0, NULL, NULL);
+    }
+    return MOD_CONT;
+}
+
+/* EVENT : CAPAB */
+int anope_event_capab(char *source, int ac, char **av)
+{
+    capab_parse(ac, av);
+    return MOD_CONT;
+}
+
+/* EVENT : OS */
+int anope_event_os(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    m_privmsg(source, s_OperServ, av[0]);
+    return MOD_CONT;
+}
+
+/* EVENT : NS */
+int anope_event_ns(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    m_privmsg(source, s_NickServ, av[0]);
+    return MOD_CONT;
+}
+
+/* EVENT : MS */
+int anope_event_ms(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    m_privmsg(source, s_MemoServ, av[0]);
+    return MOD_CONT;
+}
+
+/* EVENT : HS */
+int anope_event_hs(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    m_privmsg(source, s_HostServ, av[0]);
+    return MOD_CONT;
+}
+
+/* EVENT : CS */
+int anope_event_cs(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    m_privmsg(source, s_ChanServ, av[0]);
+    return MOD_CONT;
+}
+
+int anope_event_436(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+
+    m_nickcoll(av[0]);
+    return MOD_CONT;
+}
+
+/* *INDENT-OFF* */
+void moduleAddIRCDMsgs(void) {
+    Message *m;
+
+    m = createMessage("401",       anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("402",       anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("436",       anope_event_436); addCoreMessage(IRCD,m);
+    m = createMessage("AWAY",      anope_event_away); addCoreMessage(IRCD,m);
+    m = createMessage("INVITE",    anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("JOIN",      anope_event_join); addCoreMessage(IRCD,m);
+    m = createMessage("KICK",      anope_event_kick); addCoreMessage(IRCD,m);
+    m = createMessage("KILL",      anope_event_kill); addCoreMessage(IRCD,m);
+    m = createMessage("MODE",      anope_event_mode); addCoreMessage(IRCD,m);
+    m = createMessage("MOTD",      anope_event_motd); addCoreMessage(IRCD,m);
+    m = createMessage("NICK",      anope_event_nick); addCoreMessage(IRCD,m);
+    m = createMessage("NOTICE",    anope_event_notice); addCoreMessage(IRCD,m);
+    m = createMessage("PART",      anope_event_part); addCoreMessage(IRCD,m);
+    m = createMessage("PASS",      anope_event_pass); addCoreMessage(IRCD,m);
+    m = createMessage("PING",      anope_event_ping); addCoreMessage(IRCD,m);
+    m = createMessage("PRIVMSG",   anope_event_privmsg); addCoreMessage(IRCD,m);
+    m = createMessage("QUIT",      anope_event_quit); addCoreMessage(IRCD,m);
+    m = createMessage("SERVER",    anope_event_server); addCoreMessage(IRCD,m);
+    m = createMessage("SQUIT",     anope_event_squit); addCoreMessage(IRCD,m);
+    m = createMessage("TOPIC",     anope_event_topic); addCoreMessage(IRCD,m);
+    m = createMessage("USER",      anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("WALLOPS",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("WHOIS",     anope_event_whois); addCoreMessage(IRCD,m);
+    m = createMessage("AKILL",     anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("GLOBOPS",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("GNOTICE",   anope_event_gnotice); addCoreMessage(IRCD,m);
+    m = createMessage("GOPER",     anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("RAKILL",    anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SILENCE",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SVSKILL",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SVSMODE",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SVSNICK",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SVSNOOP",   anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SQLINE",    anope_event_sqline); addCoreMessage(IRCD,m);
+    m = createMessage("UNSQLINE",  anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("CAPAB", 	   anope_event_capab); addCoreMessage(IRCD,m);
+    m = createMessage("CS",        anope_event_cs); addCoreMessage(IRCD,m);
+    m = createMessage("HS",        anope_event_hs); addCoreMessage(IRCD,m);
+    m = createMessage("MS",        anope_event_ms); addCoreMessage(IRCD,m);
+    m = createMessage("NS",        anope_event_ns); addCoreMessage(IRCD,m);
+    m = createMessage("OS",        anope_event_os); addCoreMessage(IRCD,m);
+    m = createMessage("RS",        anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SGLINE",    anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SJOIN",     anope_event_sjoin); addCoreMessage(IRCD,m);
+    m = createMessage("SS",        anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SVINFO",    anope_event_svinfo); addCoreMessage(IRCD,m);
+    m = createMessage("SZLINE",    anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("UNSGLINE",  anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("UNSZLINE",  anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("ERROR",     anope_event_error); addCoreMessage(IRCD,m);
+    m = createMessage("LUSERSLOCK",anope_event_luserslock); addCoreMessage(IRCD,m);
+    m = createMessage("BURST",     anope_event_burst); addCoreMessage(IRCD,m);
+    m = createMessage("ADMIN",     anope_event_admin); addCoreMessage(IRCD,m);
+    m = createMessage("SVHOST",    anope_event_vs); addCoreMessage(IRCD,m);
+    m = createMessage("ELMER",     anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SILLY",     anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("SHUN",      anope_event_null); addCoreMessage(IRCD,m);
+    m = createMessage("NORMAL",    anope_event_null); addCoreMessage(IRCD,m);
+}
+
+/* *INDENT-ON* */
+
+
+int anope_event_vs(char *source, int ac, char **av)
+{
+    User *u;
+
+    if (ac != 2)
+        return MOD_CONT;
+
+    u = finduser(av[0]);
+    if (!u) {
+        alog("user: SVHOST for nonexistent user %s", av[0]);
+        return MOD_CONT;
+    }
+
+    change_user_host(u, av[1]);
+    return MOD_CONT;
+
+}
+
+/* SQLINE */
+void anope_cmd_sqline(char *mask, char *reason)
+{
+    if (!mask || !reason) {
+        return;
+    }
+
+    send_cmd(NULL, "SQLINE %s :%s", mask, reason);
+}
+
+/* UNSGLINE */
+void anope_cmd_unsgline(char *mask)
+{
+    send_cmd(NULL, "UNSGLINE 0 :%s", mask);
+}
+
+/* UNSZLINE */
+void anope_cmd_unszline(char *mask)
+{
+    send_cmd(NULL, "UNSZLINE 0 %s", mask);
+}
+
+/* SZLINE */
+void anope_cmd_szline(char *mask, char *reason, char *whom)
+{
+    send_cmd(NULL, "SZLINE %s :%s", mask, reason);
+}
+
+/* SVSNOOP */
+void anope_cmd_svsnoop(char *server, int set)
+{
+    send_cmd(NULL, "SVSNOOP %s %s", server, (set ? "+" : "-"));
+}
+
+void anope_cmd_svsadmin(char *server, int set)
+{
+    anope_cmd_svsnoop(server, set);
+}
+
+/* SGLINE */
+void anope_cmd_sgline(char *mask, char *reason)
+{
+    send_cmd(NULL, "SGLINE %d :%s:%s", strlen(mask), mask, reason);
+}
+
+/* RAKILL */
+void anope_cmd_remove_akill(char *user, char *host)
+{
+    send_cmd(NULL, "RAKILL %s %s", host, user);
+}
+
+/* PART */
+void anope_cmd_part(char *nick, char *chan, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+
+    if (!nick || !chan) {
+        return;
+    }
+
+    if (buf) {
+        send_cmd(nick, "PART %s :%s", chan, buf);
+    } else {
+        send_cmd(nick, "PART %s", chan);
+    }
+}
+
+/* TOPIC */
+void anope_cmd_topic(char *whosets, char *chan, char *whosetit,
+                     char *topic, time_t when)
+{
+    send_cmd(whosets, "TOPIC %s %s %lu :%s", chan, whosetit,
+             (unsigned long int) when, topic);
+}
+
+/* UNSQLINE */
+void anope_cmd_unsqline(char *user)
+{
+    send_cmd(NULL, "UNSQLINE %s", user);
+}
+
+/* JOIN - SJOIN */
+void anope_cmd_join(char *user, char *channel, time_t chantime)
+{
+    send_cmd(user, "SJOIN %ld %s", (long int) chantime, channel);
+}
+
+/* AKILL */
+/* parv[1]=host 
+ * parv[2]=user
+ * parv[3]=length
+ * parv[4]=akiller
+ * parv[5]=time set
+ * parv[6]=reason
+ */
+void anope_cmd_akill(char *user, char *host, char *who, time_t when,
+                     time_t expires, char *reason)
+{
+    send_cmd(NULL, "AKILL %s %s %d %s %ld :%s", host, user, 86400 * 2, who,
+             (long int) time(NULL), reason);
+}
+
+/* SVSKILL */
+/* parv[0] = servername
+ * parv[1] = client
+ * parv[2] = nick stamp
+ * parv[3] = kill message
+ */
+/*
+  Note: if the stamp is null 0, the below usage is correct of Bahamut
+*/
+void anope_cmd_svskill(char *source, char *user, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (!source || !user || !fmt) {
+        return;
+    }
+
+    va_start(args, fmt);
+    vsnprintf(buf, BUFSIZE - 1, fmt, args);
+    va_end(args);
+
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(source, "SVSKILL %s :%s", user, buf);
+}
+
+/* SVSMODE */
+/* parv[0] - sender
+ * parv[1] - nick
+ * parv[2] - TS (or mode, depending on svs version)
+ * parv[3] - mode (or services id if old svs version)
+ * parv[4] - optional arguement (services id)
+ */
+void anope_cmd_svsmode(User * u, int ac, char **av)
+{
+    send_cmd(ServerName, "SVSMODE %s %ld %s%s%s", u->nick,
+             (long int) u->timestamp, av[0], (ac == 2 ? " " : ""),
+             (ac == 2 ? av[1] : ""));
+}
+
+/* SQUIT */
+/*
+ *        parv[0] = sender prefix 
+ *        parv[1] = server name 
+ *        parv[2] = comment
+*/
+void anope_cmd_squit(char *servname, char *message)
+{
+    send_cmd(NULL, "SQUIT %s :%s", servname, message);
+}
+
+/* PONG */
+void anope_cmd_pong(char *servname, char *who)
+{
+    send_cmd(servname, "PONG %s", who);
+}
+
+void anope_cmd_connect(int servernum)
+{
+    if (servernum == 1) {
+        anope_cmd_pass(RemotePassword);
+    } else if (servernum == 2) {
+        anope_cmd_pass(RemotePassword2);
+    } else if (servernum == 3) {
+        anope_cmd_pass(RemotePassword3);
+    }
+    anope_cmd_capab();
+    anope_cmd_server(ServerName, 1, ServerDesc);
+    anope_cmd_svinfo();
+    anope_cmd_burst();
+}
+
+
+/*
+ * SVINFO 
+ *       parv[0] = sender prefix 
+ *       parv[1] = TS_CURRENT for the server 
+ *       parv[2] = TS_MIN for the server 
+ *       parv[3] = server is standalone or connected to non-TS only 
+ *       parv[4] = server's idea of UTC time
+ */
+void anope_cmd_svinfo()
+{
+    send_cmd(NULL, "SVINFO 5 3 0 :%ld", (long int) time(NULL));
+}
+
+/* PASS */
+void anope_cmd_pass(char *pass)
+{
+    send_cmd(NULL, "PASS %s :TS", pass);
+}
+
+/* SERVER */
+void anope_cmd_server(char *servname, int hop, char *descript)
+{
+    send_cmd(NULL, "SERVER %s %d :%s", servname, hop, ServerDesc);
+}
+
+/* CAPAB */
+void anope_cmd_capab()
+{
+    /* CAPAB SSJOIN NOQUIT BURST UNCONNECT ZIP NICKIP TSMODE */
+    send_cmd(NULL, "CAPAB SSJOIN NOQUIT BURST UNCONNECT NICKIP TSMODE");
+}
+
+/* EVENT : SERVER */
+int anope_event_server(char *source, int ac, char **av)
+{
+    char *uplink;
+
+    if (!stricmp(av[1], "1")) {
+        uplink = sstrdup(av[0]);
+    }
+
+    do_server(source, av[0], av[1], av[2], NULL);
+    return MOD_CONT;
+}
+
+/* EVENT : PRIVMSG */
+int anope_event_privmsg(char *source, int ac, char **av)
+{
+    if (ac != 2)
+        return MOD_CONT;
+    m_privmsg(source, av[0], av[1]);
+    return MOD_CONT;
+}
+
+/* EVENT : SVINFO */
+/*
+ *       parv[0] = sender prefix 
+ *       parv[1] = TS_CURRENT for the server 
+ *       parv[2] = TS_MIN for the server 
+ *       parv[3] = server is standalone or connected to non-TS only 
+ *       parv[4] = server's idea of UTC time
+ */
+int anope_event_svinfo(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+
+int anope_event_part(char *source, int ac, char **av)
+{
+    if (ac < 1 || ac > 2)
+        return MOD_CONT;
+    do_part(source, ac, av);
+    return MOD_CONT;
+}
+
+int anope_event_whois(char *source, int ac, char **av)
+{
+    if (source && ac >= 1) {
+        m_whois(source, av[0]);
+    }
+    return MOD_CONT;
+}
+
+int anope_event_topic(char *source, int ac, char **av)
+{
+    if (ac != 4)
+        return MOD_CONT;
+    do_topic(source, ac, av);
+    return MOD_CONT;
+}
+
+int anope_event_squit(char *source, int ac, char **av)
+{
+    if (ac != 2)
+        return MOD_CONT;
+    do_squit(source, ac, av);
+    return MOD_CONT;
+}
+
+int anope_event_quit(char *source, int ac, char **av)
+{
+    if (ac != 1)
+        return MOD_CONT;
+    do_quit(source, ac, av);
+    return MOD_CONT;
+}
+
+/* EVENT: MODE */
+int anope_event_mode(char *source, int ac, char **av)
+{
+    if (ac < 2)
+        return MOD_CONT;
+
+    if (*av[0] == '#' || *av[0] == '&') {
+        do_cmode(source, ac, av);
+    } else {
+        do_umode(source, ac, av);
+    }
+    return MOD_CONT;
+}
+
+/* EVENT: KILL */
+int anope_event_kill(char *source, int ac, char **av)
+{
+    if (ac != 2)
+        return MOD_CONT;
+
+    m_kill(av[0], av[1]);
+    return MOD_CONT;
+}
+
+/* EVENT: KICK */
+int anope_event_kick(char *source, int ac, char **av)
+{
+    if (ac != 3)
+        return MOD_CONT;
+    do_kick(source, ac, av);
+    return MOD_CONT;
+}
+
+/* EVENT: JOIN */
+int anope_event_join(char *source, int ac, char **av)
+{
+    if (ac != 1)
+        return MOD_CONT;
+    do_join(source, ac, av);
+    return MOD_CONT;
+}
+
+/* EVENT: MOTD */
+int anope_event_motd(char *source, int ac, char **av)
+{
+    if (!source) {
+        return MOD_CONT;
+    }
+
+    m_motd(source);
+    return MOD_CONT;
+}
+
+void anope_cmd_notice_ops(char *source, char *dest, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+
+        if (!buf) {
+            return;
+        }
+        send_cmd(NULL, "NOTICE @%s :%s", dest, buf);
+    }
+}
+
+/* NOTICE */
+void anope_cmd_notice(char *source, char *dest, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, sizeof(buf), fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    if (UsePrivmsg) {
+        anope_cmd_privmsg2(source, dest, buf);
+    } else {
+        send_cmd(source, "NOTICE %s :%s", dest, buf);
+    }
+}
+
+void anope_cmd_notice2(char *source, char *dest, char *msg)
+{
+    send_cmd(source, "NOTICE %s :%s", dest, msg);
+}
+
+void anope_cmd_privmsg(char *source, char *dest, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(source, "PRIVMSG %s :%s", dest, buf);
+}
+
+void anope_cmd_privmsg2(char *source, char *dest, char *msg)
+{
+    send_cmd(source, "PRIVMSG %s :%s", dest, msg);
+}
+
+void anope_cmd_serv_notice(char *source, char *dest, char *msg)
+{
+    send_cmd(source, "NOTICE $%s :%s", dest, msg);
+}
+
+void anope_cmd_serv_privmsg(char *source, char *dest, char *msg)
+{
+    send_cmd(source, "PRIVMSG $%s :%s", dest, msg);
+}
+
+/* GLOBOPS */
+void anope_cmd_global(char *source, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(source ? source : ServerName, "GLOBOPS :%s", buf);
+}
+
+/* 391 */
+void anope_cmd_391(char *source, char *timestr)
+{
+    if (!timestr) {
+        return;
+    }
+    send_cmd(NULL, "391 :%s %s :%s", source, ServerName, timestr);
+}
+
+/* 250 */
+void anope_cmd_250(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(NULL, "250 %s ", buf);
+}
+
+/* 307 */
+void anope_cmd_307(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(ServerName, "307 %s ", buf);
+}
+
+/* 311 */
+void anope_cmd_311(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(ServerName, "311 %s ", buf);
+}
+
+/* 312 */
+void anope_cmd_312(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(ServerName, "312 %s ", buf);
+}
+
+/* 317 */
+void anope_cmd_317(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(ServerName, "317 %s ", buf);
+}
+
+/* 219 */
+void anope_cmd_219(char *source, char *letter)
+{
+    if (!source) {
+        return;
+    }
+
+    if (letter) {
+        send_cmd(NULL, "219 %s %c :End of /STATS report.", source,
+                 *letter);
+    } else {
+        send_cmd(NULL, "219 %s l :End of /STATS report.", source);
+    }
+}
+
+/* 401 */
+void anope_cmd_401(char *source, char *who)
+{
+    if (!source || !who) {
+        return;
+    }
+    send_cmd(ServerName, "401 %s %s :No such service.", source, who);
+}
+
+/* 318 */
+void anope_cmd_318(char *source, char *who)
+{
+    if (!source || !who) {
+        return;
+    }
+
+    send_cmd(ServerName, "318 %s %s :End of /WHOIS list.", source, who);
+}
+
+/* 242 */
+void anope_cmd_242(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(NULL, "242 %s ", buf);
+}
+
+/* 243 */
+void anope_cmd_243(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(NULL, "243 %s ", buf);
+}
+
+/* 211 */
+void anope_cmd_211(const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    }
+
+    send_cmd(NULL, "211 %s ", buf);
+}
+
+void anope_cmd_nick(char *nick, char *name, char *modes)
+{
+    EnforceQlinedNick(nick, NULL);
+    send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
+             (long int) time(NULL), modes, ServiceUser, ServiceHost,
+             ServerName, name);
+    anope_cmd_sqline(nick, "Reserved for services");
+}
+
+void anope_cmd_kick(char *source, char *chan, char *user, const char *fmt,
+                    ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+
+    if (buf) {
+        send_cmd(source, "KICK %s %s :%s", chan, user, buf);
+    } else {
+        send_cmd(source, "KICK %s %s", chan, user);
+    }
+}
+
+void anope_cmd_372(char *source, char *msg)
+{
+    send_cmd(ServerName, "372 %s :- %s", source, msg);
+}
+
+void anope_cmd_372_error(char *source)
+{
+    send_cmd(ServerName, "372 %s :- MOTD file not found!  Please "
+             "contact your IRC administrator.", source);
+}
+
+void anope_cmd_375(char *source)
+{
+    send_cmd(ServerName, "375 %s :- %s Message of the Day",
+             source, ServerName);
+}
+
+void anope_cmd_376(char *source)
+{
+    send_cmd(ServerName, "376 %s :End of /MOTD command.", source);
+}
+
+/* INVITE */
+void anope_cmd_invite(char *source, char *chan, char *nick)
+{
+    if (!source || !chan || !nick) {
+        return;
+    }
+
+    send_cmd(source, "INVITE %s %s", nick, chan);
+}
+
+/* QUIT */
+void anope_cmd_quit(char *source, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+
+    if (buf) {
+        send_cmd(source, "QUIT :%s", buf);
+    } else {
+        send_cmd(source, "QUIT");
+    }
+}
+
+int anope_event_away(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+
+    if (!source) {
+        return MOD_CONT;
+    }
+    m_away(source, av[0]);
+    return MOD_CONT;
+}
+
+int anope_event_ping(char *source, int ac, char **av)
+{
+    if (ac < 1)
+        return MOD_CONT;
+    anope_cmd_pong(ac > 1 ? av[1] : ServerName, av[0]);
+    return MOD_CONT;
+}
+
+void anope_cmd_351(char *source)
+{
+    send_cmd(ServerName, "351 %s Anope-%s %s :%s - %s -- %s",
+             source, version_number, ServerName, ircd->name, version_flags,
+             version_build);
+}
+
+void anope_cmd_bot_nick(char *nick, char *user, char *host, char *real,
+                        char *modes)
+{
+    EnforceQlinedNick(nick, s_BotServ);
+    send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
+             (long int) time(NULL), modes, user, host, ServerName, real);
+    anope_cmd_sqline(nick, "Reserved for services");
+}
+
+/* SVSNICK */
+/* parv[0] = sender
+ * parv[1] = old nickname
+ * parv[2] = new nickname
+ * parv[3] = timestamp
+ */
+void anope_cmd_svsnick(char *source, char *guest, time_t when)
+{
+    if (!source || !guest) {
+        return;
+    }
+    send_cmd(NULL, "SVSNICK %s %s :%ld", source, guest, (long int) when);
+}
+
+void anope_cmd_guest_nick(char *nick, char *user, char *host, char *real,
+                          char *modes)
+{
+    send_cmd(NULL, "NICK %s 1 %ld %s %s %s %s 0 0 :%s", nick,
+             (long int) time(NULL), modes, user, host, ServerName, real);
+}
+
+void anope_cmd_svso(char *source, char *nick, char *flag)
+{
+    /* Not Supported by this IRCD */
+}
+
+void anope_cmd_vhost_on(char *nick, char *vIdent, char *vhost)
+{
+    send_cmd(s_HostServ, "SVSMODE %s +v", nick);
+    anope_cmd_chghost(nick, vhost);
+}
+
+void anope_cmd_vhost_off(User * u)
+{
+    send_cmd(s_HostServ, "SVSMODE %s -v", u->nick);
+    notice_lang(s_HostServ, u, HOST_OFF_UNREAL, u->nick);
+}
+
+void anope_cmd_chghost(char *nick, char *vhost)
+{
+    if (!nick || !vhost) {
+        return;
+    }
+    send_cmd(ServerName, "SVHOST %s %s", nick, vhost);
+}
+
+/* SVSMODE +d */
+/* sent if svid is something weird */
+void anope_cmd_svid_umode(char *nick, time_t ts)
+{
+    send_cmd(ServerName, "SVSMODE %s %lu +d 1", nick,
+             (unsigned long int) ts);
+}
+
+
+/* SVSMODE +d */
+/* nc_change was = 1, and there is no na->status */
+void anope_cmd_nc_change(User * u)
+{
+    common_svsmode(u, "+d", "1");
+}
+
+/* SVSMODE +d */
+void anope_cmd_svid_umode2(User * u, char *ts)
+{
+    /* not used by bahamut ircds */
+}
+
+
+void anope_cmd_svid_umode3(User * u, char *ts)
+{
+    if (u->svid != u->timestamp) {
+        common_svsmode(u, "+rd", ts);
+    } else {
+        common_svsmode(u, "+r", NULL);
+    }
+}
+
+/* NICK <newnick>  */
+void anope_cmd_chg_nick(char *oldnick, char *newnick)
+{
+    if (!oldnick || !newnick) {
+        return;
+    }
+
+    send_cmd(oldnick, "NICK %s", newnick);
+}
+
+int anope_event_error(char *source, int ac, char **av)
+{
+    if (ac >= 1) {
+        if (debug) {
+            alog("ERROR: %s", av[0]);
+        }
+    }
+    return MOD_CONT;
+}
+
+int anope_event_notice(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_event_sqline(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+
+int anope_event_gnotice(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_event_pass(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+void anope_cmd_svsjoin(char *source, char *nick, char *chan)
+{
+    /* Can not find any reference to these in Bahamut */
+}
+
+void anope_cmd_svspart(char *source, char *nick, char *chan)
+{
+    /* Can not find any reference to these in Bahamut */
+}
+
+void anope_cmd_swhois(char *source, char *who, char *mask)
+{
+    /* not supported */
+}
+
+
+void anope_cmd_burst()
+{
+    send_cmd(NULL, "BURST");
+}
+
+void anope_cmd_eob()
+{
+    send_cmd(NULL, "BURST 0");
+}
+
+int anope_event_burst(char *source, int ac, char **av)
+{
+    Server *s;
+    s = findserver(servlist, source);
+    if (!ac) {
+        /* for future use  - start burst */
+    } else {
+        if (s) {
+            s->sync = 1;
+        }
+    }
+    return MOD_CONT;
+}
+
+int anope_event_luserslock(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_event_rehash(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_event_credits(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_event_admin(char *source, int ac, char **av)
+{
+    return MOD_CONT;
+}
+
+int anope_flood_mode_check(char *value)
+{
+    char *dp, *end;
+
+    if (value && *value != ':'
+        && (strtoul((*value == '*' ? value + 1 : value), &dp, 10) > 0)
+        && (*dp == ':') && (*(++dp) != 0) && (strtoul(dp, &end, 10) > 0)
+        && (*end == 0)) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+void anope_cmd_jupe(char *jserver, char *who, char *reason)
+{
+    char rbuf[256];
+
+    snprintf(rbuf, sizeof(rbuf), "Juped by %s%s%s", who,
+             reason ? ": " : "", reason ? reason : "");
+
+    anope_cmd_squit(jserver, rbuf);
+    anope_cmd_server(jserver, 2, rbuf);
+    new_server(me_server, jserver, rbuf, SERVER_JUPED, NULL);
+}
+
+/* GLOBOPS - to handle old WALLOPS */
+void anope_cmd_global_legacy(char *source, char *fmt)
+{
+    send_cmd(source ? source : ServerName, "GLOBOPS :%s", fmt);
+}
+
+/* 
+  1 = valid nick
+  0 = nick is in valid
+*/
+int anope_valid_nick(char *nick)
+{
+    /* no hard coded invalid nicks */
+    return 1;
+}
+
+void anope_cmd_ctcp(char *source, char *dest, const char *fmt, ...)
+{
+    va_list args;
+    char buf[BUFSIZE];
+    char *s;
+    *buf = '\0';
+
+    if (fmt) {
+        va_start(args, fmt);
+        vsnprintf(buf, BUFSIZE - 1, fmt, args);
+        va_end(args);
+    }
+    if (!buf) {
+        return;
+    } else {
+        s = normalizeBuffer(buf);
+    }
+
+    send_cmd(source, "%s NOTICE :\1%s \1", dest, s);
+}
+
+#endif
diff --git a/src/unreal32.c b/src/unreal32.c
index f600cbf65..ae06b3fb2 100644
--- a/src/unreal32.c
+++ b/src/unreal32.c
@@ -71,7 +71,7 @@ IRCDVar ircd[] = {
      0,                         /* Has Admin            */
      0,                         /* Chan SQlines         */
      0,                         /* Quit on Kill         */
-     0,                         /* SVSMODE unban        */
+     1,                         /* SVSMODE unban        */
      1,                         /* Has Protect          */
      1,                         /* Reverse              */
      1,                         /* Chan Reg             */
@@ -201,7 +201,7 @@ char csmodes[128] = {
     0,
     0, 0, 0,
     'h',                        /* (37) % Channel halfops */
-    'b',                        /* (38) & Channel halfops */
+    'b',                        /* (38) & bans */
     0, 0, 0,
     'q',
 
@@ -1932,7 +1932,8 @@ void anope_cmd_sgline(char *mask, char *reason)
 /* SVSMODE -b */
 void anope_cmd_unban(char *name, char *nick)
 {
-    /* Not Supported by this IRCD */
+    send_cmd(ServerName, "%s %s -b %s", send_token("SVSMODE", "n"), name,
+             nick);
 }
 
 /* SVSMODE +d */
@@ -2025,7 +2026,6 @@ int anope_event_swhois(char *source, int ac, char **av)
     return MOD_CONT;
 }
 
-
 int anope_event_rehash(char *source, int ac, char **av)
 {
     return MOD_CONT;
@@ -2041,7 +2041,6 @@ int anope_event_admin(char *source, int ac, char **av)
     return MOD_CONT;
 }
 
-
 int anope_event_sdesc(char *source, int ac, char **av)
 {
     Server *s;
@@ -2054,14 +2053,12 @@ int anope_event_sdesc(char *source, int ac, char **av)
     return MOD_CONT;
 }
 
-
 int anope_event_sjoin(char *source, int ac, char **av)
 {
     do_sjoin(source, ac, av);
     return MOD_CONT;
 }
 
-
 void anope_cmd_swhois(char *source, char *who, char *mask)
 {
     send_cmd(source, "SWHOIS %s :%s", who, mask);
@@ -2072,7 +2069,6 @@ void anope_cmd_eob()
     send_cmd(ServerName, "EOS");
 }
 
-
 /* svswatch
  * parv[0] - sender
  * parv[1] - target nick
diff --git a/src/users.c b/src/users.c
index 28ccaa9ae..ad17d40ad 100644
--- a/src/users.c
+++ b/src/users.c
@@ -17,7 +17,8 @@
 #define HASH(nick)	(((nick)[0]&31)<<5 | ((nick)[1]&31))
 User *userlist[1024];
 
-int32 usercnt = 0, opcnt = 0, maxusercnt = 0;
+int32 usercnt = 0, opcnt = 0;
+uint32 maxusercnt = 0;
 time_t maxusertime;
 
 /*************************************************************************/
@@ -707,8 +708,9 @@ void do_quit(const char *source, int ac, char **av)
              merge_args(ac, av));
         return;
     }
-    if (debug)
+    if (debug) {
         alog("debug: %s quits", source);
+    }
     if ((na = user->na) && (!(na->status & NS_VERBOTEN))
         && (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
         na->last_seen = time(NULL);
@@ -717,8 +719,9 @@ void do_quit(const char *source, int ac, char **av)
         na->last_quit = *av[0] ? sstrdup(av[0]) : NULL;
     }
 #ifndef STREAMLINED
-    if (LimitSessions)
+    if (LimitSessions) {
         del_session(user->host);
+    }
 #endif
     delete_user(user);
 }
@@ -736,13 +739,15 @@ void do_kill(char *nick, char *msg)
     NickAlias *na;
 
     user = finduser(nick);
-    if (!user)
+    if (!user) {
         if (debug) {
             alog("debug: KILL of nonexistent nick: %s", nick);
         }
-    return;
-    if (debug)
+        return;
+    }
+    if (debug) {
         alog("debug: %s killed", nick);
+    }
     if ((na = user->na) && (!(na->status & NS_VERBOTEN))
         && (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
         na->last_seen = time(NULL);
@@ -752,8 +757,9 @@ void do_kill(char *nick, char *msg)
 
     }
 #ifndef STREAMLINED
-    if (LimitSessions)
+    if (LimitSessions) {
         del_session(user->host);
+    }
 #endif
     delete_user(user);
 }