Changeset 801

Timestamp:

02/12/07 05:52:32 (5 years ago)

Author:

wd

Message:

Get the base/existing IRC module compiling again. Clear out old junk.

Location:

trunk/ithildin/modules/ircd

Files:

• addons/acl.c (modified) (22 diffs)
• addons/acl.h (modified) (3 diffs)
• addons/core.c (deleted)
• addons/core.h (deleted)
• addons/drone_fizzer.c (deleted)
• addons/pscan.c (deleted)
• addons/throttle.c (modified) (5 diffs)
• channel.c (modified) (16 diffs)
• channel.h (modified) (2 diffs)
• client.c (modified) (7 diffs)
• client.h (modified) (4 diffs)
• commands/akill.c (modified) (3 diffs)
• commands/trace.c (modified) (2 diffs)
• connection.c (modified) (13 diffs)
• connection.h (modified) (2 diffs)
• etc/pscan.conf (deleted)
• ircd.c (modified) (9 diffs)
• ircd.h (modified) (3 diffs)
• modconfig.h (added)
• protocol.c (modified) (3 diffs)
• server.c (modified) (2 diffs)

trunk/ithildin/modules/ircd/addons/acl.c

@@ -82 +82 @@
     /* insert into lists.. */
     LIST_INSERT_HEAD(acl.list, ap, lp);
-    if (ap->stage == ACL_STAGE_CONNECT)
-        list = acl.stage1_list;
-    else if (ap->stage == ACL_STAGE_PREREG)
-        list = acl.stage2_list;
+    if (ap->stage == ACL_STAGE_CONNECTED)
+        list = acl.connected_list;
+    else if (ap->stage == ACL_STAGE_UNREGISTERED)
+        list = acl.unregistered_list;
     else
-        list = acl.stage3_list;
+        list = acl.registered_list;
 
     if (LIST_EMPTY(list))
@@ -176 +176 @@
         rule = acl.default_rule;
 
-    if (stage == ACL_STAGE_CONNECT)
-        list = acl.stage1_list;
-    else if (stage == ACL_STAGE_PREREG)
-        list = acl.stage2_list;
+    if (stage == ACL_STAGE_CONNECTED)
+        list = acl.connected_list;
+    else if (stage == ACL_STAGE_UNREGISTERED)
+        list = acl.unregistered_list;
     else
-        list = acl.stage3_list;
+        list = acl.registered_list;
 
     /* now try and find them in the bucket. */
@@ -210 +210 @@
     
     /* and remove it from whatever list it's in */
-    if (ap->stage == ACL_STAGE_CONNECT)
-        LIST_REMOVE(ap, intlp);
-    else if (ap->stage == ACL_STAGE_PREREG)
-        LIST_REMOVE(ap, intlp);
-    else
-        LIST_REMOVE(ap, intlp);
+    LIST_REMOVE(ap, intlp);
 
     /* now free the memory */
@@ -256 +251 @@
     void *ret;
 
-    if (stage == 0 || stage == ACL_STAGE_CONNECT) {
-        cp = LIST_FIRST(ircd.connections.stage1);
+    if (stage == 0 || stage == ACL_STAGE_CONNECTED) {
+        cp = LIST_FIRST(ircd.connections.connected);
         while (cp != NULL) {
             cp2 = LIST_NEXT(cp, lp);
-            if ((ret = acl_stage1_hook(NULL, (void *)cp)) != NULL) {
+            if ((ret = acl_connected_stage_hook(NULL, (void *)cp)) != NULL) {
                 destroy_connection(cp, ret);
                 nukes++;
@@ -268 +263 @@
         }
     }
-    if (stage == 0 || stage == ACL_STAGE_PREREG) {
-        cp = LIST_FIRST(ircd.connections.stage2);
+    if (stage == 0 || stage == ACL_STAGE_UNREGISTERED) {
+        cp = LIST_FIRST(ircd.connections.unregistered);
         while (cp != NULL) {
             cp2 = LIST_NEXT(cp, lp);
-            if ((ret = acl_stage2_hook(NULL, (void *)cp)) != NULL) {
+            if ((ret = acl_unregistered_stage_hook(NULL, (void *)cp)) != NULL) {
                 destroy_connection(cp, ret);
                 nukes++;
@@ -280 +275 @@
         }
     }
-    if (stage == 0 || stage == ACL_STAGE_REGISTER) {
+    if (stage == 0 || stage == ACL_STAGE_REGISTERED) {
         cp = LIST_FIRST(ircd.connections.clients);
         while (cp != NULL) {
             cp2 = LIST_NEXT(cp, lp);
-            if ((ret = acl_stage3_hook(NULL, (void *)cp)) != NULL) {
+            if ((ret = acl_registered_stage_hook(NULL, (void *)cp)) != NULL) {
                 destroy_connection(cp, ret);
                 nukes++;
@@ -299 +294 @@
                 by, ap->type,
                 (ap->stage > 1 ? ap->user : ""), (ap->stage > 1 ? "@" : ""),
-                ap->host, ap->stage,
+                ap->host, acl_stage_int_to_str(ap->stage),
                 (ap->access == ACL_DENY ? "DENY" :
                  (ap->access == ACL_ALLOW ? "ALLOW" : "UNKNOWN")),
@@ -307 +302 @@
 }
 
-/* vi:set ts=8 sts=4 sw=4 tw=76 et: */
+/* Returns the integer representation of an ACL stage name, or 0 if the name
+ * is not understood. */
+int acl_stage_str_to_int(const char *str) {
+    int ret = 0;
+
+    /* see if it's a number first */
+    ret = str_conv_int(str, 0);
+    if (ret < 1 || ret > 3)
+        return 0;
+    else if (!strncasecmp(s, "connected", 4))
+        return ACL_STAGE_CONNECTED;
+    else if (!strncasecmp(s, "unregistered", 5))
+        return ACL_STAGE_UNREGISTERED;
+    else if (!strncasecmp(s, "registered", 3))
+        return ACL_STAGE_REGISTERED;
+
+    return 0;
+}
+
+/* Return a string representing the name of the ACL stage, or NULL if it
+ * cannot be converted. */
+const char *acl_stage_int_to_str(int stg) {
+    switch (stg) {
+    case ACL_STAGE_CONNECTED:
+        return "connected";
+    case ACL_STAGE_UNREGISTERED:
+        return "unregistered";
+    case ACL_STAGE_REGISTERED:
+        return "registered";
+    default:
+        return NULL;
+    }
+}
+
 /* handling for stage one is by far the easiest, there are no classes or
- * passwords involved.  also, stuff in stage1 should always be in a single
+ * passwords involved.  also, stuff this stage should always be in a single
  * place.  we create a hashtable, but it's mostly just a glorified list (for
  * now, anyways) */
-HOOK_FUNCTION(acl_stage1_hook) {
+HOOK_FUNCTION(acl_connected_stage_hook) {
     acl_t *ap;
     connection_t *cp = (connection_t  *)data;
@@ -319 +347 @@
     /* now match.  skip over any entries that aren't the default hash or our
      * hash. */
-    LIST_FOREACH(ap, acl.stage1_list, intlp) {
+    LIST_FOREACH(ap, acl.connected_list, intlp) {
         if (ap->hash != hash && ap->hash != ACL_DEFAULT_HASH)
             continue;
@@ -342 +370 @@
 }
 
-/* stage2 is next, and resembles stage1 except that we do class checks, and we
- * actually have a full mask now. */
-HOOK_FUNCTION(acl_stage2_hook) {
+/* the unregistered stage is next, and resembles the connected stage except
+ * that we do class checks, and we actually have a full mask now. */
+HOOK_FUNCTION(acl_unregistered_stage_hook) {
     acl_t *ap;
     connection_t  *cp = (connection_t  *)data;
@@ -358 +386 @@
      * and the ip (using hostmatch and ipmatch).  All together that is four
      * calls.  Also, our hash space is expanded. */
-    LIST_FOREACH(ap, acl.stage2_list, intlp) {
+    LIST_FOREACH(ap, acl.unregistered_list, intlp) {
         if (ap->hash != hash && ap->hash != iphash &&
                 ap->hash != ACL_DEFAULT_HASH)
@@ -383 +411 @@
 }
 
-/* stage3 is the last stage, it's nearly identical to stage2, but there is a
- * slight change for 'allow-always' type rules and passwords, also, unlike the
- * previous two, the default is to *deny* clients.  Also, unlike the other two
- * stages, while the first match *usually* wins, we do check for 'allow-always'
- * rules. */
-HOOK_FUNCTION(acl_stage3_hook) {
+/* the final stage (registered) is a client only check.  additionally rules
+ * for allow-always and passwords are available, along with rules for
+ * banning the 'gecos' field (info line) of a user.  unlike the previous two
+ * rulesets the default is to deny (in line with other IRC servers).
+ * An allow-always match will be sought even if an allow match is found. */
+HOOK_FUNCTION(acl_registered_stage_hook) {
     acl_t *ap;
     connection_t  *cp = (connection_t  *)data;
@@ -404 +432 @@
      * 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. */
-    LIST_FOREACH(ap, acl.stage3_list, intlp) {
+    LIST_FOREACH(ap, acl.registered_list, intlp) {
         if (ap->hash != hash && ap->hash != iphash &&
                 ap->hash != ACL_DEFAULT_HASH)
@@ -451 +479 @@
     }
 
-    if (ret == NULL && !LIST_EMPTY(acl.stage3_list))
+    if (ret == NULL && !LIST_EMPTY(acl.registered_list))
         return "You are not authorised to use this server.";
     return ret;
@@ -518 +546 @@
 
         clp = cep->list;
-        stg = str_conv_int(conf_find_entry("stage", clp, 1),
-                ACL_STAGE_REGISTER);
+        stg = ACL_STAGE_REGISTERED;
+        if ((s = conf_find_entry("stage", clp, 1)) != NULL) {
+            if ((stg = acl_stage_str_to_int(s)) == 0) {
+                log_warn("invalid stage %s", s);
+                continue;
+            }
+
+            /* warn about use of stage numbers */
+            if (str_conv_int(s, -1) != -1) 
+                log_warn("stage numbers in ACLs are deprecated, please "
+                         "use one of 'connected', 'unregistered' or "
+                         "'registered' instead.");
+        }
         s = conf_find_entry("access", clp, 1);
         if (s == NULL) {
@@ -646 +685 @@
                     mask = s;
                 else if (!strcasecmp(tok, "stage")) {
-                    stage = str_conv_int(s, 0);
-                    if (stage < ACL_STAGE_CONNECT ||
-                            stage > ACL_STAGE_REGISTER) {
+                    if ((stage = acl_stage_str_to_int(s)) == 0) {
                         snprintf(rpl, XINFO_LEN,
                                 "%s is not a valid stage type", s);
@@ -684 +721 @@
     /* okay, now dump them the list.. */
     switch (stage) {
-        case ACL_STAGE_PREREG:
-            list = acl.stage2_list;
+        case ACL_STAGE_UNREGISTERED:
+            list = acl.unregistered_list;
             break;
-        case ACL_STAGE_REGISTER:
-            list = acl.stage3_list;
+        case ACL_STAGE_REGISTERED:
+            list = acl.unregistered_list;
             break;
-        case ACL_STAGE_CONNECT:
+        case ACL_STAGE_CONNECTED:
         default:
-            list = acl.stage1_list;
+            list = acl.connected_list;
     }
     while (list != NULL) {
@@ -705 +742 @@
                 continue;
             snprintf(rpl, XINFO_LEN,
-                    "STAGE %d RULE %5hu ADDRESS %s%s%s ACCESS %s TYPE %s",
-                    ap->stage, ap->rule,
+                    "STAGE %s RULE %5hu ADDRESS %s%s%s ACCESS %s TYPE %s",
+                    acl_stage_int_to_str(ap->stage), ap->rule,
                     (*ap->user ? ap->user : ""), (*ap->user ? "@" : ""),
                     ap->host, (ap->access == ACL_DENY ? "DENY" :
@@ -728 +765 @@
         /* keep looping? */
         if (stage == 0) {
-            if (list == acl.stage1_list)
-                list = acl.stage2_list;
-            else if (list == acl.stage2_list)
-                list = acl.stage3_list;
+            if (list == acl.connected_list)
+                list = acl.unregistered_list;
+            else if (list == acl.unregistered_list)
+                list = acl.registered_list;
             else
                 break;
@@ -744 +781 @@
 
     LIST_ALLOC(acl.list);
-    LIST_ALLOC(acl.stage1_list);
-    LIST_ALLOC(acl.stage2_list);
-    LIST_ALLOC(acl.stage3_list);
+    LIST_ALLOC(acl.connected_list);
+    LIST_ALLOC(acl.unregisted_list);
+    LIST_ALLOC(acl.registered_list);
 
     add_xinfo_handler(xinfo_acl_handler, "ACL", XINFO_HANDLER_OPER, 
@@ -752 +789 @@
 
     /* add hooks for stage checks */
-    add_hook(ircd.events.stage1_connect, acl_stage1_hook);
-    add_hook(ircd.events.stage2_connect, acl_stage2_hook);
-    add_hook(ircd.events.stage3_connect, acl_stage3_hook);
+    add_hook(ircd.events.connection_connected, acl_connected_hook);
+    add_hook(ircd.events.connection_unregistered, acl_unregistered_hook);
+    add_hook(ircd.events.connection_registered, acl_registered_hook);
     add_hook(me.events.read_conf, acl_conf_hook);
 
@@ -766 +803 @@
         destroy_acl(LIST_FIRST(acl.list));
     LIST_FREE(acl.list);
-    LIST_FREE(acl.stage1_list);
-    LIST_FREE(acl.stage2_list);
-    LIST_FREE(acl.stage3_list);
+    LIST_FREE(acl.connected_list);
+    LIST_FREE(acl.unregistered_list);
+    LIST_FREE(acl.registered_list);
 
     remove_xinfo_handler(xinfo_acl_handler);
 
-    remove_hook(ircd.events.stage1_connect, acl_stage1_hook);
-    remove_hook(ircd.events.stage2_connect, acl_stage2_hook);
-    remove_hook(ircd.events.stage3_connect, acl_stage3_hook);
+    remove_hook(ircd.events.connection_connected, acl_connected_hook);
+    remove_hook(ircd.events.connection_unregistered, acl_unregistered_hook);
+    remove_hook(ircd.events.connection_registered, acl_registered_hook);
     remove_hook(me.events.read_conf, acl_conf_hook);
 }

trunk/ithildin/modules/ircd/addons/acl.h

@@ -12 +12 @@
 
 typedef struct acl {
-#define ACL_STAGE_CONNECT 1
-#define ACL_STAGE_PREREG 2
-#define ACL_STAGE_REGISTER 3
+#define ACL_STAGE_CONNECTED 1
+#define ACL_STAGE_UNREGISTERED 2
+#define ACL_STAGE_REGISTERED 3
     int     stage;                  /* one of 1, 2, or 3 */
 #define ACL_ACCESS_ANY -1
@@ -56 +56 @@
 
 extern struct acl_module_data {
-    struct acl_list *stage1_list;
-    struct acl_list *stage2_list;
-    struct acl_list *stage3_list;
+    struct acl_list *connected_list;
+    struct acl_list *unregistered_list;
+    struct acl_list *registered_list;
     struct acl_list *list;
 
@@ -71 +71 @@
 void acl_add_timer(acl_t *, time_t);
 void acl_force_check(int, const acl_t *, const char *, bool);
-HOOK_FUNCTION(acl_stage1_hook);
-HOOK_FUNCTION(acl_stage2_hook);
-HOOK_FUNCTION(acl_stage3_hook);
+int acl_stage_str_to_int(const char *);
+const char *acl_stage_int_to_str(int);
+HOOK_FUNCTION(acl_connected_stage_hook);
+HOOK_FUNCTION(acl_unregistered_stage_hook);
+HOOK_FUNCTION(acl_registered_stage_hook);
 
 #endif

trunk/ithildin/modules/ircd/addons/throttle.c

@@ -61 +61 @@
 static void destroy_throttle(throttle_t *);
 
-HOOK_FUNCTION(throttle_stage1_hook);
+HOOK_FUNCTION(throttle_connected_hook);
 HOOK_FUNCTION(throttle_conf_hook);
 HOOK_FUNCTION(throttle_timer_hook);
@@ -106 +106 @@
 #define THROTTLE_ERRMSG                                                        \
     "Your host is trying to (re)connect too fast -- throttled."
-HOOK_FUNCTION(throttle_stage1_hook) {
+HOOK_FUNCTION(throttle_connected_hook) {
     connection_t *cp = (connection_t *)data;
     throttle_t *tp = find_throttle(isock_raddr(cp->sock));
@@ -164 +164 @@
 
     if (tp->banned + len >= me.now)  {
-        if ((ap = find_acl(ACL_STAGE_CONNECT, ACL_DENY, cp->host,
+        if ((ap = find_acl(ACL_STAGE_CONNECTED, ACL_DENY, cp->host,
                         throttle_acl_type, ACL_DEFAULT_RULE, NULL, NULL)) == NULL) {
-            ap = create_acl(ACL_STAGE_CONNECT, ACL_DENY, cp->host,
+            ap = create_acl(ACL_STAGE_CONNECTED, ACL_DENY, cp->host,
                     throttle_acl_type, ACL_DEFAULT_RULE);
             ap->reason = strdup(THROTTLE_ERRMSG);
@@ -272 +272 @@
     LIST_ALLOC(throttle.list);
 
-    add_hook_before(ircd.events.stage1_connect, throttle_stage1_hook,
-            acl_stage1_hook);
+    add_hook_before(ircd.events.connection_connected,
+            throttle_connected_stage_hook, acl_connected_stage_hook);
     add_hook(me.events.read_conf, throttle_conf_hook);
 
@@ -288 +288 @@
     LIST_FREE(throttle.list);
 
-    remove_hook(ircd.events.stage1_connect, throttle_stage1_hook);
+    remove_hook(ircd.events.connection_connected,
+            throttle_connected_stage_hook);
     remove_hook(me.events.read_conf, throttle_conf_hook);
 }

trunk/ithildin/modules/ircd/channel.c

@@ -73 +73 @@
 void destroy_channel(channel_t *chan) {
     unsigned char *s;
-    chanmode_func changefn;
     int dummy;
 
@@ -81 +80 @@
     s = ircd.cmodes.avail;
     while (*s) {
-        changefn = (chanmode_func)getsym(ircd.cmodes.modes[*s].changefunc);
-        changefn(NULL, chan, *s, CHANMODE_CLEAR, NULL, &dummy);
+        ircd.cmodes.modes[*s].changefunc(NULL, chan, *s, CHANMODE_CLEAR, NULL, &dummy);
         s++;
     }
@@ -123 +121 @@
 
 uint64_t chanmode_request(unsigned char suggested, unsigned char *actual,
-        int flags, char *changefn, char *queryfn, size_t extra, void *extdata) {
+        int flags, chanmode_func changefn, chanmode_query_func queryfn,
+        size_t extra, void *extdata) {
     struct chanmode *md = NULL;
     int i, j;
@@ -156 +155 @@
     md->umask = 0;
     md->prefix = '\0';
-    md->changefunc = import_symbol(changefn);
-    md->queryfunc = import_symbol(queryfn);
+    md->changefunc = changefn;
+    md->queryfunc = queryfn;
     md->flags = flags;
     md->mdi = NULL;
@@ -196 +195 @@
 void chanmode_release(unsigned char mode) {
     channel_t *chan;
-    chanmode_func changefn =
-        (chanmode_func)getsym(ircd.cmodes.modes[mode].changefunc);
     int dummy;
     
     /* clear the mode from all the channels .. */
     LIST_FOREACH(chan, ircd.lists.channels, lp)
-        changefn(NULL, chan, mode, CHANMODE_CLEAR, NULL, &dummy);
+        ircd.cmodes.modes[mode].changefunc(NULL, chan, mode, CHANMODE_CLEAR, NULL, &dummy);
 
     /* we don't touch the mode or mask members because those are set elsewhere
@@ -219 +216 @@
         destroy_mdext_item(ircd.mdext.channel, ircd.cmodes.modes[mode].mdi);
     chanmode_build_lists();
+}
+
+void chanmode_update_funcs(unsigned char mode, chanmode_func changefunc,
+        chanmode_query_func queryfunc) {
+    struct chanmode *cmp = &ircd.cmodes.modes[mode];
+
+    if (cmp->avail || !cmp->mask) /* only if it exists.. */
+        return;
+
+    cmp->changefunc = changefunc;
+    cmp->queryfunc = queryfunc;
 }
 
@@ -285 +293 @@
         int *argused) {
     struct chanmode *cmp = &ircd.cmodes.modes[mode];
-    chanmode_func changefn;
 
     if (cmp->avail || !cmp->mask) /* only if it exists.. */
@@ -292 +299 @@
     /* otherwise, just try and set the mode with the given functions, returning
      * the value as requested */
-    changefn = (chanmode_func)getsym(cmp->changefunc);
-    return changefn(cli, chan, mode, CHANMODE_SET, arg, argused);
+    return cmp->changefunc(cli, chan, mode, CHANMODE_SET, arg, argused);
 }
 
@@ -299 +305 @@
         int *argused) {
     struct chanmode *cmp = ircd.cmodes.pfxmap[prefix];
-    chanmode_func changefn;
 
     if (cmp == NULL)
@@ -305 +310 @@
 
     /* found it, now set it */
-    changefn = (chanmode_func)getsym(cmp->changefunc);
-    return changefn(NULL, chan, cmp->mode, CHANMODE_SET, arg, argused);
+    return cmp->changefunc(NULL, chan, cmp->mode, CHANMODE_SET, arg, argused);
 }
 
@@ -312 +316 @@
         char *arg, int *argused) {
     struct chanmode *cmp = &ircd.cmodes.modes[mode];
-    chanmode_func changefn;
 
     if (cmp->avail || !cmp->mask) /* only if it exists.. */
@@ -319 +322 @@
     /* otherwise, just try and set the mode with the given functions, returning
      * the value as requested */
-    changefn = (chanmode_func)getsym(cmp->changefunc);
-    return changefn(cli, chan, mode, CHANMODE_UNSET, arg, argused);
+    return cmp->changefunc(cli, chan, mode, CHANMODE_UNSET, arg, argused);
 }
 
@@ -326 +328 @@
         int *argused) {
     struct chanmode *cmp = ircd.cmodes.pfxmap[prefix];
-    chanmode_func changefn;
 
     if (cmp == NULL)
@@ -332 +333 @@
 
     /* found it, now unset it */
-    changefn = (chanmode_func)getsym(cmp->changefunc);
-    return changefn(NULL, chan, cmp->mode, CHANMODE_UNSET, arg, argused);
+    return cmp->changefunc(NULL, chan, cmp->mode, CHANMODE_UNSET, arg, argused);
 }
 
@@ -339 +339 @@
         int *argused, void **state) {
     struct chanmode *cmp = &ircd.cmodes.modes[mode];
-    chanmode_query_func queryfn;
 
     if (cmp->avail || !cmp->mask) /* only if it exists.. */
@@ -345 +344 @@
 
     /* let's ask 'em about it. */
-    queryfn = (chanmode_query_func)getsym(cmp->queryfunc);
-    return queryfn(chan, mode, arg, argused, state);
+    return cmp->queryfunc(chan, mode, arg, argused, state);
 }
 

trunk/ithildin/modules/ircd/channel.h

@@ -93 +93 @@
 #define CHANMODE_NOARG      -4
 
-uint64_t chanmode_request(unsigned char, unsigned char *, int, char *,
-        char *, size_t, void *);
+uint64_t chanmode_request(unsigned char, unsigned char *, int,
+        chanmode_func, chanmode_query_func, size_t, void *);
 void chanmode_release(unsigned char);
+void chanmode_update_funcs(unsigned char, chanmode_func,
+        chanmode_query_func);
 /* ways to set and unset channel modes.  channel modes are typically set by
  * their mode character, but can also be set by prefix in the case of userflag
@@ -174 +176 @@
                                    the prefix (specified by the caller in extdata).
                                    no error checking is done on this value. */
-    msymbol_t *changefunc;      /* the symbol/function to change the mode */
-    msymbol_t *queryfunc;       /* the symbol/function to query the mode */
+    chanmode_func changefunc;  /* the symbol/function to change the mode */
+    chanmode_query_func queryfunc; /* the symbol/function to query the mode */
     int            flags;       /* flags given for this mode */
     struct mdext_item *mdi;     /* the mdext_item which describes the channel mode.

trunk/ithildin/modules/ircd/client.c

@@ -186 +186 @@
         /* only do this stuff if it's a real client, and not a fake one */
         if (cp != NULL) {
-            /* check to see if our client is stage3 okay */
-            returns = hook_event(ircd.events.stage3_connect, cp);
+            /* check to see if our client is okay */
+            returns = hook_event(ircd.events.connection_registered, cp);
             while (x < hook_num_returns) {
                 if (returns[x] != NULL) {/* denied, with a reason */
@@ -195 +195 @@
                 x++;
             }
-            /* remove our client from the stage2 list, and put it in the stage3
-             * list. */
+            /* remove our client from the unregistered list, and put it in
+             * the registered * list. */
             LIST_REMOVE(cp, lp);
             LIST_INSERT_HEAD(ircd.connections.clients, cp, lp);
@@ -315 +315 @@
 /* mode goodies below here */
 uint64_t usermode_request(unsigned char suggested, unsigned char *actual,
-        int flags, int sflag, char *changer) {
+        int flags, int sflag, usermode_func changefunc) {
     struct usermode *md = NULL;
     uint64_t allmodes = 0;
@@ -355 +355 @@
     md->avail = 0; /* mark it used */
     md->flags = flags;
-    if (changer != NULL)
-        md->changer = import_symbol(changer);
-    else
-        md->changer = NULL;
+    md->changefunc = changefunc;
     md->sflag = sflag;
     *actual = md->mode;
@@ -384 +381 @@
     ircd.umodes.modes[mode].avail = 1;
     ircd.umodes.modes[mode].flags = 0;
-    ircd.umodes.modes[mode].changer = NULL;
+    ircd.umodes.modes[mode].changefunc = NULL;
     allmodes &= ~ircd.umodes.modes[mode].mask;
 
     strcpy(ircd.umodes.avail, usermode_getstr(allmodes, 0) + 1);
+}
+
+void usermode_update_func(unsigned char mode, usermode_func changefunc) {
+    struct usermode *md = &ircd.umodes.modes[mode];
+
+    if (md->avail || !md->mask)
+        return 0;
+
+    md->changefunc = changefunc;
 }
 
@@ -467 +473 @@
     /* always call the set function.  if they're not our client, we ignore the
      * return value. */
-    if ((md->changer != NULL &&
-                !((usermode_func)getsym(md->changer))(cli, on, mode, 1, arg,
-                    argused)) && MYCLIENT(on))
+    if ((md->changefunc != NULL &&
+                !md->changefunc(cli, on, mode, 1, arg, argused)) && MYCLIENT(on))
         return 0;
     /* if they're local, not opered, and the mode is an oper mode, don't let
@@ -500 +505 @@
     /* always call the unset function.  if they're not our client, we ignore
      * the return value. */
-    if ((md->changer != NULL &&
-                !((usermode_func)getsym(md->changer))(cli, on, mode, 0, arg,
-                    argused)) && MYCLIENT(on))
+    if ((md->changefunc != NULL &&
+                !md->changefunc(cli, on, mode, 0, arg, argused)) && MYCLIENT(on))
         return 0;
 

trunk/ithildin/modules/ircd/client.h

@@ -66 +66 @@
 
 /* this registers a client on the network/server.  registering a client
- * consists of checking it against stage3 acls, placing it in a connection
+ * consists of checking it against registered acls, placing it in a connection
  * class (for real, not the default) (or dropping it if the class is full),
  * then propogating the user creation across the network, and finally
@@ -98 +98 @@
         char *, int *);
 
-uint64_t usermode_request(unsigned char, unsigned char *, int, int, char *);
+uint64_t usermode_request(unsigned char, unsigned char *, int, int,
+        usermode_func);
 
 /* use this function to release a mode if you no longer care about it being set
@@ -104 +105 @@
  * had one */
 void usermode_release(unsigned char);
+
+/* this function provides a way to update the assigned function for a
+ * usermode */
+void usermode_update_func(unsigned char, usermode_func);
 
 /* this function returns a mode string from the passed 64bit integer. the
@@ -147 +152 @@
     int     flags;                  /* flags for the usermode */
     uint64_t mask;                  /* the bitmask for the mode */
-    msymbol_t *changer;             /* the changer function for the mode */
+    usermode_func changefunc;       /* the changer function for the mode */
     int     sflag;                  /* send flag (if any) for this mode. */
 };

trunk/ithildin/modules/ircd/commands/akill.c

@@ -49 +49 @@
 #define ACL_DEL 1
     int op = ACL_ADD;
-    int stage = ACL_STAGE_REGISTER;
+    int stage = ACL_STAGE_REGISTERED;
     time_t expire = 0;
     char *reason = NULL;
@@ -123 +123 @@
         }
 
-        stage = ACL_STAGE_CONNECT;
+        stage = ACL_STAGE_CONNECTED;
         type = acl_szline_type;
         strlcpy(mask, argv[1], HOSTLEN + 1);
@@ -141 +141 @@
         }
 
-        stage = ACL_STAGE_CONNECT;
+        stage = ACL_STAGE_CONNECTED;
         type = acl_szline_type;
         strlcpy(mask, argv[1], HOSTLEN + 1);

trunk/ithildin/modules/ircd/commands/trace.c

@@ -125 +125 @@
      * fairly valueless, especially on big servers, and there are other ways to
      * get full listings.  Only dump unknowns/opers/servers/classes for now */
-    LIST_FOREACH(connp, ircd.connections.stage1, lp)
+    LIST_FOREACH(connp, ircd.connections.connected, lp)
         sendto_one(cli, RPL_FMT(cli, RPL_TRACEUNKNOWN), connp->cls->name,
                 connp->host, me.now - connp->last);
-    LIST_FOREACH(connp, ircd.connections.stage2, lp)
+    LIST_FOREACH(connp, ircd.connections.unregistered, lp)
         sendto_one(cli, RPL_FMT(cli, RPL_TRACEUNKNOWN), connp->cls->name,
                 connp->host, me.now - connp->last);
@@ -147 +147 @@
                 scnt++;
         sp = connp->srv;
-        sendto_one(cli, RPL_FMT(cli, RPL_TRACESERVER), connp->cls->name, cnt,
-                scnt, sp->name, "*", me.now - connp->last);
+        sendto_one(cli, RPL_FMT(cli, RPL_TRACESERVER), connp->cls->name, scnt,
+                cnt, sp->name, "*", me.now - connp->last);
     }
     LIST_FOREACH(clsp, ircd.lists.classes, lp) {

trunk/ithildin/modules/ircd/connection.c

@@ -22 +22 @@
 IDSTRING(rcsid, "$Id$");
 
-static void connection_stage2_done(connection_t *);
-static void connection_init_lookups(connection_t *);
+static void connection_init_done(connection_t *);
 
 void destroy_connection(connection_t *c, char *reason) {
@@ -71 +70 @@
 }
 
-/* this function closes all 'unknown' (stage1/stage2) connections, handy in
- * various places. */
+/* this function closes all 'unknown' (connected/unregistered) connections,
+ * handy in various places. */
 int close_unknown_connections(char *reason) {
     connection_t *cp;
     int count = 0;
 
-    while (!LIST_EMPTY(ircd.connections.stage1)) {
-        cp = LIST_FIRST(ircd.connections.stage1);
+    while (!LIST_EMPTY(ircd.connections.connected)) {
+        cp = LIST_FIRST(ircd.connections.connected);
         destroy_connection(cp, reason);
         count++;
     }
-    while (!LIST_EMPTY(ircd.connections.stage2)) {
-        cp = LIST_FIRST(ircd.connections.stage2);
+    while (!LIST_EMPTY(ircd.connections.unregistered)) {
+        cp = LIST_FIRST(ircd.connections.unregistered);
         destroy_connection(cp, reason);
         count++;
@@ -122 +121 @@
         return 0;
     }
+
     return 1;
 }
@@ -129 +129 @@
     isocket_t *sp = NULL;
     isocket_t *listener = (isocket_t *)data;
-    void **returns;
-    int x;
-    int dead;
 
     while ((sp = socket_accept(listener)) != NULL) {
@@ -143 +140 @@
 
         add_to_class(LIST_FIRST(ircd.lists.classes), c);
-        LIST_INSERT_HEAD(ircd.connections.stage1, c, lp);
-
-        /* check for stage 1 access */
-        returns = hook_event(ircd.events.stage1_connect, c);
-        x = 0;
-        dead = 0;
-        while (x < hook_num_returns) {
-            if (returns[x] != NULL) {
-                /* this is not an allowed connection, drop it with the given
-                 * error message. */
-                destroy_connection(c, returns[x]);
-                dead = 1;
-                break;
-            }
-            x++;
-        }
-
-        if (dead)
-            continue; /* connection was dropped above */
-
+        LIST_INSERT_HEAD(ircd.connections.connected, c, lp);
         add_hook(sp->datahook, ircd_connection_datahook);
 
-        /* success?  do auth-stuff */
+        /* Check first for SSL goodies */
 #ifdef HAVE_OPENSSL
         if (SOCKET_SSL(listener)) {
             if (socket_ssl_enable(c->sock)) {
                 if (socket_ssl_accept(c->sock)) {
-                    if (!SOCKET_SSL_HANDSHAKING(c->sock))
-                        connection_init_lookups(c); /* handshake is done? */
-                    else
+                    if (SOCKET_SSL_HANDSHAKING(c->sock)) {
+                        /* handshake isn't done... we have to defer the
+                         * event calling */
                         c->flags |= IRCD_CONNFL_SSLINIT;
-                    continue; /* handshake isn't done. */
+                        continue;
+                    }
                 }
             }
@@ -183 +162 @@
 #endif
 
-        connection_init_lookups(c);
+        connection_init_done(c);
+
     }
 
@@ -189 +169 @@
 }
 
-/* this is used to initialize the stage2 lookups.  it is kept separate so that
- * SSL accepts can be done prior to the data sending. */
-static void connection_init_lookups(connection_t *c) {
-    char msg[256];
-
-    if (!(c->flags & IRCD_CONNFL_DNS)) {
-        sprintf(msg, ":%s NOTICE AUTH :*** Looking up your hostname...\r\n",
-                ircd.me->name);
-        socket_write(c->sock, msg, strlen(msg));
-        dns_lookup(DNS_C_IN, DNS_T_PTR, c->host, connection_lookup_hook);
-    }
-    if (!(c->flags & IRCD_CONNFL_IDENT)) {
-        sprintf(msg, ":%s NOTICE AUTH :*** Checking Ident...\r\n",
-                ircd.me->name);
-        socket_write(c->sock, msg, strlen(msg));
-        check_ident(c->sock, connection_ident_hook);
-    }
-    if (IRCD_CONN_DONE(c) && IRCD_CONN_NEED_STAGE2(c))
-        connection_stage2_done(c);
-}
-
-/* this function handles receiving/sending of lookups.  the first time it is
- * called for a socket it will either have a successful ptr lookup or a
- * failure.  if the ptr lookup is successful it then performs a host lookup on
- * the host returned.  if that lookup succeeds the connection's hostname is set
- * to that, otherwise in any case of failure the connection's hostname is set
- * to its IP address */
-HOOK_FUNCTION(connection_lookup_hook) {
-    dns_lookup_t *dlp = (dns_lookup_t *)data;
-    struct dns_rr *drp;
-    connection_t *c, *c2;
-    char msg[256];
-    char ip[FQDN_MAXLEN];
-
-    c = LIST_FIRST(ircd.connections.stage1);
-    while (c != NULL) {
-        c2 = LIST_NEXT(c, lp);
-
-        if (dlp->type == DNS_T_PTR) {
-            /* this was a reverse lookup.  skip hosts doing address lookups and
-             * non-matching connections. */
-            if (c->flags & IRCD_CONNFL_DNS || strcasecmp(c->host, dlp->data)) {
-                c = c2;
-                continue;
-            }
-
-            /* this connection matches.  look for a ptr record. */
-            drp = LIST_FIRST(&dlp->rrs.an);
-            while (drp != NULL) {
-                /* Use the first PTR answer we get. */
-                if (drp->type == DNS_T_PTR)
-                    break;
-                drp = LIST_NEXT(drp, lp);
-            }
-            if (dlp->flags & DNS_LOOKUP_FL_FAILED || drp == NULL) {
-                sprintf(msg, ":%s NOTICE AUTH :*** Couldn't find your "
-                        "hostname.\r\n", ircd.me->name);
-                socket_write(c->sock, msg, strlen(msg));
-                c->flags |= IRCD_CONNFL_DNS;
-            } else {
-                strlcpy(c->host, drp->rdata.txt, HOSTLEN + 1);
-                c->flags |= IRCD_CONNFL_DNS_PTR;
-                dns_lookup(DNS_C_IN, (c->sock->peeraddr.family == PF_INET6
-                            ? DNS_T_AAAA : DNS_T_A), c->host,
-                        connection_lookup_hook);
-            }
-        } else {
-            dns_type_t atype;
-
-            /* this was a forward lookup.  skip reverses and non-matching
-             * connections as above. */
-            if (!(c->flags & IRCD_CONNFL_DNS) ||
-                    strcasecmp(c->host, dlp->data)) {
-                c = c2;
-                continue;
-            }
-
-            get_socket_address(isock_raddr(c->sock), ip, FQDN_MAXLEN, NULL);
-            /* a match.  look for the right A or AAAA record.  there may, in
-             * this case, be several of them. */
-            atype = (c->sock->peeraddr.family == PF_INET6 ?
-                    DNS_T_AAAA : DNS_T_A);
-            drp = LIST_FIRST(&dlp->rrs.an);
-            while (drp != NULL) {
-                /* Check each answer.. */
-                if (drp->type == atype &&
-                        !strcasecmp(drp->rdata.txt, ip))
-                    break;
-                drp = LIST_NEXT(drp, lp);
-            }
-            if (dlp->flags & DNS_LOOKUP_FL_FAILED || drp == NULL) {
-                sprintf(msg, ":%s NOTICE AUTH :*** Couldn't find your "
-                        "hostname.\r\n", ircd.me->name);
-                socket_write(c->sock, msg, strlen(msg));
-                c->flags |= IRCD_CONNFL_DNS;
-                strcpy(c->host, ip);
-            } else {
-                sprintf(msg, ":%s NOTICE AUTH :*** Found your hostname.\r\n",
-                        ircd.me->name);
-                if (!istr_okay(ircd.maps.host, c->host)) {
-                    sprintf(msg, ":%s NOTICE AUTH :*** Found your hostname, "
-                            "but it contains invalid characters.  Using IP "
-                            "instead.\r\n", ircd.me->name);
-                    /* log a warning, too */
-                    log_warn("bad hostname from %s: %s", ip, c->host);
-                    strcpy(c->host, ip);
-                }
-                socket_write(c->sock, msg, strlen(msg));
-                c->flags |= IRCD_CONNFL_DNS_ADDR;
-            }
-        }
-        if (IRCD_CONN_DONE(c) && IRCD_CONN_NEED_STAGE2(c))
-            connection_stage2_done(c);
-
-        c = c2;
-    }
-
-    return NULL;
-}
-
-HOOK_FUNCTION(connection_ident_hook) {
-    struct ident_request *i = (struct ident_request *)data;
-    connection_t *c;
-    char msg[256];
-
-    /* try and find our socket. */
-    LIST_FOREACH(c, ircd.connections.stage1, lp) {
-        if (!memcmp(isock_laddr(c->sock), &i->laddr,
-                    sizeof(struct isock_address)) &&
-                !memcmp(isock_raddr(c->sock), &i->raddr,
-                    sizeof(struct isock_address)))
-            break; /* found it */
-    }
-    if (c == NULL)
-        return NULL; /* didn't find it. */
-
-    c->flags |= IRCD_CONNFL_IDENT;
-    if (!strcmp(i->answer, "")) {
-        strcpy(c->user, "~");
-        sprintf(msg, ":%s NOTICE AUTH :*** No Ident response.\r\n",
-                ircd.me->name);
-    } else {
-        strncpy(c->user, i->answer, USERLEN);
-        sprintf(msg, ":%s NOTICE AUTH :*** Got Ident response.\r\n",
-                ircd.me->name);
-    }
-
-    socket_write(c->sock, msg, strlen(msg));
-    if (IRCD_CONN_DONE(c) && IRCD_CONN_NEED_STAGE2(c))
-        connection_stage2_done(c);
-
-    return NULL;
-}
-
-static void connection_stage2_done(connection_t *c) {
+/* Called when the initial work on a connection should be done. */
+static void connection_init_done(connection_t *c) {
+    void **returns;
+    int x;
+
+    /* check for preliminary connection access */
+    returns = hook_event(ircd.events.connection_connected, c);
+    x = 0;
+    while (x < hook_num_returns) {
+        if (returns[x] != NULL) {
+            /* this is not an allowed connection, drop it with the given
+             * error message. */
+            destroy_connection(c, returns[x]);
+            break;
+        }
+        x++;
+    }
+}
+
+bool connection_set_unregistered(connection_t *c) {
     void **returns;
     int x = 0;
 
-    returns = hook_event(ircd.events.stage2_connect, c);
+    returns = hook_event(ircd.events.connection_unregistered, c);
     while (x < hook_num_returns) {
         if (returns[x] != NULL) {
@@ -353 +198 @@
              * structure. */
             destroy_connection(c, (char *)returns[x]);
-            return;
+            return false;
         }
         x++;
     }
     LIST_REMOVE(c, lp);
-    LIST_INSERT_HEAD(ircd.connections.stage2, c, lp);
+    LIST_INSERT_HEAD(ircd.connections.unregistered, c, lp);
 
     /* now stick them in the default protocol */
@@ -365 +210 @@
     /* and monitor them */
     socket_monitor(c->sock, SOCKET_FL_READ|SOCKET_FL_WRITE);
+
+    return true;
 }
 
@@ -380 +227 @@
         }
         c->flags &= ~IRCD_CONNFL_SSLINIT;
-        connection_init_lookups(c);
+        connection_init_done(c);
         return NULL;
-    } else if (!IRCD_CONN_DONE(c)) {
-        log_debug("!IRCD_CONN_DONE(%p) caught! (flags %x)", c, c->flags);
-        return NULL; /* ignore unfinished connections */
-    }
+    }
+    /* XXX: removed debug message for hooks when the connection isn't
+     * completed.  we probably don't need this anymore... */
 #endif
             
@@ -463 +309 @@
 
     /* handle sendqs for each of our three connection stages, in order */
-    cp = LIST_FIRST(ircd.connections.stage1);
+    cp = LIST_FIRST(ircd.connections.connected);
     while (cp != NULL) {
         cp2 = LIST_NEXT(cp, lp);
@@ -469 +315 @@
         cp = cp2;
     }
-    cp = LIST_FIRST(ircd.connections.stage2);
+    cp = LIST_FIRST(ircd.connections.unregistered);
     while (cp != NULL) {
         cp2 = LIST_NEXT(cp, lp);
@@ -492 +338 @@
     return NULL;
 }
+
 /* vi:set ts=8 sts=4 sw=4 tw=76 et: */

trunk/ithildin/modules/ircd/connection.h

@@ -46 +46 @@
     } stats;
 
-#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)) ==                  \
-     (IRCD_CONNFL_DNS | IRCD_CONNFL_IDENT))
-#define IRCD_CONN_NEED_STAGE2(x) (!((x)->flags & IRCD_CONNFL_STAGE2))
-
 #define IRCD_CONNFL_WRITEABLE 0x100 /* set if the socket is writeable */
 #define CONN_PINGSENT(conn) (conn->flags & IRCD_CONNFL_PINGSENT)
@@ -81 +71 @@
 };
 
+bool connection_set_unregistered(connection_t *);
+bool connection_set_registered(connection_t *);
+
 void destroy_connection(connection_t *, char *);
 int close_unknown_connections(char *);
 int sendq_flush(connection_t *);
 
-HOOK_FUNCTION(connection_lookup_hook);
-HOOK_FUNCTION(connection_ident_hook);
 HOOK_FUNCTION(ircd_connection_datahook);
 HOOK_FUNCTION(ircd_writer_hook);

trunk/ithildin/modules/ircd/ircd.c

@@ -18 +18 @@
 IDSTRING(rcsid, "$Id$");
 
-MODULE_REGISTER(PACKAGE_VERSION);
+MODULE_REGISTER(IRCD_VERSION);
 /*
 @DEPENDENCIES@: dns ident
@@ -66 +66 @@
     }
 
-    /* time out dead clients in stage2/clients based on their class */
-    cp = LIST_FIRST(ircd.connections.stage2);
+    /* XXX: does the connection timeout code actually belong in connection.c
+     * / client.c / server.c? */
+
+    /* time out or promote connections based on callback completion and
+     * class ping frequency */
+    cp = LIST_FIRST(ircd.connections.connected);
     while (cp != NULL) {
         cp2 = LIST_NEXT(cp, lp);
-        /* for stage2, drop connections 4x faster than normal, since
-         * connections should *not* sit in a stage2 situation */
+        if (callback_pending(cp->sock) == 0)
+            connection_set_unregistered(cp);
+        /* there is no connection timeout for fresh connections */
+    }
+
+    cp = LIST_FIRST(ircd.connections.unregistered);
+    while (cp != NULL) {
+        cp2 = LIST_NEXT(cp, lp);
+        /* for unregistered, drop connections 4x faster than normal, since
+         * connections should *not* sit in this state for long */
         if ((now - cp->last) > (cp->cls->freq / 4))
             destroy_connection(cp, "Ping timeout");
@@ -259 +271 @@
     if (!get_module_savedata(savelist, "ircd.connections",
                 &ircd.connections)) {
-        LIST_ALLOC(ircd.connections.stage1);
-        LIST_ALLOC(ircd.connections.stage2);
+        LIST_ALLOC(ircd.connections.connected);
+        LIST_ALLOC(ircd.connections.unregistered);
         LIST_ALLOC(ircd.connections.clients);
         LIST_ALLOC(ircd.connections.servers);
@@ -338 +350 @@
 
         /* we know that all modes are free.  grab i, o, and s */
-        EXPORT_SYM(mode_set_counter);
         ircd.umodes.i = usermode_request('i', &c, USERMODE_FL_GLOBAL, -1,
-                "mode_set_counter");
+                mode_set_counter);
         ircd.umodes.o = usermode_request('o', &c, USERMODE_FL_GLOBAL,
-                ircd.sflag.ops, "mode_set_counter");
+                ircd.sflag.ops, mode_set_counter);
         ircd.umodes.s = usermode_request('s', &c, 0, ircd.sflag.servmsg,
                 NULL);
+    } else {
+        /* Be sure to update the function address for this channel mode in
+         * case it moved.. */
+        usermode_update_func(ircd.umodes.i, mode_set_counter);
+        usermode_update_func(ircd.umodes.o, mode_set_counter);
+        usermode_update_func(ircd.umodes.s, mode_set_counter);
     }
 
@@ -357 +374 @@
      * later in *this function*. :) */
     if (!get_module_savedata(savelist, "ircd.events", &ircd.events)) {
-        ircd.events.stage1_connect = create_event(0);
-        ircd.events.stage2_connect = create_event(0);
-        ircd.events.stage3_connect = create_event(0);
+        ircd.events.connection_connected = create_event(0);
+        ircd.events.connection_unregistered = create_event(0);
+        ircd.events.connection_registered = create_event(0);
 
         ircd.events.client_connect = create_event(EVENT_FL_NORETURN);
@@ -471 +488 @@
         
     if (!get_module_savedata(savelist, "ircd.hashes", &ircd.hashes)) {
-        EXPORT_SYM(nickcmp);
-        EXPORT_SYM(chancmp);
 
         ircd.hashes.command = create_hash_table(32,
                 offsetof(struct command, name), COMMAND_MAXLEN,
-                HASH_FL_NOCASE|HASH_FL_STRING, "strncasecmp");
+                HASH_FL_NOCASE|HASH_FL_STRING,
+                (hashcmp_function_t)strncasecmp);
 
         ircd.hashes.client = create_hash_table(128, offsetof(client_t, nick),
-                NICKLEN, HASH_FL_NOCASE|HASH_FL_STRING, "nickcmp");
+                NICKLEN, HASH_FL_NOCASE|HASH_FL_STRING,
+                (hashcmp_function_t)nickcmp);
         ircd.hashes.client_history = create_hash_table(1024,
                 offsetof(struct client_history, nick), NICKLEN,
-                HASH_FL_NOCASE|HASH_FL_STRING, "nickcmp");
+                HASH_FL_NOCASE|HASH_FL_STRING,
+                (hashcmp_function_t)nickcmp);
 
         ircd.hashes.channel = create_hash_table(128, offsetof(channel_t, name),
-                CHANLEN, HASH_FL_NOCASE|HASH_FL_STRING, "chancmp");
+                CHANLEN, HASH_FL_NOCASE|HASH_FL_STRING,
+                (hashcmp_function_t)chancmp);
+    } else if (reload) {
+        ircd.hashes.client->cmpfunc = (hashcmp_function_t)nickcmp;
+        ircd.hashes.client_history->cmpfunc = (hashcmp_function_t)nickcmp;
+        ircd.hashes.channel->cmpfunc = (hashcmp_function_t)chancmp;
     }
 
     if (!get_module_savedata(savelist, "ircd.mdext", &ircd.mdext)) {
-        EXPORT_SYM(client_mdext_iter);
-        EXPORT_SYM(channel_mdext_iter);
-        EXPORT_SYM(class_mdext_iter);
-        ircd.mdext.client = create_mdext_header("client_mdext_iter");
-        ircd.mdext.channel = create_mdext_header("channel_mdext_iter");
-        ircd.mdext.class = create_mdext_header("class_mdext_iter");
+        ircd.mdext.client = create_mdext_header(client_mdext_iter);
+        ircd.mdext.channel = create_mdext_header(channel_mdext_iter);
+        ircd.mdext.class = create_mdext_header(class_mdext_iter);
+    } else if (reload) {
+        ircd.mdext.client->iter = client_mdext_iter;
+        ircd.mdext.channel->iter = channel_mdext_iter;
+        ircd.mdext.class->iter = class_mdext_iter;
     }
 
@@ -548 +572 @@
         free(ircd.argv[i]);
     free(ircd.argv);
-
-    dns_lookup_cancel(connection_lookup_hook);
-    ident_cancel(connection_ident_hook);
 
     /* close unknown connections and either remove our datahook if we're
@@ -644 +665 @@
 
         /* events ... */
-        destroy_event(ircd.events.stage1_connect);
-        destroy_event(ircd.events.stage2_connect);
-        destroy_event(ircd.events.stage3_connect);
+        destroy_event(ircd.events.connection_connected);
+        destroy_event(ircd.events.connection_unregistered);
+        destroy_event(ircd.events.connection_registered);
         destroy_event(ircd.events.client_connect);
         destroy_event(ircd.events.client_disconnect);
@@ -670 +691 @@
 
         /* And lists... */
-        LIST_FREE(ircd.connections.stage1);
-        LIST_FREE(ircd.connections.stage2);
+        LIST_FREE(ircd.connections.connected);
+        LIST_FREE(ircd.connections.unregistered);
         LIST_FREE(ircd.connections.clients);
         LIST_FREE(ircd.connections.servers);

trunk/ithildin/modules/ircd/ircd.h

@@ -149 +149 @@
 
         /* the three connection stage events, used by the acl system, and
-         * maybe others. */
-        event_t        *stage1_connect;
-        event_t        *stage2_connect;
-        event_t        *stage3_connect;
+         * maybe others.   connection_registered only fires for CLIENTS
+         * which are registered. */
+        event_t        *connection_connected;
+        event_t        *connection_unregistered;
+        event_t        *connection_registered;
 
         /* other events */
-        event_t        *client_connect;    /* called after the stage*_connect to note
+        event_t *client_connect;    /* called after connection_registered to note
                                        the connection of a (local) client */
         event_t *client_disconnect; /* called when a registered client (local)
                                        is disconnecting from the server */
-        event_t        *register_client;   /* called from register_client() for all
+        event_t *register_client;   /* called from register_client() for all
                                        connecting clients. */
         event_t *unregister_client; /* called from destroy_client() for all
@@ -170 +171 @@
                                        initially created. */
         event_t *channel_destroy;   /* same, but for destruction. */
-        event_t        *channel_add;            /* hooked when a client joins a channel */
-        event_t        *channel_del;            /* same, but with part */
-
-        event_t        *server_introduce;  /* called when server_introduce() is
+        event_t *channel_add;            /* hooked when a client joins a channel */
+        event_t *channel_del;            /* same, but with part */
+
+        event_t *server_introduce;  /* called when server_introduce() is
                                        called, the server's structure is passed
                                        as the data */
-        event_t        *server_establish;  /* called during the misc phase of
+        event_t *server_establish;  /* called during the misc phase of
                                        server_establish(), extra data that
                                        might need to be sent should be sent
                                        here! */
 
-        event_t        *can_join_channel;  /* called when the can_join_channel()
-                                       function is called.  see channel.h */
-        event_t        *can_see_channel;   /* called when the can_see_channel()
-                                       function is called.  see channel.h */
-        event_t        *can_send_channel;  /* called when the can_send_channel()
-                                       function is called.  see channel.h */
-        event_t        *can_nick_channel;  /* called when the can_nick_channel()
+        event_t *can_join_channel;  /* called when the can_join_channel()
+                                       function is called.  see channel.h */
+        event_t *can_see_channel;   /* called when the can_see_channel()
+                                       function is called.  see channel.h */
+        event_t *can_send_channel;  /* called when the can_send_channel()
+                                       function is called.  see channel.h */
+        event_t *can_nick_channel;  /* called when the can_nick_channel()
                                        function is called.  see channel.h */
 
@@ -197 +198 @@
 
     struct {
-        /* while there are three connection stages, the last one has no list
-         * as it is very brief, clients who would pass stage3 are in the, you
-         * guessed it, client list */
-        LIST_HEAD(, connection) *stage1;
-        LIST_HEAD(, connection) *stage2;
+        /* connection groupings.  connected clients are fresh off an
+         * accept(), unregistered clients have passed a set of rudimentary
+         * checks but not yet registered, and registered connections are
+         * clients.  servers share a separate list but would also be
+         * considered 'registered' */
+        LIST_HEAD(, connection) *connected;
+        LIST_HEAD(, connection) *unregistered;
 
         LIST_HEAD(, connection) *clients;
 
-        /* server connections are here, so they aren't handled with client
-         * connections (which are (assumed)stages 1/2, and (known) stage3) */
         LIST_HEAD(, connection) *servers;
     } connections;

trunk/ithildin/modules/ircd/protocol.c

@@ -32 +32 @@
     char *s;
 
-    if (!(cp->flags & IRCD_CONNFL_STAGE2)) { /* initialize the connection */
+    if (cp->buf == NULL || cp->bufsize == 0) {
+        /* initialize the connection */
         cp->buf = malloc(DEFAULT_BUFFER_SIZE);
         cp->buflen = 0;
         cp->bufsize = DEFAULT_BUFFER_SIZE;
-        cp->flags |= IRCD_CONNFL_STAGE2;
         cp->buf[0] = '\0';
     }
@@ -252 +252 @@
         return; /* don't do this here.. */
 
-    cp = LIST_FIRST(ircd.connections.stage1);
+    cp = LIST_FIRST(ircd.connections.connected);
     while (cp != NULL) {
         cp2 = LIST_NEXT(cp, lp);
@@ -259 +259 @@
         cp = cp2;
     }
-    cp = LIST_FIRST(ircd.connections.stage2);
+    cp = LIST_FIRST(ircd.connections.unregistered);
     while (cp != NULL) {
         cp2 = LIST_NEXT(cp, lp);

trunk/ithildin/modules/ircd/server.c

@@ -480 +480 @@
     cp->last = me.now;
 
-    /* put it on the stage2 list.  technically it should stay as stage2 until
+    /* put it on the unregistered list.  it should stay unregistered until
      * the negotiation is finished and server_register() is called. */
-    LIST_INSERT_HEAD(ircd.connections.stage2, cp, lp);
+    LIST_INSERT_HEAD(ircd.connections.unregistered, cp, lp);
     proto->setup(cp);
 
@@ -557 +557 @@
     remove_hook(sock->datahook, server_connecting_hook);
     sock->udata = sp->conn; /* set udata to what is expected */
-    /* also, make sure IRCD_CONN_DONE() will test positive */
-    cp->flags |= (IRCD_CONNFL_DNS | IRCD_CONNFL_IDENT);
     add_hook(sock->datahook, ircd_connection_datahook);
     scp->srv = NULL; /* all done */