*/
/*
- * 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
+ * Use table isn't saving properly across sessions
*/
#include "sysdep.h"
#include "internet_addressing.h"
#include "serv_network.h"
#include "clientsocket.h"
+#include "file_ops.h"
/*
* 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 the Citadel network during network runs.
+ * We build a map of network nodes during processing.
*/
-struct NetMap {
- struct NetMap *next;
- char nodename[SIZ];
- time_t lastcontact;
- char nexthop[SIZ];
-};
-
struct NetMap *the_netmap = NULL;
-
/*
- * network_talking_to() -- concurrency checker
+ * 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.
*/
-int network_talking_to(char *nodename, int operation) {
+int network_usetable(int operation, struct CtdlMessage *msg) {
- static char *nttlist = NULL;
- char *ptr = NULL;
- int i;
+ static struct UseTable *ut = NULL;
+ struct UseTable *uptr = NULL;
+ char *serialized_table = NULL;
+ char msgid[SIZ];
char buf[SIZ];
- int retval = 0;
-
- begin_critical_section(S_NTTLIST);
+ int i;
+ size_t stlen = 0;
switch(operation) {
-
- case NTT_ADD:
- if (nttlist == NULL) nttlist = strdoop("");
- if (nttlist == NULL) break;
- nttlist = (char *)reallok(nttlist,
- (strlen(nttlist) + strlen(nodename) + 3) );
- strcat(nttlist, "|");
- strcat(nttlist, nodename);
- break;
-
- case NTT_REMOVE:
- if (nttlist == NULL) break;
- if (strlen(nttlist) == 0) break;
- ptr = mallok(strlen(nttlist));
- if (ptr == NULL) break;
- strcpy(ptr, "");
- for (i = 0; i < num_tokens(nttlist, '|'); ++i) {
- extract(buf, nttlist, i);
- if ( (strlen(buf) > 0)
- && (strcasecmp(buf, nodename)) ) {
- strcat(ptr, buf);
- strcat(ptr, "|");
+
+ 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(nttlist);
- nttlist = ptr;
- break;
-
- case NTT_CHECK:
- if (nttlist == NULL) break;
- if (strlen(nttlist) == 0) break;
- for (i = 0; i < num_tokens(nttlist, '|'); ++i) {
- extract(buf, nttlist, i);
- if (!strcasecmp(buf, nodename)) ++retval;
+
+ 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);
}
- break;
- }
- if (nttlist != NULL) lprintf(9, "nttlist=<%s>\n", nttlist);
- end_critical_section(S_NTTLIST);
- return(retval);
-}
+ /* 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);
+
+ while (ut != NULL) {
+ if (serialized_table != NULL) {
+ sprintf(&serialized_table[strlen(
+ serialized_table)], "%s|%ld\n",
+ ut->message_id,
+ 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);
+}
/*
}
}
- /* 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) {
+ /* FIXME - post a msg in Aide> telling us what happened */
+ CtdlFreeMessage(msg);
+ msg = NULL;
+ return;
+ }
/* Learn network topology from the path */
if ((msg->cm_fields['N'] != NULL) && (msg->cm_fields['P'] != NULL)) {
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);
}