* Modules can now unregister any of their hooks (though none yet take

  advantage of this).

diff --git a/citadel/ChangeLog b/citadel/ChangeLog
index 36e4c571bd4c178126f732551b54121177d035f1..797e0a2c1d2324c3f731ffd9c270bddc3348cb63 100644 (file)
--- a/citadel/ChangeLog
+++ b/citadel/ChangeLog
@@ -1,4 +1,8 @@
  $Log$
+ Revision 590.61  2002/01/15 06:20:18  error
+ * Modules can now unregister any of their hooks (though none yet take
+   advantage of this).
+
  Revision 590.60  2002/01/14 08:49:13  error
  * Fixed bug in cmd_cre8() causing protocol to get out of sync when creating
    a new room
@@ -3151,3 +3155,4 @@ Sat Jul 11 00:20:48 EDT 1998 Nathan Bryant <bryant@cs.usm.maine.edu>
 
 Fri Jul 10 1998 Art Cancro <ajc@uncensored.citadel.org>
        * Initial CVS import 
+

diff --git a/citadel/dynloader.c b/citadel/dynloader.c
index c58a5049fe05698a7a99765563217279a13424f1..15c8ef7de4a2361c3cffd7c6738ce07fff425bdc 100644 (file)
--- a/citadel/dynloader.c
+++ b/citadel/dynloader.c
@@ -13,6 +13,7 @@
 #include "sysdep.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 #ifdef HAVE_DLFCN_H
 #include <dlfcn.h>
 #endif
@@ -73,6 +74,29 @@ void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc)
        lprintf(5, "Registered server command %s (%s)\n", cmd, desc);
 }
 
+
+void CtdlUnregisterProtoHook(void (*handler) (char *), char *cmd)
+{
+       struct ProtoFunctionHook *cur, *p;
+
+       for (cur = ProtoHookList; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               handler == cur->handler &&
+                               !strcmp(cmd, cur->cmd)) {
+                       lprintf(5, "Unregistered server command %s (%s)\n",
+                                       cmd, cur->desc);
+                       p = cur->next;
+                       if (cur == ProtoHookList) {
+                               ProtoHookList = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 int DLoader_Exec_Cmd(char *cmdbuf)
 {
        struct ProtoFunctionHook *p;
@@ -164,6 +188,27 @@ void CtdlRegisterLogHook(void (*fcn_ptr) (char *), int loglevel)
 }
 
 
+void CtdlUnregisterLogHook(void (*fcn_ptr) (char *), int loglevel)
+{
+       struct LogFunctionHook *cur, *p;
+
+       for (cur = LogHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               fcn_ptr == cur->h_function_pointer &&
+                               loglevel == cur->loglevel) {
+                       lprintf(5, "Unregistered logging function\n");
+                       p = cur->next;
+                       if (cur == LogHookTable) {
+                               LogHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterCleanupHook(void (*fcn_ptr) (void))
 {
 
@@ -179,6 +224,26 @@ void CtdlRegisterCleanupHook(void (*fcn_ptr) (void))
 }
 
 
+void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void))
+{
+       struct CleanupFunctionHook *cur, *p;
+
+       for (cur = CleanupHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               fcn_ptr == cur->h_function_pointer) {
+                       lprintf(5, "Unregistered cleanup function\n");
+                       p = cur->next;
+                       if (cur == CleanupHookTable) {
+                               CleanupHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType)
 {
 
@@ -196,6 +261,28 @@ void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType)
 }
 
 
+void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType)
+{
+       struct SessionFunctionHook *cur, *p;
+
+       for (cur = SessionHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               fcn_ptr == cur->h_function_pointer &&
+                               EventType == cur->eventtype) {
+                       lprintf(5, "Unregistered session function (type %d)\n",
+                                       EventType);
+                       p = cur->next;
+                       if (cur == SessionHookTable) {
+                               SessionHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
 {
 
@@ -213,6 +300,28 @@ void CtdlRegisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
 }
 
 
+void CtdlUnregisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
+{
+       struct UserFunctionHook *cur, *p;
+
+       for (cur = UserHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               fcn_ptr == cur->h_function_pointer &&
+                               EventType == cur->eventtype) {
+                       lprintf(5, "Unregistered user function (type %d)\n",
+                                       EventType);
+                       p = cur->next;
+                       if (cur == UserHookTable) {
+                               UserHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
                                int EventType)
 {
@@ -231,6 +340,29 @@ void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
 }
 
 
+void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *),
+               int EventType)
+{
+       struct MessageFunctionHook *cur, *p;
+
+       for (cur = MessageHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               handler == cur->h_function_pointer &&
+                               EventType == cur->eventtype) {
+                       lprintf(5, "Unregistered message function (type %d)\n",
+                                       EventType);
+                       p = cur->next;
+                       if (cur == MessageHookTable) {
+                               MessageHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
 {
 
@@ -245,6 +377,29 @@ void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
        lprintf(5, "Registered a new x-msg function (priority %d)\n", order);
 }
 
+
+void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
+{
+       struct XmsgFunctionHook *cur, *p;
+
+       for (cur = XmsgHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               fcn_ptr == cur->h_function_pointer &&
+                               order == cur->order) {
+                       lprintf(5, "Unregistered x-msg function "
+                                       "(priority %d)\n", order);
+                       p = cur->next;
+                       if (cur == XmsgHookTable) {
+                               XmsgHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
+
 void CtdlRegisterServiceHook(int tcp_port,
                        char *sockpath,
                        void (*h_greeting_function) (void),
@@ -288,6 +443,39 @@ void CtdlRegisterServiceHook(int tcp_port,
 }
 
 
+void CtdlUnregisterServiceHook(int tcp_port, char *sockpath,
+                       void (*h_greeting_function) (void),
+                       void (*h_command_function) (void) )
+{
+       struct ServiceFunctionHook *cur, *p;
+
+       for (cur = ServiceHookTable; cur != NULL; cur = cur->next) {
+               /* This will also remove duplicates if any */
+               while (cur != NULL &&
+                               !(sockpath && cur->sockpath &&
+                                       strcmp(sockpath, cur->sockpath)) &&
+                               h_greeting_function == cur->h_greeting_function &&
+                               h_command_function == cur->h_command_function &&
+                               tcp_port == cur->tcp_port) {
+                       close(cur->msock);
+                       if (sockpath) {
+                               lprintf(5, "Closed UNIX domain socket %s\n",
+                                               sockpath);
+                       } else if (tcp_port) {
+                               lprintf(5, "Closed TCP port %d\n", tcp_port);
+                       } else {
+                               lprintf(5, "Unregistered unknown service\n");
+                       }
+                       p = cur->next;
+                       if (cur == ServiceHookTable) {
+                               ServiceHookTable = p;
+                       }
+                       phree(cur);
+                       cur = p;
+               }
+       }
+}
+
 
 void PerformSessionHooks(int EventType)
 {
@@ -374,7 +562,7 @@ int PerformXmsgHooks(char *sender, char *recp, char *msg)
                 * deliveries to local users simultaneously signed onto
                 * remote services.
                 */
-               if (total_sent) goto DONE;
+               if (total_sent) break;
        }
-DONE:  return total_sent;
+       return total_sent;
 }

diff --git a/citadel/dynloader.h b/citadel/dynloader.h
index d685fcbfbd6913b1965c5ef88cd3e4df8441fef1..dc32a01708fbe14bf2a1c90fcfe09e8de177d821 100644 (file)
--- a/citadel/dynloader.h
+++ b/citadel/dynloader.h
@@ -10,26 +10,37 @@ int DLoader_Exec_Cmd(char *cmdbuf);
 char *Dynamic_Module_Init(void);
 
 void CtdlRegisterLogHook(void (*fcn_ptr)(char *), int loglevel);
+void CtdlUnregisterLogHook(void (*fcn_ptr)(char *), int loglevel);
 void PerformLogHooks(int loglevel, char *logmsg);
 
 
 void CtdlRegisterSessionHook(void (*fcn_ptr)(void), int EventType);
+void CtdlUnregisterSessionHook(void (*fcn_ptr)(void), int EventType);
 void PerformSessionHooks(int EventType);
 
 void CtdlRegisterUserHook(void (*fcn_ptr)(char*, long), int EventType);
+void CtdlUnregisterUserHook(void (*fcn_ptr)(char*, long), int EventType);
 void PerformUserHooks(char *username, long usernum, int EventType);
 
 void CtdlRegisterXmsgHook(int (*fcn_ptr)(char *, char *, char *), int order);
+void CtdlUnregisterXmsgHook(int (*fcn_ptr)(char *, char *, char *), int order);
 int PerformXmsgHooks(char *, char *, char *);
 
 void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *), int EventType);
+void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *), int EventType);
 int PerformMessageHooks(struct CtdlMessage *, int EventType);
 
 void CtdlRegisterCleanupHook(void (*fcn_ptr)(void));
+void CtdlUnregisterCleanupHook(void (*fcn_ptr)(void));
 void CtdlRegisterProtoHook(void (*handler)(char *), char *cmd, char *desc);
+void CtdlUnregisterProtoHook(void (*handler)(char *), char *cmd);
 void CtdlRegisterServiceHook(int tcp_port,
                        char *sockpath,
                         void (*h_greeting_function) (void),
                         void (*h_command_function) (void) ) ;
+void CtdlUnregisterServiceHook(int tcp_port,
+                       char *sockpath,
+                        void (*h_greeting_function) (void),
+                        void (*h_command_function) (void) ) ;
 
 #endif /* DYNLOADER_H */