contrib/sendmail-8.14/sendmail/domain.c

   1 /*
   2  * Copyright (c) 1998-2004, 2006, 2010 Sendmail, Inc. and its suppliers.
   3  *      All rights reserved.
   4  * Copyright (c) 1986, 1995-1997 Eric P. Allman.  All rights reserved.
   5  * Copyright (c) 1988, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * By using this file, you agree to the terms and conditions set
   9  * forth in the LICENSE file which can be found at the top level of
  10  * the sendmail distribution.
  11  *
  12  */
  13
  14 #include <sendmail.h>
  15 #include "map.h"
  16
  17 #if NAMED_BIND
  18 SM_RCSID("@(#)$Id: domain.c,v 8.204 2010/06/29 15:35:33 ca Exp $ (with name server)")
  19 #else /* NAMED_BIND */
  20 SM_RCSID("@(#)$Id: domain.c,v 8.204 2010/06/29 15:35:33 ca Exp $ (without name server)")
  21 #endif /* NAMED_BIND */
  22
  23 #if NAMED_BIND
  24
  25 # include <arpa/inet.h>
  26
  27
  28 # ifndef MXHOSTBUFSIZE
  29 #  define MXHOSTBUFSIZE (128 * MAXMXHOSTS)
  30 # endif /* ! MXHOSTBUFSIZE */
  31
  32 static char     MXHostBuf[MXHOSTBUFSIZE];
  33 #if (MXHOSTBUFSIZE < 2) || (MXHOSTBUFSIZE >= INT_MAX/2)
  34         ERROR: _MXHOSTBUFSIZE is out of range
  35 #endif /* (MXHOSTBUFSIZE < 2) || (MXHOSTBUFSIZE >= INT_MAX/2) */
  36
  37 # ifndef MAXDNSRCH
  38 #  define MAXDNSRCH     6       /* number of possible domains to search */
  39 # endif /* ! MAXDNSRCH */
  40
  41 # ifndef RES_DNSRCH_VARIABLE
  42 #  define RES_DNSRCH_VARIABLE   _res.dnsrch
  43 # endif /* ! RES_DNSRCH_VARIABLE */
  44
  45 # ifndef NO_DATA
  46 #  define NO_DATA       NO_ADDRESS
  47 # endif /* ! NO_DATA */
  48
  49 # ifndef HFIXEDSZ
  50 #  define HFIXEDSZ      12      /* sizeof(HEADER) */
  51 # endif /* ! HFIXEDSZ */
  52
  53 # define MAXCNAMEDEPTH  10      /* maximum depth of CNAME recursion */
  54
  55 # if defined(__RES) && (__RES >= 19940415)
  56 #  define RES_UNC_T     char *
  57 # else /* defined(__RES) && (__RES >= 19940415) */
  58 #  define RES_UNC_T     unsigned char *
  59 # endif /* defined(__RES) && (__RES >= 19940415) */
  60
  61 static int      mxrand __P((char *));
  62 static int      fallbackmxrr __P((int, unsigned short *, char **));
  63
  64 /*
  65 **  GETFALLBACKMXRR -- get MX resource records for fallback MX host.
  66 **
  67 **      We have to initialize this once before doing anything else.
  68 **      Moreover, we have to repeat this from time to time to avoid
  69 **      stale data, e.g., in persistent queue runners.
  70 **      This should be done in a parent process so the child
  71 **      processes have the right data.
  72 **
  73 **      Parameters:
  74 **              host -- the name of the fallback MX host.
  75 **
  76 **      Returns:
  77 **              number of MX records.
  78 **
  79 **      Side Effects:
  80 **              Populates NumFallbackMXHosts and fbhosts.
  81 **              Sets renewal time (based on TTL).
  82 */
  83
  84 int NumFallbackMXHosts = 0;     /* Number of fallback MX hosts (after MX expansion) */
  85 static char *fbhosts[MAXMXHOSTS + 1];
  86
  87 int
  88 getfallbackmxrr(host)
  89         char *host;
  90 {
  91         int i, rcode;
  92         int ttl;
  93         static time_t renew = 0;
  94
  95 #if 0
  96         /* This is currently done before this function is called. */
  97         if (host == NULL || *host == '\0')
  98                 return 0;
  99 #endif /* 0 */
 100         if (NumFallbackMXHosts > 0 && renew > curtime())
 101                 return NumFallbackMXHosts;
 102         if (host[0] == '[')
 103         {
 104                 fbhosts[0] = host;
 105                 NumFallbackMXHosts = 1;
 106         }
 107         else
 108         {
 109                 /* free old data */
 110                 for (i = 0; i < NumFallbackMXHosts; i++)
 111                         sm_free(fbhosts[i]);
 112
 113                 /* get new data */
 114                 NumFallbackMXHosts = getmxrr(host, fbhosts, NULL, false,
 115                                              &rcode, false, &ttl);
 116                 renew = curtime() + ttl;
 117                 for (i = 0; i < NumFallbackMXHosts; i++)
 118                         fbhosts[i] = newstr(fbhosts[i]);
 119         }
 120         return NumFallbackMXHosts;
 121 }
 122
 123 /*
 124 **  FALLBACKMXRR -- add MX resource records for fallback MX host to list.
 125 **
 126 **      Parameters:
 127 **              nmx -- current number of MX records.
 128 **              prefs -- array of preferences.
 129 **              mxhosts -- array of MX hosts (maximum size: MAXMXHOSTS)
 130 **
 131 **      Returns:
 132 **              new number of MX records.
 133 **
 134 **      Side Effects:
 135 **              If FallbackMX was set, it appends the MX records for
 136 **              that host to mxhosts (and modifies prefs accordingly).
 137 */
 138
 139 static int
 140 fallbackmxrr(nmx, prefs, mxhosts)
 141         int nmx;
 142         unsigned short *prefs;
 143         char **mxhosts;
 144 {
 145         int i;
 146
 147         for (i = 0; i < NumFallbackMXHosts && nmx < MAXMXHOSTS; i++)
 148         {
 149                 if (nmx > 0)
 150                         prefs[nmx] = prefs[nmx - 1] + 1;
 151                 else
 152                         prefs[nmx] = 0;
 153                 mxhosts[nmx++] = fbhosts[i];
 154         }
 155         return nmx;
 156 }
 157
 158 /*
 159 **  GETMXRR -- get MX resource records for a domain
 160 **
 161 **      Parameters:
 162 **              host -- the name of the host to MX.
 163 **              mxhosts -- a pointer to a return buffer of MX records.
 164 **              mxprefs -- a pointer to a return buffer of MX preferences.
 165 **                      If NULL, don't try to populate.
 166 **              droplocalhost -- If true, all MX records less preferred
 167 **                      than the local host (as determined by $=w) will
 168 **                      be discarded.
 169 **              rcode -- a pointer to an EX_ status code.
 170 **              tryfallback -- add also fallback MX host?
 171 **              pttl -- pointer to return TTL (can be NULL).
 172 **
 173 **      Returns:
 174 **              The number of MX records found.
 175 **              -1 if there is an internal failure.
 176 **              If no MX records are found, mxhosts[0] is set to host
 177 **                      and 1 is returned.
 178 **
 179 **      Side Effects:
 180 **              The entries made for mxhosts point to a static array
 181 **              MXHostBuf[MXHOSTBUFSIZE], so the data needs to be copied,
 182 **              if it must be preserved across calls to this function.
 183 */
 184
 185 int
 186 getmxrr(host, mxhosts, mxprefs, droplocalhost, rcode, tryfallback, pttl)
 187         char *host;
 188         char **mxhosts;
 189         unsigned short *mxprefs;
 190         bool droplocalhost;
 191         int *rcode;
 192         bool tryfallback;
 193         int *pttl;
 194 {
 195         register unsigned char *eom, *cp;
 196         register int i, j, n;
 197         int nmx = 0;
 198         register char *bp;
 199         HEADER *hp;
 200         querybuf answer;
 201         int ancount, qdcount, buflen;
 202         bool seenlocal = false;
 203         unsigned short pref, type;
 204         unsigned short localpref = 256;
 205         char *fallbackMX = FallbackMX;
 206         bool trycanon = false;
 207         unsigned short *prefs;
 208         int (*resfunc) __P((const char *, int, int, u_char *, int));
 209         unsigned short prefer[MAXMXHOSTS];
 210         int weight[MAXMXHOSTS];
 211         int ttl = 0;
 212         extern int res_query(), res_search();
 213
 214         if (tTd(8, 2))
 215                 sm_dprintf("getmxrr(%s, droplocalhost=%d)\n",
 216                            host, droplocalhost);
 217         *rcode = EX_OK;
 218         if (pttl != NULL)
 219                 *pttl = SM_DEFAULT_TTL;
 220         if (*host == '\0')
 221                 return 0;
 222
 223         if ((fallbackMX != NULL && droplocalhost &&
 224              wordinclass(fallbackMX, 'w')) || !tryfallback)
 225         {
 226                 /* don't use fallback for this pass */
 227                 fallbackMX = NULL;
 228         }
 229
 230         if (mxprefs != NULL)
 231                 prefs = mxprefs;
 232         else
 233                 prefs = prefer;
 234
 235         /* efficiency hack -- numeric or non-MX lookups */
 236         if (host[0] == '[')
 237                 goto punt;
 238
 239         /*
 240         **  If we don't have MX records in our host switch, don't
 241         **  try for MX records.  Note that this really isn't "right",
 242         **  since we might be set up to try NIS first and then DNS;
 243         **  if the host is found in NIS we really shouldn't be doing
 244         **  MX lookups.  However, that should be a degenerate case.
 245         */
 246
 247         if (!UseNameServer)
 248                 goto punt;
 249         if (HasWildcardMX && ConfigLevel >= 6)
 250                 resfunc = res_query;
 251         else
 252                 resfunc = res_search;
 253
 254         errno = 0;
 255         n = (*resfunc)(host, C_IN, T_MX, (unsigned char *) &answer,
 256                        sizeof(answer));
 257         if (n < 0)
 258         {
 259                 if (tTd(8, 1))
 260                         sm_dprintf("getmxrr: res_search(%s) failed (errno=%d, h_errno=%d)\n",
 261                                 host, errno, h_errno);
 262                 switch (h_errno)
 263                 {
 264                   case NO_DATA:
 265                         trycanon = true;
 266                         /* FALLTHROUGH */
 267
 268                   case NO_RECOVERY:
 269                         /* no MX data on this host */
 270                         goto punt;
 271
 272                   case HOST_NOT_FOUND:
 273 # if BROKEN_RES_SEARCH
 274                   case 0:       /* Ultrix resolver retns failure w/ h_errno=0 */
 275 # endif /* BROKEN_RES_SEARCH */
 276                         /* host doesn't exist in DNS; might be in /etc/hosts */
 277                         trycanon = true;
 278                         *rcode = EX_NOHOST;
 279                         goto punt;
 280
 281                   case TRY_AGAIN:
 282                   case -1:
 283                         /* couldn't connect to the name server */
 284                         if (fallbackMX != NULL)
 285                         {
 286                                 /* name server is hosed -- push to fallback */
 287                                 return fallbackmxrr(nmx, prefs, mxhosts);
 288                         }
 289                         /* it might come up later; better queue it up */
 290                         *rcode = EX_TEMPFAIL;
 291                         break;
 292
 293                   default:
 294                         syserr("getmxrr: res_search (%s) failed with impossible h_errno (%d)",
 295                                 host, h_errno);
 296                         *rcode = EX_OSERR;
 297                         break;
 298                 }
 299
 300                 /* irreconcilable differences */
 301                 return -1;
 302         }
 303
 304         /* avoid problems after truncation in tcp packets */
 305         if (n > sizeof(answer))
 306                 n = sizeof(answer);
 307
 308         /* find first satisfactory answer */
 309         hp = (HEADER *)&answer;
 310         cp = (unsigned char *)&answer + HFIXEDSZ;
 311         eom = (unsigned char *)&answer + n;
 312         for (qdcount = ntohs((unsigned short) hp->qdcount);
 313              qdcount--;
 314              cp += n + QFIXEDSZ)
 315         {
 316                 if ((n = dn_skipname(cp, eom)) < 0)
 317                         goto punt;
 318         }
 319
 320         /* NOTE: see definition of MXHostBuf! */
 321         buflen = sizeof(MXHostBuf) - 1;
 322         SM_ASSERT(buflen > 0);
 323         bp = MXHostBuf;
 324         ancount = ntohs((unsigned short) hp->ancount);
 325
 326         /* See RFC 1035 for layout of RRs. */
 327         /* XXX leave room for FallbackMX ? */
 328         while (--ancount >= 0 && cp < eom && nmx < MAXMXHOSTS - 1)
 329         {
 330                 if ((n = dn_expand((unsigned char *)&answer, eom, cp,
 331                                    (RES_UNC_T) bp, buflen)) < 0)
 332                         break;
 333                 cp += n;
 334                 GETSHORT(type, cp);
 335                 cp += INT16SZ;          /* skip over class */
 336                 GETLONG(ttl, cp);
 337                 GETSHORT(n, cp);        /* rdlength */
 338                 if (type != T_MX)
 339                 {
 340                         if (tTd(8, 8) || _res.options & RES_DEBUG)
 341                                 sm_dprintf("unexpected answer type %d, size %d\n",
 342                                         type, n);
 343                         cp += n;
 344                         continue;
 345                 }
 346                 GETSHORT(pref, cp);
 347                 if ((n = dn_expand((unsigned char *)&answer, eom, cp,
 348                                    (RES_UNC_T) bp, buflen)) < 0)
 349                         break;
 350                 cp += n;
 351                 n = strlen(bp);
 352 # if 0
 353                 /* Can this happen? */
 354                 if (n == 0)
 355                 {
 356                         if (LogLevel > 4)
 357                                 sm_syslog(LOG_ERR, NOQID,
 358                                           "MX records for %s contain empty string",
 359                                           host);
 360                         continue;
 361                 }
 362 # endif /* 0 */
 363                 if (wordinclass(bp, 'w'))
 364                 {
 365                         if (tTd(8, 3))
 366                                 sm_dprintf("found localhost (%s) in MX list, pref=%d\n",
 367                                         bp, pref);
 368                         if (droplocalhost)
 369                         {
 370                                 if (!seenlocal || pref < localpref)
 371                                         localpref = pref;
 372                                 seenlocal = true;
 373                                 continue;
 374                         }
 375                         weight[nmx] = 0;
 376                 }
 377                 else
 378                         weight[nmx] = mxrand(bp);
 379                 prefs[nmx] = pref;
 380                 mxhosts[nmx++] = bp;
 381                 bp += n;
 382                 if (bp[-1] != '.')
 383                 {
 384                         *bp++ = '.';
 385                         n++;
 386                 }
 387                 *bp++ = '\0';
 388                 if (buflen < n + 1)
 389                 {
 390                         /* don't want to wrap buflen */
 391                         break;
 392                 }
 393                 buflen -= n + 1;
 394         }
 395
 396         /* return only one TTL entry, that should be sufficient */
 397         if (ttl > 0 && pttl != NULL)
 398                 *pttl = ttl;
 399
 400         /* sort the records */
 401         for (i = 0; i < nmx; i++)
 402         {
 403                 for (j = i + 1; j < nmx; j++)
 404                 {
 405                         if (prefs[i] > prefs[j] ||
 406                             (prefs[i] == prefs[j] && weight[i] > weight[j]))
 407                         {
 408                                 register int temp;
 409                                 register char *temp1;
 410
 411                                 temp = prefs[i];
 412                                 prefs[i] = prefs[j];
 413                                 prefs[j] = temp;
 414                                 temp1 = mxhosts[i];
 415                                 mxhosts[i] = mxhosts[j];
 416                                 mxhosts[j] = temp1;
 417                                 temp = weight[i];
 418                                 weight[i] = weight[j];
 419                                 weight[j] = temp;
 420                         }
 421                 }
 422                 if (seenlocal && prefs[i] >= localpref)
 423                 {
 424                         /* truncate higher preference part of list */
 425                         nmx = i;
 426                 }
 427         }
 428
 429         /* delete duplicates from list (yes, some bozos have duplicates) */
 430         for (i = 0; i < nmx - 1; )
 431         {
 432                 if (sm_strcasecmp(mxhosts[i], mxhosts[i + 1]) != 0)
 433                         i++;
 434                 else
 435                 {
 436                         /* compress out duplicate */
 437                         for (j = i + 1; j < nmx; j++)
 438                         {
 439                                 mxhosts[j] = mxhosts[j + 1];
 440                                 prefs[j] = prefs[j + 1];
 441                         }
 442                         nmx--;
 443                 }
 444         }
 445
 446         if (nmx == 0)
 447         {
 448 punt:
 449                 if (seenlocal)
 450                 {
 451                         struct hostent *h = NULL;
 452
 453                         /*
 454                         **  If we have deleted all MX entries, this is
 455                         **  an error -- we should NEVER send to a host that
 456                         **  has an MX, and this should have been caught
 457                         **  earlier in the config file.
 458                         **
 459                         **  Some sites prefer to go ahead and try the
 460                         **  A record anyway; that case is handled by
 461                         **  setting TryNullMXList.  I believe this is a
 462                         **  bad idea, but it's up to you....
 463                         */
 464
 465                         if (TryNullMXList)
 466                         {
 467                                 SM_SET_H_ERRNO(0);
 468                                 errno = 0;
 469                                 h = sm_gethostbyname(host, AF_INET);
 470                                 if (h == NULL)
 471                                 {
 472                                         if (errno == ETIMEDOUT ||
 473                                             h_errno == TRY_AGAIN ||
 474                                             (errno == ECONNREFUSED &&
 475                                              UseNameServer))
 476                                         {
 477                                                 *rcode = EX_TEMPFAIL;
 478                                                 return -1;
 479                                         }
 480 # if NETINET6
 481                                         SM_SET_H_ERRNO(0);
 482                                         errno = 0;
 483                                         h = sm_gethostbyname(host, AF_INET6);
 484                                         if (h == NULL &&
 485                                             (errno == ETIMEDOUT ||
 486                                              h_errno == TRY_AGAIN ||
 487                                              (errno == ECONNREFUSED &&
 488                                               UseNameServer)))
 489                                         {
 490                                                 *rcode = EX_TEMPFAIL;
 491                                                 return -1;
 492                                         }
 493 # endif /* NETINET6 */
 494                                 }
 495                         }
 496
 497                         if (h == NULL)
 498                         {
 499                                 *rcode = EX_CONFIG;
 500                                 syserr("MX list for %s points back to %s",
 501                                        host, MyHostName);
 502                                 return -1;
 503                         }
 504 # if NETINET6
 505                         freehostent(h);
 506                         h = NULL;
 507 # endif /* NETINET6 */
 508                 }
 509                 if (strlen(host) >= sizeof(MXHostBuf))
 510                 {
 511                         *rcode = EX_CONFIG;
 512                         syserr("Host name %s too long",
 513                                shortenstring(host, MAXSHORTSTR));
 514                         return -1;
 515                 }
 516                 (void) sm_strlcpy(MXHostBuf, host, sizeof(MXHostBuf));
 517                 mxhosts[0] = MXHostBuf;
 518                 prefs[0] = 0;
 519                 if (host[0] == '[')
 520                 {
 521                         register char *p;
 522 # if NETINET6
 523                         struct sockaddr_in6 tmp6;
 524 # endif /* NETINET6 */
 525
 526                         /* this may be an MX suppression-style address */
 527                         p = strchr(MXHostBuf, ']');
 528                         if (p != NULL)
 529                         {
 530                                 *p = '\0';
 531
 532                                 if (inet_addr(&MXHostBuf[1]) != INADDR_NONE)
 533                                 {
 534                                         nmx++;
 535                                         *p = ']';
 536                                 }
 537 # if NETINET6
 538                                 else if (anynet_pton(AF_INET6, &MXHostBuf[1],
 539                                                      &tmp6.sin6_addr) == 1)
 540                                 {
 541                                         nmx++;
 542                                         *p = ']';
 543                                 }
 544 # endif /* NETINET6 */
 545                                 else
 546                                 {
 547                                         trycanon = true;
 548                                         mxhosts[0]++;
 549                                 }
 550                         }
 551                 }
 552                 if (trycanon &&
 553                     getcanonname(mxhosts[0], sizeof(MXHostBuf) - 2, false, pttl))
 554                 {
 555                         /* XXX MXHostBuf == "" ?  is that possible? */
 556                         bp = &MXHostBuf[strlen(MXHostBuf)];
 557                         if (bp[-1] != '.')
 558                         {
 559                                 *bp++ = '.';
 560                                 *bp = '\0';
 561                         }
 562                         nmx = 1;
 563                 }
 564         }
 565
 566         /* if we have a default lowest preference, include that */
 567         if (fallbackMX != NULL && !seenlocal)
 568         {
 569                 nmx = fallbackmxrr(nmx, prefs, mxhosts);
 570         }
 571         return nmx;
 572 }
 573 /*
 574 **  MXRAND -- create a randomizer for equal MX preferences
 575 **
 576 **      If two MX hosts have equal preferences we want to randomize
 577 **      the selection.  But in order for signatures to be the same,
 578 **      we need to randomize the same way each time.  This function
 579 **      computes a pseudo-random hash function from the host name.
 580 **
 581 **      Parameters:
 582 **              host -- the name of the host.
 583 **
 584 **      Returns:
 585 **              A random but repeatable value based on the host name.
 586 */
 587
 588 static int
 589 mxrand(host)
 590         register char *host;
 591 {
 592         int hfunc;
 593         static unsigned int seed;
 594
 595         if (seed == 0)
 596         {
 597                 seed = (int) curtime() & 0xffff;
 598                 if (seed == 0)
 599                         seed++;
 600         }
 601
 602         if (tTd(17, 9))
 603                 sm_dprintf("mxrand(%s)", host);
 604
 605         hfunc = seed;
 606         while (*host != '\0')
 607         {
 608                 int c = *host++;
 609
 610                 if (isascii(c) && isupper(c))
 611                         c = tolower(c);
 612                 hfunc = ((hfunc << 1) ^ c) % 2003;
 613         }
 614
 615         hfunc &= 0xff;
 616         hfunc++;
 617
 618         if (tTd(17, 9))
 619                 sm_dprintf(" = %d\n", hfunc);
 620         return hfunc;
 621 }
 622 /*
 623 **  BESTMX -- find the best MX for a name
 624 **
 625 **      This is really a hack, but I don't see any obvious way
 626 **      to generalize it at the moment.
 627 */
 628
 629 /* ARGSUSED3 */
 630 char *
 631 bestmx_map_lookup(map, name, av, statp)
 632         MAP *map;
 633         char *name;
 634         char **av;
 635         int *statp;
 636 {
 637         int nmx;
 638         int saveopts = _res.options;
 639         int i;
 640         ssize_t len = 0;
 641         char *result;
 642         char *mxhosts[MAXMXHOSTS + 1];
 643 #if _FFR_BESTMX_BETTER_TRUNCATION
 644         char *buf;
 645 #else /* _FFR_BESTMX_BETTER_TRUNCATION */
 646         char *p;
 647         char buf[PSBUFSIZE / 2];
 648 #endif /* _FFR_BESTMX_BETTER_TRUNCATION */
 649
 650         _res.options &= ~(RES_DNSRCH|RES_DEFNAMES);
 651         nmx = getmxrr(name, mxhosts, NULL, false, statp, false, NULL);
 652         _res.options = saveopts;
 653         if (nmx <= 0)
 654                 return NULL;
 655         if (bitset(MF_MATCHONLY, map->map_mflags))
 656                 return map_rewrite(map, name, strlen(name), NULL);
 657         if ((map->map_coldelim == '\0') || (nmx == 1))
 658                 return map_rewrite(map, mxhosts[0], strlen(mxhosts[0]), av);
 659
 660         /*
 661         **  We were given a -z flag (return all MXs) and there are multiple
 662         **  ones.  We need to build them all into a list.
 663         */
 664
 665 #if _FFR_BESTMX_BETTER_TRUNCATION
 666         for (i = 0; i < nmx; i++)
 667         {
 668                 if (strchr(mxhosts[i], map->map_coldelim) != NULL)
 669                 {
 670                         syserr("bestmx_map_lookup: MX host %.64s includes map delimiter character 0x%02X",
 671                                mxhosts[i], map->map_coldelim);
 672                         return NULL;
 673                 }
 674                 len += strlen(mxhosts[i]) + 1;
 675                 if (len < 0)
 676                 {
 677                         len -= strlen(mxhosts[i]) + 1;
 678                         break;
 679                 }
 680         }
 681         buf = (char *) sm_malloc(len);
 682         if (buf == NULL)
 683         {
 684                 *statp = EX_UNAVAILABLE;
 685                 return NULL;
 686         }
 687         *buf = '\0';
 688         for (i = 0; i < nmx; i++)
 689         {
 690                 int end;
 691
 692                 end = sm_strlcat(buf, mxhosts[i], len);
 693                 if (i != nmx && end + 1 < len)
 694                 {
 695                         buf[end] = map->map_coldelim;
 696                         buf[end + 1] = '\0';
 697                 }
 698         }
 699
 700         /* Cleanly truncate for rulesets */
 701         truncate_at_delim(buf, PSBUFSIZE / 2, map->map_coldelim);
 702 #else /* _FFR_BESTMX_BETTER_TRUNCATION */
 703         p = buf;
 704         for (i = 0; i < nmx; i++)
 705         {
 706                 size_t slen;
 707
 708                 if (strchr(mxhosts[i], map->map_coldelim) != NULL)
 709                 {
 710                         syserr("bestmx_map_lookup: MX host %.64s includes map delimiter character 0x%02X",
 711                                mxhosts[i], map->map_coldelim);
 712                         return NULL;
 713                 }
 714                 slen = strlen(mxhosts[i]);
 715                 if (len + slen + 2 > sizeof(buf))
 716                         break;
 717                 if (i > 0)
 718                 {
 719                         *p++ = map->map_coldelim;
 720                         len++;
 721                 }
 722                 (void) sm_strlcpy(p, mxhosts[i], sizeof(buf) - len);
 723                 p += slen;
 724                 len += slen;
 725         }
 726 #endif /* _FFR_BESTMX_BETTER_TRUNCATION */
 727
 728         result = map_rewrite(map, buf, len, av);
 729 #if _FFR_BESTMX_BETTER_TRUNCATION
 730         sm_free(buf);
 731 #endif /* _FFR_BESTMX_BETTER_TRUNCATION */
 732         return result;
 733 }
 734 /*
 735 **  DNS_GETCANONNAME -- get the canonical name for named host using DNS
 736 **
 737 **      This algorithm tries to be smart about wildcard MX records.
 738 **      This is hard to do because DNS doesn't tell is if we matched
 739 **      against a wildcard or a specific MX.
 740 **
 741 **      We always prefer A & CNAME records, since these are presumed
 742 **      to be specific.
 743 **
 744 **      If we match an MX in one pass and lose it in the next, we use
 745 **      the old one.  For example, consider an MX matching *.FOO.BAR.COM.
 746 **      A hostname bletch.foo.bar.com will match against this MX, but
 747 **      will stop matching when we try bletch.bar.com -- so we know
 748 **      that bletch.foo.bar.com must have been right.  This fails if
 749 **      there was also an MX record matching *.BAR.COM, but there are
 750 **      some things that just can't be fixed.
 751 **
 752 **      Parameters:
 753 **              host -- a buffer containing the name of the host.
 754 **                      This is a value-result parameter.
 755 **              hbsize -- the size of the host buffer.
 756 **              trymx -- if set, try MX records as well as A and CNAME.
 757 **              statp -- pointer to place to store status.
 758 **              pttl -- pointer to return TTL (can be NULL).
 759 **
 760 **      Returns:
 761 **              true -- if the host matched.
 762 **              false -- otherwise.
 763 */
 764
 765 bool
 766 dns_getcanonname(host, hbsize, trymx, statp, pttl)
 767         char *host;
 768         int hbsize;
 769         bool trymx;
 770         int *statp;
 771         int *pttl;
 772 {
 773         register unsigned char *eom, *ap;
 774         register char *cp;
 775         register int n;
 776         HEADER *hp;
 777         querybuf answer;
 778         int ancount, qdcount;
 779         int ret;
 780         char **domain;
 781         int type;
 782         int ttl = 0;
 783         char **dp;
 784         char *mxmatch;
 785         bool amatch;
 786         bool gotmx = false;
 787         int qtype;
 788         int initial;
 789         int loopcnt;
 790         char nbuf[SM_MAX(MAXPACKET, MAXDNAME*2+2)];
 791         char *searchlist[MAXDNSRCH + 2];
 792
 793         if (tTd(8, 2))
 794                 sm_dprintf("dns_getcanonname(%s, trymx=%d)\n", host, trymx);
 795
 796         if ((_res.options & RES_INIT) == 0 && res_init() == -1)
 797         {
 798                 *statp = EX_UNAVAILABLE;
 799                 return false;
 800         }
 801
 802         *statp = EX_OK;
 803
 804         /*
 805         **  Initialize domain search list.  If there is at least one
 806         **  dot in the name, search the unmodified name first so we
 807         **  find "vse.CS" in Czechoslovakia instead of in the local
 808         **  domain (e.g., vse.CS.Berkeley.EDU).  Note that there is no
 809         **  longer a country named Czechoslovakia but this type of problem
 810         **  is still present.
 811         **
 812         **  Older versions of the resolver could create this
 813         **  list by tearing apart the host name.
 814         */
 815
 816         loopcnt = 0;
 817 cnameloop:
 818         /* Check for dots in the name */
 819         for (cp = host, n = 0; *cp != '\0'; cp++)
 820                 if (*cp == '.')
 821                         n++;
 822
 823         /*
 824         **  Build the search list.
 825         **      If there is at least one dot in name, start with a null
 826         **      domain to search the unmodified name first.
 827         **      If name does not end with a dot and search up local domain
 828         **      tree desired, append each local domain component to the
 829         **      search list; if name contains no dots and default domain
 830         **      name is desired, append default domain name to search list;
 831         **      else if name ends in a dot, remove that dot.
 832         */
 833
 834         dp = searchlist;
 835         if (n > 0)
 836                 *dp++ = "";
 837         if (n >= 0 && *--cp != '.' && bitset(RES_DNSRCH, _res.options))
 838         {
 839                 /* make sure there are less than MAXDNSRCH domains */
 840                 for (domain = RES_DNSRCH_VARIABLE, ret = 0;
 841                      *domain != NULL && ret < MAXDNSRCH;
 842                      ret++)
 843                         *dp++ = *domain++;
 844         }
 845         else if (n == 0 && bitset(RES_DEFNAMES, _res.options))
 846         {
 847                 *dp++ = _res.defdname;
 848         }
 849         else if (*cp == '.')
 850         {
 851                 *cp = '\0';
 852         }
 853         *dp = NULL;
 854
 855         /*
 856         **  Now loop through the search list, appending each domain in turn
 857         **  name and searching for a match.
 858         */
 859
 860         mxmatch = NULL;
 861         initial = T_A;
 862 # if NETINET6
 863         if (InetMode == AF_INET6)
 864                 initial = T_AAAA;
 865 # endif /* NETINET6 */
 866         qtype = initial;
 867
 868         for (dp = searchlist; *dp != NULL; )
 869         {
 870                 if (qtype == initial)
 871                         gotmx = false;
 872                 if (tTd(8, 5))
 873                         sm_dprintf("dns_getcanonname: trying %s.%s (%s)\n",
 874                                 host, *dp,
 875 # if NETINET6
 876                                 qtype == T_AAAA ? "AAAA" :
 877 # endif /* NETINET6 */
 878                                 qtype == T_A ? "A" :
 879                                 qtype == T_MX ? "MX" :
 880                                 "???");
 881                 errno = 0;
 882                 ret = res_querydomain(host, *dp, C_IN, qtype,
 883                                       answer.qb2, sizeof(answer.qb2));
 884                 if (ret <= 0)
 885                 {
 886                         int save_errno = errno;
 887
 888                         if (tTd(8, 7))
 889                                 sm_dprintf("\tNO: errno=%d, h_errno=%d\n",
 890                                            save_errno, h_errno);
 891
 892                         if (save_errno == ECONNREFUSED || h_errno == TRY_AGAIN)
 893                         {
 894                                 /*
 895                                 **  the name server seems to be down or broken.
 896                                 */
 897
 898                                 SM_SET_H_ERRNO(TRY_AGAIN);
 899                                 if (**dp == '\0')
 900                                 {
 901                                         if (*statp == EX_OK)
 902                                                 *statp = EX_TEMPFAIL;
 903                                         goto nexttype;
 904                                 }
 905                                 *statp = EX_TEMPFAIL;
 906
 907                                 if (WorkAroundBrokenAAAA)
 908                                 {
 909                                         /*
 910                                         **  Only return if not TRY_AGAIN as an
 911                                         **  attempt with a different qtype may
 912                                         **  succeed (res_querydomain() calls
 913                                         **  res_query() calls res_send() which
 914                                         **  sets errno to ETIMEDOUT if the
 915                                         **  nameservers could be contacted but
 916                                         **  didn't give an answer).
 917                                         */
 918
 919                                         if (save_errno != ETIMEDOUT)
 920                                                 return false;
 921                                 }
 922                                 else
 923                                         return false;
 924                         }
 925
 926 nexttype:
 927                         if (h_errno != HOST_NOT_FOUND)
 928                         {
 929                                 /* might have another type of interest */
 930 # if NETINET6
 931                                 if (qtype == T_AAAA)
 932                                 {
 933                                         qtype = T_A;
 934                                         continue;
 935                                 }
 936                                 else
 937 # endif /* NETINET6 */
 938                                 if (qtype == T_A && !gotmx &&
 939                                     (trymx || **dp == '\0'))
 940                                 {
 941                                         qtype = T_MX;
 942                                         continue;
 943                                 }
 944                         }
 945
 946                         /* definite no -- try the next domain */
 947                         dp++;
 948                         qtype = initial;
 949                         continue;
 950                 }
 951                 else if (tTd(8, 7))
 952                         sm_dprintf("\tYES\n");
 953
 954                 /* avoid problems after truncation in tcp packets */
 955                 if (ret > sizeof(answer))
 956                         ret = sizeof(answer);
 957                 SM_ASSERT(ret >= 0);
 958
 959                 /*
 960                 **  Appear to have a match.  Confirm it by searching for A or
 961                 **  CNAME records.  If we don't have a local domain
 962                 **  wild card MX record, we will accept MX as well.
 963                 */
 964
 965                 hp = (HEADER *) &answer;
 966                 ap = (unsigned char *) &answer + HFIXEDSZ;
 967                 eom = (unsigned char *) &answer + ret;
 968
 969                 /* skip question part of response -- we know what we asked */
 970                 for (qdcount = ntohs((unsigned short) hp->qdcount);
 971                      qdcount--;
 972                      ap += ret + QFIXEDSZ)
 973                 {
 974                         if ((ret = dn_skipname(ap, eom)) < 0)
 975                         {
 976                                 if (tTd(8, 20))
 977                                         sm_dprintf("qdcount failure (%d)\n",
 978                                                 ntohs((unsigned short) hp->qdcount));
 979                                 *statp = EX_SOFTWARE;
 980                                 return false;           /* ???XXX??? */
 981                         }
 982                 }
 983
 984                 amatch = false;
 985                 for (ancount = ntohs((unsigned short) hp->ancount);
 986                      --ancount >= 0 && ap < eom;
 987                      ap += n)
 988                 {
 989                         n = dn_expand((unsigned char *) &answer, eom, ap,
 990                                       (RES_UNC_T) nbuf, sizeof(nbuf));
 991                         if (n < 0)
 992                                 break;
 993                         ap += n;
 994                         GETSHORT(type, ap);
 995                         ap += INT16SZ;          /* skip over class */
 996                         GETLONG(ttl, ap);
 997                         GETSHORT(n, ap);        /* rdlength */
 998                         switch (type)
 999                         {
1000                           case T_MX:
1001                                 gotmx = true;
1002                                 if (**dp != '\0' && HasWildcardMX)
1003                                 {
1004                                         /*
1005                                         **  If we are using MX matches and have
1006                                         **  not yet gotten one, save this one
1007                                         **  but keep searching for an A or
1008                                         **  CNAME match.
1009                                         */
1010
1011                                         if (trymx && mxmatch == NULL)
1012                                                 mxmatch = *dp;
1013                                         continue;
1014                                 }
1015
1016                                 /*
1017                                 **  If we did not append a domain name, this
1018                                 **  must have been a canonical name to start
1019                                 **  with.  Even if we did append a domain name,
1020                                 **  in the absence of a wildcard MX this must
1021                                 **  still be a real MX match.
1022                                 **  Such MX matches are as good as an A match,
1023                                 **  fall through.
1024                                 */
1025                                 /* FALLTHROUGH */
1026
1027 # if NETINET6
1028                           case T_AAAA:
1029 # endif /* NETINET6 */
1030                           case T_A:
1031                                 /* Flag that a good match was found */
1032                                 amatch = true;
1033
1034                                 /* continue in case a CNAME also exists */
1035                                 continue;
1036
1037                           case T_CNAME:
1038                                 if (DontExpandCnames)
1039                                 {
1040                                         /* got CNAME -- guaranteed canonical */
1041                                         amatch = true;
1042                                         break;
1043                                 }
1044
1045                                 if (loopcnt++ > MAXCNAMEDEPTH)
1046                                 {
1047                                         /*XXX should notify postmaster XXX*/
1048                                         message("DNS failure: CNAME loop for %s",
1049                                                 host);
1050                                         if (CurEnv->e_message == NULL)
1051                                         {
1052                                                 char ebuf[MAXLINE];
1053
1054                                                 (void) sm_snprintf(ebuf,
1055                                                         sizeof(ebuf),
1056                                                         "Deferred: DNS failure: CNAME loop for %.100s",
1057                                                         host);
1058                                                 CurEnv->e_message =
1059                                                     sm_rpool_strdup_x(
1060                                                         CurEnv->e_rpool, ebuf);
1061                                         }
1062                                         SM_SET_H_ERRNO(NO_RECOVERY);
1063                                         *statp = EX_CONFIG;
1064                                         return false;
1065                                 }
1066
1067                                 /* value points at name */
1068                                 if ((ret = dn_expand((unsigned char *)&answer,
1069                                                      eom, ap, (RES_UNC_T) nbuf,
1070                                                      sizeof(nbuf))) < 0)
1071                                         break;
1072                                 (void) sm_strlcpy(host, nbuf, hbsize);
1073
1074                                 /*
1075                                 **  RFC 1034 section 3.6 specifies that CNAME
1076                                 **  should point at the canonical name -- but
1077                                 **  urges software to try again anyway.
1078                                 */
1079
1080                                 goto cnameloop;
1081
1082                           default:
1083                                 /* not a record of interest */
1084                                 continue;
1085                         }
1086                 }
1087
1088                 if (amatch)
1089                 {
1090                         /*
1091                         **  Got a good match -- either an A, CNAME, or an
1092                         **  exact MX record.  Save it and get out of here.
1093                         */
1094
1095                         mxmatch = *dp;
1096                         break;
1097                 }
1098
1099                 /*
1100                 **  Nothing definitive yet.
1101                 **      If this was a T_A query and we haven't yet found a MX
1102                 **              match, try T_MX if allowed to do so.
1103                 **      Otherwise, try the next domain.
1104                 */
1105
1106 # if NETINET6
1107                 if (qtype == T_AAAA)
1108                         qtype = T_A;
1109                 else
1110 # endif /* NETINET6 */
1111                 if (qtype == T_A && !gotmx && (trymx || **dp == '\0'))
1112                         qtype = T_MX;
1113                 else
1114                 {
1115                         qtype = initial;
1116                         dp++;
1117                 }
1118         }
1119
1120         /* if nothing was found, we are done */
1121         if (mxmatch == NULL)
1122         {
1123                 if (*statp == EX_OK)
1124                         *statp = EX_NOHOST;
1125                 return false;
1126         }
1127
1128         /*
1129         **  Create canonical name and return.
1130         **  If saved domain name is null, name was already canonical.
1131         **  Otherwise append the saved domain name.
1132         */
1133
1134         (void) sm_snprintf(nbuf, sizeof(nbuf), "%.*s%s%.*s", MAXDNAME, host,
1135                            *mxmatch == '\0' ? "" : ".",
1136                            MAXDNAME, mxmatch);
1137         (void) sm_strlcpy(host, nbuf, hbsize);
1138         if (tTd(8, 5))
1139                 sm_dprintf("dns_getcanonname: %s\n", host);
1140         *statp = EX_OK;
1141
1142         /* return only one TTL entry, that should be sufficient */
1143         if (ttl > 0 && pttl != NULL)
1144                 *pttl = ttl;
1145         return true;
1146 }
1147 #endif /* NAMED_BIND */