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