* 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 <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <string.h>
-#include <limits.h>
-#include <ctype.h>
-#include <syslog.h>
#include <libcitadel.h>
-#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 <stdarg.h>
-#include "snprintf.h"
-#endif
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;
int loglevel;
void (*h_function_pointer) (char *);
};
-extern LogFunctionHook *LogHookTable;
+
+LogFunctionHook *LogHookTable = NULL;
typedef struct FixedOutputHook FixedOutputHook;
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;
void (*h_function_pointer) (void);
int eventtype;
};
-extern SessionFunctionHook *SessionHookTable;
-
+SessionFunctionHook *SessionHookTable = NULL;
/*
* UserFunctionHook extensions are used for any type of hook which implements
void (*h_function_pointer) (struct ctdluser *usbuf);
int eventtype;
};
-extern UserFunctionHook *UserHookTable;
+UserFunctionHook *UserHookTable = NULL;
/*
* MessageFunctionHook extensions are used for hooks which implement handlers
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;
/*
NetprocFunctionHook *next;
int (*h_function_pointer) (struct CtdlMessage *msg, char *target_room);
};
-extern NetprocFunctionHook *NetprocHookTable;
+NetprocFunctionHook *NetprocHookTable = NULL;
/*
DeleteFunctionHook *next;
void (*h_function_pointer) (char *target_room, long msgnum);
};
-extern DeleteFunctionHook *DeleteHookTable;
+DeleteFunctionHook *DeleteHookTable = NULL;
/*
int (*h_function_pointer) (char *, char *, char *, char *);
int order;
};
-extern XmsgFunctionHook *XmsgHookTable;
+XmsgFunctionHook *XmsgHookTable = NULL;
RoomFunctionHook *next;
int (*fcn_ptr) (struct ctdlroom *);
};
-extern RoomFunctionHook *RoomHookTable;
+RoomFunctionHook *RoomHookTable = NULL;
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 {
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)
{
{
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;
+
+ 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)
{
}
-void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
+void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *, recptypes *),
int EventType)
{
}
-void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *),
+void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *, recptypes *),
int EventType)
{
MessageFunctionHook *cur, *p, *last;
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) {
- MOD_syslog(LOG_INFO, "Closed UNIX domain socket %s\n",
+ MOD_syslog(LOG_INFO, "%s UNIX domain socket %s\n",
+ Text,
cur->sockpath);
unlink(cur->sockpath);
} else if (cur->tcp_port) {
- MOD_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 {
MOD_syslog(LOG_INFO, "Destroyed service \"%s\"\n", cur->ServiceName);
}
*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)
{
}
}
-int PerformMessageHooks(struct CtdlMessage *msg, int EventType)
+int PerformMessageHooks(struct CtdlMessage *msg, recptypes *recps, int EventType)
{
MessageFunctionHook *fcn = NULL;
int total_retval = 0;
*/
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);
}
}
{
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";
}
projects / citadel.git / blobdiff