/*
* rfc822.c -- code for slicing and dicing RFC822 mail headers
*
- * Copyright 1996 by Eric S. Raymond
- * All rights reserved.
+ * Copyright 1997 by Eric S. Raymond
* For license terms, see the file COPYING in this directory.
*/
#include <stdlib.h>
#endif
+#include "config.h"
#include "fetchmail.h"
+#include "i18n.h"
#define HEADER_END(p) ((p)[0] == '\n' && ((p)[1] != ' ' && (p)[1] != '\t'))
#ifdef TESTMAIN
static int verbose;
+char *program_name = "rfc822";
#endif /* TESTMAIN */
-void reply_hack(buf, host)
+unsigned char *reply_hack(buf, host)
/* hack message headers so replies will work properly */
-char *buf; /* header to be hacked */
-const char *host; /* server hostname */
+unsigned char *buf; /* header to be hacked */
+const unsigned char *host; /* server hostname */
{
- char *from, *cp;
- int parendepth, state, has_host_part;
-
- if (strncmp("From: ", buf, 6)
- && strncmp("To: ", buf, 4)
- && strncmp("Reply-", buf, 6)
- && strncmp("Cc: ", buf, 4)
- && strncmp("Bcc: ", buf, 5)) {
- return;
+ unsigned char *from, *cp, last_nws = '\0', *parens_from = NULL;
+ int parendepth, state, has_bare_name_part, has_host_part;
+#ifndef TESTMAIN
+ int addresscount = 1;
+#endif /* TESTMAIN */
+
+ if (strncasecmp("From:", buf, 5)
+ && strncasecmp("To:", buf, 3)
+ && strncasecmp("Reply-To:", buf, 9)
+ && strncasecmp("Return-Path:", buf, 12)
+ && strncasecmp("Cc:", buf, 3)
+ && strncasecmp("Bcc:", buf, 4)
+ && strncasecmp("Resent-From:", buf, 12)
+ && strncasecmp("Resent-To:", buf, 10)
+ && strncasecmp("Resent-Cc:", buf, 10)
+ && strncasecmp("Resent-Bcc:", buf, 11)
+ && strncasecmp("Apparently-From:", buf, 16)
+ && strncasecmp("Apparently-To:", buf, 14)
+ && strncasecmp("Sender:", buf, 7)
+ && strncasecmp("Resent-Sender:", buf, 14)
+ ) {
+ return(buf);
}
+#ifndef TESTMAIN
+ if (outlevel >= O_DEBUG)
+ report_build(stdout, _("About to rewrite %s"), buf);
+
+ /* make room to hack the address; buf must be malloced */
+ for (cp = buf; *cp; cp++)
+ if (*cp == ',' || isspace(*cp))
+ addresscount++;
+ buf = (unsigned char *)xrealloc(buf, strlen(buf) + addresscount * strlen(host) + 1);
+#endif /* TESTMAIN */
+
+ /*
+ * This is going to foo up on some ill-formed addresses.
+ * Note that we don't rewrite the fake address <> in order to
+ * avoid screwing up bounce suppression with a null Return-Path.
+ */
+
parendepth = state = 0;
- has_host_part = FALSE;
+ has_host_part = has_bare_name_part = FALSE;
for (from = buf; *from; from++)
{
#ifdef TESTMAIN
}
#endif /* TESTMAIN */
if (state != 2)
+ {
if (*from == '(')
++parendepth;
else if (*from == ')')
--parendepth;
+ }
if (!parendepth && !has_host_part)
switch (state)
break;
case 1: /* we've seen the colon, we're looking for addresses */
+ if (!isspace(*from))
+ last_nws = *from;
if (*from == '<')
state = 3;
else if (*from == '@')
has_host_part = TRUE;
else if (*from == '"')
state = 2;
- else if ((*from == ',' || HEADER_END(from)) && !has_host_part)
+ /*
+ * Not expanding on last non-WS == ';' deals with groupnames,
+ * an obscure misfeature described in sections
+ * 6.1, 6.2.6, and A.1.5 of the RFC822 standard.
+ */
+ else if ((*from == ',' || HEADER_END(from))
+ && has_bare_name_part
+ && !has_host_part
+ && last_nws != ';')
{
int hostlen;
+ unsigned char *p;
- while (isspace(*from))
+ p = from;
+ if (parens_from)
+ from = parens_from;
+ while (isspace(*from) || (*from == ','))
--from;
from++;
hostlen = strlen(host);
cp[hostlen+1] = *cp;
*from++ = '@';
memcpy(from, host, hostlen);
- from += strlen(from);
+ from = p + hostlen + 1;
has_host_part = TRUE;
- }
+ }
+ else if (from[1] == '('
+ && has_bare_name_part
+ && !has_host_part
+ && last_nws != ';' && last_nws != ')')
+ {
+ parens_from = from;
+ }
+ else if (!isspace(*from))
+ has_bare_name_part = TRUE;
break;
case 2: /* we're in a string */
case 3: /* we're in a <>-enclosed address */
if (*from == '@')
has_host_part = TRUE;
- else if (*from == '>' && !has_host_part)
+ else if (*from == '>' && from[-1] != '<')
{
- int hostlen;
-
- hostlen = strlen(host);
- for (cp = from + strlen(from); cp >= from; --cp)
- cp[hostlen+1] = *cp;
- *from++ = '@';
- memcpy(from, host, hostlen);
- from += strlen(from);
- has_host_part = TRUE;
+ state = 1;
+ if (!has_host_part)
+ {
+ int hostlen;
+
+ hostlen = strlen(host);
+ for (cp = from + strlen(from); cp >= from; --cp)
+ cp[hostlen+1] = *cp;
+ *from++ = '@';
+ memcpy(from, host, hostlen);
+ from += hostlen;
+ has_host_part = TRUE;
+ }
}
break;
}
+
+ /*
+ * If we passed a comma, reset everything.
+ */
+ if (from[-1] == ',' && !parendepth) {
+ has_host_part = has_bare_name_part = FALSE;
+ parens_from = NULL;
+ }
}
+
+#ifndef TESTMAIN
+ if (outlevel >= O_DEBUG)
+ report_complete(stdout, _("Rewritten version is %s\n"), buf);
+#endif /* TESTMAIN */
+ return(buf);
}
-char *nxtaddr(hdr)
+unsigned char *nxtaddr(hdr)
/* parse addresses in succession out of a specified RFC822 header */
-const char *hdr; /* header to be parsed, NUL to continue previous hdr */
+const unsigned char *hdr; /* header to be parsed, NUL to continue previous hdr */
{
- static char *tp, address[POPBUFSIZE+1];
- static const char *hp;
+ static unsigned char *tp, address[POPBUFSIZE+1];
+ static const unsigned char *hp;
static int state, oldstate;
#ifdef TESTMAIN
- static const char *orighdr;
+ static const unsigned char *orighdr;
#endif /* TESTMAIN */
- int parendepth;
+ int parendepth = 0;
#define START_HDR 0 /* before header colon */
#define SKIP_JUNK 1 /* skip whitespace, \n, and junk */
#ifdef TESTMAIN
orighdr = hdr;
#endif /* TESTMAIN */
+ tp = address;
}
for (; *hp; hp++)
else if (HEADER_END(hp))
{
state = ENDIT_ALL;
- while (isspace(*--tp))
- continue;
- *++tp = '\0';
- return(tp > address ? (tp = address) : (char *)NULL);
+ if (tp > address)
+ {
+ while (isspace(*--tp))
+ continue;
+ *++tp = '\0';
+ }
+ return(tp > address ? (tp = address) : (unsigned char *)NULL);
}
else if (*hp == '\\') /* handle RFC822 escaping */
{
- *tp++ = *hp++; /* take the escape */
- *tp++ = *hp; /* take following char */
+ if (state != INSIDE_PARENS)
+ {
+ *tp++ = *hp++; /* take the escape */
+ *tp++ = *hp; /* take following unsigned char */
+ }
}
else switch (state)
{
case START_HDR: /* before header colon */
if (*hp == ':')
- {
state = SKIP_JUNK;
- tp = address;
- }
break;
case SKIP_JUNK: /* looking for address start */
else if (*hp == '(') /* address comment -- ignore */
{
parendepth = 1;
+ oldstate = SKIP_JUNK;
state = INSIDE_PARENS;
}
else if (*hp == '<') /* begin <address> */
else if (*hp == '(') /* beginning of comment */
{
parendepth = 1;
+ oldstate = BARE_ADDRESS;
state = INSIDE_PARENS;
}
else if (*hp == '<') /* beginning of real address */
else if (*hp == ')')
--parendepth;
if (parendepth == 0)
- state = SKIP_JUNK;
+ state = oldstate;
break;
case INSIDE_BRACKETS: /* possible <>-enclosed address */
}
#ifdef TESTMAIN
-static void parsebuf(char *longbuf, int reply)
+static void parsebuf(unsigned char *longbuf, int reply)
{
- char *cp;
+ unsigned char *cp;
if (reply)
{
printf("Rewritten buffer: %s", longbuf);
}
else
- if ((cp = nxtaddr(longbuf)) != (char *)NULL)
+ if ((cp = nxtaddr(longbuf)) != (unsigned char *)NULL)
do {
printf("\t-> \"%s\"\n", cp);
} while
- ((cp = nxtaddr((char *)NULL)) != (char *)NULL);
+ ((cp = nxtaddr((unsigned char *)NULL)) != (unsigned char *)NULL);
}
main(int argc, char *argv[])
{
- char buf[MSGBUFSIZE], longbuf[BUFSIZ];
- int ch, reply;
+ unsigned char buf[MSGBUFSIZE], longbuf[BUFSIZ];
+ int ch, reply;
verbose = reply = FALSE;
while ((ch = getopt(argc, argv, "rv")) != EOF)
{
if (buf[0] == ' ' || buf[0] == '\t')
strcat(longbuf, buf);
- else if (!strncmp("From: ", buf, 6)
- || !strncmp("To: ", buf, 4)
- || !strncmp("Reply-", buf, 6)
- || !strncmp("Cc: ", buf, 4)
- || !strncmp("Bcc: ", buf, 5))
+ else if (!strncasecmp("From: ", buf, 6)
+ || !strncasecmp("To: ", buf, 4)
+ || !strncasecmp("Reply-", buf, 6)
+ || !strncasecmp("Cc: ", buf, 4)
+ || !strncasecmp("Bcc: ", buf, 5))
strcpy(longbuf, buf);
else if (longbuf[0])
{
projects / ~andy / fetchmail / blobdiff