X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fserv_extensions.c;h=4b4e44c08ab958bdb32478fa6e1629dbaaf3cd8b;hb=60f03c2407f834ba677dfac9fe545db255ac8263;hp=45221c514eef4a3ced49c122cadc8e8c49e14c32;hpb=e85aa196b15dae29036b46a28412ce57961c85f9;p=citadel.git diff --git a/citadel/serv_extensions.c b/citadel/serv_extensions.c index 45221c514..4b4e44c08 100644 --- a/citadel/serv_extensions.c +++ b/citadel/serv_extensions.c @@ -5,57 +5,30 @@ * Copyright (c) 1987-2011 by the citadel.org team * * This program is open source software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. + * it under the terms of the GNU General Public License, version 3. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include "sysdep.h" #include -#include -#include -#include -#include -#include -#include -#include -#include #include -#include "citadel.h" -#include "server.h" -#include "serv_extensions.h" -#include "sysdep_decls.h" -#include "msgbase.h" -#include "config.h" +#include "sysdep_decls.h" #include "modules/crypto/serv_crypto.h" /* Needed until a universal crypto startup hook is implimented for CtdlStartTLS */ +#include "serv_extensions.h" #include "ctdl_module.h" -#ifndef HAVE_SNPRINTF -#include -#include "snprintf.h" -#endif +int DebugModules = 0; /* * Structure defentitions for hook tables */ -typedef struct __LogDebugEntry { - CtdlDbgFunction F; - const char *Name; - long Len; -} LogDebugEntry; HashList *LogDebugEntryTable = NULL; typedef struct LogFunctionHook LogFunctionHook; @@ -64,7 +37,8 @@ struct LogFunctionHook { int loglevel; void (*h_function_pointer) (char *); }; -extern LogFunctionHook *LogHookTable; + +LogFunctionHook *LogHookTable = NULL; typedef struct FixedOutputHook FixedOutputHook; struct FixedOutputHook { @@ -72,7 +46,23 @@ struct FixedOutputHook { char content_type[64]; void (*h_function_pointer) (char *, int); }; -extern FixedOutputHook *FixedOutputTable; +FixedOutputHook *FixedOutputTable = NULL; + + + +/* + * TDAPVetoHookFunctionHook extensions are used for any type of hook for which + * may prevent the autopurger to run for this specific data class. + * the function should at least LOG_INFO that it does so. + */ +typedef struct TDAPVetoHookFunctionHook TDAPVetoHookFunctionHook; +struct TDAPVetoHookFunctionHook { + TDAPVetoHookFunctionHook *next; + int Priority; + int (*h_function_pointer) (StrBuf *); + int eventtype; +}; +TDAPVetoHookFunctionHook *TDAPVetoHookTable = NULL; @@ -85,11 +75,11 @@ extern FixedOutputHook *FixedOutputTable; typedef struct SessionFunctionHook SessionFunctionHook; struct SessionFunctionHook { SessionFunctionHook *next; + int Priority; void (*h_function_pointer) (void); int eventtype; }; -extern SessionFunctionHook *SessionHookTable; - +SessionFunctionHook *SessionHookTable = NULL; /* * UserFunctionHook extensions are used for any type of hook which implements @@ -102,7 +92,7 @@ struct UserFunctionHook { void (*h_function_pointer) (struct ctdluser *usbuf); int eventtype; }; -extern UserFunctionHook *UserHookTable; +UserFunctionHook *UserHookTable = NULL; /* * MessageFunctionHook extensions are used for hooks which implement handlers @@ -111,10 +101,10 @@ extern UserFunctionHook *UserHookTable; typedef struct MessageFunctionHook MessageFunctionHook; struct MessageFunctionHook { MessageFunctionHook *next; - int (*h_function_pointer) (struct CtdlMessage *msg); + int (*h_function_pointer) (struct CtdlMessage *msg, recptypes *recps); int eventtype; }; -extern MessageFunctionHook *MessageHookTable; +MessageFunctionHook *MessageHookTable = NULL; /* @@ -126,7 +116,7 @@ struct NetprocFunctionHook { NetprocFunctionHook *next; int (*h_function_pointer) (struct CtdlMessage *msg, char *target_room); }; -extern NetprocFunctionHook *NetprocHookTable; +NetprocFunctionHook *NetprocHookTable = NULL; /* @@ -138,7 +128,7 @@ struct DeleteFunctionHook { DeleteFunctionHook *next; void (*h_function_pointer) (char *target_room, long msgnum); }; -extern DeleteFunctionHook *DeleteHookTable; +DeleteFunctionHook *DeleteHookTable = NULL; /* @@ -153,7 +143,7 @@ struct XmsgFunctionHook { int (*h_function_pointer) (char *, char *, char *, char *); int order; }; -extern XmsgFunctionHook *XmsgHookTable; +XmsgFunctionHook *XmsgHookTable = NULL; @@ -167,7 +157,7 @@ struct RoomFunctionHook { RoomFunctionHook *next; int (*fcn_ptr) (struct ctdlroom *); }; -extern RoomFunctionHook *RoomHookTable; +RoomFunctionHook *RoomHookTable = NULL; @@ -177,21 +167,12 @@ struct SearchFunctionHook { void (*fcn_ptr) (int *, long **, const char *); char *name; }; -extern SearchFunctionHook *SearchFunctionHookTable; - +SearchFunctionHook *SearchFunctionHookTable = NULL; CleanupFunctionHook *CleanupHookTable = NULL; CleanupFunctionHook *EVCleanupHookTable = NULL; -SessionFunctionHook *SessionHookTable = NULL; -UserFunctionHook *UserHookTable = NULL; -XmsgFunctionHook *XmsgHookTable = NULL; -MessageFunctionHook *MessageHookTable = NULL; -NetprocFunctionHook *NetprocHookTable = NULL; -DeleteFunctionHook *DeleteHookTable = NULL; + ServiceFunctionHook *ServiceHookTable = NULL; -FixedOutputHook *FixedOutputTable = NULL; -RoomFunctionHook *RoomHookTable = NULL; -SearchFunctionHook *SearchFunctionHookTable = NULL; typedef struct ProtoFunctionHook ProtoFunctionHook; struct ProtoFunctionHook { @@ -275,8 +256,8 @@ void LogPrintMessages(long err) StrBufAppendBufPlain(Message, HKEY("\n\n"), 0); StrBufAppendBufPlain(Message, CKEY(ErrGeneral[3]), 0); - syslog(LOG_EMERG, "%s", ChrPtr(Message)); - syslog(LOG_EMERG, "%s", ErrSubject); + MOD_syslog(LOG_EMERG, "%s", ChrPtr(Message)); + MOD_syslog(LOG_EMERG, "%s", ErrSubject); quickie_message("Citadel", NULL, NULL, AIDEROOM, ChrPtr(Message), FMT_FIXED, ErrSubject); FreeStrBuf(&Message); @@ -332,15 +313,8 @@ long FourHash(const char *key, long length) return ret; } -/* -typedef struct __LogDebugEntry { - CtdlDbgFunction F; - const char *Name; - long Len; -} LogDebugEntry; -HashList *LogDebugEntryTable = NULL; -*/ -void CtdlRegisterDebugFlagHook(const char *Name, long Len, CtdlDbgFunction F) + +void CtdlRegisterDebugFlagHook(const char *Name, long Len, CtdlDbgFunction F, const int *LogP) { LogDebugEntry *E; if (LogDebugEntryTable == NULL) @@ -349,6 +323,7 @@ void CtdlRegisterDebugFlagHook(const char *Name, long Len, CtdlDbgFunction F) E->F = F; E->Name = Name; E->Len = Len; + E->LogP = LogP; Put(LogDebugEntryTable, Name, Len, E, NULL); } @@ -377,7 +352,7 @@ void CtdlSetDebugLogFacilities(const char **Str, long n) (vptr != NULL)) { LogDebugEntry *E = (LogDebugEntry*)vptr; - E->F(); + E->F(1); } } } @@ -392,7 +367,7 @@ void CtdlSetDebugLogFacilities(const char **Str, long n) Pos = GetNewHashPos(LogDebugEntryTable, 0); while (GetNextHashPos(LogDebugEntryTable, Pos, &HKLen, &ch, &vptr)) { LogDebugEntry *E = (LogDebugEntry*)vptr; - E->F(); + E->F(1); } DeleteHashPos(&Pos); @@ -424,7 +399,7 @@ void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc) p->desc = desc; Put(ProtoHookList, cmd, 4, p, NULL); - syslog(LOG_INFO, "Registered server command %s (%s)\n", cmd, desc); + MOD_syslog(LOG_DEBUG, "Registered server command %s (%s)\n", cmd, desc); } void CtdlDestroyProtoHooks(void) @@ -445,26 +420,35 @@ void CtdlRegisterCleanupHook(void (*fcn_ptr) (void)) newfcn->h_function_pointer = fcn_ptr; CleanupHookTable = newfcn; - syslog(LOG_INFO, "Registered a new cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new cleanup function\n"); } void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void)) { - 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) { - syslog(LOG_INFO, "Unregistered cleanup function\n"); + CleanupFunctionHook *cur, *p, *last; + last = NULL; + cur = CleanupHookTable; + while (cur != NULL) + { + if (fcn_ptr == cur->h_function_pointer) + { + MODM_syslog(LOG_DEBUG, "Unregistered cleanup function\n"); p = cur->next; - if (cur == CleanupHookTable) { - CleanupHookTable = p; - } + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + CleanupHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -476,7 +460,7 @@ void CtdlDestroyCleanupHooks(void) cur = CleanupHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed cleanup function\n"); p = cur->next; free(cur); cur = p; @@ -495,26 +479,35 @@ void CtdlRegisterEVCleanupHook(void (*fcn_ptr) (void)) newfcn->h_function_pointer = fcn_ptr; EVCleanupHookTable = newfcn; - syslog(LOG_INFO, "Registered a new cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new cleanup function\n"); } void CtdlUnregisterEVCleanupHook(void (*fcn_ptr) (void)) { - CleanupFunctionHook *cur, *p; - - for (cur = EVCleanupHookTable; cur != NULL; cur = cur->next) { - /* This will also remove duplicates if any */ - while (cur != NULL && - fcn_ptr == cur->h_function_pointer) { - syslog(LOG_INFO, "Unregistered cleanup function\n"); + CleanupFunctionHook *cur, *p, *last; + last = NULL; + cur = EVCleanupHookTable; + while (cur != NULL) + { + if (fcn_ptr == cur->h_function_pointer) + { + MODM_syslog(LOG_DEBUG, "Unregistered cleanup function\n"); p = cur->next; - if (cur == EVCleanupHookTable) { - EVCleanupHookTable = p; - } + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + EVCleanupHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -526,50 +519,136 @@ void CtdlDestroyEVCleanupHooks(void) cur = EVCleanupHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed cleanup function\n"); p = cur->next; + cur->h_function_pointer(); free(cur); cur = p; } EVCleanupHookTable = NULL; } +void CtdlRegisterTDAPVetoHook(int (*fcn_ptr) (StrBuf*), int EventType, int Priority) +{ + TDAPVetoHookFunctionHook *newfcn; + + newfcn = (TDAPVetoHookFunctionHook *) + malloc(sizeof(TDAPVetoHookFunctionHook)); + newfcn->Priority = Priority; + newfcn->h_function_pointer = fcn_ptr; + newfcn->eventtype = EventType; -void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType) + TDAPVetoHookFunctionHook **pfcn; + pfcn = &TDAPVetoHookTable; + while ((*pfcn != NULL) && + ((*pfcn)->Priority < newfcn->Priority) && + ((*pfcn)->next != NULL)) + pfcn = &(*pfcn)->next; + + newfcn->next = *pfcn; + *pfcn = newfcn; + + MOD_syslog(LOG_DEBUG, "Registered a new TDAP Veto function (type %d Priority %d)\n", + EventType, Priority); +} + + +void CtdlUnregisterTDAPVetoHook(int (*fcn_ptr) (StrBuf*), int EventType) { + TDAPVetoHookFunctionHook *cur, *p, *last; + last = NULL; + cur = TDAPVetoHookTable; + while (cur != NULL) { + if ((fcn_ptr == cur->h_function_pointer) && + (EventType == cur->eventtype)) + { + MOD_syslog(LOG_DEBUG, "Unregistered TDAP Veto function (type %d)\n", + EventType); + p = cur->next; + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + TDAPVetoHookTable = p; + cur = p; + } + else { + last = cur; + cur = cur->next; + } + } +} + +void CtdlDestroyTDAPVetoHooks(void) +{ + TDAPVetoHookFunctionHook *cur, *p; + + cur = TDAPVetoHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed TDAP Veto function\n"); + p = cur->next; + free(cur); + cur = p; + } + TDAPVetoHookTable = NULL; +} + + +void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType, int Priority) +{ SessionFunctionHook *newfcn; newfcn = (SessionFunctionHook *) malloc(sizeof(SessionFunctionHook)); - newfcn->next = SessionHookTable; + newfcn->Priority = Priority; newfcn->h_function_pointer = fcn_ptr; newfcn->eventtype = EventType; - SessionHookTable = newfcn; - syslog(LOG_INFO, "Registered a new session function (type %d)\n", - EventType); + SessionFunctionHook **pfcn; + pfcn = &SessionHookTable; + while ((*pfcn != NULL) && + ((*pfcn)->Priority < newfcn->Priority) && + ((*pfcn)->next != NULL)) + pfcn = &(*pfcn)->next; + + newfcn->next = *pfcn; + *pfcn = newfcn; + + MOD_syslog(LOG_DEBUG, "Registered a new session function (type %d Priority %d)\n", + EventType, Priority); } void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType) { - 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) { - syslog(LOG_INFO, "Unregistered session function (type %d)\n", - EventType); + SessionFunctionHook *cur, *p, *last; + last = NULL; + cur = SessionHookTable; + while (cur != NULL) { + if ((fcn_ptr == cur->h_function_pointer) && + (EventType == cur->eventtype)) + { + MOD_syslog(LOG_DEBUG, "Unregistered session function (type %d)\n", + EventType); p = cur->next; - if (cur == SessionHookTable) { - SessionHookTable = p; - } + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + SessionHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -580,7 +659,7 @@ void CtdlDestroySessionHooks(void) cur = SessionHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed session function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed session function\n"); p = cur->next; free(cur); cur = p; @@ -601,29 +680,37 @@ void CtdlRegisterUserHook(void (*fcn_ptr) (ctdluser *), int EventType) newfcn->eventtype = EventType; UserHookTable = newfcn; - syslog(LOG_INFO, "Registered a new user function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Registered a new user function (type %d)\n", + EventType); } void CtdlUnregisterUserHook(void (*fcn_ptr) (struct ctdluser *), int EventType) { - 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) { - syslog(LOG_INFO, "Unregistered user function (type %d)\n", - EventType); + UserFunctionHook *cur, *p, *last; + last = NULL; + cur = UserHookTable; + while (cur != NULL) { + if ((fcn_ptr == cur->h_function_pointer) && + (EventType == cur->eventtype)) + { + MOD_syslog(LOG_DEBUG, "Unregistered user function (type %d)\n", + EventType); p = cur->next; - if (cur == UserHookTable) { - UserHookTable = p; - } + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + UserHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -634,7 +721,7 @@ void CtdlDestroyUserHooks(void) cur = UserHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed user function \n"); + MODM_syslog(LOG_DEBUG, "Destroyed user function \n"); p = cur->next; free(cur); cur = p; @@ -643,7 +730,7 @@ void CtdlDestroyUserHooks(void) } -void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *), +void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *, recptypes *), int EventType) { @@ -656,30 +743,37 @@ void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *), newfcn->eventtype = EventType; MessageHookTable = newfcn; - syslog(LOG_INFO, "Registered a new message function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Registered a new message function (type %d)\n", + EventType); } -void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *), +void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *, recptypes *), int EventType) { - 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) { - syslog(LOG_INFO, "Unregistered message function (type %d)\n", - EventType); + MessageFunctionHook *cur, *p, *last; + last = NULL; + cur = MessageHookTable; + while (cur != NULL) { + if ((handler == cur->h_function_pointer) && + (EventType == cur->eventtype)) + { + MOD_syslog(LOG_DEBUG, "Unregistered message function (type %d)\n", + EventType); p = cur->next; - if (cur == MessageHookTable) { - MessageHookTable = p; - } free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + MessageHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -690,7 +784,7 @@ void CtdlDestroyMessageHook(void) cur = MessageHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed message function (type %d)\n", cur->eventtype); + MOD_syslog(LOG_DEBUG, "Destroyed message function (type %d)\n", cur->eventtype); p = cur->next; free(cur); cur = p; @@ -709,24 +803,34 @@ void CtdlRegisterRoomHook(int (*fcn_ptr)(struct ctdlroom *)) newfcn->fcn_ptr = fcn_ptr; RoomHookTable = newfcn; - syslog(LOG_INFO, "Registered a new room function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new room function\n"); } void CtdlUnregisterRoomHook(int (*fcn_ptr)(struct ctdlroom *)) { - RoomFunctionHook *cur, *p; - - for (cur = RoomHookTable; cur != NULL; cur = cur->next) { - while (cur != NULL && fcn_ptr == cur->fcn_ptr) { - syslog(LOG_INFO, "Unregistered room function\n"); + RoomFunctionHook *cur, *p, *last; + last = NULL; + cur = RoomHookTable; + while (cur != NULL) + { + if (fcn_ptr == cur->fcn_ptr) { + MODM_syslog(LOG_DEBUG, "Unregistered room function\n"); p = cur->next; - if (cur == RoomHookTable) { - RoomHookTable = p; - } + free(cur); + cur = NULL; + + if (last != NULL) + last->next = p; + else + RoomHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -738,7 +842,7 @@ void CtdlDestroyRoomHooks(void) cur = RoomHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed room function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed room function\n"); p = cur->next; free(cur); cur = p; @@ -756,26 +860,35 @@ void CtdlRegisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) ) newfcn->h_function_pointer = handler; NetprocHookTable = newfcn; - syslog(LOG_INFO, "Registered a new netproc function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new netproc function\n"); } void CtdlUnregisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) ) { - NetprocFunctionHook *cur, *p; + NetprocFunctionHook *cur, *p, *last; - for (cur = NetprocHookTable; cur != NULL; cur = cur->next) { - /* This will also remove duplicates if any */ - while (cur != NULL && - handler == cur->h_function_pointer ) { - syslog(LOG_INFO, "Unregistered netproc function\n"); + cur = NetprocHookTable; + last = NULL; + + while (cur != NULL) { + if (handler == cur->h_function_pointer) + { + MODM_syslog(LOG_DEBUG, "Unregistered netproc function\n"); p = cur->next; - if (cur == NetprocHookTable) { + free(cur); + if (last != NULL) { + last->next = p; + } + else { NetprocHookTable = p; } - free(cur); cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -786,7 +899,7 @@ void CtdlDestroyNetprocHooks(void) cur = NetprocHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed netproc function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed netproc function\n"); p = cur->next; free(cur); cur = p; @@ -805,26 +918,34 @@ void CtdlRegisterDeleteHook(void (*handler)(char *, long) ) newfcn->h_function_pointer = handler; DeleteHookTable = newfcn; - syslog(LOG_INFO, "Registered a new delete function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new delete function\n"); } void CtdlUnregisterDeleteHook(void (*handler)(char *, long) ) { - DeleteFunctionHook *cur, *p; + DeleteFunctionHook *cur, *p, *last; - for (cur = DeleteHookTable; cur != NULL; cur = cur->next) { - /* This will also remove duplicates if any */ - while (cur != NULL && - handler == cur->h_function_pointer ) { - syslog(LOG_INFO, "Unregistered delete function\n"); + last = NULL; + cur = DeleteHookTable; + while (cur != NULL) { + if (handler == cur->h_function_pointer ) + { + MODM_syslog(LOG_DEBUG, "Unregistered delete function\n"); p = cur->next; - if (cur == DeleteHookTable) { - DeleteHookTable = p; - } free(cur); + + if (last != NULL) + last->next = p; + else + DeleteHookTable = p; + cur = p; } + else { + last = cur; + cur = cur->next; + } } } void CtdlDestroyDeleteHooks(void) @@ -834,7 +955,7 @@ void CtdlDestroyDeleteHooks(void) cur = DeleteHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed delete function\n"); + MODM_syslog(LOG_DEBUG, "Destroyed delete function\n"); p = cur->next; free(cur); cur = p; @@ -856,25 +977,38 @@ void CtdlRegisterFixedOutputHook(char *content_type, void (*handler)(char *, int safestrncpy(newfcn->content_type, content_type, sizeof newfcn->content_type); FixedOutputTable = newfcn; - syslog(LOG_INFO, "Registered a new fixed output function for %s\n", newfcn->content_type); + MOD_syslog(LOG_DEBUG, "Registered a new fixed output function for %s\n", newfcn->content_type); } void CtdlUnregisterFixedOutputHook(char *content_type) { - FixedOutputHook *cur, *p; + FixedOutputHook *cur, *p, *last; - for (cur = FixedOutputTable; cur != NULL; cur = cur->next) { + last = NULL; + cur = FixedOutputTable; + while (cur != NULL) { /* This will also remove duplicates if any */ - while (cur != NULL && (!strcasecmp(content_type, cur->content_type))) { - syslog(LOG_INFO, "Unregistered fixed output function for %s\n", content_type); + if (!strcasecmp(content_type, cur->content_type)) { + MOD_syslog(LOG_DEBUG, + "Unregistered fixed output function for %s\n", + content_type); + p = cur->next; - if (cur == FixedOutputTable) { - FixedOutputTable = p; - } free(cur); + + if (last != NULL) + last->next = p; + else + FixedOutputTable = p; + cur = p; } + else + { + last = cur; + cur = cur->next; + } } } @@ -885,7 +1019,7 @@ void CtdlDestroyFixedOutputHooks(void) cur = FixedOutputTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed fixed output function for %s\n", cur->content_type); + MOD_syslog(LOG_DEBUG, "Destroyed fixed output function for %s\n", cur->content_type); p = cur->next; free(cur); cur = p; @@ -922,28 +1056,36 @@ void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *, char *), int o newfcn->order = order; newfcn->h_function_pointer = fcn_ptr; XmsgHookTable = newfcn; - syslog(LOG_INFO, "Registered a new x-msg function (priority %d)\n", order); + MOD_syslog(LOG_DEBUG, "Registered a new x-msg function (priority %d)\n", order); } void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *, char *), int order) { - XmsgFunctionHook *cur, *p; + XmsgFunctionHook *cur, *p, *last; - for (cur = XmsgHookTable; cur != NULL; cur = cur->next) { + last = NULL; + cur = XmsgHookTable; + while (cur != NULL) { /* This will also remove duplicates if any */ - while (cur != NULL && - fcn_ptr == cur->h_function_pointer && - order == cur->order) { - syslog(LOG_INFO, "Unregistered x-msg function " - "(priority %d)\n", order); + if (fcn_ptr == cur->h_function_pointer && + order == cur->order) { + MOD_syslog(LOG_DEBUG, "Unregistered x-msg function " + "(priority %d)\n", order); p = cur->next; - if (cur == XmsgHookTable) { - XmsgHookTable = p; - } free(cur); + + if (last != NULL) + last->next = p; + else + XmsgHookTable = p; + cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -954,7 +1096,7 @@ void CtdlDestroyXmsgHooks(void) cur = XmsgHookTable; while (cur != NULL) { - syslog(LOG_INFO, "Destroyed x-msg function " + MOD_syslog(LOG_DEBUG, "Destroyed x-msg function " "(priority %d)\n", cur->order); p = cur->next; @@ -993,7 +1135,7 @@ void CtdlRegisterServiceHook(int tcp_port, snprintf(message, SIZ, "Unix domain socket '%s': ", sockpath); } else if (tcp_port <= 0) { /* port -1 to disable */ - syslog(LOG_INFO, "Service %s has been manually disabled, skipping\n", ServiceName); + MOD_syslog(LOG_INFO, "Service %s has been manually disabled, skipping\n", ServiceName); free (message); free(newfcn); return; @@ -1010,12 +1152,12 @@ void CtdlRegisterServiceHook(int tcp_port, if (newfcn->msock > 0) { ServiceHookTable = newfcn; strcat(message, "registered."); - syslog(LOG_INFO, "%s\n", message); + MOD_syslog(LOG_INFO, "%s\n", message); } else { AddPortError(message, error); strcat(message, "FAILED."); - syslog(LOG_CRIT, "%s\n", message); + MOD_syslog(LOG_CRIT, "%s\n", message); free(newfcn); } free(message); @@ -1028,35 +1170,41 @@ void CtdlUnregisterServiceHook(int tcp_port, char *sockpath, void (*h_async_function) (void) ) { - ServiceFunctionHook *cur, *p; + ServiceFunctionHook *cur, *p, *last; + last = NULL; cur = ServiceHookTable; while (cur != NULL) { /* 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 && - h_async_function == cur->h_async_function && - tcp_port == cur->tcp_port) { - close(cur->msock); + if (h_greeting_function == cur->h_greeting_function && + h_command_function == cur->h_command_function && + h_async_function == cur->h_async_function && + tcp_port == cur->tcp_port && + !(sockpath && cur->sockpath && strcmp(sockpath, cur->sockpath)) ) + { + if (cur->msock > 0) + close(cur->msock); if (sockpath) { - syslog(LOG_INFO, "Closed UNIX domain socket %s\n", - sockpath); + MOD_syslog(LOG_INFO, "Closed UNIX domain socket %s\n", + sockpath); unlink(sockpath); } else if (tcp_port) { - syslog(LOG_INFO, "Closed TCP port %d\n", tcp_port); + MOD_syslog(LOG_INFO, "Closed TCP port %d\n", tcp_port); } else { - syslog(LOG_INFO, "Unregistered service \"%s\"\n", cur->ServiceName); + MOD_syslog(LOG_INFO, "Unregistered service \"%s\"\n", cur->ServiceName); } p = cur->next; - if (cur == ServiceHookTable) { - ServiceHookTable = p; - } free(cur); + if (last != NULL) + last->next = p; + else + ServiceHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -1074,13 +1222,13 @@ void CtdlShutdownServiceHooks(void) close(cur->msock); cur->msock = -1; if (cur->sockpath != NULL){ - syslog(LOG_INFO, "[%s] Closed UNIX domain socket %s\n", - cur->ServiceName, - cur->sockpath); + MOD_syslog(LOG_INFO, "[%s] Closed UNIX domain socket %s\n", + cur->ServiceName, + cur->sockpath); unlink(cur->sockpath); } else { - syslog(LOG_INFO, "[%s] closing service\n", - cur->ServiceName); + MOD_syslog(LOG_INFO, "[%s] closing service\n", + cur->ServiceName); } } cur = cur->next; @@ -1089,20 +1237,31 @@ void CtdlShutdownServiceHooks(void) void CtdlDestroyServiceHook(void) { + const char *Text; ServiceFunctionHook *cur, *p; cur = ServiceHookTable; while (cur != NULL) { - close(cur->msock); + if (cur->msock != -1) + { + close(cur->msock); + Text = "Closed"; + } + else + { + Text = " Not closing again"; + } + if (cur->sockpath) { - syslog(LOG_INFO, "Closed UNIX domain socket %s\n", - cur->sockpath); + MOD_syslog(LOG_INFO, "%s UNIX domain socket %s\n", + Text, + cur->sockpath); unlink(cur->sockpath); } else if (cur->tcp_port) { - syslog(LOG_INFO, "Closed TCP port %d\n", cur->tcp_port); + MOD_syslog(LOG_INFO, "%s TCP port %d\n", Text, cur->tcp_port); } else { - syslog(LOG_INFO, "Destroyed service \"%s\"\n", cur->ServiceName); + MOD_syslog(LOG_INFO, "Destroyed service \"%s\"\n", cur->ServiceName); } p = cur->next; free(cur); @@ -1126,23 +1285,33 @@ void CtdlRegisterSearchFuncHook(void (*fcn_ptr)(int *, long **, const char *), c newfcn->fcn_ptr = fcn_ptr; SearchFunctionHookTable = newfcn; - syslog(LOG_INFO, "Registered a new search function (%s)\n", name); + MOD_syslog(LOG_DEBUG, "Registered a new search function (%s)\n", name); } void CtdlUnregisterSearchFuncHook(void (*fcn_ptr)(int *, long **, const char *), char *name) { - SearchFunctionHook *cur, *p; + SearchFunctionHook *cur, *p, *last; - for (cur = SearchFunctionHookTable; cur != NULL; cur = cur->next) { - while (fcn_ptr && (cur->fcn_ptr == fcn_ptr) && name && !strcmp(name, cur->name)) { - syslog(LOG_INFO, "Unregistered search function(%s)\n", name); + last = NULL; + cur = SearchFunctionHookTable; + while (cur != NULL) { + if (fcn_ptr && + (cur->fcn_ptr == fcn_ptr) && + name && !strcmp(name, cur->name)) + { + MOD_syslog(LOG_DEBUG, "Unregistered search function(%s)\n", name); p = cur->next; - if (cur == SearchFunctionHookTable) { - SearchFunctionHookTable = p; - } free (cur); + if (last != NULL) + last->next = p; + else + SearchFunctionHookTable = p; cur = p; } + else { + last = cur; + cur = cur->next; + } } } @@ -1172,6 +1341,18 @@ void CtdlModuleDoSearch(int *num_msgs, long **search_msgs, const char *search_st *num_msgs = 0; } +int CheckTDAPVeto (int DBType, StrBuf *ErrMsg) +{ + int Result = 0; + TDAPVetoHookFunctionHook *fcn = NULL; + + for (fcn = TDAPVetoHookTable; (fcn != NULL) && (Result == 0); fcn = fcn->next) { + if (fcn->eventtype == DBType) { + Result = (*fcn->h_function_pointer) (ErrMsg); + } + } + return Result; +} void PerformSessionHooks(int EventType) { @@ -1198,17 +1379,17 @@ void PerformUserHooks(ctdluser *usbuf, int EventType) } } -int PerformMessageHooks(struct CtdlMessage *msg, int EventType) +int PerformMessageHooks(struct CtdlMessage *msg, recptypes *recps, int EventType) { MessageFunctionHook *fcn = NULL; 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. - syslog(LOG_DEBUG, "** Event type is %d, flags are %d\n", EventType, msg->cm_flags); + MOD_syslog(LOG_DEBUG, "** Event type is %d, flags are %d\n", EventType, msg->cm_flags); */ if (msg->cm_flags & CM_SKIP_HOOKS) { - syslog(LOG_DEBUG, "Skipping hooks\n"); + MODM_syslog(LOG_DEBUG, "Skipping hooks\n"); return(0); } @@ -1216,7 +1397,7 @@ int PerformMessageHooks(struct CtdlMessage *msg, int EventType) */ for (fcn = MessageHookTable; fcn != NULL; fcn = fcn->next) { if (fcn->eventtype == EventType) { - total_retval = total_retval + (*fcn->h_function_pointer) (msg); + total_retval = total_retval + (*fcn->h_function_pointer) (msg, recps); } } @@ -1233,7 +1414,7 @@ int PerformRoomHooks(struct ctdlroom *target_room) RoomFunctionHook *fcn; int total_retval = 0; - syslog(LOG_DEBUG, "Performing room hooks for <%s>\n", target_room->QRname); + MOD_syslog(LOG_DEBUG, "Performing room hooks for <%s>\n", target_room->QRname); for (fcn = RoomHookTable; fcn != NULL; fcn = fcn->next) { total_retval = total_retval + (*fcn->fcn_ptr) (target_room); @@ -1309,3 +1490,15 @@ void CtdlModuleStartCryptoMsgs(char *ok_response, char *nosup_response, char *er CtdlStartTLS (ok_response, nosup_response, error_response); #endif } + +void DebugModulesEnable(const int n) +{ + DebugModules = n; +} +CTDL_MODULE_INIT(modules) +{ + if (!threading) { + CtdlRegisterDebugFlagHook(HKEY("modules"), DebugModulesEnable, &DebugModules); + } + return "modules"; +}