/*
* $Id$
*
- * This module will eventually replace netproc and some of its utilities. In
- * the meantime, it serves as a mailing list manager.
+ * This module handles shared rooms, inter-Citadel mail, and outbound
+ * mailing list processing.
*
* Copyright (C) 2000-2001 by Art Cancro and others.
* This code is released under the terms of the GNU General Public License.
*/
/*
- * FIXME do something about concurrency issues:
- * 1. Don't allow the two nodes to poll each other at the same time
- * 2. Don't allow polls during network processing
- * 3. Kill Bill Gates using either a chainsaw or a wood chipper
+ * FIXME
+ * Don't allow polls during network processing
*/
#include "sysdep.h"
#include "internet_addressing.h"
#include "serv_network.h"
#include "clientsocket.h"
+#include "file_ops.h"
+
+#ifndef HAVE_SNPRINTF
+#include "snprintf.h"
+#endif
/*
* is global; this process *only* runs as part of the housekeeping loop and
* therefore only one will run at a time.
*/
-struct RoomProcList {
- struct RoomProcList *next;
- char name[ROOMNAMELEN];
-};
-
struct RoomProcList *rplist = NULL;
+/*
+ * We build a map of network nodes during processing.
+ */
+struct NetMap *the_netmap = NULL;
+
/*
- * We build a map of the Citadel network during network runs.
+ * Manage the use table. This is a list of messages which have recently
+ * arrived on the system. It is maintained and queried to prevent the same
+ * message from being entered into the database multiple times if it happens
+ * to arrive multiple times by accident.
*/
-struct NetMap {
- struct NetMap *next;
- char nodename[SIZ];
- time_t lastcontact;
- char nexthop[SIZ];
-};
+int network_usetable(int operation, struct CtdlMessage *msg) {
-struct NetMap *the_netmap = NULL;
+ static struct UseTable *ut = NULL;
+ struct UseTable *uptr = NULL;
+ char *serialized_table = NULL;
+ char msgid[SIZ];
+ char buf[SIZ];
+ int i;
+ size_t stlen = 0;
+
+ switch(operation) {
+
+ case UT_LOAD:
+ serialized_table = CtdlGetSysConfig(USETABLE);
+ if (serialized_table == NULL) return(0);
+
+ for (i=0; i<num_tokens(serialized_table, '\n'); ++i) {
+ extract_token(buf, serialized_table, i, '\n');
+ uptr = (struct UseTable *)
+ mallok(sizeof(struct UseTable));
+ if (uptr != NULL) {
+ uptr->next = ut;
+ extract(msgid, buf, 0);
+ uptr->message_id = strdoop(msgid);
+ uptr->timestamp = extract_long(buf, 1);
+ ut = uptr;
+ }
+ }
+
+ phree(serialized_table);
+ serialized_table = NULL;
+ return(0);
+
+ case UT_INSERT:
+ /* Bail out if we can't generate a message ID */
+ if (msg == NULL) {
+ return(0);
+ }
+ if (msg->cm_fields['I'] == NULL) {
+ return(0);
+ }
+ if (strlen(msg->cm_fields['I']) == 0) {
+ return(0);
+ }
+
+ /* Generate the message ID */
+ strcpy(msgid, msg->cm_fields['I']);
+ if (haschar(msgid, '@') == 0) {
+ strcat(msgid, "@");
+ if (msg->cm_fields['N'] != NULL) {
+ strcat(msgid, msg->cm_fields['N']);
+ }
+ else {
+ return(0);
+ }
+ }
+
+ /* Compare to the existing list */
+ for (uptr = ut; uptr != NULL; uptr = uptr->next) {
+ if (!strcasecmp(msgid, uptr->message_id)) {
+ return(1);
+ }
+ }
+
+ /* If we got to this point, it's unique: add it. */
+ uptr = (struct UseTable *)
+ mallok(sizeof(struct UseTable));
+ if (uptr == NULL) return(0);
+ uptr->next = ut;
+ uptr->message_id = strdoop(msgid);
+ uptr->timestamp = time(NULL);
+ ut = uptr;
+ return(0);
+
+ case UT_SAVE:
+ /* Figure out how big the serialized buffer should be */
+ stlen = 0;
+ for (uptr = ut; uptr != NULL; uptr = uptr->next) {
+ stlen = stlen + strlen(uptr->message_id) + 20;
+ }
+ serialized_table = mallok(stlen);
+ memset(serialized_table, 0, stlen);
+
+ while (ut != NULL) {
+ if ( (serialized_table != NULL)
+ && ( (ut->timestamp - time(NULL)) <
+ USETABLE_RETAIN) ) {
+ sprintf(&serialized_table[strlen(
+ serialized_table)], "%s|%ld\n",
+ ut->message_id,
+ (long)ut->timestamp);
+ }
+
+ /* Now free the memory */
+ uptr = ut;
+ ut = ut->next;
+ phree(uptr->message_id);
+ phree(uptr);
+ }
+ /* Write to disk */
+ CtdlPutSysConfig(USETABLE, serialized_table);
+ phree(serialized_table);
+ return(0);
+
+ }
+
+ /* should never get here unless illegal operation specified */
+ return(2);
+}
/*
sprintf(&serialized_map[strlen(serialized_map)],
"%s|%ld|%s\n",
nmptr->nodename,
- nmptr->lastcontact,
+ (long)nmptr->lastcontact,
nmptr->nexthop);
}
}
sprintf(instr,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|postmaster@%s\n" ,
- SPOOLMIME, msgnum, time(NULL), config.c_fqdn );
+ SPOOLMIME, msgnum, (long)time(NULL), config.c_fqdn );
/* Generate delivery instructions for each recipient */
for (nptr = sc->listrecps; nptr != NULL; nptr = nptr->next) {
phree(msg->cm_fields['I']);
}
sprintf(buf, "%ld.%04x.%04x@%s",
- time(NULL), getpid(), ++serialnum, config.c_fqdn);
+ (long)time(NULL), getpid(), ++serialnum, config.c_fqdn);
msg->cm_fields['I'] = strdoop(buf);
/*
char *oldpath = NULL;
char filename[SIZ];
FILE *fp;
+ char buf[SIZ];
/* Set default target room to trash */
strcpy(target_room, TWITROOM);
}
}
- /* FIXME check to see if we already have this message */
+ /*
+ * Check to see if we already have a copy of this message
+ */
+ if (network_usetable(UT_INSERT, msg) != 0) {
+ sprintf(buf, "Loopzapper rejected message <%s>\n",
+ msg->cm_fields['I']);
+ aide_message(buf);
+ CtdlFreeMessage(msg);
+ msg = NULL;
+ return;
+ }
/* Learn network topology from the path */
if ((msg->cm_fields['N'] != NULL) && (msg->cm_fields['P'] != NULL)) {
int sock;
char buf[SIZ];
+ if (network_talking_to(node, NTT_CHECK)) return;
+ network_talking_to(node, NTT_ADD);
lprintf(5, "Polling node <%s> at %s:%s\n", node, host, port);
sock = sock_connect(host, port, "tcp");
if (sock < 0) {
lprintf(7, "Could not connect: %s\n", strerror(errno));
+ network_talking_to(node, NTT_REMOVE);
return;
}
sock_puts(sock, "QUIT");
bail: sock_close(sock);
+ network_talking_to(node, NTT_REMOVE);
}
network_poll_other_citadel_nodes();
/*
- * Load the network map into memory.
+ * Load the network map and use table into memory.
*/
read_network_map();
+ network_usetable(UT_LOAD, NULL);
/*
* Go ahead and run the queue
lprintf(7, "network: processing inbound queue\n");
network_do_spoolin();
+ /* Save the usetable and network map back to disk */
+ network_usetable(UT_SAVE, NULL);
write_network_map();
lprintf(7, "network: queue run completed\n");
return;
}
+ if (network_talking_to(node, NTT_CHECK)) {
+ cprintf("%d Already talking to %s right now\n", ERROR);
+ return;
+ }
+
safestrncpy(CC->net_node, node, sizeof CC->net_node);
+ network_talking_to(node, NTT_ADD);
cprintf("%d authenticated as network node '%s'\n", OK,
CC->net_node);
}
projects / citadel.git / blobdiff