*
*/
+#ifdef DLL_EXPORT
+#define IN_LIBCIT
+#endif
+
#include "sysdep.h"
#include <stdio.h>
#include <stdlib.h>
+#include <unistd.h>
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
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 ProtoFunctionHook {
void CtdlRegisterProtoHook(void (*handler) (char *), char *cmd, char *desc)
{
- struct ProtoFunctionHook *p = mallok(sizeof *p);
+ struct ProtoFunctionHook *p;
+
+ p = (struct ProtoFunctionHook *)
+ mallok(sizeof(struct ProtoFunctionHook));
if (p == NULL) {
fprintf(stderr, "can't malloc new ProtoFunctionHook\n");
lprintf(5, "Registered server command %s (%s)\n", cmd, desc);
}
+
+void CtdlUnregisterProtoHook(void (*handler) (char *), char *cmd)
+{
+ struct ProtoFunctionHook *cur, *p;
+
+ for (cur = ProtoHookList; cur != NULL; cur = cur->next) {
+ /* This will also remove duplicates if any */
+ while (cur != NULL &&
+ handler == cur->handler &&
+ !strcmp(cmd, cur->cmd)) {
+ lprintf(5, "Unregistered server command %s (%s)\n",
+ cmd, cur->desc);
+ p = cur->next;
+ if (cur == ProtoHookList) {
+ ProtoHookList = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
int DLoader_Exec_Cmd(char *cmdbuf)
{
struct ProtoFunctionHook *p;
void DLoader_Init(char *pathname)
{
void *fcn_handle;
- char dl_error[256];
+ char dl_error[SIZ];
DIR *dir;
int i;
struct dirent *dptr;
while ((dptr = readdir(dir)) != NULL) {
if (strlen(dptr->d_name) < 4)
continue;
+#ifndef __CYGWIN__
if (strcasecmp(&dptr->d_name[strlen(dptr->d_name)-3], ".so"))
+#else
+ if (strcasecmp(&dptr->d_name[strlen(dptr->d_name)-4], ".dll"))
+#endif
continue;
snprintf(pathbuf, PATH_MAX, "%s/%s", pathname, dptr->d_name);
}
+void CtdlUnregisterLogHook(void (*fcn_ptr) (char *), int loglevel)
+{
+ struct LogFunctionHook *cur, *p;
+
+ for (cur = LogHookTable; cur != NULL; cur = cur->next) {
+ /* This will also remove duplicates if any */
+ while (cur != NULL &&
+ fcn_ptr == cur->h_function_pointer &&
+ loglevel == cur->loglevel) {
+ lprintf(5, "Unregistered logging function\n");
+ p = cur->next;
+ if (cur == LogHookTable) {
+ LogHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterCleanupHook(void (*fcn_ptr) (void))
{
}
+void CtdlUnregisterCleanupHook(void (*fcn_ptr) (void))
+{
+ struct 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) {
+ lprintf(5, "Unregistered cleanup function\n");
+ p = cur->next;
+ if (cur == CleanupHookTable) {
+ CleanupHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterSessionHook(void (*fcn_ptr) (void), int EventType)
{
}
+void CtdlUnregisterSessionHook(void (*fcn_ptr) (void), int EventType)
+{
+ struct 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(5, "Unregistered session function (type %d)\n",
+ EventType);
+ p = cur->next;
+ if (cur == SessionHookTable) {
+ SessionHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
{
}
+void CtdlUnregisterUserHook(void (*fcn_ptr) (char *, long), int EventType)
+{
+ struct 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(5, "Unregistered user function (type %d)\n",
+ EventType);
+ p = cur->next;
+ if (cur == UserHookTable) {
+ UserHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterMessageHook(int (*handler)(struct CtdlMessage *),
int EventType)
{
}
+void CtdlUnregisterMessageHook(int (*handler)(struct CtdlMessage *),
+ int EventType)
+{
+ struct 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(5, "Unregistered message function (type %d)\n",
+ EventType);
+ p = cur->next;
+ if (cur == MessageHookTable) {
+ MessageHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
+void CtdlRegisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) )
+{
+ struct NetprocFunctionHook *newfcn;
+
+ newfcn = (struct NetprocFunctionHook *)
+ mallok(sizeof(struct NetprocFunctionHook));
+ newfcn->next = NetprocHookTable;
+ newfcn->h_function_pointer = handler;
+ NetprocHookTable = newfcn;
+
+ lprintf(5, "Registered a new netproc function\n");
+}
+
+
+void CtdlUnregisterNetprocHook(int (*handler)(struct CtdlMessage *, char *) )
+{
+ struct 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(5, "Unregistered netproc function\n");
+ p = cur->next;
+ if (cur == NetprocHookTable) {
+ NetprocHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
+void CtdlRegisterDeleteHook(void (*handler)(char *, long) )
+{
+ struct DeleteFunctionHook *newfcn;
+
+ newfcn = (struct DeleteFunctionHook *)
+ mallok(sizeof(struct DeleteFunctionHook));
+ newfcn->next = DeleteHookTable;
+ newfcn->h_function_pointer = handler;
+ DeleteHookTable = newfcn;
+
+ lprintf(5, "Registered a new netproc function\n");
+}
+
+
+void CtdlUnregisterDeleteHook(void (*handler)(char *, long) )
+{
+ struct 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(5, "Unregistered netproc function\n");
+ p = cur->next;
+ if (cur == DeleteHookTable) {
+ DeleteHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
{
lprintf(5, "Registered a new x-msg function (priority %d)\n", order);
}
+
+void CtdlUnregisterXmsgHook(int (*fcn_ptr) (char *, char *, char *), int order)
+{
+ struct 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(5, "Unregistered x-msg function "
+ "(priority %d)\n", order);
+ p = cur->next;
+ if (cur == XmsgHookTable) {
+ XmsgHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
+
void CtdlRegisterServiceHook(int tcp_port,
char *sockpath,
void (*h_greeting_function) (void),
void (*h_command_function) (void) )
{
struct ServiceFunctionHook *newfcn;
- char message[256];
+ char message[SIZ];
newfcn = (struct ServiceFunctionHook *)
mallok(sizeof(struct ServiceFunctionHook));
if (sockpath != NULL) {
newfcn->msock = ig_uds_server(sockpath, config.c_maxsessions);
- sprintf(message, "Unix domain socket '%s': ", sockpath);
+ snprintf(message, sizeof message, "Unix domain socket '%s': ", sockpath);
}
else if (tcp_port <= 0) { /* port -1 to disable */
lprintf(7, "Service has been manually disabled, skipping\n");
}
else {
newfcn->msock = ig_tcp_server(tcp_port, config.c_maxsessions);
- sprintf(message, "TCP port %d: ", tcp_port);
+ snprintf(message, sizeof message, "TCP port %d: ", tcp_port);
}
if (newfcn->msock > 0) {
}
+void CtdlUnregisterServiceHook(int tcp_port, char *sockpath,
+ void (*h_greeting_function) (void),
+ void (*h_command_function) (void) )
+{
+ struct ServiceFunctionHook *cur, *p;
+
+ for (cur = ServiceHookTable; cur != NULL; cur = cur->next) {
+ /* 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 &&
+ tcp_port == cur->tcp_port) {
+ close(cur->msock);
+ if (sockpath) {
+ lprintf(5, "Closed UNIX domain socket %s\n",
+ sockpath);
+ } else if (tcp_port) {
+ lprintf(5, "Closed TCP port %d\n", tcp_port);
+ } else {
+ lprintf(5, "Unregistered unknown service\n");
+ }
+ p = cur->next;
+ if (cur == ServiceHookTable) {
+ ServiceHookTable = p;
+ }
+ phree(cur);
+ cur = p;
+ }
+ }
+}
+
void PerformSessionHooks(int EventType)
{
/* Other code may elect to protect this message from server-side
* handlers; if this is the case, don't do anything.
- */
lprintf(9, "** Event type is %d, flags are %d\n",
EventType, msg->cm_flags);
+ */
if (msg->cm_flags & CM_SKIP_HOOKS) {
lprintf(9, "Skipping hooks\n");
return(0);
+int PerformNetprocHooks(struct CtdlMessage *msg, char *target_room)
+{
+ struct NetprocFunctionHook *fcn;
+ int total_retval = 0;
+
+ for (fcn = NetprocHookTable; fcn != NULL; fcn = fcn->next) {
+ total_retval = total_retval +
+ (*fcn->h_function_pointer) (msg, target_room);
+ }
+
+ /* Return the sum of the return codes from the hook functions.
+ * A nonzero return code will cause the message to *not* be imported.
+ */
+ return total_retval;
+}
+
+
+void PerformDeleteHooks(char *room, long msgnum)
+{
+ struct DeleteFunctionHook *fcn;
+
+ for (fcn = DeleteHookTable; fcn != NULL; fcn = fcn->next) {
+ (*fcn->h_function_pointer) (room, msgnum);
+ }
+}
+
+
+
int PerformXmsgHooks(char *sender, char *recp, char *msg)
{
struct XmsgFunctionHook *fcn;
* deliveries to local users simultaneously signed onto
* remote services.
*/
- if (total_sent) goto DONE;
+ if (total_sent) break;
}
-DONE: return total_sent;
+ return total_sent;
}
projects / citadel.git / blobdiff