* Copyright (C) 2000-2002 by Art Cancro and others.
* This code is released under the terms of the GNU General Public License.
*
+ * ** NOTE ** A word on the S_NETCONFIGS semaphore:
+ * This is a fairly high-level type of critical section. It ensures that no
+ * two threads work on the netconfigs files at the same time. Since we do
+ * so many things inside these, here are the rules:
+ * 1. begin_critical_section(S_NETCONFIGS) *before* begin_ any others.
+ * 2. Do *not* perform any I/O with the client during these sections.
+ *
*/
/*
- * FIXME
- * Don't allow polls during network processing
+ * Duration of time (in seconds) after which pending list subscribe/unsubscribe
+ * requests that have not been confirmed will be deleted.
*/
+#define EXP 259200 /* three days */
#include "sysdep.h"
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
+#include <ctype.h>
#include <signal.h>
#include <pwd.h>
#include <errno.h>
#include "citserver.h"
#include "support.h"
#include "config.h"
-#include "dynloader.h"
+#include "serv_extensions.h"
#include "room_ops.h"
#include "user_ops.h"
#include "policy.h"
#include "snprintf.h"
#endif
+/* Nonzero while we are doing outbound network processing */
+static int doing_queue = 0;
/*
* When we do network processing, it's accomplished in two passes; one to
*/
struct NetMap *the_netmap = NULL;
+/*
+ * Keep track of what messages to reject
+ */
+struct FilterList *load_filter_list(void) {
+ char *serialized_list = NULL;
+ int i;
+ char buf[SIZ];
+ struct FilterList *newlist = NULL;
+ struct FilterList *nptr;
+
+ 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
serialized_map = reallok(serialized_map,
(strlen(serialized_map)+SIZ) );
if (strlen(nmptr->nodename) > 0) {
- sprintf(&serialized_map[strlen(serialized_map)],
+ snprintf(&serialized_map[strlen(serialized_map)],
+ SIZ,
"%s|%ld|%s\n",
nmptr->nodename,
(long)nmptr->lastcontact,
FILE *fp;
if (CtdlAccessCheck(ac_room_aide)) return;
- assoc_file_name(filename, &CC->quickroom, "netconfigs");
+ assoc_file_name(filename, sizeof filename, &CC->room, "netconfigs");
cprintf("%d Network settings for room #%ld <%s>\n",
LISTING_FOLLOWS,
- CC->quickroom.QRnumber, CC->quickroom.QRname);
+ CC->room.QRnumber, CC->room.QRname);
fp = fopen(filename, "r");
if (fp != NULL) {
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->room, "netconfigs");
fp = fopen(tempfilename, "w");
if (fp == NULL) {
*/
unlink(filename);
snprintf(buf, sizeof buf, "/bin/mv %s %s", tempfilename, filename);
+ begin_critical_section(S_NETCONFIGS);
system(buf);
+ end_critical_section(S_NETCONFIGS);
}
-
/*
* Spools out one message from the list.
*/
void network_spool_msg(long msgnum, void *userdata) {
struct SpoolControl *sc;
- struct namelist *nptr;
int err;
int i;
- char *instr = NULL;
char *newpath = NULL;
+ char *instr = NULL;
size_t instr_len = SIZ;
struct CtdlMessage *msg = NULL;
struct CtdlMessage *imsg;
+ struct namelist *nptr;
struct ser_ret sermsg;
FILE *fp;
char filename[SIZ];
(long)instr_len);
abort();
}
- sprintf(instr,
+ snprintf(instr, instr_len,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|postmaster@%s\n" ,
SPOOLMIME, msgnum, (long)time(NULL), config.c_fqdn );
/* Generate delivery instructions for each recipient */
for (nptr = sc->listrecps; nptr != NULL; nptr = nptr->next) {
- sprintf(&instr[strlen(instr)], "remote|%s|0||\n",
- nptr->name);
+ size_t tmp = strlen(instr);
+ snprintf(&instr[tmp], instr_len - tmp,
+ "remote|%s|0||\n", nptr->name);
}
/*
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
}
+
+ /*
+ * Process digest recipients
+ */
+ if ((sc->digestrecps != NULL) && (sc->digestfp != NULL)) {
+ fprintf(sc->digestfp, " -----------------------------------"
+ "------------------------------------"
+ "-------\n");
+ CtdlRedirectOutput(sc->digestfp, -1);
+ CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ALL, 0, 0);
+ CtdlRedirectOutput(NULL, -1);
+ sc->num_msgs_spooled += 1;
+ }
/*
* Process IGnet push shares
msg = CtdlFetchMessage(msgnum);
if (msg != NULL) {
+ size_t newpath_len;
/* Prepend our node name to the Path field whenever
* sending a message to another IGnet node
if (msg->cm_fields['P'] == NULL) {
msg->cm_fields['P'] = strdoop("username");
}
- newpath = mallok(strlen(msg->cm_fields['P']) +
- strlen(config.c_nodename) + 2);
- sprintf(newpath, "%s!%s", config.c_nodename,
- msg->cm_fields['P']);
+ newpath_len = strlen(msg->cm_fields['P']) +
+ strlen(config.c_nodename) + 2;
+ newpath = mallok(newpath_len);
+ snprintf(newpath, newpath_len, "%s!%s",
+ config.c_nodename, msg->cm_fields['P']);
phree(msg->cm_fields['P']);
msg->cm_fields['P'] = newpath;
if (msg->cm_fields['C'] != NULL) {
phree(msg->cm_fields['C']);
}
- msg->cm_fields['C'] = strdoop(CC->quickroom.QRname);
+ msg->cm_fields['C'] = strdoop(CC->room.QRname);
/*
* Determine if this message is set to be deleted
/* Send the message */
if (send == 1) {
- sprintf(filename,
+ snprintf(filename, sizeof filename,
"./network/spoolout/%s",
nptr->name);
fp = fopen(filename, "ab");
/* Delete this message if delete-after-send is set */
if (delete_after_send) {
- CtdlDeleteMessages(CC->quickroom.QRname, msgnum, "");
+ CtdlDeleteMessages(CC->room.QRname, msgnum, "");
}
}
+/*
+ * Deliver digest messages
+ */
+void network_deliver_digest(struct SpoolControl *sc) {
+ char buf[SIZ];
+ int i;
+ struct CtdlMessage *msg;
+ long msglen;
+ long msgnum;
+ char *instr = NULL;
+ size_t instr_len = SIZ;
+ struct CtdlMessage *imsg;
+ struct namelist *nptr;
+
+ if (sc->num_msgs_spooled < 1) {
+ fclose(sc->digestfp);
+ sc->digestfp = NULL;
+ return;
+ }
+
+ msg = mallok(sizeof(struct CtdlMessage));
+ memset(msg, 0, sizeof(struct CtdlMessage));
+ msg->cm_magic = CTDLMESSAGE_MAGIC;
+ msg->cm_format_type = FMT_RFC822;
+ msg->cm_anon_type = MES_NORMAL;
+
+ sprintf(buf, "%ld", time(NULL));
+ msg->cm_fields['T'] = strdoop(buf);
+ msg->cm_fields['A'] = strdoop(CC->room.QRname);
+ msg->cm_fields['U'] = strdoop(CC->room.QRname);
+ sprintf(buf, "room_%s@%s", CC->room.QRname, config.c_fqdn);
+ for (i=0; i<strlen(buf); ++i) {
+ if (isspace(buf[i])) buf[i]='_';
+ buf[i] = tolower(buf[i]);
+ }
+ msg->cm_fields['F'] = strdoop(buf);
+
+ fseek(sc->digestfp, 0L, SEEK_END);
+ msglen = ftell(sc->digestfp);
+
+ msg->cm_fields['M'] = mallok(msglen + 1);
+ fseek(sc->digestfp, 0L, SEEK_SET);
+ fread(msg->cm_fields['M'], (size_t)msglen, 1, sc->digestfp);
+ msg->cm_fields['M'][msglen] = 0;
+
+ fclose(sc->digestfp);
+ sc->digestfp = NULL;
+
+ msgnum = CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM);
+ CtdlFreeMessage(msg);
+
+ /* Now generate the delivery instructions */
+
+ /*
+ * Figure out how big a buffer we need to allocate
+ */
+ for (nptr = sc->digestrecps; nptr != NULL; nptr = nptr->next) {
+ instr_len = instr_len + strlen(nptr->name);
+ }
+
+ /*
+ * allocate...
+ */
+ lprintf(9, "Generating delivery instructions\n");
+ instr = mallok(instr_len);
+ if (instr == NULL) {
+ lprintf(1, "Cannot allocate %ld bytes for instr...\n",
+ (long)instr_len);
+ abort();
+ }
+ snprintf(instr, instr_len,
+ "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
+ "bounceto|postmaster@%s\n" ,
+ SPOOLMIME, msgnum, (long)time(NULL), config.c_fqdn );
+
+ /* Generate delivery instructions for each recipient */
+ for (nptr = sc->digestrecps; nptr != NULL; nptr = nptr->next) {
+ size_t tmp = strlen(instr);
+ snprintf(&instr[tmp], instr_len - tmp,
+ "remote|%s|0||\n", nptr->name);
+ }
+
+ /*
+ * Generate a message from the instructions
+ */
+ imsg = mallok(sizeof(struct CtdlMessage));
+ memset(imsg, 0, sizeof(struct CtdlMessage));
+ imsg->cm_magic = CTDLMESSAGE_MAGIC;
+ imsg->cm_anon_type = MES_NORMAL;
+ imsg->cm_format_type = FMT_RFC822;
+ imsg->cm_fields['A'] = strdoop("Citadel");
+ imsg->cm_fields['M'] = instr;
+
+ /* Save delivery instructions in spoolout room */
+ CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
+ CtdlFreeMessage(imsg);
+}
/*
char instr[SIZ];
FILE *fp;
struct SpoolControl sc;
- /* struct namelist *digestrecps = NULL; */
struct namelist *nptr;
+ size_t miscsize = 0;
+ size_t linesize = 0;
+ int skipthisline = 0;
+ int i;
- lprintf(7, "Spooling <%s>\n", room_to_spool);
- if (getroom(&CC->quickroom, room_to_spool) != 0) {
+ if (getroom(&CC->room, room_to_spool) != 0) {
lprintf(1, "ERROR: cannot load <%s>\n", room_to_spool);
return;
}
memset(&sc, 0, sizeof(struct SpoolControl));
- assoc_file_name(filename, &CC->quickroom, "netconfigs");
+ assoc_file_name(filename, sizeof filename, &CC->room, "netconfigs");
+
+ begin_critical_section(S_NETCONFIGS);
+ end_critical_section(S_NETCONFIGS);
fp = fopen(filename, "r");
if (fp == NULL) {
- lprintf(7, "Outbound batch processing skipped for <%s>\n",
- CC->quickroom.QRname);
+ end_critical_section(S_NETCONFIGS);
return;
}
- lprintf(5, "Outbound batch processing started for <%s>\n",
- CC->quickroom.QRname);
+ lprintf(5, "Networking started for <%s>\n", CC->room.QRname);
while (fgets(buf, sizeof buf, fp) != NULL) {
buf[strlen(buf)-1] = 0;
extract(nptr->name, buf, 1);
sc.listrecps = nptr;
}
+ else if (!strcasecmp(instr, "digestrecp")) {
+ nptr = (struct namelist *)
+ mallok(sizeof(struct namelist));
+ nptr->next = sc.digestrecps;
+ extract(nptr->name, buf, 1);
+ sc.digestrecps = nptr;
+ }
else if (!strcasecmp(instr, "ignet_push_share")) {
nptr = (struct namelist *)
mallok(sizeof(struct namelist));
extract(nptr->name, buf, 1);
sc.ignet_push_shares = nptr;
}
+ else {
+ /* Preserve 'other' lines ... *unless* they happen to
+ * be subscribe/unsubscribe pendings with expired
+ * timestamps.
+ */
+ skipthisline = 0;
+ if (!strncasecmp(buf, "subpending|", 11)) {
+ if (time(NULL) - extract_long(buf, 4) > EXP) {
+ skipthisline = 1;
+ }
+ }
+ if (!strncasecmp(buf, "unsubpending|", 13)) {
+ if (time(NULL) - extract_long(buf, 3) > EXP) {
+ skipthisline = 1;
+ }
+ }
+
+ if (skipthisline == 0) {
+ linesize = strlen(buf);
+ sc.misc = realloc(sc.misc,
+ (miscsize + linesize + 2) );
+ sprintf(&sc.misc[miscsize], "%s\n", buf);
+ miscsize = miscsize + linesize + 1;
+ }
+ }
}
fclose(fp);
+ /* If there are digest recipients, we have to build a digest */
+ if (sc.digestrecps != NULL) {
+ sc.digestfp = tmpfile();
+ fprintf(sc.digestfp, "Content-type: text/plain\n\n");
+ }
/* Do something useful */
- CtdlForEachMessage(MSGS_GT, sc.lastsent, (-63), NULL, NULL,
+ CtdlForEachMessage(MSGS_GT, sc.lastsent, NULL, NULL,
network_spool_msg, &sc);
+ /* If we wrote a digest, deliver it and then close it */
+ snprintf(buf, sizeof buf, "room_%s@%s",
+ CC->room.QRname, config.c_fqdn);
+ for (i=0; i<strlen(buf); ++i) {
+ buf[i] = tolower(buf[i]);
+ if (isspace(buf[i])) buf[i] = '_';
+ }
+ if (sc.digestfp != NULL) {
+ fprintf(sc.digestfp, " -----------------------------------"
+ "------------------------------------"
+ "-------\n"
+ "You are subscribed to the '%s' "
+ "list.\n"
+ "To post to the list: %s\n",
+ CC->room.QRname, buf
+ );
+ network_deliver_digest(&sc); /* deliver and close */
+ }
/* Now rewrite the config file */
fp = fopen(filename, "w");
phree(sc.listrecps);
sc.listrecps = nptr;
}
+ /* Do the same for digestrecps */
+ while (sc.digestrecps != NULL) {
+ fprintf(fp, "digestrecp|%s\n", sc.digestrecps->name);
+ nptr = sc.digestrecps->next;
+ phree(sc.digestrecps);
+ sc.digestrecps = nptr;
+ }
while (sc.ignet_push_shares != NULL) {
fprintf(fp, "ignet_push_share|%s\n",
sc.ignet_push_shares->name);
phree(sc.ignet_push_shares);
sc.ignet_push_shares = nptr;
}
+ if (sc.misc != NULL) {
+ fwrite(sc.misc, strlen(sc.misc), 1, fp);
+ }
+ phree(sc.misc);
fclose(fp);
}
-
- lprintf(5, "Outbound batch processing finished for <%s>\n",
- CC->quickroom.QRname);
+ end_critical_section(S_NETCONFIGS);
}
/*
* Batch up and send all outbound traffic from the current room
*/
-void network_queue_room(struct quickroom *qrbuf, void *data) {
+void network_queue_room(struct ctdlroom *qrbuf, void *data) {
struct RoomProcList *ptr;
ptr = (struct RoomProcList *) mallok(sizeof (struct RoomProcList));
struct recptypes *valid = NULL;
char force_room[ROOMNAMELEN];
static int serialnum = 0;
+ size_t size;
lprintf(9, "entering network_bounce()\n");
if (msg == NULL) return;
- sprintf(bouncesource, "%s@%s", BOUNCESOURCE, config.c_nodename);
+ snprintf(bouncesource, sizeof 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.%04x.%04x@%s",
- (long)time(NULL), getpid(), ++serialnum, config.c_fqdn);
+ snprintf(buf, sizeof buf, "%ld.%04lx.%04x@%s",
+ (long)time(NULL), (long)getpid(), ++serialnum, config.c_fqdn);
msg->cm_fields['I'] = strdoop(buf);
/*
else {
oldpath = strdoop("unknown_user");
}
- msg->cm_fields['P'] = mallok(strlen(oldpath) + SIZ);
- sprintf(msg->cm_fields['P'], "%s!%s", config.c_nodename, oldpath);
+ size = strlen(oldpath) + SIZ;
+ msg->cm_fields['P'] = mallok(size);
+ snprintf(msg->cm_fields['P'], size, "%s!%s", config.c_nodename, oldpath);
phree(oldpath);
/* Now submit the message */
valid = NULL;
}
if ( (valid == NULL) || (!strcasecmp(recipient, bouncesource)) ) {
- strcpy(force_room, AIDEROOM);
+ strcpy(force_room, config.c_aideroom);
}
else {
strcpy(force_room, "");
}
if ( (valid == NULL) && (strlen(force_room) == 0) ) {
- strcpy(force_room, AIDEROOM);
+ strcpy(force_room, config.c_aideroom);
}
CtdlSubmitMsg(msg, valid, force_room);
else {
oldpath = strdoop("unknown_user");
}
- msg->cm_fields['P'] =
- mallok(strlen(oldpath) + SIZ);
- sprintf(msg->cm_fields['P'], "%s!%s",
+ size = strlen(oldpath) + SIZ;
+ msg->cm_fields['P'] = mallok(size);
+ snprintf(msg->cm_fields['P'], size, "%s!%s",
config.c_nodename, oldpath);
phree(oldpath);
serialize_message(&sermsg, msg);
/* now send it */
- sprintf(filename,
+ snprintf(filename, sizeof filename,
"./network/spoolout/%s",
msg->cm_fields['D']);
fp = fopen(filename, "ab");
* Check to see if we already have a copy of this message
*/
if (network_usetable(msg) != 0) {
- sprintf(buf,
+ snprintf(buf, sizeof buf,
"Loopzapper rejected message <%s> "
"from <%s> in <%s> @ <%s>\n",
((msg->cm_fields['I']!=NULL)?(msg->cm_fields['I']):""),
if (dp == NULL) return;
while (d = readdir(dp), d != NULL) {
- sprintf(filename, "./network/spoolin/%s", d->d_name);
+ snprintf(filename, sizeof filename, "./network/spoolin/%s", d->d_name);
network_process_file(filename);
}
}
while (bytes_received < download_len) {
- sprintf(buf, "READ %ld|%ld",
+ snprintf(buf, sizeof buf, "READ %ld|%ld",
bytes_received,
((download_len - bytes_received > IGNET_PACKET_SIZE)
? IGNET_PACKET_SIZE : (download_len - bytes_received)));
return;
}
lprintf(9, "%s\n", buf);
- sprintf(buf, "mv %s ./network/spoolin/%s.%ld",
+ snprintf(buf, sizeof buf, "mv %s ./network/spoolin/%s.%ld",
tempfilename, remote_nodename, (long) getpid());
system(buf);
}
return;
}
- sprintf(sfname, "./network/spoolout/%s", remote_nodename);
+ snprintf(sfname, sizeof sfname, "./network/spoolout/%s", remote_nodename);
fd = open(sfname, O_RDONLY);
if (fd < 0) {
if (errno == ENOENT) {
while (plen = (long) read(fd, pbuf, IGNET_PACKET_SIZE), plen > 0L) {
bytes_to_write = plen;
while (bytes_to_write > 0L) {
- sprintf(buf, "WRIT %ld", bytes_to_write);
+ snprintf(buf, sizeof buf, "WRIT %ld", bytes_to_write);
if (sock_puts(sock, buf) < 0) {
close(fd);
return;
lprintf(9, ">%s\n", buf);
/* Identify ourselves */
- sprintf(buf, "NETP %s|%s", config.c_nodename, secret);
+ snprintf(buf, sizeof buf, "NETP %s|%s", config.c_nodename, secret);
lprintf(9, "<%s\n", buf);
if (sock_puts(sock, buf) <0) goto bail;
if (sock_gets(sock, buf) < 0) goto bail;
* Run through the rooms doing various types of network stuff.
*/
void network_do_queue(void) {
- static int doing_queue = 0;
static time_t last_run = 0L;
struct RoomProcList *ptr;
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
/* 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
char secret[SIZ];
char nexthop[SIZ];
+ if (doing_queue) {
+ cprintf("%d spooling - try again in a few minutes\n", ERROR);
+ return;
+ }
+
extract(node, cmdbuf, 0);
extract(pass, cmdbuf, 1);
safestrncpy(CC->net_node, node, sizeof CC->net_node);
network_talking_to(node, NTT_ADD);
- cprintf("%d authenticated as network node '%s'\n", OK,
+ cprintf("%d authenticated as network node '%s'\n", CIT_OK,
CC->net_node);
}
+
+
/*
* Module entry point
*/
-char *Dynamic_Module_Init(void)
+char *serv_network_init(void)
{
CtdlRegisterProtoHook(cmd_gnet, "GNET", "Get network config");
CtdlRegisterProtoHook(cmd_snet, "SNET", "Set network config");
projects / citadel.git / blobdiff