Changeset 818

Timestamp:

09/21/08 22:00:54 (4 years ago)

Author:

wd

Message:

• Make RFC1459 the default protocol
• Add PROTOCOL command
• Add WEBIRC support for Mibbit

Location:

branches/ithildin-1.1/modules/ircd

Files:

• addons/hostmask.c (modified) (1 diff)
• commands/protocol.c (added)
• commands/user.c (modified) (1 diff)
• commands/webirc.c (added)
• conf/commands.conf (modified) (2 diffs)
• connection.c (modified) (2 diffs)
• ircd.c (modified) (3 diffs)
• protocol.c (modified) (2 diffs)
• protocols/rfc1459.c (modified) (1 diff)

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

@@ -83 +83 @@
     if (mask != NULL && *mask != '\0') {
         if (!strcasecmp(mask, CGI_IRC_SPECIAL_MASK)) {
-            /* Special CGI:IRC hack.  We take the password, if supplied, an
+            /* Special CGI:IRC hack.  We take the password, if supplied, and
              * use it as a hostname (as long as it's valid).  Good stuff. */
             if (cli->conn->pass != NULL && *cli->conn->pass != '\0' &&

branches/ithildin-1.1/modules/ircd/commands/user.c

@@ -53 +53 @@
         strcpy(u, "null");
 
-    /* fill in other stuff */
-    strncpy(cli->host, cp->host, HOSTLEN);
+    /* fill in other stuff if it hasn't already been set */
+    if (*cli->host == '\0')
+        strncpy(cli->host, cp->host, HOSTLEN);
     strncpy(cli->info, argv[4], GCOSLEN);
     cli->server = ircd.me;

branches/ithildin-1.1/modules/ircd/conf/commands.conf

@@ -128 +128 @@
     //command pong;        // (required by addons/core)
 
+    //command protocol; // allows unregistered clients to change their
+                        // protocol (required by proto/rfc1459)
+
     //command quit;        // allows users to sign off the server (required by
                         // addons/core)
@@ -197 +200 @@
 
     command watch;        // adds 'server-side notify' support.
+
+    /*
+    // This command enables WEBIRC command support (largely for Mibbit).
+    // You must specify the correct originating IP and the password you
+    // expect sent for authentication purposes.
+    command webirc {
+        ip 67.207.141.120;
+        password "your-mibbit-password";
+    };
+    */
 
     command who;        // allows users to get short-form information

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

@@ -362 +362 @@
     /* now stick them in the default protocol */
     c->proto = ircd.default_proto;
+    c->proto->setup(c);
     c->last = me.now;
     /* and monitor them */
@@ -436 +437 @@
         /* 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
+         * I think, potentially falsely, that it may be beneficial to batch
          * writes and reads in this manner. */
         c->flags |= IRCD_CONNFL_WRITEABLE;

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

@@ -383 +383 @@
     ircd.events.started = create_event(EVENT_FL_HOOKONCE);
 
-    /* setup our default protocol.  if we didn't save it, then we allocate it
-     * fresh, and fill in the name only.  we set up the input no matter what
-     * because function addresses may change. */
-    if (!get_module_savedata(savelist, "ircd.default_proto",
-                &ircd.default_proto)) {
-        ircd.default_proto = malloc(sizeof(protocol_t));
-        memset(ircd.default_proto, 0, sizeof(protocol_t));
-        ircd.default_proto->name = strdup("default");
-    }
-    ircd.default_proto->input = protocol_default_input;
-    if (LIST_EMPTY(ircd.lists.protocols))
-        LIST_INSERT_HEAD(ircd.lists.protocols, ircd.default_proto, lp);
-
     /* grab the timer hook to see if connections have timed out */
     timer_ref = create_timer(-1, timer_fuzz, ircd_timer_hook, NULL);
@@ -511 +498 @@
     if (!reload && !ircd_parse_conf(conf))
         return 0;
+
+    /* setup our default protocol (rfc1459). */
+#define DEFAULT_PROTOCOL "rfc1459"
+    if (find_protocol(DEFAULT_PROTOCOL) == NULL &&
+        !add_protocol(DEFAULT_PROTOCOL)) {
+        log_error("could not load rfc1459 protocol?");
+        return 0;
+    }
+    ircd.default_proto = find_protocol(DEFAULT_PROTOCOL);
 
     if (!ircd.started) {
@@ -635 +631 @@
         add_module_savedata(savelist, "ircd.privileges",
                 sizeof(ircd.privileges), &ircd.privileges);
-        add_module_savedata(savelist, "ircd.default_proto",
-                sizeof(ircd.default_proto), &ircd.default_proto);
         add_module_savedata(savelist, "ircd.lists", sizeof(ircd.lists),
                 &ircd.lists);

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

@@ -14 +14 @@
 
 IDSTRING(rcsid, "$Id$");
-
-/* this function, defined below, and the one defined immediately below here are
- * the default packet parsers.  The default packets resemble rfc1459 strongly.
- * The actual packet parser is a bit pickier about what gets passed along,
- * however. */
-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) {
-    isocket_t *sp = (isocket_t *)data;
-    connection_t *cp = (connection_t *)sp->udata;
-    int ret = 0;
-    char *s;
-
-    if (!(cp->flags & IRCD_CONNFL_STAGE2)) { /* 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';
-    }
-
-    if (cp->buflen < cp->bufsize)
-        ret = socket_read(sp, cp->buf + cp->buflen,
-                cp->bufsize - cp->buflen);
-    if (ret < 0)
-        return (void *)0; /* the error should be picked up by the handler. */
-    else if (ret == 0)
-        return (void *)0; /* nothing to do */
-
-    cp->buflen += ret;
-
-    cp->stats.recv += ret;
-    /* the rest of this was yanked almost verbatim from proto/rfc1459.c, I had
-     * done it a different way, but it ate a flaming bag of acidli when
-     * connections to servers were attempted.  Now I've split this into a
-     * pretty straightforward rfc1459 packet parser, and a command handler
-     * function which lives below */
-
-    while (cp->buflen > 0) {
-        /* if the buffer is full but no terminating character (\n) is found, we
-         * cheat */
-        if (cp->buflen == cp->bufsize) {
-            cp->buf[cp->bufsize - 1] = '\n';
-            s = cp->buf + cp->bufsize - 1;
-        } else {
-            cp->buf[cp->buflen] = '\0';
-            s = strchr(cp->buf, '\n');
-            if (s == NULL)
-                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.
-         * Bump the rest of the contents of 'buf' down if we read more than we
-         * have parsed. */
-        /* null-terminate and get rid of the [\r]\n sequence */
-        if (*(s - 1) == '\r')
-            *(s - 1) = '\0';
-        else
-            *s = '\0';
-
-        /* 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) {
-            cp->buflen -= s - cp->buf;
-            memcpy(cp->buf, s, cp->buflen);
-        } else {
-            cp->buflen = 0; /* all done */
-            *cp->buf = '\0'; /* no leftovers! */
-        }
-        if (ret == PROTOCOL_PARSE_PROTOSET)
-            return (void *)IRCD_PROTOCOL_CHANGED;
-    }
-
-    return (void *)0;
-}
-
-static int protocol_packet_parse(connection_t *cp, char *end) {
-    char *s, emsg[128];
-    int rfc1459 = 0; /* this is such a dumb hack */
-
-    cp->stats.precv++; /* another packet received.. */
-    s = cp->buf;
-    if (*s == ':') /* prefixed command?  ignore it totally! */
-        return 0;
-
-    if (!strncasecmp(cp->buf, "QUIT", 4)) {
-        destroy_connection(cp, "");
-        return IRCD_CONNECTION_CLOSED;
-    } else if (!strncasecmp(cp->buf, "PROTOCOL", 8)) {
-        /* we received a 'protocol' command.  cool.  this makes our life easy,
-         * just grab the stuff after and find a protocol if possible */
-        s += 8;
-        while (isspace(*s))
-            s++;
-        if (*s == '\0') {
-            destroy_connection(cp, "bogus protocol command");
-            return IRCD_CONNECTION_CLOSED;
-        }
-
-        /* otherwise, s points to their desired protocol */
-    } else if (!strncasecmp(s, "NICK", 4) || !strncasecmp(s, "USER", 4) ||
-                !strncasecmp(s, "PASS", 4)) {
-            /* this is probably an rfc1459 connection */
-        rfc1459 = 1;
-        s = "rfc1459";
-    } else {
-        log_debug("received weird packet for unprotocoled connection: %s",
-                cp->buf);
-        return 0;
-    }
-
-    /* s now points to our chosen protocol! joy */
-    cp->proto = find_protocol(s);
-    if (cp->proto == NULL) {
-        sprintf(emsg, "protocol %s is not supported", s);
-        destroy_connection(cp, emsg);
-        return IRCD_CONNECTION_CLOSED;
-    }
-        
-    /* call the setup function for this connection */
-    if (cp->proto->setup != NULL)
-        cp->proto->setup(cp);
-        
-    if (rfc1459) {
-        /* 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';
-
-        return PROTOCOL_PARSE_1459STOP;
-    }
-
-    return PROTOCOL_PARSE_PROTOSET;
-}
 
 protocol_t *find_protocol(char *name) {
@@ -237 +87 @@
         pp->bufsize = *i64p;
     else
-        pp->bufsize = DEFAULT_BUFFER_SIZE;
+        pp->bufsize = 512;
 }
 

branches/ithildin-1.1/modules/ircd/protocols/rfc1459.c

@@ -16 +16 @@
 @DEPENDENCIES@: ircd
 @DEPENDENCIES@: ircd/commands/nick ircd/commands/pass ircd/commands/user
+@DEPENDENCIES@: ircd/commands/protocol
 */