X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmsgbase.c;h=36c5fbb2ded471f7da741d669f94e79e68dd5dd0;hb=11219dbc3e638e7ee47feffbbb7d63588d7dd77f;hp=10c173add63a6dcbd1b6aea7569b5bb653c72a26;hpb=36d04901ec62a2f95611f7ae91e3aa60009246ad;p=citadel.git

diff --git a/citadel/msgbase.c b/citadel/msgbase.c
index 10c173add..36c5fbb2d 100644
--- a/citadel/msgbase.c
+++ b/citadel/msgbase.c
@@ -5,10 +5,6 @@
  *
  */
 
-#ifdef DLL_EXPORT
-#define IN_LIBCIT
-#endif
-
 #include "sysdep.h"
 #include <stdlib.h>
 #include <unistd.h>
@@ -53,9 +49,17 @@
 #include "internet_addressing.h"
 #include "serv_fulltext.h"
 #include "vcard.h"
+#include "euidindex.h"
+#include "journaling.h"
+#include "citadel_dirs.h"
+#include "serv_network.h"
 
-long config_msgnum;
+#ifdef HAVE_LIBSIEVE
+# include "serv_sieve.h"
+#endif /* HAVE_LIBSIEVE */
 
+long config_msgnum;
+struct addresses_to_be_filed *atbf = NULL;
 
 /* 
  * This really belongs in serv_network.c, but I don't know how to export
@@ -85,7 +89,8 @@ char *msgkeys[] = {
 	NULL, 
 	"hnod",
 	"msgn",
-	NULL, NULL, NULL,
+	"jrnl",
+	NULL, NULL,
 	"text",
 	"node",
 	"room",
@@ -142,14 +147,9 @@ int alias(char *name)
 
 	striplt(name);
 	remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
+	stripallbut(name, '<', '>');
 
-	fp = fopen(
-#ifndef HAVE_ETG_DIR
-			   "network/"
-#else
-			   ETC_DIR
-#endif
-			   "mail.aliases", "r");
+	fp = fopen(file_mail_aliases, "r");
 	if (fp == NULL) {
 		fp = fopen("/dev/null", "r");
 	}
@@ -244,16 +244,11 @@ void get_mm(void)
 {
 	FILE *fp;
 
-	fp = fopen(
-#ifndef HAVE_RUN_DIR
-			   "."
-#else
-			   RUN_DIR
-#endif
-			   "/citadel.control", "r");
+	fp = fopen(file_citadel_control, "r");
 	if (fp == NULL) {
-		lprintf(CTDL_CRIT, "Cannot open citadel.control: %s\n",
-			strerror(errno));
+		lprintf(CTDL_CRIT, "Cannot open %s: %s\n",
+				file_citadel_control,
+				strerror(errno));
 		exit(errno);
 	}
 	fread((char *) &CitControl, sizeof(struct CitControl), 1, fp);
@@ -279,7 +274,7 @@ void headers_listing(long msgnum, void *userdata)
 	struct CtdlMessage *msg;
 
 	msg = CtdlFetchMessage(msgnum, 0);
-	if (msg < 0L) {
+	if (msg == NULL) {
 		cprintf("%ld|0|||||\n", msgnum);
 		return;
 	}
@@ -347,10 +342,11 @@ void CtdlGetSeen(char *buf, int which_set) {
 /*
  * Manipulate the "seen msgs" string (or other message set strings)
  */
-void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
+void CtdlSetSeen(long *target_msgnums, int num_target_msgnums,
+		int target_setting, int which_set,
 		struct ctdluser *which_user, struct ctdlroom *which_room) {
 	struct cdbdata *cdbfr;
-	int i, j;
+	int i, j, k;
 	int is_seen = 0;
 	int was_seen = 0;
 	long lo = (-1L);
@@ -367,8 +363,9 @@ void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
 	char setstr[SIZ], lostr[SIZ], histr[SIZ];
 	size_t tmp;
 
-	lprintf(CTDL_DEBUG, "CtdlSetSeen(%ld, %d, %d)\n",
-		target_msgnum, target_setting, which_set);
+	lprintf(CTDL_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %d, %d)\n",
+		num_target_msgnums, target_msgnums[0],
+		target_setting, which_set);
 
 	/* Learn about the user and room in question */
 	CtdlGetRelationship(&vbuf,
@@ -379,8 +376,8 @@ void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
 	/* Load the message list */
 	cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
 	if (cdbfr != NULL) {
-		msglist = malloc(cdbfr->len);
-		memcpy(msglist, cdbfr->ptr, cdbfr->len);
+		msglist = (long *) cdbfr->ptr;
+		cdbfr->ptr = NULL;	/* CtdlSetSeen() now owns this memory */
 		num_msgs = cdbfr->len / sizeof(long);
 		cdb_free(cdbfr);
 	} else {
@@ -433,13 +430,13 @@ void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
 	hi = (-1L);
 
 	for (i=0; i<num_msgs; ++i) {
-		is_seen = 0;
 
-		if (msglist[i] == target_msgnum) {
-			is_seen = target_setting;
-		}
-		else {
-			is_seen = is_set[i];
+		is_seen = is_set[i];	/* Default to existing setting */
+
+		for (k=0; k<num_target_msgnums; ++k) {
+			if (msglist[i] == target_msgnums[k]) {
+				is_seen = target_setting;
+			}
 		}
 
 		if (is_seen) {
@@ -512,14 +509,14 @@ void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
  * API function to perform an operation for each qualifying message in the
  * current room.  (Returns the number of messages processed.)
  */
-int CtdlForEachMessage(int mode, long ref,
+int CtdlForEachMessage(int mode, long ref, char *search_string,
 			char *content_type,
 			struct CtdlMessage *compare,
 			void (*CallBack) (long, void *),
 			void *userdata)
 {
 
-	int a;
+	int a, i, j;
 	struct visit vbuf;
 	struct cdbdata *cdbfr;
 	long *msglist = NULL;
@@ -531,6 +528,8 @@ int CtdlForEachMessage(int mode, long ref,
 	int is_seen = 0;
 	long lastold = 0L;
 	int printed_lastold = 0;
+	int num_search_msgs = 0;
+	long *search_msgs = NULL;
 
 	/* Learn about the user and room in question */
 	get_mm();
@@ -540,8 +539,8 @@ int CtdlForEachMessage(int mode, long ref,
 	/* Load the message list */
 	cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
 	if (cdbfr != NULL) {
-		msglist = malloc(cdbfr->len);
-		memcpy(msglist, cdbfr->ptr, cdbfr->len);
+		msglist = (long *) cdbfr->ptr;
+		cdbfr->ptr = NULL;	/* CtdlForEachMessage() now owns this memory */
 		num_msgs = cdbfr->len / sizeof(long);
 		cdb_free(cdbfr);
 	} else {
@@ -595,7 +594,45 @@ int CtdlForEachMessage(int mode, long ref,
 		}
 	}
 
+	/* If a search string was specified, get a message list from
+	 * the full text index and remove messages which aren't on both
+	 * lists.
+	 *
+	 * How this works:
+	 * Since the lists are sorted and strictly ascending, and the
+	 * output list is guaranteed to be shorter than or equal to the
+	 * input list, we overwrite the bottom of the input list.  This
+	 * eliminates the need to memmove big chunks of the list over and
+	 * over again.
+	 */
+	if ( (num_msgs > 0) && (mode == MSGS_SEARCH) && (search_string) ) {
+		ft_search(&num_search_msgs, &search_msgs, search_string);
+		if (num_search_msgs > 0) {
 	
+			int orig_num_msgs;
+
+			orig_num_msgs = num_msgs;
+			num_msgs = 0;
+			for (i=0; i<orig_num_msgs; ++i) {
+				for (j=0; j<num_search_msgs; ++j) {
+					if (msglist[i] == search_msgs[j]) {
+						msglist[num_msgs++] = msglist[i];
+					}
+				}
+			}
+		}
+		else {
+			num_msgs = 0;	/* No messages qualify */
+		}
+		if (search_msgs != NULL) free(search_msgs);
+
+		/* Now that we've purged messages which don't contain the search
+		 * string, treat a MSGS_SEARCH just like a MSGS_ALL from this
+		 * point on.
+		 */
+		mode = MSGS_ALL;
+	}
+
 	/*
 	 * Now iterate through the message list, according to the
 	 * criteria supplied by the caller.
@@ -655,13 +692,14 @@ void cmd_msgs(char *cmdbuf)
 	int with_template = 0;
 	struct CtdlMessage *template = NULL;
 	int with_headers = 0;
+	char search_string[1024];
 
 	extract_token(which, cmdbuf, 0, '|', sizeof which);
 	cm_ref = extract_int(cmdbuf, 1);
+	extract_token(search_string, cmdbuf, 1, '|', sizeof search_string);
 	with_template = extract_int(cmdbuf, 2);
 	with_headers = extract_int(cmdbuf, 3);
 
-	mode = MSGS_ALL;
 	strcat(which, "   ");
 	if (!strncasecmp(which, "OLD", 3))
 		mode = MSGS_OLD;
@@ -673,12 +711,22 @@ void cmd_msgs(char *cmdbuf)
 		mode = MSGS_LAST;
 	else if (!strncasecmp(which, "GT", 2))
 		mode = MSGS_GT;
+	else if (!strncasecmp(which, "SEARCH", 6))
+		mode = MSGS_SEARCH;
+	else
+		mode = MSGS_ALL;
 
 	if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
 		cprintf("%d not logged in\n", ERROR + NOT_LOGGED_IN);
 		return;
 	}
 
+	if ( (mode == MSGS_SEARCH) && (!config.c_enable_fulltext) ) {
+		cprintf("%d Full text index is not enabled on this server.\n",
+			ERROR + CMD_NOT_SUPPORTED);
+		return;
+	}
+
 	if (with_template) {
 		unbuffer_output();
 		cprintf("%d Send template then receive message list\n",
@@ -703,7 +751,8 @@ void cmd_msgs(char *cmdbuf)
 	}
 
 	CtdlForEachMessage(mode,
-			cm_ref,
+			( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
+			( (mode == MSGS_SEARCH) ? search_string : NULL ),
 			NULL,
 			template,
 			(with_headers ? headers_listing : simple_listing),
@@ -746,7 +795,7 @@ void do_help_subst(char *buffer)
 	help_subst(buffer, "^variantname", CITADEL);
 	snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
 	help_subst(buffer, "^maxsessions", buf2);
-	help_subst(buffer, "^bbsdir", CTDLDIR);
+	help_subst(buffer, "^bbsdir", ctdl_bbsbase_dir);
 }
 
 
@@ -759,7 +808,6 @@ void do_help_subst(char *buffer)
  *	     to the client.  The client software may reformat it again.
  */
 void memfmout(
-	int width,		/* screen width to use */
 	char *mptr,		/* where are we going to get our text from? */
 	char subst,		/* nonzero if we should do substitutions */
 	char *nl)		/* string to terminate lines with */
@@ -770,6 +818,7 @@ void memfmout(
 	cit_uint8_t ch;
 	char aaa[140];
 	char buffer[SIZ];
+	static int width = 80;
 
 	strcpy(aaa, "");
 	old = 255;
@@ -797,15 +846,13 @@ void memfmout(
 		old = real;
 		real = ch;
 
-		if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10))
+		if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10)) {
 			ch = 32;
+		}
 		if (((old == 13) || (old == 10)) && (isspace(real))) {
 			cprintf("%s", nl);
 			c = 1;
 		}
-		if (ch > 126)
-			continue;
-
 		if (ch > 32) {
 			if (((strlen(aaa) + c) > (width - 5)) && (strlen(aaa) > (width - 5))) {
 				cprintf("%s%s", nl, aaa);
@@ -922,6 +969,27 @@ void mime_download(char *name, char *filename, char *partnum, char *disp,
 
 
 
+/*
+ * Callback function for mime parser that outputs a section all at once
+ */
+void mime_spew_section(char *name, char *filename, char *partnum, char *disp,
+		   void *content, char *cbtype, char *cbcharset, size_t length,
+		   char *encoding, void *cbuserdata)
+{
+	int *found_it = (int *)cbuserdata;
+
+	/* ...or if this is not the desired section */
+	if (strcasecmp(CC->download_desired_section, partnum))
+		return;
+
+	*found_it = 1;
+
+	cprintf("%d %d\n", BINARY_FOLLOWS, length);
+	client_write(content, length);
+}
+
+
+
 /*
  * Load a message from disk into memory.
  * This is used by CtdlOutputMsg() and other fetch functions.
@@ -998,7 +1066,7 @@ struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
 		}
 	}
 	if (ret->cm_fields['M'] == NULL) {
-		ret->cm_fields['M'] = strdup("<no text>\n");
+		ret->cm_fields['M'] = strdup("\r\n\r\n (no text)\r\n");
 	}
 
 	/* Perform "before read" hooks (aborting if any return nonzero) */
@@ -1066,7 +1134,9 @@ void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
 	if (!strcasecmp(cbtype, "multipart/alternative")) {
 		++ma->is_ma;
 		ma->did_print = 0;
-		return;
+	}
+	if (!strcasecmp(cbtype, "message/rfc822")) {
+		++ma->freeze;
 	}
 }
 
@@ -1074,8 +1144,8 @@ void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
  * Post callback function for multipart/alternative
  */
 void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
-	  	void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
-		void *cbuserdata)
+	  	void *content, char *cbtype, char *cbcharset, size_t length,
+		char *encoding, void *cbuserdata)
 {
 	struct ma_info *ma;
 	
@@ -1084,7 +1154,9 @@ void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
 	if (!strcasecmp(cbtype, "multipart/alternative")) {
 		--ma->is_ma;
 		ma->did_print = 0;
-	return;
+	}
+	if (!strcasecmp(cbtype, "message/rfc822")) {
+		--ma->freeze;
 	}
 }
 
@@ -1092,61 +1164,82 @@ void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
  * Inline callback function for mime parser that wants to display text
  */
 void fixed_output(char *name, char *filename, char *partnum, char *disp,
-	  	void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
-		void *cbuserdata)
-	{
-		char *ptr;
-		char *wptr;
-		size_t wlen;
-		struct ma_info *ma;
-	
-		ma = (struct ma_info *)cbuserdata;
+	  	void *content, char *cbtype, char *cbcharset, size_t length,
+		char *encoding, void *cbuserdata)
+{
+	char *ptr;
+	char *wptr;
+	size_t wlen;
+	struct ma_info *ma;
 
-		lprintf(CTDL_DEBUG, "fixed_output() type=<%s>\n", cbtype);	
+	ma = (struct ma_info *)cbuserdata;
 
-		/*
-		 * If we're in the middle of a multipart/alternative scope and
-		 * we've already printed another section, skip this one.
-		 */	
-	   	if ( (ma->is_ma == 1) && (ma->did_print == 1) ) {
-			lprintf(CTDL_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
-			return;
-		}
-		ma->did_print = 1;
-	
-		if ( (!strcasecmp(cbtype, "text/plain")) 
-		   || (strlen(cbtype)==0) ) {
-			wptr = content;
-			if (length > 0) {
-				client_write(wptr, length);
-				if (wptr[length-1] != '\n') {
-					cprintf("\n");
-				}
-			}
-		}
-		else if (!strcasecmp(cbtype, "text/html")) {
-			ptr = html_to_ascii(content, 80, 0);
-			wlen = strlen(ptr);
-			client_write(ptr, wlen);
-			if (ptr[wlen-1] != '\n') {
+	lprintf(CTDL_DEBUG,
+		"fixed_output() part %s: %s (%s) (%ld bytes)\n",
+		partnum, filename, cbtype, (long)length);
+
+	/*
+	 * If we're in the middle of a multipart/alternative scope and
+	 * we've already printed another section, skip this one.
+	 */	
+   	if ( (ma->is_ma) && (ma->did_print) ) {
+		lprintf(CTDL_DEBUG, "Skipping part %s (%s)\n",
+			partnum, cbtype);
+		return;
+	}
+	ma->did_print = 1;
+
+	if ( (!strcasecmp(cbtype, "text/plain")) 
+	   || (strlen(cbtype)==0) ) {
+		wptr = content;
+		if (length > 0) {
+			client_write(wptr, length);
+			if (wptr[length-1] != '\n') {
 				cprintf("\n");
 			}
-			free(ptr);
 		}
-		else if (strncasecmp(cbtype, "multipart/", 10)) {
-			cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
-				partnum, filename, cbtype, (long)length);
+		return;
+	}
+
+	if (!strcasecmp(cbtype, "text/html")) {
+		ptr = html_to_ascii(content, length, 80, 0);
+		wlen = strlen(ptr);
+		client_write(ptr, wlen);
+		if (ptr[wlen-1] != '\n') {
+			cprintf("\n");
+		}
+		free(ptr);
+		return;
+	}
+
+	if (ma->use_fo_hooks) {
+		if (PerformFixedOutputHooks(cbtype, content, length)) {
+		/* above function returns nonzero if it handled the part */
+			return;
 		}
 	}
 
+	if (strncasecmp(cbtype, "multipart/", 10)) {
+		cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
+			partnum, filename, cbtype, (long)length);
+		return;
+	}
+}
+
 /*
  * The client is elegant and sophisticated and wants to be choosy about
  * MIME content types, so figure out which multipart/alternative part
  * we're going to send.
+ *
+ * We use a system of weights.  When we find a part that matches one of the
+ * MIME types we've declared as preferential, we can store it in ma->chosen_part
+ * and then set ma->chosen_pref to that MIME type's position in our preference
+ * list.  If we then hit another match, we only replace the first match if
+ * the preference value is lower.
  */
 void choose_preferred(char *name, char *filename, char *partnum, char *disp,
-	  	void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
-		void *cbuserdata)
+	  	void *content, char *cbtype, char *cbcharset, size_t length,
+		char *encoding, void *cbuserdata)
 {
 	char buf[1024];
 	int i;
@@ -1157,8 +1250,12 @@ void choose_preferred(char *name, char *filename, char *partnum, char *disp,
 	if (ma->is_ma > 0) {
 		for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
 			extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
-			if (!strcasecmp(buf, cbtype)) {
-				strcpy(ma->chosen_part, partnum);
+			lprintf(CTDL_DEBUG, "Is <%s> == <%s> ??\n", buf, cbtype);
+			if ( (!strcasecmp(buf, cbtype)) && (!ma->freeze) ) {
+				if (i < ma->chosen_pref) {
+					safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
+					ma->chosen_pref = i;
+				}
 			}
 		}
 	}
@@ -1168,8 +1265,8 @@ void choose_preferred(char *name, char *filename, char *partnum, char *disp,
  * Now that we've chosen our preferred part, output it.
  */
 void output_preferred(char *name, char *filename, char *partnum, char *disp,
-	  	void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
-		void *cbuserdata)
+	  	void *content, char *cbtype, char *cbcharset, size_t length,
+		char *encoding, void *cbuserdata)
 {
 	int i;
 	char buf[128];
@@ -1221,6 +1318,37 @@ void output_preferred(char *name, char *filename, char *partnum, char *disp,
 }
 
 
+struct encapmsg {
+	char desired_section[64];
+	char *msg;
+	size_t msglen;
+};
+
+
+/*
+ * Callback function for
+ */
+void extract_encapsulated_message(char *name, char *filename, char *partnum, char *disp,
+		   void *content, char *cbtype, char *cbcharset, size_t length,
+		   char *encoding, void *cbuserdata)
+{
+	struct encapmsg *encap;
+
+	encap = (struct encapmsg *)cbuserdata;
+
+	/* Only proceed if this is the desired section... */
+	if (!strcasecmp(encap->desired_section, partnum)) {
+		encap->msglen = length;
+		encap->msg = malloc(length + 2);
+		memcpy(encap->msg, content, length);
+		return;
+	}
+
+}
+
+
+
+
 /*
  * Get a message off disk.  (returns om_* values found in msgbase.h)
  * 
@@ -1229,13 +1357,17 @@ int CtdlOutputMsg(long msg_num,		/* message number (local) to fetch */
 		int mode,		/* how would you like that message? */
 		int headers_only,	/* eschew the message body? */
 		int do_proto,		/* do Citadel protocol responses? */
-		int crlf		/* Use CRLF newlines instead of LF? */
+		int crlf,		/* Use CRLF newlines instead of LF? */
+		char *section		/* NULL or a message/rfc822 section */
 ) {
 	struct CtdlMessage *TheMessage = NULL;
 	int retcode = om_no_such_msg;
+	struct encapmsg encap;
 
-	lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d\n", 
-		msg_num, mode);
+	lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d, section=%s\n", 
+		msg_num, mode,
+		(section ? section : "<>")
+	);
 
 	if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
 		if (do_proto) cprintf("%d Not logged in.\n",
@@ -1262,11 +1394,45 @@ int CtdlOutputMsg(long msg_num,		/* message number (local) to fetch */
 			ERROR + MESSAGE_NOT_FOUND, msg_num);
 		return(om_no_such_msg);
 	}
-	
-	retcode = CtdlOutputPreLoadedMsg(
-			TheMessage, msg_num, mode,
-			headers_only, do_proto, crlf);
 
+	/* Here is the weird form of this command, to process only an
+	 * encapsulated message/rfc822 section.
+	 */
+	if (section) if (strlen(section)>0) if (strcmp(section, "0")) {
+		memset(&encap, 0, sizeof encap);
+		safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
+		mime_parser(TheMessage->cm_fields['M'],
+			NULL,
+			*extract_encapsulated_message,
+			NULL, NULL, (void *)&encap, 0
+		);
+		CtdlFreeMessage(TheMessage);
+		TheMessage = NULL;
+
+		if (encap.msg) {
+			encap.msg[encap.msglen] = 0;
+			TheMessage = convert_internet_message(encap.msg);
+			encap.msg = NULL;	/* no free() here, TheMessage owns it now */
+
+			/* Now we let it fall through to the bottom of this
+			 * function, because TheMessage now contains the
+			 * encapsulated message instead of the top-level
+			 * message.  Isn't that neat?
+			 */
+
+		}
+		else {
+			if (do_proto) cprintf("%d msg %ld has no part %s\n",
+				ERROR + MESSAGE_NOT_FOUND, msg_num, section);
+			retcode = om_no_such_msg;
+		}
+
+	}
+
+	/* Ok, output the message now */
+	retcode = CtdlOutputPreLoadedMsg(
+		TheMessage, mode,
+		headers_only, do_proto, crlf);
 	CtdlFreeMessage(TheMessage);
 
 	return(retcode);
@@ -1279,7 +1445,6 @@ int CtdlOutputMsg(long msg_num,		/* message number (local) to fetch */
  */
 int CtdlOutputPreLoadedMsg(
 		struct CtdlMessage *TheMessage,
-		long msg_num,
 		int mode,		/* how would you like that message? */
 		int headers_only,	/* eschew the message body? */
 		int do_proto,		/* do Citadel protocol responses? */
@@ -1308,12 +1473,11 @@ int CtdlOutputPreLoadedMsg(
 	char mid[100];
 	char datestamp[100];
 
-	lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %ld, %d, %d, %d, %d\n",
+	lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
 		((TheMessage == NULL) ? "NULL" : "not null"),
-		msg_num,
 		mode, headers_only, do_proto, crlf);
 
-	snprintf(mid, sizeof mid, "%ld", msg_num);
+	strcpy(mid, "unknown");
 	nl = (crlf ? "\r\n" : "\n");
 
 	if (!is_valid_message(TheMessage)) {
@@ -1349,8 +1513,34 @@ int CtdlOutputPreLoadedMsg(
 		return((CC->download_fp != NULL) ? om_ok : om_mime_error);
 	}
 
+	/* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
+	 * in a single server operation instead of opening a download file.
+	 */
+	if (mode == MT_SPEW_SECTION) {
+		if (TheMessage->cm_format_type != FMT_RFC822) {
+			if (do_proto)
+				cprintf("%d This is not a MIME message.\n",
+				ERROR + ILLEGAL_VALUE);
+		} else {
+			/* Parse the message text component */
+			int found_it = 0;
+
+			mptr = TheMessage->cm_fields['M'];
+			mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
+			/* If section wasn't found, print an error
+			 */
+			if (!found_it) {
+				if (do_proto) cprintf(
+					"%d Section %s not found.\n",
+					ERROR + FILE_NOT_FOUND,
+					CC->download_desired_section);
+			}
+		}
+		return((CC->download_fp != NULL) ? om_ok : om_mime_error);
+	}
+
 	/* now for the user-mode message reading loops */
-	if (do_proto) cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
+	if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
 
 	/* Does the caller want to skip the headers? */
 	if (headers_only == HEADERS_NONE) goto START_TEXT;
@@ -1451,6 +1641,12 @@ int CtdlOutputPreLoadedMsg(
 				else if (i == 'Y') {
 					cprintf("CC: %s%s", mptr, nl);
 				}
+				else if (i == 'P') {
+					cprintf("Return-Path: %s%s", mptr, nl);
+				}
+				else if (i == 'V') {
+					cprintf("Envelope-To: %s%s", mptr, nl);
+				}
 				else if (i == 'U') {
 					cprintf("Subject: %s%s", mptr, nl);
 					subject_found = 1;
@@ -1534,46 +1730,36 @@ START_TEXT:
 				(void *)&ma, 0);
 		}
 		else if (mode == MT_RFC822) {	/* unparsed RFC822 dump */
-			/* FIXME ... we have to put some code in here to avoid
-			 * printing duplicate header information when both
-			 * Citadel and RFC822 headers exist.  Preference should
-			 * probably be given to the RFC822 headers.
-			 */
-			int done_rfc822_hdrs = 0;
-			while (ch=*(mptr++), ch!=0) {
+			char *start_of_text = NULL;
+			start_of_text = strstr(mptr, "\n\r\n");
+			if (start_of_text == NULL) start_of_text = strstr(mptr, "\n\n");
+			if (start_of_text == NULL) start_of_text = mptr;
+			++start_of_text;
+			start_of_text = strstr(start_of_text, "\n");
+			++start_of_text;
+			while (ch=*mptr, ch!=0) {
 				if (ch==13) {
 					/* do nothing */
 				}
-				else if (ch==10) {
-					if (!done_rfc822_hdrs) {
-						if (headers_only != HEADERS_NONE) {
-							cprintf("%s", nl);
-						}
-					}
-					else {
-						if (headers_only != HEADERS_ONLY) {
-							cprintf("%s", nl);
-						}
-					}
-					if ((*(mptr) == 13) || (*(mptr) == 10)) {
-						done_rfc822_hdrs = 1;
-					}
-				}
-				else {
-					if (done_rfc822_hdrs) {
-						if (headers_only != HEADERS_NONE) {
-							cprintf("%c", ch);
+				else switch(headers_only) {
+					case HEADERS_NONE:
+						if (mptr >= start_of_text) {
+							if (ch == 10) cprintf("%s", nl);
+							else cprintf("%c", ch);
 						}
-					}
-					else {
-						if (headers_only != HEADERS_ONLY) {
-							cprintf("%c", ch);
+						break;
+					case HEADERS_ONLY:
+						if (mptr < start_of_text) {
+							if (ch == 10) cprintf("%s", nl);
+							else cprintf("%c", ch);
 						}
-					}
-					if ((*mptr == 13) || (*mptr == 10)) {
-						done_rfc822_hdrs = 1;
-					}
+						break;
+					default:
+						if (ch == 10) cprintf("%s", nl);
+						else cprintf("%c", ch);
+						break;
 				}
+				++mptr;
 			}
 			goto DONE;
 		}
@@ -1623,7 +1809,7 @@ START_TEXT:
 		if (mode == MT_MIME) {
 			cprintf("Content-type: text/x-citadel-variformat\n\n");
 		}
-		memfmout(80, mptr, 0, nl);
+		memfmout(mptr, 0, nl);
 	}
 
 	/* If the message on disk is format 4 (MIME), we've gotta hand it
@@ -1635,7 +1821,9 @@ START_TEXT:
 		memset(&ma, 0, sizeof(struct ma_info));
 
 		if (mode == MT_MIME) {
+			ma.use_fo_hooks = 0;
 			strcpy(ma.chosen_part, "1");
+			ma.chosen_pref = 9999;
 			mime_parser(mptr, NULL,
 				*choose_preferred, *fixed_output_pre,
 				*fixed_output_post, (void *)&ma, 0);
@@ -1643,6 +1831,7 @@ START_TEXT:
 				*output_preferred, NULL, NULL, (void *)&ma, 0);
 		}
 		else {
+			ma.use_fo_hooks = 1;
 			mime_parser(mptr, NULL,
 				*fixed_output, *fixed_output_pre,
 				*fixed_output_post, (void *)&ma, 0);
@@ -1668,7 +1857,7 @@ void cmd_msg0(char *cmdbuf)
 	msgid = extract_long(cmdbuf, 0);
 	headers_only = extract_int(cmdbuf, 1);
 
-	CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0);
+	CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL);
 	return;
 }
 
@@ -1684,7 +1873,7 @@ void cmd_msg2(char *cmdbuf)
 	msgid = extract_long(cmdbuf, 0);
 	headers_only = extract_int(cmdbuf, 1);
 
-	CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1);
+	CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL);
 }
 
 
@@ -1734,9 +1923,11 @@ void cmd_msg3(char *cmdbuf)
 void cmd_msg4(char *cmdbuf)
 {
 	long msgid;
+	char section[64];
 
 	msgid = extract_long(cmdbuf, 0);
-	CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0);
+	extract_token(section, cmdbuf, 1, '|', sizeof section);
+	CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) );
 }
 
 
@@ -1762,103 +1953,118 @@ void cmd_opna(char *cmdbuf)
 
 	msgid = extract_long(cmdbuf, 0);
 	extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
-	safestrncpy(CC->download_desired_section, desired_section, sizeof CC->download_desired_section);
-	CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1);
+	safestrncpy(CC->download_desired_section, desired_section,
+		sizeof CC->download_desired_section);
+	CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL);
+}			
+
+
+/*
+ * Open a component of a MIME message and transmit it all at once
+ */
+void cmd_dlat(char *cmdbuf)
+{
+	long msgid;
+	char desired_section[128];
+
+	msgid = extract_long(cmdbuf, 0);
+	extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
+	safestrncpy(CC->download_desired_section, desired_section,
+		sizeof CC->download_desired_section);
+	CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL);
 }			
 
 
 /*
- * Save a message pointer into a specified room
+ * Save one or more message pointers into a specified room
  * (Returns 0 for success, nonzero for failure)
  * roomname may be NULL to use the current room
+ *
+ * Note that the 'supplied_msg' field may be set to NULL, in which case
+ * the message will be fetched from disk, by number, if we need to perform
+ * replication checks.  This adds an additional database read, so if the
+ * caller already has the message in memory then it should be supplied.  (Obviously
+ * this mode of operation only works if we're saving a single message.)
  */
-int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
-	int i;
+int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
+				int do_repl_check, struct CtdlMessage *supplied_msg)
+{
+	int i, j, unique;
 	char hold_rm[ROOMNAMELEN];
 	struct cdbdata *cdbfr;
 	int num_msgs;
 	long *msglist;
 	long highest_msg = 0L;
+
+	long msgid = 0;
 	struct CtdlMessage *msg = NULL;
 
-	lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
-		roomname, msgid, flags);
+	long *msgs_to_be_merged = NULL;
+	int num_msgs_to_be_merged = 0;
 
-	strcpy(hold_rm, CC->room.QRname);
+	lprintf(CTDL_DEBUG,
+		"CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d)\n",
+		roomname, num_newmsgs, do_repl_check);
 
-	/* We may need to check to see if this message is real */
-	if (  (flags & SM_VERIFY_GOODNESS)
-	   || (flags & SM_DO_REPL_CHECK)
-	   ) {
-		msg = CtdlFetchMessage(msgid, 1);
-		if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
-	}
-
-	/* Perform replication checks if necessary */
-	if ( (flags & SM_DO_REPL_CHECK) && (msg != NULL) ) {
-
-		if (getroom(&CC->room,
-		   ((roomname != NULL) ? roomname : CC->room.QRname) )
-	   	   != 0) {
-			lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
-			if (msg != NULL) CtdlFreeMessage(msg);
-			return(ERROR + ROOM_NOT_FOUND);
-		}
+	strcpy(hold_rm, CC->room.QRname);
 
-		if (ReplicationChecks(msg) != 0) {
-			getroom(&CC->room, hold_rm);
-			if (msg != NULL) CtdlFreeMessage(msg);
-			lprintf(CTDL_DEBUG,
-				"Did replication, and newer exists\n");
-			return(0);
-		}
-	}
+	/* Sanity checks */
+	if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
+	if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
+	if (num_newmsgs > 1) supplied_msg = NULL;
 
 	/* Now the regular stuff */
 	if (lgetroom(&CC->room,
 	   ((roomname != NULL) ? roomname : CC->room.QRname) )
 	   != 0) {
 		lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
-		if (msg != NULL) CtdlFreeMessage(msg);
 		return(ERROR + ROOM_NOT_FOUND);
 	}
 
+
+	msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
+	num_msgs_to_be_merged = 0;
+
+
 	cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
 	if (cdbfr == NULL) {
 		msglist = NULL;
 		num_msgs = 0;
 	} else {
-		msglist = malloc(cdbfr->len);
-		if (msglist == NULL)
-			lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
+		msglist = (long *) cdbfr->ptr;
+		cdbfr->ptr = NULL;	/* CtdlSaveMsgPointerInRoom() now owns this memory */
 		num_msgs = cdbfr->len / sizeof(long);
-		memcpy(msglist, cdbfr->ptr, cdbfr->len);
 		cdb_free(cdbfr);
 	}
 
 
-	/* Make sure the message doesn't already exist in this room.  It
-	 * is absolutely taboo to have more than one reference to the same
-	 * message in a room.
+	/* Create a list of msgid's which were supplied by the caller, but do
+	 * not already exist in the target room.  It is absolutely taboo to
+	 * have more than one reference to the same message in a room.
 	 */
-	if (num_msgs > 0) for (i=0; i<num_msgs; ++i) {
-		if (msglist[i] == msgid) {
-			lputroom(&CC->room);	/* unlock the room */
-			getroom(&CC->room, hold_rm);
-			if (msg != NULL) CtdlFreeMessage(msg);
-			free(msglist);
-			return(ERROR + ALREADY_EXISTS);
+	for (i=0; i<num_newmsgs; ++i) {
+		unique = 1;
+		if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
+			if (msglist[j] == newmsgidlist[i]) {
+				unique = 0;
+			}
+		}
+		if (unique) {
+			msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
 		}
 	}
 
-	/* Now add the new message */
-	++num_msgs;
-	msglist = realloc(msglist, (num_msgs * sizeof(long)));
+	lprintf(9, "%d unique messages to be merged\n", num_msgs_to_be_merged);
 
+	/*
+	 * Now merge the new messages
+	 */
+	msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
 	if (msglist == NULL) {
 		lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
 	}
-	msglist[num_msgs - 1] = msgid;
+	memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
+	num_msgs += num_msgs_to_be_merged;
 
 	/* Sort the message list, so all the msgid's are in order */
 	num_msgs = sort_msglist(msglist, num_msgs);
@@ -1876,19 +2082,82 @@ int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
 	/* Update the highest-message pointer and unlock the room. */
 	CC->room.QRhighest = highest_msg;
 	lputroom(&CC->room);
+
+	/* Perform replication checks if necessary */
+	if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
+		lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
+
+		for (i=0; i<num_msgs_to_be_merged; ++i) {
+			msgid = msgs_to_be_merged[i];
+	
+			if (supplied_msg != NULL) {
+				msg = supplied_msg;
+			}
+			else {
+				msg = CtdlFetchMessage(msgid, 0);
+			}
+	
+			if (msg != NULL) {
+				ReplicationChecks(msg);
+		
+				/* If the message has an Exclusive ID, index that... */
+				if (msg->cm_fields['E'] != NULL) {
+					index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
+				}
+
+				/* Free up the memory we may have allocated */
+				if (msg != supplied_msg) {
+					CtdlFreeMessage(msg);
+				}
+			}
+	
+		}
+	}
+
+	else {
+		lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
+	}
+
+	/* Submit this room for net processing */
+	network_queue_room(&CC->room, NULL);
+
+#ifdef HAVE_LIBSIEVE
+	/* If this is someone's inbox, submit the room for sieve processing */
+	if (!strcasecmp(&CC->room.QRname[11], MAILROOM)) {
+		sieve_queue_room(&CC->room);
+	}
+#endif /* HAVE_LIBSIEVE */
+
+	/* Go back to the room we were in before we wandered here... */
 	getroom(&CC->room, hold_rm);
 
-	/* Bump the reference count for this message. */
-	if ((flags & SM_DONT_BUMP_REF)==0) {
-		AdjRefCount(msgid, +1);
+	/* Bump the reference count for all messages which were merged */
+	for (i=0; i<num_msgs_to_be_merged; ++i) {
+		AdjRefCount(msgs_to_be_merged[i], +1);
+	}
+
+	/* Free up memory... */
+	if (msgs_to_be_merged != NULL) {
+		free(msgs_to_be_merged);
 	}
 
 	/* Return success. */
-	if (msg != NULL) CtdlFreeMessage(msg);
 	return (0);
 }
 
 
+/*
+ * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
+ * a single message.
+ */
+int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
+			int do_repl_check, struct CtdlMessage *supplied_msg)
+{
+	return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg);
+}
+
+
+
 
 /*
  * Message base operation to save a new message to the message store
@@ -1908,7 +2177,7 @@ long send_message(struct CtdlMessage *msg) {
 
 	/* Get a new message number */
 	newmsgid = get_new_message_number();
-	snprintf(msgidbuf, sizeof msgidbuf, "%ld@%s", newmsgid, config.c_fqdn);
+	snprintf(msgidbuf, sizeof msgidbuf, "%010ld@%s", newmsgid, config.c_fqdn);
 
 	/* Generate an ID if we don't have one already */
 	if (msg->cm_fields['I']==NULL) {
@@ -1975,21 +2244,31 @@ long send_message(struct CtdlMessage *msg) {
 void serialize_message(struct ser_ret *ret,		/* return values */
 			struct CtdlMessage *msg)	/* unserialized msg */
 {
-	size_t wlen;
+	size_t wlen, fieldlen;
 	int i;
 	static char *forder = FORDER;
 
-	if (is_valid_message(msg) == 0) return;		/* self check */
+	/*
+	 * Check for valid message format
+	 */
+	if (is_valid_message(msg) == 0) {
+		lprintf(CTDL_ERR, "serialize_message() aborting due to invalid message\n");
+		ret->len = 0;
+		ret->ser = NULL;
+		return;
+	}
 
 	ret->len = 3;
 	for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
 		ret->len = ret->len +
 			strlen(msg->cm_fields[(int)forder[i]]) + 2;
 
-	lprintf(CTDL_DEBUG, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
 	ret->ser = malloc(ret->len);
 	if (ret->ser == NULL) {
+		lprintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
+			(long)ret->len, strerror(errno));
 		ret->len = 0;
+		ret->ser = NULL;
 		return;
 	}
 
@@ -1999,9 +2278,10 @@ void serialize_message(struct ser_ret *ret,		/* return values */
 	wlen = 3;
 
 	for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
+		fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
 		ret->ser[wlen++] = (char)forder[i];
-		strcpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
-		wlen = wlen + strlen(msg->cm_fields[(int)forder[i]]) + 1;
+		safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
+		wlen = wlen + fieldlen + 1;
 	}
 	if (ret->len != wlen) lprintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
 		(long)ret->len, (long)wlen);
@@ -2012,73 +2292,33 @@ void serialize_message(struct ser_ret *ret,		/* return values */
 
 
 /*
- * Back end for the ReplicationChecks() function
+ * Check to see if any messages already exist in the current room which
+ * carry the same Exclusive ID as this one.  If any are found, delete them.
  */
-void check_repl(long msgnum, void *userdata) {
-	lprintf(CTDL_DEBUG, "check_repl() replacing message %ld\n", msgnum);
-	CtdlDeleteMessages(CC->room.QRname, msgnum, "", 0);
-}
+void ReplicationChecks(struct CtdlMessage *msg) {
+	long old_msgnum = (-1L);
 
+	if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
 
-/*
- * Check to see if any messages already exist which carry the same Exclusive ID
- * as this one.  If any are found, delete them.
- *
- */
-int ReplicationChecks(struct CtdlMessage *msg) {
-	struct CtdlMessage *template;
-	int abort_this = 0;
+	lprintf(CTDL_DEBUG, "Performing replication checks in <%s>\n",
+		CC->room.QRname);
 
 	/* No exclusive id?  Don't do anything. */
-	if (msg->cm_fields['E'] == NULL) return 0;
-	if (strlen(msg->cm_fields['E']) == 0) return 0;
-	lprintf(CTDL_DEBUG, "Exclusive ID: <%s>\n", msg->cm_fields['E']);
-
-	template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
-	memset(template, 0, sizeof(struct CtdlMessage));
-	template->cm_fields['E'] = strdup(msg->cm_fields['E']);
-
-	CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
-
-	CtdlFreeMessage(template);
-	lprintf(CTDL_DEBUG, "ReplicationChecks() returning %d\n", abort_this);
-	return(abort_this);
-}
-
-
-
-/* 
- * Turn an arbitrary RFC822 address into a struct vCard for possible
- * inclusion into an address book.
- */
-struct vCard *vcard_new_from_rfc822_addr(char *addr) {
-	struct vCard *v;
-	char user[256], node[256], name[256], email[256], n[256], uid[256];
-	int i;
+	if (msg == NULL) return;
+	if (msg->cm_fields['E'] == NULL) return;
+	if (strlen(msg->cm_fields['E']) == 0) return;
+	/*lprintf(CTDL_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
+		msg->cm_fields['E'], CC->room.QRname);*/
 
-	v = vcard_new();
-	if (v == NULL) return(NULL);
-
-	process_rfc822_addr(addr, user, node, name);
-	vcard_set_prop(v, "fn", name, 0);
-
-	vcard_fn_to_n(n, name, sizeof n);
-	vcard_set_prop(v, "n", n, 0);
-
-	snprintf(email, sizeof email, "%s@%s", user, node);
-	vcard_set_prop(v, "email;internet", email, 0);
-
-	snprintf(uid, sizeof uid, "collected: %s %s@%s", name, user, node);
-	for (i=0; i<strlen(uid); ++i) {
-		if (isspace(uid[i])) uid[i] = '_';
-		uid[i] = tolower(uid[i]);
+	old_msgnum = locate_message_by_euid(msg->cm_fields['E'], &CC->room);
+	if (old_msgnum > 0L) {
+		lprintf(CTDL_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
+		CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "", 0);
 	}
-	vcard_set_prop(v, "UID", uid, 0);
-
-	return(v);
 }
 
 
+
 /*
  * Save a message to disk and submit it into the delivery system.
  */
@@ -2096,19 +2336,18 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	long newmsgid;
 	char *mptr = NULL;
 	struct ctdluser userbuf;
-	int a, i, j;
+	int a, i;
 	struct MetaData smi;
 	FILE *network_fp = NULL;
 	static int seqnum = 1;
 	struct CtdlMessage *imsg = NULL;
-	struct CtdlMessage *vmsg = NULL;
-	long vmsgnum = (-1L);
-	char *ser = NULL;
-	struct vCard *v = NULL;
 	char *instr;
 	struct ser_ret smr;
 	char *hold_R, *hold_D;
 	char *collected_addresses = NULL;
+	struct addresses_to_be_filed *aptr = NULL;
+	char *saved_rfc822_version = NULL;
+	int qualified_for_journaling = 0;
 
 	lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
 	if (is_valid_message(msg) == 0) return(-1);	/* self check */
@@ -2117,7 +2356,6 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	 * giving it one, right now.
 	 */
 	if (msg->cm_fields['T'] == NULL) {
-		lprintf(CTDL_DEBUG, "Generating timestamp\n");
 		snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
 		msg->cm_fields['T'] = strdup(generated_timestamp);
 	}
@@ -2125,7 +2363,6 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	/* If this message has no path, we generate one.
 	 */
 	if (msg->cm_fields['P'] == NULL) {
-		lprintf(CTDL_DEBUG, "Generating path\n");
 		if (msg->cm_fields['A'] != NULL) {
 			msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
 			for (a=0; a<strlen(msg->cm_fields['P']); ++a) {
@@ -2147,7 +2384,6 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	}
 
 	/* Learn about what's inside, because it's what's inside that counts */
-	lprintf(CTDL_DEBUG, "Learning what's inside\n");
 	if (msg->cm_fields['M'] == NULL) {
 		lprintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
 		return(-2);
@@ -2178,8 +2414,7 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	}
 
 	/* Goto the correct room */
-	lprintf(CTDL_DEBUG, "Selected room %s\n",
-		(recps) ? CC->room.QRname : SENTITEMS);
+	lprintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CC->room.QRname : SENTITEMS);
 	strcpy(hold_rm, CC->room.QRname);
 	strcpy(actual_rm, CC->room.QRname);
 	if (recps != NULL) {
@@ -2187,12 +2422,11 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	}
 
 	/* If the user is a twit, move to the twit room for posting */
-	lprintf(CTDL_DEBUG, "Handling twit stuff: %s\n",
-			(CC->user.axlevel == 2) ? config.c_twitroom : "OK");
 	if (TWITDETECT) {
 		if (CC->user.axlevel == 2) {
 			strcpy(hold_rm, actual_rm);
 			strcpy(actual_rm, config.c_twitroom);
+			lprintf(CTDL_DEBUG, "Diverting to twit room\n");
 		}
 	}
 
@@ -2218,9 +2452,13 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
 	if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
 
-	/* If this message has an Exclusive ID, perform replication checks */
-	lprintf(CTDL_DEBUG, "Performing replication checks\n");
-	if (ReplicationChecks(msg) > 0) return(-4);
+	/*
+	 * If this message has an Exclusive ID, and the room is replication
+	 * checking enabled, then do replication checks.
+	 */
+	if (DoesThisRoomNeedEuidIndexing(&CC->room)) {
+		ReplicationChecks(msg);
+	}
 
 	/* Save it to disk */
 	lprintf(CTDL_DEBUG, "Saving to disk\n");
@@ -2238,13 +2476,16 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	safestrncpy(smi.meta_content_type, content_type,
 			sizeof smi.meta_content_type);
 
-	/* As part of the new metadata record, measure how
-	 * big this message will be when displayed as RFC822.
-	 * Both POP and IMAP use this, and it's best to just take the hit now
-	 * instead of having to potentially measure thousands of messages when
-	 * a mailbox is opened later.
+	/*
+	 * Measure how big this message will be when rendered as RFC822.
+	 * We do this for two reasons:
+	 * 1. We need the RFC822 length for the new metadata record, so the
+	 *    POP and IMAP services don't have to calculate message lengths
+	 *    while the user is waiting (multiplied by potentially hundreds
+	 *    or thousands of messages).
+	 * 2. If journaling is enabled, we will need an RFC822 version of the
+	 *    message to attach to the journalized copy.
 	 */
-
 	if (CC->redirect_buffer != NULL) {
 		lprintf(CTDL_ALERT, "CC->redirect_buffer is not NULL during message submission!\n");
 		abort();
@@ -2252,9 +2493,9 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	CC->redirect_buffer = malloc(SIZ);
 	CC->redirect_len = 0;
 	CC->redirect_alloc = SIZ;
-	CtdlOutputPreLoadedMsg(msg, 0L, MT_RFC822, HEADERS_ALL, 0, 1);
+	CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1);
 	smi.meta_rfc822_length = CC->redirect_len;
-	free(CC->redirect_buffer);
+	saved_rfc822_version = CC->redirect_buffer;
 	CC->redirect_buffer = NULL;
 	CC->redirect_len = 0;
 	CC->redirect_alloc = 0;
@@ -2269,17 +2510,16 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 	 * is no local sender; it would otherwise go to the Trashcan).
 	 */
 	if ((!CC->internal_pgm) || (recps == NULL)) {
-		if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
+		if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
 			lprintf(CTDL_ERR, "ERROR saving message pointer!\n");
-			CtdlSaveMsgPointerInRoom(config.c_aideroom,
-							newmsgid, 0);
+			CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
 		}
 	}
 
 	/* For internet mail, drop a copy in the outbound queue room */
 	if (recps != NULL)
 	 if (recps->num_internet > 0) {
-		CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0);
+		CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
 	}
 
 	/* If other rooms are specified, drop them there too. */
@@ -2289,7 +2529,7 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 		extract_token(recipient, recps->recp_room, i,
 					'|', sizeof recipient);
 		lprintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
-		CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
+		CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
 	}
 
 	/* Bump this user's messages posted counter. */
@@ -2311,13 +2551,13 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 		if (getuser(&userbuf, recipient) == 0) {
 			MailboxName(actual_rm, sizeof actual_rm,
 					&userbuf, MAILROOM);
-			CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
+			CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
 			BumpNewMailCounter(userbuf.usernum);
 		}
 		else {
 			lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
 			CtdlSaveMsgPointerInRoom(config.c_aideroom,
-							newmsgid, 0);
+				newmsgid, 0, msg);
 		}
 	}
 
@@ -2349,12 +2589,8 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 		serialize_message(&smr, msg);
 		if (smr.len > 0) {
 			snprintf(submit_filename, sizeof submit_filename,
-#ifndef HAVE_SPOOL_DIR
-					 "."
-#else
-					 SPOOL_DIR
-#endif
-					 "/network/spoolin/netmail.%04lx.%04x.%04x",
+					 "%s/netmail.%04lx.%04x.%04x",
+					 ctdl_netin_dir,
 					 (long) getpid(), CC->cs_pid, ++seqnum);
 			network_fp = fopen(submit_filename, "wb+");
 			if (network_fp != NULL) {
@@ -2394,7 +2630,8 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 
 	  	for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
 			size_t tmp = strlen(instr);
-			extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
+			extract_token(recipient, recps->recp_internet,
+				i, '|', sizeof recipient);
 			snprintf(&instr[tmp], SIZ * 2 - tmp,
 				 "remote|%s|0||\n", recipient);
 		}
@@ -2405,6 +2642,7 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 		imsg->cm_anon_type = MES_NORMAL;
 		imsg->cm_format_type = FMT_RFC822;
 		imsg->cm_fields['A'] = strdup("Citadel");
+		imsg->cm_fields['J'] = strdup("do not journal");
 		imsg->cm_fields['M'] = instr;
 		CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
 		CtdlFreeMessage(imsg);
@@ -2412,69 +2650,59 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 
 	/*
 	 * Any addresses to harvest for someone's address book?
-	 * (Don't do this if this is not a message with recipients, otherwise we will
-	 * send this function into infinite recursion!!!!!)
 	 */
-	if (recps != NULL) {
+	if ( (CC->logged_in) && (recps != NULL) ) {
 		collected_addresses = harvest_collected_addresses(msg);
 	}
 
 	if (collected_addresses != NULL) {
-		for (i=0; i<num_tokens(collected_addresses, ','); ++i) {
-
-			/* Make a vCard out of each address */
-			extract_token(recipient, collected_addresses, i, ',', sizeof recipient);
-			striplt(recipient);
-			v = vcard_new_from_rfc822_addr(recipient);
-			if (v != NULL) {
-				vmsg = malloc(sizeof(struct CtdlMessage));
-				memset(vmsg, 0, sizeof(struct CtdlMessage));
-				vmsg->cm_magic = CTDLMESSAGE_MAGIC;
-				vmsg->cm_anon_type = MES_NORMAL;
-				vmsg->cm_format_type = FMT_RFC822;
-				vmsg->cm_fields['A'] = strdup("Citadel");
-				vmsg->cm_fields['E'] =  strdup(vcard_get_prop(v, "UID", 0, 0, 0));
-				ser = vcard_serialize(v);
-				if (ser != NULL) {
-					vmsg->cm_fields['M'] = malloc(strlen(ser) + 1024);
-					sprintf(vmsg->cm_fields['M'],
-						"Content-type: text/x-vcard"
-						"\r\n\r\n%s\r\n", ser);
-					free(ser);
-				}
-				vcard_free(v);
-
-				if (recps->num_local > 0) {
-					for (j=0; j<num_tokens(recps->recp_local, '|'); ++j) {
-						extract_token(recipient, recps->recp_local, j,
-							'|', sizeof recipient);
-						lprintf(CTDL_DEBUG, "Adding contact for <%s>\n", recipient);
-						if (getuser(&userbuf, recipient) == 0) {
-							MailboxName(actual_rm, sizeof actual_rm,
-								&userbuf, USERCONTACTSROOM);
-
-							if (vmsgnum < 0L) {
-								vmsgnum = CtdlSubmitMsg(vmsg,
-											NULL, actual_rm);
-							}
-							else {
-								CtdlSaveMsgPointerInRoom(actual_rm,
-												vmsgnum, 0);
-							}
+		begin_critical_section(S_ATBF);
+		aptr = (struct addresses_to_be_filed *)
+			malloc(sizeof(struct addresses_to_be_filed));
+		aptr->next = atbf;
+		MailboxName(actual_rm, sizeof actual_rm,
+			&CC->user, USERCONTACTSROOM);
+		aptr->roomname = strdup(actual_rm);
+		aptr->collected_addresses = collected_addresses;
+		atbf = aptr;
+		end_critical_section(S_ATBF);
+	}
 
-						}
-					}
-				}
-				CtdlFreeMessage(vmsg);
-			}
+	/*
+	 * Determine whether this message qualifies for journaling.
+	 */
+	if (msg->cm_fields['J'] != NULL) {
+		qualified_for_journaling = 0;
+	}
+	else {
+		if (recps == NULL) {
+			qualified_for_journaling = config.c_journal_pubmsgs;
+		}
+		else if (recps->num_local + recps->num_ignet + recps->num_internet > 0) {
+			qualified_for_journaling = config.c_journal_email;
+		}
+		else {
+			qualified_for_journaling = config.c_journal_pubmsgs;
 		}
-		free(collected_addresses);
 	}
-	return(newmsgid);
-}
-
 
+	/*
+	 * Do we have to perform journaling?  If so, hand off the saved
+	 * RFC822 version will be handed off to the journaler for background
+	 * submit.  Otherwise, we have to free the memory ourselves.
+	 */
+	if (saved_rfc822_version != NULL) {
+		if (qualified_for_journaling) {
+			JournalBackgroundSubmit(msg, saved_rfc822_version, recps);
+		}
+		else {
+			free(saved_rfc822_version);
+		}
+	}
 
+	/* Done. */
+	return(newmsgid);
+}
 
 
 
@@ -2483,7 +2711,7 @@ long CtdlSubmitMsg(struct CtdlMessage *msg,	/* message to save */
 /*
  * Convenience function for generating small administrative messages.
  */
-void quickie_message(char *from, char *to, char *room, char *text, 
+void quickie_message(char *from, char *fromaddr, char *to, char *room, char *text, 
 			int format_type, char *subject)
 {
 	struct CtdlMessage *msg;
@@ -2494,7 +2722,21 @@ void quickie_message(char *from, char *to, char *room, char *text,
 	msg->cm_magic = CTDLMESSAGE_MAGIC;
 	msg->cm_anon_type = MES_NORMAL;
 	msg->cm_format_type = format_type;
-	msg->cm_fields['A'] = strdup(from);
+
+	if (from != NULL) {
+		msg->cm_fields['A'] = strdup(from);
+	}
+	else if (fromaddr != NULL) {
+		msg->cm_fields['A'] = strdup(fromaddr);
+		if (strchr(msg->cm_fields['A'], '@')) {
+			*strchr(msg->cm_fields['A'], '@') = 0;
+		}
+	}
+	else {
+		msg->cm_fields['A'] = strdup("Citadel");
+	}
+
+	if (fromaddr != NULL) msg->cm_fields['F'] = strdup(fromaddr);
 	if (room != NULL) msg->cm_fields['O'] = strdup(room);
 	msg->cm_fields['N'] = strdup(NODENAME);
 	if (to != NULL) {
@@ -2530,6 +2772,7 @@ char *CtdlReadMessageBody(char *terminator,	/* token signalling EOT */
 	char *m;
 	int flushing = 0;
 	int finished = 0;
+	int dotdot = 0;
 
 	if (exist == NULL) {
 		m = malloc(4096);
@@ -2547,6 +2790,11 @@ char *CtdlReadMessageBody(char *terminator,	/* token signalling EOT */
 		}
 	}
 
+	/* Do we need to change leading ".." to "." for SMTP escaping? */
+	if (!strcmp(terminator, ".")) {
+		dotdot = 1;
+	}
+
 	/* flush the input if we have nowhere to store it */
 	if (m == NULL) {
 		flushing = 1;
@@ -2563,6 +2811,13 @@ char *CtdlReadMessageBody(char *terminator,	/* token signalling EOT */
 			strcat(buf, "\n");
 		}
 
+		/* Unescape SMTP-style input of two dots at the beginning of the line */
+		if (dotdot) {
+			if (!strncmp(buf, "..", 2)) {
+				strcpy(buf, &buf[1]);
+			}
+		}
+
 		if ( (!flushing) && (!finished) ) {
 			/* Measure the line */
 			linelen = strlen(buf);
@@ -2615,6 +2870,7 @@ struct CtdlMessage *CtdlMakeMessage(
 	int format_type,		/* variformat, plain text, MIME... */
 	char *fake_name,		/* who we're masquerading as */
 	char *subject,			/* Subject (optional) */
+	char *supplied_euid,		/* ...or NULL if this is irrelevant */
 	char *preformatted_text		/* ...or NULL to read text from client */
 ) {
 	char dest_node[SIZ];
@@ -2675,6 +2931,10 @@ struct CtdlMessage *CtdlMakeMessage(
 		}
 	}
 
+	if (supplied_euid != NULL) {
+		msg->cm_fields['E'] = strdup(supplied_euid);
+	}
+
 	if (preformatted_text != NULL) {
 		msg->cm_fields['M'] = preformatted_text;
 	}
@@ -2749,20 +3009,23 @@ int CtdlCheckInternetMailPermission(struct ctdluser *who) {
 /*
  * Validate recipients, count delivery types and errors, and handle aliasing
  * FIXME check for dupes!!!!!
- * Returns 0 if all addresses are ok, -1 if no addresses were specified,
- * or the number of addresses found invalid.
+ * Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses 
+ * were specified, or the number of addresses found invalid.
+ * caller needs to free the result.
  */
-struct recptypes *validate_recipients(char *recipients) {
+struct recptypes *validate_recipients(char *supplied_recipients) {
 	struct recptypes *ret;
-	char this_recp[SIZ];
-	char this_recp_cooked[SIZ];
+	char recipients[SIZ];
+	char this_recp[256];
+	char this_recp_cooked[256];
 	char append[SIZ];
-	int num_recps;
+	int num_recps = 0;
 	int i, j;
 	int mailtype;
 	int invalid;
 	struct ctdluser tempUS;
 	struct ctdlroom tempQR;
+	int in_quotes = 0;
 
 	/* Initialize */
 	ret = (struct recptypes *) malloc(sizeof(struct recptypes));
@@ -2775,28 +3038,42 @@ struct recptypes *validate_recipients(char *recipients) {
 	ret->num_error = 0;
 	ret->num_room = 0;
 
-	if (recipients == NULL) {
-		num_recps = 0;
-	}
-	else if (strlen(recipients) == 0) {
-		num_recps = 0;
+	if (supplied_recipients == NULL) {
+		strcpy(recipients, "");
 	}
 	else {
-		/* Change all valid separator characters to commas */
-		for (i=0; i<strlen(recipients); ++i) {
-			if ((recipients[i] == ';') || (recipients[i] == '|')) {
-				recipients[i] = ',';
-			}
-		}
+		safestrncpy(recipients, supplied_recipients, sizeof recipients);
+	}
 
-		/* Count 'em up */
-		num_recps = num_tokens(recipients, ',');
+	/* Change all valid separator characters to commas */
+	for (i=0; i<strlen(recipients); ++i) {
+		if ((recipients[i] == ';') || (recipients[i] == '|')) {
+			recipients[i] = ',';
+		}
 	}
 
-	if (num_recps > 0) for (i=0; i<num_recps; ++i) {
-		extract_token(this_recp, recipients, i, ',', sizeof this_recp);
+	/* Now start extracting recipients... */
+
+	while (strlen(recipients) > 0) {
+
+		for (i=0; i<=strlen(recipients); ++i) {
+			if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
+			if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
+				safestrncpy(this_recp, recipients, i+1);
+				this_recp[i] = 0;
+				if (recipients[i] == ',') {
+					strcpy(recipients, &recipients[i+1]);
+				}
+				else {
+					strcpy(recipients, "");
+				}
+				break;
+			}
+		}
+
 		striplt(this_recp);
-		lprintf(CTDL_DEBUG, "Evaluating recipient #%d <%s>\n", i, this_recp);
+		lprintf(CTDL_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
+		++num_recps;
 		mailtype = alias(this_recp);
 		mailtype = alias(this_recp);
 		mailtype = alias(this_recp);
@@ -2934,6 +3211,7 @@ void cmd_ent0(char *entargs)
 	char recp[SIZ];
 	char cc[SIZ];
 	char bcc[SIZ];
+	char supplied_euid[128];
 	char masquerade_as[SIZ];
 	int anon_flag = 0;
 	int format_type = 0;
@@ -2960,6 +3238,15 @@ void cmd_ent0(char *entargs)
 	do_confirm = extract_int(entargs, 6);
 	extract_token(cc, entargs, 7, '|', sizeof cc);
 	extract_token(bcc, entargs, 8, '|', sizeof bcc);
+	switch(CC->room.QRdefaultview) {
+		case VIEW_NOTES:
+		case VIEW_WIKI:
+			extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
+			break;
+		default:
+			supplied_euid[0] = 0;
+			break;
+	}
 
 	/* first check to make sure the request is valid. */
 
@@ -3120,7 +3407,9 @@ void cmd_ent0(char *entargs)
 
 	msg = CtdlMakeMessage(&CC->user, recp, cc,
 		CC->room.QRname, anonymous, format_type,
-		masquerade_as, subject, NULL);
+		masquerade_as, subject,
+		((strlen(supplied_euid) > 0) ? supplied_euid : NULL),
+		NULL);
 
 	/* Put together one big recipients struct containing to/cc/bcc all in
 	 * one.  This is for the envelope.
@@ -3182,7 +3471,8 @@ void cmd_ent0(char *entargs)
  * (returns the actual number of messages deleted)
  */
 int CtdlDeleteMessages(char *room_name,		/* which room */
-			long dmsgnum,		/* or "0" for any */
+			long *dmsgnums,		/* array of msg numbers to be deleted */
+			int num_dmsgnums,	/* number of msgs to be deleted, or 0 for "any" */
 			char *content_type,	/* or "" for any */
 			int deferred		/* let TDAP sweep it later */
 )
@@ -3193,13 +3483,13 @@ int CtdlDeleteMessages(char *room_name,		/* which room */
 	long *msglist = NULL;
 	long *dellist = NULL;
 	int num_msgs = 0;
-	int i;
+	int i, j;
 	int num_deleted = 0;
 	int delete_this;
 	struct MetaData smi;
 
-	lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %ld, %s, %d)\n",
-		room_name, dmsgnum, content_type, deferred);
+	lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s, %d)\n",
+		room_name, num_dmsgnums, content_type, deferred);
 
 	/* get room record, obtaining a lock... */
 	if (lgetroom(&qrbuf, room_name) != 0) {
@@ -3210,9 +3500,9 @@ int CtdlDeleteMessages(char *room_name,		/* which room */
 	cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
 
 	if (cdbfr != NULL) {
-		msglist = malloc(cdbfr->len);
 		dellist = malloc(cdbfr->len);
-		memcpy(msglist, cdbfr->ptr, cdbfr->len);
+		msglist = (long *) cdbfr->ptr;
+		cdbfr->ptr = NULL;	/* CtdlDeleteMessages() now owns this memory */
 		num_msgs = cdbfr->len / sizeof(long);
 		cdb_free(cdbfr);
 	}
@@ -3222,9 +3512,20 @@ int CtdlDeleteMessages(char *room_name,		/* which room */
 
 			/* Set/clear a bit for each criterion */
 
-			if ((dmsgnum == 0L) || (msglist[i] == dmsgnum)) {
+			/* 0 messages in the list or a null list means that we are
+			 * interested in deleting any messages which meet the other criteria.
+			 */
+			if ((num_dmsgnums == 0) || (dmsgnums == NULL)) {
 				delete_this |= 0x01;
 			}
+			else {
+				for (j=0; j<num_dmsgnums; ++j) {
+					if (msglist[i] == dmsgnums[j]) {
+						delete_this |= 0x01;
+					}
+				}
+			}
+
 			if (strlen(content_type) == 0) {
 				delete_this |= 0x02;
 			} else {
@@ -3257,11 +3558,11 @@ int CtdlDeleteMessages(char *room_name,		/* which room */
 	 * DELETED_MSGS_ROOM.  This will cause the reference count to remain
 	 * at least 1, which will save the user from having to synchronously
 	 * wait for various disk-intensive operations to complete.
+	 *
+	 * Slick -- we now use the new bulk API for moving messages.
 	 */
 	if ( (deferred) && (num_deleted) ) {
-		for (i=0; i<num_deleted; ++i) {
-			CtdlCopyMsgToRoom(dellist[i], DELETED_MSGS_ROOM);
-		}
+		CtdlCopyMsgsToRoom(dellist, num_deleted, DELETED_MSGS_ROOM);
 	}
 
 	/* Go through the messages we pulled out of the index, and decrement
@@ -3306,37 +3607,56 @@ int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
 /*
  * Delete message from current room
  */
-void cmd_dele(char *delstr)
+void cmd_dele(char *args)
 {
-	long delnum;
 	int num_deleted;
+	int i;
+	char msgset[SIZ];
+	char msgtok[32];
+	long *msgs;
+	int num_msgs = 0;
+
+	extract_token(msgset, args, 0, '|', sizeof msgset);
+	num_msgs = num_tokens(msgset, ',');
+	if (num_msgs < 1) {
+		cprintf("%d Nothing to do.\n", CIT_OK);
+		return;
+	}
 
 	if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
 		cprintf("%d Higher access required.\n",
 			ERROR + HIGHER_ACCESS_REQUIRED);
 		return;
 	}
-	delnum = extract_long(delstr, 0);
 
-	num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "", 1);
+	/*
+	 * Build our message set to be moved/copied
+	 */
+	msgs = malloc(num_msgs * sizeof(long));
+	for (i=0; i<num_msgs; ++i) {
+		extract_token(msgtok, msgset, i, ',', sizeof msgtok);
+		msgs[i] = atol(msgtok);
+	}
+
+	num_deleted = CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "", 1);
+	free(msgs);
 
 	if (num_deleted) {
 		cprintf("%d %d message%s deleted.\n", CIT_OK,
 			num_deleted, ((num_deleted != 1) ? "s" : ""));
 	} else {
-		cprintf("%d Message %ld not found.\n", ERROR + MESSAGE_NOT_FOUND, delnum);
+		cprintf("%d Message not found.\n", ERROR + MESSAGE_NOT_FOUND);
 	}
 }
 
 
 /*
- * Back end API function for moves and deletes
+ * Back end API function for moves and deletes (multiple messages)
  */
-int CtdlCopyMsgToRoom(long msgnum, char *dest) {
+int CtdlCopyMsgsToRoom(long *msgnums, int num_msgs, char *dest) {
 	int err;
 
-	err = CtdlSaveMsgPointerInRoom(dest, msgnum,
-		(SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
+	err = CtdlSaveMsgPointersInRoom(dest, msgnums, num_msgs, 1, NULL);
 	if (err != 0) return(err);
 
 	return(0);
@@ -3344,21 +3664,34 @@ int CtdlCopyMsgToRoom(long msgnum, char *dest) {
 
 
 
+
 /*
  * move or copy a message to another room
  */
 void cmd_move(char *args)
 {
-	long num;
+	char msgset[SIZ];
+	char msgtok[32];
+	long *msgs;
+	int num_msgs = 0;
+
 	char targ[ROOMNAMELEN];
 	struct ctdlroom qtemp;
 	int err;
 	int is_copy = 0;
 	int ra;
 	int permit = 0;
+	int i;
+
+	extract_token(msgset, args, 0, '|', sizeof msgset);
+	num_msgs = num_tokens(msgset, ',');
+	if (num_msgs < 1) {
+		cprintf("%d Nothing to do.\n", CIT_OK);
+		return;
+	}
 
-	num = extract_long(args, 0);
 	extract_token(targ, args, 1, '|', sizeof targ);
+	convert_room_name_macros(targ, sizeof targ);
 	targ[ROOMNAMELEN - 1] = 0;
 	is_copy = extract_int(args, 2);
 
@@ -3400,10 +3733,23 @@ void cmd_move(char *args)
 		return;
 	}
 
-	err = CtdlCopyMsgToRoom(num, targ);
+	/*
+	 * Build our message set to be moved/copied
+	 */
+	msgs = malloc(num_msgs * sizeof(long));
+	for (i=0; i<num_msgs; ++i) {
+		extract_token(msgtok, msgset, i, ',', sizeof msgtok);
+		msgs[i] = atol(msgtok);
+	}
+
+	/*
+	 * Do the copy
+	 */
+	err = CtdlCopyMsgsToRoom(msgs, num_msgs, targ);
 	if (err != 0) {
-		cprintf("%d Cannot store message in %s: error %d\n",
+		cprintf("%d Cannot store message(s) in %s: error %d\n",
 			err, targ, err);
+		free(msgs);
 		return;
 	}
 
@@ -3411,10 +3757,11 @@ void cmd_move(char *args)
 	 * if this is a 'move' rather than a 'copy' operation.
 	 */
 	if (is_copy == 0) {
-		CtdlDeleteMessages(CC->room.QRname, num, "", 0);
+		CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "", 0);
 	}
+	free(msgs);
 
-	cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
+	cprintf("%d Message(s) %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
 }
 
 
@@ -3535,12 +3882,12 @@ void CtdlWriteObject(char *req_room,		/* Room to stuff it in */
 	char *encoded_message = NULL;
 	off_t raw_length = 0;
 
-	if (is_mailbox != NULL)
+	if (is_mailbox != NULL) {
 		MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
-	else
+	}
+	else {
 		safestrncpy(roomname, req_room, sizeof(roomname));
-	lprintf(CTDL_DEBUG, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
-
+	}
 
 	fp = fopen(tempfilename, "rb");
 	if (fp == NULL) {
@@ -3621,7 +3968,7 @@ void CtdlWriteObject(char *req_room,		/* Room to stuff it in */
 	 */
 	if (is_unique) {
 		lprintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
-			CtdlDeleteMessages(roomname, 0L, content_type, 0)
+			CtdlDeleteMessages(roomname, NULL, 0, content_type, 0)
 		);
 	}
 	/* Now write the data */
@@ -3656,7 +4003,7 @@ char *CtdlGetSysConfig(char *sysconfname) {
 	/* We want the last (and probably only) config in this room */
 	begin_critical_section(S_CONFIG);
 	config_msgnum = (-1L);
-	CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
+	CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
 		CtdlGetSysConfigBackend, NULL);
 	msgnum = config_msgnum;
 	end_critical_section(S_CONFIG);
@@ -3689,7 +4036,7 @@ void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
 	char temp[PATH_MAX];
 	FILE *fp;
 
-	strcpy(temp, tmpnam(NULL));
+	CtdlMakeTempFileName(temp, sizeof temp);
 
 	fp = fopen(temp, "w");
 	if (fp == NULL) return;