1245 lines
28 KiB
C
1245 lines
28 KiB
C
/*
|
|
* Copyright (c) 1998-2003 Sendmail, Inc. and its suppliers.
|
|
* All rights reserved.
|
|
* Copyright (c) 1986, 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>
|
|
|
|
#if NAMED_BIND
|
|
SM_RCSID("@(#)$Id: domain.c,v 8.181.2.9 2003/08/11 23:23:40 gshapiro Exp $ (with name server)")
|
|
#else /* NAMED_BIND */
|
|
SM_RCSID("@(#)$Id: domain.c,v 8.181.2.9 2003/08/11 23:23:40 gshapiro Exp $ (without name server)")
|
|
#endif /* NAMED_BIND */
|
|
|
|
#if NAMED_BIND
|
|
|
|
# include <arpa/inet.h>
|
|
|
|
|
|
/*
|
|
** The standard udp packet size PACKETSZ (512) is not sufficient for some
|
|
** nameserver answers containing very many resource records. The resolver
|
|
** may switch to tcp and retry if it detects udp packet overflow.
|
|
** Also note that the resolver routines res_query and res_search return
|
|
** the size of the *un*truncated answer in case the supplied answer buffer
|
|
** it not big enough to accommodate the entire answer.
|
|
*/
|
|
|
|
# ifndef MAXPACKET
|
|
# define MAXPACKET 8192 /* max packet size used internally by BIND */
|
|
# endif /* ! MAXPACKET */
|
|
|
|
typedef union
|
|
{
|
|
HEADER qb1;
|
|
unsigned char qb2[MAXPACKET];
|
|
} querybuf;
|
|
|
|
# ifndef MXHOSTBUFSIZE
|
|
# define MXHOSTBUFSIZE (128 * MAXMXHOSTS)
|
|
# endif /* ! MXHOSTBUFSIZE */
|
|
|
|
static char MXHostBuf[MXHOSTBUFSIZE];
|
|
#if (MXHOSTBUFSIZE < 2) || (MXHOSTBUFSIZE >= INT_MAX/2)
|
|
ERROR: _MXHOSTBUFSIZE is out of range
|
|
#endif /* (MXHOSTBUFSIZE < 2) || (MXHOSTBUFSIZE >= INT_MAX/2) */
|
|
|
|
# ifndef MAXDNSRCH
|
|
# define MAXDNSRCH 6 /* number of possible domains to search */
|
|
# endif /* ! MAXDNSRCH */
|
|
|
|
# ifndef RES_DNSRCH_VARIABLE
|
|
# define RES_DNSRCH_VARIABLE _res.dnsrch
|
|
# endif /* ! RES_DNSRCH_VARIABLE */
|
|
|
|
# ifndef NO_DATA
|
|
# define NO_DATA NO_ADDRESS
|
|
# endif /* ! NO_DATA */
|
|
|
|
# ifndef HFIXEDSZ
|
|
# define HFIXEDSZ 12 /* sizeof(HEADER) */
|
|
# endif /* ! HFIXEDSZ */
|
|
|
|
# define MAXCNAMEDEPTH 10 /* maximum depth of CNAME recursion */
|
|
|
|
# if defined(__RES) && (__RES >= 19940415)
|
|
# define RES_UNC_T char *
|
|
# else /* defined(__RES) && (__RES >= 19940415) */
|
|
# define RES_UNC_T unsigned char *
|
|
# endif /* defined(__RES) && (__RES >= 19940415) */
|
|
|
|
static char *gethostalias __P((char *));
|
|
static int mxrand __P((char *));
|
|
static int fallbackmxrr __P((int, unsigned short *, char **));
|
|
|
|
/*
|
|
** GETFALLBACKMXRR -- get MX resource records for fallback MX host.
|
|
**
|
|
** We have to initialize this once before doing anything else.
|
|
** Moreover, we have to repeat this from time to time to avoid
|
|
** stale data, e.g., in persistent queue runners.
|
|
** This should be done in a parent process so the child
|
|
** processes have the right data.
|
|
**
|
|
** Parameters:
|
|
** host -- the name of the fallback MX host.
|
|
**
|
|
** Returns:
|
|
** number of MX records.
|
|
**
|
|
** Side Effects:
|
|
** Populates NumFallBackMXHosts and fbhosts.
|
|
** Sets renewal time (based on TTL).
|
|
*/
|
|
|
|
int NumFallBackMXHosts = 0; /* Number of fallback MX hosts (after MX expansion) */
|
|
static char *fbhosts[MAXMXHOSTS + 1];
|
|
|
|
int
|
|
getfallbackmxrr(host)
|
|
char *host;
|
|
{
|
|
int i, rcode;
|
|
int ttl;
|
|
static time_t renew = 0;
|
|
|
|
#if 0
|
|
/* This is currently done before this function is called. */
|
|
if (host == NULL || *host == '\0')
|
|
return 0;
|
|
#endif /* 0 */
|
|
if (NumFallBackMXHosts > 0 && renew > curtime())
|
|
return NumFallBackMXHosts;
|
|
if (host[0] == '[')
|
|
{
|
|
fbhosts[0] = host;
|
|
NumFallBackMXHosts = 1;
|
|
}
|
|
else
|
|
{
|
|
/* free old data */
|
|
for (i = 0; i < NumFallBackMXHosts; i++)
|
|
sm_free(fbhosts[i]);
|
|
|
|
/* get new data */
|
|
NumFallBackMXHosts = getmxrr(host, fbhosts, NULL, false,
|
|
&rcode, false, &ttl);
|
|
renew = curtime() + ttl;
|
|
for (i = 0; i < NumFallBackMXHosts; i++)
|
|
fbhosts[i] = newstr(fbhosts[i]);
|
|
}
|
|
return NumFallBackMXHosts;
|
|
}
|
|
|
|
/*
|
|
** FALLBACKMXRR -- add MX resource records for fallback MX host to list.
|
|
**
|
|
** Parameters:
|
|
** nmx -- current number of MX records.
|
|
** prefs -- array of preferences.
|
|
** mxhosts -- array of MX hosts (maximum size: MAXMXHOSTS)
|
|
**
|
|
** Returns:
|
|
** new number of MX records.
|
|
**
|
|
** Side Effects:
|
|
** If FallBackMX was set, it appends the MX records for
|
|
** that host to mxhosts (and modifies prefs accordingly).
|
|
*/
|
|
|
|
static int
|
|
fallbackmxrr(nmx, prefs, mxhosts)
|
|
int nmx;
|
|
unsigned short *prefs;
|
|
char **mxhosts;
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NumFallBackMXHosts && nmx < MAXMXHOSTS; i++)
|
|
{
|
|
if (nmx > 0)
|
|
prefs[nmx] = prefs[nmx - 1] + 1;
|
|
else
|
|
prefs[nmx] = 0;
|
|
mxhosts[nmx++] = fbhosts[i];
|
|
}
|
|
return nmx;
|
|
}
|
|
|
|
/*
|
|
** GETMXRR -- get MX resource records for a domain
|
|
**
|
|
** Parameters:
|
|
** host -- the name of the host to MX.
|
|
** mxhosts -- a pointer to a return buffer of MX records.
|
|
** mxprefs -- a pointer to a return buffer of MX preferences.
|
|
** If NULL, don't try to populate.
|
|
** droplocalhost -- If true, all MX records less preferred
|
|
** than the local host (as determined by $=w) will
|
|
** be discarded.
|
|
** rcode -- a pointer to an EX_ status code.
|
|
** tryfallback -- add also fallback MX host?
|
|
** pttl -- pointer to return TTL (can be NULL).
|
|
**
|
|
** Returns:
|
|
** The number of MX records found.
|
|
** -1 if there is an internal failure.
|
|
** If no MX records are found, mxhosts[0] is set to host
|
|
** and 1 is returned.
|
|
**
|
|
** Side Effects:
|
|
** The entries made for mxhosts point to a static array
|
|
** MXHostBuf[MXHOSTBUFSIZE], so the data needs to be copied,
|
|
** if it must be preserved across calls to this function.
|
|
*/
|
|
|
|
int
|
|
getmxrr(host, mxhosts, mxprefs, droplocalhost, rcode, tryfallback, pttl)
|
|
char *host;
|
|
char **mxhosts;
|
|
unsigned short *mxprefs;
|
|
bool droplocalhost;
|
|
int *rcode;
|
|
bool tryfallback;
|
|
int *pttl;
|
|
{
|
|
register unsigned char *eom, *cp;
|
|
register int i, j, n;
|
|
int nmx = 0;
|
|
register char *bp;
|
|
HEADER *hp;
|
|
querybuf answer;
|
|
int ancount, qdcount, buflen;
|
|
bool seenlocal = false;
|
|
unsigned short pref, type;
|
|
unsigned short localpref = 256;
|
|
char *fallbackMX = FallBackMX;
|
|
bool trycanon = false;
|
|
unsigned short *prefs;
|
|
int (*resfunc)();
|
|
unsigned short prefer[MAXMXHOSTS];
|
|
int weight[MAXMXHOSTS];
|
|
int ttl = 0;
|
|
extern int res_query(), res_search();
|
|
|
|
if (tTd(8, 2))
|
|
sm_dprintf("getmxrr(%s, droplocalhost=%d)\n",
|
|
host, droplocalhost);
|
|
if (*host == '\0')
|
|
return 0;
|
|
|
|
if ((fallbackMX != NULL && droplocalhost &&
|
|
wordinclass(fallbackMX, 'w')) || !tryfallback)
|
|
{
|
|
/* don't use fallback for this pass */
|
|
fallbackMX = NULL;
|
|
}
|
|
|
|
*rcode = EX_OK;
|
|
|
|
if (mxprefs != NULL)
|
|
prefs = mxprefs;
|
|
else
|
|
prefs = prefer;
|
|
|
|
/* efficiency hack -- numeric or non-MX lookups */
|
|
if (host[0] == '[')
|
|
goto punt;
|
|
|
|
/*
|
|
** If we don't have MX records in our host switch, don't
|
|
** try for MX records. Note that this really isn't "right",
|
|
** since we might be set up to try NIS first and then DNS;
|
|
** if the host is found in NIS we really shouldn't be doing
|
|
** MX lookups. However, that should be a degenerate case.
|
|
*/
|
|
|
|
if (!UseNameServer)
|
|
goto punt;
|
|
if (HasWildcardMX && ConfigLevel >= 6)
|
|
resfunc = res_query;
|
|
else
|
|
resfunc = res_search;
|
|
|
|
errno = 0;
|
|
n = (*resfunc)(host, C_IN, T_MX, (unsigned char *) &answer,
|
|
sizeof(answer));
|
|
if (n < 0)
|
|
{
|
|
if (tTd(8, 1))
|
|
sm_dprintf("getmxrr: res_search(%s) failed (errno=%d, h_errno=%d)\n",
|
|
host == NULL ? "<NULL>" : host, errno, h_errno);
|
|
switch (h_errno)
|
|
{
|
|
case NO_DATA:
|
|
trycanon = true;
|
|
/* FALLTHROUGH */
|
|
|
|
case NO_RECOVERY:
|
|
/* no MX data on this host */
|
|
goto punt;
|
|
|
|
case HOST_NOT_FOUND:
|
|
# if BROKEN_RES_SEARCH
|
|
case 0: /* Ultrix resolver retns failure w/ h_errno=0 */
|
|
# endif /* BROKEN_RES_SEARCH */
|
|
/* host doesn't exist in DNS; might be in /etc/hosts */
|
|
trycanon = true;
|
|
*rcode = EX_NOHOST;
|
|
goto punt;
|
|
|
|
case TRY_AGAIN:
|
|
case -1:
|
|
/* couldn't connect to the name server */
|
|
if (fallbackMX != NULL)
|
|
{
|
|
/* name server is hosed -- push to fallback */
|
|
return fallbackmxrr(nmx, prefs, mxhosts);
|
|
}
|
|
/* it might come up later; better queue it up */
|
|
*rcode = EX_TEMPFAIL;
|
|
break;
|
|
|
|
default:
|
|
syserr("getmxrr: res_search (%s) failed with impossible h_errno (%d)",
|
|
host, h_errno);
|
|
*rcode = EX_OSERR;
|
|
break;
|
|
}
|
|
|
|
/* irreconcilable differences */
|
|
return -1;
|
|
}
|
|
|
|
/* avoid problems after truncation in tcp packets */
|
|
if (n > sizeof(answer))
|
|
n = sizeof(answer);
|
|
|
|
/* find first satisfactory answer */
|
|
hp = (HEADER *)&answer;
|
|
cp = (unsigned char *)&answer + HFIXEDSZ;
|
|
eom = (unsigned char *)&answer + n;
|
|
for (qdcount = ntohs((unsigned short) hp->qdcount);
|
|
qdcount--;
|
|
cp += n + QFIXEDSZ)
|
|
{
|
|
if ((n = dn_skipname(cp, eom)) < 0)
|
|
goto punt;
|
|
}
|
|
|
|
/* NOTE: see definition of MXHostBuf! */
|
|
buflen = sizeof(MXHostBuf) - 1;
|
|
SM_ASSERT(buflen > 0);
|
|
bp = MXHostBuf;
|
|
ancount = ntohs((unsigned short) hp->ancount);
|
|
|
|
/* See RFC 1035 for layout of RRs. */
|
|
/* XXX leave room for FallBackMX ? */
|
|
while (--ancount >= 0 && cp < eom && nmx < MAXMXHOSTS - 1)
|
|
{
|
|
if ((n = dn_expand((unsigned char *)&answer, eom, cp,
|
|
(RES_UNC_T) bp, buflen)) < 0)
|
|
break;
|
|
cp += n;
|
|
GETSHORT(type, cp);
|
|
cp += INT16SZ; /* skip over class */
|
|
GETLONG(ttl, cp);
|
|
GETSHORT(n, cp); /* rdlength */
|
|
if (type != T_MX)
|
|
{
|
|
if (tTd(8, 8) || _res.options & RES_DEBUG)
|
|
sm_dprintf("unexpected answer type %d, size %d\n",
|
|
type, n);
|
|
cp += n;
|
|
continue;
|
|
}
|
|
GETSHORT(pref, cp);
|
|
if ((n = dn_expand((unsigned char *)&answer, eom, cp,
|
|
(RES_UNC_T) bp, buflen)) < 0)
|
|
break;
|
|
cp += n;
|
|
n = strlen(bp);
|
|
# if 0
|
|
/* Can this happen? */
|
|
if (n == 0)
|
|
{
|
|
if (LogLevel > 4)
|
|
sm_syslog(LOG_ERR, NOQID,
|
|
"MX records for %s contain empty string",
|
|
host);
|
|
continue;
|
|
}
|
|
# endif /* 0 */
|
|
if (wordinclass(bp, 'w'))
|
|
{
|
|
if (tTd(8, 3))
|
|
sm_dprintf("found localhost (%s) in MX list, pref=%d\n",
|
|
bp, pref);
|
|
if (droplocalhost)
|
|
{
|
|
if (!seenlocal || pref < localpref)
|
|
localpref = pref;
|
|
seenlocal = true;
|
|
continue;
|
|
}
|
|
weight[nmx] = 0;
|
|
}
|
|
else
|
|
weight[nmx] = mxrand(bp);
|
|
prefs[nmx] = pref;
|
|
mxhosts[nmx++] = bp;
|
|
bp += n;
|
|
if (bp[-1] != '.')
|
|
{
|
|
*bp++ = '.';
|
|
n++;
|
|
}
|
|
*bp++ = '\0';
|
|
if (buflen < n + 1)
|
|
{
|
|
/* don't want to wrap buflen */
|
|
break;
|
|
}
|
|
buflen -= n + 1;
|
|
}
|
|
|
|
/* return only one TTL entry, that should be sufficient */
|
|
if (ttl > 0 && pttl != NULL)
|
|
*pttl = ttl;
|
|
|
|
/* sort the records */
|
|
for (i = 0; i < nmx; i++)
|
|
{
|
|
for (j = i + 1; j < nmx; j++)
|
|
{
|
|
if (prefs[i] > prefs[j] ||
|
|
(prefs[i] == prefs[j] && weight[i] > weight[j]))
|
|
{
|
|
register int temp;
|
|
register char *temp1;
|
|
|
|
temp = prefs[i];
|
|
prefs[i] = prefs[j];
|
|
prefs[j] = temp;
|
|
temp1 = mxhosts[i];
|
|
mxhosts[i] = mxhosts[j];
|
|
mxhosts[j] = temp1;
|
|
temp = weight[i];
|
|
weight[i] = weight[j];
|
|
weight[j] = temp;
|
|
}
|
|
}
|
|
if (seenlocal && prefs[i] >= localpref)
|
|
{
|
|
/* truncate higher preference part of list */
|
|
nmx = i;
|
|
}
|
|
}
|
|
|
|
/* delete duplicates from list (yes, some bozos have duplicates) */
|
|
for (i = 0; i < nmx - 1; )
|
|
{
|
|
if (sm_strcasecmp(mxhosts[i], mxhosts[i + 1]) != 0)
|
|
i++;
|
|
else
|
|
{
|
|
/* compress out duplicate */
|
|
for (j = i + 1; j < nmx; j++)
|
|
{
|
|
mxhosts[j] = mxhosts[j + 1];
|
|
prefs[j] = prefs[j + 1];
|
|
}
|
|
nmx--;
|
|
}
|
|
}
|
|
|
|
if (nmx == 0)
|
|
{
|
|
punt:
|
|
if (seenlocal)
|
|
{
|
|
struct hostent *h = NULL;
|
|
|
|
/*
|
|
** If we have deleted all MX entries, this is
|
|
** an error -- we should NEVER send to a host that
|
|
** has an MX, and this should have been caught
|
|
** earlier in the config file.
|
|
**
|
|
** Some sites prefer to go ahead and try the
|
|
** A record anyway; that case is handled by
|
|
** setting TryNullMXList. I believe this is a
|
|
** bad idea, but it's up to you....
|
|
*/
|
|
|
|
if (TryNullMXList)
|
|
{
|
|
SM_SET_H_ERRNO(0);
|
|
errno = 0;
|
|
h = sm_gethostbyname(host, AF_INET);
|
|
if (h == NULL)
|
|
{
|
|
if (errno == ETIMEDOUT ||
|
|
h_errno == TRY_AGAIN ||
|
|
(errno == ECONNREFUSED &&
|
|
UseNameServer))
|
|
{
|
|
*rcode = EX_TEMPFAIL;
|
|
return -1;
|
|
}
|
|
# if NETINET6
|
|
SM_SET_H_ERRNO(0);
|
|
errno = 0;
|
|
h = sm_gethostbyname(host, AF_INET6);
|
|
if (h == NULL &&
|
|
(errno == ETIMEDOUT ||
|
|
h_errno == TRY_AGAIN ||
|
|
(errno == ECONNREFUSED &&
|
|
UseNameServer)))
|
|
{
|
|
*rcode = EX_TEMPFAIL;
|
|
return -1;
|
|
}
|
|
# endif /* NETINET6 */
|
|
}
|
|
}
|
|
|
|
if (h == NULL)
|
|
{
|
|
*rcode = EX_CONFIG;
|
|
syserr("MX list for %s points back to %s",
|
|
host, MyHostName);
|
|
return -1;
|
|
}
|
|
# if NETINET6
|
|
freehostent(h);
|
|
hp = NULL;
|
|
# endif /* NETINET6 */
|
|
}
|
|
if (strlen(host) >= sizeof MXHostBuf)
|
|
{
|
|
*rcode = EX_CONFIG;
|
|
syserr("Host name %s too long",
|
|
shortenstring(host, MAXSHORTSTR));
|
|
return -1;
|
|
}
|
|
(void) sm_strlcpy(MXHostBuf, host, sizeof MXHostBuf);
|
|
mxhosts[0] = MXHostBuf;
|
|
prefs[0] = 0;
|
|
if (host[0] == '[')
|
|
{
|
|
register char *p;
|
|
# if NETINET6
|
|
struct sockaddr_in6 tmp6;
|
|
# endif /* NETINET6 */
|
|
|
|
/* this may be an MX suppression-style address */
|
|
p = strchr(MXHostBuf, ']');
|
|
if (p != NULL)
|
|
{
|
|
*p = '\0';
|
|
|
|
if (inet_addr(&MXHostBuf[1]) != INADDR_NONE)
|
|
{
|
|
nmx++;
|
|
*p = ']';
|
|
}
|
|
# if NETINET6
|
|
else if (anynet_pton(AF_INET6, &MXHostBuf[1],
|
|
&tmp6.sin6_addr) == 1)
|
|
{
|
|
nmx++;
|
|
*p = ']';
|
|
}
|
|
# endif /* NETINET6 */
|
|
else
|
|
{
|
|
trycanon = true;
|
|
mxhosts[0]++;
|
|
}
|
|
}
|
|
}
|
|
if (trycanon &&
|
|
getcanonname(mxhosts[0], sizeof MXHostBuf - 2, false, pttl))
|
|
{
|
|
/* XXX MXHostBuf == "" ? is that possible? */
|
|
bp = &MXHostBuf[strlen(MXHostBuf)];
|
|
if (bp[-1] != '.')
|
|
{
|
|
*bp++ = '.';
|
|
*bp = '\0';
|
|
}
|
|
nmx = 1;
|
|
}
|
|
}
|
|
|
|
/* if we have a default lowest preference, include that */
|
|
if (fallbackMX != NULL && !seenlocal)
|
|
{
|
|
nmx = fallbackmxrr(nmx, prefs, mxhosts);
|
|
}
|
|
return nmx;
|
|
}
|
|
/*
|
|
** MXRAND -- create a randomizer for equal MX preferences
|
|
**
|
|
** If two MX hosts have equal preferences we want to randomize
|
|
** the selection. But in order for signatures to be the same,
|
|
** we need to randomize the same way each time. This function
|
|
** computes a pseudo-random hash function from the host name.
|
|
**
|
|
** Parameters:
|
|
** host -- the name of the host.
|
|
**
|
|
** Returns:
|
|
** A random but repeatable value based on the host name.
|
|
*/
|
|
|
|
static int
|
|
mxrand(host)
|
|
register char *host;
|
|
{
|
|
int hfunc;
|
|
static unsigned int seed;
|
|
|
|
if (seed == 0)
|
|
{
|
|
seed = (int) curtime() & 0xffff;
|
|
if (seed == 0)
|
|
seed++;
|
|
}
|
|
|
|
if (tTd(17, 9))
|
|
sm_dprintf("mxrand(%s)", host);
|
|
|
|
hfunc = seed;
|
|
while (*host != '\0')
|
|
{
|
|
int c = *host++;
|
|
|
|
if (isascii(c) && isupper(c))
|
|
c = tolower(c);
|
|
hfunc = ((hfunc << 1) ^ c) % 2003;
|
|
}
|
|
|
|
hfunc &= 0xff;
|
|
hfunc++;
|
|
|
|
if (tTd(17, 9))
|
|
sm_dprintf(" = %d\n", hfunc);
|
|
return hfunc;
|
|
}
|
|
/*
|
|
** BESTMX -- find the best MX for a name
|
|
**
|
|
** This is really a hack, but I don't see any obvious way
|
|
** to generalize it at the moment.
|
|
*/
|
|
|
|
/* ARGSUSED3 */
|
|
char *
|
|
bestmx_map_lookup(map, name, av, statp)
|
|
MAP *map;
|
|
char *name;
|
|
char **av;
|
|
int *statp;
|
|
{
|
|
int nmx;
|
|
int saveopts = _res.options;
|
|
int i;
|
|
ssize_t len = 0;
|
|
char *result;
|
|
char *mxhosts[MAXMXHOSTS + 1];
|
|
#if _FFR_BESTMX_BETTER_TRUNCATION
|
|
char *buf;
|
|
#else /* _FFR_BESTMX_BETTER_TRUNCATION */
|
|
char *p;
|
|
char buf[PSBUFSIZE / 2];
|
|
#endif /* _FFR_BESTMX_BETTER_TRUNCATION */
|
|
|
|
_res.options &= ~(RES_DNSRCH|RES_DEFNAMES);
|
|
nmx = getmxrr(name, mxhosts, NULL, false, statp, false, NULL);
|
|
_res.options = saveopts;
|
|
if (nmx <= 0)
|
|
return NULL;
|
|
if (bitset(MF_MATCHONLY, map->map_mflags))
|
|
return map_rewrite(map, name, strlen(name), NULL);
|
|
if ((map->map_coldelim == '\0') || (nmx == 1))
|
|
return map_rewrite(map, mxhosts[0], strlen(mxhosts[0]), av);
|
|
|
|
/*
|
|
** We were given a -z flag (return all MXs) and there are multiple
|
|
** ones. We need to build them all into a list.
|
|
*/
|
|
|
|
#if _FFR_BESTMX_BETTER_TRUNCATION
|
|
for (i = 0; i < nmx; i++)
|
|
{
|
|
if (strchr(mxhosts[i], map->map_coldelim) != NULL)
|
|
{
|
|
syserr("bestmx_map_lookup: MX host %.64s includes map delimiter character 0x%02X",
|
|
mxhosts[i], map->map_coldelim);
|
|
return NULL;
|
|
}
|
|
len += strlen(mxhosts[i]) + 1;
|
|
if (len < 0)
|
|
{
|
|
len -= strlen(mxhosts[i]) + 1;
|
|
break;
|
|
}
|
|
}
|
|
buf = (char *) sm_malloc(len);
|
|
if (buf == NULL)
|
|
{
|
|
*statp = EX_UNAVAILABLE;
|
|
return NULL;
|
|
}
|
|
*buf = '\0';
|
|
for (i = 0; i < nmx; i++)
|
|
{
|
|
int end;
|
|
|
|
end = sm_strlcat(buf, mxhosts[i], len);
|
|
if (i != nmx && end + 1 < len)
|
|
{
|
|
buf[end] = map->map_coldelim;
|
|
buf[end + 1] = '\0';
|
|
}
|
|
}
|
|
|
|
/* Cleanly truncate for rulesets */
|
|
truncate_at_delim(buf, PSBUFSIZE / 2, map->map_coldelim);
|
|
#else /* _FFR_BESTMX_BETTER_TRUNCATION */
|
|
p = buf;
|
|
for (i = 0; i < nmx; i++)
|
|
{
|
|
size_t slen;
|
|
|
|
if (strchr(mxhosts[i], map->map_coldelim) != NULL)
|
|
{
|
|
syserr("bestmx_map_lookup: MX host %.64s includes map delimiter character 0x%02X",
|
|
mxhosts[i], map->map_coldelim);
|
|
return NULL;
|
|
}
|
|
slen = strlen(mxhosts[i]);
|
|
if (len + slen + 2 > sizeof buf)
|
|
break;
|
|
if (i > 0)
|
|
{
|
|
*p++ = map->map_coldelim;
|
|
len++;
|
|
}
|
|
(void) sm_strlcpy(p, mxhosts[i], sizeof buf - len);
|
|
p += slen;
|
|
len += slen;
|
|
}
|
|
#endif /* _FFR_BESTMX_BETTER_TRUNCATION */
|
|
|
|
result = map_rewrite(map, buf, len, av);
|
|
#if _FFR_BESTMX_BETTER_TRUNCATION
|
|
sm_free(buf);
|
|
#endif /* _FFR_BESTMX_BETTER_TRUNCATION */
|
|
return result;
|
|
}
|
|
/*
|
|
** DNS_GETCANONNAME -- get the canonical name for named host using DNS
|
|
**
|
|
** This algorithm tries to be smart about wildcard MX records.
|
|
** This is hard to do because DNS doesn't tell is if we matched
|
|
** against a wildcard or a specific MX.
|
|
**
|
|
** We always prefer A & CNAME records, since these are presumed
|
|
** to be specific.
|
|
**
|
|
** If we match an MX in one pass and lose it in the next, we use
|
|
** the old one. For example, consider an MX matching *.FOO.BAR.COM.
|
|
** A hostname bletch.foo.bar.com will match against this MX, but
|
|
** will stop matching when we try bletch.bar.com -- so we know
|
|
** that bletch.foo.bar.com must have been right. This fails if
|
|
** there was also an MX record matching *.BAR.COM, but there are
|
|
** some things that just can't be fixed.
|
|
**
|
|
** Parameters:
|
|
** host -- a buffer containing the name of the host.
|
|
** This is a value-result parameter.
|
|
** hbsize -- the size of the host buffer.
|
|
** trymx -- if set, try MX records as well as A and CNAME.
|
|
** statp -- pointer to place to store status.
|
|
** pttl -- pointer to return TTL (can be NULL).
|
|
**
|
|
** Returns:
|
|
** true -- if the host matched.
|
|
** false -- otherwise.
|
|
*/
|
|
|
|
bool
|
|
dns_getcanonname(host, hbsize, trymx, statp, pttl)
|
|
char *host;
|
|
int hbsize;
|
|
bool trymx;
|
|
int *statp;
|
|
int *pttl;
|
|
{
|
|
register unsigned char *eom, *ap;
|
|
register char *cp;
|
|
register int n;
|
|
HEADER *hp;
|
|
querybuf answer;
|
|
int ancount, qdcount;
|
|
int ret;
|
|
char **domain;
|
|
int type;
|
|
int ttl = 0;
|
|
char **dp;
|
|
char *mxmatch;
|
|
bool amatch;
|
|
bool gotmx = false;
|
|
int qtype;
|
|
int initial;
|
|
int loopcnt;
|
|
char *xp;
|
|
char nbuf[SM_MAX(MAXPACKET, MAXDNAME*2+2)];
|
|
char *searchlist[MAXDNSRCH + 2];
|
|
|
|
if (tTd(8, 2))
|
|
sm_dprintf("dns_getcanonname(%s, trymx=%d)\n", host, trymx);
|
|
|
|
if ((_res.options & RES_INIT) == 0 && res_init() == -1)
|
|
{
|
|
*statp = EX_UNAVAILABLE;
|
|
return false;
|
|
}
|
|
|
|
*statp = EX_OK;
|
|
|
|
/*
|
|
** Initialize domain search list. If there is at least one
|
|
** dot in the name, search the unmodified name first so we
|
|
** find "vse.CS" in Czechoslovakia instead of in the local
|
|
** domain (e.g., vse.CS.Berkeley.EDU). Note that there is no
|
|
** longer a country named Czechoslovakia but this type of problem
|
|
** is still present.
|
|
**
|
|
** Older versions of the resolver could create this
|
|
** list by tearing apart the host name.
|
|
*/
|
|
|
|
loopcnt = 0;
|
|
cnameloop:
|
|
/* Check for dots in the name */
|
|
for (cp = host, n = 0; *cp != '\0'; cp++)
|
|
if (*cp == '.')
|
|
n++;
|
|
|
|
/*
|
|
** If this is a simple name, determine whether it matches an
|
|
** alias in the file defined by the environment variable HOSTALIASES.
|
|
*/
|
|
|
|
if (n == 0 && (xp = gethostalias(host)) != NULL)
|
|
{
|
|
if (loopcnt++ > MAXCNAMEDEPTH)
|
|
{
|
|
syserr("loop in ${HOSTALIASES} file");
|
|
}
|
|
else
|
|
{
|
|
(void) sm_strlcpy(host, xp, hbsize);
|
|
goto cnameloop;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Build the search list.
|
|
** If there is at least one dot in name, start with a null
|
|
** domain to search the unmodified name first.
|
|
** If name does not end with a dot and search up local domain
|
|
** tree desired, append each local domain component to the
|
|
** search list; if name contains no dots and default domain
|
|
** name is desired, append default domain name to search list;
|
|
** else if name ends in a dot, remove that dot.
|
|
*/
|
|
|
|
dp = searchlist;
|
|
if (n > 0)
|
|
*dp++ = "";
|
|
if (n >= 0 && *--cp != '.' && bitset(RES_DNSRCH, _res.options))
|
|
{
|
|
/* make sure there are less than MAXDNSRCH domains */
|
|
for (domain = RES_DNSRCH_VARIABLE, ret = 0;
|
|
*domain != NULL && ret < MAXDNSRCH;
|
|
ret++)
|
|
*dp++ = *domain++;
|
|
}
|
|
else if (n == 0 && bitset(RES_DEFNAMES, _res.options))
|
|
{
|
|
*dp++ = _res.defdname;
|
|
}
|
|
else if (*cp == '.')
|
|
{
|
|
*cp = '\0';
|
|
}
|
|
*dp = NULL;
|
|
|
|
/*
|
|
** Now loop through the search list, appending each domain in turn
|
|
** name and searching for a match.
|
|
*/
|
|
|
|
mxmatch = NULL;
|
|
initial = T_A;
|
|
# if NETINET6
|
|
if (InetMode == AF_INET6)
|
|
initial = T_AAAA;
|
|
# endif /* NETINET6 */
|
|
qtype = initial;
|
|
|
|
for (dp = searchlist; *dp != NULL; )
|
|
{
|
|
if (qtype == initial)
|
|
gotmx = false;
|
|
if (tTd(8, 5))
|
|
sm_dprintf("dns_getcanonname: trying %s.%s (%s)\n",
|
|
host, *dp,
|
|
# if NETINET6
|
|
qtype == T_AAAA ? "AAAA" :
|
|
# endif /* NETINET6 */
|
|
qtype == T_A ? "A" :
|
|
qtype == T_MX ? "MX" :
|
|
"???");
|
|
errno = 0;
|
|
ret = res_querydomain(host, *dp, C_IN, qtype,
|
|
answer.qb2, sizeof(answer.qb2));
|
|
if (ret <= 0)
|
|
{
|
|
int save_errno = errno;
|
|
|
|
if (tTd(8, 7))
|
|
sm_dprintf("\tNO: errno=%d, h_errno=%d\n",
|
|
save_errno, h_errno);
|
|
|
|
if (save_errno == ECONNREFUSED || h_errno == TRY_AGAIN)
|
|
{
|
|
/*
|
|
** the name server seems to be down or broken.
|
|
*/
|
|
|
|
SM_SET_H_ERRNO(TRY_AGAIN);
|
|
# if _FFR_DONT_STOP_LOOKING
|
|
if (**dp == '\0')
|
|
{
|
|
if (*statp == EX_OK)
|
|
*statp = EX_TEMPFAIL;
|
|
goto nexttype;
|
|
}
|
|
# endif /* _FFR_DONT_STOP_LOOKING */
|
|
*statp = EX_TEMPFAIL;
|
|
|
|
if (WorkAroundBrokenAAAA)
|
|
{
|
|
/*
|
|
** Only return if not TRY_AGAIN as an
|
|
** attempt with a different qtype may
|
|
** succeed (res_querydomain() calls
|
|
** res_query() calls res_send() which
|
|
** sets errno to ETIMEDOUT if the
|
|
** nameservers could be contacted but
|
|
** didn't give an answer).
|
|
*/
|
|
|
|
if (save_errno != ETIMEDOUT)
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
# if _FFR_DONT_STOP_LOOKING
|
|
nexttype:
|
|
# endif /* _FFR_DONT_STOP_LOOKING */
|
|
if (h_errno != HOST_NOT_FOUND)
|
|
{
|
|
/* might have another type of interest */
|
|
# if NETINET6
|
|
if (qtype == T_AAAA)
|
|
{
|
|
qtype = T_A;
|
|
continue;
|
|
}
|
|
else
|
|
# endif /* NETINET6 */
|
|
if (qtype == T_A && !gotmx &&
|
|
(trymx || **dp == '\0'))
|
|
{
|
|
qtype = T_MX;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* definite no -- try the next domain */
|
|
dp++;
|
|
qtype = initial;
|
|
continue;
|
|
}
|
|
else if (tTd(8, 7))
|
|
sm_dprintf("\tYES\n");
|
|
|
|
/* avoid problems after truncation in tcp packets */
|
|
if (ret > sizeof(answer))
|
|
ret = sizeof(answer);
|
|
if (ret < 0)
|
|
{
|
|
*statp = EX_SOFTWARE;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** Appear to have a match. Confirm it by searching for A or
|
|
** CNAME records. If we don't have a local domain
|
|
** wild card MX record, we will accept MX as well.
|
|
*/
|
|
|
|
hp = (HEADER *) &answer;
|
|
ap = (unsigned char *) &answer + HFIXEDSZ;
|
|
eom = (unsigned char *) &answer + ret;
|
|
|
|
/* skip question part of response -- we know what we asked */
|
|
for (qdcount = ntohs((unsigned short) hp->qdcount);
|
|
qdcount--;
|
|
ap += ret + QFIXEDSZ)
|
|
{
|
|
if ((ret = dn_skipname(ap, eom)) < 0)
|
|
{
|
|
if (tTd(8, 20))
|
|
sm_dprintf("qdcount failure (%d)\n",
|
|
ntohs((unsigned short) hp->qdcount));
|
|
*statp = EX_SOFTWARE;
|
|
return false; /* ???XXX??? */
|
|
}
|
|
}
|
|
|
|
amatch = false;
|
|
for (ancount = ntohs((unsigned short) hp->ancount);
|
|
--ancount >= 0 && ap < eom;
|
|
ap += n)
|
|
{
|
|
n = dn_expand((unsigned char *) &answer, eom, ap,
|
|
(RES_UNC_T) nbuf, sizeof nbuf);
|
|
if (n < 0)
|
|
break;
|
|
ap += n;
|
|
GETSHORT(type, ap);
|
|
ap += INT16SZ; /* skip over class */
|
|
GETLONG(ttl, ap);
|
|
GETSHORT(n, ap); /* rdlength */
|
|
switch (type)
|
|
{
|
|
case T_MX:
|
|
gotmx = true;
|
|
if (**dp != '\0' && HasWildcardMX)
|
|
{
|
|
/*
|
|
** If we are using MX matches and have
|
|
** not yet gotten one, save this one
|
|
** but keep searching for an A or
|
|
** CNAME match.
|
|
*/
|
|
|
|
if (trymx && mxmatch == NULL)
|
|
mxmatch = *dp;
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
** If we did not append a domain name, this
|
|
** must have been a canonical name to start
|
|
** with. Even if we did append a domain name,
|
|
** in the absence of a wildcard MX this must
|
|
** still be a real MX match.
|
|
** Such MX matches are as good as an A match,
|
|
** fall through.
|
|
*/
|
|
/* FALLTHROUGH */
|
|
|
|
# if NETINET6
|
|
case T_AAAA:
|
|
# endif /* NETINET6 */
|
|
case T_A:
|
|
/* Flag that a good match was found */
|
|
amatch = true;
|
|
|
|
/* continue in case a CNAME also exists */
|
|
continue;
|
|
|
|
case T_CNAME:
|
|
if (DontExpandCnames)
|
|
{
|
|
/* got CNAME -- guaranteed canonical */
|
|
amatch = true;
|
|
break;
|
|
}
|
|
|
|
if (loopcnt++ > MAXCNAMEDEPTH)
|
|
{
|
|
/*XXX should notify postmaster XXX*/
|
|
message("DNS failure: CNAME loop for %s",
|
|
host);
|
|
if (CurEnv->e_message == NULL)
|
|
{
|
|
char ebuf[MAXLINE];
|
|
|
|
(void) sm_snprintf(ebuf,
|
|
sizeof ebuf,
|
|
"Deferred: DNS failure: CNAME loop for %.100s",
|
|
host);
|
|
CurEnv->e_message =
|
|
sm_rpool_strdup_x(
|
|
CurEnv->e_rpool, ebuf);
|
|
}
|
|
SM_SET_H_ERRNO(NO_RECOVERY);
|
|
*statp = EX_CONFIG;
|
|
return false;
|
|
}
|
|
|
|
/* value points at name */
|
|
if ((ret = dn_expand((unsigned char *)&answer,
|
|
eom, ap, (RES_UNC_T) nbuf,
|
|
sizeof(nbuf))) < 0)
|
|
break;
|
|
(void) sm_strlcpy(host, nbuf, hbsize);
|
|
|
|
/*
|
|
** RFC 1034 section 3.6 specifies that CNAME
|
|
** should point at the canonical name -- but
|
|
** urges software to try again anyway.
|
|
*/
|
|
|
|
goto cnameloop;
|
|
|
|
default:
|
|
/* not a record of interest */
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (amatch)
|
|
{
|
|
/*
|
|
** Got a good match -- either an A, CNAME, or an
|
|
** exact MX record. Save it and get out of here.
|
|
*/
|
|
|
|
mxmatch = *dp;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
** Nothing definitive yet.
|
|
** If this was a T_A query and we haven't yet found a MX
|
|
** match, try T_MX if allowed to do so.
|
|
** Otherwise, try the next domain.
|
|
*/
|
|
|
|
# if NETINET6
|
|
if (qtype == T_AAAA)
|
|
qtype = T_A;
|
|
else
|
|
# endif /* NETINET6 */
|
|
if (qtype == T_A && !gotmx && (trymx || **dp == '\0'))
|
|
qtype = T_MX;
|
|
else
|
|
{
|
|
qtype = initial;
|
|
dp++;
|
|
}
|
|
}
|
|
|
|
/* if nothing was found, we are done */
|
|
if (mxmatch == NULL)
|
|
{
|
|
if (*statp == EX_OK)
|
|
*statp = EX_NOHOST;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
** Create canonical name and return.
|
|
** If saved domain name is null, name was already canonical.
|
|
** Otherwise append the saved domain name.
|
|
*/
|
|
|
|
(void) sm_snprintf(nbuf, sizeof nbuf, "%.*s%s%.*s", MAXDNAME, host,
|
|
*mxmatch == '\0' ? "" : ".",
|
|
MAXDNAME, mxmatch);
|
|
(void) sm_strlcpy(host, nbuf, hbsize);
|
|
if (tTd(8, 5))
|
|
sm_dprintf("dns_getcanonname: %s\n", host);
|
|
*statp = EX_OK;
|
|
|
|
/* return only one TTL entry, that should be sufficient */
|
|
if (ttl > 0 && pttl != NULL)
|
|
*pttl = ttl;
|
|
return true;
|
|
}
|
|
|
|
static char *
|
|
gethostalias(host)
|
|
char *host;
|
|
{
|
|
char *fname;
|
|
SM_FILE_T *fp;
|
|
register char *p = NULL;
|
|
long sff = SFF_REGONLY;
|
|
char buf[MAXLINE];
|
|
static char hbuf[MAXDNAME];
|
|
|
|
if (ResNoAliases)
|
|
return NULL;
|
|
if (DontLockReadFiles)
|
|
sff |= SFF_NOLOCK;
|
|
fname = getenv("HOSTALIASES");
|
|
if (fname == NULL ||
|
|
(fp = safefopen(fname, O_RDONLY, 0, sff)) == NULL)
|
|
return NULL;
|
|
while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf, sizeof buf) != NULL)
|
|
{
|
|
for (p = buf; p != '\0' && !(isascii(*p) && isspace(*p)); p++)
|
|
continue;
|
|
if (*p == 0)
|
|
{
|
|
/* syntax error */
|
|
continue;
|
|
}
|
|
*p++ = '\0';
|
|
if (sm_strcasecmp(buf, host) == 0)
|
|
break;
|
|
}
|
|
|
|
if (sm_io_eof(fp))
|
|
{
|
|
/* no match */
|
|
(void) sm_io_close(fp, SM_TIME_DEFAULT);
|
|
return NULL;
|
|
}
|
|
(void) sm_io_close(fp, SM_TIME_DEFAULT);
|
|
|
|
/* got a match; extract the equivalent name */
|
|
while (*p != '\0' && isascii(*p) && isspace(*p))
|
|
p++;
|
|
host = p;
|
|
while (*p != '\0' && !(isascii(*p) && isspace(*p)))
|
|
p++;
|
|
*p = '\0';
|
|
(void) sm_strlcpy(hbuf, host, sizeof hbuf);
|
|
return hbuf;
|
|
}
|
|
#endif /* NAMED_BIND */
|