X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=citadel%2Finternet_addressing.c;h=68daf88542c6e11b0dd974de5a195c91605a2045;hp=c96d722e12ccd2bf4b0b5be632a5d1297c0e1a13;hb=b9a2089d59579d13694e08b299c2aaf44ef9df6c;hpb=76fab287198d1da021be18e608717bacb953e169 diff --git a/citadel/internet_addressing.c b/citadel/internet_addressing.c index c96d722e1..68daf8854 100644 --- a/citadel/internet_addressing.c +++ b/citadel/internet_addressing.c @@ -1,8 +1,16 @@ /* - * $Id$ - * * This file contains functions which handle the mapping of Internet addresses * to users on the Citadel system. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. */ #include "sysdep.h" @@ -15,18 +23,7 @@ #include #include #include - -#if TIME_WITH_SYS_TIME -# include -# include -#else -# if HAVE_SYS_TIME_H -# include -# else -# include -# endif -#endif - +#include #include #include #include @@ -43,42 +40,12 @@ #include "room_ops.h" #include "parsedate.h" #include "database.h" - - -#ifndef HAVE_SNPRINTF -#include "snprintf.h" -#endif - - +#include "ctdl_module.h" #ifdef HAVE_ICONV #include -/* - * Wrapper around iconv_open() - * Our version adds aliases for non-standard Microsoft charsets - * such as 'MS950', aliasing them to names like 'CP950' - * - * tocode Target encoding - * fromcode Source encoding - */ -iconv_t ctdl_iconv_open(const char *tocode, const char *fromcode) -{ - iconv_t ic = (iconv_t)(-1) ; - ic = iconv_open(tocode, fromcode); - if (ic == (iconv_t)(-1) ) { - char alias_fromcode[64]; - if ( (strlen(fromcode) == 5) && (!strncasecmp(fromcode, "MS", 2)) ) { - safestrncpy(alias_fromcode, fromcode, sizeof alias_fromcode); - alias_fromcode[0] = 'C'; - alias_fromcode[1] = 'P'; - ic = iconv_open(tocode, alias_fromcode); - } - } - return(ic); -} - #if 0 -/* This is the non-define version in case of s.b. needing to debug */ +/* This is the non-define version in case it is needed for debugging */ inline void FindNextEnd (char *bptr, char *end) { /* Find the next ?Q? */ @@ -115,33 +82,33 @@ 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 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) { const char *default_header_charset = "iso-8859-1"; if ( (strcasecmp(default_header_charset, "UTF-8")) && (strcasecmp(default_header_charset, "us-ascii")) ) { - ic = ctdl_iconv_open("UTF-8", default_header_charset); + ctdl_iconv_open("UTF-8", default_header_charset, &ic); if (ic != (iconv_t)(-1) ) { ibuf = malloc(1024); isav = ibuf; @@ -167,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); @@ -176,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) || @@ -213,37 +177,34 @@ void utf8ify_rfc822_string(char *buf) { */ 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; - long pos; + 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); } - ic = ctdl_iconv_open("UTF-8", charset); + ctdl_iconv_open("UTF-8", charset, &ic); if (ic != (iconv_t)(-1) ) { obuflen = 1024; obuf = (char *) malloc(obuflen); @@ -301,15 +262,12 @@ 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. @@ -319,13 +277,14 @@ int CtdlHostAlias(char *fqdn) { int i; char buf[256]; 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, config.c_fqdn)) return(hostalias_localhost); - if (!strcasecmp(fqdn, config.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; inum_local == 0) { + free_recipients(recp); + return(0); + } + + for (i=0; inum_local; ++i) { + extract_token(addr, recp->recp_local, i, '|', addr_buf_len); + if (!strcasecmp(addr, CC->user.fullname)) { + free_recipients(recp); + return(1); + } + } + free_recipients(recp); + return(0); +} +/* If the last item in a list of recipients was truncated to a partial address, + * remove it completely in order to avoid choking library functions. + */ +void sanitize_truncated_recipient(char *str) +{ + if (!str) return; + if (num_tokens(str, ',') < 2) return; + + int len = strlen(str); + if (len < 900) return; + if (len > 998) str[998] = 0; + + char *cptr = strrchr(str, ','); + if (!cptr) return; + + char *lptr = strchr(cptr, '<'); + char *rptr = strchr(cptr, '>'); + + if ( (lptr) && (rptr) && (rptr > lptr) ) return; + + *cptr = 0; +} /* - * Return 0 if a given string fuzzy-matches a Citadel user account - * - * FIXME ... this needs to be updated to handle aliases. + * This function is self explanatory. + * (What can I say, I'm in a weird mood today...) */ -int fuzzy_match(struct ctdluser *us, char *matchstring) { +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. + */ +int alias(char *name) { /* process alias and routing info for mail */ int a; + char aaa[SIZ]; + int at = 0; + char node[64]; + + char original_name[256]; + safestrncpy(original_name, name, sizeof original_name); + + striplt(name); + remove_any_whitespace_to_the_left_or_right_of_at_symbol(name); + stripallbut(name, '<', '>'); + + /* Hit the email address directory */ + if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) { + strcpy(name, aaa); + } + + if (strcasecmp(original_name, name)) { + syslog(LOG_INFO, "internet_addressing: %s is being forwarded to %s", original_name, name); + } + + /* Change "user @ xxx" to "user" if xxx is an alias for this host */ + for (a=0; name[a] != '\0'; ++a) { + if (name[a] == '@') { + if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) { + name[a] = 0; + syslog(LOG_DEBUG, "internet_addressing: changed to <%s>", name); + break; + } + } + } + + /* determine local or remote type, see citadel.h */ + 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); + + /* 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); + } + + /* If we get to this point it's an invalid node name */ + return (MES_ERROR); +} + + +/* + * 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(const char *supplied_recipients, const char *RemoteIdentifier, int Flags) { + struct CitContext *CCC = CC; + 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; + int err = 0; + char errmsg[SIZ]; + int in_quotes = 0; + + /* Initialize */ + ret = (struct recptypes *) malloc(sizeof(struct recptypes)); + if (ret == NULL) return(NULL); + + /* Set all strings to null and numeric values to zero */ + memset(ret, 0, sizeof(struct recptypes)); + + if (supplied_recipients == NULL) { + recipients = strdup(""); + } + else { + recipients = strdup(supplied_recipients); + } - if ( (!strncasecmp(matchstring, "cit", 3)) - && (atol(&matchstring[3]) == us->usernum)) { - return 0; + /* 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; + ret->errormsg = malloc(len); + ret->recp_local = malloc(len); + ret->recp_internet = 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_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... */ + + 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; + syslog(LOG_DEBUG, "internet_addressing: evaluating recipient #%d: %s", num_recps, this_recp); + ++num_recps; + + strcpy(org_recp, this_recp); + alias(this_recp); + alias(this_recp); + mailtype = alias(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]; + } + } + this_recp_cooked[j] = '\0'; + invalid = 0; + errmsg[0] = 0; + switch(mailtype) { + case MES_LOCAL: + if (!strcasecmp(this_recp, "sysop")) { + ++ret->num_room; + strcpy(this_recp, CtdlGetConfigStr("c_aideroom")); + if (!IsEmptyStr(ret->recp_room)) { + strcat(ret->recp_room, "|"); + } + 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 */ + ); + 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_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; + + } + else if (CtdlGetUser(&tempUS, this_recp) == 0) { + ++ret->num_local; + strcpy(this_recp, tempUS.fullname); + if (!IsEmptyStr(ret->recp_local)) { + strcat(ret->recp_local, "|"); + } + 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); + } + 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, + * 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; + } + else { + ++ret->num_internet; + if (!IsEmptyStr(ret->recp_internet)) { + strcat(ret->recp_internet, "|"); + } + strcat(ret->recp_internet, this_recp); + } + break; + case MES_ERROR: + ++ret->num_error; + invalid = 1; + break; + } + if (invalid) { + if (IsEmptyStr(errmsg)) { + snprintf(append, sizeof append, "Invalid recipient: %s", this_recp); + } + else { + snprintf(append, sizeof append, "%s", errmsg); + } + if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) { + if (!IsEmptyStr(ret->errormsg)) { + strcat(ret->errormsg, "; "); + } + strcat(ret->errormsg, append); + } + } + else { + if (IsEmptyStr(ret->display_recp)) { + strcpy(append, this_recp); + } + else { + snprintf(append, sizeof append, ", %s", this_recp); + } + if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) { + strcat(ret->display_recp, append); + } + } + } + free(org_recp); + + if ( (ret->num_local + ret->num_internet + ret->num_room + ret->num_error) == 0) { + ret->num_error = (-1); + strcpy(ret->errormsg, "No recipients specified."); + } + + 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); + return(ret); +} + + +/* + * Destructor for recptypes + */ +void free_recipients(struct recptypes *valid) { + + if (valid == NULL) { + return; + } + + if (valid->recptypes_magic != RECPTYPES_MAGIC) { + 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_room != NULL) free(valid->recp_room); + if (valid->recp_orgroom != NULL) free(valid->recp_orgroom); + if (valid->display_recp != NULL) free(valid->display_recp); + if (valid->bounce_to != NULL) free(valid->bounce_to); + if (valid->envelope_from != NULL) free(valid->envelope_from); + if (valid->sending_room != NULL) free(valid->sending_room); + free(valid); +} + + +char *qp_encode_email_addrs(char *source) { + char *user, *node, *name; + const char headerStr[] = "=?UTF-8?Q?"; + char *Encoded; + char *EncodedName; + char *nPtr; + int need_to_encode = 0; + long SourceLen; + long EncodedMaxLen; + long nColons = 0; + long *AddrPtr; + long *AddrUtf8; + long nAddrPtrMax = 50; + long nmax; + int InQuotes = 0; + int i, n; + + if (source == NULL) return source; + if (IsEmptyStr(source)) return source; + syslog(LOG_DEBUG, "internet_addressing: qp_encode_email_addrs <%s>", source); + + AddrPtr = malloc (sizeof (long) * nAddrPtrMax); + AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax); + memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax); + *AddrPtr = 0; + i = 0; + while (!IsEmptyStr (&source[i])) { + if (nColons >= nAddrPtrMax){ + long *ptr; + + ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2); + memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax); + free (AddrPtr), AddrPtr = ptr; + + ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2); + 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)) { + need_to_encode = 1; + AddrUtf8[nColons] = 1; + } + if (source[i] == '"') { + InQuotes = !InQuotes; + } + if (!InQuotes && source[i] == ',') { + AddrPtr[nColons] = i; + nColons++; + } + i++; + } + if (need_to_encode == 0) { + free(AddrPtr); + free(AddrUtf8); + return source; } - len = strlen(matchstring); - for (a=0; !IsEmptyStr(&us->fullname[a]); ++a) { - if (!strncasecmp(&us->fullname[a], - matchstring, len)) { - return 0; + SourceLen = i; + EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3; + Encoded = (char*) malloc (EncodedMaxLen); + + 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); + name = malloc(SourceLen + 1); + + nPtr = Encoded; + *nPtr = '\0'; + for (i = 0; i < nColons && nPtr != NULL; i++) { + nmax = EncodedMaxLen - (nPtr - Encoded); + if (AddrUtf8[i]) { + 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); + } + else { + EncodedName = rfc2047encode(name, strlen(name)); + 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]]); + } + if (n > 0 ) + nPtr += n; + else { + char *ptr, *nnPtr; + ptr = (char*) malloc(EncodedMaxLen * 2); + memcpy(ptr, Encoded, EncodedMaxLen); + nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr; + free(Encoded), Encoded = ptr; + EncodedMaxLen *= 2; + i--; /* do it once more with properly lengthened buffer */ } } - return -1; + for (i = 0; i < nColons; i++) + source[--AddrPtr[i]] = ','; + + free(user); + free(node); + free(name); + free(AddrUtf8); + free(AddrPtr); + return Encoded; } /* * Unfold a multi-line field into a single line, removing multi-whitespaces */ -void unfold_rfc822_field(char *field) { - int i; +void unfold_rfc822_field(char **field, char **FieldEnd) +{ int quote = 0; + char *pField = *field; + char *sField; + char *pFieldEnd = *FieldEnd; + + while (isspace(*pField)) + pField++; + /* remove leading/trailing whitespace */ + ; - striplt(field); /* remove leading/trailing whitespace */ + while (isspace(*pFieldEnd)) + pFieldEnd --; + *FieldEnd = pFieldEnd; /* convert non-space whitespace to spaces, and remove double blanks */ - for (i=0; icm_fields['M']; /* M field contains rfc822 text */ - for (i = end; i >= beg; --i) { - if (rfc822[i] == ':') colonpos = i; + for (pos = end; pos >= beg; pos--) { + if (*pos == ':') colonpos = pos; } - if (colonpos < 0) return(0); /* no colon? not a valid header line */ + if (colonpos == NULL) return(0); /* no colon? not a valid header line */ - key = malloc((end - beg) + 2); - safestrncpy(key, &rfc822[beg], (end-beg)+1); - key[colonpos - beg] = 0; + len = end - beg; + key = malloc(len + 2); + memcpy(key, beg, len + 1); + key[len] = '\0'; + valueend = key + len; + * ( key + (colonpos - beg) ) = '\0'; value = &key[(colonpos - beg) + 1]; - unfold_rfc822_field(value); +/* printf("Header: [%s]\nValue: [%s]\n", key, value); */ + unfold_rfc822_field(&value, &valueend); + valuelen = valueend - value + 1; +/* printf("UnfoldedValue: [%s]\n", value); */ /* * Here's the big rfc822-to-citadel loop. @@ -576,87 +1077,102 @@ int convert_field(struct CtdlMessage *msg, int beg, int end) { if (!strcasecmp(key, "Date")) { parsed_date = parsedate(value); if (parsed_date < 0L) parsed_date = time(NULL); - snprintf(buf, sizeof buf, "%ld", (long)parsed_date ); - if (msg->cm_fields['T'] == NULL) - msg->cm_fields['T'] = strdup(buf); + + if (CM_IsEmpty(msg, eTimestamp)) + CM_SetFieldLONG(msg, eTimestamp, parsed_date); processed = 1; } else if (!strcasecmp(key, "From")) { process_rfc822_addr(value, user, node, name); - CtdlLogPrintf(CTDL_DEBUG, "Converted to <%s@%s> (%s)\n", user, node, name); - snprintf(addr, sizeof addr, "%s@%s", user, node); - if (msg->cm_fields['A'] == NULL) - msg->cm_fields['A'] = strdup(name); - processed = 1; - if (msg->cm_fields['F'] == NULL) - msg->cm_fields['F'] = strdup(addr); + 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, -1); + } + if (CM_IsEmpty(msg, erFc822Addr) && !IsEmptyStr(addr)) { + CM_SetField(msg, erFc822Addr, addr, -1); + } processed = 1; } else if (!strcasecmp(key, "Subject")) { - if (msg->cm_fields['U'] == NULL) - msg->cm_fields['U'] = strdup(value); + if (CM_IsEmpty(msg, eMsgSubject)) + CM_SetField(msg, eMsgSubject, value, valuelen); + processed = 1; + } + + else if (!strcasecmp(key, "List-ID")) { + if (CM_IsEmpty(msg, eListID)) + CM_SetField(msg, eListID, value, valuelen); processed = 1; } else if (!strcasecmp(key, "To")) { - if (msg->cm_fields['R'] == NULL) - msg->cm_fields['R'] = strdup(value); + if (CM_IsEmpty(msg, eRecipient)) + CM_SetField(msg, eRecipient, value, valuelen); processed = 1; } else if (!strcasecmp(key, "CC")) { - if (msg->cm_fields['Y'] == NULL) - msg->cm_fields['Y'] = strdup(value); + if (CM_IsEmpty(msg, eCarbonCopY)) + CM_SetField(msg, eCarbonCopY, value, valuelen); processed = 1; } else if (!strcasecmp(key, "Message-ID")) { - if (msg->cm_fields['I'] != NULL) { - CtdlLogPrintf(CTDL_WARNING, "duplicate message id\n"); + if (!CM_IsEmpty(msg, emessageId)) { + syslog(LOG_WARNING, "internet_addressing: duplicate message id"); } + else { + char *pValue; + long pValueLen; - if (msg->cm_fields['I'] == NULL) { - msg->cm_fields['I'] = strdup(value); - + pValue = value; + pValueLen = valuelen; /* Strip angle brackets */ - while (haschar(msg->cm_fields['I'], '<') > 0) { - strcpy(&msg->cm_fields['I'][0], - &msg->cm_fields['I'][1]); + while (haschar(pValue, '<') > 0) { + pValue ++; + pValueLen --; } - for (i = 0; icm_fields['I']); ++i) - if (msg->cm_fields['I'][i] == '>') - msg->cm_fields['I'][i] = 0; + + for (i = 0; i <= pValueLen; ++i) + if (pValue[i] == '>') { + pValueLen = i; + break; + } + + CM_SetField(msg, emessageId, pValue, pValueLen); } processed = 1; } else if (!strcasecmp(key, "Return-Path")) { - if (msg->cm_fields['P'] == NULL) - msg->cm_fields['P'] = strdup(value); + if (CM_IsEmpty(msg, eMessagePath)) + CM_SetField(msg, eMessagePath, value, valuelen); processed = 1; } else if (!strcasecmp(key, "Envelope-To")) { - if (msg->cm_fields['V'] == NULL) - msg->cm_fields['V'] = strdup(value); + if (CM_IsEmpty(msg, eenVelopeTo)) + CM_SetField(msg, eenVelopeTo, value, valuelen); processed = 1; } else if (!strcasecmp(key, "References")) { - if (msg->cm_fields['W'] != NULL) { - free(msg->cm_fields['W']); - } - msg->cm_fields['W'] = strdup(value); + CM_SetField(msg, eWeferences, value, valuelen); + processed = 1; + } + + else if (!strcasecmp(key, "Reply-To")) { + CM_SetField(msg, eReplyTo, value, valuelen); processed = 1; } else if (!strcasecmp(key, "In-reply-to")) { - if (msg->cm_fields['W'] == NULL) { /* References: supersedes In-reply-to: */ - msg->cm_fields['W'] = strdup(value); - } + if (CM_IsEmpty(msg, eWeferences)) /* References: supersedes In-reply-to: */ + CM_SetField(msg, eWeferences, value, valuelen); processed = 1; } @@ -664,7 +1180,7 @@ int convert_field(struct CtdlMessage *msg, int beg, int end) { /* Clean up and move on. */ free(key); /* Don't free 'value', it's actually the same buffer */ - return(processed); + return processed; } @@ -706,17 +1222,24 @@ void convert_references_to_wefewences(char *str) { /* * Convert an RFC822 message (headers + body) to a CtdlMessage structure. * NOTE: the supplied buffer becomes part of the CtdlMessage structure, and - * will be deallocated when CtdlFreeMessage() is called. Therefore, the + * will be deallocated when CM_Free() is called. Therefore, the * supplied buffer should be DEREFERENCED. It should not be freed or used * again. */ struct CtdlMessage *convert_internet_message(char *rfc822) { + StrBuf *RFCBuf = NewStrBufPlain(rfc822, -1); + free (rfc822); + return convert_internet_message_buf(&RFCBuf); +} + +struct CtdlMessage *convert_internet_message_buf(StrBuf **rfc822) +{ struct CtdlMessage *msg; - int pos, beg, end, msglen; - int done; - char buf[SIZ]; + const char *pos, *beg, *end, *totalend; + int done, alldone = 0; int converted; + StrBuf *OtherHeaders; msg = malloc(sizeof(struct CtdlMessage)); if (msg == NULL) return msg; @@ -725,36 +1248,39 @@ struct CtdlMessage *convert_internet_message(char *rfc822) { msg->cm_magic = CTDLMESSAGE_MAGIC; /* self check */ msg->cm_anon_type = 0; /* never anonymous */ msg->cm_format_type = FMT_RFC822; /* internet message */ - msg->cm_fields['M'] = rfc822; - pos = 0; + pos = ChrPtr(*rfc822); + totalend = pos + StrLength(*rfc822); done = 0; + OtherHeaders = NewStrBufPlain(NULL, StrLength(*rfc822)); - while (!done) { + while (!alldone) { /* Locate beginning and end of field, keeping in mind that * some fields might be multiline */ - beg = pos; - end = (-1); + end = beg = pos; - msglen = strlen(rfc822); - while ( (end < 0) && (done == 0) ) { + while ((end < totalend) && + (end == beg) && + (done == 0) ) + { - if ((rfc822[pos]=='\n') - && (!isspace(rfc822[pos+1]))) { + if ( (*pos=='\n') && ((*(pos+1))!=0x20) && ((*(pos+1))!=0x09) ) + { end = pos; } /* done with headers? */ - if ( (rfc822[pos]=='\n') - && ( (rfc822[pos+1]=='\n') - ||(rfc822[pos+1]=='\r')) ) { - end = pos; - done = 1; + if ((*pos=='\n') && + ( (*(pos+1)=='\n') || + (*(pos+1)=='\r')) ) + { + alldone = 1; } - if (pos >= (msglen-1) ) { + if (pos >= (totalend - 1) ) + { end = pos; done = 1; } @@ -767,35 +1293,40 @@ struct CtdlMessage *convert_internet_message(char *rfc822) { converted = convert_field(msg, beg, end); /* Strip the field out of the RFC822 header if we used it */ - if (converted) { - strcpy(&rfc822[beg], &rfc822[pos]); - pos = beg; + if (!converted) { + StrBufAppendBufPlain(OtherHeaders, beg, end - beg, 0); + StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0); } /* If we've hit the end of the message, bail out */ - if (pos > strlen(rfc822)) done = 1; + if (pos >= totalend) + alldone = 1; } + StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0); + if (pos < totalend) + StrBufAppendBufPlain(OtherHeaders, pos, totalend - pos, 0); + FreeStrBuf(rfc822); + CM_SetAsFieldSB(msg, eMesageText, &OtherHeaders); /* Follow-up sanity checks... */ /* If there's no timestamp on this message, set it to now. */ - if (msg->cm_fields['T'] == NULL) { - snprintf(buf, sizeof buf, "%ld", (long)time(NULL)); - msg->cm_fields['T'] = strdup(buf); + if (CM_IsEmpty(msg, eTimestamp)) { + CM_SetFieldLONG(msg, eTimestamp, time(NULL)); } /* If a W (references, or rather, Wefewences) field is present, we * have to convert it from RFC822 format to Citadel format. */ - if (msg->cm_fields['W'] != NULL) { - convert_references_to_wefewences(msg->cm_fields['W']); + if (!CM_IsEmpty(msg, eWeferences)) { + /// todo: API! + convert_references_to_wefewences(msg->cm_fields[eWeferences]); } return msg; } - /* * 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 @@ -803,11 +1334,11 @@ struct CtdlMessage *convert_internet_message(char *rfc822) { * The caller is responsible for freeing the returned buffer. If the requested * field is not present, or anything else goes wrong, it returns NULL. */ -char *rfc822_fetch_field(char *rfc822, char *fieldname) { +char *rfc822_fetch_field(const char *rfc822, const char *fieldname) { char *fieldbuf = NULL; - char *end_of_headers; - char *field_start; - char *ptr; + const char *end_of_headers; + const char *field_start; + const char *ptr; char *cont; char fieldhdr[SIZ]; @@ -818,13 +1349,13 @@ char *rfc822_fetch_field(char *rfc822, char *fieldname) { snprintf(fieldhdr, sizeof fieldhdr, "%s:", fieldname); /* Locate the end of the headers, so we don't run past that point */ - end_of_headers = bmstrcasestr(rfc822, "\n\r\n"); + end_of_headers = cbmstrcasestr(rfc822, "\n\r\n"); if (end_of_headers == NULL) { - end_of_headers = bmstrcasestr(rfc822, "\n\n"); + end_of_headers = cbmstrcasestr(rfc822, "\n\n"); } if (end_of_headers == NULL) return (NULL); - field_start = bmstrcasestr(rfc822, fieldhdr); + field_start = cbmstrcasestr(rfc822, fieldhdr); if (field_start == NULL) return(NULL); if (field_start > end_of_headers) return(NULL); @@ -832,11 +1363,11 @@ char *rfc822_fetch_field(char *rfc822, char *fieldname) { strcpy(fieldbuf, ""); ptr = field_start; - ptr = memreadline(ptr, fieldbuf, SIZ-strlen(fieldbuf) ); + ptr = cmemreadline(ptr, fieldbuf, SIZ-strlen(fieldbuf) ); while ( (isspace(ptr[0])) && (ptr < end_of_headers) ) { strcat(fieldbuf, " "); cont = &fieldbuf[strlen(fieldbuf)]; - ptr = memreadline(ptr, cont, SIZ-strlen(fieldbuf) ); + ptr = cmemreadline(ptr, cont, SIZ-strlen(fieldbuf) ); striplt(cont); } @@ -847,7 +1378,6 @@ char *rfc822_fetch_field(char *rfc822, char *fieldname) { } - /***************************************************************************** * DIRECTORY MANAGEMENT FUNCTIONS * *****************************************************************************/ @@ -867,13 +1397,12 @@ void directory_key(char *key, char *addr) { } key[keylen++] = 0; - CtdlLogPrintf(CTDL_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]; @@ -887,7 +1416,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 { @@ -896,28 +1425,19 @@ 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 */ -void CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) { +int CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) { char key[SIZ]; - CtdlLogPrintf(CTDL_DEBUG, "Dir: %s --> %s\n", - internet_addr, citadel_addr); - if (IsDirectory(internet_addr, 0) == 0) return; - + if (IsDirectory(internet_addr, 0) == 0) { + return 0; + } + 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 ); + cdb_store(CDB_DIRECTORY, key, strlen(key), citadel_addr, strlen(citadel_addr)+1 ); + return 1; } @@ -927,11 +1447,12 @@ void CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) { * (NOTE: we don't actually use or need the citadel_addr variable; it's merely * here because the callback API expects to be able to send it.) */ -void CtdlDirectoryDelUser(char *internet_addr, char *citadel_addr) { +int CtdlDirectoryDelUser(char *internet_addr, char *citadel_addr) { char key[SIZ]; - + + syslog(LOG_DEBUG, "internet_addressing: delete directory entry: %s --> %s", internet_addr, citadel_addr); directory_key(key, internet_addr); - cdb_delete(CDB_DIRECTORY, key, strlen(key) ); + return cdb_delete(CDB_DIRECTORY, key, strlen(key) ) == 0; } @@ -945,7 +1466,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); @@ -956,7 +1479,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); } @@ -975,20 +1500,20 @@ char *harvest_collected_addresses(struct CtdlMessage *msg) { char user[256], node[256], name[256]; int is_harvestable; int i, j, h; - int field = 0; + eMsgField field = 0; if (msg == NULL) return(NULL); is_harvestable = 1; strcpy(addr, ""); - if (msg->cm_fields['A'] != NULL) { - strcat(addr, msg->cm_fields['A']); + if (!CM_IsEmpty(msg, eAuthor)) { + strcat(addr, msg->cm_fields[eAuthor]); } - if (msg->cm_fields['F'] != NULL) { + if (!CM_IsEmpty(msg, erFc822Addr)) { strcat(addr, " <"); - strcat(addr, msg->cm_fields['F']); + strcat(addr, msg->cm_fields[erFc822Addr]); strcat(addr, ">"); - if (IsDirectory(msg->cm_fields['F'], 0)) { + if (IsDirectory(msg->cm_fields[erFc822Addr], 0)) { is_harvestable = 0; } } @@ -1004,17 +1529,17 @@ char *harvest_collected_addresses(struct CtdlMessage *msg) { /* Scan both the R (To) and Y (CC) fields */ for (i = 0; i < 2; ++i) { - if (i == 0) field = 'R' ; - if (i == 1) field = 'Y' ; + if (i == 0) field = eRecipient; + if (i == 1) field = eCarbonCopY; - if (msg->cm_fields[field] != NULL) { + if (!CM_IsEmpty(msg, field)) { for (j=0; jcm_fields[field], ','); ++j) { extract_token(addr, msg->cm_fields[field], j, ',', sizeof addr); if (strstr(addr, "=?") != NULL) 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)) { @@ -1033,3 +1558,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 to <%s>", usbuf.fullname, new_emailaddrs); + + /* Delete all of the existing directory index records for the user (easier this way) */ + for (i=0; ifullname, 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); +}