* Removed the built-in memory leak checker. It wasn't threadsafe and

[citadel.git] / citadel / serv_extensions.c

diff --git a/citadel/serv_extensions.c b/citadel/serv_extensions.c
index 29c92587ea847e2d8fa876dec54f350c9b68411d..8d07fe6a3c08e3c3b6470888ee1f4f5014aa79eb 100644 (file)
--- a/citadel/serv_extensions.c
+++ b/citadel/serv_extensions.c
@@ -50,7 +50,7 @@ void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc)
        struct ProtoFunctionHook *p;
 
        p = (struct ProtoFunctionHook *)
-               mallok(sizeof(struct ProtoFunctionHook));
+               malloc(sizeof(struct ProtoFunctionHook));
 
        if (p == NULL) {
                fprintf(stderr, "can't malloc new ProtoFunctionHook\n");
@@ -61,7 +61,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);
+       lprintf(CTDL_INFO, "Registered server command %s (%s)\n", cmd, desc);
 }
 
 
@@ -74,13 +74,13 @@ void CtdlUnregisterProtoHook(void (*handler) (char *), char *cmd)
                while (cur != NULL &&
                                handler == cur->handler &&
                                !strcmp(cmd, cur->cmd)) {
-                       lprintf(5, "Unregistered server command %s (%s)\n",
+                       lprintf(CTDL_INFO, "Unregistered server command %s (%s)\n",
                                        cmd, cur->desc);
                        p = cur->next;
                        if (cur == ProtoHookList) {
                                ProtoHookList = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -104,7 +104,8 @@ void initialize_server_extensions(void)
 {
        serv_bio_init();
        serv_calendar_init();
-       serv_inithat_init();
+       serv_ldap_init();
+       serv_chat_init();
        serv_expire_init();
        serv_imap_init();
        serv_inetcfg_init();
@@ -132,13 +133,13 @@ void CtdlRegisterLogHook(void (*fcn_ptr) (char *), int loglevel)
        struct LogFunctionHook *newfcn;
 
        newfcn = (struct LogFunctionHook *)
-           mallok(sizeof(struct LogFunctionHook));
+           malloc(sizeof(struct LogFunctionHook));
        newfcn->next = LogHookTable;
        newfcn->h_function_pointer = fcn_ptr;
        newfcn->loglevel = loglevel;
        LogHookTable = newfcn;
 
-       lprintf(5, "Registered a new logging function\n");
+       lprintf(CTDL_INFO, "Registered a new logging function\n");
 }
 
 
@@ -151,12 +152,12 @@ void CtdlUnregisterLogHook(void (*fcn_ptr) (char *), int loglevel)
                while (cur != NULL &&
                                fcn_ptr == cur->h_function_pointer &&
                                loglevel == cur->loglevel) {
-                       lprintf(5, "Unregistered logging function\n");
+                       lprintf(CTDL_INFO, "Unregistered logging function\n");
                        p = cur->next;
                        if (cur == LogHookTable) {
                                LogHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -169,12 +170,12 @@ void CtdlRegisterCleanupHook(void (*fcn_ptr) (void))
        struct CleanupFunctionHook *newfcn;
 
        newfcn = (struct CleanupFunctionHook *)
-           mallok(sizeof(struct CleanupFunctionHook));
+           malloc(sizeof(struct CleanupFunctionHook));
        newfcn->next = CleanupHookTable;
        newfcn->h_function_pointer = fcn_ptr;
        CleanupHookTable = newfcn;
 
-       lprintf(5, "Registered a new cleanup function\n");
+       lprintf(CTDL_INFO, "Registered a new cleanup function\n");
 }
 
 
@@ -186,12 +187,12 @@ void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void))
                /* This will also remove duplicates if any */
                while (cur != NULL &&
                                fcn_ptr == cur->h_function_pointer) {
-                       lprintf(5, "Unregistered cleanup function\n");
+                       lprintf(CTDL_INFO, "Unregistered cleanup function\n");
                        p = cur->next;
                        if (cur == CleanupHookTable) {
                                CleanupHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -204,13 +205,13 @@ void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType)
        struct SessionFunctionHook *newfcn;
 
        newfcn = (struct SessionFunctionHook *)
-           mallok(sizeof(struct SessionFunctionHook));
+           malloc(sizeof(struct SessionFunctionHook));
        newfcn->next = SessionHookTable;
        newfcn->h_function_pointer = fcn_ptr;
        newfcn->eventtype = EventType;
        SessionHookTable = newfcn;
 
-       lprintf(5, "Registered a new session function (type %d)\n",
+       lprintf(CTDL_INFO, "Registered a new session function (type %d)\n",
                EventType);
 }
 
@@ -224,37 +225,37 @@ void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType)
                while (cur != NULL &&
                                fcn_ptr == cur->h_function_pointer &&
                                EventType == cur->eventtype) {
-                       lprintf(5, "Unregistered session function (type %d)\n",
+                       lprintf(CTDL_INFO, "Unregistered session function (type %d)\n",
                                        EventType);
                        p = cur->next;
                        if (cur == SessionHookTable) {
                                SessionHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
 }
 
 
-void CtdlRegisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
+void CtdlRegisterUserHook(void (*fcn_ptr) (struct ctdluser *), int EventType)
 {
 
        struct UserFunctionHook *newfcn;
 
        newfcn = (struct UserFunctionHook *)
-           mallok(sizeof(struct UserFunctionHook));
+           malloc(sizeof(struct UserFunctionHook));
        newfcn->next = UserHookTable;
        newfcn->h_function_pointer = fcn_ptr;
        newfcn->eventtype = EventType;
        UserHookTable = newfcn;
 
-       lprintf(5, "Registered a new user function (type %d)\n",
+       lprintf(CTDL_INFO, "Registered a new user function (type %d)\n",
                EventType);
 }
 
 
-void CtdlUnregisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
+void CtdlUnregisterUserHook(void (*fcn_ptr) (struct ctdluser *), int EventType)
 {
        struct UserFunctionHook *cur, *p;
 
@@ -263,13 +264,13 @@ void CtdlUnregisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
                while (cur != NULL &&
                                fcn_ptr == cur->h_function_pointer &&
                                EventType == cur->eventtype) {
-                       lprintf(5, "Unregistered user function (type %d)\n",
+                       lprintf(CTDL_INFO, "Unregistered user function (type %d)\n",
                                        EventType);
                        p = cur->next;
                        if (cur == UserHookTable) {
                                UserHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -283,13 +284,13 @@ void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
        struct MessageFunctionHook *newfcn;
 
        newfcn = (struct MessageFunctionHook *)
-           mallok(sizeof(struct MessageFunctionHook));
+           malloc(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",
+       lprintf(CTDL_INFO, "Registered a new message function (type %d)\n",
                EventType);
 }
 
@@ -304,13 +305,13 @@ void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *),
                while (cur != NULL &&
                                handler == cur->h_function_pointer &&
                                EventType == cur->eventtype) {
-                       lprintf(5, "Unregistered message function (type %d)\n",
+                       lprintf(CTDL_INFO, "Unregistered message function (type %d)\n",
                                        EventType);
                        p = cur->next;
                        if (cur == MessageHookTable) {
                                MessageHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -322,12 +323,12 @@ void CtdlRegisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) )
        struct NetprocFunctionHook *newfcn;
 
        newfcn = (struct NetprocFunctionHook *)
-           mallok(sizeof(struct NetprocFunctionHook));
+           malloc(sizeof(struct NetprocFunctionHook));
        newfcn->next = NetprocHookTable;
        newfcn->h_function_pointer = handler;
        NetprocHookTable = newfcn;
 
-       lprintf(5, "Registered a new netproc function\n");
+       lprintf(CTDL_INFO, "Registered a new netproc function\n");
 }
 
 
@@ -339,12 +340,12 @@ void CtdlUnregisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) )
                /* This will also remove duplicates if any */
                while (cur != NULL &&
                                handler == cur->h_function_pointer ) {
-                       lprintf(5, "Unregistered netproc function\n");
+                       lprintf(CTDL_INFO, "Unregistered netproc function\n");
                        p = cur->next;
                        if (cur == NetprocHookTable) {
                                NetprocHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -356,12 +357,12 @@ void CtdlRegisterDeleteHook(void (*handler)(char *, long) )
        struct DeleteFunctionHook *newfcn;
 
        newfcn = (struct DeleteFunctionHook *)
-           mallok(sizeof(struct DeleteFunctionHook));
+           malloc(sizeof(struct DeleteFunctionHook));
        newfcn->next = DeleteHookTable;
        newfcn->h_function_pointer = handler;
        DeleteHookTable = newfcn;
 
-       lprintf(5, "Registered a new netproc function\n");
+       lprintf(CTDL_INFO, "Registered a new netproc function\n");
 }
 
 
@@ -373,12 +374,12 @@ void CtdlUnregisterDeleteHook(void (*handler)(char *, long) )
                /* This will also remove duplicates if any */
                while (cur != NULL &&
                                handler == cur->h_function_pointer ) {
-                       lprintf(5, "Unregistered netproc function\n");
+                       lprintf(CTDL_INFO, "Unregistered netproc function\n");
                        p = cur->next;
                        if (cur == DeleteHookTable) {
                                DeleteHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -391,12 +392,12 @@ void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
        struct XmsgFunctionHook *newfcn;
 
        newfcn = (struct XmsgFunctionHook *)
-           mallok(sizeof(struct XmsgFunctionHook));
+           malloc(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);
+       lprintf(CTDL_INFO, "Registered a new x-msg function (priority %d)\n", order);
 }
 
 
@@ -409,13 +410,13 @@ void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
                while (cur != NULL &&
                                fcn_ptr == cur->h_function_pointer &&
                                order == cur->order) {
-                       lprintf(5, "Unregistered x-msg function "
+                       lprintf(CTDL_INFO, "Unregistered x-msg function "
                                        "(priority %d)\n", order);
                        p = cur->next;
                        if (cur == XmsgHookTable) {
                                XmsgHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -431,7 +432,7 @@ void CtdlRegisterServiceHook(int tcp_port,
        char message[SIZ];
 
        newfcn = (struct ServiceFunctionHook *)
-           mallok(sizeof(struct ServiceFunctionHook));
+           malloc(sizeof(struct ServiceFunctionHook));
        newfcn->next = ServiceHookTable;
        newfcn->tcp_port = tcp_port;
        newfcn->sockpath = sockpath;
@@ -443,8 +444,8 @@ void CtdlRegisterServiceHook(int tcp_port,
                snprintf(message, sizeof message, "Unix domain socket '%s': ", sockpath);
        }
        else if (tcp_port <= 0) {       /* port -1 to disable */
-               lprintf(7, "Service has been manually disabled, skipping\n");
-               phree(newfcn);
+               lprintf(CTDL_INFO, "Service has been manually disabled, skipping\n");
+               free(newfcn);
                return;
        }
        else {
@@ -455,12 +456,12 @@ void CtdlRegisterServiceHook(int tcp_port,
        if (newfcn->msock > 0) {
                ServiceHookTable = newfcn;
                strcat(message, "registered.");
-               lprintf(5, "%s\n", message);
+               lprintf(CTDL_INFO, "%s\n", message);
        }
        else {
                strcat(message, "FAILED.");
-               lprintf(2, "%s\n", message);
-               phree(newfcn);
+               lprintf(CTDL_CRIT, "%s\n", message);
+               free(newfcn);
        }
 }
 
@@ -481,18 +482,18 @@ void CtdlUnregisterServiceHook(int tcp_port, char *sockpath,
                                tcp_port == cur->tcp_port) {
                        close(cur->msock);
                        if (sockpath) {
-                               lprintf(5, "Closed UNIX domain socket %s\n",
+                               lprintf(CTDL_INFO, "Closed UNIX domain socket %s\n",
                                                sockpath);
                        } else if (tcp_port) {
-                               lprintf(5, "Closed TCP port %d\n", tcp_port);
+                               lprintf(CTDL_INFO, "Closed TCP port %d\n", tcp_port);
                        } else {
-                               lprintf(5, "Unregistered unknown service\n");
+                               lprintf(CTDL_INFO, "Unregistered unknown service\n");
                        }
                        p = cur->next;
                        if (cur == ServiceHookTable) {
                                ServiceHookTable = p;
                        }
-                       phree(cur);
+                       free(cur);
                        cur = p;
                }
        }
@@ -521,13 +522,13 @@ void PerformLogHooks(int loglevel, char *logmsg)
        }
 }
 
-void PerformUserHooks(char *username, long usernum, int EventType)
+void PerformUserHooks(struct ctdluser *usbuf, int EventType)
 {
        struct UserFunctionHook *fcn;
 
        for (fcn = UserHookTable; fcn != NULL; fcn = fcn->next) {
                if (fcn->eventtype == EventType) {
-                       (*fcn->h_function_pointer) (username, usernum);
+                       (*fcn->h_function_pointer) (usbuf);
                }
        }
 }
@@ -539,11 +540,11 @@ int PerformMessageHooks(struct CtdlMessage *msg, int EventType)
 
        /* 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",
+       lprintf(CTDL_DEBUG, "** Event type is %d, flags are %d\n",
                EventType, msg->cm_flags);
         */
        if (msg->cm_flags & CM_SKIP_HOOKS) {
-               lprintf(9, "Skipping hooks\n");
+               lprintf(CTDL_DEBUG, "Skipping hooks\n");
                return(0);
        }