/*
* $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.
+ * Copyright (C) 2000-2002 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.
+ * Keep track of what messages to reject
*/
-struct NetMap {
- struct NetMap *next;
- char nodename[SIZ];
- time_t lastcontact;
- char nexthop[SIZ];
-};
+struct FilterList *load_filter_list(void) {
+ char *serialized_list = NULL;
+ int i;
+ char buf[SIZ];
+ struct FilterList *newlist = NULL;
+ struct FilterList *nptr;
-struct NetMap *the_netmap = NULL;
+ serialized_list = CtdlGetSysConfig(FILTERLIST);
+ if (serialized_list == NULL) return(NULL); /* if null, no entries */
+
+ /* Use the string tokenizer to grab one line at a time */
+ for (i=0; i<num_tokens(serialized_list, '\n'); ++i) {
+ extract_token(buf, serialized_list, i, '\n');
+ nptr = (struct FilterList *) mallok(sizeof(struct FilterList));
+ extract(nptr->fl_user, buf, 0);
+ striplt(nptr->fl_user);
+ extract(nptr->fl_room, buf, 1);
+ striplt(nptr->fl_room);
+ extract(nptr->fl_node, buf, 2);
+ striplt(nptr->fl_node);
+
+ /* Cowardly refuse to add an any/any/any entry that would
+ * end up filtering every single message.
+ */
+ if (strlen(nptr->fl_user) + strlen(nptr->fl_room)
+ + strlen(nptr->fl_node) == 0) {
+ phree(nptr);
+ }
+ else {
+ nptr->next = newlist;
+ newlist = nptr;
+ }
+ }
+
+ phree(serialized_list);
+ return newlist;
+}
+
+
+void free_filter_list(struct FilterList *fl) {
+ if (fl == NULL) return;
+ free_filter_list(fl->next);
+ phree(fl);
+}
+/*
+ * Check 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_usetable(struct CtdlMessage *msg) {
+
+ char msgid[SIZ];
+ struct cdbdata *cdbut;
+ struct UseTable ut;
+
+ /* 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);
+ }
+ }
+
+ cdbut = cdb_fetch(CDB_USETABLE, msgid, strlen(msgid));
+ if (cdbut != NULL) {
+ cdb_free(cdbut);
+ return(1);
+ }
+
+ /* If we got to this point, it's unique: add it. */
+ strcpy(ut.ut_msgid, msgid);
+ ut.ut_timestamp = time(NULL);
+ cdb_store(CDB_USETABLE, msgid, strlen(msgid),
+ &ut, sizeof(struct UseTable) );
+ return(0);
+}
+
+
/*
* Read the network map from its configuration file into memory.
*/
sprintf(&serialized_map[strlen(serialized_map)],
"%s|%ld|%s\n",
nmptr->nodename,
- nmptr->lastcontact,
+ (long)nmptr->lastcontact,
nmptr->nexthop);
}
}
FILE *fp;
if (CtdlAccessCheck(ac_room_aide)) return;
- assoc_file_name(filename, &CC->quickroom, "netconfigs");
+ assoc_file_name(filename, sizeof filename, &CC->quickroom, "netconfigs");
cprintf("%d Network settings for room #%ld <%s>\n",
LISTING_FOLLOWS,
CC->quickroom.QRnumber, CC->quickroom.QRname);
if (CtdlAccessCheck(ac_room_aide)) return;
safestrncpy(tempfilename, tmpnam(NULL), sizeof tempfilename);
- assoc_file_name(filename, &CC->quickroom, "netconfigs");
+ assoc_file_name(filename, sizeof filename, &CC->quickroom, "netconfigs");
fp = fopen(tempfilename, "w");
if (fp == NULL) {
lprintf(9, "Generating delivery instructions\n");
instr = mallok(instr_len);
if (instr == NULL) {
- lprintf(1, "Cannot allocate %d bytes for instr...\n",
- instr_len);
+ lprintf(1, "Cannot allocate %ld bytes for instr...\n",
+ (long)instr_len);
abort();
}
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) {
imsg->cm_fields['M'] = instr;
/* Save delivery instructions in spoolout room */
- CtdlSaveMsg(imsg, "", SMTP_SPOOLOUT_ROOM, MES_LOCAL);
+ CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
}
}
memset(&sc, 0, sizeof(struct SpoolControl));
- assoc_file_name(filename, &CC->quickroom, "netconfigs");
+ assoc_file_name(filename, sizeof filename, &CC->quickroom, "netconfigs");
fp = fopen(filename, "r");
if (fp == NULL) {
+
+/*
+ * Bounce a message back to the sender
+ */
+void network_bounce(struct CtdlMessage *msg, char *reason) {
+ char *oldpath = NULL;
+ char buf[SIZ];
+ char bouncesource[SIZ];
+ char recipient[SIZ];
+ struct recptypes *valid = NULL;
+ char force_room[ROOMNAMELEN];
+ static int serialnum = 0;
+
+ lprintf(9, "entering network_bounce()\n");
+
+ if (msg == NULL) return;
+
+ sprintf(bouncesource, "%s@%s", BOUNCESOURCE, config.c_nodename);
+
+ /*
+ * Give it a fresh message ID
+ */
+ if (msg->cm_fields['I'] != NULL) {
+ phree(msg->cm_fields['I']);
+ }
+ sprintf(buf, "%ld.%04lx.%04x@%s",
+ (long)time(NULL), (long)getpid(), ++serialnum, config.c_fqdn);
+ msg->cm_fields['I'] = strdoop(buf);
+
+ /*
+ * FIXME ... right now we're just sending a bounce; we really want to
+ * include the text of the bounced message.
+ */
+ if (msg->cm_fields['M'] != NULL) {
+ phree(msg->cm_fields['M']);
+ }
+ msg->cm_fields['M'] = strdoop(reason);
+ msg->cm_format_type = 0;
+
+ /*
+ * Turn the message around
+ */
+ if (msg->cm_fields['R'] == NULL) {
+ phree(msg->cm_fields['R']);
+ }
+
+ if (msg->cm_fields['D'] == NULL) {
+ phree(msg->cm_fields['D']);
+ }
+
+ snprintf(recipient, sizeof recipient, "%s@%s",
+ msg->cm_fields['A'], msg->cm_fields['N']);
+
+ if (msg->cm_fields['A'] == NULL) {
+ phree(msg->cm_fields['A']);
+ }
+
+ if (msg->cm_fields['N'] == NULL) {
+ phree(msg->cm_fields['N']);
+ }
+
+ msg->cm_fields['A'] = strdoop(BOUNCESOURCE);
+ msg->cm_fields['N'] = strdoop(config.c_nodename);
+
+
+ /* prepend our node to the path */
+ if (msg->cm_fields['P'] != NULL) {
+ oldpath = msg->cm_fields['P'];
+ msg->cm_fields['P'] = NULL;
+ }
+ else {
+ oldpath = strdoop("unknown_user");
+ }
+ msg->cm_fields['P'] = mallok(strlen(oldpath) + SIZ);
+ sprintf(msg->cm_fields['P'], "%s!%s", config.c_nodename, oldpath);
+ phree(oldpath);
+
+ /* Now submit the message */
+ valid = validate_recipients(recipient);
+ if (valid != NULL) if (valid->num_error > 0) {
+ phree(valid);
+ valid = NULL;
+ }
+ if ( (valid == NULL) || (!strcasecmp(recipient, bouncesource)) ) {
+ strcpy(force_room, AIDEROOM);
+ }
+ else {
+ strcpy(force_room, "");
+ }
+ if ( (valid == NULL) && (strlen(force_room) == 0) ) {
+ strcpy(force_room, AIDEROOM);
+ }
+ CtdlSubmitMsg(msg, valid, force_room);
+
+ /* Clean up */
+ if (valid != NULL) phree(valid);
+ CtdlFreeMessage(msg);
+ lprintf(9, "leaving network_bounce()\n");
+}
+
+
+
+
/*
* Process a buffer containing a single message from a single file
* from the inbound queue
struct CtdlMessage *msg;
long pos;
int field;
- int a;
- int e = MES_LOCAL;
- struct usersupp tempUS;
- char recp[SIZ];
+ struct recptypes *recp = NULL;
char target_room[ROOMNAMELEN];
struct ser_ret sermsg;
char *oldpath = NULL;
char filename[SIZ];
FILE *fp;
+ char buf[SIZ];
/* Set default target room to trash */
strcpy(target_room, TWITROOM);
else { /* invalid destination node name */
- /* FIXME bounce the msg */
+ network_bounce(msg,
+"A message you sent could not be delivered due to an invalid destination node"
+" name. Please check the address and try sending the message again.\n");
+ msg = NULL;
+ return;
}
}
}
- /* 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(msg) != 0) {
+ sprintf(buf,
+ "Loopzapper rejected message <%s> "
+ "from <%s> in <%s> @ <%s>\n",
+ ((msg->cm_fields['I']!=NULL)?(msg->cm_fields['I']):""),
+ ((msg->cm_fields['A']!=NULL)?(msg->cm_fields['A']):""),
+ ((msg->cm_fields['O']!=NULL)?(msg->cm_fields['O']):""),
+ ((msg->cm_fields['N']!=NULL)?(msg->cm_fields['N']):"")
+ );
+ 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)) {
/* Does it have a recipient? If so, validate it... */
if (msg->cm_fields['R'] != NULL) {
-
- safestrncpy(recp, msg->cm_fields['R'], sizeof(recp));
-
- e = alias(recp); /* alias and mail type */
- if ((recp[0] == 0) || (e == MES_ERROR)) {
-
- /* FIXME bounce the msg */
-
- }
- else if (e == MES_LOCAL) {
- a = getuser(&tempUS, recp);
- if (a != 0) {
- /* FIXME bounce the msg */
- }
- else {
- MailboxName(target_room, &tempUS, MAILROOM);
- }
+ recp = validate_recipients(msg->cm_fields['R']);
+ if (recp != NULL) if (recp->num_error > 0) {
+ network_bounce(msg,
+"A message you sent could not be delivered due to an invalid address.\n"
+"Please check the address and try sending the message again.\n");
+ msg = NULL;
+ phree(recp);
+ return;
}
- }
+ strcpy(target_room, ""); /* no target room if mail */
+ }
else if (msg->cm_fields['C'] != NULL) {
safestrncpy(target_room,
sizeof target_room);
}
+ /* Strip out fields that are only relevant during transit */
+ if (msg->cm_fields['D'] != NULL) {
+ phree(msg->cm_fields['D']);
+ msg->cm_fields['D'] = NULL;
+ }
+ if (msg->cm_fields['C'] != NULL) {
+ phree(msg->cm_fields['C']);
+ msg->cm_fields['C'] = NULL;
+ }
+
/* save the message into a room */
- msg->cm_flags = CM_SKIP_HOOKS;
- CtdlSaveMsg(msg, "", target_room, 0);
+ if (PerformNetprocHooks(msg, target_room) == 0) {
+ msg->cm_flags = CM_SKIP_HOOKS;
+ CtdlSubmitMsg(msg, recp, target_room);
+ }
CtdlFreeMessage(msg);
+ phree(recp);
}
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);
}
/*
* Run no more frequently than once every n seconds
*/
- if ( (time(NULL) - last_run) < NETWORK_QUEUE_FREQUENCY ) return;
+ if ( (time(NULL) - last_run) < config.c_net_freq ) return;
/*
* This is a simple concurrency check to make sure only one queue run
network_poll_other_citadel_nodes();
/*
- * Load the network map into memory.
+ * Load the network map and filter list into memory.
*/
read_network_map();
+ filterlist = load_filter_list();
/*
* Go ahead and run the queue
lprintf(7, "network: processing inbound queue\n");
network_do_spoolin();
+ /* Save the network map back to disk */
write_network_map();
+ /* Free the filter list in memory */
+ free_filter_list(filterlist);
+ filterlist = NULL;
+
lprintf(7, "network: queue run completed\n");
doing_queue = 0;
}
-
/*
* cmd_netp() - authenticate to the server as another Citadel node polling
* for network traffic
return;
}
+ if (network_talking_to(node, NTT_CHECK)) {
+ cprintf("%d Already talking to %s right now\n", ERROR, node);
+ 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);
}
+
+
/*
* Module entry point
*/
char *Dynamic_Module_Init(void)
{
CtdlRegisterProtoHook(cmd_gnet, "GNET", "Get network config");
- CtdlRegisterProtoHook(cmd_snet, "SNET", "Get network config");
+ CtdlRegisterProtoHook(cmd_snet, "SNET", "Set network config");
CtdlRegisterProtoHook(cmd_netp, "NETP", "Identify as network poller");
CtdlRegisterSessionHook(network_do_queue, EVT_TIMER);
return "$Id$";
projects / citadel.git / blobdiff