Changeset 786

Timestamp:

10/14/06 10:02:21 (6 years ago)

Author:

wd

Message:

Merge in many changes from modules. My bad for not staying on top of these!

Location:

branches/ithildin-scons/modules

Files:

• ircd/addons/acl.c (modified) (24 diffs)
• ircd/addons/acl.h (modified) (3 diffs)
• ircd/addons/cmode_filter.c (modified) (1 diff)
• ircd/addons/cmode_strip.c (modified) (3 diffs)
• ircd/addons/core.c (modified) (1 diff)
• ircd/addons/hostcrypt.c (modified) (1 diff)
• ircd/addons/hostmask.c (modified) (4 diffs)
• ircd/addons/quarantine.c (modified) (1 diff)
• ircd/addons/throttle.c (modified) (1 diff)
• ircd/client.c (modified) (5 diffs)
• ircd/client.h (modified) (5 diffs)
• ircd/command.c (modified) (4 diffs)
• ircd/command.h (modified) (1 diff)
• ircd/commands/acl.c (modified) (2 diffs)
• ircd/commands/akill.c (modified) (5 diffs)
• ircd/commands/die.c (modified) (2 diffs)
• ircd/commands/error.c (modified) (1 diff)
• ircd/commands/info.c (modified) (2 diffs)
• ircd/commands/join.c (modified) (2 diffs)
• ircd/commands/kill.c (modified) (1 diff)
• ircd/commands/mode.c (modified) (7 diffs)
• ircd/commands/motd.c (modified) (1 diff)
• ircd/commands/nick.c (modified) (3 diffs)
• ircd/commands/oper.c (modified) (1 diff)
• ircd/commands/pass.c (modified) (1 diff)
• ircd/commands/quit.c (modified) (2 diffs)
• ircd/commands/rehash.c (modified) (1 diff)
• ircd/commands/server.c (modified) (9 diffs)
• ircd/commands/sjoin.c (modified) (10 diffs)
• ircd/commands/squit.c (modified) (4 diffs)
• ircd/commands/svinfo.c (modified) (2 diffs)
• ircd/commands/svsmode.c (modified) (2 diffs)
• ircd/commands/topic.c (modified) (1 diff)
• ircd/commands/version.c (modified) (1 diff)
• ircd/commands/watch.c (modified) (1 diff)
• ircd/commands/whois.c (modified) (3 diffs)
• ircd/commands/whowas.c (modified) (1 diff)
• ircd/commands/xinfo.c (modified) (5 diffs)
• ircd/conf.c (modified) (2 diffs)
• ircd/connection.c (modified) (5 diffs)
• ircd/connection.h (modified) (3 diffs)
• ircd/doc/conf.txt (modified) (2 diffs)
• ircd/ircd.c (modified) (2 diffs)
• ircd/protocol.c (modified) (11 diffs)
• ircd/protocol.h (modified) (2 diffs)
• ircd/protocols/dreamforge.c (modified) (1 diff)
• ircd/protocols/ithildin1.c (modified) (2 diffs)
• ircd/protocols/shared/rfc1459_io.c (modified) (3 diffs)
• ircd/send.c (modified) (3 diffs)
• ircd/send.h (modified) (1 diff)
• ircd/server.c (modified) (5 diffs)
• ircd/server.h (modified) (1 diff)
• ircd/support.c (modified) (6 diffs)
• ircd/support.h (modified) (3 diffs)
• log/log.c (modified) (1 diff)

branches/ithildin-scons/modules/ircd/addons/acl.c

@@ -26 +26 @@
  * CIDR mask, or something else) */
 #define ACL_DEFAULT_HASH 0
-/* the default rule at which inserts happen */
-#define ACL_DEFAULT_RULE 1000
-#define ACL_DEFAULT_CONF_RULE 2000
 
 /* function prototypes */
@@ -36 +33 @@
 XINFO_FUNC(xinfo_acl_handler);
 
-/* create an acl structure with the given definition (or find one if it exists
- * already) and add it in to the system.  ACLs are equivalent for our purposes
- * if they are in the same stage and have the same host-pattern.  It doesn't
- * make sense to have an accept for a host and a deny for host (with the
- * exception that hosts which have a password are considered different enough
- * to be left alone. */
-acl_t *create_acl(int stage, int acc, char *host, const char *type) {
+/* Create an ACL with the given data.  We will override ACLs that are
+ * similar enough to ourself (same stage/host/access/rule#) unless they have
+ * special parameter data (such as passwords or 'info line' bans) */
+acl_t *create_acl(int stage, int acc, char *host, const char *type, int rule) {
     acl_t *ap, *ap2;
     char *at, hostcopy[USERLEN + HOSTLEN + 2];
-    struct acl_tq *list;
+    struct acl_list *list;
     
-    if ((ap = find_acl(stage, host, type, NULL, NULL)) != NULL) {
-        if ((ap->pass != NULL && (ap->access != acc)) || ap->info != NULL)
-            ap = NULL; /* if it has a password, don't trample it unless we are
-                          adding another rule with a password and the same
-                          access.  if it has an info field, don't trample it at
-                          all. */
+    /* look for an ACL in this stage from the same hostname and with the
+     * same access and rule number.  If we find one we will delete it unless
+     * it has an info-line, in which case we will leave it alone.  (This is
+     * sort of a broken concession to not having a create command which
+     * takes that information...) */
+    if ((ap = find_acl(stage, acc, host, type, rule, NULL, NULL)) != NULL) {
+        if (ap->info != NULL)
+            ap = NULL;
     }
 
@@ -78 +74 @@
     
     /* add them into the big list... */
-    ap->rule = acl.default_rule;
+    if (rule == ACL_DEFAULT_RULE)
+        ap->rule = acl.default_rule;
+    else
+        ap->rule = (short)rule;
     ap->hash = get_acl_hash(ap->host);
 
@@ -90 +89 @@
         list = acl.stage3_list;
 
-    if (TAILQ_EMPTY(list))
-        TAILQ_INSERT_HEAD(list, ap, intlp);
+    if (LIST_EMPTY(list))
+        LIST_INSERT_HEAD(list, ap, intlp);
     else {
-        TAILQ_FOREACH(ap2, list, intlp) {
+        LIST_FOREACH(ap2, list, intlp) {
             if (ap2->rule > ap->rule) {
-                TAILQ_INSERT_BEFORE(ap2, ap, intlp);
+                LIST_INSERT_BEFORE(ap2, ap, intlp);
                 break;
-            }
-        }
-        if (ap2 == NULL)
-            TAILQ_INSERT_TAIL(list, ap, intlp);
+            } else if (LIST_NEXT(ap2, intlp) == NULL) {
+                LIST_INSERT_AFTER(ap2, ap, intlp);
+                break;
+            }
+        }
     }
 
@@ -153 +153 @@
 /* this function finds an ACL based on stage/host/type, and possibly based on
  * the pass/info parameters. */
-acl_t *find_acl(int stage, char *hostmask, const char *type, char *pass,
-        char *info) {
-    struct acl_tq *list;
+acl_t *find_acl(int stage, int acc, char *hostmask, const char *type,
+        int rule, char *pass, char *info) {
+    struct acl_list *list;
     char *at, hostcopy[USERLEN + HOSTLEN + 2], user[USERLEN + 1];
     char host[HOSTLEN + 1];
     acl_t *ap;
 
+    
     /* extract user@host data */
     strlcpy(hostcopy, hostmask, USERLEN + HOSTLEN + 2);
@@ -172 +173 @@
     }
 
+    if (rule == ACL_DEFAULT_RULE)
+        rule = acl.default_rule;
+
     if (stage == ACL_STAGE_CONNECT)
         list = acl.stage1_list;
@@ -180 +184 @@
 
     /* now try and find them in the bucket. */
-    TAILQ_FOREACH(ap, list, intlp) {
+    LIST_FOREACH(ap, list, intlp) {
+        if (acc != ACL_ACCESS_ANY && ap->access != acc)
+            continue;
+        if (rule != ACL_ANY_RULE && ap->rule != rule)
+            continue;
+
         if (!strcasecmp(ap->user, user) && !strcasecmp(ap->host, host) &&
                 !strcasecmp(ap->type, type) &&
@@ -202 +211 @@
     /* and remove it from whatever list it's in */
     if (ap->stage == ACL_STAGE_CONNECT)
-        TAILQ_REMOVE(acl.stage1_list, ap, intlp);
+        LIST_REMOVE(ap, intlp);
     else if (ap->stage == ACL_STAGE_PREREG)
-        TAILQ_REMOVE(acl.stage2_list, ap, intlp);
+        LIST_REMOVE(ap, intlp);
     else
-        TAILQ_REMOVE(acl.stage3_list, ap, intlp);
+        LIST_REMOVE(ap, intlp);
 
     /* now free the memory */
@@ -217 +226 @@
     if (ap->info != NULL)
         free(ap->info);
+    if (ap->redirect != NULL)
+        free(ap->redirect);
     if (ap->timer != TIMER_INVALID)
         destroy_timer(ap->timer);
@@ -308 +319 @@
     /* now match.  skip over any entries that aren't the default hash or our
      * hash. */
-    TAILQ_FOREACH(ap, acl.stage1_list, intlp) {
+    LIST_FOREACH(ap, acl.stage1_list, intlp) {
         if (ap->hash != hash && ap->hash != ACL_DEFAULT_HASH)
             continue;
@@ -347 +358 @@
      * and the ip (using hostmatch and ipmatch).  All together that is four
      * calls.  Also, our hash space is expanded. */
-    TAILQ_FOREACH(ap, acl.stage2_list, intlp) {
+    LIST_FOREACH(ap, acl.stage2_list, intlp) {
         if (ap->hash != hash && ap->hash != iphash &&
                 ap->hash != ACL_DEFAULT_HASH)
@@ -393 +404 @@
      * aren't allowed because of a class being full we actually have to keep on
      * looking to see if they fit in somewhere else. blechhh. */
-    TAILQ_FOREACH(ap, acl.stage3_list, intlp) {
+    LIST_FOREACH(ap, acl.stage3_list, intlp) {
         if (ap->hash != hash && ap->hash != iphash &&
                 ap->hash != ACL_DEFAULT_HASH)
@@ -400 +411 @@
         /* check password/info first, since they're cheaper than all the
          * match calls (I guess */
-        if (ap->pass != NULL && strcmp(ap->pass, cp->pass))
+        if (ap->pass != NULL && cp->pass != NULL && strcmp(ap->pass, cp->pass))
             continue; /* password incorrect */
         if (ap->info != NULL && !match(ap->info, cp->cli->info))
@@ -409 +420 @@
                 /* okay, it actually matches. */
                 if (ap->access == ACL_DENY) {
+                    /* Is this a redirect?  Maybe so, let's send them the
+                     * redirect message if it is. */
+                    if (ap->redirect != NULL)
+                        sendto_one(cp->cli, RPL_FMT(cp->cli, RPL_REDIR),
+                                ap->redirect, ap->redirect_port);
+
                     /* if there's a reason for the ban and they weren't already
-                     * denied set ret, otherwise just leave it alone */
+                     * denied set ret, otherwise just leave it alone.  Why?
+                     * this is possible if there is no more room in their
+                     * connection class.  We want them to know that they
+                     * would be authorized if the class wasn't full, instead
+                     * of telling them they are not at all authorized. */
                     ret = (ret != NULL ? ret : ap->reason);
                     break; /* we'll return below. */
@@ -430 +451 @@
     }
 
-    if (ret == NULL && !TAILQ_EMPTY(acl.stage3_list))
+    if (ret == NULL && !LIST_EMPTY(acl.stage3_list))
         return "You are not authorised to use this server.";
     return ret;
@@ -444 +465 @@
 }
 
+/* These two are the defaults for runtime and configured rule numbers,
+ * respectively. */
+#define ACLCONF_DEFAULT_RULE 1000
+#define ACLCONF_DEFAULT_CONF_RULE 2000
 HOOK_FUNCTION(acl_conf_hook) {
     conf_entry_t *cep;
     conf_list_t *clp;
     acl_t *ap, *ap2;
-    int stg, acc;
-    char *s, *class, *pass, *info, *reason;
+    int stg, acc, redirect_port = 0;
+    char *s, *class, *pass, *info, *reason, *redir;
+    char redirect[SERVLEN + 1];
     class_t *cls;
-    int odr, rn, dcr; /* Old Default Rule, Rule Number, Default Conf Rule */
+    int rule;
+    int default_rule; /* default rule for config entries */
 
     /* remove anything that points to a conf.  usually this will only be
@@ -466 +493 @@
     /* see about setting the default rule number.. */
     if ((s = conf_find_entry("default-acl-rule", *ircd.confhead, 1)) != NULL)
-        acl.default_rule = str_conv_int(s, ACL_DEFAULT_RULE);
+        acl.default_rule = str_conv_int(s, ACLCONF_DEFAULT_RULE);
     else
-        acl.default_rule = ACL_DEFAULT_RULE;
+        acl.default_rule = ACLCONF_DEFAULT_RULE;
     if ((s = conf_find_entry("default-acl-conf-rule", *ircd.confhead, 1)) !=
             NULL)
-        dcr = str_conv_int(s, ACL_DEFAULT_CONF_RULE);
+        default_rule = str_conv_int(s, ACLCONF_DEFAULT_CONF_RULE);
     else
-        dcr = ACL_DEFAULT_CONF_RULE;
+        default_rule = ACLCONF_DEFAULT_CONF_RULE;
 
     /* now read through the conf looking for ACLs, as we find them parse and
@@ -482 +509 @@
     while ((cep = conf_find_next("acl", NULL, CONF_TYPE_LIST, cep,
                     *ircd.confhead, 1)) != NULL) {
-        rn = dcr;
+        rule = default_rule;
         if (cep->string != NULL)
-            rn = str_conv_int(cep->string, -1);
-        if (rn < 0 || rn > USHRT_MAX) {
-            log_warn("got acl with bogus rule number (%d)", rn);
-            rn = dcr;
+            rule = str_conv_int(cep->string, -1);
+        if (rule < 0 || rule > USHRT_MAX) {
+            log_warn("got acl with bogus rule number (%d)", rule);
+            rule = default_rule;
         }
 
@@ -522 +549 @@
         pass = conf_find_entry("pass", clp, 1);
         info = conf_find_entry("info", clp, 1);
-        if (access == ACL_DENY) {
+        if (acc == ACL_DENY) {
             if ((reason = conf_find_entry("reason", clp, 1)) == NULL)
                 reason = "You are not authorised to use this server.";
         }
+
+        if ((redir = conf_find_entry("redirect", clp, 1)) != NULL) {
+            /* try finding the port .. */
+            if ((s = strchr(redir, ':')) != NULL) {
+                strlcpy(redirect, redir, (s - redir <= SERVLEN ?
+                            (s - redir) + 1 : SERVLEN + 1));
+                if ((redirect_port = str_conv_int(s + 1, 0)) == 0)
+                    log_warn("Could not parse server:port combo for redirect "
+                            "%s", redir);
+            } else {
+                strlcpy(redirect, redir, SERVLEN + 1);
+                redirect_port = 6667;
+            }
+
+            if (acc != ACL_DENY) {
+                log_warn("Redirection forces a DENY ACL type.");
+                acc = ACL_DENY;
+            }
+        } else
+            *redirect = '\0';
+                
+
 
         /* now iterate through all the host lists and all the regular hosts and
          * add the acl.  yikes!  Use this macro to make life a bit easier. */
 #define ACL_PARSE_ADD(_host) do {                                             \
-        odr = acl.default_rule;                                               \
-        acl.default_rule = rn;                                                \
-        ap = create_acl(stg, acc, _host, "acl");                              \
-        acl.default_rule = odr;                                               \
+        ap = create_acl(stg, acc, _host, "acl", rule);                        \
         ap->conf = clp;                                                       \
         ap->cls = cls;                                                        \
@@ -546 +592 @@
         if (str_conv_bool(conf_find_entry("skip-ident", clp, 1), 0))          \
             ap->flags |= ACL_FL_SKIP_IDENT;                                   \
+        if (*redirect != '\0' && redirect_port != 0) {                        \
+            ap->redirect = strdup(redirect);                                  \
+            ap->redirect_port = redirect_port;                                \
+        }                                                                     \
 } while (0)
 
@@ -572 +622 @@
      * for ACLs based on four parameters: mask, stage, access, and type. */
     acl_t *ap;
-    struct acl_tq *list;
+    struct acl_list *list;
     char rpl[XINFO_LEN];
     char *mask = NULL, *type = NULL;
@@ -645 +695 @@
     }
     while (list != NULL) {
-        TAILQ_FOREACH(ap, list, intlp) {
+        LIST_FOREACH(ap, list, intlp) {
             if (acc != -1 && ap->access != acc)
                 continue;
@@ -694 +744 @@
 
     LIST_ALLOC(acl.list);
-    TAILQ_ALLOC(acl.stage1_list);
-    TAILQ_ALLOC(acl.stage2_list);
-    TAILQ_ALLOC(acl.stage3_list);
-
-    add_xinfo_handler(xinfo_acl_handler, "ACL", XINFO_HANDLER_OPER, NULL,
+    LIST_ALLOC(acl.stage1_list);
+    LIST_ALLOC(acl.stage2_list);
+    LIST_ALLOC(acl.stage3_list);
+
+    add_xinfo_handler(xinfo_acl_handler, "ACL", XINFO_HANDLER_OPER, 
             "Provides information about the server Access Control List");
 
@@ -716 +766 @@
         destroy_acl(LIST_FIRST(acl.list));
     LIST_FREE(acl.list);
-    TAILQ_FREE(acl.stage1_list);
-    TAILQ_FREE(acl.stage2_list);
-    TAILQ_FREE(acl.stage3_list);
+    LIST_FREE(acl.stage1_list);
+    LIST_FREE(acl.stage2_list);
+    LIST_FREE(acl.stage3_list);
 
     remove_xinfo_handler(xinfo_acl_handler);

branches/ithildin-scons/modules/ircd/addons/acl.h

@@ -16 +16 @@
 #define ACL_STAGE_REGISTER 3
     int     stage;                  /* one of 1, 2, or 3 */
+#define ACL_ACCESS_ANY -1
 #define ACL_DENY 0
 #define ACL_ALLOW 1
@@ -31 +32 @@
                                        only) */
     char    *pass;                  /* password */
+    char    *redirect;              /* redirect server (or NULL if none) */
+    int     redirect_port;          /* redirect port */
+
     time_t  added;                  /* when it was added */
     time_t  expire;                 /* when this will expire */
@@ -44 +48 @@
                                        NULL otherwise. */
 
-    TAILQ_ENTRY(acl) intlp;         /* list pointers.  intlp is for internal */
-    LIST_ENTRY(acl) lp;             /* use.  lp is part of 'the big list'. */
+    LIST_ENTRY(acl) intlp;          /* list pointers.  intlp is for internal
+                                       (stage-segregated) lists */
+    LIST_ENTRY(acl) lp;             /* lp is for the 'big list'. */
 } acl_t;
 
-TAILQ_HEAD(acl_tq, acl);
+LIST_HEAD(acl_list, acl);
 
 extern struct acl_module_data {
-    struct acl_tq *stage1_list;
-    struct acl_tq *stage2_list;
-    struct acl_tq *stage3_list;
-    LIST_HEAD(, acl) *list;
+    struct acl_list *stage1_list;
+    struct acl_list *stage2_list;
+    struct acl_list *stage3_list;
+    struct acl_list *list;
 
     unsigned short default_rule;
 } acl;
 
-acl_t *create_acl(int, int, char *, const char *);
-acl_t *find_acl(int, char *, const char *, char *, char *);
+#define ACL_ANY_RULE -1
+#define ACL_DEFAULT_RULE -2
+acl_t *create_acl(int, int, char *, const char *, int);
+acl_t *find_acl(int, int, char *, const char *, int, char *, char *);
 void destroy_acl(acl_t *);
 void acl_add_timer(acl_t *, time_t);

branches/ithildin-scons/modules/ircd/addons/cmode_filter.c

@@ -35 +35 @@
                 "chanmode_flag", "chanmode_flag_query", 0, NULL);
 
-    add_hook(ircd.events.can_send_channel, can_send_filter);
+    add_hook_before(ircd.events.can_send_channel, can_send_filter, NULL);
     add_hook(me.events.read_conf, filter_conf_hook);
 

branches/ithildin-scons/modules/ircd/addons/cmode_strip.c

@@ -42 +42 @@
                 "chanmode_flag", "chanmode_flag_query", 0, NULL);
 
-    add_hook(ircd.events.can_send_channel, can_send_strip);
+    add_hook_before(ircd.events.can_send_channel, can_send_strip, NULL);
     add_hook(me.events.read_conf, strip_conf_hook);
 
@@ -58 +58 @@
 
     remove_hook(ircd.events.can_send_channel, can_send_strip);
+    remove_hook(me.events.read_conf, strip_conf_hook);
 }
 
-#define ANSI_CHAR        '\033'
-#define BLINK_CHAR        '\006'
-#define BOLD_CHAR        '\002'
-#define COLOR_CHAR        '\003'
-#define INVERSE_CHAR        '\026'
-#define UNDERLINE_CHAR        '\037'
+#define ANSI_CHAR       '\033'
+#define BLINK_CHAR      '\006'
+#define BOLD_CHAR       '\002'
+#define COLOR_CHAR      '\003'
+#define INVERSE_CHAR    '\026'
+#define UNDERLINE_CHAR  '\037'
 
 HOOK_FUNCTION(strip_conf_hook) {
@@ -117 +118 @@
 
     if (chanmode_isset(ccap->chan, chanmode_strip)) {
-        char *from, *to;
-        from = to = ccap->extra;
+        unsigned char *from, *to;
+        from = to = (unsigned char *)ccap->extra;
 
         while (*from != '\0') {
-            if (strip_chars[(unsigned char)*from]) {
+            if (strip_chars[*from]) {
+                /* We will always skip the character here, it just may not
+                 * match COLOR_CHAR in which case we simply continue on */
                 if (*from++ == COLOR_CHAR) {
                     if (isdigit(*from)) {
-                        if (isdigit(*++from)) {
-                            if (*++from == ',') {
-                                if (isdigit(*++from)) {
-                                    if (isdigit(*from))
-                                        from++;
-                                }
-                            }
+                        if (isdigit(*++from))
+                            from++; /* skip second digit which is optional */
+
+                        if (*from == ',' && isdigit(*(from + 1))) {
+                            /* background color specified ... */
+                            from += 2;
+                            if (isdigit(*from))
+                                from++;
                         }
                     }
                 }
-                continue;
-            }
-            *to++ = *from++;
+            } else
+                *to++ = *from++;
         }
+        *to = '\0';
     }
 

branches/ithildin-scons/modules/ircd/addons/core.c

@@ -303 +303 @@
                         match(cbp->host, host))
                     return CHANMODE_FAIL; /* already set. */
+#else
+                if (!strcasecmp(cbp->nick, nick) &&
+                        !strcasecmp(cbp->user, user) &&
+                        !strcasecmp(cbp->host, host))
+                    return CHANMODE_FAIL;
 #endif
             }

branches/ithildin-scons/modules/ircd/addons/hostcrypt.c

@@ -243 +243 @@
     if (set)
         hostcrypt_encrypt(cli);
-    else
-        hostcrypt_decrypt(cli);
+    else {
+        /* Do not decrypt their hostname if they've been added to the
+         * history section.  This is indicative of an automated unsetting,
+         * not a manual one. */
+        if (!(cli->flags & IRCD_CLIENT_HISTORY))
+            hostcrypt_decrypt(cli);
+    }
 
     return 1;

branches/ithildin-scons/modules/ircd/addons/hostmask.c

@@ -20 +20 @@
 */
 
+#define CGI_IRC_SPECIAL_MASK "cgi:irc"
+
 static struct mdext_item *class_hostmask_mdi;
 
 HOOK_FUNCTION(hostmask_conf_hook);
 HOOK_FUNCTION(hostmask_cc_hook);
+static int validate_cgiirc_host(const char *, char **, char **);
 
 MODULE_LOADER(hostmask) {
@@ -53 +56 @@
             /* verify the mask.  make sure it consists ONLY of valid
              * characters, and that it has multiple parts. */
-            if (!istr_okay(ircd.maps.host, s) || strchr(s, '.') == NULL)
-                log_error("hostmask %s is invalid.", s);
-            else
+            if (strcasecmp(s, CGI_IRC_SPECIAL_MASK) &&
+                    (!istr_okay(ircd.maps.host, s) ||
+                     strchr(s, '.') == NULL))
+                log_error("hostmask for class %s is invalid", cls->name);
+            else {
                 strlcpy(mdext(cls, class_hostmask_mdi), s, HOSTLEN + 1);
+                log_debug("setting hostmask for class %s to %s", cls->name,
+                        mdext(cls, class_hostmask_mdi));
+            }
         }
     }
@@ -65 +73 @@
 HOOK_FUNCTION(hostmask_cc_hook) {
     client_t *cli = (client_t *)data;
-    char *mask = NULL;
+    char *mask, *ip;
 
-    if (cli->conn != NULL)
-        mask = mdext(cli->conn->cls, class_hostmask_mdi);
+    if (cli->conn == NULL)
+        return NULL; /* nothing to do */
 
+    mask = ip = NULL;
+
+    mask = mdext(cli->conn->cls, class_hostmask_mdi);
     if (mask != NULL && *mask != '\0') {
+        if (!strcasecmp(mask, CGI_IRC_SPECIAL_MASK)) {
+            /* Special CGI:IRC hack.  We take the password, if supplied, an
+             * use it as a hostname (as long as it's valid).  Good stuff. */
+            if (cli->conn->pass != NULL && *cli->conn->pass != '\0' &&
+                    validate_cgiirc_host(cli->conn->pass, &ip, &mask)) {
+                log_debug("cgi:irc connection masked as %s / %s", ip, mask);
+                strcpy(cli->ip, ip); /* set the IP as well */
+            } else {
+                log_warn("cgi:irc hostmasked connection provided invalid "
+                        "host (%s) (%s!%s@%s)",
+                        (cli->conn->pass == NULL ? "" : cli->conn->pass),
+                        cli->nick, cli->user, cli->host);
+                return NULL;
+            }
+            /* fallthrough to normal mask case. */
+        }
         sendto_flag(SFLAG("SPY"), "Changing hostname for %s!%s@%s to %s",
                 cli->nick, cli->user, cli->host, mask);
@@ -79 +106 @@
 }
 
+/* CGIIRC(6)+__(2)+\0(1)+ip+host */
+#define CGIIRC_HOST_SIZE 9 + IPADDR_MAXLEN + HOSTLEN
+
+/* validate the string from a CGI:IRC connection.  The string is of the form
+ * CGIIRC_<ip>_<host>.  We ensure that both the IP and hostname are valid.  */
+static int validate_cgiirc_host(const char *in, char **ip, char **host) {
+    static char str[CGIIRC_HOST_SIZE];
+    char *s_ip, *s_host;
+
+    *ip = *host = NULL;
+    strlcpy(str, in, CGIIRC_HOST_SIZE);
+    
+    if (strncmp(str, "CGIIRC_", 7))
+        return 0;
+
+    s_ip = str + 7;
+    if ((s_host = strchr(s_ip, '_')) == NULL)
+        return 0; /* no hostname */
+    *s_host++ = '\0';
+
+    /* now we have ip/host, let's validate */
+    if (*s_ip == '\0' || *s_host == '\0')
+        return 0;
+
+    if (get_address_type(s_ip) == PF_UNSPEC)
+        return 0; /* bad IP */
+
+    if (strchr(s_host, '.') == NULL || !istr_okay(ircd.maps.host, s_host))
+        return 0; /* bogus host */
+
+    *ip = s_ip;
+    *host = s_host;
+    return 1;
+}
+
 /* vi:set ts=8 sts=4 sw=4 tw=76 et: */

branches/ithildin-scons/modules/ircd/addons/quarantine.c

@@ -237 +237 @@
     }
 
-    add_xinfo_handler(xinfo_quarantine_handler, "QUARANTINE", 0, NULL,
+    add_xinfo_handler(xinfo_quarantine_handler, "QUARANTINE", 0, 
             "Provides a list of nickname and channel quarantines");
 

branches/ithildin-scons/modules/ircd/addons/throttle.c

@@ -164 +164 @@
 
     if (tp->banned + len >= me.now)  {
-        if ((ap = find_acl(ACL_STAGE_CONNECT, cp->host, throttle_acl_type,
-                        NULL, NULL)) == NULL) {
+        if ((ap = find_acl(ACL_STAGE_CONNECT, ACL_DENY, cp->host,
+                        throttle_acl_type, ACL_DEFAULT_RULE, NULL, NULL)) == NULL) {
             ap = create_acl(ACL_STAGE_CONNECT, ACL_DENY, cp->host,
-                    throttle_acl_type);
+                    throttle_acl_type, ACL_DEFAULT_RULE);
             ap->reason = strdup(THROTTLE_ERRMSG);
         }

branches/ithildin-scons/modules/ircd/client.c

@@ -68 +68 @@
             sendto_serv_butone(cli->server, cli, NULL, NULL, "QUIT", ":%s",
                     msg);
-        /* uh, also, if they're leaving from a squit we need to send a QUIT to
-         * servers without NOQUIT support. */
-        if (cli->flags & IRCD_CLIENT_SQUIT)
-            sendto_serv_pflag_butone(PROTOCOL_SFL_NOQUIT, false, cli->server,
-                    cli, NULL, NULL, "QUIT", ":%s", msg);
 
         clp = LIST_FIRST(&cli->chans);
@@ -119 +114 @@
             ircd.stats.serv.unkclients--;
         cli->conn->cli = NULL;
-        destroy_connection(cli->conn, msg);
+
+        /* If sendq_flush does not close the connection for us (it will
+         * return 0 if it does) then close the connection.  This ensures
+         * that we do best-effort work on dumping the last dribbly bits of
+         * the sendq out to the client if we can.  We do not try hard to
+         * make this work, though! */
+        if (sendq_flush(cli->conn))
+            destroy_connection(cli->conn, msg);
     }
 
@@ -137 +139 @@
  * however, as that is left up to the caller. */
 void client_change_nick(client_t *cli, char *to) {
-    int casechng;
+    int casechng = !istrcmp(ircd.maps.nick, cli->nick, to);
     
     /* check to see if this is just a case change.  if it is, istrcmp will
      * return 0.  if it's a case change, we don't do anything except set the
      * new nickname in the client structure. */
-    casechng = !istrcmp(ircd.maps.nick, cli->nick, to);
-    if (!casechng) {
+    if (*cli->nick != '\0' && !casechng) {
         hash_delete(ircd.hashes.client, cli);
-        client_add_history(cli);
-    }
+
+        /* History entries for unregistered clients are extremely useless,
+         * and detrimental sometimes. */
+        if (CLIENT_REGISTERED(cli))
+            client_add_history(cli);
+    }
+
     strncpy(cli->nick, to, NICKLEN);
+
     if (!casechng) {
         hash_insert(ircd.hashes.client, cli);
-        hook_event(ircd.events.client_nick, cli);
+
+        /* We only hook client_nick for registered clients, there is little
+         * value in hooking it for nonregistered folks. */
+        if (CLIENT_REGISTERED(cli))
+            hook_event(ircd.events.client_nick, cli);
     }
 }
@@ -180 +191 @@
                 if (returns[x] != NULL) {/* denied, with a reason */
                     destroy_client(cli, (char *)returns[x]);
-                        return IRCD_CLOSEDCONN; /* not successful */
+                        return IRCD_CONNECTION_CLOSED; /* not successful */
                 }
                 x++;
@@ -189 +200 @@
             LIST_INSERT_HEAD(ircd.connections.clients, cp, lp);
             ircd.stats.serv.unkclients--;
+
         }
 
         cli->signon = cli->ts = me.now;
         cli->hops = 0; /* our client, they're 0 hops from us <G> */
-    }
-
-    /* do other work now.. */
-    if (MYCLIENT(cli)) {
+
         /* only hook for local registration */
         hook_event(ircd.events.client_connect, cli);
+
+        /* clear the password after client_connect, assume that nothing else
+         * will need to hook it and use it anymore. */
+        if (cp != NULL) {
+            /* clean out their password */
+            if (cp->pass != NULL) {
+                free(cp->pass);
+                cp->pass = NULL;
+            }
+        }
 
         /* accounting stuff */

branches/ithildin-scons/modules/ircd/client.h

@@ -12 +12 @@
 
 struct client {
-    char    nick[NICKLEN + 1];        /* nickname */
-    char    user[USERLEN + 1];        /* username on IRC (different from username
-                                   in conn */
-    char    host[HOSTLEN + 1];        /* hostname on IRC */
-    char    *orighost;                /* concession for host-changing modules.  this
-                                   will normally point to the 'host' field of
-                                   the client, but may be pointed elsewhere if
-                                   need be. */
-    char    ip[IPADDR_MAXLEN + 1]; /* IP address (NICKIP) */
-    char    info[GCOSLEN + 1];        /* gecos/gcos info (ircname) */
+    char    nick[NICKLEN + 1];      /* nickname */
+    char    user[USERLEN + 1];      /* username on IRC (different from username
+                                       in conn */
+    char    host[HOSTLEN + 1];      /* hostname on IRC */
+    char    *orighost;              /* concession for host-changing modules.  this
+                                       will normally point to the 'host' field of
+                                       the client, but may be pointed elsewhere if
+                                       need be. */
+    char    ip[IPADDR_MAXLEN + 1];  /* IP address (NICKIP) */
+    char    info[GCOSLEN + 1];      /* gecos/gcos info (ircname) */
 
 #define IRCD_CLIENT_REGISTERED        0x0001
@@ -28 +28 @@
 #define IRCD_CLIENT_KILLED        0x0002
 #define IRCD_CLIENT_HISTORY        0x0004
-#define IRCD_CLIENT_SQUIT       0x0008
-    int            flags;
+    int     flags;
 
     /* check to see if this is our client.  we know it's ours if their server
@@ -36 +35 @@
 #define MYCLIENT(cli) (cli->server == ircd.me)
     struct connection *conn;        /* the connection for this client, NULL if
-                                   remote or pseudo-client. */
+                                       remote or pseudo-client. */
 
-    time_t  signon;                /* signon time */
-    time_t  ts;                        /* timestamp of the nickname */
-    time_t  last;                /* used for idle time (different from
-                                   conn->last) */
-    int            hops;                /* how many hops away are they? */
-    uint64_t modes;                /* the user's modes, see below */
+    time_t  signon;                 /* signon time */
+    time_t  ts;                     /* timestamp of the nickname */
+    time_t  last;                   /* used for idle time (different from
+                                       conn->last) */
+    int     hops;                   /* how many hops away are they? */
+    uint64_t modes;                 /* the user's modes, see below */
 
-    struct userchans chans;        /* our channels */
+    struct userchans chans;         /* our channels */
 
-    struct privilege_set *pset;        /* privileges (usually derived from class) */
-    struct server *server;        /* server which owns this client */
+    struct privilege_set *pset;     /* privileges (usually derived from class) */
+    struct server *server;          /* server which owns this client */
 
     struct client_history *hist;
 
-    char    *mdext;                /* mdext data */
+    char    *mdext;                 /* mdext data */
     
     LIST_ENTRY(client) lp;
@@ -139 +138 @@
 
 struct usermode {
-    unsigned char mode;                    /* the actual mode */
-    char    avail;                    /* 1 if available, 0 otherwise */
-#define USERMODE_FL_GLOBAL  0x1            /* the usermode is spread across the
+    unsigned char mode;             /* the actual mode */
+    char    avail;                  /* 1 if available, 0 otherwise */
+#define USERMODE_FL_GLOBAL  0x1     /* the usermode is spread across the
                                        network */
-#define USERMODE_FL_OPER    0x2            /* the usermode is operator only */
+#define USERMODE_FL_OPER    0x2     /* the usermode is operator only */
 #define USERMODE_FL_PRESERVE 0x4    /* preserve the mode once set unless
                                        explicitly unset by the user */
-    int            flags;                    /* flags for the usermode */
-    uint64_t mask;                    /* the bitmask for the mode */
-    msymbol_t *changer;                    /* the changer function for the mode */
-    int sflag;                            /* send flag (if any) for this mode. */
+    int     flags;                  /* flags for the usermode */
+    uint64_t mask;                  /* the bitmask for the mode */
+    msymbol_t *changer;             /* the changer function for the mode */
+    int     sflag;                  /* send flag (if any) for this mode. */
 };
 
 TAILQ_HEAD(client_history_list, client_history);
 struct client_history {
-    char    nick[NICKLEN + 1];            /* these are all the same as in the */
+    char    nick[NICKLEN + 1];      /* these are all the same as in the */
     char    serv[SERVLEN + 1];
 
-    client_t *cli;                    /* points to the client we created this
+    client_t *cli;                  /* points to the client we created this
                                        from.  for currently online clients the
                                        nick will be different. */
-    time_t  signoff;                    /* when the client signed off */
+    time_t  signoff;                /* when the client signed off */
 
     TAILQ_ENTRY(client_history) lp;
@@ -176 +175 @@
  * functions when checking for access */
 struct client_check_args {
-    client_t *from;        /* the client performing the action */
-    client_t *to;        /* the client being acted on */
-    char    *extra;        /* any extra data */
+    client_t *from;                 /* the client performing the action */
+    client_t *to;                   /* the client being acted on */
+    char    *extra;                 /* any extra data */
 };
 
-#define CLIENT_CHECK_OVERRIDE        HOOK_COND_SPASS
-#define CLIENT_CHECK_OK                HOOK_COND_PASS
-#define CLIENT_CHECK_NO                HOOK_COND_FAIL
+#define CLIENT_CHECK_OVERRIDE   HOOK_COND_SPASS
+#define CLIENT_CHECK_OK         HOOK_COND_PASS
+#define CLIENT_CHECK_NO         HOOK_COND_FAIL
 int client_check_access(client_t *, client_t *, char *, event_t *);
 #define can_can_send_client(from, to, arg) \

branches/ithildin-scons/modules/ircd/command.c

@@ -401 +401 @@
             }
         }
-        /* check operator and command use privileges */
+        /* check operator and command use privileges.  Why do this only for
+         * local clients?  Because we need to assume that even if we are not
+         * configured to accept commands from a client, every other server
+         * is.  Without a distributed privilege understanding we have to
+         * assume positive intent. */
         if ((cmd->client.flags & COMMAND_FL_OPERATOR && !OPER(cli)) ||
                 !BPRIV(cli, cmd->priv)) {
@@ -426 +430 @@
      * touch it in this state. */
     switch ((ret = cmd->client.cmd(cmd, argc, argv, cli))) {
-    case IRCD_CLOSEDCONN:
-    case IRCD_PARSESTOP:
+    case IRCD_CONNECTION_CLOSED:
+    case IRCD_PROTOCOL_CHANGED:
         return ret;
     }
@@ -433 +437 @@
     /* same as above, if it's not ours we need to get out of here now.
      * commands that destroy non-local clients are not under obligation to
-     * return IRCD_CLOSEDCONN for those clients, so we don't know that the
-     * client structure is dead.  Avoid the race here. */
+     * return IRCD_CONNECTION_CLOSED  for those clients, so we don't know
+     * that the client structure is dead, and we're done handling it at any
+     * rate. */
     if (ours == false || cli->conn == NULL || cli->conn->cls->flood <= 0)
         return ret;
@@ -476 +481 @@
         if (cli->conn->flood >= flimit) {
             destroy_client(cli, "Excess Flood");
-            return IRCD_CLOSEDCONN;
+            return IRCD_CONNECTION_CLOSED;
         }
     }

branches/ithildin-scons/modules/ircd/command.h

@@ -20 +20 @@
 /* error numbers which can be returned by the command executer and commands
  * themselves */
-#define IRCD_CLOSEDCONN -1  /* connection closed, stop any parsing */
-#define IRCD_PARSESTOP  -2  /* finish current work on buffer and then stop
-                               parsing (this differs from CLOSEDCONN in that
-                               the buf field of the connection can continue to
-                               be modified, this is basically an allowance for
-                               the rfc1459 hackery) */
+
+/* Connection has been closed.  Stop any parsing or handling of the
+ * associated pointers *IMMEDIATELY* */
+#define IRCD_CONNECTION_CLOSED      -1
+/* Notification that the protocol has been changed.  This should cause
+ * parsing to stop AFTER the finalized cleanup on the existing buffer.
+ * Input functions are only gauranteed that the connection structure is
+ * still valid for the buffer variables, parsing routines should never be
+ * called after this is returned.*/
+#define IRCD_PROTOCOL_CHANGED       -2
+
 
 extern union cptr_u {

branches/ithildin-scons/modules/ircd/commands/acl.c

@@ -228 +228 @@
 
     /* see if it exists */
-    ap = find_acl(stage, mask, type, NULL, NULL);
+    ap = find_acl(stage, acc, mask, type, ACL_DEFAULT_RULE, NULL, NULL);
 
     /* are we adding..? */
@@ -238 +238 @@
         }
 
-        ap = create_acl(stage, acc, mask, type);
+        ap = create_acl(stage, acc, mask, type, ACL_DEFAULT_RULE);
         ap->reason = strdup(reason);
         /* if the expire time is non-zero, set a conf to 0x1 so it will get

branches/ithildin-scons/modules/ircd/commands/akill.c

@@ -55 +55 @@
     char *info = NULL;
 
-    if (!SERVER_MASTER(srv)) {
+    /* XXX: This is a hack to allow sglinebursts to be sent from non-master
+     * servers.  I guess we should detect the bursting condition and only
+     * accept these at that time, but that's not we do it. :) */
+    if (!SERVER_MASTER(srv) && strcasecmp(argv[0], "SGLINE") &&
+            strcasecmp(argv[0], "UNSGLINE")) {
         sendto_serv_butone(NULL, NULL, ircd.me, NULL, "GLOBOPS",
                 ":Non-master server %s trying to %s", srv->name, argv[0]);
@@ -64 +68 @@
 
     if (!strcasecmp(argv[0], "AKILL")) {
+        char *user, *host, *set_by;
+        time_t set_at;
         /* arguments: host user length set-by set-at reason */
         if ((!SERVER_SUPPORTS(sptr, PROTOCOL_SFL_SHORTAKILL) && argc != 7) ||
@@ -72 +78 @@
         }
 
-        snprintf(mask, USERLEN + HOSTLEN + 2, "%s@%s", argv[2], argv[1]);
-        if (SERVER_SUPPORTS(sptr, PROTOCOL_SFL_SHORTAKILL))
-            reason = (argc > 3 ? argv[3] : "");
-        else {
+        host = argv[1];
+        user = argv[2];
+        if (SERVER_SUPPORTS(sptr, PROTOCOL_SFL_SHORTAKILL)) {
+            reason = (argc > 3 ? argv[3] : "<no reason>");
+
+            /* others we don't get ... */
+            set_by = "<unknown>";
+            set_at = me.now;
+            expire = 0;
+        } else {
             expire = str_conv_time(argv[3], 0);
+            set_by = argv[4];
+            set_at = str_conv_time(argv[5], me.now);
             reason = argv[6];
         }
+        snprintf(mask, USERLEN + HOSTLEN + 2, "%s@%s", user, host);
+
+        /* propogate out.  If we're getting data from a 'SHORTAKILL' server
+         * we'll end up sending out some fallacious/made up stuff.  Oh well! */
         sendto_serv_pflag_butone(PROTOCOL_SFL_SHORTAKILL, true, sptr, NULL,
-                srv, NULL, "AKILL", "%s %s :%s", argv[1], argv[2], reason);
+                srv, NULL, "AKILL", "%s %s :%s", host, user, reason);
         sendto_serv_pflag_butone(PROTOCOL_SFL_SHORTAKILL, false, sptr, NULL,
-                srv, NULL, "AKILL", "%s %s %s %s %s :%s", argv[1], argv[2],
-                argv[3], argv[4], argv[5], argv[6]);
+                srv, NULL, "AKILL", "%s %s %d %s %d :%s", host, user,
+                expire, set_by, set_at, reason);
     } else if (!strcasecmp(argv[0], "RAKILL")) {
         /* arguments: host user */
@@ -173 +191 @@
 
     if (op == ACL_ADD) {
-        ap = create_acl(stage, ACL_DENY, mask, type);
+        ap = create_acl(stage, ACL_DENY, mask, type, ACL_DEFAULT_RULE);
         ap->conf = ACL_CONF_TEMP;
         if (expire)
@@ -184 +202 @@
         acl_force_check(ap->stage, ap, srv->name, false);
     } else if (op == ACL_DEL) {
-        if ((ap = find_acl(stage, mask, type, NULL, info)))
+        if ((ap = find_acl(stage, ACL_DENY, mask, type, ACL_DEFAULT_RULE, NULL, info)))
             destroy_acl(ap);
     }

branches/ithildin-scons/modules/ircd/commands/die.c

@@ -56 +56 @@
     }
     while ((cp = LIST_FIRST(ircd.connections.servers)) != NULL)
-        destroy_server(cp->srv, smsg, NULL);
+        destroy_server(cp->srv, smsg);
     
     /* mark the process for shutdown.  this won't actually kill the process,
@@ -62 +62 @@
     exit_process(NULL, NULL);
 
-    return IRCD_CLOSEDCONN; /* and nothing else matters! */
+    return IRCD_CONNECTION_CLOSED; /* and nothing else matters! */
 }
 

branches/ithildin-scons/modules/ircd/commands/error.c

@@ -24 +24 @@
     sendto_flag(ircd.sflag.ops, "ERROR :from %s -- %s", srv->name, argv[1]);
     /* ERROR means destroy the connection. :) */
-    destroy_server(srv, argv[1], srv);
-    return IRCD_CLOSEDCONN;
+    destroy_server(srv, argv[1]);
+    return IRCD_CONNECTION_CLOSED;
 }
 /* vi:set ts=8 sts=4 sw=4 tw=76 et: */

branches/ithildin-scons/modules/ircd/commands/info.c

@@ -34 +34 @@
     CMSG("371", ":%s");
 #define RPL_INFOSTART 373
-    CMSG("373", ":Server INFO");
+    CMSG("373", ":%s Server INFO");
 #define RPL_ENDOFINFO 374
     CMSG("374", ":End of /INFO list.");
@@ -59 +59 @@
     int i, lines = 2;
 
-    sendto_one(cli, RPL_FMT(cli, RPL_INFOSTART));
+    sendto_one(cli, RPL_FMT(cli, RPL_INFOSTART), ircd.me->name);
     if (info_text_copying != NULL) {
         for (i = 0;info_text_copying[i] != NULL;i++)

branches/ithildin-scons/modules/ircd/commands/join.c

@@ -106 +106 @@
                 fargv[1] = clp->chan->name;
                 switch ((i = command_exec_client(2, fargv, cli))) {
-                case IRCD_PARSESTOP:
-                case IRCD_CLOSEDCONN:
+                case IRCD_PROTOCOL_CHANGED:
+                case IRCD_CONNECTION_CLOSED:
                     return i;
                 }
@@ -144 +144 @@
         sendto_channel_local(chan, cli, NULL, "JOIN", NULL);
         if (new)
-            sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, sptr, cli, NULL,
-                    NULL, "SJOIN", "%d %s + :%s%s", chan->created, chan->name,
-                    chanmode_getprefixes(chan, cli), cli->nick);
+            sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, sptr, NULL,
+                    cli->server, NULL, "SJOIN", "%d %s + :%s%s", chan->created,
+                    chan->name, chanmode_getprefixes(chan, cli), cli->nick);
         else
             sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, sptr, cli,

branches/ithildin-scons/modules/ircd/commands/kill.c

@@ -135 +135 @@
         destroy_client(cp, msg);
         if (cp == cli)
-            return IRCD_CLOSEDCONN; /* suicide kills end here. */
+            return IRCD_CONNECTION_CLOSED; /* suicide kills end here. */
 
         if (++count == KILL_MAX) {

branches/ithildin-scons/modules/ircd/commands/mode.c

@@ -89 +89 @@
                         &argv[2], 1);
         } else {
-            return channel_mode(cli, NULL, chan, 0, argc - 2, &argv[2], 1);
+            return channel_mode(cli, NULL, chan, chan->created, argc - 2,
+                    &argv[2], 1);
         }
     } else if ((cp = find_client(argv[1])) != NULL) {
@@ -244 +245 @@
                 (cli != NULL ? cli_server_uplink(cli) : srv), "MODE",         \
                 "%s %s", result, rbuf);                                       \
+        sendto_serv_pflag_butone(PROTOCOL_SFL_TSMODE, false, sptr, cli,       \
+                    srv, chan->name, "MODE", "%s%s %d", result, rbuf,         \
+                    chan->created);                                           \
         r = result + 1;                                                       \
         rblen = 0;                                                            \
@@ -251 +255 @@
 }
 /* this is a lot like my mode changer from bahamut 1.x.  hopefully it'll be a
- * bit cleaner/more readable, thoughl.  Oh, and we now do the logic of ts
+ * bit cleaner/more readable, though.  Oh, and we now do the logic of ts
  * changes completely in this function.  lovely.  argc is the count only of the
  * mode changes and any arguments, and argv[0] is the mode changes if argc is
@@ -271 +275 @@
     char rbuf[RBUF_SIZE], *rb = rbuf;
     int rblen = 0;
-    int changeok = 1;
-    int keepours = 1;
+    bool changeok = true, keepours = true;
 
     if (cli != NULL && MYCLIENT(cli) && argc == 0) {
@@ -298 +301 @@
                                        this. */
 
-    /* check timestamp. we only accept modes if ts is <= to ours.  if ts is
-     * less than ours, blast away our modes (all of them!).  if ts is greater,
-     * dump any mode changes.  this should really only apply at synchronization
-     * time, so we don't bother sending back an 'unset' if we dump their
-     * changes, as we assume they'll get the new ts soon anyhow. */
-    if ((cli && !MYCLIENT(cli)) || srv) {
-        if (ts > chan->created)
-            changeok = 0; /* no changes! */
-        else if (ts < chan->created)
-            keepours = 0;
+    /*
+     * Check timestamp.  From servers which do not have the TS flag in their
+     * protocol we ACCEPT the changes and set the channel's TS to 0 (this is
+     * a bad hack to support older servers, not reasonable behavior).
+     * In the case where TS is properly supported from the sending server we
+     * only accept modes if ts is <= to our own.
+     *
+     * If the sender's TS for the channel is LESS than ours we remove every
+     * mode we have set on the channel, treating them all as invalid.  This
+     * case should only *ever* occur during synchronization.  We do not send
+     * the mode changes down in the opposite direction because we will send
+     * this command, with the correct TS, down the wire and all other TS
+     * servers will do the same thing.
+     *
+     * Similarly if we ignore their changes (ts > ours) we simply return,
+     * believing that a TS server will properly remove its modes.
+     *
+     * This is perhaps an overly trusting maneuever and, should this become
+     * an issue, the code #if 0'd out below should suffice to reverse any
+     * changes we got. :)
+     */
+
+    if ((cli != NULL && !MYCLIENT(cli)) || (srv != NULL && srv != ircd.me)) {
+        /* We need the uplink for either the server or client in order to
+         * verify flags. */
+        server_t *sp = (srv != NULL ? srv_server_uplink(srv) : cli_server_uplink(cli));
+
+        if (!SERVER_SUPPORTS(sp, PROTOCOL_SFL_TS)) {
+            /* server does not have TS support, set ts to 0, but we do not
+             * remove our own modes (because we believe the server will
+             * accept our modes as stupidly as we accepted theirs... */
+            if (srv != NULL && !SERVER_MASTER(srv)) {
+                log_debug("server %s has no TS support, setting TS for %s to 0!",
+                        sp->name, chan->name);
+                ts = 0;
+                chan->created = 0; /* normally set when we reject our modes, but
+                                      we don't reject our modes in this case..  */
+            } else
+                /* For master servers without TS protocol support just
+                 * default to giving them what we think is the right TS.
+                 * Why do this?  Because it fits in with the whole 'master'
+                 * concept.  We're going to take these modes no matter what.
+                 * Why break TS over it? */
+                ts = chan->created;
+        } else {
+            if (ts > chan->created)
+                changeok = false; /* no changes! */
+            else if (ts < chan->created)
+                keepours = false;
+        }
     }
 
     if (!changeok) {
+        log_debug("rejecting changes to channel %s (ours=%d, theirs=%d",
+                chan->name, chan->created, ts);
 #if 0
         /* invert their modes and send them right back. */
@@ -344 +389 @@
         /* this is a rather complex case, we basically have to wade through
          * our modes and remove them as we go.  First we remove channel
-         * modes, then user prefixes.  blech, */
+         * modes, then user prefixes. 
+         *
+         * NB: We send reverted modes to local clients and non-ts servers
+         * only.  Servers which are TS will get the updated TS and revert
+         * their modes accordingly on their own.  This helps to reduce spam
+         * from changes of this nature. */
         unsigned char *s;
         int cnt = 0;
@@ -351 +401 @@
         r = result + 1;
         rblen = 0;
+
+        log_debug("reverting our modes for channel %s (ours=%d, theirs=%d",
+                chan->name, chan->created, ts);
+        chan->created = ts;
 
         s = ircd.cmodes.avail;

branches/ithildin-scons/modules/ircd/commands/motd.c

@@ -37 +37 @@
     /* numerics .. */
 #define RPL_MOTD 372
-    CMSG("372", ":%s");
+    CMSG("372", ":- %s");
 #define RPL_MOTDSTART 375
     CMSG("375", ":- %s Message of the Day - ");

branches/ithildin-scons/modules/ircd/commands/nick.c

@@ -106 +106 @@
             sendto_one(cli, RPL_FMT(cli, changeok), argv[1]);
         else if (changeok < 0) {
-            strcpy(cli->nick, argv[1]);
-            /* add the client to the hash immediately to prevent collisions. */
-            hash_insert(ircd.hashes.client, cli);
+            client_change_nick(cli, argv[1]);
             /* if the username has been filled in then assume the USER command
              * was called as well. */
@@ -158 +156 @@
      * a channel, sendto_common_channels ensures they'll get the message */
     sendto_common_channels(cli, NULL, "NICK", ":%s", argv[1]);
-    sendto_serv_butone(sptr, cli, NULL, NULL, "NICK", "%s :%d", argv[1],
-            cli->ts);
+    sendto_serv_butone(sptr, cli, NULL, NULL, "NICK", "%s :%d",
+            argv[1], cli->ts);
     client_change_nick(cli, argv[1]);
 
@@ -289 +287 @@
 check_collision(client_t *known, client_t *unknown, bool new) {
 
+    /* This condition is extremely incorrect for what should be obvious
+     * reasons. */
+    assert(known != unknown);
+
     /* known is the only one which might be a local connection.  if it is on
      * our server and is unregistered then drop it no matter what. */

branches/ithildin-scons/modules/ircd/commands/oper.c

@@ -23 +23 @@
 MODULE_LOADER(oper) {
 
-    add_xinfo_handler(xinfo_oper_func, "OPERATORS", 0, NULL,
+    add_xinfo_handler(xinfo_oper_func, "OPERATORS", 0,
             "Provides information about server operators");
 

branches/ithildin-scons/modules/ircd/commands/pass.c

@@ -17 +17 @@
 */
 
+static void copy_in_pass(connection_t *, char *);
+
 CLIENT_COMMAND(pass, 1, 1, COMMAND_FL_UNREGISTERED) {
+
     /* just copy the pass in */
-    strncpy(cli->conn->pass, argv[1], PASSWDLEN);
-
+    copy_in_pass(cli->conn, argv[1]);
     return COMMAND_WEIGHT_NONE;
 }
 
 SERVER_COMMAND(pass, 1, 1, COMMAND_FL_UNREGISTERED) {
+
     /* just copy the pass in */
-    strncpy(srv->conn->pass, argv[1], PASSWDLEN);
-
+    copy_in_pass(srv->conn, argv[1]);
     return 0;
 }
+
+static void copy_in_pass(connection_t *conn, char *pass) {
+
+    /* Hack to support CGI IRC, which sends the 'real hostname' as the client
+     * password.  What?  Let's use HOSTLEN I guess! */
+    if (conn->pass != NULL)
+        free(conn->pass); /* dump whatever was there before.. */
+    conn->pass = strdup(pass);
+}
+
 /* vi:set ts=8 sts=4 sw=4 tw=76 et: */

branches/ithildin-scons/modules/ircd/commands/quit.c

@@ -37 +37 @@
 
     if (MYCLIENT(cli)) {
+        snprintf(fmsg, TOPICLEN, MSG_FMT(cli, quit_format), msg);
+        fmsg[TOPICLEN] = '\0';
+
         /* We check to see if their message would be moderated in any channels
          * they are in.  If this is the case they are parted from the channels
          * before the quit is sent. */
-        if (!CLIENT_MASTER(cli) && msg != NULL) {
+        if (!CLIENT_MASTER(cli) && *fmsg != '\0') {
             clp = LIST_FIRST(&cli->chans);
             while (clp != NULL) {
                 clp2 = LIST_NEXT(clp, lpcli);
 
-                if (can_can_send_channel(cli, clp->chan, msg) >= 0) {
+                if (can_can_send_channel(cli, clp->chan, fmsg) >= 0) {
                     sendto_channel_local(clp->chan, cli, NULL, "PART", NULL);
                     sendto_serv_butone(sptr, cli, NULL, clp->chan->name,
@@ -55 +58 @@
         }
 
-        /* if it's our client, the connection will be closed.  we check here
-         * because we can't after a destroy_client() */
-        snprintf(fmsg, TOPICLEN, MSG_FMT(cli, quit_format), msg);
-        fmsg[TOPICLEN] = '\0';
+        /* Be sure to return appropriately for our local clients */
         destroy_client(cli, fmsg);
-        return IRCD_CLOSEDCONN;
+        return IRCD_CONNECTION_CLOSED;
+    } else {
+        destroy_client(cli, msg);
+        return COMMAND_WEIGHT_NONE;
     }
-    destroy_client(cli, msg);
-    return COMMAND_WEIGHT_NONE;
 }
 

branches/ithildin-scons/modules/ircd/commands/rehash.c

@@ -60 +60 @@
     /* it's for us. */
     sendto_one(cli, RPL_FMT(cli, RPL_REHASHING), me.conf_file);
-    sendto_flag(ircd.sflag.ops, "%s is rehashing the server.", cli->nick);
+    sendto_flag(ircd.sflag.ops, "%s is rehashing the server configuration.", cli->nick);
     log_notice("%s!%s@%s rehashed the server", cli->nick, cli->user,
             cli->host);

branches/ithildin-scons/modules/ircd/commands/server.c

@@ -53 +53 @@
         if (clp == NULL) {
             /* no access for this server */
-            destroy_server(srv, "no access", NULL);
-            return IRCD_CLOSEDCONN;
+            destroy_server(srv, "no access");
+            return IRCD_CONNECTION_CLOSED;
         }
 
@@ -66 +66 @@
                     ":Link %s cancelled, server %s already exists",
                     srv->conn->host, argv[1]);
-            destroy_server(srv, "Server Exists", NULL);
-            return IRCD_CLOSEDCONN;
+            destroy_server(srv, "Server Exists");
+            return IRCD_CONNECTION_CLOSED;
         }
 
@@ -77 +77 @@
         }
         if (servers > 1 && !SERVER_HUB((ircd.me))) {
-            destroy_server(srv, "I'm a leaf, not a hub!", NULL);
-            return IRCD_CLOSEDCONN;
+            destroy_server(srv, "I'm a leaf, not a hub!");
+            return IRCD_CONNECTION_CLOSED;
         }   
         
@@ -96 +96 @@
         if (SOCKET_SSL(srv->conn->sock)) {
             if (!server_ssl_verify(srv)) {
-                destroy_server(srv, "no access", NULL);
-                return IRCD_CLOSEDCONN;
+                destroy_server(srv, "no access");
+                return IRCD_CONNECTION_CLOSED;
             }
         } else
@@ -107 +107 @@
             s = conf_find_entry("address", clp, 1);
             if (s == NULL || strcmp(s, ip)) {
-                destroy_server(srv, "no access", NULL);
-                return IRCD_CLOSEDCONN;
+                destroy_server(srv, "no access");
+                return IRCD_CONNECTION_CLOSED;
             }
 
             /* now check passwords. */
             if ((pass = conf_find_entry("theirpass", clp, 1)) == NULL) {
-                destroy_server(srv, "no access", NULL);
-                return IRCD_CLOSEDCONN; /* passwordless servers are a bad
+                destroy_server(srv, "no access");
+                return IRCD_CONNECTION_CLOSED; /* passwordless servers are a bad
                                            idea! */
             }
 
-            if (strcmp(pass, srv->conn->pass)) {
+            if (srv->conn->pass == NULL || strcmp(pass, srv->conn->pass)) {
                 destroy_connection(srv->conn, "password mismatch");
-                return IRCD_CLOSEDCONN; /* password mismatch */
+                return IRCD_CONNECTION_CLOSED; /* password mismatch */
             }
         }
@@ -152 +152 @@
                 sendto_serv_butone(srv, NULL, ircd.me, NULL, "GNOTICE",
                         ":Non-Hub link %s introduced %s.", srv->name, argv[1]);
-                destroy_server(srv, "Too many servers.", NULL);
-                return IRCD_CLOSEDCONN;
+                destroy_server(srv, "Too many servers.");
+                return IRCD_CONNECTION_CLOSED;
             }
         }
@@ -193 +193 @@
     else {
         destroy_client(cli, "no access");
-        return IRCD_CLOSEDCONN;
+        return IRCD_CONNECTION_CLOSED;
     }
 
@@ -200 +200 @@
             (pp = find_protocol(s)) == NULL) {
         destroy_client(cli, "no access");
-        return IRCD_CLOSEDCONN;
+        return IRCD_CONNECTION_CLOSED;
     }
 
@@ -216 +216 @@
     cp->proto->setup(cp);
     if ((ret = s_server_cmd(NULL, argc, argv, cp->srv)) != 0)
-        return ret; /* Give them whatever s_server_cmd gave, it
-                                   will always return 0 on success, anything
-                                   else is an error. */
-
-    return IRCD_PARSESTOP; /* make sure they halt immediately. */
+        return ret; /* Give them whatever s_server_cmd gave, it will always
+                       return 0 on success, anything else is an error. */
+
+    /* Inform them that the protocol has been changed. */
+    return IRCD_PROTOCOL_CHANGED;
 }
 

branches/ithildin-scons/modules/ircd/commands/sjoin.c

@@ -39 +39 @@
     add_to_channel(cli, chan, true);
     sendto_channel_local(chan, cli, NULL, "JOIN", NULL);
-    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, sptr, cli, NULL, NULL,
-            "SJOIN", "%d %s", chan->created, chan->name);
-    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, sptr, cli, NULL, NULL,
-            "JOIN", "%s", chan->name);
+    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, cli->server, cli, NULL,
+            NULL, "SJOIN", "%d %s", chan->created, chan->name);
+    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, cli->server, cli, NULL,
+            NULL, "JOIN", "%s", chan->name);
 
     return COMMAND_WEIGHT_NONE;
@@ -55 +55 @@
 SERVER_COMMAND(sjoin, 4, 5, 0) {
     channel_t *chan;
-    char *joiners = argv[argc - 1], *prefix;
-    char *s;
+    char *client, *prefix;
+    char *buf = argv[argc - 1];
     char realjoiners[512];
     client_t *cp;
     time_t ts = str_conv_int(argv[1], 0);
-    int changeok = 1;
+    bool changeok = true;
     int i;
     int mset = 0;
@@ -68 +68 @@
 
     mlen = 0;
+    /* make sure to set this incase we never actually touch the modes below,
+     * this prevents us from sending out goofy SJOIn data */
+    *modes = *modebuf = '\0';
     chan = find_channel(argv[2]);
 
@@ -75 +78 @@
         chan->created = ts;
     } 
+
+    /* Check TS before running channel_mode (which will reset TS in a
+     * variety of conditions).  All we need to know is whether or not to
+     * accept ops down below, channel_mode does the rest of the logic... */
+    if (ts > chan->created)
+        changeok = false;
+
     /* handle mode changes.  we basically dump off the stuff to the mode
      * command handler.  We subtract four from argc (argv[0] is cmd,
@@ -81 +91 @@
     channel_mode(NULL, srv, chan, ts, (argc - 4), argv + 3, 0);
 
-    /* check for ts changes. */
-    /* we actually accept the older ts here.  if their ts is newer than
-     * ours we will quite likely have to undo changes and stuff.
-     * basically, we shouldn't trust any changes made to a channel whose ts
-     * isn't the same or lower than ours. */
-    if (ts > chan->created)
-        changeok = 0;
-    else if (ts < chan->created)
-        chan->created = ts;
-    /* otherwise everything is the same and copacetic */
-
     /* now parse the list of joiners, and propogate our SJOIN out to others */
     *realjoiners = '\0';
-    while (*joiners) {
-        s = strchr(joiners, ' ');
-        if (s != NULL)
-            *s = '\0';
+    while ((client = strsep(&buf, " ")) != NULL) {
+        if (*client == '\0')
+            continue;
 
         /* handle prefix stuff.  first find out where the prefixes end and the
          * nick begins,  prefixes can't be normal nick characters for obvious
          * reasons, so use this fact.. */
-        prefix = joiners;
-        while (*joiners && !istr_okay(ircd.maps.nick, joiners))
-            joiners++;
+        prefix = client;
+        while (*client && !istr_okay(ircd.maps.nick, client))
+            client++;
         /* now we know what our prefixes are.. */
 
-        cp = find_client(joiners);
+        cp = find_client(client);
         if (cp != NULL) {
             add_to_channel(cp, chan, true);
@@ -114 +112 @@
                 strcat(realjoiners, prefix);
             else /* otherwise, just the nick! */
-                strcat(realjoiners, joiners);
+                strcat(realjoiners, client);
             strcat(realjoiners, " ");
 
@@ -120 +118 @@
              * channel. */
             sendto_channel_local(chan, cp, NULL, "JOIN", NULL);
-            sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, sptr, cp,
+            sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, srv, cp,
                     NULL, chan->name, "JOIN", NULL);
             if (changeok) {
-                while (prefix != joiners) {
-                    chanmode_setprefix(*prefix, chan, joiners, &i);
+                while (prefix != client) {
+                    chanmode_setprefix(*prefix, chan, client, &i);
+                    /* XXX: hardcoded prefixes :( */
                     if (*prefix == '@')
                         modes[mset++] = 'o';
@@ -132 +131 @@
                         continue;
                     modes[mset] = '\0';
-                    mlen += sprintf(&modebuf[mlen], " %s", joiners);
+                    mlen += sprintf(&modebuf[mlen], " %s", client);
                     prefix++;
                 }
-                if (mset == 6) { /* if we've got six modes to set */
+                if (mset >= 6) { /* if we've got six (or more) modes to set */
                     /* okay... assume that non SJOIN servers also don't use
                      * TSMODE.. */
-                    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, sptr,
-                           NULL, srv, chan->name, "MODE", "%s%s %d", modes,
+                    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, srv,
+                           NULL, srv, chan->name, "MODE", "+%s%s %d", modes,
                            modebuf, chan->created); 
                     sendto_channel_local(chan, NULL, srv, "MODE", "+%s%s",
@@ -148 +147 @@
             }
         } else
-            log_warn("got SJOIN for unknown nick %s", joiners);
-
-        if (s != NULL)
-            joiners = s + 1;
-        else /* if there's nothing left, break */
-            break;
+            log_warn("got SJOIN for unknown nick %s on %s", client,
+                    chan->name);
     }
 
     /* if we have leftover modes, send them first */
     if (changeok && mset) {
-        sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, sptr,
-               NULL, srv, chan->name, "MODE", "%s%s %d", modes,
+        sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, false, srv,
+               NULL, srv, chan->name, "MODE", "+%s%s %d", modes,
                modebuf, chan->created); 
         sendto_channel_local(chan, NULL, srv, "MODE", "+%s%s",
@@ -173 +168 @@
         mlen += sprintf(&modebuf[mlen], " %s", argv[i++]);
 
-    sendto_serv_butone(srv, NULL, srv, NULL, "SJOIN", "%d %s %s%s :%s",
-            chan->created, chan->name, argv[3], modebuf, realjoiners);
+    sendto_serv_pflag_butone(PROTOCOL_SFL_SJOIN, true, srv, NULL, srv, NULL,
+            "SJOIN", "%d %s %s%s :%s", chan->created, chan->name, argv[3],
+            modebuf, realjoiners);
 
     return 1;

branches/ithildin-scons/modules/ircd/commands/squit.c

@@ -55 +55 @@
                 /* preserve this old behavior. ;) I find it amusing. */
                 destroy_client(cli, argv[2]);
-                return IRCD_CLOSEDCONN;
+                return IRCD_CONNECTION_CLOSED;
             }
 
@@ -67 +67 @@
         if (MYSERVER(sp)) {
             if (!MYCLIENT(cli)) {
-                sendto_flag(SFLAG("GNOTICE"), "Remote SQUIT %s from %s (%s)",
-                        sp->name, cli->nick, msg);
                 sendto_serv_butone(NULL, NULL, ircd.me, NULL, "GNOTICE",
                         ":Remote SQUIT %s from %s (%s)", sp->name, cli->nick,
                         msg);
+                sendto_flag(SFLAG("GNOTICE"), "Remote SQUIT %s from %s (%s)",
+                        sp->name, cli->nick, msg);
             }
-            destroy_server(sp, msg, NULL);
-        } else {
-            /* Otherwise this is not a verification of a server quit, just a
-             * request to do so.  In this case we pass the request towards the
-             * server and wait for confirmation. */
-            sendto_serv_from(sp, cli, NULL, sp->name, "SQUIT", msg);
-        }
+        } else
+            /* We are an interrim along the road, ensure the final
+             * destination gets the message. */
+            sendto_serv_from(sp, cli, NULL, sp->name, "SQUIT", ":%s", msg);
+
+        destroy_server(sp, msg);
     } else
         sendto_one(cli, RPL_FMT(cli, ERR_NOSUCHSERVER), argv[1]);
@@ -93 +92 @@
      * parameters we lovingly drop the sender on his head. */
     if (argc < 2) {
-        destroy_server(srv, msg, NULL);
-        return IRCD_CLOSEDCONN;
+        destroy_server(srv, msg);
+        return IRCD_CONNECTION_CLOSED;
     }
 
     if ((sp = find_server(argv[1])) == NULL) {
-        log_warn("received SQUIT for unknown server %s from %s", argv[1],
+        log_debug("received SQUIT for unknown server %s from %s", argv[1],
                 srv->name);
         return 0;
@@ -115 +114 @@
         sendto_serv_butone(NULL, NULL, ircd.me, NULL, "GNOTICE",
                 ":Remote SQUIT %s from %s (%s)", sp->name, srv->name, msg);
-        destroy_server(sp, msg, NULL);
-        if (sp == srv)
-            /* be sure to let them know that the connection will be closed */
-            return IRCD_CLOSEDCONN;
-    } else {
-        /* Otherwise we need to see if this is coming from the direction of the
-         * server, or from somewhere else.  If it's coming from somewhere else,
-         * it's a request to SQUIT the server, if it's coming from the
-         * direction of the server it means the server *did* quit */
-        if (srv_server_uplink(srv) != srv_server_uplink(sp))
-            /* a request to SQUIT ... */
-            sendto_serv_from(sp, NULL, srv, sp->name, "SQUIT", msg);
-        else
-            destroy_server(sp, msg, srv);
-    }
+    } else
+        /* Otherwise we must continue to pass the SQUIT towards its final
+         * destination, as well as destroying the server.  See the
+         * commentary in destroy_server for an explanation of what messages
+         * this sends. */
+        sendto_serv_from(sp, NULL, srv, sp->name, "SQUIT", ":%s", msg);
 
-    return 0;
+    destroy_server(sp, msg);
+
+    if (sp == srv)
+        /* If the command came from the server we're killing, be sure to
+         * send back a 'CLOSEDCONN' so we stop parsing the buffer. */
+        return IRCD_CONNECTION_CLOSED;
+    else
+        return 0;
 }
 

branches/ithildin-scons/modules/ircd/commands/svinfo.c

@@ -41 +41 @@
                 "Link %s dropped, wrong TS protocol version (%s,%s)",
                 sptr->conn->host, argv[1], argv[2]);
-        destroy_server(sptr, "Incompatible TS version", NULL);
-        return IRCD_CLOSEDCONN;
+        destroy_server(sptr, "Incompatible TS version");
+        return IRCD_CONNECTION_CLOSED;
     }
 
@@ -57 +57 @@
                 ":Link %s dropped, excessive TS delta (delta=%d)",
                 sptr->conn->host, delta);
-        destroy_server(sptr, "Excessive TS delta", NULL);
-        return IRCD_CLOSEDCONN;
+        destroy_server(sptr, "Excessive TS delta");
+        return IRCD_CONNECTION_CLOSED;
     }
 

branches/ithildin-scons/modules/ircd/commands/svsmode.c

@@ -49 +49 @@
     channel_t *chan;
     client_t *cp;
-    time_t ts;
-    char *s;
-    int oarg = 2;
-    int plus = 1;
-    uint64_t oldmode;
-    char result[64];
+    char **myargv;
+    int myargc;
 
     if (check_channame(argv[1]) && (chan = find_channel(argv[1])) != NULL) {
@@ -60 +56 @@
         channel_mode(cli, srv, chan, chan->created, argc - 2, argv + 2, 1);
     } else if ((cp = find_client(argv[1])) != NULL) {
-        /* this is less simple.  svsmode sends +d <x> to set 'services id' on
-         * people, and we'll handle that here.  XXX: this is a hack, and we
-         * should call user_mode() but we don't. :( */
-        if (isdigit(*argv[oarg]))
-            ts = str_conv_int(argv[oarg++], 0);
-        else
-            ts = 0;
+        /* Services setting "client modes."  There's also this sort of like,
+         * stupid hack where they send "+d <ts>" which is a 'servicesid'
+         * used to track clients on the network.  We one-off support this
+         * and treat everything else as a real client mode. */
 
-        if (ts && cp->ts != ts)
-            return; /* not the same client */
-
-        oldmode = cp->modes;
-        s = argv[oarg++];
-        while (*s) {
-            switch (*s) {
-                case '+':
-                    plus = 1;
-                    break;
-                case '-':
-                    plus = 0;
-                    break;
-                case 'd':
-                    /* special case to set 'services id' */
-                    if (oarg < argc)
-                        SVSID(cp) = str_conv_int(argv[oarg++], 0);
-                    break;
-                default:
-                    if (plus)
-                        usermode_set(*s, NULL, cp, NULL, NULL);
-                    else
-                        usermode_unset(*s, NULL, cp, NULL, NULL);
-                    break;
-            }
-            s++;
+        /* They may send a ts along first.  We must skip this. */
+        if (isdigit(*argv[2])) {
+            myargv = argv + 3; /* skip to argv[3] */
+            myargc = argc - 3;
+        } else {
+            myargv = argv + 2;
+            myargc = argc - 2;
         }
 
-        if (MYCLIENT(cp))  {
-            usermode_diff(oldmode, cp->modes, result, 0);
-            if (*result != '\0') {
-                if (cli != NULL)
-                    sendto_one_from(cp, cli, NULL, "MODE", ":%s", result);
-                else
-                    sendto_one_from(cp, cp, NULL, "MODE", ":%s", result);
-            }
+        if (myargc == 2 && (!strcmp(myargv[0], "+d") ||
+                    !strcmp(myargv[0], "+T"))) {
+            if (!strcmp(argv[0], "+d"))
+                /* this is so dumb */
+                SVSID(cp) = str_conv_int(myargv[1], 0);
+
+            sendto_serv_butone(sptr, cli, srv, cp->nick, "SVSMODE",
+                    "%s %s", myargv[0], myargv[1]);
+            return;
         }
-        if (argc > 3)
-            sendto_serv_butone(sptr, cli, srv, cp->nick, "SVSMODE",
-                    "%d %s %s", ts, argv[2], argv[3]);
-        else
-            sendto_serv_butone(sptr, cli, srv, cp->nick, "SVSMODE",
-                    "%d %s", ts, argv[2]);
+        if (MYCLIENT(cp))
+            /* Is this our client?  If so do the usermode thing.  Otherwise
+             * just pass along the command, we expect a MODE back when it is
+             * processed by the user's server. */
+            user_mode(NULL, cp, myargc, myargv, true);
+
+        sendto_serv_butone(sptr, cli, srv, cp->nick, "SVSMODE", "%s",
+                myargv[0]);
     }
 }

branches/ithildin-scons/modules/ircd/commands/topic.c

@@ -37 +37 @@
     add_isupport("TOPICLEN", ISUPPORT_FL_INT, (char *)&i64);
 
-    add_hook(ircd.events.channel_add, topic_channel_add_hook);
+    /* stuff this hook in nice and early so we are always in front of NAMES.
+     * THis should be harmless, at least for now.  Some clients seem to
+     * depend on speculative wording in RFC1459 that says RPL_TOPIC and
+     * RPL_NAMREPLY are sent.  They believe this implies that RPL_TOPIC must
+     * be first.  Most clients do not break when this isn't the case, but a
+     * few poorly written ones do. */
+    add_hook_before(ircd.events.channel_add, topic_channel_add_hook, NULL);
+
     add_hook(ircd.events.server_establish, topic_server_establish_hook);
 

branches/ithildin-scons/modules/ircd/commands/version.c

@@ -40 +40 @@
             ircd.vercomment);
     send_isupport(cli);
+    if (me.debug)
+        sendto_one(cli, "NOTICE", ":This server is running in debug mode. "
+                "Some traffic may be logged.");
 
     return COMMAND_WEIGHT_MEDIUM;

branches/ithildin-scons/modules/ircd/commands/watch.c

@@ -200 +200 @@
             int sblen = 0;
 
+            /* XXX: static sized buffer-fuck.  this must be cleaned up */
             wp = find_watch(cli->nick);
             sendto_one(cli, RPL_FMT(cli, RPL_WATCHSTAT), cwp->count,
                     (wp != NULL ? wp->count : 0));
             LIST_FOREACH(wlp, &cwp->list, lpwtch) {
-                if (320 - sblen <= strlen(wlp->watch->nick)) {
+                if (310 - sblen <= strlen(wlp->watch->nick)) {
                     /* send the list if it's getting full */
                     sendto_one(cli, RPL_FMT(cli, RPL_WATCHLIST), sbuf);
                     sblen = 0;
                 }
-                sblen += snprintf(sbuf + sblen, 320 - sblen, "%s ",
+                sblen += snprintf(sbuf + sblen, 310 - sblen, "%s ",
                         wlp->watch->nick);
             }

branches/ithildin-scons/modules/ircd/commands/whois.c

@@ -57 +57 @@
 CLIENT_COMMAND(whois, 1, 2, 0) {
     client_t *target;
+    char *nick = (argc > 2 ? argv[2] : argv[1]);
     struct chanlink *clp;
 #define WHOISBUFLEN 320
@@ -67 +68 @@
         return COMMAND_WEIGHT_HIGH;
 
-    if (argc > 2)
-        target = find_client(argv[2]);
-    else
-        target = find_client(argv[1]);
-
+    target = find_client(nick);
     if (target == NULL) {
-        sendto_one(cli, RPL_FMT(cli, ERR_NOSUCHNICK),
-                (argc > 2 ? argv[2] : argv[1]));
-        return COMMAND_WEIGHT_NONE;
+        sendto_one(cli, RPL_FMT(cli, ERR_NOSUCHNICK), nick);
+        sendto_one(cli, RPL_FMT(cli, RPL_ENDOFWHOIS), nick);
+        return COMMAND_WEIGHT_LOW;
     }
 
@@ -83 +80 @@
     /* show them the real host if they can see it and this is either a local
      * real client (conn != NULL) or orighost points somewhere different */
-    if (CAN_SEE_REAL_HOST(cli, target)) {
-        if (target->conn != NULL) {
-            /* in this case show them the values we got from identd/dns */
-            if (*target->conn->user == '\0' || *target->conn->user == '~')
-            sendto_one(cli, RPL_FMT(cli, RPL_WHOISACTUALLY), target->nick,
-                        target->user, target->conn->host, target->ip);
-            else
-                sendto_one(cli, RPL_FMT(cli, RPL_WHOISACTUALLY), target->nick,
-                        target->conn->user, target->conn->host, target->ip);
-        } else if (target->orighost != target->host)
-            sendto_one(cli, RPL_FMT(cli, RPL_WHOISACTUALLY), target->nick,
-                    target->user, target->orighost, target->ip);
-    }
+    if (CAN_SEE_REAL_HOST(cli, target) && target->orighost != target->host)
+        sendto_one(cli, RPL_FMT(cli, RPL_WHOISACTUALLY), target->nick,
+                target->user, target->orighost, target->ip);
     if (!CLIENT_MASTER(target) || MYCLIENT(target)) {
         /* don't show channels that master clients are in unless this is a

branches/ithildin-scons/modules/ircd/commands/whowas.c

@@ -54 +54 @@
     if (target == NULL) {
         sendto_one(cli, RPL_FMT(cli, ERR_WASNOSUCHNICK), argv[1]);
-        return COMMAND_WEIGHT_NONE;
+        sendto_one(cli, RPL_FMT(cli, RPL_ENDOFWHOWAS), argv[1]);
+        return COMMAND_WEIGHT_LOW;
     }
 

branches/ithildin-scons/modules/ircd/commands/xinfo.c

@@ -30 +30 @@
 MODULE_LOADER(xinfo) {
 
-    add_xinfo_handler(xinfo_class_handler, "CLASS", 0, NULL,
+    add_xinfo_handler(xinfo_class_handler, "CLASS", 0,
             "Provides information about server connection classes");
-    add_xinfo_handler(xinfo_client_handler, "CLIENT", XINFO_HANDLER_OPER, NULL,
+    add_xinfo_handler(xinfo_client_handler, "CLIENT", XINFO_HANDLER_OPER,
             "Provices information about clients on this server");
     add_xinfo_handler(xinfo_connects_handler, "CONNECTS", XINFO_HANDLER_OPER,
-            NULL, "Shows information about server uplinks");
-    add_xinfo_handler(xinfo_hash_handler, "HASH", XINFO_HANDLER_OPER, NULL,
+            "Shows information about server uplinks");
+    add_xinfo_handler(xinfo_hash_handler, "HASH", XINFO_HANDLER_OPER,
             "Shows hash table statistics.");
-    add_xinfo_handler(xinfo_me_handler, "ME", XINFO_HANDLER_LOCAL, NULL,
+    add_xinfo_handler(xinfo_me_handler, "ME", XINFO_HANDLER_LOCAL,
             "Provides information about your connection statistics");
     add_xinfo_handler(xinfo_privilege_handler, "PRIVILEGE",
-            XINFO_HANDLER_LOCAL | XINFO_HANDLER_OPER, NULL,
+            XINFO_HANDLER_LOCAL | XINFO_HANDLER_OPER,
             "Provides information about available privileges");
-    add_xinfo_handler(xinfo_server_handler, "SERVER", 0, NULL,
+    add_xinfo_handler(xinfo_server_handler, "SERVER", 0,
             "Provides information about this (or other) servers");
-    add_xinfo_handler(xinfo_xinfo_handler, "XINFO", 0, NULL,
+    add_xinfo_handler(xinfo_xinfo_handler, "XINFO", 0,
             "Provides a list of available XINFO query-handlers");
 
@@ -136 +136 @@
         return COMMAND_WEIGHT_LOW; /* silently ignore these */
     if ((xhp->flags & XINFO_HANDLER_OPER && !OPER(cli)) ||
-            (xhp->flags & XINFO_HANDLER_PRIV && !BPRIV(cli, xhp->priv))) {
+            !BPRIV(cli, xhp->priv)) {
         sendto_one(cli, RPL_FMT(cli, ERR_NOPRIVILEGES));
         return COMMAND_WEIGHT_LOW;
@@ -182 +182 @@
     client_t *cp;
     char rpl[XINFO_LEN];
+    char *user;
+    char ip[IPADDR_MAXLEN + 1];
 
     if (argc < 2) {
@@ -197 +199 @@
     }
                 
-    snprintf(rpl, XINFO_LEN, "%s!%s@%s[%s]", cp->nick, cp->user, cp->host,
-            cp->ip);
+    if (cp->conn != NULL) {
+        /* give them the connection info if we can... */
+        if (*cp->conn->user == '\0' || *cp->conn->user == '~')
+            user = cp->user; /* this information is not valuable here */
+        else
+            user = cp->conn->user;
+        if (cp->conn->sock != NULL) /* should never be NULL but.. */
+            get_socket_address(isock_raddr(cp->conn->sock), ip,
+                    IPADDR_MAXLEN + 1, NULL);
+        else
+            strcpy(ip, cp->ip);
+        snprintf(rpl, XINFO_LEN, "%s!%s@%s[%s]", cp->nick, user,
+                cp->conn->host, ip);
+    } else
+        snprintf(rpl, XINFO_LEN, "%s!%s@%s[%s]", cp->nick, cp->user,
+                cp->host, cp->ip);
     sendto_one(cli, RPL_FMT(cli, RPL_XINFO), "ADDRESS", rpl);
     snprintf(rpl, XINFO_LEN, "TS %d SIGNON %d IDLE %d", cp->ts,
@@ -425 +441 @@
             continue; /* non-local */
         if ((xhp->flags & XINFO_HANDLER_OPER && !OPER(cli)) ||
-                (xhp->flags & XINFO_HANDLER_PRIV && !BPRIV(cli, xhp->priv)))
+                !BPRIV(cli, xhp->priv))
             continue; /* not privileged */
 

branches/ithildin-scons/modules/ircd/conf.c

@@ -335 +335 @@
                     log_warn("could not enable SSL on %s/%d", addr, port);
                     destroy_socket(isp);
+                    return;
                 }
 #endif
@@ -505 +506 @@
             /* update their flags, too. */
             server_set_flags(srv);
-        }
-    }
-
-    /* now check for autoconnects */
+        } else
+            srv->conf = NULL; /* important to re-set this if we need to */
+    }
+
+    /* Wipe out any existing auto-connect info.. */
+    while (!LIST_EMPTY(ircd.lists.server_connects))
+        destroy_server_connect(LIST_FIRST(ircd.lists.server_connects));
+
+    /* And add new ones */
     cep = NULL;
     while ((cep = conf_find_next("server", NULL, CONF_TYPE_LIST, cep, conf, 1))

branches/ithildin-scons/modules/ircd/connection.c

@@ -41 +41 @@
         return;
     } else if (c->srv != NULL) {
-        destroy_server(c->srv, reason, NULL);
+        destroy_server(c->srv, reason);
         return;
     }
 
-    /* empty their sendq */
-    while (STAILQ_FIRST(&c->sendq) != NULL)
-        sendq_pop(c);
-    /* if there is a reason, send them a message */
-    if (reason != NULL && *reason != '\0') {
+    /* Try to send them an error message if we can.  We assume someone has
+     * tried to flush their sendq or doesn't think we should, so if it's
+     * empty we send an error, otherwise we clean it off and don't bother
+     * trying to send since other sends have already failed (and we infer
+     * that this means the socket is not writeable) */
+    if (STAILQ_EMPTY(&c->sendq) && reason != NULL && *reason != '\0') {
         snprintf(msg, 512, "\r\nERROR :Closing Link: %s (%s)\r\n", 
                 c->host, reason);
         socket_write(c->sock, msg, strlen(msg));
-    }
+    } else {
+        while (STAILQ_FIRST(&c->sendq) != NULL)
+            sendq_pop(c);
+    }
+
+    if (c->pass != NULL)
+        free(c->pass);
+
     if (c->buf != NULL)
         free(c->buf);
@@ -182 +190 @@
 
 /* this is used to initialize the stage2 lookups.  it is kept separate so that
- * SSL accpets can be done prior to the data sending. */
+ * SSL accepts can be done prior to the data sending. */
 static void connection_init_lookups(connection_t *c) {
     char msg[256];
@@ -363 +371 @@
     connection_t *c = (connection_t *)s->udata;
     char msg[512];
+    int ret;
 
 #ifdef HAVE_OPENSSL
@@ -379 +388 @@
 #endif
             
-    /* We have to assume that once c->proto->input() is called, 'c' is
-     * potentially no longer valid.  We're the high end of the chain:
-     * socket read ready -> read data -> parse data -> execute command, the
-     * command execution could invalidate the client (and thus connection) so
-     * we take the easy road and read last because that way we don't touch 'c'
-     * anymore and so if it is invalidated by destruction, it's still safe. */
+    /*
+     * Read first, then write, then check errors.  If the read succeeds
+     * (does not return IRCD_CONNECTION_CLOSED) we should be ensured that
+     * the connection is still valid.
+     */
+
+    if (SOCKET_READ(s)) {
+        ret = (int)c->proto->input(ep, data);
+        /* We do this in a while loop because we may end up doing more than
+         * one proto change (unlikely but the support for this is nearly
+         * free so...) */
+        while (ret == IRCD_PROTOCOL_CHANGED) {
+            /* A protocol change implies two things to us:
+             * 1) We may need to resize the buffer for this protocol.  We
+             * can only resize up, not down!  In the down case we do the
+             * wrong thing and close the connection instead of looping a
+             * parser to clear the buffer. (XXX: worth fixing?)
+             * 2) If there is any data in the buffer we should call the new
+             * protocol's input function, protocol changes may leave
+             * lingering data which would otherwise generate socket events
+             * if we acted on it, so.. act on it here. */
+
+            if (c->bufsize < c->proto->bufsize) {
+                /* We must resize the buffer... we can happily just use
+                 * realloc here, since nothing should depend on the address
+                 * of c->buf between input calls */
+                c->buf = realloc(c->buf, c->proto->bufsize);
+                c->bufsize = c->proto->bufsize;
+            }
+            if (c->buflen > 0)
+                /* We pass NULL as the event parameter for the input
+                 * function as a way of saying "this was forcefully called
+                 * outisde the normal event mechanism".  This is to tell the
+                 * protocol handler that it should try to flush its current
+                 * buffer even if there is no data from the socket.
+                 * XXX: this is kind of a hack... */
+                ret = (int)c->proto->input(NULL, data);
+            else
+                ret = 0; /* kill the loop :) */
+        }
+
+        if (ret == IRCD_CONNECTION_CLOSED)
+            return NULL; /* nothing to do... */
+    }
+
+    if (SOCKET_WRITE(s))
+        /* Only flag that we are writeable.  The writer hook takes care of
+         * doing buffered writes for us outside the construct of this loop.
+         * I thiml, potentially falsely, that it may be beneficial to batch
+         * writes and reads in this manner. */
+        c->flags |= IRCD_CONNFL_WRITEABLE;
+
     if (SOCKET_ERROR(s)) {
         if (c->srv != NULL) {
@@ -400 +455 @@
         return NULL;
     }
-    if (SOCKET_WRITE(s))
-        c->flags |= IRCD_CONNFL_WRITEABLE;
-    if (SOCKET_READ(s))
-        c->proto->input(ep, data);
 
     return NULL;

branches/ithildin-scons/modules/ircd/connection.h

@@ -2 +2 @@
  * connection.h: support structures/prototypes for connection.c
  * 
- * Copyright 2002 the Ithildin Project.
+ * Copyright 2002-2006 the Ithildin Project.
  * See the COPYING file for more information on licensing and use.
  * 
@@ -8 +8 @@
  */
 
-#ifndef IRCD_SOCKET_H
-#define IRCD_SOCKET_H
+#ifndef IRCD_CONNECTION_H
+#define IRCD_CONNECTION_H
 
 struct connection {
-    isocket_t *sock;                    /* our socket */
-    client_t *cli;                    /* either a client or a server, should */
-    server_t *srv;                    /* never be both! */
-    char    host[HOSTLEN + 1];            /* user and host data (as given by
+    isocket_t *sock;                /* our socket */
+    client_t *cli;                  /* either a client or a server, should */
+    server_t *srv;                  /* never be both! */
+    char    host[HOSTLEN + 1];      /* user and host data (as given by
                                        identd/dns) */
     char    user[USERLEN + 1];
-    char    pass[PASSWDLEN + 1];    /* password, after registration feel
-                                       free to use this as empty bufferspace */
+    char    *pass;                  /* password, if not NULL it must be
+                                       malloc'd memory.  It will be
+                                       destroyed after client registration.  */
 
-    char    *buf;                    /* temporary buffer pointer, possibly
+    char    *buf;                   /* temporary buffer pointer, possibly
                                        used in many places */
     size_t  buflen;                 /* length of data in the buffer */
-    size_t  bufsize;                    /* size of the temporary buffer. */
+    size_t  bufsize;                /* size of the temporary buffer. */
+    size_t  bufresize;              /* When non-0 a resize request for the
+                                       buffer.  We do this in the socket
+                                       event hook, after reading has
+                                       completed. */
 
-    class_t   *cls;                    /* our connection class */
-    protocol_t *proto;                    /* our current protocol */
+    class_t   *cls;                 /* our connection class */
+    protocol_t *proto;              /* our current protocol */
     message_set_t *mset;            /* our message set, NULL for servers */
 
-    time_t  signon;                    /* time of connection (not registration) */
-    time_t  last;                    /* last update to this item */
-    int            flood;                    /* flood level (clients only) */
+    time_t  signon;                 /* time of connection (not registration) */
+    time_t  last;                   /* last update to this item */
+    int     flood;                  /* flood level (clients only) */
 
     struct {
-        int64_t sent;                    /* bytes sent */
-        int64_t psent;                    /* "packets" sent */
-        int64_t recv;                    /* bytes received */
-        int64_t precv;                    /* "packets" received */
+        int64_t sent;               /* bytes sent */
+        int64_t psent;              /* "packets" sent */
+        int64_t recv;               /* bytes received */
+        int64_t precv;              /* "packets" received */
     } stats;
 
-#define IRCD_CONNFL_DNS_PTR                0x1
-#define IRCD_CONNFL_DNS_ADDR                0x2
+#define IRCD_CONNFL_DNS_PTR     0x1
+#define IRCD_CONNFL_DNS_ADDR    0x2
 #define IRCD_CONNFL_DNS        (IRCD_CONNFL_DNS_PTR | IRCD_CONNFL_DNS_ADDR)
-#define IRCD_CONNFL_IDENT                0x4
-#define IRCD_CONNFL_STAGE2                0x8
-#define IRCD_CONN_DONE(x)                                                \
-    (((x)->flags & (IRCD_CONNFL_DNS | IRCD_CONNFL_IDENT)) ==                \
+#define IRCD_CONNFL_IDENT       0x4
+#define IRCD_CONNFL_STAGE2      0x8
+#define IRCD_CONN_DONE(x)                                                     \
+    (((x)->flags & (IRCD_CONNFL_DNS | IRCD_CONNFL_IDENT)) ==                  \
      (IRCD_CONNFL_DNS | IRCD_CONNFL_IDENT))
-#define IRCD_CONN_NEED_STAGE2(x)        (!((x)->flags & IRCD_CONNFL_STAGE2))
+#define IRCD_CONN_NEED_STAGE2(x) (!((x)->flags & IRCD_CONNFL_STAGE2))
 
 #define IRCD_CONNFL_WRITEABLE 0x100 /* set if the socket is writeable */
@@ -68 +73 @@
 #endif
 
-    int            flags;                    /* connection flags (DO NOT PUT
+    int     flags;                  /* connection flags (DO NOT PUT
                                        CLIENT/SERVER FLAGS HERE) */
 
-    int            sendq_items;            /* items on the send queue */
-    STAILQ_HEAD(, sendq_item) sendq; /* and te queue itself */
+    int     sendq_items;            /* items on the send queue */
+    STAILQ_HEAD(, sendq_item) sendq;/* and te queue itself */
     LIST_ENTRY(connection) lp;
 };

branches/ithildin-scons/modules/ircd/doc/conf.txt

@@ -66 +66 @@
     reason "You are not authorized to use this server.";
 
+    // redirect: (optional)
+    // This specifies that a connection should be redirected to the
+    // specified server/port (server:port form).  If the port is left off
+    // it is assumed to be the default port (typically 6667).  This applies
+    // only to entries in stage 3.
+    // NB: redirect ACLs are always deny type.  That is, the redirect message
+    // is provided and then the connection is closed.
+    redirect <some-irc-server:some-port>;
+
     // skip-dns: (optional)
     // This option can be used to skip doing a dns lookup on a connection.
@@ -111 +120 @@
     // hostmask: addons/hostmask (optional)
     // This masks all users in this connection class to the given hostname.
+    // The special mask "cgi:irc" enables support for the CGI:IRC web gateway
+    // to pass in the user's real hostname via the PASS command.  If you set
+    // the hostmask to "cgi:irc" and a connection in the class either does not
+    // give a password or gives an invalid host the connection will be
+    // unmasked.
     hostmask <some.host.name>;
 

branches/ithildin-scons/modules/ircd/ircd.c

@@ -18 +18 @@
 IDSTRING(rcsid, "$Id$");
 
-MODULE_REGISTER(PACKAGE_VERSION);
+MODULE_REGISTER("1.0rc1");
 /*
 @DEPENDENCIES@: dns ident
@@ -443 +443 @@
         CMSG("004", "%s %s %s %s");                         /* rpl_myinfo */
         CMSG("005", "%s :are available on this server.");   /* rpl_isupport */
+        CMSG("010", "%s %d :Please redirect your client to this server and "
+                "port."); /* rpl_redir */
         CMSG("263", ":Server load is temporarily too heavy, please wait a "
                 "while and try again."); /* rpl_loadtoohigh */

branches/ithildin-scons/modules/ircd/protocol.c

@@ -21 +21 @@
 static int protocol_packet_parse(connection_t *cp, char *end);
 
+/* Return codes from protocol_packet_parse */
+#define PROTOCOL_PARSE_PROTOSET 1
+#define PROTOCOL_PARSE_1459STOP 2
+
 #define DEFAULT_BUFFER_SIZE 512
 HOOK_FUNCTION(protocol_default_input) {
@@ -40 +44 @@
                 cp->bufsize - cp->buflen);
     if (ret < 0)
-        return NULL; /* the error should be picked up by the handler. */
+        return (void *)0; /* the error should be picked up by the handler. */
     else if (ret == 0)
-        return NULL; /* nothing to do */
+        return (void *)0; /* nothing to do */
 
     cp->buflen += ret;
@@ -63 +67 @@
             s = strchr(cp->buf, '\n');
             if (s == NULL)
-                return NULL; /* no command terminator found and we're out of
-                                data */
+                return (void *)0; /* no command terminator found and we're out
+                                     of data */
         }
         /* make a local copy of the packet, then pass it off to the parser.
@@ -74 +78 @@
         else
             *s = '\0';
-        if ((ret = protocol_packet_parse(cp, s)) == IRCD_PARSESTOP)
-            return NULL; /* stop parsing.. */
-        else if (ret == IRCD_CLOSEDCONN)
-            return NULL;
+
+        /* Parse the packet, we must stop parsing immediately if the
+         * connection is closed.  Additionally, we stop parsing immediately
+         * if we get the 1459 return because the code that returns it
+         * modifies our buffer for us.  In that case we return proto changed
+         * and let input be call for us above. */
+        if ((ret = protocol_packet_parse(cp, s)) == IRCD_CONNECTION_CLOSED)
+            return (void *)ret; /* stop parsing.. */
+        else if (ret == PROTOCOL_PARSE_1459STOP)
+            return (void *)IRCD_PROTOCOL_CHANGED;
         s++; /* increment s, now we see if our packet contains more data */
         if ((size_t)(s - cp->buf) < cp->buflen) {
@@ -86 +96 @@
             *cp->buf = '\0'; /* no leftovers! */
         }
-        if (ret) {
-            /* if the parser was otherwise successful, see if we have left over
-             * data and call the input function for the protocol if we do, then
-             * return. */
-            if (cp->buflen != 0)
-                cp->proto->input(NULL, (void *)cp->sock);
-            return NULL; /* now stop. */
-        }
-    }
-
-    return NULL;
+        if (ret == PROTOCOL_PARSE_PROTOSET)
+            return (void *)IRCD_PROTOCOL_CHANGED;
+    }
+
+    return (void *)0;
 }
 
@@ -110 +114 @@
     if (!strncasecmp(cp->buf, "QUIT", 4)) {
         destroy_connection(cp, "");
-        return IRCD_CLOSEDCONN;
+        return IRCD_CONNECTION_CLOSED;
     } else if (!strncasecmp(cp->buf, "PROTOCOL", 8)) {
         /* we received a 'protocol' command.  cool.  this makes our life easy,
@@ -119 +123 @@
         if (*s == '\0') {
             destroy_connection(cp, "bogus protocol command");
-            return IRCD_CLOSEDCONN;
+            return IRCD_CONNECTION_CLOSED;
         }
 
@@ -139 +143 @@
         sprintf(emsg, "protocol %s is not supported", s);
         destroy_connection(cp, emsg);
-        return IRCD_CLOSEDCONN;
+        return IRCD_CONNECTION_CLOSED;
     }
         
@@ -147 +151 @@
         
     if (rfc1459) {
-        /* an ugly hack.  re-add the [\r]\n, then call the input function. */
+        /* Re-adjust the buffer and return the special token to immediately
+         * and successfully halt parsing (see above).  We do this because
+         * the protocol itself needs to receive the message we hooked onto
+         * for 1459 verification. */
         if (*(end - 1) == '\0')
             *(end - 1) = '\r';
         *end = '\n';
-        /* we had re-set cp->buflen here, but I don't see why we're doing that?
-         * PARSESTOP prevents the buffer adjustments above, so let's not jack
-         * with cp->buflen.  Yikes. */
-#if 0
-        cp->buflen = strlen(cp->buf); /* ... */
-#endif
-        cp->proto->input(NULL, (void *)cp->sock);
-        return IRCD_PARSESTOP;
-    }
-    return 1; /* success */
+
+        return PROTOCOL_PARSE_1459STOP;
+    }
+
+    return PROTOCOL_PARSE_PROTOSET;
 }
 
@@ -231 +233 @@
     if ((i64p = (uint64_t *)module_symbol(pp->dll, "protocol_flags")) != NULL)
         pp->flags = *i64p;
+
+    if ((i64p = (uint64_t *)module_symbol(pp->dll, "protocol_buffer_size")) != NULL)
+        pp->bufsize = *i64p;
+    else
+        pp->bufsize = DEFAULT_BUFFER_SIZE;
 }
 
@@ -271 +278 @@
         cp2 = LIST_NEXT(cp, lp);
         if (cp->proto == pp)
-            destroy_server(cp->srv, "protocol removed", NULL);
+            destroy_server(cp->srv, "protocol removed");
         cp = cp2;
     }

branches/ithildin-scons/modules/ircd/protocol.h

@@ -20 +20 @@
 struct protocol {
     char    *name;            /* name of protocol */
-    hook_function_t input;  /* function hooked when data is available */
+
+    /* The input function is hooked when data is available.  The return code
+     * (if not 0) from the command parser should be honored and also
+     * returned up the chain (it is used by the socket hook function) */
+    hook_function_t input; 
 
     /* function called to create a new message.  the arguments are: sender
@@ -43 +47 @@
      * these are somewhat hackish.  client and server protocols may have
      * different flags with the same value, so beware! */
-#define PROTOCOL_SFL_SJOIN        0x0001
-#define PROTOCOL_SFL_NOQUIT        0x0002
-#define PROTOCOL_SFL_TSMODE        0x0004
-#define PROTOCOL_SFL_ATTR        0x0008
-#define PROTOCOL_SFL_TS                0x0010
-#define PROTOCOL_SFL_SHORTAKILL        0x0020
+#define PROTOCOL_SFL_SJOIN      0x0001
+#define PROTOCOL_SFL_NOQUIT     0x0002
+#define PROTOCOL_SFL_TSMODE     0x0004
+#define PROTOCOL_SFL_ATTR       0x0008
+#define PROTOCOL_SFL_TS         0x0010
+#define PROTOCOL_SFL_SHORTAKILL 0x0020
 
-#define PROTOCOL_MFL_NOCACHE        (0x01ULL << 56)
+    /* Top eight bits (currently) reserved for "module" flags.  Right now
+     * just one, nocache, exists.  This instructs the send* functions to not
+     * cache messages when they otherwise would.  This is a hack to allow
+     * sending slightly different messages to different individual members
+     * in a protocol (see the hostcrypt addon for a real-world example of
+     * the usefulness/uselessness of this. :) */
+#define PROTOCOL_MFL_NOCACHE    (0x01ULL << 56)
     uint64_t flags;
+
+    /* the buffer size we should allocate for clients in this protocol */
+    uint64_t bufsize;
 
     /* the module this protocol is represented by */

branches/ithildin-scons/modules/ircd/protocols/dreamforge.c

@@ -2 +2 @@
  * dreamforge.c: the dreamforge server<->server protocol
  * 
- * Copyright 2003, 2004 the Ithildin Project.
+ * Copyright 2003-2006 the Ithildin Project.
  * See the COPYING file for more information on licensing and use.
  */

branches/ithildin-scons/modules/ircd/protocols/ithildin1.c

@@ -28 +28 @@
 void sync_channel(connection_t *, channel_t *);
 
-/* With \n included.  We allow longer server messages as a convenience here. */
-#define MAX_PACKET_LEN 1024
+/* With \n included.  We allow longer server messages as a convenience here
+ * (reduces net traffic on very big commands like SJOINs) */
+#define MAX_PACKET_LEN 512
 /* Use the rfc1459-type input routine, since we do effectively the same thing
  * here.  Note also that MAX_COMMAND_ARGS remains unchanged. */
@@ -123 +124 @@
             "%s %d %d %s %s %s :%s", cli->nick, cli->hops + 1, cli->ts,
             cli->user, cli->orighost, cli->server->name, cli->info);
+    sendto_serv_from(conn->srv, cli, NULL, cli->nick, "MODE", "%s",
+            usermode_getstr(cli->modes, 1));
 }
 
-#define BUF_SIZE 768
+#define BUF_SIZE 320
 #include "shared/sjoin_sync_channel.c"
 

branches/ithildin-scons/modules/ircd/protocols/shared/rfc1459_io.c

@@ -10 +10 @@
 #endif
 
+const uint64_t protocol_buffer_size = MAX_PACKET_LEN;
+
 HOOK_FUNCTION(input);
 struct send_msg *output(struct protocol_sender *, char *, char *, char *,
         va_list);
+
 /* input as much data as we can from the user. */
 HOOK_FUNCTION(input) {
@@ -63 +66 @@
                     (cp->cli != NULL ? cp->cli->nick :
                      (cp->srv != NULL ? cp->srv->name : "")), cp->buf);
-            if ((ret = packet_parse(cp)) == IRCD_CLOSEDCONN)
-                return NULL; /* connection closed, stop immediately */
+            if ((ret = packet_parse(cp)) == IRCD_CONNECTION_CLOSED)
+                return (void *)ret; /* connection closed, stop immediately */
             s++; /* increment s, now we see if our packet contains more data */
             if (s - cp->buf < cp->buflen) {
@@ -75 +78 @@
             }
 
-            if (ret == IRCD_PARSESTOP)
-                return NULL;
+            if (ret == IRCD_PROTOCOL_CHANGED)
+                return (void *)ret;
         }
     }
 
     /* if there are any errors they will be picked up elsewhere */
-    return NULL;
+    return (void *)0;
 }
 

branches/ithildin-scons/modules/ircd/send.c

@@ -608 +608 @@
     }
     free(ircd.sflag.flags[flg].name);
+
+    memset(&ircd.sflag.flags[flg], 0, sizeof(struct send_flag));
     ircd.sflag.flags[flg].num = -1;
 }
@@ -631 +633 @@
 
     /* otherwise, put them in. */
-    clp = malloc(sizeof(struct chanlink));
+    clp = calloc(1, sizeof(struct chanlink));
     clp->cli = cli;
     clp->chan = NULL;
@@ -672 +674 @@
     char lmsg[512];
     va_list vl;
-        
+
     if (flg < 0 || flg >= ircd.sflag.size || ircd.sflag.flags[flg].num < 0)
         return; /* nothing to do here. */

branches/ithildin-scons/modules/ircd/send.h

@@ -166 +166 @@
       ircd.messages.msgs[index].default_fmt))
 
-/* below here are defines for the numerics added by default */
-#define RPL_WELCOME 001
-#define RPL_YOURHOST 002
-#define RPL_CREATED 003
-#define RPL_MYINFO 004
-#define RPL_ISUPPORT 005
+/* below here are defines for the numerics added by default. Worth noting
+ * that it is unwise to prefix numerics with leading 0s because then they
+ * will be interpreted as octal numbers (not that uh.. I did that...) */
+#define RPL_WELCOME 1
+#define RPL_YOURHOST 2
+#define RPL_CREATED 3
+#define RPL_MYINFO 4
+#define RPL_ISUPPORT 5
+#define RPL_REDIR 10
 #define RPL_LOADTOOHIGH 263
 

branches/ithildin-scons/modules/ircd/server.c

@@ -42 +42 @@
  * quits for its clients out to users, and sending the split message.  it calls
  * itself recursively to remove other servers connected to the server it is
- * called for, as well.   The source argument is used as the 'but one'
- * argument when sending SQUITs via sendto_serv_butone. */
+ * called for, as well.  We do not take care of sending a SQUIT message to
+ * srv!  This is important, because some callers (specifically the SQUIT
+ * command code) may very well need to pass on a SQUIT if this isn't a
+ * locally connected server.  In this case they are expected to do so, we
+ * don't do it here because we don't have the information required. */
 static int destroy_server_count = 0;
 static char destroy_server_splitmsg[512];
-void destroy_server(server_t *srv, char *msg, server_t *source) {
+void destroy_server(server_t *srv, char *msg) {
     client_t *cp, *cp2;
     server_t *sp, *sp2;
@@ -56 +59 @@
         sprintf(destroy_server_splitmsg, "%s %s", srv->parent->name, srv->name);
 
-    /* now remove each client on the server, and remove all servers on the
-     * server.  this is recursive.  neat */
-    cp = LIST_FIRST(ircd.lists.clients);
-    while (cp != NULL) {
-        cp2 = LIST_NEXT(cp, lp);
-        if (cp->server == srv) {
-            cp->flags |= IRCD_CLIENT_KILLED | IRCD_CLIENT_SQUIT;
-            destroy_client(cp, destroy_server_splitmsg);
+    if (SERVER_REGISTERED(srv)) {
+        /* First remove all its attached servers, this runs recursively and
+         * will send out SQUITs and QUITs and all that gack for servers that
+         * are NOQUIT-dumb */
+        sp = LIST_FIRST(ircd.lists.servers);
+        while (sp != NULL) {
+            sp2 = LIST_NEXT(sp, lp);
+            if (sp->parent == srv)
+                destroy_server(sp, msg);
+            sp = sp2;
         }
-        cp = cp2;
-    }
-    sp = LIST_FIRST(ircd.lists.servers);
-    while (sp != NULL) {
-        sp2 = LIST_NEXT(sp, lp);
-        if (sp->parent == srv)
-            destroy_server(sp, msg, source);
-        sp = sp2;
-    }
-
-    if (SERVER_REGISTERED(srv)) {
+
+        /* Now remove all the clients from this server */
+        cp = LIST_FIRST(ircd.lists.clients);
+        while (cp != NULL) {
+            cp2 = LIST_NEXT(cp, lp);
+            if (cp->server == srv) {
+                cp->flags |= IRCD_CLIENT_KILLED;
+                /* Send out QUITs for servers that are not 'NOQUIT' enabled.
+                 * In doing so we send QUITs to *everything* that doesn't do
+                 * NOQUIT, including the source of the SQUIT! The only place
+                 * we don't send towards is srv, since we believe this will
+                 * be handled properly downstream.  That is, NOQUIT makes
+                 * the strange assumption that every server in the path of a
+                 * SQUIT knows all about the server being squit, but other
+                 * servers not in the path might not.  Why/how this makes
+                 * sense is a mystery to me, and this is *really* spammy. */
+                sendto_serv_pflag_butone(PROTOCOL_SFL_NOQUIT, false, srv,
+                        cp, NULL, NULL, "QUIT", ":%s",
+                        destroy_server_splitmsg);
+                destroy_client(cp, destroy_server_splitmsg);
+            }
+            cp = cp2;
+        }
+
         ircd.stats.servers--;
         if (srv->conn != NULL)
             ircd.stats.serv.servers--;
-        LIST_REMOVE(srv, lp);
-    }
-
-    /* Send the SQUIT for this server, last but not least. */
-    if (SERVER_REGISTERED(srv)) {
+
+        /* Send the SQUIT for this server, last but not least. */
         /* Some servers are really dumb.  For servers which properly support
          * NOQUIT we can simply send a single SQUIT for the first-tier
          * server.  For other servers (dreamforge is stupid like this) we
-         * have to send a SQUIT for *every single server* that goes away. */
+         * have to send a SQUIT for *every single server* that goes away,
+         * and we do it in the same fashion as when sending out QUITs, that
+         * is, everything but srv will get a SQUIT, even if it might not
+         * need it (see above commentary) */
         if (destroy_server_count == 1)
-            sendto_serv_butone(source, NULL, NULL, srv->name, "SQUIT", msg);
+            sendto_serv_butone(srv, NULL, NULL, srv->name, "SQUIT",
+                    ":%s", ircd.me->name);
         else
-            sendto_serv_pflag_butone(PROTOCOL_SFL_NOQUIT, false, source,
-                    NULL, NULL, srv->name, "SQUIT", msg);
-    }
-
-    /* if this server is ours, we have to close the connection.  also, we
-     * should try as best we can to flush the buffer.  this probably won't work
-     * very well, but we take a stab at it. */
+            sendto_serv_pflag_butone(PROTOCOL_SFL_NOQUIT, false, srv,
+                    NULL, NULL, srv->name, "SQUIT", ":%s", ircd.me->name);
+
+        /* Lastly, remove 'srv' from the list of servers */
+        LIST_REMOVE(srv, lp);
+    }
+
+    /* If this server is ours we have to close the connection.  We try first
+     * to flush the sendq.  If sendq_flush returns 0 it has closed the
+     * connection for us (socket error), otherwise we close it ourself. */
     if (MYSERVER(srv)) {
-        if (sendq_flush(srv->conn)) {
-            srv->conn->srv = NULL;
+        srv->conn->srv = NULL;
+        if (sendq_flush(srv->conn))
             destroy_connection(srv->conn, msg);
-        }
     }
 
@@ -172 +193 @@
     /* XXX: we should perform more stringement protocol checks. */
     sendto_serv_from(srv, NULL, NULL, NULL, "PROTOCOL", "%s",
-            s == NULL ?  "bahamut14" : s);
+            s == NULL ?  "ithildin1" : s);
 
     /* send them our password unless we're using SSL for the server, in which
@@ -272 +293 @@
         LIST_REMOVE(sp->conn, lp);
         LIST_INSERT_HEAD(ircd.connections.servers, sp->conn, lp);
+        
+        /* clean out the password area */
+        if (sp->conn->pass != NULL) {
+            free(sp->conn->pass);
+            sp->conn->pass = NULL;
+        }
     }
 
@@ -494 +521 @@
                 "connection to server %s failed (%s)", sp->name,
                 socket_strerror(sock));
-        destroy_server(sp, "", NULL);
+        destroy_server(sp, "");
         scp->srv = NULL; /* don't forget to unset this */
 

branches/ithildin-scons/modules/ircd/server.h

@@ -88 +88 @@
 
 server_t *create_server(connection_t *);
-void destroy_server(server_t *, char *, server_t *);
+void destroy_server(server_t *, char *);
 server_t *find_server(char *);
 

branches/ithildin-scons/modules/ircd/support.c

@@ -35 +35 @@
     ip = malloc(sizeof(struct isupport));
     memset(ip, 0, sizeof(struct isupport));
-    ip->name = strdup(name);
+    strlcpy(ip->name, name, ISUPPORTNAME_MAXLEN + 1);
     /* now insert into a list.  we alphabetically sort our list, just
      * because I like to. :) */
@@ -84 +84 @@
     if (ip != NULL) {
         LIST_REMOVE(ip, lp);
-        free(ip->name);
         if (!(ip->flags & ISUPPORT_FL_PRIV) && ip->value.str != NULL)
             free(ip->value.str);
@@ -127 +126 @@
             slen = tc = 0;
         }
-        slen += sprintf(str + slen, " %s", token);
+        
+        /* tricky code here to prevent sending an additional space at the
+         * beginning of the line when one is not needed. */
+        slen += sprintf(str + slen, (slen ? " %s" : "%s"), token);
     }
     /* send remnants */
@@ -144 +146 @@
  * fifth is a description of the handler (usually short).  The function returns
  * non-zero upon successful installation. */
-int add_xinfo_handler(xinfo_func func, char *name, int flags,
-        void *udata, char *desc) {
+int add_xinfo_handler(xinfo_func func, char *name, int flags, char *desc) {
     struct xinfo_handler *xhp = find_xinfo_handler(name);
+    uint64_t i64 = 1;
+    char privname[XINFONAME_MAXLEN + 1 + 6]; /* add 6 for "xinfo-" tag */
 
     if (xhp != NULL)
@@ -153 +156 @@
     xhp = malloc(sizeof(struct xinfo_handler));
     xhp->func = func;
-    xhp->name = strdup(name);
+    strlcpy(xhp->name, name, XINFONAME_MAXLEN + 1);
     xhp->flags = flags;
-    if (xhp->flags & XINFO_HANDLER_PRIV)
-        xhp->priv = *(int *)udata;
-    else
-        xhp->priv = -1;
+
+    /* Create a privilege for them.  Always bool, this is simply a "yes/no"
+     * flag to whether or not this information is available.  Always default
+     * to 1 */
+    sprintf(privname, "xinfo-%s", xhp->name);
+    xhp->priv = create_privilege(privname, PRIVILEGE_FL_BOOL, &i64, NULL);
+
     xhp->desc = strdup((desc != NULL ? desc : "no description"));
 
@@ -206 +212 @@
         if (xhp->func == func) {
             LIST_REMOVE(xhp, lp);
-            free(xhp->name);
             free(xhp->desc);
             free(xhp);

branches/ithildin-scons/modules/ircd/support.h

@@ -11 +11 @@
 #define IRCD_SUPPORT_H
 
+#define ISUPPORTNAME_MAXLEN 31 /* XXX: what does the spec say, if anything,
+                                  about this...? */
+
 /* a feature may have a straightforward string value, or it may have a value
  * which is connect-time dependent.  features which are connect-time dependent
  * are assumed to be privileges, but see below. */
 struct isupport {
-    char    *name;        /* name of the feature supported. */
+    char name[ISUPPORTNAME_MAXLEN + 1];
     union {
         char *str;        /* string value */
@@ -47 +50 @@
         char **argv __UNUSED)
 
+#define XINFONAME_MAXLEN ISUPPORTNAME_MAXLEN
+
 /* The xinfo_handler structure contains a each xinfo handler's necessary
  * details. */
 struct xinfo_handler {
-    char *name;
+    char name[XINFONAME_MAXLEN + 1];
     char *desc;
 #define XINFO_HANDLER_LOCAL 0x1
 #define XINFO_HANDLER_OPER  0x2
-#define XINFO_HANDLER_PRIV  0x4
     int flags;
-    int priv; /* privilege, if any */
+    int priv; /* privilege */
     xinfo_func func;
 
@@ -64 +68 @@
 #define XINFO_LEN 512
 
-int add_xinfo_handler(xinfo_func, char *, int, void *, char *);
+int add_xinfo_handler(xinfo_func, char *, int, char *);
 struct xinfo_handler *find_xinfo_handler(char *);
 void remove_xinfo_handler(xinfo_func);

branches/ithildin-scons/modules/log/log.c

@@ -126 +126 @@
 
                     if ((lhp->file = fopen(fname, "a")) == NULL) {
+                        /* Be sure to set DEFUNCT *first* to avoid nasty log
+                         * recursion!  This way when we come back around to
+                         * this rule we will not hit it again. */
+                        lhp->flags |= LOG_FL_DEFUNCT;
                         log_error("cannot open logfile %s: %s",
                                 lhp->filename, strerror(errno));
-                        lhp->flags |= LOG_FL_DEFUNCT;
                     }
                 }