X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Finternet_addressing.c;h=72b52b6808e20b17f35986ffe7743986f05aa2c3;hb=e8de1b7b553cc11ae7f0a84dd02f3abc85bea761;hp=99b22d786ff7f73ec06a46cb2926c3a17b65d170;hpb=c4609169aa7baf208848e72c16d33a3f892353b8;p=citadel.git

diff --git a/citadel/internet_addressing.c b/citadel/internet_addressing.c
index 99b22d786..72b52b680 100644
--- a/citadel/internet_addressing.c
+++ b/citadel/internet_addressing.c
@@ -2,7 +2,7 @@
  * This file contains functions which handle the mapping of Internet addresses
  * to users on the Citadel system.
  *
- * Copyright (c) 1987-2015 by the citadel.org team
+ * Copyright (c) 1987-2021 by the citadel.org team
  *
  * This program is open source software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3.
@@ -13,7 +13,6 @@
  * GNU General Public License for more details.
  */
 
-
 #include "sysdep.h"
 #include <stdlib.h>
 #include <unistd.h>
@@ -45,8 +44,8 @@
 #ifdef HAVE_ICONV
 #include <iconv.h>
 
+/* This is the non-define version in case it is needed for debugging */
 #if 0
-/* This is the non-define version in case of s.b. needing to debug */
 inline void FindNextEnd (char *bptr, char *end)
 {
 	/* Find the next ?Q? */
@@ -83,27 +82,27 @@ void utf8ify_rfc822_string(char *buf) {
 	char encoding[16];
 	char istr[1024];
 	iconv_t ic = (iconv_t)(-1) ;
-	char *ibuf;			/**< Buffer of characters to be converted */
-	char *obuf;			/**< Buffer for converted characters */
-	size_t ibuflen;			/**< Length of input buffer */
-	size_t obuflen;			/**< Length of output buffer */
-	char *isav;			/**< Saved pointer to input buffer */
-	char *osav;			/**< Saved pointer to output buffer */
+	char *ibuf;			// Buffer of characters to be converted
+	char *obuf;			// Buffer for converted characters
+	size_t ibuflen;			// Length of input buffer
+	size_t obuflen;			// Length of output buffer
+	char *isav;			// Saved pointer to input buffer
+	char *osav;			// Saved pointer to output buffer
 	int passes = 0;
 	int i, len, delta;
 	int illegal_non_rfc2047_encoding = 0;
 
 	/* Sometimes, badly formed messages contain strings which were simply
-	 *  written out directly in some foreign character set instead of
-	 *  using RFC2047 encoding.  This is illegal but we will attempt to
-	 *  handle it anyway by converting from a user-specified default
-	 *  charset to UTF-8 if we see any nonprintable characters.
+	 * written out directly in some foreign character set instead of
+	 * using RFC2047 encoding.  This is illegal but we will attempt to
+	 * handle it anyway by converting from a user-specified default
+	 * charset to UTF-8 if we see any nonprintable characters.
 	 */
 	len = strlen(buf);
 	for (i=0; i<len; ++i) {
 		if ((buf[i] < 32) || (buf[i] > 126)) {
 			illegal_non_rfc2047_encoding = 1;
-			i = len; ///< take a shortcut, it won't be more than one.
+			i = len;	// take a shortcut, it won't be more than one.
 		}
 	}
 	if (illegal_non_rfc2047_encoding) {
@@ -135,8 +134,7 @@ void utf8ify_rfc822_string(char *buf) {
 	if (start != NULL) 
 		FindNextEnd (start, end);
 
-	while ((start != NULL) && (end != NULL))
-	{
+	while ((start != NULL) && (end != NULL)) {
 		next = strstr(end, "=?");
 		if (next != NULL)
 			FindNextEnd(next, nextend);
@@ -144,9 +142,7 @@ void utf8ify_rfc822_string(char *buf) {
 			next = NULL;
 
 		/* did we find two partitions */
-		if ((next != NULL) && 
-		    ((next - end) > 2))
-		{
+		if ((next != NULL) && ((next - end) > 2)) {
 			ptr = end + 2;
 			while ((ptr < next) && 
 			       (isspace(*ptr) ||
@@ -176,38 +172,33 @@ void utf8ify_rfc822_string(char *buf) {
 		end = nextend;
 	}
 
-	/* Now we handle foreign character sets properly encoded
-	 * in RFC2047 format.
-	 */
+	// Now we handle foreign character sets properly encoded in RFC2047 format.
 	start = strstr(buf, "=?");
 	FindNextEnd((start != NULL)? start : buf, end);
-	while (start != NULL && end != NULL && end > start)
-	{
+	while (start != NULL && end != NULL && end > start) {
 		extract_token(charset, start, 1, '?', sizeof charset);
 		extract_token(encoding, start, 2, '?', sizeof encoding);
 		extract_token(istr, start, 3, '?', sizeof istr);
 
 		ibuf = malloc(1024);
 		isav = ibuf;
-		if (!strcasecmp(encoding, "B")) {	/**< base64 */
+		if (!strcasecmp(encoding, "B")) {	// base64
 			ibuflen = CtdlDecodeBase64(ibuf, istr, strlen(istr));
 		}
-		else if (!strcasecmp(encoding, "Q")) {	/**< quoted-printable */
+		else if (!strcasecmp(encoding, "Q")) {	// quoted-printable
 			size_t len;
 			unsigned long pos;
 			
 			len = strlen(istr);
 			pos = 0;
-			while (pos < len)
-			{
+			while (pos < len) {
 				if (istr[pos] == '_') istr[pos] = ' ';
 				pos++;
 			}
-
 			ibuflen = CtdlDecodeQuotedPrintable(ibuf, istr, len);
 		}
 		else {
-			strcpy(ibuf, istr);		/**< unknown encoding */
+			strcpy(ibuf, istr);		// unknown encoding
 			ibuflen = strlen(istr);
 		}
 
@@ -269,15 +260,7 @@ inline void utf8ify_rfc822_string(char *a){};
 #endif
 
 
-
-struct trynamebuf {
-	char buffer1[SIZ];
-	char buffer2[SIZ];
-};
-
 char *inetcfg = NULL;
-struct spamstrings_t *spamstrings = NULL;
-
 
 /*
  * Return nonzero if the supplied name is an alias for this host.
@@ -289,12 +272,12 @@ int CtdlHostAlias(char *fqdn) {
 	char host[256], type[256];
 	int found = 0;
 
-	if (fqdn == NULL) return(hostalias_nomatch);
-	if (IsEmptyStr(fqdn)) return(hostalias_nomatch);
-	if (!strcasecmp(fqdn, "localhost")) return(hostalias_localhost);
-	if (!strcasecmp(fqdn, CtdlGetConfigStr("c_fqdn"))) return(hostalias_localhost);
-	if (!strcasecmp(fqdn, CtdlGetConfigStr("c_nodename"))) return(hostalias_localhost);
-	if (inetcfg == NULL) return(hostalias_nomatch);
+	if (fqdn == NULL)					return(hostalias_nomatch);
+	if (IsEmptyStr(fqdn))					return(hostalias_nomatch);
+	if (!strcasecmp(fqdn, "localhost"))			return(hostalias_localhost);
+	if (!strcasecmp(fqdn, CtdlGetConfigStr("c_fqdn")))	return(hostalias_localhost);
+	if (!strcasecmp(fqdn, CtdlGetConfigStr("c_nodename")))	return(hostalias_localhost);
+	if (inetcfg == NULL)					return(hostalias_nomatch);
 
 	config_lines = num_tokens(inetcfg, '\n');
 	for (i=0; i<config_lines; ++i) {
@@ -305,33 +288,33 @@ int CtdlHostAlias(char *fqdn) {
 		found = 0;
 
 		/* Process these in a specific order, in case there are multiple matches.
-		 * We want directory to override masq, for example.
+		 * We want localhost to override masq, for example.
 		 */
 
 		if ( (!strcasecmp(type, "masqdomain")) && (!strcasecmp(fqdn, host))) {
 			found = hostalias_masq;
 		}
+
 		if ( (!strcasecmp(type, "localhost")) && (!strcasecmp(fqdn, host))) {
 			found = hostalias_localhost;
 		}
+
+		// "directory" used to be a distributed version of "localhost" but they're both the same now
 		if ( (!strcasecmp(type, "directory")) && (!strcasecmp(fqdn, host))) {
-			found = hostalias_directory;
+			found = hostalias_localhost;
 		}
 
 		if (found) return(found);
 	}
-
 	return(hostalias_nomatch);
 }
 
 
-
 /*
  * Determine whether a given Internet address belongs to the current user
  */
-int CtdlIsMe(char *addr, int addr_buf_len)
-{
-	recptypes *recp;
+int CtdlIsMe(char *addr, int addr_buf_len) {
+	struct recptypes *recp;
 	int i;
 
 	recp = validate_recipients(addr, NULL, 0);
@@ -356,7 +339,7 @@ int CtdlIsMe(char *addr, int addr_buf_len)
 
 
 /* If the last item in a list of recipients was truncated to a partial address,
- * remove it completely in order to avoid choking libSieve
+ * remove it completely in order to avoid choking library functions.
  */
 void sanitize_truncated_recipient(char *str)
 {
@@ -379,88 +362,77 @@ void sanitize_truncated_recipient(char *str)
 }
 
 
-
-
-
 /*
  * This function is self explanatory.
  * (What can I say, I'm in a weird mood today...)
  */
-void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name)
-{
-	unsigned int i;
-
-	for (i = 0; i < strlen(name); ++i) {
-		if (name[i] == '@') {
-			while (isspace(name[i - 1]) && i > 0) {
-				strcpy(&name[i - 1], &name[i]);
-				--i;
-			}
-			while (isspace(name[i + 1])) {
-				strcpy(&name[i + 1], &name[i + 2]);
-			}
+void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name) {
+	char *ptr;
+	if (!name) return;
+
+	for (ptr=name; *ptr; ++ptr) {
+		while ( (isspace(*ptr)) && (*(ptr+1)=='@') ) {
+			strcpy(ptr, ptr+1);
+			if (ptr > name) --ptr;
+		}
+		while ( (*ptr=='@') && (*(ptr+1)!=0) && (isspace(*(ptr+1))) ) {
+			strcpy(ptr+1, ptr+2);
 		}
 	}
 }
 
 
-/*
- * Aliasing for network mail.
- * (Error messages have been commented out, because this is a server.)
- */
-int alias(char *name)
-{				/* process alias and routing info for mail */
-	struct CitContext *CCC = CC;
-	FILE *fp;
-	int a, i;
-	char aaa[SIZ], bbb[SIZ];
-	char *ignetcfg = NULL;
-	char *ignetmap = NULL;
+// values that can be returned by expand_aliases()
+enum {
+	EA_ERROR,		// Can't send message due to bad address
+	EA_MULTIPLE,		// Alias expanded into multiple recipients -- run me again!
+	EA_LOCAL,		// Local message, do no network processing
+	EA_INTERNET		// Convert msg and send as Internet mail
+};
+
+
+// Process alias and routing info for email addresses
+int expand_aliases(char *name, char *aliases) {
+	int a;
+	char aaa[SIZ];
 	int at = 0;
-	char node[64];
-	char testnode[64];
-	char buf[SIZ];
 
-	char original_name[256];
+	if (aliases) {
+		int num_aliases = num_tokens(aliases, '\n');
+		for (a=0; a<num_aliases; ++a) {
+			extract_token(aaa, aliases, a, '\n', sizeof aaa);
+			char *bar = strchr(aaa, '|');
+			if (bar) {
+				bar[0] = 0;
+				++bar;
+				striplt(aaa);
+				striplt(bar);
+				if ( (!IsEmptyStr(aaa)) && (!strcasecmp(name, aaa)) ) {
+					syslog(LOG_DEBUG, "internet_addressing: global alias <%s> to <%s>", name, bar);
+					strcpy(name, bar);
+				}
+			}
+		}
+		if (strchr(name, ',')) {
+			return(EA_MULTIPLE);
+		}
+	}
+
+	char original_name[256];				// Now go for the regular aliases
 	safestrncpy(original_name, name, sizeof original_name);
 
+	// should these checks still be here, or maybe move them to split_recps() ?
 	striplt(name);
 	remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
 	stripallbut(name, '<', '>');
 
-	fp = fopen(file_mail_aliases, "r");
-	if (fp == NULL) {
-		fp = fopen("/dev/null", "r");
-	}
-	if (fp == NULL) {
-		return (MES_ERROR);
-	}
-	strcpy(aaa, "");
-	strcpy(bbb, "");
-	while (fgets(aaa, sizeof aaa, fp) != NULL) {
-		while (isspace(name[0]))
-			strcpy(name, &name[1]);
-		aaa[strlen(aaa) - 1] = 0;
-		strcpy(bbb, "");
-		for (a = 0; aaa[a] != '\0'; ++a) {
-			if (aaa[a] == ',') {
-				strcpy(bbb, &aaa[a + 1]);
-				aaa[a] = 0;
-				break;
-			}
-		}
-		if (!strcasecmp(name, aaa))
-			strcpy(name, bbb);
-	}
-	fclose(fp);
-
-	/* Hit the Global Address Book */
+	/* Hit the email address directory */
 	if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) {
 		strcpy(name, aaa);
 	}
 
 	if (strcasecmp(original_name, name)) {
-		MSG_syslog(LOG_INFO, "%s is being forwarded to %s\n", original_name, name);
+		syslog(LOG_INFO, "internet_addressing: directory alias <%s> to <%s>", original_name, name);
 	}
 
 	/* Change "user @ xxx" to "user" if xxx is an alias for this host */
@@ -468,99 +440,110 @@ int alias(char *name)
 		if (name[a] == '@') {
 			if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
 				name[a] = 0;
-				MSG_syslog(LOG_INFO, "Changed to <%s>\n", name);
+				syslog(LOG_DEBUG, "internet_addressing: host is local, recipient is <%s>", name);
 				break;
 			}
 		}
 	}
 
-	/* determine local or remote type, see citadel.h */
+	/* Is this a local or remote recipient? */
 	at = haschar(name, '@');
-	if (at == 0) return(MES_LOCAL);		/* no @'s - local address */
-	if (at > 1) return(MES_ERROR);		/* >1 @'s - invalid address */
-	remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
+	if (at == 0) {
+		return(EA_LOCAL);			/* no @'s = local address */
+	}
+	else if (at == 1) {
+		return(EA_INTERNET);			/* one @ = internet address */
+	}
+	else {
+		return(EA_ERROR);			/* more than one @ = badly formed address */
+	}
+}
 
-	/* figure out the delivery mode */
-	extract_token(node, name, 1, '@', sizeof node);
 
-	/* If there are one or more dots in the nodename, we assume that it
-	 * is an FQDN and will attempt SMTP delivery to the Internet.
-	 */
-	if (haschar(node, '.') > 0) {
-		return(MES_INTERNET);
+// Return a supplied list of email addresses as an array, removing superfluous information and syntax.
+// If an existing Array is supplied as "append_to" it will do so; otherwise a new Array is allocated.
+Array *split_recps(char *addresses, Array *append_to) {
+
+	if (IsEmptyStr(addresses)) {		// nothing supplied, nothing returned
+		return(NULL);
 	}
 
-	/* Otherwise we look in the IGnet maps for a valid Citadel node.
-	 * Try directly-connected nodes first...
-	 */
-	ignetcfg = CtdlGetSysConfig(IGNETCFG);
-	for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
-		extract_token(buf, ignetcfg, i, '\n', sizeof buf);
-		extract_token(testnode, buf, 0, '|', sizeof testnode);
-		if (!strcasecmp(node, testnode)) {
-			free(ignetcfg);
-			return(MES_IGNET);
+	// Copy the supplied address list into our own memory space, because we are going to modify it.
+	char *a = strdup(addresses);
+	if (a == NULL) {
+		syslog(LOG_ERR, "internet_addressing: malloc() failed: %m");
+		return(NULL);
+	}
+
+	// Strip out anything in double quotes
+	char *l = NULL;
+	char *r = NULL;
+	do {
+		l = strchr(a, '\"');
+		r = strrchr(a, '\"');
+		if (r > l) {
+			strcpy(l, r+1);
+		}
+	} while (r > l);
+
+	// Transform all qualifying delimiters to commas
+	for (char *t=a; t[0]; ++t) {
+		if ((t[0]==';') || (t[0]=='|')) {
+			t[0]=',';
 		}
 	}
-	free(ignetcfg);
 
-	/*
-	 * Then try nodes that are two or more hops away.
-	 */
-	ignetmap = CtdlGetSysConfig(IGNETMAP);
-	for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
-		extract_token(buf, ignetmap, i, '\n', sizeof buf);
-		extract_token(testnode, buf, 0, '|', sizeof testnode);
-		if (!strcasecmp(node, testnode)) {
-			free(ignetmap);
-			return(MES_IGNET);
+	// Tokenize the recipients into an array.  No single recipient should be larger than 256 bytes.
+	Array *recipients_array = NULL;
+	if (append_to) {
+		recipients_array = append_to;			// Append to an existing array of recipients
+	}
+	else {
+		recipients_array = array_new(256);		// This is a new array of recipients
+	}
+
+	int num_addresses = num_tokens(a, ',');
+	for (int i=0; i<num_addresses; ++i) {
+		char this_address[256];
+		extract_token(this_address, a, i, ',', sizeof this_address);
+		striplt(this_address);				// strip leading and trailing whitespace
+		stripout(this_address, '(', ')');		// remove any portion in parentheses
+		stripallbut(this_address, '<', '>');		// if angle brackets are present, keep only what is inside them
+		if (!IsEmptyStr(this_address)) {
+			array_append(recipients_array, this_address);
 		}
 	}
-	free(ignetmap);
 
-	/* If we get to this point it's an invalid node name */
-	return (MES_ERROR);
+	free(a);						// We don't need this buffer anymore.
+	return(recipients_array);				// Return the completed array to the caller.
 }
 
 
-
-/*
- * Validate recipients, count delivery types and errors, and handle aliasing
- * FIXME check for dupes!!!!!
- *
- * 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 using free_recipients()
- */
-recptypes *validate_recipients(const char *supplied_recipients, 
-			       const char *RemoteIdentifier, 
-			       int Flags) {
-	struct CitContext *CCC = CC;
-	recptypes *ret;
+// Validate recipients, count delivery types and errors, and handle aliasing
+// FIXME check for dupes!!!!!
+//
+// 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 using free_recipients()
+//
+struct recptypes *validate_recipients(char *supplied_recipients, const char *RemoteIdentifier, int Flags) {
+	struct recptypes *ret;
 	char *recipients = NULL;
-	char *org_recp;
-	char this_recp[256];
-	char this_recp_cooked[256];
 	char append[SIZ];
 	long len;
-	int num_recps = 0;
-	int i, j;
 	int mailtype;
 	int invalid;
 	struct ctdluser tempUS;
-	struct ctdlroom tempQR;
-	struct ctdlroom tempQR2;
+	struct ctdlroom original_room;
 	int err = 0;
 	char errmsg[SIZ];
-	int in_quotes = 0;
+	char *org_recp;
+	char this_recp[256];
 
-	/* Initialize */
-	ret = (recptypes *) malloc(sizeof(recptypes));
+	ret = (struct recptypes *) malloc(sizeof(struct recptypes));			// Initialize
 	if (ret == NULL) return(NULL);
-
-	/* Set all strings to null and numeric values to zero */
-	memset(ret, 0, sizeof(recptypes));
+	memset(ret, 0, sizeof(struct recptypes));					// set all values to null/zero
 
 	if (supplied_recipients == NULL) {
 		recipients = strdup("");
@@ -569,79 +552,44 @@ recptypes *validate_recipients(const char *supplied_recipients,
 		recipients = strdup(supplied_recipients);
 	}
 
-	/* Allocate some memory.  Yes, this allocates 500% more memory than we will
-	 * actually need, but it's healthier for the heap than doing lots of tiny
-	 * realloc() calls instead.
-	 */
-	len = strlen(recipients) + 1024;
+	len = strlen(recipients) + 1024;						// allocate memory
 	ret->errormsg = malloc(len);
 	ret->recp_local = malloc(len);
 	ret->recp_internet = malloc(len);
-	ret->recp_ignet = malloc(len);
 	ret->recp_room = malloc(len);
 	ret->display_recp = malloc(len);
 	ret->recp_orgroom = malloc(len);
-	org_recp = malloc(len);
 
 	ret->errormsg[0] = 0;
 	ret->recp_local[0] = 0;
 	ret->recp_internet[0] = 0;
-	ret->recp_ignet[0] = 0;
 	ret->recp_room[0] = 0;
 	ret->recp_orgroom[0] = 0;
 	ret->display_recp[0] = 0;
-
 	ret->recptypes_magic = RECPTYPES_MAGIC;
 
-	/* Change all valid separator characters to commas */
-	for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
-		if ((recipients[i] == ';') || (recipients[i] == '|')) {
-			recipients[i] = ',';
-		}
-	}
-
-	/* Now start extracting recipients... */
+	Array *recp_array = split_recps(supplied_recipients, NULL);
 
-	while (!IsEmptyStr(recipients)) {
-		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);
-		if (IsEmptyStr(this_recp))
-			break;
-		MSG_syslog(LOG_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
-		++num_recps;
+	char *aliases = CtdlGetSysConfig(GLOBAL_ALIASES);				// First hit the Global Alias Table
 
-		strcpy(org_recp, this_recp);
-		alias(this_recp);
-		alias(this_recp);
-		mailtype = alias(this_recp);
+	for (int r=0; (recp_array && r<array_len(recp_array)); ++r) {
+		org_recp = (char *)array_get_element_at(recp_array, r);
+		strncpy(this_recp, org_recp, sizeof this_recp);
+		mailtype = expand_aliases(this_recp, aliases);
+		syslog(LOG_DEBUG, "Recipient #%d of type %d is <%s>", r, mailtype, this_recp);
 
-		for (j = 0; !IsEmptyStr(&this_recp[j]); ++j) {
-			if (this_recp[j]=='_') {
-				this_recp_cooked[j] = ' ';
-			}
-			else {
-				this_recp_cooked[j] = this_recp[j];
-			}
+		// If an alias expanded to multiple recipients, strip off those recipients and append them
+		// to the end of the array.  This loop will hit those again when it gets there.
+		if (mailtype == EA_MULTIPLE) {
+			recp_array = split_recps(this_recp, recp_array);
 		}
-		this_recp_cooked[j] = '\0';
+
 		invalid = 0;
 		errmsg[0] = 0;
 		switch(mailtype) {
-		case MES_LOCAL:
+		case EA_LOCAL:					// There are several types of "local" recipients.
+
+			// Old BBS conventions require mail to "sysop" to go somewhere.  Send it to the admin room.
 			if (!strcasecmp(this_recp, "sysop")) {
 				++ret->num_room;
 				strcpy(this_recp, CtdlGetConfigStr("c_aideroom"));
@@ -650,44 +598,55 @@ recptypes *validate_recipients(const char *supplied_recipients,
 				}
 				strcat(ret->recp_room, this_recp);
 			}
-			else if ( (!strncasecmp(this_recp, "room_", 5))
-				  && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
 
-				/* Save room so we can restore it later */
-				tempQR2 = CCC->room;
-				CCC->room = tempQR;
-					
-				/* Check permissions to send mail to this room */
-				err = CtdlDoIHavePermissionToPostInThisRoom(
-					errmsg, 
-					sizeof errmsg, 
-					RemoteIdentifier,
-					Flags,
-					0			/* 0 = not a reply */
+			// This handles rooms which can receive posts via email.
+			else if (!strncasecmp(this_recp, "room_", 5)) {
+				original_room = CC->room;				// Remember where we parked
+
+				char mail_to_room[ROOMNAMELEN];
+				char *m;
+				strncpy(mail_to_room, &this_recp[5], sizeof mail_to_room);
+				for (m = mail_to_room; *m; ++m) {
+					if (m[0] == '_') m[0]=' ';
+				}
+				if (!CtdlGetRoom(&CC->room, mail_to_room)) {		// Find the room they asked for
+
+					err = CtdlDoIHavePermissionToPostInThisRoom(	// check for write permissions to room
+						errmsg, 
+						sizeof errmsg, 
+						RemoteIdentifier,
+						Flags,
+						0					// 0 means "this is not a reply"
 					);
-				if (err)
-				{
+					if (err) {
+						++ret->num_error;
+						invalid = 1;
+					} 
+					else {
+						++ret->num_room;
+						if (!IsEmptyStr(ret->recp_room)) {
+							strcat(ret->recp_room, "|");
+						}
+						strcat(ret->recp_room, &this_recp[5]);
+	
+						if (!IsEmptyStr(ret->recp_orgroom)) {
+							strcat(ret->recp_orgroom, "|");
+						}
+						strcat(ret->recp_orgroom, org_recp);
+	
+					}
+				}
+				else {							// no such room exists
 					++ret->num_error;
 					invalid = 1;
-				} 
-				else {
-					++ret->num_room;
-					if (!IsEmptyStr(ret->recp_room)) {
-						strcat(ret->recp_room, "|");
-					}
-					strcat(ret->recp_room, &this_recp_cooked[5]);
-
-					if (!IsEmptyStr(ret->recp_orgroom)) {
-						strcat(ret->recp_orgroom, "|");
-					}
-					strcat(ret->recp_orgroom, org_recp);
-
 				}
-					
-				/* Restore room in case something needs it */
-				CCC->room = tempQR2;
+						
+				// Restore this session's original room location.
+				CC->room = original_room;
 
 			}
+
+			// This handles the most common case, which is mail to a user's inbox.
 			else if (CtdlGetUser(&tempUS, this_recp) == 0) {
 				++ret->num_local;
 				strcpy(this_recp, tempUS.fullname);
@@ -696,26 +655,17 @@ recptypes *validate_recipients(const char *supplied_recipients,
 				}
 				strcat(ret->recp_local, this_recp);
 			}
-			else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
-				++ret->num_local;
-				strcpy(this_recp, tempUS.fullname);
-				if (!IsEmptyStr(ret->recp_local)) {
-					strcat(ret->recp_local, "|");
-				}
-				strcat(ret->recp_local, this_recp);
-			}
+
+			// No match for this recipient
 			else {
 				++ret->num_error;
 				invalid = 1;
 			}
 			break;
-		case MES_INTERNET:
-			/* Yes, you're reading this correctly: if the target
-			 * domain points back to the local system or an attached
-			 * Citadel directory, the address is invalid.  That's
-			 * because if the address were valid, we would have
-			 * already translated it to a local address by now.
-			 */
+		case EA_INTERNET:
+			// Yes, you're reading this correctly: if the target domain points back to the local system,
+			// the address is invalid.  That's because if the address were valid, we would have
+			// already translated it to a local address by now.
 			if (IsDirectory(this_recp, 0)) {
 				++ret->num_error;
 				invalid = 1;
@@ -728,14 +678,10 @@ recptypes *validate_recipients(const char *supplied_recipients,
 				strcat(ret->recp_internet, this_recp);
 			}
 			break;
-		case MES_IGNET:
-			++ret->num_ignet;
-			if (!IsEmptyStr(ret->recp_ignet)) {
-				strcat(ret->recp_ignet, "|");
-			}
-			strcat(ret->recp_ignet, this_recp);
+		case EA_MULTIPLE:
+			// just skip the multiple here because we've already expanded it
 			break;
-		case MES_ERROR:
+		case EA_ERROR:
 			++ret->num_error;
 			invalid = 1;
 			break;
@@ -766,22 +712,25 @@ recptypes *validate_recipients(const char *supplied_recipients,
 			}
 		}
 	}
-	free(org_recp);
 
-	if ((ret->num_local + ret->num_internet + ret->num_ignet +
-	     ret->num_room + ret->num_error) == 0) {
+	if (aliases != NULL) {		// ok, we're done with the global alias list now
+		free(aliases);
+	}
+
+	if ( (ret->num_local + ret->num_internet + ret->num_room + ret->num_error) == 0) {
 		ret->num_error = (-1);
 		strcpy(ret->errormsg, "No recipients specified.");
 	}
 
-	MSGM_syslog(LOG_DEBUG, "validate_recipients()\n");
-	MSG_syslog(LOG_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
-	MSG_syslog(LOG_DEBUG, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
-	MSG_syslog(LOG_DEBUG, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
-	MSG_syslog(LOG_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
-	MSG_syslog(LOG_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
+	syslog(LOG_DEBUG, "internet_addressing: validate_recipients() = %d local, %d room, %d SMTP, %d error",
+		ret->num_local, ret->num_room, ret->num_internet, ret->num_error
+	);
 
 	free(recipients);
+	if (recp_array) {
+		array_free(recp_array);
+	}
+
 	return(ret);
 }
 
@@ -789,22 +738,20 @@ recptypes *validate_recipients(const char *supplied_recipients,
 /*
  * Destructor for recptypes
  */
-void free_recipients(recptypes *valid) {
+void free_recipients(struct recptypes *valid) {
 
 	if (valid == NULL) {
 		return;
 	}
 
 	if (valid->recptypes_magic != RECPTYPES_MAGIC) {
-		struct CitContext *CCC = CC;
-		MSGM_syslog(LOG_EMERG, "Attempt to call free_recipients() on some other data type!\n");
+		syslog(LOG_ERR, "internet_addressing: attempt to call free_recipients() on some other data type!");
 		abort();
 	}
 
 	if (valid->errormsg != NULL)		free(valid->errormsg);
 	if (valid->recp_local != NULL)		free(valid->recp_local);
 	if (valid->recp_internet != NULL)	free(valid->recp_internet);
-	if (valid->recp_ignet != NULL)		free(valid->recp_ignet);
 	if (valid->recp_room != NULL)		free(valid->recp_room);
 	if (valid->recp_orgroom != NULL)        free(valid->recp_orgroom);
 	if (valid->display_recp != NULL)	free(valid->display_recp);
@@ -815,9 +762,7 @@ void free_recipients(recptypes *valid) {
 }
 
 
-char *qp_encode_email_addrs(char *source)
-{
-	struct CitContext *CCC = CC;
+char *qp_encode_email_addrs(char *source) {
 	char *user, *node, *name;
 	const char headerStr[] = "=?UTF-8?Q?";
 	char *Encoded;
@@ -836,8 +781,7 @@ char *qp_encode_email_addrs(char *source)
 
 	if (source == NULL) return source;
 	if (IsEmptyStr(source)) return source;
-	if (MessageDebugEnabled != 0) cit_backtrace();
-	MSG_syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
+	syslog(LOG_DEBUG, "internet_addressing: qp_encode_email_addrs <%s>", source);
 
 	AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
 	AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
@@ -853,20 +797,19 @@ char *qp_encode_email_addrs(char *source)
 			free (AddrPtr), AddrPtr = ptr;
 
 			ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
-			memset(&ptr[nAddrPtrMax], 0, 
-			       sizeof (long) * nAddrPtrMax);
+			memset(&ptr[nAddrPtrMax], 0, sizeof (long) * nAddrPtrMax);
 
 			memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
 			free (AddrUtf8), AddrUtf8 = ptr;
 			nAddrPtrMax *= 2;				
 		}
-		if (((unsigned char) source[i] < 32) || 
-		    ((unsigned char) source[i] > 126)) {
+		if (((unsigned char) source[i] < 32) || ((unsigned char) source[i] > 126)) {
 			need_to_encode = 1;
 			AddrUtf8[nColons] = 1;
 		}
-		if (source[i] == '"')
+		if (source[i] == '"') {
 			InQuotes = !InQuotes;
+		}
 		if (!InQuotes && source[i] == ',') {
 			AddrPtr[nColons] = i;
 			nColons++;
@@ -883,8 +826,9 @@ char *qp_encode_email_addrs(char *source)
 	EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
 	Encoded = (char*) malloc (EncodedMaxLen);
 
-	for (i = 0; i < nColons; i++)
+	for (i = 0; i < nColons; i++) {
 		source[AddrPtr[i]++] = '\0';
+	}
 	/* TODO: if libidn, this might get larger*/
 	user = malloc(SourceLen + 1);
 	node = malloc(SourceLen + 1);
@@ -895,28 +839,19 @@ char *qp_encode_email_addrs(char *source)
 	for (i = 0; i < nColons && nPtr != NULL; i++) {
 		nmax = EncodedMaxLen - (nPtr - Encoded);
 		if (AddrUtf8[i]) {
-			process_rfc822_addr(&source[AddrPtr[i]], 
-					    user,
-					    node,
-					    name);
+			process_rfc822_addr(&source[AddrPtr[i]], user, node, name);
 			/* TODO: libIDN here ! */
 			if (IsEmptyStr(name)) {
-				n = snprintf(nPtr, nmax, 
-					     (i==0)?"%s@%s" : ",%s@%s",
-					     user, node);
+				n = snprintf(nPtr, nmax, (i==0)?"%s@%s" : ",%s@%s", user, node);
 			}
 			else {
 				EncodedName = rfc2047encode(name, strlen(name));			
-				n = snprintf(nPtr, nmax, 
-					     (i==0)?"%s <%s@%s>" : ",%s <%s@%s>",
-					     EncodedName, user, node);
+				n = snprintf(nPtr, nmax, (i==0)?"%s <%s@%s>" : ",%s <%s@%s>", EncodedName, user, node);
 				free(EncodedName);
 			}
 		}
 		else { 
-			n = snprintf(nPtr, nmax, 
-				     (i==0)?"%s" : ",%s",
-				     &source[AddrPtr[i]]);
+			n = snprintf(nPtr, nmax, (i==0)?"%s" : ",%s", &source[AddrPtr[i]]);
 		}
 		if (n > 0 )
 			nPtr += n;
@@ -942,31 +877,6 @@ char *qp_encode_email_addrs(char *source)
 }
 
 
-/*
- * Return 0 if a given string fuzzy-matches a Citadel user account
- *
- * FIXME ... this needs to be updated to handle aliases.
- */
-int fuzzy_match(struct ctdluser *us, char *matchstring) {
-	int a;
-	long len;
-
-	if ( (!strncasecmp(matchstring, "cit", 3)) 
-	   && (atol(&matchstring[3]) == us->usernum)) {
-		return 0;
-	}
-
-	len = strlen(matchstring);
-	for (a=0; !IsEmptyStr(&us->fullname[a]); ++a) {
-		if (!strncasecmp(&us->fullname[a],
-		   matchstring, len)) {
-			return 0;
-		}
-	}
-	return -1;
-}
-
-
 /*
  * Unfold a multi-line field into a single line, removing multi-whitespaces
  */
@@ -993,20 +903,17 @@ void unfold_rfc822_field(char **field, char **FieldEnd)
 	{
 		if ((*sField=='\r') || (*sField=='\n'))
 		{
-			int Offset = 1;
-			while (((*(sField + Offset) == '\r') ||
-				(*(sField + Offset) == '\n') ||
-				(isspace(*(sField + Offset)))) && 
-			       (sField + Offset < pFieldEnd))
-				Offset ++;
-			sField += Offset;
+			int offset = 1;
+			while ( ( (*(sField + offset) == '\r') || (*(sField + offset) == '\n' )) && (sField + offset < pFieldEnd) ) {
+				offset ++;
+			}
+			sField += offset;
 			*pField = *sField;
 		}
 		else {
 			if (*sField=='\"') quote = 1 - quote;
 			if (!quote) {
-				if (isspace(*sField))
-				{
+				if (isspace(*sField)) {
 					*pField = ' ';
 					pField++;
 					sField++;
@@ -1026,13 +933,11 @@ void unfold_rfc822_field(char **field, char **FieldEnd)
 }
 
 
-
 /*
  * Split an RFC822-style address into userid, host, and full name
  *
  */
-void process_rfc822_addr(const char *rfc822, char *user, char *node, char *name)
-{
+void process_rfc822_addr(const char *rfc822, char *user, char *node, char *name) {
 	int a;
 
 	strcpy(user, "");
@@ -1127,7 +1032,6 @@ void process_rfc822_addr(const char *rfc822, char *user, char *node, char *name)
 	) {
 		strcpy(node, CtdlGetConfigStr("c_nodename"));
 	}
-
 	else {
 
 		/* strip anything to the left of a @ */
@@ -1165,7 +1069,6 @@ void process_rfc822_addr(const char *rfc822, char *user, char *node, char *name)
 }
 
 
-
 /*
  * convert_field() is a helper function for convert_internet_message().
  * Given start/end positions for an rfc822 field, it converts it to a Citadel
@@ -1225,12 +1128,14 @@ int convert_field(struct CtdlMessage *msg, const char *beg, const char *end) {
 
 	else if (!strcasecmp(key, "From")) {
 		process_rfc822_addr(value, user, node, name);
-		syslog(LOG_DEBUG, "Converted to <%s@%s> (%s)\n", user, node, name);
+		syslog(LOG_DEBUG, "internet_addressing: converted to <%s@%s> (%s)", user, node, name);
 		snprintf(addr, sizeof(addr), "%s@%s", user, node);
-		if (CM_IsEmpty(msg, eAuthor) && !IsEmptyStr(name))
-			CM_SetField(msg, eAuthor, name, strlen(name));
-		if (CM_IsEmpty(msg, erFc822Addr) && !IsEmptyStr(addr))
-			CM_SetField(msg, erFc822Addr, addr, strlen(addr));
+		if (CM_IsEmpty(msg, eAuthor) && !IsEmptyStr(name)) {
+			CM_SetField(msg, eAuthor, name, -1);
+		}
+		if (CM_IsEmpty(msg, erFc822Addr) && !IsEmptyStr(addr)) {
+			CM_SetField(msg, erFc822Addr, addr, -1);
+		}
 		processed = 1;
 	}
 
@@ -1260,7 +1165,7 @@ int convert_field(struct CtdlMessage *msg, const char *beg, const char *end) {
 
 	else if (!strcasecmp(key, "Message-ID")) {
 		if (!CM_IsEmpty(msg, emessageId)) {
-			syslog(LOG_WARNING, "duplicate message id\n");
+			syslog(LOG_WARNING, "internet_addressing: duplicate message id");
 		}
 		else {
 			char *pValue;
@@ -1371,7 +1276,6 @@ struct CtdlMessage *convert_internet_message(char *rfc822) {
 }
 
 
-
 struct CtdlMessage *convert_internet_message_buf(StrBuf **rfc822)
 {
 	struct CtdlMessage *msg;
@@ -1466,7 +1370,6 @@ struct CtdlMessage *convert_internet_message_buf(StrBuf **rfc822)
 }
 
 
-
 /*
  * Look for a particular header field in an RFC822 message text.  If the
  * requested field is found, it is unfolded (if necessary) and returned to
@@ -1518,7 +1421,6 @@ char *rfc822_fetch_field(const char *rfc822, const char *fieldname) {
 }
 
 
-
 /*****************************************************************************
  *                      DIRECTORY MANAGEMENT FUNCTIONS                       *
  *****************************************************************************/
@@ -1538,13 +1440,12 @@ void directory_key(char *key, char *addr) {
 	}
 	key[keylen++] = 0;
 
-	syslog(LOG_DEBUG, "Directory key is <%s>\n", key);
+	syslog(LOG_DEBUG, "internet_addressing: directory key is <%s>", key);
 }
 
 
-
-/* Return nonzero if the supplied address is in a domain we keep in
- * the directory
+/*
+ * Return nonzero if the supplied address is in one of "our" domains
  */
 int IsDirectory(char *addr, int allow_masq_domains) {
 	char domain[256];
@@ -1558,7 +1459,7 @@ int IsDirectory(char *addr, int allow_masq_domains) {
 	if ( (h == hostalias_masq) && allow_masq_domains)
 		return(1);
 	
-	if ( (h == hostalias_localhost) || (h == hostalias_directory) ) {
+	if (h == hostalias_localhost) {
 		return(1);
 	}
 	else {
@@ -1567,23 +1468,16 @@ int IsDirectory(char *addr, int allow_masq_domains) {
 }
 
 
-/*
- * Initialize the directory database (erasing anything already there)
- */
-void CtdlDirectoryInit(void) {
-	cdb_trunc(CDB_DIRECTORY);
-}
-
-
 /*
  * Add an Internet e-mail address to the directory for a user
  */
 int CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) {
 	char key[SIZ];
 
-	if (IsDirectory(internet_addr, 0) == 0) 
+	if (IsDirectory(internet_addr, 0) == 0) {
 		return 0;
-	syslog(LOG_DEBUG, "Create directory entry: %s --> %s\n", internet_addr, citadel_addr);
+	}
+	syslog(LOG_DEBUG, "internet_addressing: create directory entry: %s --> %s", internet_addr, citadel_addr);
 	directory_key(key, internet_addr);
 	cdb_store(CDB_DIRECTORY, key, strlen(key), citadel_addr, strlen(citadel_addr)+1 );
 	return 1;
@@ -1598,8 +1492,8 @@ int CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) {
  */
 int CtdlDirectoryDelUser(char *internet_addr, char *citadel_addr) {
 	char key[SIZ];
-
-	syslog(LOG_DEBUG, "Delete directory entry: %s --> %s\n", internet_addr, citadel_addr);
+	
+	syslog(LOG_DEBUG, "internet_addressing: delete directory entry: %s --> %s", internet_addr, citadel_addr);
 	directory_key(key, internet_addr);
 	return cdb_delete(CDB_DIRECTORY, key, strlen(key) ) == 0;
 }
@@ -1615,7 +1509,9 @@ int CtdlDirectoryLookup(char *target, char *internet_addr, size_t targbuflen) {
 	char key[SIZ];
 
 	/* Dump it in there unchanged, just for kicks */
-	safestrncpy(target, internet_addr, targbuflen);
+	if (target != NULL) {
+		safestrncpy(target, internet_addr, targbuflen);
+	}
 
 	/* Only do lookups for addresses with hostnames in them */
 	if (num_tokens(internet_addr, '@') != 2) return(-1);
@@ -1626,7 +1522,9 @@ int CtdlDirectoryLookup(char *target, char *internet_addr, size_t targbuflen) {
 	directory_key(key, internet_addr);
 	cdbrec = cdb_fetch(CDB_DIRECTORY, key, strlen(key) );
 	if (cdbrec != NULL) {
-		safestrncpy(target, cdbrec->ptr, targbuflen);
+		if (target != NULL) {
+			safestrncpy(target, cdbrec->ptr, targbuflen);
+		}
 		cdb_free(cdbrec);
 		return(0);
 	}
@@ -1684,7 +1582,7 @@ char *harvest_collected_addresses(struct CtdlMessage *msg) {
 					utf8ify_rfc822_string(addr);
 				process_rfc822_addr(addr, user, node, name);
 				h = CtdlHostAlias(node);
-				if ( (h != hostalias_localhost) && (h != hostalias_directory) ) {
+				if (h != hostalias_localhost) {
 					coll = realloc(coll, strlen(coll) + strlen(addr) + 4);
 					if (coll == NULL) return(NULL);
 					if (!IsEmptyStr(coll)) {
@@ -1703,3 +1601,106 @@ char *harvest_collected_addresses(struct CtdlMessage *msg) {
 	}
 	return(coll);
 }
+
+
+/*
+ * Helper function for CtdlRebuildDirectoryIndex()
+ */
+void CtdlRebuildDirectoryIndex_backend(char *username, void *data) {
+
+	int j = 0;
+	struct ctdluser usbuf;
+
+	if (CtdlGetUser(&usbuf, username) != 0) {
+		return;
+	}
+
+	if ( (!IsEmptyStr(usbuf.fullname)) && (!IsEmptyStr(usbuf.emailaddrs)) ) {
+		for (j=0; j<num_tokens(usbuf.emailaddrs, '|'); ++j) {
+			char one_email[512];
+			extract_token(one_email, usbuf.emailaddrs, j, '|', sizeof one_email);
+			CtdlDirectoryAddUser(one_email, usbuf.fullname);
+		}
+	}
+}
+
+
+/*
+ * Initialize the directory database (erasing anything already there)
+ */
+void CtdlRebuildDirectoryIndex(void) {
+	syslog(LOG_INFO, "internet_addressing: rebuilding email address directory index");
+	cdb_trunc(CDB_DIRECTORY);
+	ForEachUser(CtdlRebuildDirectoryIndex_backend, NULL);
+}
+
+
+/*
+ * Configure Internet email addresses for a user account, updating the Directory Index in the process
+ */
+void CtdlSetEmailAddressesForUser(char *requested_user, char *new_emailaddrs)
+{
+	struct ctdluser usbuf;
+	int i;
+	char buf[SIZ];
+
+	if (CtdlGetUserLock(&usbuf, requested_user) != 0) {	// We are relying on the fact that the DirectoryIndex functions don't lock.
+		return;						// Silently fail here if we can't acquire a lock on the user record.
+	}
+
+	syslog(LOG_DEBUG, "internet_addressing: setting email addresses for <%s> to <%s>", usbuf.fullname, new_emailaddrs);
+
+	/* Delete all of the existing directory index records for the user (easier this way) */
+	for (i=0; i<num_tokens(usbuf.emailaddrs, '|'); ++i) {
+		extract_token(buf, usbuf.emailaddrs, i, '|', sizeof buf);
+		CtdlDirectoryDelUser(buf, requested_user);
+	}
+
+	strcpy(usbuf.emailaddrs, new_emailaddrs);		// make it official.
+
+	/* Index all of the new email addresses (they've already been sanitized) */
+	for (i=0; i<num_tokens(usbuf.emailaddrs, '|'); ++i) {
+		extract_token(buf, usbuf.emailaddrs, i, '|', sizeof buf);
+		CtdlDirectoryAddUser(buf, requested_user);
+	}
+
+	CtdlPutUserLock(&usbuf);
+}
+
+
+/*
+ * Auto-generate an Internet email address for a user account
+ */
+void AutoGenerateEmailAddressForUser(struct ctdluser *user)
+{
+	char synthetic_email_addr[1024];
+	int i, j;
+	int u = 0;
+
+	for (i=0; u==0; ++i) {
+		if (i == 0) {
+			// first try just converting the user name to lowercase and replacing spaces with underscores
+			snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "%s@%s", user->fullname, CtdlGetConfigStr("c_fqdn"));
+			for (j=0; ((synthetic_email_addr[j] != '\0')&&(synthetic_email_addr[j] != '@')); j++) {
+				synthetic_email_addr[j] = tolower(synthetic_email_addr[j]);
+				if (!isalnum(synthetic_email_addr[j])) {
+					synthetic_email_addr[j] = '_';
+				}
+			}
+		}
+		else if (i == 1) {
+			// then try 'ctdl' followed by the user number
+			snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "ctdl%08lx@%s", user->usernum, CtdlGetConfigStr("c_fqdn"));
+		}
+		else if (i > 1) {
+			// oof.  just keep trying other numbers until we find one
+			snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "ctdl%08x@%s", i, CtdlGetConfigStr("c_fqdn"));
+		}
+		u = CtdlDirectoryLookup(NULL, synthetic_email_addr, 0);
+		syslog(LOG_DEBUG, "user_ops: address <%s> lookup returned <%d>", synthetic_email_addr, u);
+	}
+
+	CtdlSetEmailAddressesForUser(user->fullname, synthetic_email_addr);
+	strncpy(CC->user.emailaddrs, synthetic_email_addr, sizeof(user->emailaddrs));
+	syslog(LOG_DEBUG, "user_ops: auto-generated email address <%s> for <%s>", synthetic_email_addr, user->fullname);
+}