Added new event hooks system and started migrating events to new system

[irc/evilnet/x3.git] / src / hash.c

diff --git a/src/hash.c b/src/hash.c
index 3e381053059e48d48742d9929ba76e31e758cf89..8f6a3dfe9edd41dacc8bdfc30de645e317a0abb2 100644 (file)
--- 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 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)
 {
 
 void init_structs(void)
 {


@@ -47,7 +48,8 @@ void init_structs(void)
     clients = dict_new();
     servers = dict_new();
     userList_init(&curr_opers);
     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)
 }
 
 int userList_contains(struct userList *list, struct userNode *user)


@@ -101,37 +103,96 @@ GetServerH(const char *name)
     return dict_find(servers, name, NULL);
 }
 
     return dict_find(servers, name, NULL);
 }
 

-new_user_func_t *nuf_list;
-void **nuf_list_extra;
-unsigned int nuf_size = 0, nuf_used = 0;
+sasl_input_func_t *sif_list;
+void **sif_list_extra;
+unsigned int sif_size = 0, sif_used = 0;

 
 void
 
 void

-reg_new_user_func(new_user_func_t handler, void *extra)
+reg_sasl_input_func(sasl_input_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));
-            nuf_list_extra = realloc(nuf_list_extra, nuf_size*sizeof(void*));
+    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 {
         } else {

-            nuf_size = 8;
-            nuf_list = malloc(nuf_size*sizeof(new_user_func_t));
-            nuf_list_extra = malloc(nuf_size*sizeof(void*));
+            sif_size = 8;
+            sif_list = malloc(sif_size*sizeof(new_user_func_t));
+            sif_list_extra = malloc(sif_size*sizeof(void*));

         }
     }
         }
     }

-    nuf_list[nuf_used] = handler;
-    nuf_list_extra[nuf_used++] = extra;
+    sif_list[sif_used] = handler;
+    sif_list_extra[sif_used++] = extra;

 }
 
 void
 }
 
 void

-call_new_user_funcs(struct userNode* user)
+call_sasl_input_func(struct server* source ,const char *identifier, const char *subcmd, const char *data, const char *ext)

 {
     unsigned int i;
 
 {
     unsigned int i;
 

-    for (i = 0; i < nuf_used && !(user->dead); ++i)
+    for (i = 0; i < sif_used; ++i)

     {
     {

-        nuf_list[i](user, nuf_list_extra[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--;
+}
+
+void
+nuf_free_ehf(struct eh_func *ehf)
+{
+    if (ehf->extra != NULL)
+        free(ehf->extra);
+}
+
+DEFINE_EH_FUNC_LIST(nuf_list, EH_ADD_TAIL, nuf_free_ehf);
+
+int
+nuf_wrapper(void *extra, void *callextra)
+{
+    struct funcargs *fa = (struct funcargs *)extra;
+    struct userNode *user = (struct userNode *)callextra;
+
+    ((new_user_func_t)fa->func)(user, fa->extra);
+
+    if (user->dead)
+        return EH_STOP;
+
+    return EH_CONT;
+}
+
+void
+reg_new_user_func_pos(new_user_func_t handler, void *extra, int pos)
+{
+    struct funcargs *fa = malloc(sizeof(struct funcargs));
+
+    fa->func = (void *)handler;
+    fa->extra = extra;
+
+    reg_hook_func_pos(&nuf_list, nuf_wrapper, (void *)fa, pos);
+}
+
+void
+reg_new_user_func(new_user_func_t handler, void *extra)
+{
+    reg_new_user_func_pos(handler, extra, EH_ADD_DEFAULT);
+}
+
+void
+call_new_user_funcs(struct userNode* user)
+{
+    call_hook_func_args(&nuf_list, (void *)user);

 }
 
 static nick_change_func_t *ncf2_list;
 }
 
 static nick_change_func_t *ncf2_list;


@@ -153,7 +214,7 @@ reg_nick_change_func(nick_change_func_t handler, void *extra)
         }
     }
     ncf2_list[ncf2_used] = handler;
         }
     }
     ncf2_list[ncf2_used] = handler;

-    ncf2_list[ncf2_used++] = extra;
+    ncf2_list_extra[ncf2_used++] = extra;

 }
 
 
 }
 
 


@@ -403,39 +464,72 @@ set_geoip_info(struct userNode *user)
 }
 
 static new_channel_func_t *ncf_list;
 }
 
 static new_channel_func_t *ncf_list;

+static void **ncf_list_extra;

 static unsigned int ncf_size = 0, ncf_used = 0;
 
 void
 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]));
 {
     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]));
        } 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 unsigned int jf_size = 0, jf_used = 0;
+void
+jf_free_ehf(struct eh_func *ehf)
+{
+    if (ehf->extra != NULL)
+        free(ehf->extra);
+}
+
+DEFINE_EH_FUNC_LIST(jf_list, EH_ADD_TAIL, jf_free_ehf);
+
+int
+jf_wrapper(void *extra, void *callextra)
+{
+    struct funcargs *fa = (struct funcargs *)extra;
+    struct modeNode *mNode = (struct modeNode *)callextra;
+    struct userNode *user = mNode->user;
+
+    ((join_func_t)fa->func)(mNode, fa->extra);
+
+    if (user->dead)
+        return EH_STOP;
+
+    return EH_CONT;
+}

 
 void
 
 void

-reg_join_func(join_func_t handler)
+reg_join_func_pos(join_func_t handler, void *extra, int pos)

 {
 {

-    if (jf_used == jf_size) {
-       if (jf_size) {
-           jf_size <<= 1;
-           jf_list = realloc(jf_list, jf_size*sizeof(join_func_t));
-       } else {
-           jf_size = 8;
-           jf_list = malloc(jf_size*sizeof(join_func_t));
-       }
-    }
-    jf_list[jf_used++] = handler;
+    struct funcargs *fa = malloc(sizeof(struct funcargs));
+
+    fa->func = (void *)handler;
+    fa->extra = extra;
+
+    reg_hook_func_pos(&jf_list, jf_wrapper, (void *)fa, pos);
+}
+
+void
+reg_join_func(join_func_t handler, void *extra)
+{
+    reg_join_func_pos(handler, extra, EH_ADD_DEFAULT);
+}
+
+void
+call_join_funcs(struct modeNode *mNode)
+{
+    call_hook_func_args(&jf_list, (void *)mNode);

 }
 
 int rel_age;
 }
 
 int rel_age;


@@ -549,7 +643,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++)
     /* 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)) {
 
     /* go through list of bans and add each one */
     if (banlist && (rel_age >= 0)) {


@@ -589,21 +683,25 @@ AddChannel(const char *name, time_t time_, const char *modes, char *banlist, cha
 }
 
 static del_channel_func_t *dcf_list;
 }
 
 static del_channel_func_t *dcf_list;

+static void **dcf_list_extra;

 static unsigned int dcf_size = 0, dcf_used = 0;
 
 void
 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]));
 {
     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]));
        } 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
 }
 
 static void


@@ -633,7 +731,7 @@ DelChannel(struct chanNode *channel)
     channel->exemptlist.used = 0;
 
     for (n=0; n<dcf_used; n++)
     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);
 
     modeList_clean(&channel->members);
     banList_clean(&channel->banlist);


@@ -645,7 +743,6 @@ struct modeNode *
 AddChannelUser(struct userNode *user, struct chanNode* channel)
 {
        struct modeNode *mNode;
 AddChannelUser(struct userNode *user, struct chanNode* channel)
 {
        struct modeNode *mNode;

-       unsigned int n;

 
        mNode = GetUserMode(channel, user);
        if (mNode)
 
        mNode = GetUserMode(channel, user);
        if (mNode)


@@ -671,51 +768,50 @@ AddChannelUser(struct userNode *user, struct chanNode* channel)
             && !(channel->modes & MODE_REGISTERED)
             && !(channel->modes & MODE_APASS)) {
             mNode->modes |= MODE_CHANOP;
             && !(channel->modes & MODE_REGISTERED)
             && !(channel->modes & MODE_APASS)) {
             mNode->modes |= MODE_CHANOP;

-            log_module(MAIN_LOG, LOG_DEBUG, "setting op");

         }
 
         if (IsLocal(user)) {
             irc_join(user, channel);
         }
 
         }
 
         if (IsLocal(user)) {
             irc_join(user, channel);
         }
 

-        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))
-                return NULL;
-        }
+        call_join_funcs(mNode);

 
        return mNode;
 }
 
 static part_func_t *pf_list;
 
        return mNode;
 }
 
 static part_func_t *pf_list;

+static void **pf_list_extra;

 static unsigned int pf_size = 0, pf_used = 0;
 
 void
 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));
 {
     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));
        } 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
 }
 
 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++)
 {
     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]));
             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--;
 }
 
     pf_used--;
 }
 


@@ -756,7 +852,7 @@ DelChannelUser(struct userNode* user, struct chanNode* channel, const char *reas
 
     /* make callbacks */
     for (n=0; n<pf_used; n++)
 
     /* 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);
 
     /* free memory */
     free(mNode);


@@ -768,6 +864,7 @@ DelChannelUser(struct userNode* user, struct chanNode* channel, const char *reas
 }
 
 static kick_func_t *kf_list;
 }
 
 static kick_func_t *kf_list;

+static void **kf_list_extra;

 static unsigned int kf_size = 0, kf_used = 0;
 
 void
 static unsigned int kf_size = 0, kf_used = 0;
 
 void


@@ -780,7 +877,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++)
 
     /* 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);
 
     /* don't remove them from the channel, since the server will send a PART */
     irc_kick(kicker, target, channel, why);


@@ -794,18 +891,21 @@ KickChannelUser(struct userNode* target, struct chanNode* channel, struct userNo
 }
 
 void
 }
 
 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));
 {
     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));
        } 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
 }
 
 void


@@ -822,7 +922,7 @@ ChannelUserKicked(struct userNode* kicker, struct userNode* victim, struct chanN
         mn->idle_since = now;
 
     for (n=0; n<kf_used; n++)
         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);
 
 
     DelChannelUser(victim, channel, 0, 0);
 


@@ -851,21 +951,25 @@ int ChannelExemptExists(struct chanNode *channel, const char *exempt)
 }
 
 static topic_func_t *tf_list;
 }
 
 static topic_func_t *tf_list;

+static void **tf_list_extra;

 static unsigned int tf_size = 0, tf_used = 0;
 
 void
 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));
 {
     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));
        } 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
 }
 
 void


@@ -897,7 +1001,7 @@ SetChannelTopic(struct chanNode *channel, struct userNode *service, struct userN
              * that it has reverted the topic change, and that further
              * hooks should not be called.
              */
              * that it has reverted the topic change, and that further
              * hooks should not be called.
              */

-           if (tf_list[n](user, channel, old_topic))
+           if (tf_list[n](user, channel, old_topic, tf_list_extra[n]))

                 break;
     }
 }
                 break;
     }
 }


@@ -972,7 +1076,7 @@ DEFINE_LIST(channelList, struct chanNode*)
 DEFINE_LIST(serverList, struct server*)
 
 static void
 DEFINE_LIST(serverList, struct server*)
 
 static void

-hash_cleanup(void)
+hash_cleanup(UNUSED_ARG(void *extra))

 {
     dict_iterator_t it, next;
 
 {
     dict_iterator_t it, next;
 


@@ -985,19 +1089,24 @@ hash_cleanup(void)
     dict_delete(clients);
     dict_delete(servers);
     userList_clean(&curr_opers);
     dict_delete(clients);
     dict_delete(servers);
     userList_clean(&curr_opers);

+    count_opers = 0;

 
     free(slf_list);
     free(slf_list_extra);
 
     free(slf_list);
     free(slf_list_extra);

-    free(nuf_list);
-    free(nuf_list_extra);
+    free_hook_func_list(&nuf_list);

     free(ncf2_list);
     free(ncf2_list_extra);
     free(duf_list);
     free(duf_list_extra);
     free(ncf_list);
     free(ncf2_list);
     free(ncf2_list_extra);
     free(duf_list);
     free(duf_list_extra);
     free(ncf_list);

-    free(jf_list);
+    free(ncf_list_extra);
+    free_hook_func_list(&jf_list);

     free(dcf_list);
     free(dcf_list);

+    free(dcf_list_extra);

     free(pf_list);
     free(pf_list);

+    free(pf_list_extra);

     free(kf_list);
     free(kf_list);

+    free(kf_list_extra);

     free(tf_list);
     free(tf_list);

+    free(tf_list_extra);

 }
 }