X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fserv_extensions.c;h=9100daea3509c914b2df4a8670de418b146b9bda;hb=9f3bb5c0737c12bd1765425ad8676d5cde03f52f;hp=cb0618a61cdee24d3affd39ed8a2b499c30ce3af;hpb=45f9eabf6d47b4e6cc9e8b85f2183bdeb8a2149c;p=citadel.git diff --git a/citadel/serv_extensions.c b/citadel/serv_extensions.c index cb0618a61..9100daea3 100644 --- a/citadel/serv_extensions.c +++ b/citadel/serv_extensions.c @@ -1,9 +1,22 @@ /* - * $Id$ - * * Citadel Dynamic Loading Module * Written by Brian Costello * + * 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. + * + * 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" @@ -15,42 +28,434 @@ #include #include #include +#include +#include #include "citadel.h" #include "server.h" #include "serv_extensions.h" #include "sysdep_decls.h" #include "msgbase.h" -#include "tools.h" #include "config.h" +#include "modules/crypto/serv_crypto.h" /* Needed until a universal crypto startup hook is implimented for CtdlStartTLS */ + +#include "ctdl_module.h" + #ifndef HAVE_SNPRINTF #include #include "snprintf.h" #endif -struct CleanupFunctionHook *CleanupHookTable = NULL; -struct SessionFunctionHook *SessionHookTable = NULL; -struct UserFunctionHook *UserHookTable = NULL; -struct XmsgFunctionHook *XmsgHookTable = NULL; -struct MessageFunctionHook *MessageHookTable = NULL; -struct NetprocFunctionHook *NetprocHookTable = NULL; -struct DeleteFunctionHook *DeleteHookTable = NULL; -struct ServiceFunctionHook *ServiceHookTable = NULL; -struct FixedOutputHook *FixedOutputTable = NULL; +int DebugModules = 0; + +/* + * Structure defentitions for hook tables + */ + +typedef struct __LogDebugEntry { + CtdlDbgFunction F; + const char *Name; + long Len; + const int *LogP; +} LogDebugEntry; +HashList *LogDebugEntryTable = NULL; + +typedef struct LogFunctionHook LogFunctionHook; +struct LogFunctionHook { + LogFunctionHook *next; + int loglevel; + void (*h_function_pointer) (char *); +}; +extern LogFunctionHook *LogHookTable; + +typedef struct FixedOutputHook FixedOutputHook; +struct FixedOutputHook { + FixedOutputHook *next; + char content_type[64]; + void (*h_function_pointer) (char *, int); +}; +extern FixedOutputHook *FixedOutputTable; + + + +/* + * SessionFunctionHook extensions are used for any type of hook for which + * the context in which it's being called (which is determined by the event + * type) will make it obvious for the hook function to know where to look for + * pertinent data. + */ +typedef struct SessionFunctionHook SessionFunctionHook; +struct SessionFunctionHook { + SessionFunctionHook *next; + void (*h_function_pointer) (void); + int eventtype; +}; +extern SessionFunctionHook *SessionHookTable; + + +/* + * UserFunctionHook extensions are used for any type of hook which implements + * an operation on a user or username (potentially) other than the one + * operating the current session. + */ +typedef struct UserFunctionHook UserFunctionHook; +struct UserFunctionHook { + UserFunctionHook *next; + void (*h_function_pointer) (struct ctdluser *usbuf); + int eventtype; +}; +extern UserFunctionHook *UserHookTable; + +/* + * MessageFunctionHook extensions are used for hooks which implement handlers + * for various types of message operations (save, read, etc.) + */ +typedef struct MessageFunctionHook MessageFunctionHook; +struct MessageFunctionHook { + MessageFunctionHook *next; + int (*h_function_pointer) (struct CtdlMessage *msg); + int eventtype; +}; +extern MessageFunctionHook *MessageHookTable; + + +/* + * NetprocFunctionHook extensions are used for hooks which implement handlers + * for incoming network messages. + */ +typedef struct NetprocFunctionHook NetprocFunctionHook; +struct NetprocFunctionHook { + NetprocFunctionHook *next; + int (*h_function_pointer) (struct CtdlMessage *msg, char *target_room); +}; +extern NetprocFunctionHook *NetprocHookTable; + + +/* + * DeleteFunctionHook extensions are used for hooks which get called when a + * message is about to be deleted. + */ +typedef struct DeleteFunctionHook DeleteFunctionHook; +struct DeleteFunctionHook { + DeleteFunctionHook *next; + void (*h_function_pointer) (char *target_room, long msgnum); +}; +extern DeleteFunctionHook *DeleteHookTable; + + +/* + * ExpressMessageFunctionHook extensions are used for hooks which implement + * the sending of an instant message through various channels. Any function + * registered should return the number of recipients to whom the message was + * successfully transmitted. + */ +typedef struct XmsgFunctionHook XmsgFunctionHook; +struct XmsgFunctionHook { + XmsgFunctionHook *next; + int (*h_function_pointer) (char *, char *, char *, char *); + int order; +}; +extern XmsgFunctionHook *XmsgHookTable; + + + +/* + * RoomFunctionHook extensions are used for hooks which impliment room + * processing functions when new messages are added EG. SIEVE. + */ +typedef struct RoomFunctionHook RoomFunctionHook; +struct RoomFunctionHook { + RoomFunctionHook *next; + int (*fcn_ptr) (struct ctdlroom *); +}; +extern RoomFunctionHook *RoomHookTable; + + + +typedef struct SearchFunctionHook SearchFunctionHook; +struct SearchFunctionHook { + SearchFunctionHook *next; + void (*fcn_ptr) (int *, long **, const char *); + char *name; +}; +extern SearchFunctionHook *SearchFunctionHookTable; + + +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 { void (*handler) (char *cmdbuf); - char *cmd; - char *desc; - struct ProtoFunctionHook *next; -} *ProtoHookList = NULL; + const char *cmd; + const char *desc; +}; + +HashList *ProtoHookList = NULL; + + +#define ERR_PORT (1 << 1) + + +static StrBuf *portlist = NULL; + +static StrBuf *errormessages = NULL; + + +long DetailErrorFlags; +ConstStr Empty = {HKEY("")}; +char *ErrSubject = "Startup Problems"; +ConstStr ErrGeneral[] = { + {HKEY("Citadel had trouble on starting up. ")}, + {HKEY(" This means, citadel won't be the service provider for a specific service you configured it to.\n\n" + "If you don't want citadel to provide these services, turn them off in WebCit via: ")}, + {HKEY("To make both ways actualy take place restart the citserver with \"sendcommand down\"\n\n" + "The errors returned by the system were:\n")}, + {HKEY("You can recheck the above if you follow this faq item:\n" + "http://www.citadel.org/doku.php?id=faq:mastering_your_os:net#netstat")} +}; + +ConstStr ErrPortShort = { HKEY("We couldn't bind all ports you configured to be provided by citadel server.\n")}; +ConstStr ErrPortWhere = { HKEY("\"Admin->System Preferences->Network\".\n\nThe failed ports and sockets are: ")}; +ConstStr ErrPortHint = { HKEY("If you want citadel to provide you with that functionality, " + "check the output of \"netstat -lnp\" on linux Servers or \"netstat -na\" on *BSD" + " and stop the program that binds these ports.\n You should eventually remove " + " their initscripts in /etc/init.d so that you won't get this trouble once more.\n" + " After that goto \"Administration -> Shutdown Citadel\" to make Citadel restart & retry to bind this port.\n")}; + + +void LogPrintMessages(long err) +{ + StrBuf *Message; + StrBuf *List, *DetailList; + ConstStr *Short, *Where, *Hint; + + + Message = NewStrBufPlain(NULL, + StrLength(portlist) + StrLength(errormessages)); + + DetailErrorFlags = DetailErrorFlags & ~err; + + switch (err) + { + case ERR_PORT: + Short = &ErrPortShort; + Where = &ErrPortWhere; + Hint = &ErrPortHint; + List = portlist; + DetailList = errormessages; + break; + default: + Short = &Empty; + Where = &Empty; + Hint = &Empty; + List = NULL; + DetailList = NULL; + } + + StrBufAppendBufPlain(Message, CKEY(ErrGeneral[0]), 0); + StrBufAppendBufPlain(Message, CKEY(*Short), 0); + StrBufAppendBufPlain(Message, CKEY(ErrGeneral[1]), 0); + StrBufAppendBufPlain(Message, CKEY(*Where), 0); + StrBufAppendBuf(Message, List, 0); + StrBufAppendBufPlain(Message, HKEY("\n\n"), 0); + StrBufAppendBufPlain(Message, CKEY(*Hint), 0); + StrBufAppendBufPlain(Message, HKEY("\n\n"), 0); + StrBufAppendBufPlain(Message, CKEY(ErrGeneral[2]), 0); + StrBufAppendBuf(Message, DetailList, 0); + StrBufAppendBufPlain(Message, HKEY("\n\n"), 0); + StrBufAppendBufPlain(Message, CKEY(ErrGeneral[3]), 0); + + 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); + FreeStrBuf(&List); + FreeStrBuf(&DetailList); +} + + +void AddPortError(char *Port, char *ErrorMessage) +{ + long len; + + DetailErrorFlags |= ERR_PORT; + + len = StrLength(errormessages); + if (len > 0) StrBufAppendBufPlain(errormessages, HKEY("; "), 0); + else errormessages = NewStrBuf(); + StrBufAppendBufPlain(errormessages, ErrorMessage, -1, 0); + + + len = StrLength(portlist); + if (len > 0) StrBufAppendBufPlain(portlist, HKEY(";"), 0); + else portlist = NewStrBuf(); + StrBufAppendBufPlain(portlist, Port, -1, 0); +} + + +int DLoader_Exec_Cmd(char *cmdbuf) +{ + void *vP; + ProtoFunctionHook *p; + + if (GetHash(ProtoHookList, cmdbuf, 4, &vP) && (vP != NULL)) { + p = (ProtoFunctionHook*) vP; + p->handler(&cmdbuf[5]); + return 1; + } + return 0; +} + +long FourHash(const char *key, long length) +{ + int i; + int ret = 0; + const unsigned char *ptr = (const unsigned char*)key; + + for (i = 0; i < 4; i++, ptr ++) + ret = (ret << 8) | + ( ((*ptr >= 'a') && + (*ptr <= 'z'))? + *ptr - 'a' + 'A': + *ptr); + + return ret; +} + +void CtdlRegisterDebugFlagHook(const char *Name, long Len, CtdlDbgFunction F, const int *LogP) +{ + LogDebugEntry *E; + if (LogDebugEntryTable == NULL) + LogDebugEntryTable = NewHash(1, NULL); + E = (LogDebugEntry*) malloc(sizeof(LogDebugEntry)); + E->F = F; + E->Name = Name; + E->Len = Len; + E->LogP = LogP; + Put(LogDebugEntryTable, Name, Len, E, NULL); + +} +void CtdlSetDebugLogFacilities(const char **Str, long n) +{ + StrBuf *Token = NULL; + StrBuf *Buf = NULL; + const char *ch; + int i; + int DoAll = 0; + void *vptr; + + for (i=0; i < n; i++){ + if ((Str[i] != NULL) && !IsEmptyStr(Str[i])) { + if (strcmp(Str[i], "all") == 0) { + DoAll = 1; + continue; + } + Buf = NewStrBufPlain(Str[i], -1); + ch = NULL; + if (Token == NULL) + Token = NewStrBufPlain(NULL, StrLength(Buf)); + while ((ch != StrBufNOTNULL) && + StrBufExtract_NextToken(Token, Buf, &ch, ',')) { + if (GetHash(LogDebugEntryTable, SKEY(Token), &vptr) && + (vptr != NULL)) + { + LogDebugEntry *E = (LogDebugEntry*)vptr; + E->F(1); + } + } + } + FreeStrBuf(&Buf); + } + FreeStrBuf(&Token); + if (DoAll) { + long HKLen; + const char *ch; + HashPos *Pos; + + Pos = GetNewHashPos(LogDebugEntryTable, 0); + while (GetNextHashPos(LogDebugEntryTable, Pos, &HKLen, &ch, &vptr)) { + LogDebugEntry *E = (LogDebugEntry*)vptr; + E->F(1); + } + + DeleteHashPos(&Pos); + } +} +void cmd_log_get(char *argbuf) +{ + long HKLen; + const char *ch; + HashPos *Pos; + void *vptr; + + if (CtdlAccessCheck(ac_aide)) return; + + cprintf("%d Log modules enabled:\n", LISTING_FOLLOWS); + + Pos = GetNewHashPos(LogDebugEntryTable, 0); + + while (GetNextHashPos(LogDebugEntryTable, Pos, &HKLen, &ch, &vptr)) { + LogDebugEntry *E = (LogDebugEntry*)vptr; + cprintf("%s: %d\n", ch, *E->LogP); + } + + DeleteHashPos(&Pos); + cprintf("000\n"); +} +void cmd_log_set(char *argbuf) +{ + void *vptr; + int lset; + int wlen; + char which[SIZ] = ""; + + if (CtdlAccessCheck(ac_aide)) return; + + wlen = extract_token(which, argbuf, 0, '|', sizeof(which)); + if (wlen < 0) wlen = 0; + lset = extract_int(argbuf, 1); + if (lset != 0) lset = 1; + if (GetHash(LogDebugEntryTable, which, wlen, &vptr) && + (vptr != NULL)) + { + LogDebugEntry *E = (LogDebugEntry*)vptr; + E->F(lset); + cprintf("%d %s|%d\n", CIT_OK, which, lset); + } + else { + cprintf("%d Log setting %s not known\n", + ERROR, which); + } +} +void CtdlDestroyDebugTable(void) +{ + + DeleteHash(&LogDebugEntryTable); +} void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc) { - struct ProtoFunctionHook *p; + ProtoFunctionHook *p; + + if (ProtoHookList == NULL) + ProtoHookList = NewHash (1, FourHash); + - p = (struct ProtoFunctionHook *) - malloc(sizeof(struct ProtoFunctionHook)); + p = (ProtoFunctionHook *) + malloc(sizeof(ProtoFunctionHook)); if (p == NULL) { fprintf(stderr, "can't malloc new ProtoFunctionHook\n"); @@ -59,26 +464,45 @@ void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc) p->handler = handler; p->cmd = cmd; p->desc = desc; - p->next = ProtoHookList; - ProtoHookList = p; - lprintf(CTDL_INFO, "Registered server command %s (%s)\n", cmd, desc); + + Put(ProtoHookList, cmd, 4, p, NULL); + MOD_syslog(LOG_DEBUG, "Registered server command %s (%s)\n", cmd, desc); +} + +void CtdlDestroyProtoHooks(void) +{ + + DeleteHash(&ProtoHookList); +} + + +void CtdlRegisterCleanupHook(void (*fcn_ptr) (void)) +{ + + CleanupFunctionHook *newfcn; + + newfcn = (CleanupFunctionHook *) + malloc(sizeof(CleanupFunctionHook)); + newfcn->next = CleanupHookTable; + newfcn->h_function_pointer = fcn_ptr; + CleanupHookTable = newfcn; + + MODM_syslog(LOG_DEBUG, "Registered a new cleanup function\n"); } -void CtdlUnregisterProtoHook(void (*handler) (char *), char *cmd) +void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void)) { - struct ProtoFunctionHook *cur, *p; + CleanupFunctionHook *cur, *p; - for (cur = ProtoHookList; cur != NULL; cur = cur->next) { + for (cur = CleanupHookTable; cur != NULL; cur = cur->next) { /* This will also remove duplicates if any */ while (cur != NULL && - handler == cur->handler && - !strcmp(cmd, cur->cmd)) { - lprintf(CTDL_INFO, "Unregistered server command %s (%s)\n", - cmd, cur->desc); + fcn_ptr == cur->h_function_pointer) { + MODM_syslog(LOG_DEBUG, "Unregistered cleanup function\n"); p = cur->next; - if (cur == ProtoHookList) { - ProtoHookList = p; + if (cur == CleanupHookTable) { + CleanupHookTable = p; } free(cur); cur = p; @@ -87,78 +511,48 @@ void CtdlUnregisterProtoHook(void (*handler) (char *), char *cmd) } -int DLoader_Exec_Cmd(char *cmdbuf) +void CtdlDestroyCleanupHooks(void) { - struct ProtoFunctionHook *p; - - for (p = ProtoHookList; p; p = p->next) { - if (!strncasecmp(cmdbuf, p->cmd, 4)) { - p->handler(&cmdbuf[5]); - return 1; - } + CleanupFunctionHook *cur, *p; + + cur = CleanupHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed cleanup function\n"); + p = cur->next; + free(cur); + cur = p; } - return 0; -} - -void initialize_server_extensions(void) -{ - lprintf(CTDL_INFO, "%s\n", serv_bio_init()); - lprintf(CTDL_INFO, "%s\n", serv_calendar_init()); - lprintf(CTDL_INFO, "%s\n", serv_notes_init()); - lprintf(CTDL_INFO, "%s\n", serv_ldap_init()); - lprintf(CTDL_INFO, "%s\n", serv_chat_init()); - lprintf(CTDL_INFO, "%s\n", serv_expire_init()); - lprintf(CTDL_INFO, "%s\n", serv_imap_init()); - lprintf(CTDL_INFO, "%s\n", serv_upgrade_init()); - lprintf(CTDL_INFO, "%s\n", serv_inetcfg_init()); - lprintf(CTDL_INFO, "%s\n", serv_listsub_init()); - lprintf(CTDL_INFO, "%s\n", serv_mrtg_init()); - lprintf(CTDL_INFO, "%s\n", serv_netfilter_init()); - lprintf(CTDL_INFO, "%s\n", serv_network_init()); - lprintf(CTDL_INFO, "%s\n", serv_newuser_init()); - lprintf(CTDL_INFO, "%s\n", serv_pas2_init()); - lprintf(CTDL_INFO, "%s\n", serv_pop3_init()); - lprintf(CTDL_INFO, "%s\n", serv_rwho_init()); - lprintf(CTDL_INFO, "%s\n", serv_smtp_init()); - lprintf(CTDL_INFO, "%s\n", serv_spam_init()); - /* lprintf(CTDL_INFO, "%s\n", serv_test_init()); */ - lprintf(CTDL_INFO, "%s\n", serv_vandelay_init()); - lprintf(CTDL_INFO, "%s\n", serv_vcard_init()); - lprintf(CTDL_INFO, "%s\n", serv_fulltext_init()); - lprintf(CTDL_INFO, "%s\n", serv_autocompletion_init()); - lprintf(CTDL_INFO, "%s\n", serv_postfix_tcpdict()); - lprintf(CTDL_INFO, "%s\n", serv_managesieve_init()); + CleanupHookTable = NULL; } - - -void CtdlRegisterCleanupHook(void (*fcn_ptr) (void)) +void CtdlRegisterEVCleanupHook(void (*fcn_ptr) (void)) { - struct CleanupFunctionHook *newfcn; + CleanupFunctionHook *newfcn; - newfcn = (struct CleanupFunctionHook *) - malloc(sizeof(struct CleanupFunctionHook)); - newfcn->next = CleanupHookTable; + newfcn = (CleanupFunctionHook *) + malloc(sizeof(CleanupFunctionHook)); + newfcn->next = EVCleanupHookTable; newfcn->h_function_pointer = fcn_ptr; - CleanupHookTable = newfcn; + EVCleanupHookTable = newfcn; - lprintf(CTDL_INFO, "Registered a new cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new cleanup function\n"); } -void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void)) +void CtdlUnregisterEVCleanupHook(void (*fcn_ptr) (void)) { - struct CleanupFunctionHook *cur, *p; + CleanupFunctionHook *cur, *p; - for (cur = CleanupHookTable; cur != NULL; cur = cur->next) { + for (cur = EVCleanupHookTable; cur != NULL; cur = cur->next) { /* This will also remove duplicates if any */ while (cur != NULL && fcn_ptr == cur->h_function_pointer) { - lprintf(CTDL_INFO, "Unregistered cleanup function\n"); + MODM_syslog(LOG_DEBUG, "Unregistered cleanup function\n"); p = cur->next; - if (cur == CleanupHookTable) { - CleanupHookTable = p; + if (cur == EVCleanupHookTable) { + EVCleanupHookTable = p; } free(cur); cur = p; @@ -167,34 +561,50 @@ void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void)) } +void CtdlDestroyEVCleanupHooks(void) +{ + CleanupFunctionHook *cur, *p; + + cur = EVCleanupHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed cleanup function\n"); + p = cur->next; + free(cur); + cur = p; + } + EVCleanupHookTable = NULL; +} + + void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType) { - struct SessionFunctionHook *newfcn; + SessionFunctionHook *newfcn; - newfcn = (struct SessionFunctionHook *) - malloc(sizeof(struct SessionFunctionHook)); + newfcn = (SessionFunctionHook *) + malloc(sizeof(SessionFunctionHook)); newfcn->next = SessionHookTable; newfcn->h_function_pointer = fcn_ptr; newfcn->eventtype = EventType; SessionHookTable = newfcn; - lprintf(CTDL_INFO, "Registered a new session function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Registered a new session function (type %d)\n", + EventType); } void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType) { - struct SessionFunctionHook *cur, *p; + 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(CTDL_INFO, "Unregistered session function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Unregistered session function (type %d)\n", + EventType); p = cur->next; if (cur == SessionHookTable) { SessionHookTable = p; @@ -205,35 +615,50 @@ void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType) } } +void CtdlDestroySessionHooks(void) +{ + SessionFunctionHook *cur, *p; + + cur = SessionHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed session function\n"); + p = cur->next; + free(cur); + cur = p; + } + SessionHookTable = NULL; +} + -void CtdlRegisterUserHook(void (*fcn_ptr) (struct ctdluser *), int EventType) +void CtdlRegisterUserHook(void (*fcn_ptr) (ctdluser *), int EventType) { - struct UserFunctionHook *newfcn; + UserFunctionHook *newfcn; - newfcn = (struct UserFunctionHook *) - malloc(sizeof(struct UserFunctionHook)); + newfcn = (UserFunctionHook *) + malloc(sizeof(UserFunctionHook)); newfcn->next = UserHookTable; newfcn->h_function_pointer = fcn_ptr; newfcn->eventtype = EventType; UserHookTable = newfcn; - lprintf(CTDL_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) { - struct UserFunctionHook *cur, *p; + 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(CTDL_INFO, "Unregistered user function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Unregistered user function (type %d)\n", + EventType); p = cur->next; if (cur == UserHookTable) { UserHookTable = p; @@ -244,37 +669,52 @@ void CtdlUnregisterUserHook(void (*fcn_ptr) (struct ctdluser *), int EventType) } } +void CtdlDestroyUserHooks(void) +{ + UserFunctionHook *cur, *p; + + cur = UserHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed user function \n"); + p = cur->next; + free(cur); + cur = p; + } + UserHookTable = NULL; +} + void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *), int EventType) { - struct MessageFunctionHook *newfcn; + MessageFunctionHook *newfcn; - newfcn = (struct MessageFunctionHook *) - malloc(sizeof(struct MessageFunctionHook)); + newfcn = (MessageFunctionHook *) + malloc(sizeof(MessageFunctionHook)); newfcn->next = MessageHookTable; newfcn->h_function_pointer = handler; newfcn->eventtype = EventType; MessageHookTable = newfcn; - lprintf(CTDL_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 *), int EventType) { - struct MessageFunctionHook *cur, *p; + 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(CTDL_INFO, "Unregistered message function (type %d)\n", - EventType); + MOD_syslog(LOG_DEBUG, "Unregistered message function (type %d)\n", + EventType); p = cur->next; if (cur == MessageHookTable) { MessageHookTable = p; @@ -285,30 +725,92 @@ void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *), } } +void CtdlDestroyMessageHook(void) +{ + MessageFunctionHook *cur, *p; + + cur = MessageHookTable; + while (cur != NULL) + { + MOD_syslog(LOG_DEBUG, "Destroyed message function (type %d)\n", cur->eventtype); + p = cur->next; + free(cur); + cur = p; + } + MessageHookTable = NULL; +} + + +void CtdlRegisterRoomHook(int (*fcn_ptr)(struct ctdlroom *)) +{ + RoomFunctionHook *newfcn; + + newfcn = (RoomFunctionHook *) + malloc(sizeof(RoomFunctionHook)); + newfcn->next = RoomHookTable; + newfcn->fcn_ptr = fcn_ptr; + RoomHookTable = newfcn; + + 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) { + MODM_syslog(LOG_DEBUG, "Unregistered room function\n"); + p = cur->next; + if (cur == RoomHookTable) { + RoomHookTable = p; + } + free(cur); + cur = p; + } + } +} + + +void CtdlDestroyRoomHooks(void) +{ + RoomFunctionHook *cur, *p; + + cur = RoomHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed room function\n"); + p = cur->next; + free(cur); + cur = p; + } + RoomHookTable = NULL; +} void CtdlRegisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) ) { - struct NetprocFunctionHook *newfcn; + NetprocFunctionHook *newfcn; - newfcn = (struct NetprocFunctionHook *) - malloc(sizeof(struct NetprocFunctionHook)); + newfcn = (NetprocFunctionHook *) + malloc(sizeof(NetprocFunctionHook)); newfcn->next = NetprocHookTable; newfcn->h_function_pointer = handler; NetprocHookTable = newfcn; - lprintf(CTDL_INFO, "Registered a new netproc function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new netproc function\n"); } void CtdlUnregisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) ) { - struct NetprocFunctionHook *cur, *p; + NetprocFunctionHook *cur, *p; for (cur = NetprocHookTable; cur != NULL; cur = cur->next) { /* This will also remove duplicates if any */ while (cur != NULL && handler == cur->h_function_pointer ) { - lprintf(CTDL_INFO, "Unregistered netproc function\n"); + MODM_syslog(LOG_DEBUG, "Unregistered netproc function\n"); p = cur->next; if (cur == NetprocHookTable) { NetprocHookTable = p; @@ -319,30 +821,45 @@ void CtdlUnregisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) ) } } +void CtdlDestroyNetprocHooks(void) +{ + NetprocFunctionHook *cur, *p; + + cur = NetprocHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed netproc function\n"); + p = cur->next; + free(cur); + cur = p; + } + NetprocHookTable = NULL; +} + void CtdlRegisterDeleteHook(void (*handler)(char *, long) ) { - struct DeleteFunctionHook *newfcn; + DeleteFunctionHook *newfcn; - newfcn = (struct DeleteFunctionHook *) - malloc(sizeof(struct DeleteFunctionHook)); + newfcn = (DeleteFunctionHook *) + malloc(sizeof(DeleteFunctionHook)); newfcn->next = DeleteHookTable; newfcn->h_function_pointer = handler; DeleteHookTable = newfcn; - lprintf(CTDL_INFO, "Registered a new netproc function\n"); + MODM_syslog(LOG_DEBUG, "Registered a new delete function\n"); } void CtdlUnregisterDeleteHook(void (*handler)(char *, long) ) { - struct DeleteFunctionHook *cur, *p; + DeleteFunctionHook *cur, *p; for (cur = DeleteHookTable; cur != NULL; cur = cur->next) { /* This will also remove duplicates if any */ while (cur != NULL && handler == cur->h_function_pointer ) { - lprintf(CTDL_INFO, "Unregistered netproc function\n"); + MODM_syslog(LOG_DEBUG, "Unregistered delete function\n"); p = cur->next; if (cur == DeleteHookTable) { DeleteHookTable = p; @@ -352,33 +869,47 @@ void CtdlUnregisterDeleteHook(void (*handler)(char *, long) ) } } } +void CtdlDestroyDeleteHooks(void) +{ + DeleteFunctionHook *cur, *p; + + cur = DeleteHookTable; + while (cur != NULL) + { + MODM_syslog(LOG_DEBUG, "Destroyed delete function\n"); + p = cur->next; + free(cur); + cur = p; + } + DeleteHookTable = NULL; +} void CtdlRegisterFixedOutputHook(char *content_type, void (*handler)(char *, int) ) { - struct FixedOutputHook *newfcn; + FixedOutputHook *newfcn; - newfcn = (struct FixedOutputHook *) - malloc(sizeof(struct FixedOutputHook)); + newfcn = (FixedOutputHook *) + malloc(sizeof(FixedOutputHook)); newfcn->next = FixedOutputTable; newfcn->h_function_pointer = handler; safestrncpy(newfcn->content_type, content_type, sizeof newfcn->content_type); FixedOutputTable = newfcn; - lprintf(CTDL_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) { - struct FixedOutputHook *cur, *p; + FixedOutputHook *cur, *p; for (cur = FixedOutputTable; cur != NULL; cur = cur->next) { /* This will also remove duplicates if any */ while (cur != NULL && (!strcasecmp(content_type, cur->content_type))) { - lprintf(CTDL_INFO, "Unregistered fixed output function for %s\n", content_type); + MOD_syslog(LOG_DEBUG, "Unregistered fixed output function for %s\n", content_type); p = cur->next; if (cur == FixedOutputTable) { FixedOutputTable = p; @@ -389,10 +920,26 @@ void CtdlUnregisterFixedOutputHook(char *content_type) } } +void CtdlDestroyFixedOutputHooks(void) +{ + FixedOutputHook *cur, *p; + + cur = FixedOutputTable; + while (cur != NULL) + { + MOD_syslog(LOG_DEBUG, "Destroyed fixed output function for %s\n", cur->content_type); + p = cur->next; + free(cur); + cur = p; + + } + FixedOutputTable = NULL; +} + /* returns nonzero if we found a hook and used it */ int PerformFixedOutputHooks(char *content_type, char *content, int content_length) { - struct FixedOutputHook *fcn; + FixedOutputHook *fcn; for (fcn = FixedOutputTable; fcn != NULL; fcn = fcn->next) { if (!strcasecmp(content_type, fcn->content_type)) { @@ -407,32 +954,31 @@ int PerformFixedOutputHooks(char *content_type, char *content, int content_lengt -void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order) +void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *, char *), int order) { - struct XmsgFunctionHook *newfcn; + XmsgFunctionHook *newfcn; - newfcn = (struct XmsgFunctionHook *) - malloc(sizeof(struct XmsgFunctionHook)); + newfcn = (XmsgFunctionHook *) malloc(sizeof(XmsgFunctionHook)); newfcn->next = XmsgHookTable; newfcn->order = order; newfcn->h_function_pointer = fcn_ptr; XmsgHookTable = newfcn; - lprintf(CTDL_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 *), int order) +void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *, char *), int order) { - struct XmsgFunctionHook *cur, *p; + 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(CTDL_INFO, "Unregistered x-msg function " - "(priority %d)\n", order); + MOD_syslog(LOG_DEBUG, "Unregistered x-msg function " + "(priority %d)\n", order); p = cur->next; if (cur == XmsgHookTable) { XmsgHookTable = p; @@ -443,52 +989,78 @@ void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order) } } +void CtdlDestroyXmsgHooks(void) +{ + XmsgFunctionHook *cur, *p; + + cur = XmsgHookTable; + while (cur != NULL) + { + MOD_syslog(LOG_DEBUG, "Destroyed x-msg function " + "(priority %d)\n", cur->order); + p = cur->next; + + free(cur); + cur = p; + } + XmsgHookTable = NULL; +} + void CtdlRegisterServiceHook(int tcp_port, - char *sockpath, - void (*h_greeting_function) (void), - void (*h_command_function) (void), - void (*h_async_function) (void) - ) + char *sockpath, + void (*h_greeting_function) (void), + void (*h_command_function) (void), + void (*h_async_function) (void), + const char *ServiceName) { - struct ServiceFunctionHook *newfcn; - char message[SIZ]; - - newfcn = (struct ServiceFunctionHook *) - malloc(sizeof(struct ServiceFunctionHook)); + ServiceFunctionHook *newfcn; + char *message; + char error[SIZ]; + + strcpy(error, ""); + newfcn = (ServiceFunctionHook *) malloc(sizeof(ServiceFunctionHook)); + message = (char*) malloc (SIZ + SIZ); + newfcn->next = ServiceHookTable; newfcn->tcp_port = tcp_port; newfcn->sockpath = sockpath; newfcn->h_greeting_function = h_greeting_function; newfcn->h_command_function = h_command_function; newfcn->h_async_function = h_async_function; + newfcn->ServiceName = ServiceName; if (sockpath != NULL) { - newfcn->msock = ig_uds_server(sockpath, config.c_maxsessions); - snprintf(message, sizeof message, "Unix domain socket '%s': ", sockpath); + newfcn->msock = ctdl_uds_server(sockpath, config.c_maxsessions, error); + snprintf(message, SIZ, "Unix domain socket '%s': ", sockpath); } else if (tcp_port <= 0) { /* port -1 to disable */ - lprintf(CTDL_INFO, "Service has been manually disabled, skipping\n"); + MOD_syslog(LOG_INFO, "Service %s has been manually disabled, skipping\n", ServiceName); + free (message); free(newfcn); return; } else { - newfcn->msock = ig_tcp_server(config.c_ip_addr, - tcp_port, - config.c_maxsessions); - snprintf(message, sizeof message, "TCP port %d: ", tcp_port); + newfcn->msock = ctdl_tcp_server(config.c_ip_addr, + tcp_port, + config.c_maxsessions, + error); + snprintf(message, SIZ, "TCP port %s:%d: (%s) ", + config.c_ip_addr, tcp_port, ServiceName); } if (newfcn->msock > 0) { ServiceHookTable = newfcn; strcat(message, "registered."); - lprintf(CTDL_INFO, "%s\n", message); + MOD_syslog(LOG_INFO, "%s\n", message); } else { + AddPortError(message, error); strcat(message, "FAILED."); - lprintf(CTDL_CRIT, "%s\n", message); + MOD_syslog(LOG_CRIT, "%s\n", message); free(newfcn); } + free(message); } @@ -498,9 +1070,10 @@ void CtdlUnregisterServiceHook(int tcp_port, char *sockpath, void (*h_async_function) (void) ) { - struct ServiceFunctionHook *cur, *p; + ServiceFunctionHook *cur, *p; - for (cur = ServiceHookTable; cur != NULL; cur = cur->next) { + cur = ServiceHookTable; + while (cur != NULL) { /* This will also remove duplicates if any */ while (cur != NULL && !(sockpath && cur->sockpath && @@ -511,12 +1084,13 @@ void CtdlUnregisterServiceHook(int tcp_port, char *sockpath, tcp_port == cur->tcp_port) { close(cur->msock); if (sockpath) { - lprintf(CTDL_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) { - lprintf(CTDL_INFO, "Closed TCP port %d\n", tcp_port); + MOD_syslog(LOG_INFO, "Closed TCP port %d\n", tcp_port); } else { - lprintf(CTDL_INFO, "Unregistered unknown service\n"); + MOD_syslog(LOG_INFO, "Unregistered service \"%s\"\n", cur->ServiceName); } p = cur->next; if (cur == ServiceHookTable) { @@ -529,20 +1103,135 @@ void CtdlUnregisterServiceHook(int tcp_port, char *sockpath, } +void CtdlShutdownServiceHooks(void) +{ + /* sort of a duplicate of close_masters() but called earlier */ + ServiceFunctionHook *cur; + + cur = ServiceHookTable; + while (cur != NULL) + { + if (cur->msock != -1) + { + close(cur->msock); + cur->msock = -1; + if (cur->sockpath != NULL){ + MOD_syslog(LOG_INFO, "[%s] Closed UNIX domain socket %s\n", + cur->ServiceName, + cur->sockpath); + unlink(cur->sockpath); + } else { + MOD_syslog(LOG_INFO, "[%s] closing service\n", + cur->ServiceName); + } + } + cur = cur->next; + } +} + +void CtdlDestroyServiceHook(void) +{ + ServiceFunctionHook *cur, *p; + + cur = ServiceHookTable; + while (cur != NULL) + { + close(cur->msock); + if (cur->sockpath) { + MOD_syslog(LOG_INFO, "Closed UNIX domain socket %s\n", + cur->sockpath); + unlink(cur->sockpath); + } else if (cur->tcp_port) { + MOD_syslog(LOG_INFO, "Closed TCP port %d\n", cur->tcp_port); + } else { + MOD_syslog(LOG_INFO, "Destroyed service \"%s\"\n", cur->ServiceName); + } + p = cur->next; + free(cur); + cur = p; + } + ServiceHookTable = NULL; +} + +void CtdlRegisterSearchFuncHook(void (*fcn_ptr)(int *, long **, const char *), char *name) +{ + SearchFunctionHook *newfcn; + + if (!name || !fcn_ptr) { + return; + } + + newfcn = (SearchFunctionHook *) + malloc(sizeof(SearchFunctionHook)); + newfcn->next = SearchFunctionHookTable; + newfcn->name = name; + newfcn->fcn_ptr = fcn_ptr; + SearchFunctionHookTable = newfcn; + + 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; + + for (cur = SearchFunctionHookTable; cur != NULL; cur = cur->next) { + while (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); + cur = p; + } + } +} + +void CtdlDestroySearchHooks(void) +{ + SearchFunctionHook *cur, *p; + + cur = SearchFunctionHookTable; + SearchFunctionHookTable = NULL; + while (cur != NULL) { + p = cur->next; + free(cur); + cur = p; + } +} + +void CtdlModuleDoSearch(int *num_msgs, long **search_msgs, const char *search_string, const char *func_name) +{ + SearchFunctionHook *fcn = NULL; + + for (fcn = SearchFunctionHookTable; fcn != NULL; fcn = fcn->next) { + if (!func_name || !strcmp(func_name, fcn->name)) { + (*fcn->fcn_ptr) (num_msgs, search_msgs, search_string); + return; + } + } + *num_msgs = 0; +} + + void PerformSessionHooks(int EventType) { - struct SessionFunctionHook *fcn; + SessionFunctionHook *fcn = NULL; for (fcn = SessionHookTable; fcn != NULL; fcn = fcn->next) { if (fcn->eventtype == EventType) { + if (EventType == EVT_TIMER) { + pthread_setspecific(MyConKey, NULL); /* for every hook */ + } (*fcn->h_function_pointer) (); } } } -void PerformUserHooks(struct ctdluser *usbuf, int EventType) +void PerformUserHooks(ctdluser *usbuf, int EventType) { - struct UserFunctionHook *fcn; + UserFunctionHook *fcn = NULL; for (fcn = UserHookTable; fcn != NULL; fcn = fcn->next) { if (fcn->eventtype == EventType) { @@ -553,16 +1242,15 @@ void PerformUserHooks(struct ctdluser *usbuf, int EventType) int PerformMessageHooks(struct CtdlMessage *msg, int EventType) { - struct MessageFunctionHook *fcn; + 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. - lprintf(CTDL_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) { - lprintf(CTDL_DEBUG, "Skipping hooks\n"); + MODM_syslog(LOG_DEBUG, "Skipping hooks\n"); return(0); } @@ -570,8 +1258,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); } } @@ -583,10 +1270,26 @@ int PerformMessageHooks(struct CtdlMessage *msg, int EventType) } +int PerformRoomHooks(struct ctdlroom *target_room) +{ + RoomFunctionHook *fcn; + int total_retval = 0; + + 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); + } + + /* Return the sum of the return codes from the hook functions. + */ + return total_retval; +} + int PerformNetprocHooks(struct CtdlMessage *msg, char *target_room) { - struct NetprocFunctionHook *fcn; + NetprocFunctionHook *fcn; int total_retval = 0; for (fcn = NetprocHookTable; fcn != NULL; fcn = fcn->next) { @@ -603,7 +1306,7 @@ int PerformNetprocHooks(struct CtdlMessage *msg, char *target_room) void PerformDeleteHooks(char *room, long msgnum) { - struct DeleteFunctionHook *fcn; + DeleteFunctionHook *fcn; for (fcn = DeleteHookTable; fcn != NULL; fcn = fcn->next) { (*fcn->h_function_pointer) (room, msgnum); @@ -614,9 +1317,9 @@ void PerformDeleteHooks(char *room, long msgnum) -int PerformXmsgHooks(char *sender, char *recp, char *msg) +int PerformXmsgHooks(char *sender, char *sender_email, char *recp, char *msg) { - struct XmsgFunctionHook *fcn; + XmsgFunctionHook *fcn; int total_sent = 0; int p; @@ -625,7 +1328,7 @@ int PerformXmsgHooks(char *sender, char *recp, char *msg) if (fcn->order == p) { total_sent += (*fcn->h_function_pointer) - (sender, recp, msg); + (sender, sender_email, recp, msg); } } /* Break out of the loop if a higher-priority function @@ -637,3 +1340,29 @@ int PerformXmsgHooks(char *sender, char *recp, char *msg) } return total_sent; } + + +/* + * Dirty hack until we impliment a hook mechanism for this + */ +void CtdlModuleStartCryptoMsgs(char *ok_response, char *nosup_response, char *error_response) +{ +#ifdef HAVE_OPENSSL + 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); + + CtdlRegisterProtoHook(cmd_log_get, "LOGP", "Print Log-parameters"); + CtdlRegisterProtoHook(cmd_log_set, "LOGS", "Set Log-parameters"); + } + return "modules"; +}