* Removed all of the thread cancellation cruft that is no longer necessary

[citadel.git] / citadel / dynloader.c

diff --git a/citadel/dynloader.c b/citadel/dynloader.c
index 49e69488c110fa4db0eedda8424d2246b35a3718..259c6d3dd8f54b36004b387b143e9bcf8ceed0cb 100644 (file)
--- a/citadel/dynloader.c
+++ b/citadel/dynloader.c
@@ -17,15 +17,13 @@
 #include <dirent.h>
 #include <strings.h>
 #include <syslog.h>
-#ifdef HAVE_PTHREAD_H
-#include <pthread.h>
-#endif
 #include <limits.h>
 #include <ctype.h>
-#include "dynloader.h"
 #include "citadel.h"
 #include "server.h"
+#include "dynloader.h"
 #include "sysdep_decls.h"
+#include "msgbase.h"
 #include "tools.h"
 
 #ifndef HAVE_SNPRINTF
@@ -37,6 +35,8 @@ struct LogFunctionHook *LogHookTable = NULL;
 struct CleanupFunctionHook *CleanupHookTable = NULL;
 struct SessionFunctionHook *SessionHookTable = NULL;
 struct UserFunctionHook *UserHookTable = NULL;
+struct XmsgFunctionHook *XmsgHookTable = NULL;
+struct MessageFunctionHook *MessageHookTable = NULL;
 
 struct ProtoFunctionHook {
        void (*handler) (char *cmdbuf);
@@ -58,6 +58,7 @@ void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc)
        p->desc = desc;
        p->next = ProtoHookList;
        ProtoHookList = p;
+       lprintf(5, "Registered server command %s (%s)\n", cmd, desc);
 }
 
 int DLoader_Exec_Cmd(char *cmdbuf)
@@ -90,9 +91,10 @@ void DLoader_Init(char *pathname)
                exit(1);
        }
        while ((dptr = readdir(dir)) != NULL) {
-               if (dptr->d_name[0] == '.')
+               if (strlen(dptr->d_name) < 4)
+                       continue;
+               if (strcasecmp(&dptr->d_name[strlen(dptr->d_name)-3], ".so"))
                        continue;
-               lprintf(9, "Attempting to load %s\n", dptr->d_name);
 
                snprintf(pathbuf, PATH_MAX, "%s/%s", pathname, dptr->d_name);
 #ifdef RTLD_NOW
@@ -193,6 +195,39 @@ void CtdlRegisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
 }
 
 
+void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
+                               int EventType)
+{
+
+       struct MessageFunctionHook *newfcn;
+
+       newfcn = (struct MessageFunctionHook *)
+           mallok(sizeof(struct MessageFunctionHook));
+       newfcn->next = MessageHookTable;
+       newfcn->h_function_pointer = handler;
+       newfcn->eventtype = EventType;
+       MessageHookTable = newfcn;
+
+       lprintf(5, "Registered a new message function (type %d)\n",
+               EventType);
+}
+
+
+void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
+{
+
+       struct XmsgFunctionHook *newfcn;
+
+       newfcn = (struct XmsgFunctionHook *)
+           mallok(sizeof(struct XmsgFunctionHook));
+       newfcn->next = XmsgHookTable;
+       newfcn->order = order;
+       newfcn->h_function_pointer = fcn_ptr;
+       XmsgHookTable = newfcn;
+       lprintf(5, "Registered a new x-msg function (priority %d)\n", order);
+}
+
+
 void PerformSessionHooks(int EventType)
 {
        struct SessionFunctionHook *fcn;
@@ -225,3 +260,60 @@ void PerformUserHooks(char *username, long usernum, int EventType)
                }
        }
 }
+
+int PerformMessageHooks(struct CtdlMessage *msg, int EventType)
+{
+       struct MessageFunctionHook *fcn;
+       int total_retval = 0;
+
+       /* Other code may elect to protect this message from server-side
+        * handlers; if this is the case, don't do anything.
+        */
+       lprintf(9, "** Event type is %d, flags are %d\n",
+               EventType, msg->cm_flags);
+       if (msg->cm_flags & CM_SKIP_HOOKS) {
+               lprintf(9, "Skipping hooks\n");
+               return(0);
+       }
+
+       /* Otherwise, run all the hooks appropriate to this event type.
+        */
+       for (fcn = MessageHookTable; fcn != NULL; fcn = fcn->next) {
+               if (fcn->eventtype == EventType) {
+                       total_retval = total_retval +
+                               (*fcn->h_function_pointer) (msg);
+               }
+       }
+
+       /* Return the sum of the return codes from the hook functions.  If
+        * this is an EVT_BEFORESAVE event, a nonzero return code will cause
+        * the save operation to abort.
+        */
+       return total_retval;
+}
+
+
+
+int PerformXmsgHooks(char *sender, char *recp, char *msg)
+{
+       struct XmsgFunctionHook *fcn;
+       int total_sent = 0;
+       int p;
+
+       for (p=0; p<MAX_XMSG_PRI; ++p) {
+               for (fcn = XmsgHookTable; fcn != NULL; fcn = fcn->next) {
+                       if (fcn->order == p) {
+                               total_sent +=
+                                       (*fcn->h_function_pointer)
+                                               (sender, recp, msg);
+                       }
+               }
+               /* Break out of the loop if a higher-priority function
+                * successfully delivered the message.  This prevents duplicate
+                * deliveries to local users simultaneously signed onto
+                * remote services.
+                */
+               if (total_sent) goto DONE;
+       }
+DONE:  return total_sent;
+}