src/src/dns.c

   1 /* $Cambridge: exim/src/src/dns.c,v 1.14 2006/02/16 10:05:33 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2006 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 /* Functions for interfacing with the DNS. */
  11
  12 #include "exim.h"
  13
  14
  15 /* Function declaration needed for mutual recursion when A6 records
  16 are supported. */
  17
  18 #if HAVE_IPV6
  19 #ifdef SUPPORT_A6
  20 static void dns_complete_a6(dns_address ***, dns_answer *, dns_record *,
  21   int, uschar *);
  22 #endif
  23 #endif
  24
  25
  26 /*************************************************
  27 *               Fake DNS resolver                *
  28 *************************************************/
  29
  30 /* This function is called instead of res_search() when Exim is running in its
  31 test harness. It recognizes some special domain names, and uses them to force
  32 failure and retry responses (optionally with a delay). Otherwise, it calls an
  33 external utility that mocks-up a nameserver, if it can find the utility.
  34 If not, it passes its arguments on to res_search(). The fake nameserver may
  35 also return a code specifying that the name should be passed on.
  36
  37 Background: the original test suite required a real nameserver to carry the
  38 test zones, whereas the new test suit has the fake server for portability. This
  39 code supports both.
  40
  41 Arguments:
  42   domain      the domain name
  43   type        the DNS record type
  44   answerptr   where to put the answer
  45   size        size of the answer area
  46
  47 Returns:      length of returned data, or -1 on error (h_errno set)
  48 */
  49
  50 static int
  51 fakens_search(uschar *domain, int type, uschar *answerptr, int size)
  52 {
  53 int len = Ustrlen(domain);
  54 int asize = size;                  /* Locally modified */
  55 uschar *endname;
  56 uschar name[256];
  57 uschar utilname[256];
  58 uschar *aptr = answerptr;          /* Locally modified */
  59 struct stat statbuf;
  60
  61 /* Remove terminating dot. */
  62
  63 if (domain[len - 1] == '.') len--;
  64 Ustrncpy(name, domain, len);
  65 name[len] = 0;
  66 endname = name + len;
  67
  68 /* This code, for forcing TRY_AGAIN and NO_RECOVERY, is here so that it works
  69 for the old test suite that uses a real nameserver. When the old test suite is
  70 eventually abandoned, this code could be moved into the fakens utility. */
  71
  72 if (len >= 14 && Ustrcmp(endname - 14, "test.again.dns") == 0)
  73   {
  74   int delay = Uatoi(name);  /* digits at the start of the name */
  75   DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
  76     name, dns_text_type(type));
  77   if (delay > 0)
  78     {
  79     DEBUG(D_dns) debug_printf("delaying %d seconds\n", delay);
  80     sleep(delay);
  81     }
  82   h_errno = TRY_AGAIN;
  83   return -1;
  84   }
  85
  86 if (len >= 13 && Ustrcmp(endname - 13, "test.fail.dns") == 0)
  87   {
  88   DEBUG(D_dns) debug_printf("Return from DNS lookup of %s (%s) faked for testing\n",
  89     name, dns_text_type(type));
  90   h_errno = NO_RECOVERY;
  91   return -1;
  92   }
  93
  94 /* Look for the fakens utility, and if it exists, call it. */
  95
  96 (void)string_format(utilname, sizeof(utilname), "%s/../bin/fakens",
  97   spool_directory);
  98
  99 if (stat(CS utilname, &statbuf) >= 0)
 100   {
 101   pid_t pid;
 102   int infd, outfd, rc;
 103   uschar *argv[5];
 104
 105   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) using fakens\n",
 106     name, dns_text_type(type));
 107
 108   argv[0] = utilname;
 109   argv[1] = spool_directory;
 110   argv[2] = name;
 111   argv[3] = dns_text_type(type);
 112   argv[4] = NULL;
 113
 114   pid = child_open(argv, NULL, 0000, &infd, &outfd, FALSE);
 115   if (pid < 0)
 116     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to run fakens: %s",
 117       strerror(errno));
 118
 119   len = 0;
 120   rc = -1;
 121   while (asize > 0 && (rc = read(outfd, aptr, asize)) > 0)
 122     {
 123     len += rc;
 124     aptr += rc;       /* Don't modify the actual arguments, because they */
 125     asize -= rc;      /* may need to be passed on to res_search(). */
 126     }
 127
 128   if (rc < 0)
 129     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "read from fakens failed: %s",
 130       strerror(errno));
 131
 132   switch(child_close(pid, 0))
 133     {
 134     case 0: return len;
 135     case 1: h_errno = HOST_NOT_FOUND; return -1;
 136     case 2: h_errno = TRY_AGAIN; return -1;
 137     default:
 138     case 3: h_errno = NO_RECOVERY; return -1;
 139     case 4: h_errno = NO_DATA; return -1;
 140     case 5: /* Pass on to res_search() */
 141     DEBUG(D_dns) debug_printf("fakens returned PASS_ON\n");
 142     }
 143   }
 144
 145 /* fakens utility not found, or it returned "pass on" */
 146
 147 DEBUG(D_dns) debug_printf("passing %s on to res_search()\n", domain);
 148
 149 return res_search(CS domain, C_IN, type, answerptr, size);
 150 }
 151
 152
 153
 154 /*************************************************
 155 *        Initialize and configure resolver       *
 156 *************************************************/
 157
 158 /* Initialize the resolver and the storage for holding DNS answers if this is
 159 the first time we have been here, and set the resolver options.
 160
 161 Arguments:
 162   qualify_single    TRUE to set the RES_DEFNAMES option
 163   search_parents    TRUE to set the RES_DNSRCH option
 164
 165 Returns:            nothing
 166 */
 167
 168 void
 169 dns_init(BOOL qualify_single, BOOL search_parents)
 170 {
 171 if ((_res.options & RES_INIT) == 0)
 172   {
 173   DEBUG(D_resolver) _res.options |= RES_DEBUG;     /* For Cygwin */
 174   res_init();
 175   DEBUG(D_resolver) _res.options |= RES_DEBUG;
 176   }
 177
 178 _res.options &= ~(RES_DNSRCH | RES_DEFNAMES);
 179 _res.options |= (qualify_single? RES_DEFNAMES : 0) |
 180                 (search_parents? RES_DNSRCH : 0);
 181 if (dns_retrans > 0) _res.retrans = dns_retrans;
 182 if (dns_retry > 0) _res.retry = dns_retry;
 183 }
 184
 185
 186
 187 /*************************************************
 188 *       Build key name for PTR records           *
 189 *************************************************/
 190
 191 /* This function inverts an IP address and adds the relevant domain, to produce
 192 a name that can be used to look up PTR records.
 193
 194 Arguments:
 195   string     the IP address as a string
 196   buffer     a suitable buffer, long enough to hold the result
 197
 198 Returns:     nothing
 199 */
 200
 201 void
 202 dns_build_reverse(uschar *string, uschar *buffer)
 203 {
 204 uschar *p = string + Ustrlen(string);
 205 uschar *pp = buffer;
 206
 207 /* Handle IPv4 address */
 208
 209 #if HAVE_IPV6
 210 if (Ustrchr(string, ':') == NULL)
 211 #endif
 212   {
 213   int i;
 214   for (i = 0; i < 4; i++)
 215     {
 216     uschar *ppp = p;
 217     while (ppp > string && ppp[-1] != '.') ppp--;
 218     Ustrncpy(pp, ppp, p - ppp);
 219     pp += p - ppp;
 220     *pp++ = '.';
 221     p = ppp - 1;
 222     }
 223   Ustrcpy(pp, "in-addr.arpa");
 224   }
 225
 226 /* Handle IPv6 address; convert to binary so as to fill out any
 227 abbreviation in the textual form. */
 228
 229 #if HAVE_IPV6
 230 else
 231   {
 232   int i;
 233   int v6[4];
 234   (void)host_aton(string, v6);
 235
 236   /* The original specification for IPv6 reverse lookup was to invert each
 237   nibble, and look in the ip6.int domain. The domain was subsequently
 238   changed to ip6.arpa. */
 239
 240   for (i = 3; i >= 0; i--)
 241     {
 242     int j;
 243     for (j = 0; j < 32; j += 4)
 244       {
 245       sprintf(CS pp, "%x.", (v6[i] >> j) & 15);
 246       pp += 2;
 247       }
 248     }
 249   Ustrcpy(pp, "ip6.arpa.");
 250
 251   /* Another way of doing IPv6 reverse lookups was proposed in conjunction
 252   with A6 records. However, it fell out of favour when they did. The
 253   alternative was to construct a binary key, and look in ip6.arpa. I tried
 254   to make this code do that, but I could not make it work on Solaris 8. The
 255   resolver seems to lose the initial backslash somehow. However, now that
 256   this style of reverse lookup has been dropped, it doesn't matter. These
 257   lines are left here purely for historical interest. */
 258
 259   /**************************************************
 260   Ustrcpy(pp, "\\[x");
 261   pp += 3;
 262
 263   for (i = 0; i < 4; i++)
 264     {
 265     sprintf(pp, "%08X", v6[i]);
 266     pp += 8;
 267     }
 268   Ustrcpy(pp, "].ip6.arpa.");
 269   **************************************************/
 270
 271   }
 272 #endif
 273 }
 274
 275
 276
 277
 278 /*************************************************
 279 *       Get next DNS record from answer block    *
 280 *************************************************/
 281
 282 /* Call this with reset == RESET_ANSWERS to scan the answer block, reset ==
 283 RESET_AUTHORITY to scan the authority records, reset == RESET_ADDITIONAL to
 284 scan the additional records, and reset == RESET_NEXT to get the next record.
 285 The result is in static storage which must be copied if it is to be preserved.
 286
 287 Arguments:
 288   dnsa      pointer to dns answer block
 289   dnss      pointer to dns scan block
 290   reset     option specifing what portion to scan, as described above
 291
 292 Returns:    next dns record, or NULL when no more
 293 */
 294
 295 dns_record *
 296 dns_next_rr(dns_answer *dnsa, dns_scan *dnss, int reset)
 297 {
 298 HEADER *h = (HEADER *)dnsa->answer;
 299 int namelen;
 300
 301 /* Reset the saved data when requested to, and skip to the first required RR */
 302
 303 if (reset != RESET_NEXT)
 304   {
 305   dnss->rrcount = ntohs(h->qdcount);
 306   dnss->aptr = dnsa->answer + sizeof(HEADER);
 307
 308   /* Skip over questions; failure to expand the name just gives up */
 309
 310   while (dnss->rrcount-- > 0)
 311     {
 312     namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
 313       dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
 314     if (namelen < 0) { dnss->rrcount = 0; return NULL; }
 315     dnss->aptr += namelen + 4;    /* skip name & type & class */
 316     }
 317
 318   /* Get the number of answer records. */
 319
 320   dnss->rrcount = ntohs(h->ancount);
 321
 322   /* Skip over answers if we want to look at the authority section. Also skip
 323   the NS records (i.e. authority section) if wanting to look at the additional
 324   records. */
 325
 326   if (reset == RESET_ADDITIONAL) dnss->rrcount += ntohs(h->nscount);
 327
 328   if (reset == RESET_AUTHORITY || reset == RESET_ADDITIONAL)
 329     {
 330     while (dnss->rrcount-- > 0)
 331       {
 332       namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
 333         dnss->aptr, (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
 334       if (namelen < 0) { dnss->rrcount = 0; return NULL; }
 335       dnss->aptr += namelen + 8;            /* skip name, type, class & TTL */
 336       GETSHORT(dnss->srr.size, dnss->aptr); /* size of data portion */
 337       dnss->aptr += dnss->srr.size;         /* skip over it */
 338       }
 339     dnss->rrcount = (reset == RESET_AUTHORITY)
 340       ? ntohs(h->nscount) : ntohs(h->arcount);
 341     }
 342   }
 343
 344 /* The variable dnss->aptr is now pointing at the next RR, and dnss->rrcount
 345 contains the number of RR records left. */
 346
 347 if (dnss->rrcount-- <= 0) return NULL;
 348
 349 /* If expanding the RR domain name fails, behave as if no more records
 350 (something safe). */
 351
 352 namelen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, dnss->aptr,
 353   (DN_EXPAND_ARG4_TYPE) &(dnss->srr.name), DNS_MAXNAME);
 354 if (namelen < 0) { dnss->rrcount = 0; return NULL; }
 355
 356 /* Move the pointer past the name and fill in the rest of the data structure
 357 from the following bytes. */
 358
 359 dnss->aptr += namelen;
 360 GETSHORT(dnss->srr.type, dnss->aptr); /* Record type */
 361 dnss->aptr += 6;                      /* Don't want class or TTL */
 362 GETSHORT(dnss->srr.size, dnss->aptr); /* Size of data portion */
 363 dnss->srr.data = dnss->aptr;          /* The record's data follows */
 364 dnss->aptr += dnss->srr.size;         /* Advance to next RR */
 365
 366 /* Return a pointer to the dns_record structure within the dns_answer. This is
 367 for convenience so that the scans can use nice-looking for loops. */
 368
 369 return &(dnss->srr);
 370 }
 371
 372
 373
 374
 375 /*************************************************
 376 *            Turn DNS type into text             *
 377 *************************************************/
 378
 379 /* Turn the coded record type into a string for printing. All those that Exim
 380 uses should be included here.
 381
 382 Argument:   record type
 383 Returns:    pointer to string
 384 */
 385
 386 uschar *
 387 dns_text_type(int t)
 388 {
 389 switch(t)
 390   {
 391   case T_A:     return US"A";
 392   case T_MX:    return US"MX";
 393   case T_AAAA:  return US"AAAA";
 394   case T_A6:    return US"A6";
 395   case T_TXT:   return US"TXT";
 396   case T_PTR:   return US"PTR";
 397   case T_SOA:   return US"SOA";
 398   case T_SRV:   return US"SRV";
 399   case T_NS:    return US"NS";
 400   case T_CNAME: return US"CNAME";
 401   default:      return US"?";
 402   }
 403 }
 404
 405
 406
 407 /*************************************************
 408 *        Cache a failed DNS lookup result        *
 409 *************************************************/
 410
 411 /* We cache failed lookup results so as not to experience timeouts many
 412 times for the same domain. We need to retain the resolver options because they
 413 may change. For successful lookups, we rely on resolver and/or name server
 414 caching.
 415
 416 Arguments:
 417   name       the domain name
 418   type       the lookup type
 419   rc         the return code
 420
 421 Returns:     the return code
 422 */
 423
 424 static int
 425 dns_return(uschar *name, int type, int rc)
 426 {
 427 tree_node *node = store_get_perm(sizeof(tree_node) + 290);
 428 sprintf(CS node->name, "%.255s-%s-%lx", name, dns_text_type(type),
 429   _res.options);
 430 node->data.val = rc;
 431 (void)tree_insertnode(&tree_dns_fails, node);
 432 return rc;
 433 }
 434
 435
 436
 437 /*************************************************
 438 *              Do basic DNS lookup               *
 439 *************************************************/
 440
 441 /* Call the resolver to look up the given domain name, using the given type,
 442 and check the result. The error code TRY_AGAIN is documented as meaning "non-
 443 Authoritive Host not found, or SERVERFAIL". Sometimes there are badly set
 444 up nameservers that produce this error continually, so there is the option of
 445 providing a list of domains for which this is treated as a non-existent
 446 host.
 447
 448 Arguments:
 449   dnsa      pointer to dns_answer structure
 450   name      name to look up
 451   type      type of DNS record required (T_A, T_MX, etc)
 452
 453 Returns:    DNS_SUCCEED   successful lookup
 454             DNS_NOMATCH   name not found (NXDOMAIN)
 455                           or name contains illegal characters (if checking)
 456             DNS_NODATA    domain exists, but no data for this type (NODATA)
 457             DNS_AGAIN     soft failure, try again later
 458             DNS_FAIL      DNS failure
 459 */
 460
 461 int
 462 dns_basic_lookup(dns_answer *dnsa, uschar *name, int type)
 463 {
 464 int rc = -1;
 465 #ifndef STAND_ALONE
 466 uschar *save;
 467 #endif
 468
 469 tree_node *previous;
 470 uschar node_name[290];
 471
 472 /* DNS lookup failures of any kind are cached in a tree. This is mainly so that
 473 a timeout on one domain doesn't happen time and time again for messages that
 474 have many addresses in the same domain. We rely on the resolver and name server
 475 caching for successful lookups. */
 476
 477 sprintf(CS node_name, "%.255s-%s-%lx", name, dns_text_type(type),
 478   _res.options);
 479 previous = tree_search(tree_dns_fails, node_name);
 480 if (previous != NULL)
 481   {
 482   DEBUG(D_dns) debug_printf("DNS lookup of %.255s-%s: using cached value %s\n",
 483     name, dns_text_type(type),
 484       (previous->data.val == DNS_NOMATCH)? "DNS_NOMATCH" :
 485       (previous->data.val == DNS_NODATA)? "DNS_NODATA" :
 486       (previous->data.val == DNS_AGAIN)? "DNS_AGAIN" :
 487       (previous->data.val == DNS_FAIL)? "DNS_FAIL" : "??");
 488   return previous->data.val;
 489   }
 490
 491 /* If configured, check the hygene of the name passed to lookup. Otherwise,
 492 although DNS lookups may give REFUSED at the lower level, some resolvers
 493 turn this into TRY_AGAIN, which is silly. Give a NOMATCH return, since such
 494 domains cannot be in the DNS. The check is now done by a regular expression;
 495 give it space for substring storage to save it having to get its own if the
 496 regex has substrings that are used - the default uses a conditional.
 497
 498 This test is omitted for PTR records. These occur only in calls from the dnsdb
 499 lookup, which constructs the names itself, so they should be OK. Besides,
 500 bitstring labels don't conform to normal name syntax. (But the aren't used any
 501 more.)
 502
 503 For SRV records, we omit the initial _smtp._tcp. components at the start. */
 504
 505 #ifndef STAND_ALONE   /* Omit this for stand-alone tests */
 506
 507 if (check_dns_names_pattern[0] != 0 && type != T_PTR)
 508   {
 509   uschar *checkname = name;
 510   int ovector[3*(EXPAND_MAXN+1)];
 511
 512   if (regex_check_dns_names == NULL)
 513     regex_check_dns_names =
 514       regex_must_compile(check_dns_names_pattern, FALSE, TRUE);
 515
 516   /* For an SRV lookup, skip over the first two components (the service and
 517   protocol names, which both start with an underscore). */
 518
 519   if (type == T_SRV)
 520     {
 521     while (*checkname++ != '.');
 522     while (*checkname++ != '.');
 523     }
 524
 525   if (pcre_exec(regex_check_dns_names, NULL, CS checkname, Ustrlen(checkname),
 526       0, PCRE_EOPT, ovector, sizeof(ovector)/sizeof(int)) < 0)
 527     {
 528     DEBUG(D_dns)
 529       debug_printf("DNS name syntax check failed: %s (%s)\n", name,
 530         dns_text_type(type));
 531     host_find_failed_syntax = TRUE;
 532     return DNS_NOMATCH;
 533     }
 534   }
 535
 536 #endif /* STAND_ALONE */
 537
 538 /* Call the resolver; for an overlong response, res_search() will return the
 539 number of bytes the message would need, so we need to check for this case. The
 540 effect is to truncate overlong data.
 541
 542 If we are running in the test harness, instead of calling the normal resolver
 543 (res_search), we call fakens_search(), which recognizes certain special
 544 domains, and interfaces to a fake nameserver for certain special zones. */
 545
 546 if (running_in_test_harness)
 547   dnsa->answerlen = fakens_search(name, type, dnsa->answer, MAXPACKET);
 548 else
 549   dnsa->answerlen = res_search(CS name, C_IN, type, dnsa->answer, MAXPACKET);
 550
 551 if (dnsa->answerlen > MAXPACKET) dnsa->answerlen = MAXPACKET;
 552
 553 if (dnsa->answerlen < 0) switch (h_errno)
 554   {
 555   case HOST_NOT_FOUND:
 556   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave HOST_NOT_FOUND\n"
 557     "returning DNS_NOMATCH\n", name, dns_text_type(type));
 558   return dns_return(name, type, DNS_NOMATCH);
 559
 560   case TRY_AGAIN:
 561   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave TRY_AGAIN\n",
 562     name, dns_text_type(type));
 563
 564   /* Cut this out for various test programs */
 565   #ifndef STAND_ALONE
 566   save = deliver_domain;
 567   deliver_domain = name;  /* set $domain */
 568   rc = match_isinlist(name, &dns_again_means_nonexist, 0, NULL, NULL,
 569     MCL_DOMAIN, TRUE, NULL);
 570   deliver_domain = save;
 571   if (rc != OK)
 572     {
 573     DEBUG(D_dns) debug_printf("returning DNS_AGAIN\n");
 574     return dns_return(name, type, DNS_AGAIN);
 575     }
 576   DEBUG(D_dns) debug_printf("%s is in dns_again_means_nonexist: returning "
 577     "DNS_NOMATCH\n", name);
 578   return dns_return(name, type, DNS_NOMATCH);
 579
 580   #else   /* For stand-alone tests */
 581   return dns_return(name, type, DNS_AGAIN);
 582   #endif
 583
 584   case NO_RECOVERY:
 585   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_RECOVERY\n"
 586     "returning DNS_FAIL\n", name, dns_text_type(type));
 587   return dns_return(name, type, DNS_FAIL);
 588
 589   case NO_DATA:
 590   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave NO_DATA\n"
 591     "returning DNS_NODATA\n", name, dns_text_type(type));
 592   return dns_return(name, type, DNS_NODATA);
 593
 594   default:
 595   DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) gave unknown DNS error %d\n"
 596     "returning DNS_FAIL\n", name, dns_text_type(type), h_errno);
 597   return dns_return(name, type, DNS_FAIL);
 598   }
 599
 600 DEBUG(D_dns) debug_printf("DNS lookup of %s (%s) succeeded\n",
 601   name, dns_text_type(type));
 602
 603 return DNS_SUCCEED;
 604 }
 605
 606
 607
 608
 609 /************************************************
 610 *        Do a DNS lookup and handle CNAMES      *
 611 ************************************************/
 612
 613 /* Look up the given domain name, using the given type. Follow CNAMEs if
 614 necessary, but only so many times. There aren't supposed to be CNAME chains in
 615 the DNS, but you are supposed to cope with them if you find them.
 616
 617 The assumption is made that if the resolver gives back records of the
 618 requested type *and* a CNAME, we don't need to make another call to look up
 619 the CNAME. I can't see how it could return only some of the right records. If
 620 it's done a CNAME lookup in the past, it will have all of them; if not, it
 621 won't return any.
 622
 623 If fully_qualified_name is not NULL, set it to point to the full name
 624 returned by the resolver, if this is different to what it is given, unless
 625 the returned name starts with "*" as some nameservers seem to be returning
 626 wildcards in this form.
 627
 628 Arguments:
 629   dnsa                  pointer to dns_answer structure
 630   name                  domain name to look up
 631   type                  DNS record type (T_A, T_MX, etc)
 632   fully_qualified_name  if not NULL, return the returned name here if its
 633                           contents are different (i.e. it must be preset)
 634
 635 Returns:                DNS_SUCCEED   successful lookup
 636                         DNS_NOMATCH   name not found
 637                         DNS_NODATA    no data found
 638                         DNS_AGAIN     soft failure, try again later
 639                         DNS_FAIL      DNS failure
 640 */
 641
 642 int
 643 dns_lookup(dns_answer *dnsa, uschar *name, int type, uschar **fully_qualified_name)
 644 {
 645 int i;
 646 uschar *orig_name = name;
 647
 648 /* Loop to follow CNAME chains so far, but no further... */
 649
 650 for (i = 0; i < 10; i++)
 651   {
 652   uschar data[256];
 653   dns_record *rr, cname_rr, type_rr;
 654   dns_scan dnss;
 655   int datalen, rc;
 656
 657   /* DNS lookup failures get passed straight back. */
 658
 659   if ((rc = dns_basic_lookup(dnsa, name, type)) != DNS_SUCCEED) return rc;
 660
 661   /* We should have either records of the required type, or a CNAME record,
 662   or both. We need to know whether both exist for getting the fully qualified
 663   name, but avoid scanning more than necessary. Note that we must copy the
 664   contents of any rr blocks returned by dns_next_rr() as they use the same
 665   area in the dnsa block. */
 666
 667   cname_rr.data = type_rr.data = NULL;
 668   for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
 669        rr != NULL;
 670        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 671     {
 672     if (rr->type == type)
 673       {
 674       if (type_rr.data == NULL) type_rr = *rr;
 675       if (cname_rr.data != NULL) break;
 676       }
 677     else if (rr->type == T_CNAME) cname_rr = *rr;
 678     }
 679
 680   /* If a CNAME was found, take the fully qualified name from it; otherwise
 681   from the first data record, if present. For testing, there is a magic name
 682   that gets its casing adjusted, because my resolver doesn't seem to pass back
 683   upper case letters in domain names. */
 684
 685   if (fully_qualified_name != NULL)
 686     {
 687     if (cname_rr.data != NULL)
 688       {
 689       if (Ustrcmp(cname_rr.name, *fully_qualified_name) != 0 &&
 690           cname_rr.name[0] != '*')
 691         *fully_qualified_name = string_copy_dnsdomain(cname_rr.name);
 692       }
 693     else if (type_rr.data != NULL)
 694       {
 695       if (Ustrcmp(type_rr.name, *fully_qualified_name) != 0 &&
 696           type_rr.name[0] != '*')
 697         *fully_qualified_name = string_copy_dnsdomain(type_rr.name);
 698       }
 699     }
 700
 701   /* If any data records of the correct type were found, we are done. */
 702
 703   if (type_rr.data != NULL) return DNS_SUCCEED;
 704
 705   /* If there are no data records, we need to re-scan the DNS using the
 706   domain given in the CNAME record, which should exist (otherwise we should
 707   have had a failure from dns_lookup). However code against the possibility of
 708   its not existing. */
 709
 710   if (cname_rr.data == NULL) return DNS_FAIL;
 711   datalen = dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
 712     cname_rr.data, (DN_EXPAND_ARG4_TYPE)data, 256);
 713   if (datalen < 0) return DNS_FAIL;
 714   name = data;
 715   }       /* Loop back to do another lookup */
 716
 717 /*Control reaches here after 10 times round the CNAME loop. Something isn't
 718 right... */
 719
 720 log_write(0, LOG_MAIN, "CNAME loop for %s encountered", orig_name);
 721 return DNS_FAIL;
 722 }
 723
 724
 725
 726
 727
 728
 729 /************************************************
 730 *    Do a DNS lookup and handle virtual types   *
 731 ************************************************/
 732
 733 /* This function handles some invented "lookup types" that synthesize feature
 734 not available in the basic types. The special types all have negative values.
 735 Positive type values are passed straight on to dns_lookup().
 736
 737 Arguments:
 738   dnsa                  pointer to dns_answer structure
 739   name                  domain name to look up
 740   type                  DNS record type (T_A, T_MX, etc or a "special")
 741   fully_qualified_name  if not NULL, return the returned name here if its
 742                           contents are different (i.e. it must be preset)
 743
 744 Returns:                DNS_SUCCEED   successful lookup
 745                         DNS_NOMATCH   name not found
 746                         DNS_NODATA    no data found
 747                         DNS_AGAIN     soft failure, try again later
 748                         DNS_FAIL      DNS failure
 749 */
 750
 751 int
 752 dns_special_lookup(dns_answer *dnsa, uschar *name, int type,
 753   uschar **fully_qualified_name)
 754 {
 755 if (type >= 0) return dns_lookup(dnsa, name, type, fully_qualified_name);
 756
 757 /* The "mx hosts only" type doesn't require any special action here */
 758
 759 if (type == T_MXH) return dns_lookup(dnsa, name, T_MX, fully_qualified_name);
 760
 761 /* Find nameservers for the domain or the nearest enclosing zone, excluding the
 762 root servers. */
 763
 764 if (type == T_ZNS)
 765   {
 766   uschar *d = name;
 767   while (d != 0)
 768     {
 769     int rc = dns_lookup(dnsa, d, T_NS, fully_qualified_name);
 770     if (rc != DNS_NOMATCH && rc != DNS_NODATA) return rc;
 771     while (*d != 0 && *d != '.') d++;
 772     if (*d++ == 0) break;
 773     }
 774   return DNS_NOMATCH;
 775   }
 776
 777 /* Try to look up the Client SMTP Authorization SRV record for the name. If
 778 there isn't one, search from the top downwards for a CSA record in a parent
 779 domain, which might be making assertions about subdomains. If we find a record
 780 we set fully_qualified_name to whichever lookup succeeded, so that the caller
 781 can tell whether to look at the explicit authorization field or the subdomain
 782 assertion field. */
 783
 784 if (type == T_CSA)
 785   {
 786   uschar *srvname, *namesuff, *tld, *p;
 787   int priority, weight, port;
 788   int limit, rc, i;
 789   BOOL ipv6;
 790   dns_record *rr;
 791   dns_scan dnss;
 792
 793   DEBUG(D_dns) debug_printf("CSA lookup of %s\n", name);
 794
 795   srvname = string_sprintf("_client._smtp.%s", name);
 796   rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
 797   if (rc == DNS_SUCCEED || rc == DNS_AGAIN)
 798     {
 799     if (rc == DNS_SUCCEED) *fully_qualified_name = name;
 800     return rc;
 801     }
 802
 803   /* Search for CSA subdomain assertion SRV records from the top downwards,
 804   starting with the 2nd level domain. This order maximizes cache-friendliness.
 805   We skip the top level domains to avoid loading their nameservers and because
 806   we know they'll never have CSA SRV records. */
 807
 808   namesuff = Ustrrchr(name, '.');
 809   if (namesuff == NULL) return DNS_NOMATCH;
 810   tld = namesuff + 1;
 811   ipv6 = FALSE;
 812   limit = dns_csa_search_limit;
 813
 814   /* Use more appropriate search parameters if we are in the reverse DNS. */
 815
 816   if (strcmpic(namesuff, US".arpa") == 0)
 817     {
 818     if (namesuff - 8 > name && strcmpic(namesuff - 8, US".in-addr.arpa") == 0)
 819       {
 820       namesuff -= 8;
 821       tld = namesuff + 1;
 822       limit = 3;
 823       }
 824     else if (namesuff - 4 > name && strcmpic(namesuff - 4, US".ip6.arpa") == 0)
 825       {
 826       namesuff -= 4;
 827       tld = namesuff + 1;
 828       ipv6 = TRUE;
 829       limit = 3;
 830       }
 831     }
 832
 833   DEBUG(D_dns) debug_printf("CSA TLD %s\n", tld);
 834
 835   /* Do not perform the search if the top level or 2nd level domains do not
 836   exist. This is quite common, and when it occurs all the search queries would
 837   go to the root or TLD name servers, which is not friendly. So we check the
 838   AUTHORITY section; if it contains the root's SOA record or the TLD's SOA then
 839   the TLD or the 2LD (respectively) doesn't exist and we can skip the search.
 840   If the TLD and the 2LD exist but the explicit CSA record lookup failed, then
 841   the AUTHORITY SOA will be the 2LD's or a subdomain thereof. */
 842
 843   if (rc == DNS_NOMATCH)
 844     {
 845     /* This is really gross. The successful return value from res_search() is
 846     the packet length, which is stored in dnsa->answerlen. If we get a
 847     negative DNS reply then res_search() returns -1, which causes the bounds
 848     checks for name decompression to fail when it is treated as a packet
 849     length, which in turn causes the authority search to fail. The correct
 850     packet length has been lost inside libresolv, so we have to guess a
 851     replacement value. (The only way to fix this properly would be to
 852     re-implement res_search() and res_query() so that they don't muddle their
 853     success and packet length return values.) For added safety we only reset
 854     the packet length if the packet header looks plausible. */
 855
 856     HEADER *h = (HEADER *)dnsa->answer;
 857     if (h->qr == 1 && h->opcode == QUERY && h->tc == 0
 858         && (h->rcode == NOERROR || h->rcode == NXDOMAIN)
 859         && ntohs(h->qdcount) == 1 && ntohs(h->ancount) == 0
 860         && ntohs(h->nscount) >= 1)
 861       dnsa->answerlen = MAXPACKET;
 862
 863     for (rr = dns_next_rr(dnsa, &dnss, RESET_AUTHORITY);
 864          rr != NULL;
 865          rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 866       if (rr->type != T_SOA) continue;
 867       else if (strcmpic(rr->name, US"") == 0 ||
 868                strcmpic(rr->name, tld) == 0) return DNS_NOMATCH;
 869       else break;
 870     }
 871
 872   for (i = 0; i < limit; i++)
 873     {
 874     if (ipv6)
 875       {
 876       /* Scan through the IPv6 reverse DNS in chunks of 16 bits worth of IP
 877       address, i.e. 4 hex chars and 4 dots, i.e. 8 chars. */
 878       namesuff -= 8;
 879       if (namesuff <= name) return DNS_NOMATCH;
 880       }
 881     else
 882       /* Find the start of the preceding domain name label. */
 883       do
 884         if (--namesuff <= name) return DNS_NOMATCH;
 885       while (*namesuff != '.');
 886
 887     DEBUG(D_dns) debug_printf("CSA parent search at %s\n", namesuff + 1);
 888
 889     srvname = string_sprintf("_client._smtp.%s", namesuff + 1);
 890     rc = dns_lookup(dnsa, srvname, T_SRV, NULL);
 891     if (rc == DNS_AGAIN) return rc;
 892     if (rc != DNS_SUCCEED) continue;
 893
 894     /* Check that the SRV record we have found is worth returning. We don't
 895     just return the first one we find, because some lower level SRV record
 896     might make stricter assertions than its parent domain. */
 897
 898     for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
 899          rr != NULL;
 900          rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 901       {
 902       if (rr->type != T_SRV) continue;
 903
 904       /* Extract the numerical SRV fields (p is incremented) */
 905       p = rr->data;
 906       GETSHORT(priority, p);
 907       GETSHORT(weight, p);
 908       GETSHORT(port, p);
 909
 910       /* Check the CSA version number */
 911       if (priority != 1) continue;
 912
 913       /* If it's making an interesting assertion, return this response. */
 914       if (port & 1)
 915         {
 916         *fully_qualified_name = namesuff + 1;
 917         return DNS_SUCCEED;
 918         }
 919       }
 920     }
 921   return DNS_NOMATCH;
 922   }
 923
 924 /* Control should never reach here */
 925
 926 return DNS_FAIL;
 927 }
 928
 929
 930
 931 /* Support for A6 records has been commented out since they were demoted to
 932 experimental status at IETF 51. */
 933
 934 #if HAVE_IPV6 && defined(SUPPORT_A6)
 935
 936 /*************************************************
 937 *        Search DNS block for prefix RRs         *
 938 *************************************************/
 939
 940 /* Called from dns_complete_a6() to search an additional section or a main
 941 answer section for required prefix records to complete an IPv6 address obtained
 942 from an A6 record. For each prefix record, a recursive call to dns_complete_a6
 943 is made, with a new copy of the address so far.
 944
 945 Arguments:
 946   dnsa       the DNS answer block
 947   which      RESET_ADDITIONAL or RESET_ANSWERS
 948   name       name of prefix record
 949   yptrptr    pointer to the pointer that points to where to hang the next
 950                dns_address structure
 951   bits       number of bits we have already got
 952   bitvec     the bits we have already got
 953
 954 Returns:     TRUE if any records were found
 955 */
 956
 957 static BOOL
 958 dns_find_prefix(dns_answer *dnsa, int which, uschar *name, dns_address
 959   ***yptrptr, int bits, uschar *bitvec)
 960 {
 961 BOOL yield = FALSE;
 962 dns_record *rr;
 963 dns_scan dnss;
 964
 965 for (rr = dns_next_rr(dnsa, &dnss, which);
 966      rr != NULL;
 967      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
 968   {
 969   uschar cbitvec[16];
 970   if (rr->type != T_A6 || strcmpic(rr->name, name) != 0) continue;
 971   yield = TRUE;
 972   memcpy(cbitvec, bitvec, sizeof(cbitvec));
 973   dns_complete_a6(yptrptr, dnsa, rr, bits, cbitvec);
 974   }
 975
 976 return yield;
 977 }
 978
 979
 980
 981 /*************************************************
 982 *            Follow chains of A6 records         *
 983 *************************************************/
 984
 985 /* A6 records may be incomplete, with pointers to other records containing more
 986 bits of the address. There can be a tree structure, leading to a number of
 987 addresses originating from a single initial A6 record.
 988
 989 Arguments:
 990   yptrptr    pointer to the pointer that points to where to hang the next
 991                dns_address structure
 992   dnsa       the current DNS answer block
 993   rr         the RR we have at present
 994   bits       number of bits we have already got
 995   bitvec     the bits we have already got
 996
 997 Returns:     nothing
 998 */
 999
1000 static void
1001 dns_complete_a6(dns_address ***yptrptr, dns_answer *dnsa, dns_record *rr,
1002   int bits, uschar *bitvec)
1003 {
1004 static uschar bitmask[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
1005 uschar *p = (uschar *)(rr->data);
1006 int prefix_len, suffix_len;
1007 int i, j, k;
1008 uschar *chainptr;
1009 uschar chain[264];
1010 dns_answer cdnsa;
1011
1012 /* The prefix length is the first byte. It defines the prefix which is missing
1013 from the data in this record as a number of bits. Zero means this is the end of
1014 a chain. The suffix is the data in this record; only sufficient bytes to hold
1015 it are supplied. There may be zero bytes. We have to ignore trailing bits that
1016 we have already obtained from earlier RRs in the chain. */
1017
1018 prefix_len = *p++;                      /* bits */
1019 suffix_len = (128 - prefix_len + 7)/8;  /* bytes */
1020
1021 /* If the prefix in this record is greater than the prefix in the previous
1022 record in the chain, we have to ignore the record (RFC 2874). */
1023
1024 if (prefix_len > 128 - bits) return;
1025
1026 /* In this little loop, the number of bits up to and including the current byte
1027 is held in k. If we have none of the bits in this byte, we can just or it into
1028 the current data. If we have all of the bits in this byte, we skip it.
1029 Otherwise, some masking has to be done. */
1030
1031 for (i = suffix_len - 1, j = 15, k = 8; i >= 0; i--)
1032   {
1033   int required = k - bits;
1034   if (required >= 8) bitvec[j] |= p[i];
1035     else if (required > 0) bitvec[j] |= p[i] & bitmask[required];
1036   j--;     /* I tried putting these in the "for" statement, but gcc muttered */
1037   k += 8;  /* about computed values not being used. */
1038   }
1039
1040 /* If the prefix_length is zero, we are at the end of a chain. Build a
1041 dns_address item with the current data, hang it onto the end of the chain,
1042 adjust the hanging pointer, and we are done. */
1043
1044 if (prefix_len == 0)
1045   {
1046   dns_address *new = store_get(sizeof(dns_address) + 50);
1047   inet_ntop(AF_INET6, bitvec, CS new->address, 50);
1048   new->next = NULL;
1049   **yptrptr = new;
1050   *yptrptr = &(new->next);
1051   return;
1052   }
1053
1054 /* Prefix length is not zero. Reset the number of bits that we have collected
1055 so far, and extract the chain name. */
1056
1057 bits = 128 - prefix_len;
1058 p += suffix_len;
1059
1060 chainptr = chain;
1061 while ((i = *p++) != 0)
1062   {
1063   if (chainptr != chain) *chainptr++ = '.';
1064   memcpy(chainptr, p, i);
1065   chainptr += i;
1066   p += i;
1067   }
1068 *chainptr = 0;
1069 chainptr = chain;
1070
1071 /* Now scan the current DNS response record to see if the additional section
1072 contains the records we want. This processing can be cut out for testing
1073 purposes. */
1074
1075 if (dns_find_prefix(dnsa, RESET_ADDITIONAL, chainptr, yptrptr, bits, bitvec))
1076   return;
1077
1078 /* No chain records were found in the current DNS response block. Do a new DNS
1079 lookup to try to find these records. This opens up the possibility of DNS
1080 failures. We ignore them at this point; if all branches of the tree fail, there
1081 will be no addresses at the end. */
1082
1083 if (dns_lookup(&cdnsa, chainptr, T_A6, NULL) == DNS_SUCCEED)
1084   (void)dns_find_prefix(&cdnsa, RESET_ANSWERS, chainptr, yptrptr, bits, bitvec);
1085 }
1086 #endif  /* HAVE_IPV6 && defined(SUPPORT_A6) */
1087
1088
1089
1090
1091 /*************************************************
1092 *          Get address(es) from DNS record       *
1093 *************************************************/
1094
1095 /* The record type is either T_A for an IPv4 address or T_AAAA (or T_A6 when
1096 supported) for an IPv6 address. In the A6 case, there may be several addresses,
1097 generated by following chains. A recursive function does all the hard work. A6
1098 records now look like passing into history, so the code is only included when
1099 explicitly asked for.
1100
1101 Argument:
1102   dnsa       the DNS answer block
1103   rr         the RR
1104
1105 Returns:     pointer a chain of dns_address items
1106 */
1107
1108 dns_address *
1109 dns_address_from_rr(dns_answer *dnsa, dns_record *rr)
1110 {
1111 dns_address *yield = NULL;
1112
1113 #if HAVE_IPV6 && defined(SUPPORT_A6)
1114 dns_address **yieldptr = &yield;
1115 uschar bitvec[16];
1116 #else
1117 dnsa = dnsa;    /* Stop picky compilers warning */
1118 #endif
1119
1120 if (rr->type == T_A)
1121   {
1122   uschar *p = (uschar *)(rr->data);
1123   yield = store_get(sizeof(dns_address) + 20);
1124   (void)sprintf(CS yield->address, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1125   yield->next = NULL;
1126   }
1127
1128 #if HAVE_IPV6
1129
1130 #ifdef SUPPORT_A6
1131 else if (rr->type == T_A6)
1132   {
1133   memset(bitvec, 0, sizeof(bitvec));
1134   dns_complete_a6(&yieldptr, dnsa, rr, 0, bitvec);
1135   }
1136 #endif  /* SUPPORT_A6 */
1137
1138 else
1139   {
1140   yield = store_get(sizeof(dns_address) + 50);
1141   inet_ntop(AF_INET6, (uschar *)(rr->data), CS yield->address, 50);
1142   yield->next = NULL;
1143   }
1144 #endif  /* HAVE_IPV6 */
1145
1146 return yield;
1147 }
1148
1149 /* End of dns.c */