Changeset 803 for trunk/ithildin/modules/ircd/usermode.c

Timestamp:

05/31/07 15:15:23 (5 years ago)

Author:

wd

Message:

Many more changes:

• Moved the 'core' addon code into various places in the main ircd module.
• Split channel/user modes out of channel.c/client.c and into chanmode.c/usermode.c respectively.
• Added init/teardown routines for channel/usermodes.
• Changed the INVIS and OPER macros to have longer(:/) and more descriptive names.

File:

• trunk/ithildin/modules/ircd/usermode.c (copied) (copied from trunk/ithildin/modules/ircd/client.c) (5 diffs)

trunk/ithildin/modules/ircd/usermode.c

@@ -1 +1 @@
 /*
- * client.c: client structure management functions
+ * usermode.c: client (user) mode management functions
  * 
- * Copyright 2002 the Ithildin Project.
+ * Copyright 2002-2007 the Ithildin Project.
  * See the COPYING file for more information on licensing and use.
  * 
- * This file provides mechanisms for creating/destroy client structures, as
- * well as registering them on the server and setting/unsetting user modes on
- * them.
+ * This file contains the generic code for manipulating user modes, as well
+ * as some base usermodes supported by the server.
  */
 
@@ -16 +15 @@
 IDSTRING(rcsid, "$Id$");
 
-/* this creates a new client structure and places it in the 'conn' structure
- * passed, if any.  If there is no conn structure, then this is either a remote
- * client or a pseudo-client. */
-client_t *create_client(connection_t *conn) {
-    client_t *cp = calloc(1, sizeof(client_t));
-    cp->conn = conn;
-
-    /* set connection time/etc */
-    cp->ts = cp->last = me.now;
-    cp->orighost = cp->host; /* don't forget this one */
-
-    cp->mdext = mdext_alloc(ircd.mdext.client);
-
-    if (conn != NULL) {
-        conn->cli = cp;
-        cp->pset = conn->cls->pset;
-        get_socket_address(isock_raddr(conn->sock), cp->ip, IPADDR_MAXLEN + 1,
-                NULL);
-        ircd.stats.serv.unkclients++;
-    } else
-        cp->pset = LIST_FIRST(ircd.privileges.sets);
-
-    LIST_INSERT_HEAD(ircd.lists.clients, cp, lp);
-    return cp;
-}
-
-/* this destroys a client, and if it is our connection, also destroys the
- * client's connection.  do *NOT* try to destroy connections after
- * destroying their clients. */
-void destroy_client(client_t *cli, char *msg) {
-    struct chanlink *clp;
-    unsigned char *s;
-
-    if (cli->flags & IRCD_CLIENT_HISTORY) {
-        /* just return the memory */
-        mdext_free(ircd.mdext.client, cli->mdext);
-        free(cli);
-        return;
-    }
-
-    if (CLIENT_REGISTERED(cli)) { /* only do this stuff for registered
-                                     clients */
-        if (MYCLIENT(cli))
-            hook_event(ircd.events.client_disconnect, cli);
-        hook_event(ircd.events.unregister_client, cli);
-
-        /* if the client hasn't been flagged as 'killed' (that is, destroyed by
-         * some other action) we propogate the quit message to other servers.
-         * whatever betide we send the quit to all local users! */
-        if (!(cli->flags & IRCD_CLIENT_KILLED))
-            sendto_serv_butone(cli->server, cli, NULL, NULL, "QUIT", ":%s",
-                    msg);
-
-        clp = LIST_FIRST(&cli->chans);
-        if (clp != NULL) {
-            /* if we are in channels */
-            /* don't send a message to our user */
-            if (MYCLIENT(cli))
-                ircd.sends[cli->conn->sock->fd] = 1;
-            sendto_common_channels(cli, NULL, "QUIT", ":%s", msg);
-            while (clp != NULL) {
-                del_from_channel(cli, clp->chan, true);
-                clp = LIST_FIRST(&cli->chans);
-            }
-        }
-
-        /* add them to the client history, and also sign them off. */
-        client_add_history(cli);
-        /* and mark the client structure as a 'history' structure */
-        cli->flags |= IRCD_CLIENT_HISTORY;
-
-        /* unset all their modes.  this allows any resource cleanup to be
-         * handled by individual mode handlers. */
-        s = ircd.umodes.avail;
-        while (*s)
-            usermode_unset(*s++, cli, cli, NULL, NULL);
-
-        if (MYCLIENT(cli)) {
-            int i;
-
-            ircd.stats.serv.curclients--;
-            for (i = 0;i < ircd.sflag.size;i++)
-                remove_from_send_flag(i, cli, true);
-        }
-        /* they would now be visible, except we're nerfing them. */
-        ircd.stats.net.visclients--;
-        ircd.stats.net.curclients--;
-    }
-
-    /* Oops.  We have to delete clients from the hashtable even if they aren't
-     * registered.  Thanks dave. */
-    if (*cli->nick != '\0')
-        hash_delete(ircd.hashes.client, cli);
-
-    if (cli->conn != NULL) { /* dump it if it's ours */
-        if (!CLIENT_REGISTERED(cli))
-            ircd.stats.serv.unkclients--;
-        cli->conn->cli = NULL;
-
-        /* 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);
-    }
-
-    LIST_REMOVE(cli, lp);
-
-    if (!CLIENT_REGISTERED(cli)) {
-        /* if the client was registered then we need to preserve their client
-         * entry for the history list */
-        mdext_free(ircd.mdext.client, cli->mdext);
-        free(cli);
-    }
-}
-
-/* this function changes a client's nickname, and performs all associations
- * necessary (moving hash structures, and adding the old nickname into the
- * client history).  It does *NOT* verify that 'to' is a suitable nickname,
- * however, as that is left up to the caller. */
-void client_change_nick(client_t *cli, char *to) {
-    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. */
-    if (*cli->nick != '\0' && !casechng) {
-        hash_delete(ircd.hashes.client, 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);
-
-        /* 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);
-    }
-}
-
-/* find a client with the given name, but only if it is registered */
-client_t *find_client(char *name) {
-    client_t *cp;
-
-    if ((cp = find_client_any(name)) != NULL && CLIENT_REGISTERED(cp))
-        return cp;
-    return NULL;
-}
-
-/* register a client, the appropriate stuff should already be filled in */
-int register_client(client_t *cli) {
-    connection_t *cp = cli->conn;
-    void **returns; /* hook returns */
-    int x = 0;
-                
-    /* determine if it is okay for them to connect.  if it is, and we allow the
-     * connection through, let the rest of the network know before we do
-     * anything else! */
-    if (MYCLIENT(cli)) {
-        /* 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 okay */
-            returns = hook_event(ircd.events.connection_registered, cp);
-            while (x < hook_num_returns) {
-                if (returns[x] != NULL) {/* denied, with a reason */
-                    destroy_client(cli, (char *)returns[x]);
-                        return IRCD_CONNECTION_CLOSED; /* not successful */
-                }
-                x++;
-            }
-            /* 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);
-            ircd.stats.serv.unkclients--;
-
-        }
-
-        cli->signon = cli->ts = me.now;
-        cli->hops = 0; /* our client, they're 0 hops from us <G> */
-
-        /* 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 */
-        ircd.stats.serv.curclients++;
-        if (ircd.stats.serv.maxclients < ircd.stats.serv.curclients)
-            ircd.stats.serv.maxclients++;
-
-        /* now welcome our client */
-        sendto_one(cli, RPL_FMT(cli, RPL_WELCOME), ircd.network_full,
-                cli->nick, cli->user, cli->host);
-        sendto_one(cli, RPL_FMT(cli, RPL_YOURHOST), ircd.me->name,
-                ircd.version);
-        sendto_one(cli, RPL_FMT(cli, RPL_CREATED), ircd.ascstart);
-        sendto_one(cli, RPL_FMT(cli, RPL_MYINFO), ircd.me->name, ircd.version,
-                ircd.umodes.avail, ircd.cmodes.avail);
-        send_isupport(cli);
-
-    } else
-        /* remote clients won't have been added to the hash, do that now */
-        hash_insert(ircd.hashes.client, cli);
-                                        
-    ircd.stats.net.visclients++; /* clients are visible by default */
-    ircd.stats.net.curclients++;
-    if (ircd.stats.net.maxclients < ircd.stats.net.curclients)
-        ircd.stats.net.maxclients++;
-
-    /* If the IP hasn't been explicitly filled in yet, set it to 0.0.0.0.  Ugh
-     * ugh ugh. :) */
-    if (*cli->ip == '\0')
-        strcpy(cli->ip, "0.0.0.0");
-
-    cli->flags |= IRCD_CLIENT_REGISTERED;
-
-    /* now introduce the client to our servers down the line, sptr should be
-     * the server the client was introduced from (possibly us) */
-    LIST_FOREACH(cp, ircd.connections.servers, lp) {
-        if (cp->srv != sptr)
-            cp->proto->register_user(cp,  cli);
-    }
-
-    /* hook for all clients */
-    hook_event(ircd.events.register_client, cli);
-    return 0;
-}
-
-int check_nickname(char *nick) {
-    char first[2] = { '\0', '\0' };
-
-    first[0] = *nick;
-    if (!istr_okay(ircd.maps.nick_first, first) ||
-            !istr_okay(ircd.maps.nick, nick))
-        return 0;
-    return 1;
-}
-
-/* this takes a mask of just about any form as input and tries to turn it into
- * something useable in the nick!user@host form.  It mangles the input, so be
- * careful. */
-char *make_client_mask(char *mask) {
-    static char fmask[NICKLEN + USERLEN + HOSTLEN + 3];
-    char *s, *nick, *user, *host;
-
-    s = mask;
-    nick = user = host = NULL;
-    if ((user = strchr(mask, '!')) != NULL) {
-        *user++ = '\0'; /* find the user portion .. */
-        nick = s; /* it is nick!user.. format */
-    }
-    if ((host = strchr((user != NULL ? user : s), '@')) != NULL) {
-        *host++ = '\0'; /* find the host portion */
-        if (user == NULL) /* it is user@host form */
-            user = s; /* so s is the user */
-    } else if (user == NULL && strpbrk(s, ".:") != NULL)
-        host = s; /* it is a plain host */
-    else
-        nick = s; /* it is a plain nickname */
-
-    /* okay, we now have nick, user, and host.  make a mask. */
-    sprintf(fmask, "%s!%s@%s",
-            (nick == NULL || *nick == '\0' ? "*" : nick),
-            (user == NULL || *user == '\0' ? "*" : user),
-            (host == NULL || *host == '\0' ? "*" : host));
-
-    return fmask;
-}
-
-int client_check_access(client_t *from, client_t *to, char *ext, event_t *ep) {
-    struct client_check_args cca;
-
-    cca.from = from;
-    cca.to = to;
-    cca.extra = ext;
-
-    return hook_cond_event(ep, &cca);
-}
-
-/* mode goodies below here */
+static USERMODE_FUNC(mode_set_counter);
+
+/* This function either initializes the usermode system or handles updates
+ * in the case of a reload. */
+void usermode_init(bool reload) {
+    uint64_t ui64 = 1;
+    unsigned char c;
+
+#define MODELOOP(from, to) do {                                               \
+    for (c = from;c <= to;c++, ui64 <<= 1) {                                  \
+        ircd.umodes.modes[c].mode = c;                                        \
+        ircd.umodes.modes[c].mask = ui64;                                     \
+        ircd.umodes.modes[c].avail = 1;                                       \
+    }                                                                         \
+} while (0)
+
+    if (reload == false) {
+        MODELOOP('a', 'z'); /* set a-z modes */
+        MODELOOP('A', 'Z'); /* and A-Z modes */
+        MODELOOP('0', '9'); /* and 0-9 modes */
+
+        /* we know that all modes are free.  grab i, o, and s */
+        ircd.umodes.mode_invis = usermode_request('i', &c, USERMODE_FL_GLOBAL,
+                -1, mode_set_counter);
+        ircd.umodes.mode_oper = usermode_request('o', &c, USERMODE_FL_GLOBAL,
+                ircd.sflag.ops, mode_set_counter);
+        ircd.umodes.mode_servmsg = 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.mode_invis, mode_set_counter);
+        usermode_update_func(ircd.umodes.mode_oper, mode_set_counter);
+        usermode_update_func(ircd.umodes.mode_servmsg, mode_set_counter);
+    }
+}
+
+void usermode_deinit(bool reload) {
+    if (reload == false) {
+        /* dump our modes */
+        usermode_release(ircd.umodes.mode_invis);
+        usermode_release(ircd.umodes.mode_oper);
+        usermode_release(ircd.umodes.mode_servmsg);
+    }
+}
+
 uint64_t usermode_request(unsigned char suggested, unsigned char *actual,
         int flags, int sflag, usermode_func changefunc) {
@@ -391 +138 @@
 
     if (md->avail || !md->mask)
-        return 0;
+        return;
 
     md->changefunc = changefunc;
@@ -478 +225 @@
     /* if they're local, not opered, and the mode is an oper mode, don't let
      * them set it. */
-    if (MYCLIENT(on) && !OPER(on) && md->flags & USERMODE_FL_OPER)
+    if (MYCLIENT(on) && !CLIENT_OPERATOR(on) && md->flags & USERMODE_FL_OPER)
         return 0; /* no no. */
 
@@ -519 +266 @@
 }
 
-static void client_remove_history(client_t *);
-
-/* this function adds a client to the client_history list.  If we've maxed out
- * on entries (we use the client_history hash table to examine this) we start
- * back at the first entry and overwrite our way forward again. */
-struct client_history *client_add_history(client_t *cli) {
-    struct client_history *chp = NULL;
-
-    /* only one history entry may point to a client at any time */
-    if (cli->hist != NULL)
-        client_remove_history(cli);
-
-    if ((chp = client_find_history(cli->nick)) != NULL)
-        /* I was having this not create a new history structure, but I've had
-         * so many problems with this code (little bugs here and there) that
-         * I've decided to go for the slightly less efficient route.  I'm tired
-         * of trying little tricks in this code to keep it fast. */
-        client_remove_history(chp->cli);
-
-   if ((hashtable_count(ircd.hashes.client_history) >=
-             hashtable_size(ircd.hashes.client_history)) &&
-            (hashtable_size(ircd.hashes.client_history) >=
-             hashtable_size(ircd.hashes.client))) {
-        /* this is the tricky one.  our table is full so we need to
-         * overwrite old entries (maybe).  if the client table is larger
-         * than the history table then we also let the history table grow,
-         * but if the two are * the same size we need to pop the oldest
-         * entry off. */
-
-        chp = TAILQ_LAST(ircd.lists.client_history, client_history_list);
-        client_remove_history(chp->cli);
-    }
-
-        chp = calloc(1, sizeof(struct client_history));
-
-    /* fill it in ... */
-    strcpy(chp->nick, cli->nick);
-    strcpy(chp->serv, cli->server->name);
-    chp->cli = cli;
-    cli->hist = chp;
-    chp->signoff = me.now;
-
-    /* insert it in the hash */
-        hash_insert(ircd.hashes.client_history, chp);
-    TAILQ_INSERT_HEAD(ircd.lists.client_history, chp, lp);
-
-    return chp;
-}
-
-/* remove the client history data for a client.  if the client structure is
- * marked as 'signed off' we also free the client structure as well. */
-static void client_remove_history(client_t *cli) {
-
-    if (cli->hist == NULL) {
-        log_error("trying to delete history for a client which has none.");
-        return;
-    }
-
-    assert(cli == cli->hist->cli);
-
-    hash_delete(ircd.hashes.client_history, cli->hist);
-    TAILQ_REMOVE(ircd.lists.client_history, cli->hist, lp);
-    free(cli->hist);
-    
-    if (cli->flags & IRCD_CLIENT_HISTORY)
-        destroy_client(cli, NULL);
-    else
-        cli->hist = NULL;
-}
-
-/* this function attempts to find the client with the given nick, first by
- * looking for the actual client, then by looking in history for it.  it
- * returns an online client structure or NULL, no matter what. */
-client_t *client_get_history(char *nick, time_t limit) {
-    struct client_history *chp;
-    client_t *cli;
-
-    if ((cli = find_client(nick)) != NULL)
-        return cli;
-
-    /* no luck?  try the client history. */
-    chp = client_find_history(nick);
-    /* if we found it and they signed off at or after the current time minus
-     * the time limit, return the entry. */
-    if (chp != NULL && !(chp->cli->flags & IRCD_CLIENT_HISTORY) &&
-            chp->signoff >= (limit ? me.now - limit : 0))
-        return chp->cli;
-
-    return NULL;
-}
-
-char **client_mdext_iter(char **last) {
-    client_t *cp = *(client_t **)last;
-    static int started = 0;
-
-    if (cp == NULL) {
-        if (started) {
-            started = 0;
-            return NULL;
-        }
-        cp = LIST_FIRST(ircd.lists.clients);
-        started = 1;
-    }
-    if (cp == NULL)
-        return NULL;
-
-    *(client_t **)last = LIST_NEXT(cp, lp);
-    return (char **)&cp->mdext;
-}
-
-int nickcmp(char *one, char *two, size_t len __UNUSED) {
-        return istrcmp(ircd.maps.nick, one, two);
+/* ***************************************************************************
+ * Code specific to individual usermodes
+ * ***************************************************************************/
+static USERMODE_FUNC(mode_set_counter) {
+    int i;
+
+    switch (mode) {
+        case 'i':
+            if (set)
+                ircd.stats.net.visclients--;
+            else
+                ircd.stats.net.visclients++;
+            break;
+        case 'o':
+            /* if this is our client, isn't set +o, and doesn't have the
+             * privilege to do, deny. */
+            if (MYCLIENT(cli) && by == cli && !CLIENT_OPERATOR(cli) &&
+                    !BPRIV(cli, ircd.privileges.priv_operator))
+                return 0;
+            if (set) {
+                ircd.stats.opers++;
+                if (!MYCLIENT(cli))
+                    /* change them to the default operator privilege set */
+                    cli->pset = ircd.privileges.oper_set;
+                hook_event(ircd.events.client_oper, cli);
+            } else {
+                /* remove them from any operator-only send flags, also remove
+                 * any operator-only modes they might have set */
+                if (MYCLIENT(cli)) {
+                    unsigned char *s;
+                    for (s = ircd.umodes.avail;*s != '\0';s++) {
+                        if (ircd.umodes.modes[*s].flags & USERMODE_FL_OPER &&
+                                !(ircd.umodes.modes[*s].flags &
+                                    USERMODE_FL_PRESERVE))
+                            usermode_unset(*s, cli, cli, NULL, NULL);
+                    }
+                    for (i = 0;i < ircd.sflag.size;i++) {
+                        if (ircd.sflag.flags[i].flags &
+                                SEND_LEVEL_OPERATOR &&
+                            !(ircd.sflag.flags[i].flags &
+                                SEND_LEVEL_PRESERVE))
+                            remove_from_send_flag(i, cli, true);
+                    }
+                }
+                ircd.stats.opers--;
+                hook_event(ircd.events.client_deoper, cli);
+            }
+            break;
+    }
+
+    return 1;
 }