X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fserv_extensions.c;h=9f0bd25dcb365efe695ddff183519d3086f0caf9;hb=d262741cce924786b2de5f3f10f5470e5d45743e;hp=c46e4a4b325cc665cb63c9608438bc4d6709b7ba;hpb=5607200b755b09f11b76e96c5f3446be7bafa673;p=citadel.git

diff --git a/citadel/serv_extensions.c b/citadel/serv_extensions.c
index c46e4a4b3..9f0bd25dc 100644
--- a/citadel/serv_extensions.c
+++ b/citadel/serv_extensions.c
@@ -5,18 +5,12 @@
  * 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"
@@ -41,10 +35,6 @@
 
 #include "ctdl_module.h"
 
-#ifndef HAVE_SNPRINTF
-#include <stdarg.h>
-#include "snprintf.h"
-#endif
 
 int DebugModules = 0;
  
@@ -66,7 +56,8 @@ struct LogFunctionHook {
 	int loglevel;
 	void (*h_function_pointer) (char *);
 };
-extern LogFunctionHook *LogHookTable;
+
+LogFunctionHook *LogHookTable = NULL;
 
 typedef struct FixedOutputHook FixedOutputHook;
 struct FixedOutputHook {
@@ -74,7 +65,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;
 
 
 
@@ -87,11 +94,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
@@ -104,7 +111,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
@@ -116,7 +123,7 @@ struct MessageFunctionHook {
 	int (*h_function_pointer) (struct CtdlMessage *msg);
 	int eventtype;
 };
-extern MessageFunctionHook *MessageHookTable;
+MessageFunctionHook *MessageHookTable = NULL;
 
 
 /*
@@ -128,7 +135,7 @@ struct NetprocFunctionHook {
 	NetprocFunctionHook *next;
 	int (*h_function_pointer) (struct CtdlMessage *msg, char *target_room);
 };
-extern NetprocFunctionHook *NetprocHookTable;
+NetprocFunctionHook *NetprocHookTable = NULL;
 
 
 /*
@@ -140,7 +147,7 @@ struct DeleteFunctionHook {
 	DeleteFunctionHook *next;
 	void (*h_function_pointer) (char *target_room, long msgnum);
 };
-extern DeleteFunctionHook *DeleteHookTable;
+DeleteFunctionHook *DeleteHookTable = NULL;
 
 
 /*
@@ -155,7 +162,7 @@ struct XmsgFunctionHook {
 	int (*h_function_pointer) (char *, char *, char *, char *);
 	int order;
 };
-extern XmsgFunctionHook *XmsgHookTable;
+XmsgFunctionHook *XmsgHookTable = NULL;
 
 
 
@@ -169,7 +176,7 @@ struct RoomFunctionHook {
 	RoomFunctionHook *next;
 	int (*fcn_ptr) (struct ctdlroom *);
 };
-extern RoomFunctionHook *RoomHookTable;
+RoomFunctionHook *RoomHookTable = NULL;
 
 
 
@@ -179,21 +186,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 {
@@ -493,20 +491,29 @@ void CtdlRegisterCleanupHook(void (*fcn_ptr) (void))
 
 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) {
+	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;
+		}
 	}
 }
 
@@ -543,20 +550,29 @@ void CtdlRegisterEVCleanupHook(void (*fcn_ptr) (void))
 
 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) {
+	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;
+		}
 	}
 }
 
@@ -570,48 +586,134 @@ void CtdlDestroyEVCleanupHooks(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 CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType)
+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;
 
-	MOD_syslog(LOG_DEBUG, "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) {
+	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;
+		}
 	}
 }
 
@@ -650,22 +752,30 @@ void CtdlRegisterUserHook(void (*fcn_ptr) (ctdluser *), int 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) {
+	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;
+		}
 	}
 }
 
@@ -706,22 +816,29 @@ void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
 void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *),
 		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) {
+	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;
+		}
 	}
 }
 
@@ -779,7 +896,6 @@ void CtdlUnregisterRoomHook(int (*fcn_ptr)(struct ctdlroom *))
 			last = cur;
 			cur = cur->next;
 		}
-
 	}
 }
 
@@ -1186,18 +1302,29 @@ 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) {
-			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);
 		}
@@ -1279,6 +1406,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)
 {