mirror of
https://github.com/freebsd/freebsd-src
synced 2024-07-23 11:16:33 +00:00
2435 lines
52 KiB
C
2435 lines
52 KiB
C
/*
|
|
* Copyright (c) 1998-2004, 2006, 2007 Proofpoint, Inc. and its suppliers.
|
|
* All rights reserved.
|
|
* Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
|
|
* Copyright (c) 1988, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* By using this file, you agree to the terms and conditions set
|
|
* forth in the LICENSE file which can be found at the top level of
|
|
* the sendmail distribution.
|
|
*
|
|
*/
|
|
|
|
#include <sendmail.h>
|
|
#include <sm/sendmail.h>
|
|
#include <sm/ixlen.h>
|
|
|
|
SM_RCSID("@(#)$Id: headers.c,v 8.320 2013-11-22 20:51:55 ca Exp $")
|
|
|
|
static HDR *allocheader __P((char *, char *, int, SM_RPOOL_T *, bool));
|
|
static size_t fix_mime_header __P((HDR *, ENVELOPE *));
|
|
static int priencode __P((char *));
|
|
static bool put_vanilla_header __P((HDR *, char *, MCI *));
|
|
|
|
/*
|
|
** SETUPHEADERS -- initialize headers in symbol table
|
|
**
|
|
** Parameters:
|
|
** none
|
|
**
|
|
** Returns:
|
|
** none
|
|
*/
|
|
|
|
void
|
|
setupheaders()
|
|
{
|
|
struct hdrinfo *hi;
|
|
STAB *s;
|
|
|
|
for (hi = HdrInfo; hi->hi_field != NULL; hi++)
|
|
{
|
|
s = stab(hi->hi_field, ST_HEADER, ST_ENTER);
|
|
s->s_header.hi_flags = hi->hi_flags;
|
|
s->s_header.hi_ruleset = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** DOCHOMPHEADER -- process and save a header line.
|
|
**
|
|
** Called by chompheader.
|
|
**
|
|
** Parameters:
|
|
** line -- header as a text line.
|
|
** pflag -- flags for chompheader() (from sendmail.h)
|
|
** hdrp -- a pointer to the place to save the header.
|
|
** e -- the envelope including this header.
|
|
**
|
|
** Returns:
|
|
** flags for this header.
|
|
**
|
|
** Side Effects:
|
|
** The header is saved on the header list.
|
|
** Contents of 'line' are destroyed.
|
|
*/
|
|
|
|
static struct hdrinfo NormalHeader = { NULL, 0, NULL };
|
|
static unsigned long dochompheader __P((char *, int, HDR **, ENVELOPE *));
|
|
|
|
static unsigned long
|
|
dochompheader(line, pflag, hdrp, e)
|
|
char *line;
|
|
int pflag;
|
|
HDR **hdrp;
|
|
ENVELOPE *e;
|
|
{
|
|
unsigned char mid = '\0';
|
|
register char *p;
|
|
register HDR *h;
|
|
HDR **hp;
|
|
char *fname;
|
|
char *fvalue;
|
|
bool cond = false;
|
|
bool dropfrom;
|
|
bool headeronly;
|
|
STAB *s;
|
|
struct hdrinfo *hi;
|
|
bool nullheader = false;
|
|
BITMAP256 mopts;
|
|
|
|
headeronly = hdrp != NULL;
|
|
if (!headeronly)
|
|
hdrp = &e->e_header;
|
|
|
|
/* strip off options */
|
|
clrbitmap(mopts);
|
|
p = line;
|
|
if (!bitset(pflag, CHHDR_USER) && *p == '?')
|
|
{
|
|
int c;
|
|
register char *q;
|
|
|
|
q = strchr(++p, '?');
|
|
if (q == NULL)
|
|
goto hse;
|
|
|
|
*q = '\0';
|
|
c = *p & 0377;
|
|
|
|
/* possibly macro conditional */
|
|
if (c == MACROEXPAND)
|
|
{
|
|
/* catch ?$? */
|
|
if (*++p == '\0')
|
|
{
|
|
*q = '?';
|
|
goto hse;
|
|
}
|
|
|
|
mid = (unsigned char) *p++;
|
|
|
|
/* catch ?$abc? */
|
|
if (*p != '\0')
|
|
{
|
|
*q = '?';
|
|
goto hse;
|
|
}
|
|
}
|
|
else if (*p == '$')
|
|
{
|
|
/* catch ?$? */
|
|
if (*++p == '\0')
|
|
{
|
|
*q = '?';
|
|
goto hse;
|
|
}
|
|
|
|
mid = (unsigned char) macid(p);
|
|
if (bitset(0200, mid))
|
|
{
|
|
p += strlen(macname(mid)) + 2;
|
|
SM_ASSERT(p <= q);
|
|
}
|
|
else
|
|
p++;
|
|
|
|
/* catch ?$abc? */
|
|
if (*p != '\0')
|
|
{
|
|
*q = '?';
|
|
goto hse;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (*p != '\0')
|
|
{
|
|
if (!isascii(*p))
|
|
{
|
|
*q = '?';
|
|
goto hse;
|
|
}
|
|
|
|
setbitn(bitidx(*p), mopts);
|
|
cond = true;
|
|
p++;
|
|
}
|
|
}
|
|
p = q + 1;
|
|
}
|
|
|
|
/* find canonical name */
|
|
fname = p;
|
|
while (isascii(*p) && isgraph(*p) && *p != ':')
|
|
p++;
|
|
fvalue = p;
|
|
while (SM_ISSPACE(*p))
|
|
p++;
|
|
if (*p++ != ':' || fname == fvalue)
|
|
{
|
|
hse:
|
|
syserr("553 5.3.0 header syntax error, line \"%s\"", line);
|
|
return 0;
|
|
}
|
|
*fvalue = '\0';
|
|
fvalue = p;
|
|
|
|
/* if the field is null, go ahead and use the default */
|
|
while (SM_ISSPACE(*p))
|
|
p++;
|
|
if (*p == '\0')
|
|
nullheader = true;
|
|
|
|
/* security scan: long field names are end-of-header */
|
|
if (strlen(fname) > 100)
|
|
return H_EOH;
|
|
|
|
/* check to see if it represents a ruleset call */
|
|
if (bitset(pflag, CHHDR_DEF))
|
|
{
|
|
char hbuf[50];
|
|
|
|
(void) expand(fvalue, hbuf, sizeof(hbuf), e);
|
|
for (p = hbuf; SM_ISSPACE(*p); )
|
|
p++;
|
|
if ((*p++ & 0377) == CALLSUBR)
|
|
{
|
|
auto char *endp;
|
|
bool strc;
|
|
|
|
strc = *p == '+'; /* strip comments? */
|
|
if (strc)
|
|
++p;
|
|
if (strtorwset(p, &endp, ST_ENTER) > 0)
|
|
{
|
|
*endp = '\0';
|
|
s = stab(fname, ST_HEADER, ST_ENTER);
|
|
if (LogLevel > 9 &&
|
|
s->s_header.hi_ruleset != NULL)
|
|
sm_syslog(LOG_WARNING, NOQID,
|
|
"Warning: redefined ruleset for header=%s, old=%s, new=%s",
|
|
fname,
|
|
s->s_header.hi_ruleset, p);
|
|
s->s_header.hi_ruleset = newstr(p);
|
|
if (!strc)
|
|
s->s_header.hi_flags |= H_STRIPCOMM;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* see if it is a known type */
|
|
s = stab(fname, ST_HEADER, ST_FIND);
|
|
if (s != NULL)
|
|
hi = &s->s_header;
|
|
else
|
|
hi = &NormalHeader;
|
|
|
|
if (tTd(31, 9))
|
|
{
|
|
if (s == NULL)
|
|
sm_dprintf("no header flags match\n");
|
|
else
|
|
sm_dprintf("header match, flags=%lx, ruleset=%s\n",
|
|
hi->hi_flags,
|
|
hi->hi_ruleset == NULL ? "<NULL>"
|
|
: hi->hi_ruleset);
|
|
}
|
|
|
|
/* see if this is a resent message */
|
|
if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
|
|
bitset(H_RESENT, hi->hi_flags))
|
|
e->e_flags |= EF_RESENT;
|
|
|
|
/* if this is an Errors-To: header keep track of it now */
|
|
if (UseErrorsTo && !bitset(pflag, CHHDR_DEF) && !headeronly &&
|
|
bitset(H_ERRORSTO, hi->hi_flags))
|
|
(void) sendtolist(fvalue, NULLADDR, &e->e_errorqueue, 0, e);
|
|
|
|
/* if this means "end of header" quit now */
|
|
if (!headeronly && bitset(H_EOH, hi->hi_flags))
|
|
return hi->hi_flags;
|
|
|
|
/*
|
|
** Horrible hack to work around problem with Lotus Notes SMTP
|
|
** mail gateway, which generates From: headers with newlines in
|
|
** them and the <address> on the second line. Although this is
|
|
** legal RFC 822, many MUAs don't handle this properly and thus
|
|
** never find the actual address.
|
|
*/
|
|
|
|
if (bitset(H_FROM, hi->hi_flags) && SingleLineFromHeader)
|
|
{
|
|
while ((p = strchr(fvalue, '\n')) != NULL)
|
|
*p = ' ';
|
|
}
|
|
|
|
/*
|
|
** If there is a check ruleset, verify it against the header.
|
|
*/
|
|
|
|
if (bitset(pflag, CHHDR_CHECK))
|
|
{
|
|
int rscheckflags;
|
|
char *rs;
|
|
|
|
rscheckflags = RSF_COUNT;
|
|
if (!bitset(hi->hi_flags, H_FROM|H_RCPT))
|
|
rscheckflags |= RSF_UNSTRUCTURED;
|
|
|
|
/* no ruleset? look for default */
|
|
rs = hi->hi_ruleset;
|
|
if (rs == NULL)
|
|
{
|
|
s = stab("*", ST_HEADER, ST_FIND);
|
|
if (s != NULL)
|
|
{
|
|
rs = (&s->s_header)->hi_ruleset;
|
|
if (bitset((&s->s_header)->hi_flags,
|
|
H_STRIPCOMM))
|
|
rscheckflags |= RSF_RMCOMM;
|
|
}
|
|
}
|
|
else if (bitset(hi->hi_flags, H_STRIPCOMM))
|
|
rscheckflags |= RSF_RMCOMM;
|
|
if (rs != NULL)
|
|
{
|
|
int l, k;
|
|
char qval[MAXNAME_I];
|
|
XLENDECL
|
|
|
|
l = 0;
|
|
XLEN('"');
|
|
qval[l++] = '"';
|
|
|
|
/* - 3 to avoid problems with " at the end */
|
|
for (k = 0;
|
|
fvalue[k] != '\0' && l < sizeof(qval) - 3
|
|
&& xlen < MAXNAME - 3;
|
|
k++)
|
|
{
|
|
XLEN(fvalue[k]);
|
|
switch (fvalue[k])
|
|
{
|
|
/* XXX other control chars? */
|
|
case '\011': /* ht */
|
|
case '\012': /* nl */
|
|
case '\013': /* vt */
|
|
case '\014': /* np */
|
|
case '\015': /* cr */
|
|
qval[l++] = ' ';
|
|
break;
|
|
case '\\':
|
|
qval[l++] = fvalue[k];
|
|
++k;
|
|
XLEN(fvalue[k]);
|
|
qval[l++] = fvalue[k];
|
|
break;
|
|
case '"':
|
|
XLEN('\\');
|
|
qval[l++] = '\\';
|
|
/* FALLTHROUGH */
|
|
default:
|
|
qval[l++] = fvalue[k];
|
|
break;
|
|
}
|
|
}
|
|
/* just for "completeness": xlen not used afterwards */
|
|
XLEN('"');
|
|
qval[l++] = '"';
|
|
qval[l] = '\0';
|
|
l = strlen(fvalue + k);
|
|
|
|
/*
|
|
** If there is something left in fvalue
|
|
** then it has been truncated.
|
|
** Note: the log entry might not be correct
|
|
** in the EAI case: to get the "real" length
|
|
** ilenx() would have to be applied to fvalue.
|
|
*/
|
|
|
|
if (l > 0)
|
|
{
|
|
if (LogLevel > 9)
|
|
sm_syslog(LOG_WARNING, e->e_id,
|
|
"Warning: truncated header '%s' before check with '%s' len=%d max=%d",
|
|
fname, rs, xlen + l, MAXNAME);
|
|
}
|
|
macdefine(&e->e_macro, A_TEMP,
|
|
macid("{currHeader}"), qval);
|
|
macdefine(&e->e_macro, A_TEMP,
|
|
macid("{hdr_name}"), fname);
|
|
|
|
(void) sm_snprintf(qval, sizeof(qval), "%d", k);
|
|
macdefine(&e->e_macro, A_TEMP, macid("{hdrlen}"), qval);
|
|
if (bitset(H_FROM, hi->hi_flags))
|
|
macdefine(&e->e_macro, A_PERM,
|
|
macid("{addr_type}"), "h s");
|
|
else if (bitset(H_RCPT, hi->hi_flags))
|
|
macdefine(&e->e_macro, A_PERM,
|
|
macid("{addr_type}"), "h r");
|
|
else
|
|
macdefine(&e->e_macro, A_PERM,
|
|
macid("{addr_type}"), "h");
|
|
(void) rscheck(rs, fvalue, NULL, e, rscheckflags, 3,
|
|
NULL, e->e_id, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Drop explicit From: if same as what we would generate.
|
|
** This is to make MH (which doesn't always give a full name)
|
|
** insert the full name information in all circumstances.
|
|
*/
|
|
|
|
dropfrom = false;
|
|
p = "resent-from";
|
|
if (!bitset(EF_RESENT, e->e_flags))
|
|
p += 7;
|
|
if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
|
|
!bitset(EF_QUEUERUN, e->e_flags) && SM_STRCASEEQ(fname, p))
|
|
{
|
|
if (e->e_from.q_paddr != NULL &&
|
|
e->e_from.q_mailer != NULL &&
|
|
bitnset(M_LOCALMAILER, e->e_from.q_mailer->m_flags) &&
|
|
(strcmp(fvalue, e->e_from.q_paddr) == 0 ||
|
|
strcmp(fvalue, e->e_from.q_user) == 0))
|
|
dropfrom = true;
|
|
if (tTd(31, 2))
|
|
{
|
|
sm_dprintf("comparing header from (%s) against default (%s or %s), drop=%d\n",
|
|
fvalue, e->e_from.q_paddr, e->e_from.q_user,
|
|
dropfrom);
|
|
}
|
|
}
|
|
|
|
/* delete default value for this header */
|
|
for (hp = hdrp; (h = *hp) != NULL; hp = &h->h_link)
|
|
{
|
|
if (SM_STRCASEEQ(fname, h->h_field) &&
|
|
!bitset(H_USER, h->h_flags) &&
|
|
!bitset(H_FORCE, h->h_flags))
|
|
{
|
|
if (nullheader)
|
|
{
|
|
/* user-supplied value was null */
|
|
return 0;
|
|
}
|
|
if (dropfrom)
|
|
{
|
|
/* make this look like the user entered it */
|
|
h->h_flags |= H_USER;
|
|
|
|
/*
|
|
** If the MH hack is selected, allow to turn
|
|
** it off via a mailer flag to avoid problems
|
|
** with setups that remove the F flag from
|
|
** the RCPT mailer.
|
|
*/
|
|
|
|
if (bitnset(M_NOMHHACK,
|
|
e->e_from.q_mailer->m_flags))
|
|
{
|
|
h->h_flags &= ~H_CHECK;
|
|
}
|
|
return hi->hi_flags;
|
|
}
|
|
h->h_value = NULL;
|
|
if (!cond)
|
|
{
|
|
/* copy conditions from default case */
|
|
memmove((char *) mopts, (char *) h->h_mflags,
|
|
sizeof(mopts));
|
|
}
|
|
h->h_macro = mid;
|
|
}
|
|
}
|
|
|
|
/* create a new node */
|
|
h = (HDR *) sm_rpool_malloc_tagged_x(e->e_rpool, sizeof(*h), "header",
|
|
pflag, bitset(pflag, CHHDR_DEF) ? 0 : 1);
|
|
h->h_field = sm_rpool_strdup_tagged_x(e->e_rpool, fname, "h_field",
|
|
pflag, bitset(pflag, CHHDR_DEF) ? 0 : 1);
|
|
h->h_value = sm_rpool_strdup_tagged_x(e->e_rpool, fvalue, "h_value",
|
|
pflag, bitset(pflag, CHHDR_DEF) ? 0 : 1);
|
|
h->h_link = NULL;
|
|
memmove((char *) h->h_mflags, (char *) mopts, sizeof(mopts));
|
|
h->h_macro = mid;
|
|
*hp = h;
|
|
h->h_flags = hi->hi_flags;
|
|
if (bitset(pflag, CHHDR_USER) || bitset(pflag, CHHDR_QUEUE))
|
|
h->h_flags |= H_USER;
|
|
|
|
/* strip EOH flag if parsing MIME headers */
|
|
if (headeronly)
|
|
h->h_flags &= ~H_EOH;
|
|
if (bitset(pflag, CHHDR_DEF))
|
|
h->h_flags |= H_DEFAULT;
|
|
if (cond || mid != '\0')
|
|
h->h_flags |= H_CHECK;
|
|
|
|
/* hack to see if this is a new format message */
|
|
if (!bitset(pflag, CHHDR_DEF) && !headeronly &&
|
|
bitset(H_RCPT|H_FROM, h->h_flags) &&
|
|
(strchr(fvalue, ',') != NULL || strchr(fvalue, '(') != NULL ||
|
|
strchr(fvalue, '<') != NULL || strchr(fvalue, ';') != NULL))
|
|
{
|
|
e->e_flags &= ~EF_OLDSTYLE;
|
|
}
|
|
|
|
return h->h_flags;
|
|
}
|
|
|
|
/*
|
|
** CHOMPHEADER -- process and save a header line.
|
|
**
|
|
** Called by collect, readcf, and readqf to deal with header lines.
|
|
** This is just a wrapper for dochompheader().
|
|
**
|
|
** Parameters:
|
|
** line -- header as a text line.
|
|
** pflag -- flags for chompheader() (from sendmail.h)
|
|
** hdrp -- a pointer to the place to save the header.
|
|
** e -- the envelope including this header.
|
|
**
|
|
** Returns:
|
|
** flags for this header.
|
|
**
|
|
** Side Effects:
|
|
** The header is saved on the header list.
|
|
** Contents of 'line' are destroyed.
|
|
*/
|
|
|
|
unsigned long
|
|
chompheader(line, pflag, hdrp, e)
|
|
char *line;
|
|
int pflag;
|
|
HDR **hdrp;
|
|
register ENVELOPE *e;
|
|
{
|
|
unsigned long rval;
|
|
|
|
if (tTd(31, 6))
|
|
{
|
|
sm_dprintf("chompheader: ");
|
|
xputs(sm_debug_file(), line);
|
|
sm_dprintf("\n");
|
|
}
|
|
|
|
/* quote this if user (not config file) input */
|
|
if (bitset(pflag, CHHDR_USER))
|
|
{
|
|
char xbuf[MAXLINE]; /* EAI:ok; actual buffer might be greater */
|
|
char *xbp = NULL;
|
|
int xbufs;
|
|
|
|
xbufs = sizeof(xbuf);
|
|
xbp = quote_internal_chars(line, xbuf, &xbufs, NULL);
|
|
if (tTd(31, 7))
|
|
{
|
|
sm_dprintf("chompheader: quoted: ");
|
|
xputs(sm_debug_file(), xbp);
|
|
sm_dprintf("\n");
|
|
}
|
|
rval = dochompheader(xbp, pflag, hdrp, e);
|
|
if (xbp != xbuf)
|
|
sm_free(xbp);
|
|
}
|
|
else
|
|
rval = dochompheader(line, pflag, hdrp, e);
|
|
|
|
return rval;
|
|
}
|
|
|
|
/*
|
|
** ALLOCHEADER -- allocate a header entry
|
|
**
|
|
** Parameters:
|
|
** field -- the name of the header field (will not be copied).
|
|
** value -- the value of the field (will be copied).
|
|
** flags -- flags to add to h_flags.
|
|
** rp -- resource pool for allocations
|
|
** space -- add leading space?
|
|
**
|
|
** Returns:
|
|
** Pointer to a newly allocated and populated HDR.
|
|
**
|
|
** Notes:
|
|
** o field and value must be in internal format, i.e.,
|
|
** metacharacters must be "quoted", see quote_internal_chars().
|
|
** o maybe add more flags to decide:
|
|
** - what to copy (field/value)
|
|
** - whether to convert value to an internal format
|
|
*/
|
|
|
|
static HDR *
|
|
allocheader(field, value, flags, rp, space)
|
|
char *field;
|
|
char *value;
|
|
int flags;
|
|
SM_RPOOL_T *rp;
|
|
bool space;
|
|
{
|
|
HDR *h;
|
|
STAB *s;
|
|
|
|
/* find info struct */
|
|
s = stab(field, ST_HEADER, ST_FIND);
|
|
|
|
/* allocate space for new header */
|
|
h = (HDR *) sm_rpool_malloc_x(rp, sizeof(*h));
|
|
h->h_field = field;
|
|
if (space)
|
|
{
|
|
size_t l;
|
|
char *n;
|
|
|
|
l = strlen(value);
|
|
SM_ASSERT(l + 2 > l);
|
|
n = sm_rpool_malloc_x(rp, l + 2);
|
|
n[0] = ' ';
|
|
n[1] = '\0';
|
|
sm_strlcpy(n + 1, value, l + 1);
|
|
h->h_value = n;
|
|
}
|
|
else
|
|
h->h_value = sm_rpool_strdup_x(rp, value);
|
|
h->h_flags = flags;
|
|
if (s != NULL)
|
|
h->h_flags |= s->s_header.hi_flags;
|
|
clrbitmap(h->h_mflags);
|
|
h->h_macro = '\0';
|
|
|
|
return h;
|
|
}
|
|
|
|
/*
|
|
** ADDHEADER -- add a header entry to the end of the queue.
|
|
**
|
|
** This bypasses the special checking of chompheader.
|
|
**
|
|
** Parameters:
|
|
** field -- the name of the header field (will not be copied).
|
|
** value -- the value of the field (will be copied).
|
|
** flags -- flags to add to h_flags.
|
|
** e -- envelope.
|
|
** space -- add leading space?
|
|
**
|
|
** Returns:
|
|
** none.
|
|
**
|
|
** Side Effects:
|
|
** adds the field on the list of headers for this envelope.
|
|
**
|
|
** Notes: field and value must be in internal format, i.e.,
|
|
** metacharacters must be "quoted", see quote_internal_chars().
|
|
*/
|
|
|
|
void
|
|
addheader(field, value, flags, e, space)
|
|
char *field;
|
|
char *value;
|
|
int flags;
|
|
ENVELOPE *e;
|
|
bool space;
|
|
{
|
|
register HDR *h;
|
|
HDR **hp;
|
|
HDR **hdrlist = &e->e_header;
|
|
|
|
/* find current place in list -- keep back pointer? */
|
|
for (hp = hdrlist; (h = *hp) != NULL; hp = &h->h_link)
|
|
{
|
|
if (SM_STRCASEEQ(field, h->h_field))
|
|
break;
|
|
}
|
|
|
|
/* allocate space for new header */
|
|
h = allocheader(field, value, flags, e->e_rpool, space);
|
|
h->h_link = *hp;
|
|
*hp = h;
|
|
}
|
|
|
|
/*
|
|
** INSHEADER -- insert a header entry at the specified index
|
|
** This bypasses the special checking of chompheader.
|
|
**
|
|
** Parameters:
|
|
** idx -- index into the header list at which to insert
|
|
** field -- the name of the header field (will be copied).
|
|
** value -- the value of the field (will be copied).
|
|
** flags -- flags to add to h_flags.
|
|
** e -- envelope.
|
|
** space -- add leading space?
|
|
**
|
|
** Returns:
|
|
** none.
|
|
**
|
|
** Side Effects:
|
|
** inserts the field on the list of headers for this envelope.
|
|
**
|
|
** Notes:
|
|
** - field and value must be in internal format, i.e.,
|
|
** metacharacters must be "quoted", see quote_internal_chars().
|
|
** - the header list contains headers that might not be
|
|
** sent "out" (see putheader(): "skip"), hence there is no
|
|
** reliable way to insert a header at an exact position
|
|
** (except at the front or end).
|
|
*/
|
|
|
|
void
|
|
insheader(idx, field, value, flags, e, space)
|
|
int idx;
|
|
char *field;
|
|
char *value;
|
|
int flags;
|
|
ENVELOPE *e;
|
|
bool space;
|
|
{
|
|
HDR *h, *srch, *last = NULL;
|
|
|
|
/* allocate space for new header */
|
|
h = allocheader(field, value, flags, e->e_rpool, space);
|
|
|
|
/* find insertion position */
|
|
for (srch = e->e_header; srch != NULL && idx > 0;
|
|
srch = srch->h_link, idx--)
|
|
last = srch;
|
|
|
|
if (e->e_header == NULL)
|
|
{
|
|
e->e_header = h;
|
|
h->h_link = NULL;
|
|
}
|
|
else if (srch == NULL)
|
|
{
|
|
SM_ASSERT(last != NULL);
|
|
last->h_link = h;
|
|
h->h_link = NULL;
|
|
}
|
|
else
|
|
{
|
|
h->h_link = srch->h_link;
|
|
srch->h_link = h;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** HVALUE -- return value of a header.
|
|
**
|
|
** Only "real" fields (i.e., ones that have not been supplied
|
|
** as a default) are used.
|
|
**
|
|
** Parameters:
|
|
** field -- the field name.
|
|
** header -- the header list.
|
|
**
|
|
** Returns:
|
|
** pointer to the value part (internal format).
|
|
** NULL if not found.
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
*/
|
|
|
|
char *
|
|
hvalue(field, header)
|
|
char *field;
|
|
HDR *header;
|
|
{
|
|
register HDR *h;
|
|
|
|
for (h = header; h != NULL; h = h->h_link)
|
|
{
|
|
if (!bitset(H_DEFAULT, h->h_flags) &&
|
|
SM_STRCASEEQ(h->h_field, field))
|
|
{
|
|
char *s;
|
|
|
|
s = h->h_value;
|
|
if (s == NULL)
|
|
return NULL;
|
|
while (SM_ISSPACE(*s))
|
|
s++;
|
|
return s;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
** ISHEADER -- predicate telling if argument is a header.
|
|
**
|
|
** A line is a header if it has a single word followed by
|
|
** optional white space followed by a colon.
|
|
**
|
|
** Header fields beginning with two dashes, although technically
|
|
** permitted by RFC822, are automatically rejected in order
|
|
** to make MIME work out. Without this we could have a technically
|
|
** legal header such as ``--"foo:bar"'' that would also be a legal
|
|
** MIME separator.
|
|
**
|
|
** Parameters:
|
|
** h -- string to check for possible headerness.
|
|
**
|
|
** Returns:
|
|
** true if h is a header.
|
|
** false otherwise.
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
*/
|
|
|
|
bool
|
|
isheader(h)
|
|
char *h;
|
|
{
|
|
char *s;
|
|
|
|
s = h;
|
|
if (s[0] == '-' && s[1] == '-')
|
|
return false;
|
|
|
|
while (*s > ' ' && *s != ':' && *s != '\0')
|
|
s++;
|
|
|
|
if (h == s)
|
|
return false;
|
|
|
|
/* following technically violates RFC822 */
|
|
while (SM_ISSPACE(*s))
|
|
s++;
|
|
|
|
return (*s == ':');
|
|
}
|
|
|
|
/*
|
|
** EATHEADER -- run through the stored header and extract info.
|
|
**
|
|
** Parameters:
|
|
** e -- the envelope to process.
|
|
** full -- if set, do full processing (e.g., compute
|
|
** message priority). This should not be set
|
|
** when reading a queue file because some info
|
|
** needed to compute the priority is wrong.
|
|
** log -- call logsender()?
|
|
**
|
|
** Returns:
|
|
** none.
|
|
**
|
|
** Side Effects:
|
|
** Sets a bunch of global variables from information
|
|
** in the collected header.
|
|
*/
|
|
|
|
void
|
|
eatheader(e, full, log)
|
|
register ENVELOPE *e;
|
|
bool full;
|
|
bool log;
|
|
{
|
|
register HDR *h;
|
|
register char *p;
|
|
int hopcnt = 0;
|
|
char buf[MAXLINE];
|
|
|
|
/*
|
|
** Set up macros for possible expansion in headers.
|
|
*/
|
|
|
|
macdefine(&e->e_macro, A_PERM, 'f', e->e_sender);
|
|
macdefine(&e->e_macro, A_PERM, 'g', e->e_sender);
|
|
if (e->e_origrcpt != NULL && *e->e_origrcpt != '\0')
|
|
macdefine(&e->e_macro, A_PERM, 'u', e->e_origrcpt);
|
|
else
|
|
macdefine(&e->e_macro, A_PERM, 'u', NULL);
|
|
|
|
/* full name of from person */
|
|
p = hvalue("full-name", e->e_header);
|
|
if (p != NULL)
|
|
{
|
|
if (!rfc822_string(p))
|
|
{
|
|
/*
|
|
** Quote a full name with special characters
|
|
** as a comment so crackaddr() doesn't destroy
|
|
** the name portion of the address.
|
|
*/
|
|
|
|
p = addquotes(p, e->e_rpool);
|
|
}
|
|
macdefine(&e->e_macro, A_PERM, 'x', p);
|
|
}
|
|
|
|
if (tTd(32, 1))
|
|
sm_dprintf("----- collected header -----\n");
|
|
e->e_msgid = NULL;
|
|
for (h = e->e_header; h != NULL; h = h->h_link)
|
|
{
|
|
if (tTd(32, 1))
|
|
sm_dprintf("%s:", h->h_field);
|
|
if (h->h_value == NULL)
|
|
{
|
|
if (tTd(32, 1))
|
|
sm_dprintf("<NULL>\n");
|
|
continue;
|
|
}
|
|
|
|
/* do early binding */
|
|
if (bitset(H_DEFAULT, h->h_flags) &&
|
|
!bitset(H_BINDLATE, h->h_flags))
|
|
{
|
|
if (tTd(32, 1))
|
|
{
|
|
sm_dprintf("(");
|
|
xputs(sm_debug_file(), h->h_value);
|
|
sm_dprintf(") ");
|
|
}
|
|
expand(h->h_value, buf, sizeof(buf), e);
|
|
if (buf[0] != '\0' &&
|
|
(buf[0] != ' ' || buf[1] != '\0'))
|
|
{
|
|
if (bitset(H_FROM, h->h_flags))
|
|
expand(crackaddr(buf, e),
|
|
buf, sizeof(buf), e);
|
|
h->h_value = sm_rpool_strdup_x(e->e_rpool, buf);
|
|
h->h_flags &= ~H_DEFAULT;
|
|
}
|
|
}
|
|
if (tTd(32, 1))
|
|
{
|
|
xputs(sm_debug_file(), h->h_value);
|
|
sm_dprintf("\n");
|
|
}
|
|
|
|
/* count the number of times it has been processed */
|
|
if (bitset(H_TRACE, h->h_flags))
|
|
hopcnt++;
|
|
|
|
/* send to this person if we so desire */
|
|
if (GrabTo && bitset(H_RCPT, h->h_flags) &&
|
|
!bitset(H_DEFAULT, h->h_flags) &&
|
|
(!bitset(EF_RESENT, e->e_flags) ||
|
|
bitset(H_RESENT, h->h_flags)))
|
|
{
|
|
#if 0
|
|
int saveflags = e->e_flags;
|
|
#endif
|
|
|
|
(void) sendtolist(denlstring(h->h_value, true, false),
|
|
NULLADDR, &e->e_sendqueue, 0, e);
|
|
|
|
#if 0
|
|
/*
|
|
** Change functionality so a fatal error on an
|
|
** address doesn't affect the entire envelope.
|
|
*/
|
|
|
|
/* delete fatal errors generated by this address */
|
|
if (!bitset(EF_FATALERRS, saveflags))
|
|
e->e_flags &= ~EF_FATALERRS;
|
|
#endif /* 0 */
|
|
}
|
|
|
|
/* save the message-id for logging */
|
|
p = "resent-message-id";
|
|
if (!bitset(EF_RESENT, e->e_flags))
|
|
p += 7;
|
|
if (SM_STRCASEEQ(h->h_field, p))
|
|
{
|
|
e->e_msgid = h->h_value;
|
|
while (SM_ISSPACE(*e->e_msgid))
|
|
e->e_msgid++;
|
|
macdefine(&e->e_macro, A_PERM, macid("{msg_id}"),
|
|
e->e_msgid);
|
|
}
|
|
}
|
|
if (tTd(32, 1))
|
|
sm_dprintf("----------------------------\n");
|
|
|
|
/* if we are just verifying (that is, sendmail -t -bv), drop out now */
|
|
if (OpMode == MD_VERIFY)
|
|
return;
|
|
|
|
/* store hop count */
|
|
if (hopcnt > e->e_hopcount)
|
|
{
|
|
e->e_hopcount = hopcnt;
|
|
(void) sm_snprintf(buf, sizeof(buf), "%d", e->e_hopcount);
|
|
macdefine(&e->e_macro, A_TEMP, 'c', buf);
|
|
}
|
|
|
|
/* message priority */
|
|
p = hvalue("precedence", e->e_header);
|
|
if (p != NULL)
|
|
e->e_class = priencode(p);
|
|
if (e->e_class < 0)
|
|
e->e_timeoutclass = TOC_NONURGENT;
|
|
else if (e->e_class > 0)
|
|
e->e_timeoutclass = TOC_URGENT;
|
|
if (full)
|
|
{
|
|
e->e_msgpriority = e->e_msgsize
|
|
- e->e_class * WkClassFact
|
|
+ e->e_nrcpts * WkRecipFact;
|
|
}
|
|
|
|
/* check for DSN to properly set e_timeoutclass */
|
|
p = hvalue("content-type", e->e_header);
|
|
if (p != NULL)
|
|
{
|
|
bool oldsupr;
|
|
char **pvp;
|
|
char pvpbuf[MAXLINE];
|
|
extern unsigned char MimeTokenTab[256];
|
|
|
|
/* tokenize header */
|
|
oldsupr = SuprErrs;
|
|
SuprErrs = true;
|
|
pvp = prescan(p, '\0', pvpbuf, sizeof(pvpbuf), NULL,
|
|
MimeTokenTab, false);
|
|
SuprErrs = oldsupr;
|
|
|
|
/* Check if multipart/report */
|
|
if (pvp != NULL && pvp[0] != NULL &&
|
|
pvp[1] != NULL && pvp[2] != NULL &&
|
|
SM_STRCASEEQ(*pvp++, "multipart") &&
|
|
strcmp(*pvp++, "/") == 0 &&
|
|
SM_STRCASEEQ(*pvp++, "report"))
|
|
{
|
|
/* Look for report-type=delivery-status */
|
|
while (*pvp != NULL)
|
|
{
|
|
/* skip to semicolon separator */
|
|
while (*pvp != NULL && strcmp(*pvp, ";") != 0)
|
|
pvp++;
|
|
|
|
/* skip semicolon */
|
|
if (*pvp++ == NULL || *pvp == NULL)
|
|
break;
|
|
|
|
/* look for report-type */
|
|
if (!SM_STRCASEEQ(*pvp++, "report-type"))
|
|
continue;
|
|
|
|
/* skip equal */
|
|
if (*pvp == NULL || strcmp(*pvp, "=") != 0)
|
|
continue;
|
|
|
|
/* check value */
|
|
if (*++pvp != NULL &&
|
|
SM_STRCASEEQ(*pvp, "delivery-status"))
|
|
e->e_timeoutclass = TOC_DSN;
|
|
|
|
/* found report-type, no need to continue */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* message timeout priority */
|
|
p = hvalue("priority", e->e_header);
|
|
if (p != NULL)
|
|
{
|
|
/* (this should be in the configuration file) */
|
|
if (SM_STRCASEEQ(p, "urgent"))
|
|
e->e_timeoutclass = TOC_URGENT;
|
|
else if (SM_STRCASEEQ(p, "normal"))
|
|
e->e_timeoutclass = TOC_NORMAL;
|
|
else if (SM_STRCASEEQ(p, "non-urgent"))
|
|
e->e_timeoutclass = TOC_NONURGENT;
|
|
else if (bitset(EF_RESPONSE, e->e_flags))
|
|
e->e_timeoutclass = TOC_DSN;
|
|
}
|
|
else if (bitset(EF_RESPONSE, e->e_flags))
|
|
e->e_timeoutclass = TOC_DSN;
|
|
|
|
/* date message originated */
|
|
p = hvalue("posted-date", e->e_header);
|
|
if (p == NULL)
|
|
p = hvalue("date", e->e_header);
|
|
if (p != NULL)
|
|
macdefine(&e->e_macro, A_PERM, 'a', p);
|
|
|
|
/* check to see if this is a MIME message */
|
|
if ((e->e_bodytype != NULL &&
|
|
SM_STRCASEEQ(e->e_bodytype, "8bitmime")) ||
|
|
hvalue("MIME-Version", e->e_header) != NULL)
|
|
{
|
|
e->e_flags |= EF_IS_MIME;
|
|
if (HasEightBits)
|
|
e->e_bodytype = "8BITMIME";
|
|
}
|
|
else if ((p = hvalue("Content-Type", e->e_header)) != NULL)
|
|
{
|
|
/* this may be an RFC 1049 message */
|
|
p = strpbrk(p, ";/");
|
|
if (p == NULL || *p == ';')
|
|
{
|
|
/* yep, it is */
|
|
e->e_flags |= EF_DONT_MIME;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** From person in antiquated ARPANET mode
|
|
** required by UK Grey Book e-mail gateways (sigh)
|
|
*/
|
|
|
|
if (OpMode == MD_ARPAFTP)
|
|
{
|
|
register struct hdrinfo *hi;
|
|
|
|
for (hi = HdrInfo; hi->hi_field != NULL; hi++)
|
|
{
|
|
if (bitset(H_FROM, hi->hi_flags) &&
|
|
(!bitset(H_RESENT, hi->hi_flags) ||
|
|
bitset(EF_RESENT, e->e_flags)) &&
|
|
(p = hvalue(hi->hi_field, e->e_header)) != NULL)
|
|
break;
|
|
}
|
|
if (hi->hi_field != NULL)
|
|
{
|
|
if (tTd(32, 2))
|
|
sm_dprintf("eatheader: setsender(*%s == %s)\n",
|
|
hi->hi_field, p);
|
|
setsender(p, e, NULL, '\0', true);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Log collection information.
|
|
*/
|
|
|
|
if (tTd(92, 2))
|
|
sm_dprintf("eatheader: e_id=%s, EF_LOGSENDER=%d, LogLevel=%d, log=%d\n",
|
|
e->e_id, bitset(EF_LOGSENDER, e->e_flags), LogLevel,
|
|
log);
|
|
if (log && bitset(EF_LOGSENDER, e->e_flags) && LogLevel > 4)
|
|
{
|
|
logsender(e, e->e_msgid);
|
|
e->e_flags &= ~EF_LOGSENDER;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** LOGSENDER -- log sender information
|
|
**
|
|
** Parameters:
|
|
** e -- the envelope to log
|
|
** msgid -- the message id
|
|
**
|
|
** Returns:
|
|
** none
|
|
*/
|
|
|
|
#define XBUFLEN MAXNAME
|
|
#if (SYSLOG_BUFSIZE) >= 256
|
|
# ifndef MSGIDLOGLEN
|
|
# define MSGIDLOGLEN 100
|
|
# define FIRSTLOGLEN 850
|
|
# else
|
|
# if MSGIDLOGLEN < 100
|
|
# error "MSGIDLOGLEN too short"
|
|
# endif
|
|
/* XREF: this is "sizeof(sbuf)", see above */
|
|
# if MSGIDLOGLEN >= MAXLINE / 2
|
|
# error "MSGIDLOGLEN too long"
|
|
# endif
|
|
|
|
/* 850 - 100 for original MSGIDLOGLEN */
|
|
# define FIRSTLOGLEN (750 + MSGIDLOGLEN)
|
|
|
|
/* check that total length is ok */
|
|
# if FIRSTLOGLEN + 200 >= MAXLINE
|
|
# error "MSGIDLOGLEN too long"
|
|
# endif
|
|
# if MSGIDLOGLEN > MAXNAME
|
|
# undef XBUFLEN
|
|
# define XBUFLEN MSGIDLOGLEN
|
|
# endif
|
|
# endif
|
|
#endif /* (SYSLOG_BUFSIZE) >= 256 */
|
|
|
|
void
|
|
logsender(e, msgid)
|
|
register ENVELOPE *e;
|
|
char *msgid;
|
|
{
|
|
char *name;
|
|
register char *sbp;
|
|
register char *p;
|
|
char hbuf[MAXNAME + 1]; /* EAI:ok; restricted to short size */
|
|
char sbuf[MAXLINE + 1]; /* EAI:ok; XREF: see also MSGIDLOGLEN */
|
|
#if _FFR_8BITENVADDR
|
|
char xbuf[XBUFLEN + 1]; /* EAI:ok */
|
|
#endif
|
|
char *xstr;
|
|
|
|
if (bitset(EF_RESPONSE, e->e_flags))
|
|
name = "[RESPONSE]";
|
|
else if ((name = macvalue('_', e)) != NULL)
|
|
/* EMPTY */
|
|
;
|
|
else if (RealHostName == NULL)
|
|
name = "localhost";
|
|
else if (RealHostName[0] == '[')
|
|
name = RealHostName;
|
|
else
|
|
{
|
|
name = hbuf;
|
|
(void) sm_snprintf(hbuf, sizeof(hbuf), "%.80s", RealHostName);
|
|
if (RealHostAddr.sa.sa_family != 0)
|
|
{
|
|
p = &hbuf[strlen(hbuf)];
|
|
(void) sm_snprintf(p, SPACELEFT(hbuf, p),
|
|
" (%.100s)",
|
|
anynet_ntoa(&RealHostAddr));
|
|
}
|
|
}
|
|
|
|
#if (SYSLOG_BUFSIZE) >= 256
|
|
sbp = sbuf;
|
|
if (NULL != e->e_from.q_paddr)
|
|
{
|
|
xstr = e->e_from.q_paddr;
|
|
# if _FFR_8BITENVADDR
|
|
(void) dequote_internal_chars(e->e_from.q_paddr, xbuf, sizeof(xbuf));
|
|
xstr = xbuf;
|
|
# endif
|
|
}
|
|
else
|
|
xstr = "<NONE>";
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
"from=%.200s, size=%ld, class=%d, nrcpts=%d", xstr,
|
|
PRT_NONNEGL(e->e_msgsize), e->e_class, e->e_nrcpts);
|
|
sbp += strlen(sbp);
|
|
if (msgid != NULL)
|
|
{
|
|
# if _FFR_8BITENVADDR
|
|
(void) dequote_internal_chars(msgid, xbuf, sizeof(xbuf));
|
|
msgid = xbuf;
|
|
# endif
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
", msgid=%.*s", MSGIDLOGLEN, msgid);
|
|
sbp += strlen(sbp);
|
|
}
|
|
if (e->e_bodytype != NULL)
|
|
{
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
", bodytype=%.20s", e->e_bodytype);
|
|
sbp += strlen(sbp);
|
|
}
|
|
p = macvalue('r', e);
|
|
if (p != NULL)
|
|
{
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
", proto=%.20s", p);
|
|
sbp += strlen(sbp);
|
|
}
|
|
p = macvalue(macid("{daemon_name}"), e);
|
|
if (p != NULL)
|
|
{
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
", daemon=%.20s", p);
|
|
sbp += strlen(sbp);
|
|
}
|
|
# if _FFR_LOG_MORE1
|
|
LOG_MORE(sbuf, sbp);
|
|
# if SASL
|
|
p = macvalue(macid("{auth_type}"), e);
|
|
if (SM_IS_EMPTY(p))
|
|
p = "NONE";
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp), ", auth=%.20s", p);
|
|
sbp += strlen(sbp);
|
|
# endif /* SASL */
|
|
# endif /* _FFR_LOG_MORE1 */
|
|
sm_syslog(LOG_INFO, e->e_id, "%.*s, relay=%s", FIRSTLOGLEN, sbuf, name);
|
|
|
|
#else /* (SYSLOG_BUFSIZE) >= 256 */
|
|
|
|
sm_syslog(LOG_INFO, e->e_id,
|
|
"from=%s",
|
|
e->e_from.q_paddr == NULL ? "<NONE>"
|
|
: shortenstring(e->e_from.q_paddr,
|
|
83));
|
|
sm_syslog(LOG_INFO, e->e_id,
|
|
"size=%ld, class=%ld, nrcpts=%d",
|
|
PRT_NONNEGL(e->e_msgsize), e->e_class, e->e_nrcpts);
|
|
if (msgid != NULL)
|
|
{
|
|
# if _FFR_8BITENVADDR
|
|
(void) dequote_internal_chars(msgid, xbuf, sizeof(xbuf));
|
|
msgid = xbuf;
|
|
# endif
|
|
sm_syslog(LOG_INFO, e->e_id,
|
|
"msgid=%s",
|
|
shortenstring(msgid, 83));
|
|
}
|
|
sbp = sbuf;
|
|
*sbp = '\0';
|
|
if (e->e_bodytype != NULL)
|
|
{
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
"bodytype=%.20s, ", e->e_bodytype);
|
|
sbp += strlen(sbp);
|
|
}
|
|
p = macvalue('r', e);
|
|
if (p != NULL)
|
|
{
|
|
(void) sm_snprintf(sbp, SPACELEFT(sbuf, sbp),
|
|
"proto=%.20s, ", p);
|
|
sbp += strlen(sbp);
|
|
}
|
|
sm_syslog(LOG_INFO, e->e_id,
|
|
"%.400srelay=%s", sbuf, name);
|
|
#endif /* (SYSLOG_BUFSIZE) >= 256 */
|
|
}
|
|
|
|
/*
|
|
** PRIENCODE -- encode external priority names into internal values.
|
|
**
|
|
** Parameters:
|
|
** p -- priority in ascii.
|
|
**
|
|
** Returns:
|
|
** priority as a numeric level.
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
*/
|
|
|
|
static int
|
|
priencode(p)
|
|
char *p;
|
|
{
|
|
register int i;
|
|
|
|
for (i = 0; i < NumPriorities; i++)
|
|
{
|
|
if (SM_STRCASEEQ(p, Priorities[i].pri_name))
|
|
return Priorities[i].pri_val;
|
|
}
|
|
|
|
/* unknown priority */
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** CRACKADDR -- parse an address and turn it into a macro
|
|
**
|
|
** This doesn't actually parse the address -- it just extracts
|
|
** it and replaces it with "$g". The parse is totally ad hoc
|
|
** and isn't even guaranteed to leave something syntactically
|
|
** identical to what it started with. However, it does leave
|
|
** something semantically identical if possible, else at least
|
|
** syntactically correct.
|
|
**
|
|
** For example, it changes "Real Name <real@example.com> (Comment)"
|
|
** to "Real Name <$g> (Comment)".
|
|
**
|
|
** This algorithm has been cleaned up to handle a wider range
|
|
** of cases -- notably quoted and backslash escaped strings.
|
|
** This modification makes it substantially better at preserving
|
|
** the original syntax.
|
|
**
|
|
** Parameters:
|
|
** addr -- the address to be cracked. [A]
|
|
** e -- the current envelope.
|
|
**
|
|
** Returns:
|
|
** a pointer to the new version.
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
**
|
|
** Warning:
|
|
** The return value is saved in static storage and should
|
|
** be copied if it is to be reused.
|
|
*/
|
|
|
|
#define SM_HAVE_ROOMB ((bp < buflim) && (buflim <= bufend))
|
|
#if USE_EAI
|
|
# define SM_HAVE_ROOM ((xlen < MAXNAME) && SM_HAVE_ROOMB)
|
|
#else
|
|
# define SM_HAVE_ROOM SM_HAVE_ROOMB
|
|
#endif
|
|
|
|
/*
|
|
** Append a character to bp if we have room.
|
|
** If not, punt and return $g.
|
|
*/
|
|
|
|
#define SM_APPEND_CHAR(c) \
|
|
do \
|
|
{ \
|
|
XLEN(c); \
|
|
if (SM_HAVE_ROOM) \
|
|
*bp++ = (c); \
|
|
else \
|
|
goto returng; \
|
|
} while (0)
|
|
|
|
#if MAXNAME < 10
|
|
# error "MAXNAME must be at least 10"
|
|
#endif
|
|
|
|
char *
|
|
crackaddr(addr, e)
|
|
register char *addr;
|
|
ENVELOPE *e;
|
|
{
|
|
register char *p;
|
|
register char c;
|
|
int cmtlev; /* comment level in input string */
|
|
int realcmtlev; /* comment level in output string */
|
|
int anglelev; /* angle level in input string */
|
|
int copylev; /* 0 == in address, >0 copying */
|
|
int bracklev; /* bracket level for IPv6 addr check */
|
|
bool addangle; /* put closing angle in output */
|
|
bool qmode; /* quoting in original string? */
|
|
bool realqmode; /* quoting in output string? */
|
|
bool putgmac = false; /* already wrote $g */
|
|
bool quoteit = false; /* need to quote next character */
|
|
bool gotangle = false; /* found first '<' */
|
|
bool gotcolon = false; /* found a ':' */
|
|
register char *bp;
|
|
char *buflim;
|
|
char *bufhead;
|
|
char *addrhead;
|
|
char *bufend;
|
|
static char buf[MAXNAME_I + 1]; /* XXX: EAI? */
|
|
XLENDECL
|
|
|
|
if (tTd(33, 1))
|
|
sm_dprintf("crackaddr(%s)\n", addr);
|
|
|
|
buflim = bufend = &buf[sizeof(buf) - 1];
|
|
bp = bufhead = buf;
|
|
|
|
/* skip over leading spaces but preserve them */
|
|
while (*addr != '\0' && SM_ISSPACE(*addr))
|
|
{
|
|
SM_APPEND_CHAR(*addr);
|
|
addr++;
|
|
}
|
|
bufhead = bp;
|
|
|
|
/*
|
|
** Start by assuming we have no angle brackets. This will be
|
|
** adjusted later if we find them.
|
|
*/
|
|
|
|
p = addrhead = addr;
|
|
copylev = anglelev = cmtlev = realcmtlev = 0;
|
|
bracklev = 0;
|
|
qmode = realqmode = addangle = false;
|
|
|
|
while ((c = *p++) != '\0')
|
|
{
|
|
/*
|
|
** Try to keep legal syntax using spare buffer space
|
|
** (maintained by buflim).
|
|
*/
|
|
|
|
if (copylev > 0)
|
|
SM_APPEND_CHAR(c);
|
|
|
|
/* check for backslash escapes */
|
|
if (c == '\\')
|
|
{
|
|
/* arrange to quote the address */
|
|
if (cmtlev <= 0 && !qmode)
|
|
quoteit = true;
|
|
|
|
if ((c = *p++) == '\0')
|
|
{
|
|
/* too far */
|
|
p--;
|
|
goto putg;
|
|
}
|
|
if (copylev > 0)
|
|
SM_APPEND_CHAR(c);
|
|
goto putg;
|
|
}
|
|
|
|
/* check for quoted strings */
|
|
if (c == '"' && cmtlev <= 0)
|
|
{
|
|
qmode = !qmode;
|
|
if (copylev > 0 && SM_HAVE_ROOM)
|
|
{
|
|
if (realqmode)
|
|
buflim--;
|
|
else
|
|
buflim++;
|
|
realqmode = !realqmode;
|
|
}
|
|
continue;
|
|
}
|
|
if (qmode)
|
|
goto putg;
|
|
|
|
/* check for comments */
|
|
if (c == '(')
|
|
{
|
|
cmtlev++;
|
|
|
|
/* allow space for closing paren */
|
|
if (SM_HAVE_ROOM)
|
|
{
|
|
buflim--;
|
|
realcmtlev++;
|
|
if (copylev++ <= 0)
|
|
{
|
|
if (bp != bufhead)
|
|
SM_APPEND_CHAR(' ');
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
}
|
|
}
|
|
if (cmtlev > 0)
|
|
{
|
|
if (c == ')')
|
|
{
|
|
cmtlev--;
|
|
copylev--;
|
|
if (SM_HAVE_ROOM)
|
|
{
|
|
realcmtlev--;
|
|
buflim++;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
else if (c == ')')
|
|
{
|
|
/* syntax error: unmatched ) */
|
|
if (copylev > 0 && SM_HAVE_ROOM && bp > bufhead)
|
|
bp--;
|
|
}
|
|
|
|
/* count nesting on [ ... ] (for IPv6 domain literals) */
|
|
if (c == '[')
|
|
bracklev++;
|
|
else if (c == ']')
|
|
bracklev--;
|
|
|
|
/* check for group: list; syntax */
|
|
if (c == ':' && anglelev <= 0 && bracklev <= 0 &&
|
|
!gotcolon && !ColonOkInAddr)
|
|
{
|
|
register char *q;
|
|
|
|
/*
|
|
** Check for DECnet phase IV ``::'' (host::user)
|
|
** or DECnet phase V ``:.'' syntaxes. The latter
|
|
** covers ``user@DEC:.tay.myhost'' and
|
|
** ``DEC:.tay.myhost::user'' syntaxes (bletch).
|
|
*/
|
|
|
|
if (*p == ':' || *p == '.')
|
|
{
|
|
if (cmtlev <= 0 && !qmode)
|
|
quoteit = true;
|
|
if (copylev > 0)
|
|
{
|
|
SM_APPEND_CHAR(c);
|
|
SM_APPEND_CHAR(*p);
|
|
}
|
|
p++;
|
|
goto putg;
|
|
}
|
|
|
|
gotcolon = true;
|
|
|
|
bp = bufhead;
|
|
if (quoteit)
|
|
{
|
|
SM_APPEND_CHAR('"');
|
|
|
|
/* back up over the ':' and any spaces */
|
|
--p;
|
|
while (p > addr &&
|
|
isascii(*--p) && isspace(*p))
|
|
continue;
|
|
p++;
|
|
}
|
|
for (q = addrhead; q < p; )
|
|
{
|
|
c = *q++;
|
|
if (quoteit && c == '"')
|
|
SM_APPEND_CHAR('\\');
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
if (quoteit)
|
|
{
|
|
if (bp == &bufhead[1])
|
|
bp--;
|
|
else
|
|
SM_APPEND_CHAR('"');
|
|
while ((c = *p++) != ':')
|
|
SM_APPEND_CHAR(c);
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
|
|
/* any trailing white space is part of group: */
|
|
while (SM_ISSPACE(*p))
|
|
{
|
|
SM_APPEND_CHAR(*p);
|
|
p++;
|
|
}
|
|
copylev = 0;
|
|
putgmac = quoteit = false;
|
|
bufhead = bp;
|
|
addrhead = p;
|
|
continue;
|
|
}
|
|
|
|
if (c == ';' && copylev <= 0 && !ColonOkInAddr)
|
|
SM_APPEND_CHAR(c);
|
|
|
|
/* check for characters that may have to be quoted */
|
|
if (strchr(MustQuoteChars, c) != NULL)
|
|
{
|
|
/*
|
|
** If these occur as the phrase part of a <>
|
|
** construct, but are not inside of () or already
|
|
** quoted, they will have to be quoted. Note that
|
|
** now (but don't actually do the quoting).
|
|
*/
|
|
|
|
if (cmtlev <= 0 && !qmode)
|
|
quoteit = true;
|
|
}
|
|
|
|
/* check for angle brackets */
|
|
if (c == '<')
|
|
{
|
|
register char *q;
|
|
|
|
/* assume first of two angles is bogus */
|
|
if (gotangle)
|
|
quoteit = true;
|
|
gotangle = true;
|
|
|
|
/* oops -- have to change our mind */
|
|
anglelev = 1;
|
|
if (SM_HAVE_ROOM)
|
|
{
|
|
if (!addangle)
|
|
buflim--;
|
|
addangle = true;
|
|
}
|
|
|
|
bp = bufhead;
|
|
if (quoteit)
|
|
{
|
|
SM_APPEND_CHAR('"');
|
|
|
|
/* back up over the '<' and any spaces */
|
|
--p;
|
|
while (p > addr &&
|
|
isascii(*--p) && isspace(*p))
|
|
continue;
|
|
p++;
|
|
}
|
|
for (q = addrhead; q < p; )
|
|
{
|
|
c = *q++;
|
|
if (quoteit && c == '"')
|
|
{
|
|
SM_APPEND_CHAR('\\');
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
else
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
if (quoteit)
|
|
{
|
|
if (bp == &buf[1])
|
|
bp--;
|
|
else
|
|
SM_APPEND_CHAR('"');
|
|
while ((c = *p++) != '<')
|
|
SM_APPEND_CHAR(c);
|
|
SM_APPEND_CHAR(c);
|
|
}
|
|
copylev = 0;
|
|
putgmac = quoteit = false;
|
|
continue;
|
|
}
|
|
|
|
if (c == '>')
|
|
{
|
|
if (anglelev > 0)
|
|
{
|
|
anglelev--;
|
|
if (SM_HAVE_ROOM)
|
|
{
|
|
if (addangle)
|
|
buflim++;
|
|
addangle = false;
|
|
}
|
|
}
|
|
else if (SM_HAVE_ROOM)
|
|
{
|
|
/* syntax error: unmatched > */
|
|
if (copylev > 0 && bp > bufhead)
|
|
bp--;
|
|
quoteit = true;
|
|
continue;
|
|
}
|
|
if (copylev++ <= 0)
|
|
SM_APPEND_CHAR(c);
|
|
continue;
|
|
}
|
|
|
|
/* must be a real address character */
|
|
putg:
|
|
if (copylev <= 0 && !putgmac)
|
|
{
|
|
if (bp > buf && bp[-1] == ')')
|
|
SM_APPEND_CHAR(' ');
|
|
SM_APPEND_CHAR(MACROEXPAND);
|
|
SM_APPEND_CHAR('g');
|
|
putgmac = true;
|
|
}
|
|
}
|
|
|
|
/* repair any syntactic damage */
|
|
if (realqmode && bp < bufend)
|
|
*bp++ = '"';
|
|
while (realcmtlev-- > 0 && bp < bufend)
|
|
*bp++ = ')';
|
|
if (addangle && bp < bufend)
|
|
*bp++ = '>';
|
|
*bp = '\0';
|
|
if (bp < bufend)
|
|
goto success;
|
|
|
|
returng:
|
|
/* String too long, punt */
|
|
buf[0] = '<';
|
|
buf[1] = MACROEXPAND;
|
|
buf[2]= 'g';
|
|
buf[3] = '>';
|
|
buf[4]= '\0';
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Dropped invalid comments from header address");
|
|
|
|
success:
|
|
if (tTd(33, 1))
|
|
{
|
|
sm_dprintf("crackaddr=>`");
|
|
xputs(sm_debug_file(), buf);
|
|
sm_dprintf("'\n");
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/*
|
|
** PUTHEADER -- put the header part of a message from the in-core copy
|
|
**
|
|
** Parameters:
|
|
** mci -- the connection information.
|
|
** hdr -- the header to put.
|
|
** e -- envelope to use.
|
|
** flags -- MIME conversion flags.
|
|
**
|
|
** Returns:
|
|
** true iff header part was written successfully
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
*/
|
|
|
|
bool
|
|
putheader(mci, hdr, e, flags)
|
|
register MCI *mci;
|
|
HDR *hdr;
|
|
register ENVELOPE *e;
|
|
int flags;
|
|
{
|
|
register HDR *h;
|
|
char buf[SM_MAX(MAXLINE,BUFSIZ)];
|
|
char obuf[MAXLINE];
|
|
|
|
if (tTd(34, 1))
|
|
sm_dprintf("--- putheader, mailer = %s ---\n",
|
|
mci->mci_mailer->m_name);
|
|
|
|
/*
|
|
** If we're in MIME mode, we're not really in the header of the
|
|
** message, just the header of one of the parts of the body of
|
|
** the message. Therefore MCIF_INHEADER should not be turned on.
|
|
*/
|
|
|
|
if (!bitset(MCIF_INMIME, mci->mci_flags))
|
|
mci->mci_flags |= MCIF_INHEADER;
|
|
|
|
for (h = hdr; h != NULL; h = h->h_link)
|
|
{
|
|
register char *p = h->h_value;
|
|
char *q;
|
|
|
|
if (tTd(34, 11))
|
|
{
|
|
sm_dprintf(" %s:", h->h_field);
|
|
xputs(sm_debug_file(), p);
|
|
}
|
|
|
|
/* Skip empty headers */
|
|
if (p == NULL)
|
|
continue;
|
|
#if _FFR_8BITENVADDR
|
|
(void) dequote_internal_chars(p, buf, sizeof(buf));
|
|
#endif
|
|
|
|
/* heuristic shortening of MIME fields to avoid MUA overflows */
|
|
if (MaxMimeFieldLength > 0 &&
|
|
wordinclass(h->h_field,
|
|
macid("{checkMIMEFieldHeaders}")))
|
|
{
|
|
size_t len;
|
|
|
|
len = fix_mime_header(h, e);
|
|
if (len > 0)
|
|
{
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Truncated MIME %s header due to field size (length = %ld) (possible attack)",
|
|
h->h_field, (unsigned long) len);
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" truncated MIME %s header due to field size (length = %ld) (possible attack)\n",
|
|
h->h_field,
|
|
(unsigned long) len);
|
|
}
|
|
}
|
|
|
|
if (MaxMimeHeaderLength > 0 &&
|
|
wordinclass(h->h_field,
|
|
macid("{checkMIMETextHeaders}")))
|
|
{
|
|
size_t len;
|
|
|
|
len = strlen(p);
|
|
if (len > (size_t) MaxMimeHeaderLength)
|
|
{
|
|
h->h_value[MaxMimeHeaderLength - 1] = '\0';
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Truncated long MIME %s header (length = %ld) (possible attack)",
|
|
h->h_field, (unsigned long) len);
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" truncated long MIME %s header (length = %ld) (possible attack)\n",
|
|
h->h_field,
|
|
(unsigned long) len);
|
|
}
|
|
}
|
|
|
|
if (MaxMimeHeaderLength > 0 &&
|
|
wordinclass(h->h_field,
|
|
macid("{checkMIMEHeaders}")))
|
|
{
|
|
size_t len;
|
|
|
|
len = strlen(h->h_value);
|
|
if (shorten_rfc822_string(h->h_value,
|
|
MaxMimeHeaderLength))
|
|
{
|
|
if (len < MaxMimeHeaderLength)
|
|
{
|
|
/* we only rebalanced a bogus header */
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Fixed MIME %s header (possible attack)",
|
|
h->h_field);
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" fixed MIME %s header (possible attack)\n",
|
|
h->h_field);
|
|
}
|
|
else
|
|
{
|
|
/* we actually shortened header */
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Truncated long MIME %s header (length = %ld) (possible attack)",
|
|
h->h_field,
|
|
(unsigned long) len);
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" truncated long MIME %s header (length = %ld) (possible attack)\n",
|
|
h->h_field,
|
|
(unsigned long) len);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Suppress Content-Transfer-Encoding: if we are MIMEing
|
|
** and we are potentially converting from 8 bit to 7 bit
|
|
** MIME. If converting, add a new CTE header in
|
|
** mime8to7().
|
|
*/
|
|
|
|
if (bitset(H_CTE, h->h_flags) &&
|
|
bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME,
|
|
mci->mci_flags) &&
|
|
!bitset(M87F_NO8TO7, flags))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped (content-transfer-encoding))\n");
|
|
continue;
|
|
}
|
|
|
|
if (bitset(MCIF_INMIME, mci->mci_flags))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf("\n");
|
|
if (!put_vanilla_header(h, p, mci))
|
|
goto writeerr;
|
|
continue;
|
|
}
|
|
|
|
if (bitset(H_CHECK|H_ACHECK, h->h_flags) &&
|
|
!bitintersect(h->h_mflags, mci->mci_mailer->m_flags) &&
|
|
(h->h_macro == '\0' ||
|
|
(q = macvalue(bitidx(h->h_macro), e)) == NULL ||
|
|
*q == '\0'))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped)\n");
|
|
continue;
|
|
}
|
|
|
|
/* handle Resent-... headers specially */
|
|
if (bitset(H_RESENT, h->h_flags) && !bitset(EF_RESENT, e->e_flags))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped (resent))\n");
|
|
continue;
|
|
}
|
|
|
|
/* suppress return receipts if requested */
|
|
if (bitset(H_RECEIPTTO, h->h_flags) &&
|
|
(RrtImpliesDsn || bitset(EF_NORECEIPT, e->e_flags)))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped (receipt))\n");
|
|
continue;
|
|
}
|
|
|
|
/* macro expand value if generated internally */
|
|
if (bitset(H_DEFAULT, h->h_flags) ||
|
|
bitset(H_BINDLATE, h->h_flags))
|
|
{
|
|
expand(p, buf, sizeof(buf), e);
|
|
p = buf;
|
|
if (*p == '\0')
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped -- null value)\n");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (bitset(H_BCC, h->h_flags) && !KeepBcc)
|
|
{
|
|
/* Bcc: field -- either truncate or delete */
|
|
if (bitset(EF_DELETE_BCC, e->e_flags))
|
|
{
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" (skipped -- bcc)\n");
|
|
}
|
|
else
|
|
{
|
|
/* no other recipient headers: truncate value */
|
|
(void) sm_strlcpyn(obuf, sizeof(obuf), 2,
|
|
h->h_field, ":");
|
|
if (!putline(obuf, mci))
|
|
goto writeerr;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (tTd(34, 11))
|
|
sm_dprintf("\n");
|
|
|
|
if (bitset(H_FROM|H_RCPT, h->h_flags))
|
|
{
|
|
/* address field */
|
|
bool oldstyle = bitset(EF_OLDSTYLE, e->e_flags);
|
|
|
|
if (bitset(H_FROM, h->h_flags))
|
|
oldstyle = false;
|
|
if (!commaize(h, p, oldstyle, mci, e,
|
|
PXLF_HEADER | PXLF_STRIPMQUOTE)
|
|
&& bitnset(M_xSMTP, mci->mci_mailer->m_flags))
|
|
goto writeerr;
|
|
}
|
|
else
|
|
{
|
|
if (!put_vanilla_header(h, p, mci))
|
|
goto writeerr;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If we are converting this to a MIME message, add the
|
|
** MIME headers (but not in MIME mode!).
|
|
*/
|
|
|
|
#if MIME8TO7
|
|
if (bitset(MM_MIME8BIT, MimeMode) &&
|
|
bitset(EF_HAS8BIT, e->e_flags) &&
|
|
!bitset(EF_DONT_MIME, e->e_flags) &&
|
|
!bitnset(M_8BITS, mci->mci_mailer->m_flags) &&
|
|
!bitset(MCIF_CVT8TO7|MCIF_CVT7TO8|MCIF_INMIME, mci->mci_flags) &&
|
|
hvalue("MIME-Version", e->e_header) == NULL)
|
|
{
|
|
if (!putline("MIME-Version: 1.0", mci))
|
|
goto writeerr;
|
|
if (hvalue("Content-Type", e->e_header) == NULL)
|
|
{
|
|
(void) sm_snprintf(obuf, sizeof(obuf),
|
|
"Content-Type: text/plain; charset=%s",
|
|
defcharset(e));
|
|
if (!putline(obuf, mci))
|
|
goto writeerr;
|
|
}
|
|
if (hvalue("Content-Transfer-Encoding", e->e_header) == NULL
|
|
&& !putline("Content-Transfer-Encoding: 8bit", mci))
|
|
goto writeerr;
|
|
}
|
|
#endif /* MIME8TO7 */
|
|
return true;
|
|
|
|
writeerr:
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** PUT_VANILLA_HEADER -- output a fairly ordinary header
|
|
**
|
|
** Parameters:
|
|
** h -- the structure describing this header
|
|
** v -- the value of this header
|
|
** mci -- the connection info for output
|
|
**
|
|
** Returns:
|
|
** true iff header was written successfully
|
|
*/
|
|
|
|
static bool
|
|
put_vanilla_header(h, v, mci)
|
|
HDR *h;
|
|
char *v;
|
|
MCI *mci;
|
|
{
|
|
register char *nlp;
|
|
register char *obp;
|
|
int putflags;
|
|
char obuf[MAXLINE + 256]; /* additional length for h_field */
|
|
|
|
putflags = PXLF_HEADER | PXLF_STRIPMQUOTE;
|
|
if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
|
|
putflags |= PXLF_STRIP8BIT;
|
|
(void) sm_snprintf(obuf, sizeof(obuf), "%.200s:", h->h_field);
|
|
obp = obuf + strlen(obuf);
|
|
while ((nlp = strchr(v, '\n')) != NULL)
|
|
{
|
|
int l;
|
|
|
|
l = nlp - v;
|
|
|
|
/*
|
|
** XXX This is broken for SPACELEFT()==0
|
|
** However, SPACELEFT() is always > 0 unless MAXLINE==1.
|
|
*/
|
|
|
|
if (SPACELEFT(obuf, obp) - 1 < (size_t) l)
|
|
l = SPACELEFT(obuf, obp) - 1;
|
|
|
|
(void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.*s", l, v);
|
|
if (!putxline(obuf, strlen(obuf), mci, putflags))
|
|
goto writeerr;
|
|
v += l + 1;
|
|
obp = obuf;
|
|
if (*v != ' ' && *v != '\t')
|
|
*obp++ = ' ';
|
|
}
|
|
|
|
/* XXX This is broken for SPACELEFT()==0 */
|
|
(void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.*s",
|
|
(int) (SPACELEFT(obuf, obp) - 1), v);
|
|
return putxline(obuf, strlen(obuf), mci, putflags);
|
|
|
|
writeerr:
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** COMMAIZE -- output a header field, making a comma-translated list.
|
|
**
|
|
** Parameters:
|
|
** h -- the header field to output.
|
|
** p -- the value to put in it.
|
|
** oldstyle -- true if this is an old style header.
|
|
** mci -- the connection information.
|
|
** e -- the envelope containing the message.
|
|
** putflags -- flags for putxline()
|
|
**
|
|
** Returns:
|
|
** true iff header field was written successfully
|
|
**
|
|
** Side Effects:
|
|
** outputs "p" to "mci".
|
|
*/
|
|
|
|
bool
|
|
commaize(h, p, oldstyle, mci, e, putflags)
|
|
register HDR *h;
|
|
register char *p;
|
|
bool oldstyle;
|
|
register MCI *mci;
|
|
register ENVELOPE *e;
|
|
int putflags;
|
|
{
|
|
register char *obp;
|
|
int opos, omax, spaces;
|
|
bool firstone = true;
|
|
char **res;
|
|
char obuf[MAXLINE + 3];
|
|
|
|
/*
|
|
** Output the address list translated by the
|
|
** mailer and with commas.
|
|
*/
|
|
|
|
if (tTd(14, 2))
|
|
sm_dprintf("commaize(%s:%s)\n", h->h_field, p);
|
|
|
|
if (bitnset(M_7BITHDRS, mci->mci_mailer->m_flags))
|
|
putflags |= PXLF_STRIP8BIT;
|
|
|
|
#if _FFR_MTA_MODE
|
|
/* activate this per mailer? */
|
|
if (bitset(H_FROM, h->h_flags) && bitset(H_ASIS, h->h_flags))
|
|
{
|
|
(void) sm_snprintf(obuf, sizeof(obuf), "%.200s:%s", h->h_field,
|
|
h->h_value);
|
|
return putxline(obuf, strlen(obuf), mci, putflags);
|
|
}
|
|
#endif
|
|
|
|
obp = obuf;
|
|
(void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%.200s:", h->h_field);
|
|
/* opos = strlen(obp); instead of the next 3 lines? */
|
|
opos = strlen(h->h_field) + 1;
|
|
if (opos > 201)
|
|
opos = 201;
|
|
obp += opos;
|
|
|
|
spaces = 0;
|
|
while (*p != '\0' && SM_ISSPACE(*p))
|
|
{
|
|
++spaces;
|
|
++p;
|
|
}
|
|
if (spaces > 0)
|
|
{
|
|
SM_ASSERT(sizeof(obuf) > opos * 2);
|
|
|
|
/*
|
|
** Restrict number of spaces to half the length of buffer
|
|
** so the header field body can be put in here too.
|
|
** Note: this is a hack...
|
|
*/
|
|
|
|
if (spaces > sizeof(obuf) / 2)
|
|
spaces = sizeof(obuf) / 2;
|
|
(void) sm_snprintf(obp, SPACELEFT(obuf, obp), "%*s", spaces,
|
|
"");
|
|
opos += spaces;
|
|
obp += spaces;
|
|
SM_ASSERT(obp < &obuf[MAXLINE]);
|
|
}
|
|
|
|
omax = mci->mci_mailer->m_linelimit - 2;
|
|
if (omax < 0 || omax > 78)
|
|
omax = 78;
|
|
|
|
/*
|
|
** Run through the list of values.
|
|
*/
|
|
|
|
while (*p != '\0')
|
|
{
|
|
register char *name;
|
|
register int c;
|
|
char savechar;
|
|
int flags;
|
|
auto int status;
|
|
|
|
/*
|
|
** Find the end of the name. New style names
|
|
** end with a comma, old style names end with
|
|
** a space character. However, spaces do not
|
|
** necessarily delimit an old-style name -- at
|
|
** signs mean keep going.
|
|
*/
|
|
|
|
/* find end of name */
|
|
while ((SM_ISSPACE(*p)) || *p == ',')
|
|
p++;
|
|
name = p;
|
|
res = NULL;
|
|
for (;;)
|
|
{
|
|
auto char *oldp;
|
|
char pvpbuf[PSBUFSIZE];
|
|
|
|
res = prescan(p, oldstyle ? ' ' : ',', pvpbuf,
|
|
sizeof(pvpbuf), &oldp, ExtTokenTab, false);
|
|
p = oldp;
|
|
#if _FFR_IGNORE_BOGUS_ADDR
|
|
/* ignore addresses that can't be parsed */
|
|
if (res == NULL)
|
|
{
|
|
name = p;
|
|
continue;
|
|
}
|
|
#endif /* _FFR_IGNORE_BOGUS_ADDR */
|
|
|
|
/* look to see if we have an at sign */
|
|
while (*p != '\0' && SM_ISSPACE(*p))
|
|
p++;
|
|
|
|
if (*p != '@')
|
|
{
|
|
p = oldp;
|
|
break;
|
|
}
|
|
++p;
|
|
while (*p != '\0' && SM_ISSPACE(*p))
|
|
p++;
|
|
}
|
|
/* at the end of one complete name */
|
|
|
|
/* strip off trailing white space */
|
|
while (p >= name &&
|
|
((SM_ISSPACE(*p)) || *p == ',' || *p == '\0'))
|
|
p--;
|
|
if (++p == name)
|
|
continue;
|
|
|
|
/*
|
|
** if prescan() failed go a bit backwards; this is a hack,
|
|
** there should be some better error recovery.
|
|
*/
|
|
|
|
if (res == NULL && p > name &&
|
|
!((SM_ISSPACE(*p)) || *p == ',' || *p == '\0'))
|
|
--p;
|
|
savechar = *p;
|
|
*p = '\0';
|
|
|
|
/* translate the name to be relative */
|
|
flags = RF_HEADERADDR|RF_ADDDOMAIN;
|
|
if (bitset(H_FROM, h->h_flags))
|
|
flags |= RF_SENDERADDR;
|
|
#if USERDB
|
|
else if (e->e_from.q_mailer != NULL &&
|
|
bitnset(M_UDBRECIPIENT, e->e_from.q_mailer->m_flags))
|
|
{
|
|
char *q;
|
|
|
|
q = udbsender(name, e->e_rpool);
|
|
if (q != NULL)
|
|
name = q;
|
|
}
|
|
#endif /* USERDB */
|
|
status = EX_OK;
|
|
name = remotename(name, mci->mci_mailer, flags, &status, e);
|
|
if (status != EX_OK && bitnset(M_xSMTP, mci->mci_mailer->m_flags))
|
|
{
|
|
if (status == EX_TEMPFAIL)
|
|
mci->mci_flags |= MCIF_NOTSTICKY;
|
|
goto writeerr;
|
|
}
|
|
if (*name == '\0')
|
|
{
|
|
*p = savechar;
|
|
continue;
|
|
}
|
|
name = denlstring(name, false, true);
|
|
|
|
/* output the name with nice formatting */
|
|
opos += strlen(name);
|
|
if (!firstone)
|
|
opos += 2;
|
|
if (opos > omax && !firstone)
|
|
{
|
|
(void) sm_strlcpy(obp, ",\n", SPACELEFT(obuf, obp));
|
|
if (!putxline(obuf, strlen(obuf), mci, putflags))
|
|
goto writeerr;
|
|
obp = obuf;
|
|
(void) sm_strlcpy(obp, " ", sizeof(obuf));
|
|
opos = strlen(obp);
|
|
obp += opos;
|
|
opos += strlen(name);
|
|
}
|
|
else if (!firstone)
|
|
{
|
|
(void) sm_strlcpy(obp, ", ", SPACELEFT(obuf, obp));
|
|
obp += 2;
|
|
}
|
|
|
|
while ((c = *name++) != '\0' && obp < &obuf[MAXLINE])
|
|
*obp++ = c;
|
|
firstone = false;
|
|
*p = savechar;
|
|
}
|
|
if (obp < &obuf[sizeof(obuf)])
|
|
*obp = '\0';
|
|
else
|
|
obuf[sizeof(obuf) - 1] = '\0';
|
|
return putxline(obuf, strlen(obuf), mci, putflags);
|
|
|
|
writeerr:
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** COPYHEADER -- copy header list
|
|
**
|
|
** This routine is the equivalent of newstr for header lists
|
|
**
|
|
** Parameters:
|
|
** header -- list of header structures to copy.
|
|
** rpool -- resource pool, or NULL
|
|
**
|
|
** Returns:
|
|
** a copy of 'header'.
|
|
**
|
|
** Side Effects:
|
|
** none.
|
|
*/
|
|
|
|
HDR *
|
|
copyheader(header, rpool)
|
|
register HDR *header;
|
|
SM_RPOOL_T *rpool;
|
|
{
|
|
register HDR *newhdr;
|
|
HDR *ret;
|
|
register HDR **tail = &ret;
|
|
|
|
while (header != NULL)
|
|
{
|
|
newhdr = (HDR *) sm_rpool_malloc_x(rpool, sizeof(*newhdr));
|
|
STRUCTCOPY(*header, *newhdr);
|
|
*tail = newhdr;
|
|
tail = &newhdr->h_link;
|
|
header = header->h_link;
|
|
}
|
|
*tail = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
** FIX_MIME_HEADER -- possibly truncate/rebalance parameters in a MIME header
|
|
**
|
|
** Run through all of the parameters of a MIME header and
|
|
** possibly truncate and rebalance the parameter according
|
|
** to MaxMimeFieldLength.
|
|
**
|
|
** Parameters:
|
|
** h -- the header to truncate/rebalance
|
|
** e -- the current envelope
|
|
**
|
|
** Returns:
|
|
** length of last offending field, 0 if all ok.
|
|
**
|
|
** Side Effects:
|
|
** string modified in place
|
|
*/
|
|
|
|
static size_t
|
|
fix_mime_header(h, e)
|
|
HDR *h;
|
|
ENVELOPE *e;
|
|
{
|
|
char *begin = h->h_value;
|
|
char *end;
|
|
size_t len = 0;
|
|
size_t retlen = 0;
|
|
|
|
if (SM_IS_EMPTY(begin))
|
|
return 0;
|
|
|
|
/* Split on each ';' */
|
|
/* find_character() never returns NULL */
|
|
while ((end = find_character(begin, ';')) != NULL)
|
|
{
|
|
char save = *end;
|
|
char *bp;
|
|
|
|
*end = '\0';
|
|
|
|
len = strlen(begin);
|
|
|
|
/* Shorten individual parameter */
|
|
if (shorten_rfc822_string(begin, MaxMimeFieldLength))
|
|
{
|
|
if (len < MaxMimeFieldLength)
|
|
{
|
|
/* we only rebalanced a bogus field */
|
|
sm_syslog(LOG_ALERT, e->e_id,
|
|
"Fixed MIME %s header field (possible attack)",
|
|
h->h_field);
|
|
if (tTd(34, 11))
|
|
sm_dprintf(" fixed MIME %s header field (possible attack)\n",
|
|
h->h_field);
|
|
}
|
|
else
|
|
{
|
|
/* we actually shortened the header */
|
|
retlen = len;
|
|
}
|
|
}
|
|
|
|
/* Collapse the possibly shortened string with rest */
|
|
bp = begin + strlen(begin);
|
|
if (bp != end)
|
|
{
|
|
char *ep = end;
|
|
|
|
*end = save;
|
|
end = bp;
|
|
|
|
/* copy character by character due to overlap */
|
|
while (*ep != '\0')
|
|
*bp++ = *ep++;
|
|
*bp = '\0';
|
|
}
|
|
else
|
|
*end = save;
|
|
if (*end == '\0')
|
|
break;
|
|
|
|
/* Move past ';' */
|
|
begin = end + 1;
|
|
}
|
|
return retlen;
|
|
}
|