#include <sys/wait.h>
#include <string.h>
#include <limits.h>
+#include <libcitadel.h>
#include "citadel.h"
#include "server.h"
-#include "serv_extensions.h"
#include "sysdep_decls.h"
#include "citserver.h"
#include "support.h"
#include "config.h"
-#include "tools.h"
#include "msgbase.h"
#include "internet_addressing.h"
#include "user_ops.h"
#endif
+#ifdef HAVE_ICONV
+#include <iconv.h>
+
+/*
+ * 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 */
+inline void FindNextEnd (char *bptr, char *end)
+{
+ /* Find the next ?Q? */
+ end = strchr(bptr + 2, '?');
+ if (end == NULL) return NULL;
+ if (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) &&
+ (*(end + 2) == '?')) {
+ /* skip on to the end of the cluster, the next ?= */
+ end = strstr(end + 3, "?=");
+ }
+ else
+ /* sort of half valid encoding, try to find an end. */
+ end = strstr(bptr, "?=");
+}
+#endif
+
+#define FindNextEnd(bptr, end) { \
+ end = strchr(bptr + 2, '?'); \
+ if (end != NULL) { \
+ if (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) && (*(end + 2) == '?')) { \
+ end = strstr(end + 3, "?="); \
+ } else end = strstr(bptr, "?="); \
+ } \
+}
+
+/*
+ * Handle subjects with RFC2047 encoding such as:
+ * =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
+ */
+void utf8ify_rfc822_string(char *buf) {
+ char *start, *end, *next, *nextend, *ptr;
+ char newbuf[1024];
+ char charset[128];
+ 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 */
+ 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.
+ */
+ 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.
+ }
+ }
+ 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);
+ if (ic != (iconv_t)(-1) ) {
+ ibuf = malloc(1024);
+ isav = ibuf;
+ safestrncpy(ibuf, buf, 1024);
+ ibuflen = strlen(ibuf);
+ obuflen = 1024;
+ obuf = (char *) malloc(obuflen);
+ osav = obuf;
+ iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
+ osav[1024-obuflen] = 0;
+ strcpy(buf, osav);
+ free(osav);
+ iconv_close(ic);
+ free(isav);
+ }
+ }
+ }
+
+ /* pre evaluate the first pair */
+ nextend = end = NULL;
+ len = strlen(buf);
+ start = strstr(buf, "=?");
+ if (start != NULL)
+ FindNextEnd (start, end);
+
+ while ((start != NULL) && (end != NULL))
+ {
+ next = strstr(end, "=?");
+ if (next != NULL)
+ FindNextEnd(next, nextend);
+ if (nextend == NULL)
+ next = NULL;
+
+ /* did we find two partitions */
+ if ((next != NULL) &&
+ ((next - end) > 2))
+ {
+ ptr = end + 2;
+ while ((ptr < next) &&
+ (isspace(*ptr) ||
+ (*ptr == '\r') ||
+ (*ptr == '\n') ||
+ (*ptr == '\t')))
+ ptr ++;
+ /* did we find a gab just filled with blanks? */
+ if (ptr == next)
+ {
+ memmove (end + 2,
+ next,
+ len - (next - start));
+
+ /* now terminate the gab at the end */
+ delta = (next - end) - 2;
+ len -= delta;
+ buf[len] = '\0';
+
+ /* move next to its new location. */
+ next -= delta;
+ nextend -= delta;
+ }
+ }
+ /* our next-pair is our new first pair now. */
+ start = next;
+ end = nextend;
+ }
+
+ /* 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)
+ {
+ 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 */
+ ibuflen = CtdlDecodeBase64(ibuf, istr, strlen(istr));
+ }
+ else if (!strcasecmp(encoding, "Q")) { /**< quoted-printable */
+ size_t len;
+ long pos;
+
+ len = strlen(istr);
+ pos = 0;
+ while (pos < len)
+ {
+ if (istr[pos] == '_') istr[pos] = ' ';
+ pos++;
+ }
+
+ ibuflen = CtdlDecodeQuotedPrintable(ibuf, istr, len);
+ }
+ else {
+ strcpy(ibuf, istr); /**< unknown encoding */
+ ibuflen = strlen(istr);
+ }
+
+ ic = ctdl_iconv_open("UTF-8", charset);
+ if (ic != (iconv_t)(-1) ) {
+ obuflen = 1024;
+ obuf = (char *) malloc(obuflen);
+ osav = obuf;
+ iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
+ osav[1024-obuflen] = 0;
+
+ end = start;
+ end++;
+ strcpy(start, "");
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ strcpy(end, &end[1]);
+
+ snprintf(newbuf, sizeof newbuf, "%s%s%s", buf, osav, end);
+ strcpy(buf, newbuf);
+ free(osav);
+ iconv_close(ic);
+ }
+ else {
+ end = start;
+ end++;
+ strcpy(start, "");
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ remove_token(end, 0, '?');
+ strcpy(end, &end[1]);
+
+ snprintf(newbuf, sizeof newbuf, "%s(unreadable)%s", buf, end);
+ strcpy(buf, newbuf);
+ }
+
+ free(isav);
+
+ /*
+ * Since spammers will go to all sorts of absurd lengths to get their
+ * messages through, there are LOTS of corrupt headers out there.
+ * So, prevent a really badly formed RFC2047 header from throwing
+ * this function into an infinite loop.
+ */
+ ++passes;
+ if (passes > 20) return;
+
+ start = strstr(buf, "=?");
+ FindNextEnd((start != NULL)? start : buf, end);
+ }
+
+}
+#else
+inline void utf8ify_rfc822_string(char *a){};
+
+#endif
+
+
+
struct trynamebuf {
char buffer1[SIZ];
char buffer2[SIZ];
char host[256], type[256];
if (fqdn == NULL) return(hostalias_nomatch);
- if (strlen(fqdn) == 0) 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);
&& (!strcasecmp(fqdn, host)))
return(hostalias_localhost);
- if ( (!strcasecmp(type, "gatewaydomain"))
- && (!strcasecmp(&fqdn[strlen(fqdn)-strlen(host)], host)))
- return(hostalias_gatewaydomain);
-
if ( (!strcasecmp(type, "directory"))
- && (!strcasecmp(&fqdn[strlen(fqdn)-strlen(host)], host)))
+ && (!strcasecmp(fqdn, host)))
return(hostalias_directory);
if ( (!strcasecmp(type, "masqdomain"))
- && (!strcasecmp(&fqdn[strlen(fqdn)-strlen(host)], host)))
+ && (!strcasecmp(fqdn, host)))
return(hostalias_masq);
}
*/
int fuzzy_match(struct ctdluser *us, char *matchstring) {
int a;
+ long len;
if ( (!strncasecmp(matchstring, "cit", 3))
&& (atol(&matchstring[3]) == us->usernum)) {
return 0;
}
-
- for (a=0; a<strlen(us->fullname); ++a) {
+ len = strlen(matchstring);
+ for (a=0; !IsEmptyStr(&us->fullname[a]); ++a) {
if (!strncasecmp(&us->fullname[a],
- matchstring, strlen(matchstring))) {
+ matchstring, len)) {
return 0;
}
}
stripout(name, '<', '>');
/* strip anything to the left of a bang */
- while ((strlen(name) > 0) && (haschar(name, '!') > 0))
+ while ((!IsEmptyStr(name)) && (haschar(name, '!') > 0))
strcpy(name, &name[1]);
/* and anything to the right of a @ or % */
/* but if there are a set of quotes, that supersedes everything */
if (haschar(rfc822, 34) == 2) {
strcpy(name, rfc822);
- while ((strlen(name) > 0) && (name[0] != 34)) {
+ while ((!IsEmptyStr(name)) && (name[0] != 34)) {
strcpy(&name[0], &name[1]);
}
strcpy(&name[0], &name[1]);
}
/* strip anything to the left of a bang */
- while ((strlen(user) > 0) && (haschar(user, '!') > 0))
+ while ((!IsEmptyStr(user)) && (haschar(user, '!') > 0))
strcpy(user, &user[1]);
/* and anything to the right of a @ or % */
else {
/* strip anything to the left of a @ */
- while ((strlen(node) > 0) && (haschar(node, '@') > 0))
+ while ((!IsEmptyStr(node)) && (haschar(node, '@') > 0))
strcpy(node, &node[1]);
/* strip anything to the left of a % */
- while ((strlen(node) > 0) && (haschar(node, '%') > 0))
+ while ((!IsEmptyStr(node)) && (haschar(node, '%') > 0))
strcpy(node, &node[1]);
/* reduce multiple system bang paths to node!user */
- while ((strlen(node) > 0) && (haschar(node, '!') > 1))
+ while ((!IsEmptyStr(node)) && (haschar(node, '!') > 1))
strcpy(node, &node[1]);
/* now get rid of the user portion of a node!user string */
* but no name outside the brackets, we now have an empty name. In
* this case, use the user portion of the address as the name.
*/
- if ((strlen(name) == 0) && (strlen(user) > 0)) {
+ if ((IsEmptyStr(name)) && (!IsEmptyStr(user))) {
strcpy(name, user);
}
}
else if (!strcasecmp(key, "From")) {
process_rfc822_addr(value, user, node, name);
- lprintf(CTDL_DEBUG, "Converted to <%s@%s> (%s)\n", 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;
}
+ else if (!strcasecmp(key, "List-ID")) {
+ if (msg->cm_fields['L'] == NULL)
+ msg->cm_fields['L'] = strdup(value);
+ processed = 1;
+ }
+
else if (!strcasecmp(key, "To")) {
if (msg->cm_fields['R'] == NULL)
msg->cm_fields['R'] = strdup(value);
else if (!strcasecmp(key, "Message-ID")) {
if (msg->cm_fields['I'] != NULL) {
- lprintf(CTDL_WARNING, "duplicate message id\n");
+ CtdlLogPrintf(CTDL_WARNING, "duplicate message id\n");
}
if (msg->cm_fields['I'] == NULL) {
processed = 1;
}
+ else if (!strcasecmp(key, "References")) {
+ if (msg->cm_fields['W'] != NULL) {
+ free(msg->cm_fields['W']);
+ }
+ msg->cm_fields['W'] = strdup(value);
+ 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);
+ }
+ processed = 1;
+ }
+
+
+
/* Clean up and move on. */
free(key); /* Don't free 'value', it's actually the same buffer */
return(processed);
}
+/*
+ * Convert RFC822 references format (References) to Citadel references format (Weferences)
+ */
+void convert_references_to_wefewences(char *str) {
+ int bracket_nesting = 0;
+ char *ptr = str;
+ char *moveptr = NULL;
+ char ch;
+
+ while(*ptr) {
+ ch = *ptr;
+ if (ch == '>') {
+ --bracket_nesting;
+ if (bracket_nesting < 0) bracket_nesting = 0;
+ }
+ if ((ch == '>') && (bracket_nesting == 0) && (*(ptr+1)) && (ptr>str) ) {
+ *ptr = '|';
+ ++ptr;
+ }
+ else if (bracket_nesting > 0) {
+ ++ptr;
+ }
+ else {
+ moveptr = ptr;
+ while (*moveptr) {
+ *moveptr = *(moveptr+1);
+ ++moveptr;
+ }
+ }
+ if (ch == '<') ++bracket_nesting;
+ }
+
+}
+
+
/*
* Convert an RFC822 message (headers + body) to a CtdlMessage structure.
* NOTE: the supplied buffer becomes part of the CtdlMessage structure, and
msg->cm_fields['T'] = strdup(buf);
}
+ /* 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']);
+ }
+
return msg;
}
int i;
int keylen = 0;
- for (i=0; i<strlen(addr); ++i) {
+ for (i=0; !IsEmptyStr(&addr[i]); ++i) {
if (!isspace(addr[i])) {
key[keylen++] = tolower(addr[i]);
}
}
key[keylen++] = 0;
- lprintf(CTDL_DEBUG, "Directory key is <%s>\n", key);
+ CtdlLogPrintf(CTDL_DEBUG, "Directory key is <%s>\n", key);
}
void CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) {
char key[SIZ];
- lprintf(CTDL_DEBUG, "Dir: %s --> %s\n",
+ CtdlLogPrintf(CTDL_DEBUG, "Dir: %s --> %s\n",
internet_addr, citadel_addr);
if (IsDirectory(internet_addr, 0) == 0) return;
if (msg->cm_fields[field] != NULL) {
for (j=0; j<num_tokens(msg->cm_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) ) {
coll = realloc(coll, strlen(coll) + strlen(addr) + 4);
if (coll == NULL) return(NULL);
- if (strlen(coll) > 0) {
+ if (!IsEmptyStr(coll)) {
strcat(coll, ",");
}
striplt(addr);
}
}
- if (strlen(coll) == 0) {
+ if (IsEmptyStr(coll)) {
free(coll);
return(NULL);
}