X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/ff3b058ac51e9caf5cf1fd310b8a401a97a85582..75ddd32792fd2d0bf86c6e85d360c661134a0681:/src/hash.c?ds=sidebyside

diff --git a/src/hash.c b/src/hash.c
index 3f1b0f9..9775cfe 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -38,8 +38,9 @@ dict_t servers;
 unsigned int max_clients, invis_clients;
 time_t max_clients_time;
 struct userList curr_opers;
+unsigned int count_opers;
 
-static void hash_cleanup(void);
+static void hash_cleanup(void *extra);
 
 void init_structs(void)
 {
@@ -47,25 +48,53 @@ void init_structs(void)
     clients = dict_new();
     servers = dict_new();
     userList_init(&curr_opers);
-    reg_exit_func(hash_cleanup);
+    count_opers = 0;
+    reg_exit_func(hash_cleanup, NULL);
+}
+
+int userList_contains(struct userList *list, struct userNode *user)
+{
+    unsigned int ii;
+
+    for (ii = 0; ii < list->used; ++ii) {
+        if (user == list->list[ii]) {
+            return 1;
+        }
+    }
+    return 0;
 }
 
 server_link_func_t *slf_list;
+void **slf_list_extra;
 unsigned int slf_size = 0, slf_used = 0;
 
 void
-reg_server_link_func(server_link_func_t handler)
+reg_server_link_func(server_link_func_t handler, void *extra)
 {
     if (slf_used == slf_size) {
-	if (slf_size) {
-	    slf_size <<= 1;
-	    slf_list = realloc(slf_list, slf_size*sizeof(server_link_func_t));
-	} else {
-	    slf_size = 8;
-	    slf_list = malloc(slf_size*sizeof(server_link_func_t));
-	}
+        if (slf_size) {
+            slf_size <<= 1;
+            slf_list = realloc(slf_list, slf_size*sizeof(server_link_func_t));
+            slf_list_extra = realloc(slf_list_extra, slf_size*sizeof(void*));
+        } else {
+            slf_size = 8;
+            slf_list = malloc(slf_size*sizeof(server_link_func_t));
+            slf_list_extra = malloc(slf_size*sizeof(void*));
+        }
+    }
+    slf_list[slf_used] = handler;
+    slf_list_extra[slf_used++] = extra;
+}
+
+void
+call_server_link_funcs(struct server *server)
+{
+    unsigned int i;
+
+    for (i = 0; i < slf_used; ++i)
+    {
+        slf_list[i](server, slf_list_extra[i]);
     }
-    slf_list[slf_used++] = handler;
 }
 
 struct server*
@@ -74,70 +103,151 @@ GetServerH(const char *name)
     return dict_find(servers, name, NULL);
 }
 
+sasl_input_func_t *sif_list;
+void **sif_list_extra;
+unsigned int sif_size = 0, sif_used = 0;
+
+void
+reg_sasl_input_func(sasl_input_func_t handler, void *extra)
+{
+    if (sif_used == sif_size) {
+        if (sif_size) {
+            sif_size <<= 1;
+            sif_list = realloc(sif_list, sif_size*sizeof(new_user_func_t));
+            sif_list_extra = realloc(sif_list_extra, sif_size*sizeof(void*));
+        } else {
+            sif_size = 8;
+            sif_list = malloc(sif_size*sizeof(new_user_func_t));
+            sif_list_extra = malloc(sif_size*sizeof(void*));
+        }
+    }
+    sif_list[sif_used] = handler;
+    sif_list_extra[sif_used++] = extra;
+}
+
+void
+call_sasl_input_func(struct server* source ,const char *identifier, const char *subcmd, const char *data, const char *ext)
+{
+    unsigned int i;
+
+    for (i = 0; i < sif_used; ++i)
+    {
+        sif_list[i](source, identifier, subcmd, data, ext, sif_list_extra[i]);
+    }
+}
+
+void
+unreg_sasl_input_func(sasl_input_func_t handler, void *extra)
+{
+    unsigned int i;
+    for (i=0; i<sif_used; i++) {
+        if (sif_list[i] == handler && sif_list_extra[i] == extra) break;
+    }
+    if (i == sif_used) return;
+    memmove(sif_list+i, sif_list+i+1, (sif_used-i-1)*sizeof(sif_list[0]));
+    memmove(sif_list_extra+i, sif_list_extra+i+1, (sif_used-i-1)*sizeof(sif_list_extra[0]));
+    sif_used--;
+}
+
 new_user_func_t *nuf_list;
+void **nuf_list_extra;
 unsigned int nuf_size = 0, nuf_used = 0;
 
 void
-reg_new_user_func(new_user_func_t handler)
+reg_new_user_func(new_user_func_t handler, void *extra)
 {
     if (nuf_used == nuf_size) {
-	if (nuf_size) {
-	    nuf_size <<= 1;
-	    nuf_list = realloc(nuf_list, nuf_size*sizeof(new_user_func_t));
-	} else {
-	    nuf_size = 8;
-	    nuf_list = malloc(nuf_size*sizeof(new_user_func_t));
-	}
+        if (nuf_size) {
+            nuf_size <<= 1;
+            nuf_list = realloc(nuf_list, nuf_size*sizeof(new_user_func_t));
+            nuf_list_extra = realloc(nuf_list_extra, nuf_size*sizeof(void*));
+        } else {
+            nuf_size = 8;
+            nuf_list = malloc(nuf_size*sizeof(new_user_func_t));
+            nuf_list_extra = malloc(nuf_size*sizeof(void*));
+        }
+    }
+    nuf_list[nuf_used] = handler;
+    nuf_list_extra[nuf_used++] = extra;
+}
+
+void
+call_new_user_funcs(struct userNode* user)
+{
+    unsigned int i;
+
+    for (i = 0; i < nuf_used && !(user->dead); ++i)
+    {
+        nuf_list[i](user, nuf_list_extra[i]);
     }
-    nuf_list[nuf_used++] = handler;
 }
 
 static nick_change_func_t *ncf2_list;
+static void **ncf2_list_extra;
 static unsigned int ncf2_size = 0, ncf2_used = 0;
 
 void
-reg_nick_change_func(nick_change_func_t handler)
+reg_nick_change_func(nick_change_func_t handler, void *extra)
 {
     if (ncf2_used == ncf2_size) {
         if (ncf2_size) {
             ncf2_size <<= 1;
             ncf2_list = realloc(ncf2_list, ncf2_size*sizeof(nick_change_func_t));
+            ncf2_list_extra = realloc(ncf2_list_extra, ncf2_size*sizeof(void*));
         } else {
             ncf2_size = 8;
             ncf2_list = malloc(ncf2_size*sizeof(nick_change_func_t));
+            ncf2_list_extra = malloc(ncf2_size*sizeof(void*));
         }
     }
-    ncf2_list[ncf2_used++] = handler;
+    ncf2_list[ncf2_used] = handler;
+    ncf2_list_extra[ncf2_used++] = extra;
 }
 
 
 del_user_func_t *duf_list;
+void **duf_list_extra;
 unsigned int duf_size = 0, duf_used = 0;
 
 void
-reg_del_user_func(del_user_func_t handler)
+reg_del_user_func(del_user_func_t handler, void *extra)
 {
     if (duf_used == duf_size) {
-	if (duf_size) {
-	    duf_size <<= 1;
-	    duf_list = realloc(duf_list, duf_size*sizeof(del_user_func_t));
-	} else {
-	    duf_size = 8;
-	    duf_list = malloc(duf_size*sizeof(del_user_func_t));
-	}
+        if (duf_size) {
+            duf_size <<= 1;
+            duf_list = realloc(duf_list, duf_size*sizeof(del_user_func_t));
+            duf_list_extra = realloc(duf_list_extra, duf_size*sizeof(void*));
+        } else {
+            duf_size = 8;
+            duf_list = malloc(duf_size*sizeof(del_user_func_t));
+            duf_list_extra = malloc(duf_size*sizeof(void*));
+        }
+    }
+    duf_list[duf_used] = handler;
+    duf_list_extra[duf_used++] = extra;
+}
+
+void
+call_del_user_funcs(struct userNode *user, struct userNode *killer, const char *why)
+{
+    unsigned int i;
+
+    for (i = 0; i < duf_used; ++i)
+    {
+        duf_list[i](user, killer, why, duf_list_extra[i]);
     }
-    duf_list[duf_used++] = handler;
 }
 
 void
-unreg_del_user_func(del_user_func_t handler)
+unreg_del_user_func(del_user_func_t handler, void *extra)
 {
     unsigned int i;
     for (i=0; i<duf_used; i++) {
-        if (duf_list[i] == handler) break;
+        if (duf_list[i] == handler && duf_list_extra[i] == extra) break;
     }
     if (i == duf_used) return;
     memmove(duf_list+i, duf_list+i+1, (duf_used-i-1)*sizeof(duf_list[0]));
+    memmove(duf_list_extra+i, duf_list_extra+i+1, (duf_used-i-1)*sizeof(duf_list_extra[0]));
     duf_used--;
 }
 
@@ -189,14 +299,48 @@ NickChange(struct userNode* user, const char *new_nick, int no_announce)
     /* Make callbacks for nick changes.  Do this with new nick in
      * place because that is slightly more useful.
      */
-    for (nn=0; nn<ncf2_used; nn++)
-        ncf2_list[nn](user, old_nick);
+    for (nn=0; (nn<ncf2_used) && !user->dead; nn++)
+        ncf2_list[nn](user, old_nick, ncf2_list_extra[nn]);
     user->timestamp = now;
     if (IsLocal(user) && !no_announce)
         irc_nick(user, old_nick);
     free(old_nick);
 }
 
+void
+SVSNickChange(struct userNode* user, const char *new_nick)
+{
+    char *old_nick;
+    unsigned int nn;
+
+    /* don't do anything if there's no change */
+    old_nick = user->nick;
+    if (!strncmp(new_nick, old_nick, NICKLEN))
+        return;
+
+    /* remove old entry from clients dictionary */
+    dict_remove(clients, old_nick);
+#if !defined(WITH_PROTOCOL_P10)
+    /* Remove from uplink's clients dict */
+    dict_remove(user->uplink->users, old_nick);
+#endif
+    /* and reinsert */
+    user->nick = strdup(new_nick);
+    dict_insert(clients, user->nick, user);
+#if !defined(WITH_PROTOCOL_P10)
+    dict_insert(user->uplink->users, user->nick, user);
+#endif
+
+    /* Make callbacks for nick changes.  Do this with new nick in
+     * place because that is slightly more useful.
+     */
+    for (nn=0; (nn<ncf2_used) && !user->dead; nn++)
+        ncf2_list[nn](user, old_nick, ncf2_list_extra[nn]);
+    user->timestamp = now;
+
+    free(old_nick);
+}
+
 struct userNode *
 GetUserH(const char *nick)
 {
@@ -219,7 +363,8 @@ call_account_func(struct userNode *user, const char *stamp)
 {
     /* We've received an account stamp for a user; notify
        NickServ, which registers the sole account_func
-       right now.
+       right now.  TODO: This is a bug. This needs to register 
+       a proper list not just kill with each call!! -Rubin
 
        P10 Protocol violation if (user->modes & FLAGS_STAMPED) here.
     */
@@ -306,39 +451,47 @@ set_geoip_info(struct userNode *user)
 }
 
 static new_channel_func_t *ncf_list;
+static void **ncf_list_extra;
 static unsigned int ncf_size = 0, ncf_used = 0;
 
 void
-reg_new_channel_func(new_channel_func_t handler)
+reg_new_channel_func(new_channel_func_t handler, void *extra)
 {
     if (ncf_used == ncf_size) {
 	if (ncf_size) {
 	    ncf_size <<= 1;
 	    ncf_list = realloc(ncf_list, ncf_size*sizeof(ncf_list[0]));
+        ncf_list_extra = realloc(ncf_list_extra, ncf_size*sizeof(void*));
 	} else {
 	    ncf_size = 8;
 	    ncf_list = malloc(ncf_size*sizeof(ncf_list[0]));
+        ncf_list_extra = malloc(ncf_size*sizeof(void*));
 	}
     }
-    ncf_list[ncf_used++] = handler;
+    ncf_list[ncf_used] = handler;
+    ncf_list_extra[ncf_used++] = extra;
 }
 
 static join_func_t *jf_list;
+static void **jf_list_extra;
 static unsigned int jf_size = 0, jf_used = 0;
 
 void
-reg_join_func(join_func_t handler)
+reg_join_func(join_func_t handler, void *extra)
 {
     if (jf_used == jf_size) {
 	if (jf_size) {
 	    jf_size <<= 1;
 	    jf_list = realloc(jf_list, jf_size*sizeof(join_func_t));
+        jf_list_extra = realloc(jf_list_extra, jf_size*sizeof(void*));
 	} else {
 	    jf_size = 8;
 	    jf_list = malloc(jf_size*sizeof(join_func_t));
+        jf_list_extra = malloc(jf_size*sizeof(void*));
 	}
     }
-    jf_list[jf_used++] = handler;
+    jf_list[jf_used] = handler;
+    jf_list_extra[jf_used++] = extra;
 }
 
 int rel_age;
@@ -452,7 +605,7 @@ AddChannel(const char *name, time_t time_, const char *modes, char *banlist, cha
     /* if it's a new or updated channel, make callbacks */
     if (rel_age > 0)
         for (nn=0; nn<ncf_used; nn++)
-            ncf_list[nn](cNode);
+            ncf_list[nn](cNode, ncf_list_extra[nn]);
 
     /* go through list of bans and add each one */
     if (banlist && (rel_age >= 0)) {
@@ -492,21 +645,25 @@ AddChannel(const char *name, time_t time_, const char *modes, char *banlist, cha
 }
 
 static del_channel_func_t *dcf_list;
+static void **dcf_list_extra;
 static unsigned int dcf_size = 0, dcf_used = 0;
 
 void
-reg_del_channel_func(del_channel_func_t handler)
+reg_del_channel_func(del_channel_func_t handler, void *extra)
 {
     if (dcf_used == dcf_size) {
 	if (dcf_size) {
 	    dcf_size <<= 1;
 	    dcf_list = realloc(dcf_list, dcf_size*sizeof(dcf_list[0]));
+        dcf_list_extra = realloc(dcf_list_extra, dcf_size*sizeof(void*));
 	} else {
 	    dcf_size = 8;
 	    dcf_list = malloc(dcf_size*sizeof(dcf_list[0]));
+        dcf_list_extra = malloc(dcf_size*sizeof(dcf_list_extra[0]));
 	}
     }
-    dcf_list[dcf_used++] = handler;
+    dcf_list[dcf_used] = handler;
+    dcf_list_extra[dcf_used++] = extra;
 }
 
 static void
@@ -514,6 +671,7 @@ DelChannel(struct chanNode *channel)
 {
     unsigned int n;
 
+    verify(channel);
     dict_remove(channels, channel->name);
 
     if (channel->members.used || channel->locks) {
@@ -522,7 +680,7 @@ DelChannel(struct chanNode *channel)
 
     /* go through all channel members and delete them from the channel */
     for (n=channel->members.used; n>0; )
-        DelChannelUser(channel->members.list[--n]->user, channel, NULL, 1);
+	DelChannelUser(channel->members.list[--n]->user, channel, NULL, 1);
 
     /* delete all channel bans */
     for (n=channel->banlist.used; n>0; )
@@ -535,7 +693,7 @@ DelChannel(struct chanNode *channel)
     channel->exemptlist.used = 0;
 
     for (n=0; n<dcf_used; n++)
-        dcf_list[n](channel);
+        dcf_list[n](channel, dcf_list_extra[n]);
 
     modeList_clean(&channel->members);
     banList_clean(&channel->banlist);
@@ -571,50 +729,57 @@ AddChannelUser(struct userNode *user, struct chanNode* channel)
 
         if (channel->members.used == 1
             && !(channel->modes & MODE_REGISTERED)
-            && !(channel->modes & MODE_APASS))
+            && !(channel->modes & MODE_APASS)) {
             mNode->modes |= MODE_CHANOP;
+        }
+
+        if (IsLocal(user)) {
+            irc_join(user, channel);
+        }
 
-        for (n=0; n<jf_used; n++) {
+        for (n=0; (n<jf_used) && !user->dead; n++) {
             /* Callbacks return true if they kick or kill the user,
              * and we can continue without removing mNode. */
-            if (jf_list[n](mNode))
+            if (jf_list[n](mNode, jf_list_extra[n]))
                 return NULL;
         }
 
-	if (IsLocal(user))
-            irc_join(user, channel);
-
 	return mNode;
 }
 
 static part_func_t *pf_list;
+static void **pf_list_extra;
 static unsigned int pf_size = 0, pf_used = 0;
 
 void
-reg_part_func(part_func_t handler)
+reg_part_func(part_func_t handler, void *extra)
 {
     if (pf_used == pf_size) {
 	if (pf_size) {
 	    pf_size <<= 1;
 	    pf_list = realloc(pf_list, pf_size*sizeof(part_func_t));
+        pf_list_extra = realloc(pf_list_extra, pf_size*sizeof(void*));
 	} else {
 	    pf_size = 8;
 	    pf_list = malloc(pf_size*sizeof(part_func_t));
+        pf_list_extra = malloc(pf_size*sizeof(void*));
 	}
     }
-    pf_list[pf_used++] = handler;
+    pf_list[pf_used] = handler;
+    pf_list_extra[pf_used++] = extra;
 }
 
 void
-unreg_part_func(part_func_t handler)
+unreg_part_func(part_func_t handler, void *extra)
 {
     unsigned int i;
     for (i=0; i<pf_used; i++)
-        if (pf_list[i] == handler)
+        if (pf_list[i] == handler && pf_list_extra[i] == extra)
             break;
     if (i == pf_used)
         return;
     memmove(pf_list+i, pf_list+i+1, (pf_used-i-1)*sizeof(pf_list[0]));
+    memmove(pf_list_extra+i, pf_list_extra+i+1, (pf_used-i-1)*sizeof(pf_list_extra[0]));
     pf_used--;
 }
 
@@ -655,7 +820,7 @@ DelChannelUser(struct userNode* user, struct chanNode* channel, const char *reas
 
     /* make callbacks */
     for (n=0; n<pf_used; n++)
-	pf_list[n](mNode, reason);
+	pf_list[n](mNode, reason, pf_list_extra[n]);
 
     /* free memory */
     free(mNode);
@@ -667,6 +832,7 @@ DelChannelUser(struct userNode* user, struct chanNode* channel, const char *reas
 }
 
 static kick_func_t *kf_list;
+static void **kf_list_extra;
 static unsigned int kf_size = 0, kf_used = 0;
 
 void
@@ -679,7 +845,7 @@ KickChannelUser(struct userNode* target, struct chanNode* channel, struct userNo
 
     /* This may break things, but lets see.. -Rubin */
     for (n=0; n<kf_used; n++)
-        kf_list[n](kicker, target, channel);
+        kf_list[n](kicker, target, channel, kf_list_extra[n]);
 
     /* don't remove them from the channel, since the server will send a PART */
     irc_kick(kicker, target, channel, why);
@@ -693,18 +859,21 @@ KickChannelUser(struct userNode* target, struct chanNode* channel, struct userNo
 }
 
 void
-reg_kick_func(kick_func_t handler)
+reg_kick_func(kick_func_t handler, void *extra)
 {
     if (kf_used == kf_size) {
 	if (kf_size) {
 	    kf_size <<= 1;
 	    kf_list = realloc(kf_list, kf_size*sizeof(kick_func_t));
+        kf_list_extra = realloc(kf_list_extra, kf_size*sizeof(void*));
 	} else {
 	    kf_size = 8;
 	    kf_list = malloc(kf_size*sizeof(kick_func_t));
+        kf_list_extra = malloc(kf_size*sizeof(void*));
 	}
     }
-    kf_list[kf_used++] = handler;
+    kf_list[kf_used] = handler;
+    kf_list_extra[kf_used++] = extra;
 }
 
 void
@@ -721,7 +890,7 @@ ChannelUserKicked(struct userNode* kicker, struct userNode* victim, struct chanN
         mn->idle_since = now;
 
     for (n=0; n<kf_used; n++)
-	kf_list[n](kicker, victim, channel);
+	kf_list[n](kicker, victim, channel, kf_list_extra[n]);
 
     DelChannelUser(victim, channel, 0, 0);
 
@@ -750,21 +919,25 @@ int ChannelExemptExists(struct chanNode *channel, const char *exempt)
 }
 
 static topic_func_t *tf_list;
+static void **tf_list_extra;
 static unsigned int tf_size = 0, tf_used = 0;
 
 void
-reg_topic_func(topic_func_t handler)
+reg_topic_func(topic_func_t handler, void *extra)
 {
     if (tf_used == tf_size) {
 	if (tf_size) {
 	    tf_size <<= 1;
 	    tf_list = realloc(tf_list, tf_size*sizeof(topic_func_t));
+        tf_list_extra = realloc(tf_list_extra, tf_size*sizeof(void*));
 	} else {
 	    tf_size = 8;
 	    tf_list = malloc(tf_size*sizeof(topic_func_t));
+        tf_list_extra = malloc(tf_size*sizeof(void*));
 	}
     }
-    tf_list[tf_used++] = handler;
+    tf_list[tf_used] = handler;
+    tf_list_extra[tf_used++] = extra;
 }
 
 void
@@ -792,7 +965,11 @@ SetChannelTopic(struct chanNode *channel, struct userNode *service, struct userN
 	irc_topic(service, user, channel, topic);
     } else {
 	for (n=0; n<tf_used; n++)
-	    if (tf_list[n](user, channel, old_topic))
+            /* A topic change handler can return non-zero to indicate
+             * that it has reverted the topic change, and that further
+             * hooks should not be called.
+             */
+	    if (tf_list[n](user, channel, old_topic, tf_list_extra[n]))
                 break;
     }
 }
@@ -867,7 +1044,7 @@ DEFINE_LIST(channelList, struct chanNode*)
 DEFINE_LIST(serverList, struct server*)
 
 static void
-hash_cleanup(void)
+hash_cleanup(UNUSED_ARG(void *extra))
 {
     dict_iterator_t it, next;
 
@@ -880,15 +1057,26 @@ hash_cleanup(void)
     dict_delete(clients);
     dict_delete(servers);
     userList_clean(&curr_opers);
+    count_opers = 0;
 
     free(slf_list);
+    free(slf_list_extra);
     free(nuf_list);
+    free(nuf_list_extra);
     free(ncf2_list);
+    free(ncf2_list_extra);
     free(duf_list);
+    free(duf_list_extra);
     free(ncf_list);
+    free(ncf_list_extra);
     free(jf_list);
+    free(jf_list_extra);
     free(dcf_list);
+    free(dcf_list_extra);
     free(pf_list);
+    free(pf_list_extra);
     free(kf_list);
+    free(kf_list_extra);
     free(tf_list);
+    free(tf_list_extra);
 }