src/src/host.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 /* Functions for finding hosts, either by gethostbyname(), gethostbyaddr(), or
  11 directly via the DNS. When IPv6 is supported, getipnodebyname() and
  12 getipnodebyaddr() may be used instead of gethostbyname() and gethostbyaddr(),
  13 if the newer functions are available. This module also contains various other
  14 functions concerned with hosts and addresses, and a random number function,
  15 used for randomizing hosts with equal MXs but available for use in other parts
  16 of Exim. */
  17
  18
  19 #include "exim.h"
  20
  21
  22 /* Static variable for preserving the list of interface addresses in case it is
  23 used more than once. */
  24
  25 static ip_address_item *local_interface_data = NULL;
  26
  27
  28 #ifdef USE_INET_NTOA_FIX
  29 /*************************************************
  30 *         Replacement for broken inet_ntoa()     *
  31 *************************************************/
  32
  33 /* On IRIX systems, gcc uses a different structure passing convention to the
  34 native libraries. This causes inet_ntoa() to always yield 0.0.0.0 or
  35 255.255.255.255. To get round this, we provide a private version of the
  36 function here. It is used only if USE_INET_NTOA_FIX is set, which should happen
  37 only when gcc is in use on an IRIX system. Code send to me by J.T. Breitner,
  38 with these comments:
  39
  40   code by Stuart Levy
  41   as seen in comp.sys.sgi.admin
  42
  43 August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
  44 should now be set for them as well.
  45
  46 Arguments:  sa  an in_addr structure
  47 Returns:        pointer to static text string
  48 */
  49
  50 char *
  51 inet_ntoa(struct in_addr sa)
  52 {
  53 static uschar addr[20];
  54 sprintf(addr, "%d.%d.%d.%d",
  55         (US &sa.s_addr)[0],
  56         (US &sa.s_addr)[1],
  57         (US &sa.s_addr)[2],
  58         (US &sa.s_addr)[3]);
  59   return addr;
  60 }
  61 #endif
  62
  63
  64
  65 /*************************************************
  66 *              Random number generator           *
  67 *************************************************/
  68
  69 /* This is a simple pseudo-random number generator. It does not have to be
  70 very good for the uses to which it is put. When running the regression tests,
  71 start with a fixed seed.
  72
  73 If you need better, see vaguely_random_number() which is potentially stronger,
  74 if a crypto library is available, but might end up just calling this instead.
  75
  76 Arguments:
  77   limit:    one more than the largest number required
  78
  79 Returns:    a pseudo-random number in the range 0 to limit-1
  80 */
  81
  82 int
  83 random_number(int limit)
  84 {
  85 if (limit < 1)
  86   return 0;
  87 if (random_seed == 0)
  88   if (f.running_in_test_harness)
  89     random_seed = 42;
  90   else
  91     {
  92     int p = (int)getpid();
  93     random_seed = (int)time(NULL) ^ ((p << 16) | p);
  94     }
  95 random_seed = 1103515245 * random_seed + 12345;
  96 return (unsigned int)(random_seed >> 16) % limit;
  97 }
  98
  99 /*************************************************
 100 *      Wrappers for logging lookup times         *
 101 *************************************************/
 102
 103 /* When the 'slow_lookup_log' variable is enabled, these wrappers will
 104 write to the log file all (potential) dns lookups that take more than
 105 slow_lookup_log milliseconds
 106 */
 107
 108 static void
 109 log_long_lookup(const uschar * type, const uschar * data, unsigned long msec)
 110 {
 111 log_write(0, LOG_MAIN, "Long %s lookup for '%s': %lu msec",
 112   type, data, msec);
 113 }
 114
 115
 116 /* returns the current system epoch time in milliseconds. */
 117 static unsigned long
 118 get_time_in_ms()
 119 {
 120 struct timeval tmp_time;
 121 unsigned long seconds, microseconds;
 122
 123 gettimeofday(&tmp_time, NULL);
 124 seconds = (unsigned long) tmp_time.tv_sec;
 125 microseconds = (unsigned long) tmp_time.tv_usec;
 126 return seconds*1000 + microseconds/1000;
 127 }
 128
 129
 130 static int
 131 dns_lookup_timerwrap(dns_answer *dnsa, const uschar *name, int type,
 132   const uschar **fully_qualified_name)
 133 {
 134 int retval;
 135 unsigned long time_msec;
 136
 137 if (!slow_lookup_log)
 138   return dns_lookup(dnsa, name, type, fully_qualified_name);
 139
 140 time_msec = get_time_in_ms();
 141 retval = dns_lookup(dnsa, name, type, fully_qualified_name);
 142 if ((time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
 143   log_long_lookup(dns_text_type(type), name, time_msec);
 144 return retval;
 145 }
 146
 147
 148 /*************************************************
 149 *       Replace gethostbyname() when testing     *
 150 *************************************************/
 151
 152 /* This function is called instead of gethostbyname(), gethostbyname2(), or
 153 getipnodebyname() when running in the test harness. . It also
 154 recognizes an unqualified "localhost" and forces it to the appropriate loopback
 155 address. IP addresses are treated as literals. For other names, it uses the DNS
 156 to find the host name. In the test harness, this means it will access only the
 157 fake DNS resolver.
 158
 159 Arguments:
 160   name          the host name or a textual IP address
 161   af            AF_INET or AF_INET6
 162   error_num     where to put an error code:
 163                 HOST_NOT_FOUND/TRY_AGAIN/NO_RECOVERY/NO_DATA
 164
 165 Returns:        a hostent structure or NULL for an error
 166 */
 167
 168 static struct hostent *
 169 host_fake_gethostbyname(const uschar *name, int af, int *error_num)
 170 {
 171 #if HAVE_IPV6
 172 int alen = (af == AF_INET)? sizeof(struct in_addr):sizeof(struct in6_addr);
 173 #else
 174 int alen = sizeof(struct in_addr);
 175 #endif
 176
 177 int ipa;
 178 const uschar *lname = name;
 179 uschar *adds;
 180 uschar **alist;
 181 struct hostent *yield;
 182 dns_answer * dnsa = store_get_dns_answer();
 183 dns_scan dnss;
 184
 185 DEBUG(D_host_lookup)
 186   debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
 187     af == AF_INET ? "IPv4" : "IPv6");
 188
 189 /* Handle unqualified "localhost" */
 190
 191 if (Ustrcmp(name, "localhost") == 0)
 192   lname = af == AF_INET ? US"127.0.0.1" : US"::1";
 193
 194 /* Handle a literal IP address */
 195
 196 if ((ipa = string_is_ip_address(lname, NULL)) != 0)
 197   if (   ipa == 4 && af == AF_INET
 198      ||  ipa == 6 && af == AF_INET6)
 199     {
 200     int x[4];
 201     yield = store_get(sizeof(struct hostent), GET_UNTAINTED);
 202     alist = store_get(2 * sizeof(char *), GET_UNTAINTED);
 203     adds  = store_get(alen, GET_UNTAINTED);
 204     yield->h_name = CS name;
 205     yield->h_aliases = NULL;
 206     yield->h_addrtype = af;
 207     yield->h_length = alen;
 208     yield->h_addr_list = CSS alist;
 209     *alist++ = adds;
 210     for (int n = host_aton(lname, x), i = 0; i < n; i++)
 211       {
 212       int y = x[i];
 213       *adds++ = (y >> 24) & 255;
 214       *adds++ = (y >> 16) & 255;
 215       *adds++ = (y >> 8) & 255;
 216       *adds++ = y & 255;
 217       }
 218     *alist = NULL;
 219     }
 220
 221   /* Wrong kind of literal address */
 222
 223   else
 224     {
 225     *error_num = HOST_NOT_FOUND;
 226     yield = NULL;
 227     goto out;
 228     }
 229
 230 /* Handle a host name */
 231
 232 else
 233   {
 234   int type = af == AF_INET ? T_A:T_AAAA;
 235   int rc = dns_lookup_timerwrap(dnsa, lname, type, NULL);
 236   int count = 0;
 237
 238   lookup_dnssec_authenticated = NULL;
 239
 240   switch(rc)
 241     {
 242     case DNS_SUCCEED: break;
 243     case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; yield = NULL; goto out;
 244     case DNS_NODATA:  *error_num = NO_DATA; yield = NULL; goto out;
 245     case DNS_AGAIN:   *error_num = TRY_AGAIN; yield = NULL; goto out;
 246     default:
 247     case DNS_FAIL:    *error_num = NO_RECOVERY; yield = NULL; goto out;
 248     }
 249
 250   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
 251        rr;
 252        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
 253     count++;
 254
 255   yield = store_get(sizeof(struct hostent), GET_UNTAINTED);
 256   alist = store_get((count + 1) * sizeof(char *), GET_UNTAINTED);
 257   adds  = store_get(count *alen, GET_UNTAINTED);
 258
 259   yield->h_name = CS name;
 260   yield->h_aliases = NULL;
 261   yield->h_addrtype = af;
 262   yield->h_length = alen;
 263   yield->h_addr_list = CSS alist;
 264
 265   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
 266        rr;
 267        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
 268     {
 269     int x[4];
 270     dns_address *da;
 271     if (!(da = dns_address_from_rr(dnsa, rr))) break;
 272     *alist++ = adds;
 273     for (int n = host_aton(da->address, x), i = 0; i < n; i++)
 274       {
 275       int y = x[i];
 276       *adds++ = (y >> 24) & 255;
 277       *adds++ = (y >> 16) & 255;
 278       *adds++ = (y >> 8) & 255;
 279       *adds++ = y & 255;
 280       }
 281     }
 282   *alist = NULL;
 283   }
 284
 285 out:
 286
 287 store_free_dns_answer(dnsa);
 288 return yield;
 289 }
 290
 291
 292
 293 /*************************************************
 294 *       Build chain of host items from list      *
 295 *************************************************/
 296
 297 /* This function builds a chain of host items from a textual list of host
 298 names. It does not do any lookups. If randomize is true, the chain is build in
 299 a randomized order. There may be multiple groups of independently randomized
 300 hosts; they are delimited by a host name consisting of just "+".
 301
 302 Arguments:
 303   anchor      anchor for the chain
 304   list        text list
 305   randomize   TRUE for randomizing
 306
 307 Returns:      nothing
 308 */
 309
 310 void
 311 host_build_hostlist(host_item **anchor, const uschar *list, BOOL randomize)
 312 {
 313 int sep = 0;
 314 int fake_mx = MX_NONE;          /* This value is actually -1 */
 315 uschar *name;
 316
 317 if (!list) return;
 318 if (randomize) fake_mx--;       /* Start at -2 for randomizing */
 319
 320 *anchor = NULL;
 321
 322 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
 323   {
 324   host_item *h;
 325
 326   if (name[0] == '+' && name[1] == 0)   /* "+" delimits a randomized group */
 327     {                                   /* ignore if not randomizing */
 328     if (randomize) fake_mx--;
 329     continue;
 330     }
 331
 332   h = store_get(sizeof(host_item), GET_UNTAINTED);
 333   h->name = name;
 334   h->address = NULL;
 335   h->port = PORT_NONE;
 336   h->mx = fake_mx;
 337   h->sort_key = randomize ? (-fake_mx)*1000 + random_number(1000) : 0;
 338   h->status = hstatus_unknown;
 339   h->why = hwhy_unknown;
 340   h->last_try = 0;
 341
 342   if (!*anchor)
 343     {
 344     h->next = NULL;
 345     *anchor = h;
 346     }
 347   else
 348     {
 349     host_item *hh = *anchor;
 350     if (h->sort_key < hh->sort_key)
 351       {
 352       h->next = hh;
 353       *anchor = h;
 354       }
 355     else
 356       {
 357       while (hh->next && h->sort_key >= hh->next->sort_key)
 358         hh = hh->next;
 359       h->next = hh->next;
 360       hh->next = h;
 361       }
 362     }
 363   }
 364 }
 365
 366
 367 /*************************************************
 368 *         Get port from a host item's name       *
 369 *************************************************/
 370
 371 /* This function is called when finding the IP address for a host that is in a
 372 list of hosts explicitly configured, such as in the manualroute router, or in a
 373 fallback hosts list. We see if there is a port specification at the end of the
 374 host name, and if so, remove it. A minimum length of 3 is required for the
 375 original name; nothing shorter is recognized as having a port.
 376
 377 We test for a name ending with a sequence of digits; if preceded by colon we
 378 have a port if the character before the colon is ] and the name starts with [
 379 or if there are no other colons in the name (i.e. it's not an IPv6 address).
 380
 381 Arguments:  pointer to the host item
 382 Returns:    a port number or PORT_NONE
 383 */
 384
 385 int
 386 host_item_get_port(host_item *h)
 387 {
 388 const uschar *p;
 389 int port, x;
 390 int len = Ustrlen(h->name);
 391
 392 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
 393
 394 /* Extract potential port number */
 395
 396 port = *p-- - '0';
 397 x = 10;
 398
 399 while (p > h->name + 1 && isdigit(*p))
 400   {
 401   port += (*p-- - '0') * x;
 402   x *= 10;
 403   }
 404
 405 /* The smallest value of p at this point is h->name + 1. */
 406
 407 if (*p != ':') return PORT_NONE;
 408
 409 if (p[-1] == ']' && h->name[0] == '[')
 410   h->name = string_copyn(h->name + 1, p - h->name - 2);
 411 else if (Ustrchr(h->name, ':') == p)
 412   h->name = string_copyn(h->name, p - h->name);
 413 else return PORT_NONE;
 414
 415 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
 416 return port;
 417 }
 418
 419
 420
 421 #ifndef STAND_ALONE    /* Omit when standalone testing */
 422
 423 /*************************************************
 424 *     Build sender_fullhost and sender_rcvhost   *
 425 *************************************************/
 426
 427 /* This function is called when sender_host_name and/or sender_helo_name
 428 have been set. Or might have been set - for a local message read off the spool
 429 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
 430 as follows:
 431
 432 (a) No sender_host_name or sender_helo_name: "[ip address]"
 433 (b) Just sender_host_name: "host_name [ip address]"
 434 (c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
 435             in which case: "[ip address}"
 436 (d) The two are identical: "host_name [ip address]" includes helo = IP
 437 (e) The two are different: "host_name (helo_name) [ip address]"
 438
 439 If log_incoming_port is set, the sending host's port number is added to the IP
 440 address.
 441
 442 This function also builds sender_rcvhost for use in Received: lines, whose
 443 syntax is a bit different. This value also includes the RFC 1413 identity.
 444 There wouldn't be two different variables if I had got all this right in the
 445 first place.
 446
 447 Because this data may survive over more than one incoming SMTP message, it has
 448 to be in permanent store.  However, STARTTLS has to be forgotten and redone
 449 on a multi-message conn, so this will be called once per message then.  Hence
 450 we use malloc, so we can free.
 451
 452 Arguments:  none
 453 Returns:    nothing
 454 */
 455
 456 void
 457 host_build_sender_fullhost(void)
 458 {
 459 BOOL show_helo = TRUE;
 460 uschar * address, * fullhost, * rcvhost;
 461 rmark reset_point;
 462 int len;
 463
 464 if (!sender_host_address) return;
 465
 466 reset_point = store_mark();
 467
 468 /* Set up address, with or without the port. After discussion, it seems that
 469 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
 470 use this directly as the first item for Received: because it ain't an RFC 2822
 471 domain. Sigh. */
 472
 473 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
 474 if (!LOGGING(incoming_port) || sender_host_port <= 0)
 475   *(Ustrrchr(address, ':')) = 0;
 476
 477 /* If there's no EHLO/HELO data, we can't show it. */
 478
 479 if (!sender_helo_name) show_helo = FALSE;
 480
 481 /* If HELO/EHLO was followed by an IP literal, it's messy because of two
 482 features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
 483 doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
 484 be given in canonical form, so we have to canonicalize them before comparing. As
 485 it happens, the code works for both IPv4 and IPv6. */
 486
 487 else if (sender_helo_name[0] == '[' &&
 488          sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
 489   {
 490   int offset = 1;
 491   uschar *helo_ip;
 492
 493   if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
 494   if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
 495
 496   helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
 497
 498   if (string_is_ip_address(helo_ip, NULL) != 0)
 499     {
 500     int x[4], y[4];
 501     int sizex, sizey;
 502     uschar ipx[48], ipy[48];    /* large enough for full IPv6 */
 503
 504     sizex = host_aton(helo_ip, x);
 505     sizey = host_aton(sender_host_address, y);
 506
 507     (void)host_nmtoa(sizex, x, -1, ipx, ':');
 508     (void)host_nmtoa(sizey, y, -1, ipy, ':');
 509
 510     if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
 511     }
 512   }
 513
 514 /* Host name is not verified */
 515
 516 if (!sender_host_name)
 517   {
 518   uschar *portptr = Ustrstr(address, "]:");
 519   gstring * g;
 520   int adlen;    /* Sun compiler doesn't like ++ in initializers */
 521
 522   adlen = portptr ? (++portptr - address) : Ustrlen(address);
 523   fullhost = sender_helo_name
 524     ? string_sprintf("(%s) %s", sender_helo_name, address)
 525     : address;
 526
 527   g = string_catn(NULL, address, adlen);
 528
 529   if (sender_ident || show_helo || portptr)
 530     {
 531     int firstptr;
 532     g = string_catn(g, US" (", 2);
 533     firstptr = g->ptr;
 534
 535     if (portptr)
 536       g = string_append(g, 2, US"port=", portptr + 1);
 537
 538     if (show_helo)
 539       g = string_append(g, 2,
 540         firstptr == g->ptr ? US"helo=" : US" helo=", sender_helo_name);
 541
 542     if (sender_ident)
 543       g = string_append(g, 2,
 544         firstptr == g->ptr ? US"ident=" : US" ident=", sender_ident);
 545
 546     g = string_catn(g, US")", 1);
 547     }
 548
 549   rcvhost = string_from_gstring(g);
 550   }
 551
 552 /* Host name is known and verified. Unless we've already found that the HELO
 553 data matches the IP address, compare it with the name. */
 554
 555 else
 556   {
 557   if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
 558     show_helo = FALSE;
 559
 560   if (show_helo)
 561     {
 562     fullhost = string_sprintf("%s (%s) %s", sender_host_name,
 563       sender_helo_name, address);
 564     rcvhost = sender_ident
 565       ?  string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
 566         address, sender_helo_name, sender_ident)
 567       : string_sprintf("%s (%s helo=%s)", sender_host_name,
 568         address, sender_helo_name);
 569     }
 570   else
 571     {
 572     fullhost = string_sprintf("%s %s", sender_host_name, address);
 573     rcvhost = sender_ident
 574       ?  string_sprintf("%s (%s ident=%s)", sender_host_name, address,
 575         sender_ident)
 576       : string_sprintf("%s (%s)", sender_host_name, address);
 577     }
 578   }
 579
 580 sender_fullhost = string_copy_perm(fullhost, TRUE);
 581 sender_rcvhost = string_copy_perm(rcvhost, TRUE);
 582
 583 store_reset(reset_point);
 584
 585 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
 586 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
 587 }
 588
 589
 590
 591 /*************************************************
 592 *          Build host+ident message              *
 593 *************************************************/
 594
 595 /* Used when logging rejections and various ACL and SMTP incidents. The text
 596 return depends on whether sender_fullhost and sender_ident are set or not:
 597
 598   no ident, no host   => U=unknown
 599   no ident, host set  => H=sender_fullhost
 600   ident set, no host  => U=ident
 601   ident set, host set => H=sender_fullhost U=ident
 602
 603 Arguments:
 604   useflag   TRUE if first item to be flagged (H= or U=); if there are two
 605               items, the second is always flagged
 606
 607 Returns:    pointer to an allocated string
 608 */
 609
 610 uschar *
 611 host_and_ident(BOOL useflag)
 612 {
 613 gstring * g = NULL;
 614
 615 if (!sender_fullhost)
 616   {
 617   if (useflag)
 618     g = string_catn(g, US"U=", 2);
 619   g = string_cat(g, sender_ident ? sender_ident : US"unknown");
 620   }
 621 else
 622   {
 623   if (useflag)
 624     g = string_catn(g, US"H=", 2);
 625   g = string_cat(g, sender_fullhost);
 626   if (LOGGING(incoming_interface) && interface_address)
 627     g = string_fmt_append(g, " I=[%s]:%d", interface_address, interface_port);
 628   if (sender_ident)
 629     g = string_fmt_append(g, " U=%s", sender_ident);
 630   }
 631 gstring_release_unused(g);
 632 return string_from_gstring(g);
 633 }
 634
 635 #endif   /* STAND_ALONE */
 636
 637
 638
 639
 640 /*************************************************
 641 *         Build list of local interfaces         *
 642 *************************************************/
 643
 644 /* This function interprets the contents of the local_interfaces or
 645 extra_local_interfaces options, and creates an ip_address_item block for each
 646 item on the list. There is no special interpretation of any IP addresses; in
 647 particular, 0.0.0.0 and ::0 are returned without modification. If any address
 648 includes a port, it is set in the block. Otherwise the port value is set to
 649 zero.
 650
 651 Arguments:
 652   list        the list
 653   name        the name of the option being expanded
 654
 655 Returns:      a chain of ip_address_items, each containing to a textual
 656               version of an IP address, and a port number (host order) or
 657               zero if no port was given with the address
 658 */
 659
 660 ip_address_item *
 661 host_build_ifacelist(const uschar *list, uschar *name)
 662 {
 663 int sep = 0;
 664 uschar *s;
 665 ip_address_item * yield = NULL, * last = NULL, * next;
 666
 667 while ((s = string_nextinlist(&list, &sep, NULL, 0)))
 668   {
 669   int ipv;
 670   int port = host_address_extract_port(s);            /* Leaves just the IP address */
 671
 672   if (!(ipv = string_is_ip_address(s, NULL)))
 673     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
 674       s, name);
 675
 676   /* Skip IPv6 addresses if IPv6 is disabled. */
 677
 678   if (disable_ipv6 && ipv == 6) continue;
 679
 680   /* This use of strcpy() is OK because we have checked that s is a valid IP
 681   address above. The field in the ip_address_item is large enough to hold an
 682   IPv6 address. */
 683
 684   next = store_get(sizeof(ip_address_item), list);
 685   next->next = NULL;
 686   Ustrcpy(next->address, s);
 687   next->port = port;
 688   next->v6_include_v4 = FALSE;
 689   next->log = NULL;
 690
 691   if (!yield)
 692     yield = last = next;
 693   else
 694     {
 695     last->next = next;
 696     last = next;
 697     }
 698   }
 699
 700 return yield;
 701 }
 702
 703
 704
 705
 706
 707 /*************************************************
 708 *         Find addresses on local interfaces     *
 709 *************************************************/
 710
 711 /* This function finds the addresses of local IP interfaces. These are used
 712 when testing for routing to the local host. As the function may be called more
 713 than once, the list is preserved in permanent store, pointed to by a static
 714 variable, to save doing the work more than once per process.
 715
 716 The generic list of interfaces is obtained by calling host_build_ifacelist()
 717 for local_interfaces and extra_local_interfaces. This list scanned to remove
 718 duplicates (which may exist with different ports - not relevant here). If
 719 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
 720 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
 721 obtained from os_find_running_interfaces().
 722
 723 Arguments:    none
 724 Returns:      a chain of ip_address_items, each containing to a textual
 725               version of an IP address; the port numbers are not relevant
 726 */
 727
 728
 729 /* First, a local subfunction to add an interface to a list in permanent store,
 730 but only if there isn't a previous copy of that address on the list. */
 731
 732 static ip_address_item *
 733 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
 734 {
 735 ip_address_item *ipa2;
 736 for (ipa2 = list; ipa2; ipa2 = ipa2->next)
 737   if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
 738 ipa2 = store_get_perm(sizeof(ip_address_item), FALSE);
 739 *ipa2 = *ipa;
 740 ipa2->next = list;
 741 return ipa2;
 742 }
 743
 744
 745 /* This is the globally visible function */
 746
 747 ip_address_item *
 748 host_find_interfaces(void)
 749 {
 750 ip_address_item *running_interfaces = NULL;
 751
 752 if (!local_interface_data)
 753   {
 754   void *reset_item = store_mark();
 755   ip_address_item *dlist = host_build_ifacelist(CUS local_interfaces,
 756     US"local_interfaces");
 757   ip_address_item *xlist = host_build_ifacelist(CUS extra_local_interfaces,
 758     US"extra_local_interfaces");
 759   ip_address_item *ipa;
 760
 761   if (!dlist) dlist = xlist;
 762   else
 763     {
 764     for (ipa = dlist; ipa->next; ipa = ipa->next) ;
 765     ipa->next = xlist;
 766     }
 767
 768   for (ipa = dlist; ipa; ipa = ipa->next)
 769     {
 770     if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
 771         Ustrcmp(ipa->address, "::0") == 0)
 772       {
 773       BOOL ipv6 = ipa->address[0] == ':';
 774       if (!running_interfaces)
 775         running_interfaces = os_find_running_interfaces();
 776       for (ip_address_item * ipa2 = running_interfaces; ipa2; ipa2 = ipa2->next)
 777         if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
 778           local_interface_data = add_unique_interface(local_interface_data,
 779                                                       ipa2);
 780       }
 781     else
 782       {
 783       local_interface_data = add_unique_interface(local_interface_data, ipa);
 784       DEBUG(D_interface)
 785         {
 786         debug_printf("Configured local interface: address=%s", ipa->address);
 787         if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
 788         debug_printf("\n");
 789         }
 790       }
 791     }
 792   store_reset(reset_item);
 793   }
 794
 795 return local_interface_data;
 796 }
 797
 798
 799
 800
 801
 802 /*************************************************
 803 *        Convert network IP address to text      *
 804 *************************************************/
 805
 806 /* Given an IPv4 or IPv6 address in binary, convert it to a text
 807 string and return the result in a piece of new store. The address can
 808 either be given directly, or passed over in a sockaddr structure. Note
 809 that this isn't the converse of host_aton() because of byte ordering
 810 differences. See host_nmtoa() below.
 811
 812 Arguments:
 813   type       if < 0 then arg points to a sockaddr, else
 814              either AF_INET or AF_INET6
 815   arg        points to a sockaddr if type is < 0, or
 816              points to an IPv4 address (32 bits), or
 817              points to an IPv6 address (128 bits),
 818              in both cases, in network byte order
 819   buffer     if NULL, the result is returned in gotten store;
 820              else points to a buffer to hold the answer
 821   portptr    points to where to put the port number, if non NULL; only
 822              used when type < 0
 823
 824 Returns:     pointer to character string
 825 */
 826
 827 uschar *
 828 host_ntoa(int type, const void * arg, uschar * buffer, int * portptr)
 829 {
 830 uschar * yield;
 831
 832 /* The new world. It is annoying that we have to fish out the address from
 833 different places in the block, depending on what kind of address it is. It
 834 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
 835 function inet_ntoa() returns just uschar *, and some picky compilers insist
 836 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
 837
 838 #if HAVE_IPV6
 839 uschar addr_buffer[46];
 840 if (type < 0)
 841   {
 842   int family = ((struct sockaddr *)arg)->sa_family;
 843   if (family == AF_INET6)
 844     {
 845     struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
 846     yield = US inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
 847       sizeof(addr_buffer));
 848     if (portptr) *portptr = ntohs(sk->sin6_port);
 849     }
 850   else
 851     {
 852     struct sockaddr_in *sk = (struct sockaddr_in *)arg;
 853     yield = US inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
 854       sizeof(addr_buffer));
 855     if (portptr) *portptr = ntohs(sk->sin_port);
 856     }
 857   }
 858 else
 859   {
 860   yield = US inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
 861   }
 862
 863 /* If the result is a mapped IPv4 address, show it in V4 format. */
 864
 865 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
 866
 867 #else  /* HAVE_IPV6 */
 868
 869 /* The old world */
 870
 871 if (type < 0)
 872   {
 873   yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
 874   if (portptr) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
 875   }
 876 else
 877   yield = US inet_ntoa(*((struct in_addr *)arg));
 878 #endif
 879
 880 /* If there is no buffer, put the string into some new store. */
 881
 882 if (!buffer) buffer = store_get(46, GET_UNTAINTED);
 883
 884 /* Callers of this function with a non-NULL buffer must ensure that it is
 885 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
 886 makes this use of strcpy() OK.
 887 If the library returned apparently an apparently tainted string, clean it;
 888 we trust IP addresses. */
 889
 890 string_format_nt(buffer, 46, "%s", yield);
 891 return buffer;
 892 }
 893
 894
 895
 896
 897 /*************************************************
 898 *         Convert address text to binary         *
 899 *************************************************/
 900
 901 /* Given the textual form of an IP address, convert it to binary in an
 902 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
 903 The result has the first byte in the most significant byte of the first int. In
 904 other words, the result is not in network byte order, but in host byte order.
 905 As a result, this is not the converse of host_ntoa(), which expects network
 906 byte order. See host_nmtoa() below.
 907
 908 Arguments:
 909   address    points to the textual address, checked for syntax
 910   bin        points to an array of 4 ints
 911
 912 Returns:     the number of ints used
 913 */
 914
 915 int
 916 host_aton(const uschar * address, int * bin)
 917 {
 918 int x[4];
 919 int v4offset = 0;
 920
 921 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
 922 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
 923 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
 924 supported. */
 925
 926 if (Ustrchr(address, ':') != NULL)
 927   {
 928   const uschar * p = address;
 929   const uschar * component[8];
 930   BOOL ipv4_ends = FALSE;
 931   int ci = 0, nulloffset = 0, v6count = 8, i;
 932
 933   /* If the address starts with a colon, it will start with two colons.
 934   Just lose the first one, which will leave a null first component. */
 935
 936   if (*p == ':') p++;
 937
 938   /* Split the address into components separated by colons. The input address
 939   is supposed to be checked for syntax. There was a case where this was
 940   overlooked; to guard against that happening again, check here and crash if
 941   there are too many components. */
 942
 943   while (*p && *p != '%')
 944     {
 945     int len = Ustrcspn(p, ":%");
 946     if (len == 0) nulloffset = ci;
 947     if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
 948       "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
 949       address);
 950     component[ci++] = p;
 951     p += len;
 952     if (*p == ':') p++;
 953     }
 954
 955   /* If the final component contains a dot, it is a trailing v4 address.
 956   As the syntax is known to be checked, just set up for a trailing
 957   v4 address and restrict the v6 part to 6 components. */
 958
 959   if (Ustrchr(component[ci-1], '.') != NULL)
 960     {
 961     address = component[--ci];
 962     ipv4_ends = TRUE;
 963     v4offset = 3;
 964     v6count = 6;
 965     }
 966
 967   /* If there are fewer than 6 or 8 components, we have to insert some
 968   more empty ones in the middle. */
 969
 970   if (ci < v6count)
 971     {
 972     int insert_count = v6count - ci;
 973     for (i = v6count-1; i > nulloffset + insert_count; i--)
 974       component[i] = component[i - insert_count];
 975     while (i > nulloffset) component[i--] = US"";
 976     }
 977
 978   /* Now turn the components into binary in pairs and bung them
 979   into the vector of ints. */
 980
 981   for (i = 0; i < v6count; i += 2)
 982     bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
 983       Ustrtol(component[i+1], NULL, 16);
 984
 985   /* If there was no terminating v4 component, we are done. */
 986
 987   if (!ipv4_ends) return 4;
 988   }
 989
 990 /* Handle IPv4 address */
 991
 992 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
 993 bin[v4offset] = ((uint)x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
 994 return v4offset+1;
 995 }
 996
 997
 998 /*************************************************
 999 *           Apply mask to an IP address          *
1000 *************************************************/
1001
1002 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1003 first int, etc.
1004
1005 Arguments:
1006   count        the number of ints
1007   binary       points to the ints to be masked
1008   mask         the count of ms bits to leave, or -1 if no masking
1009
1010 Returns:       nothing
1011 */
1012
1013 void
1014 host_mask(int count, int *binary, int mask)
1015 {
1016 if (mask < 0) mask = 99999;
1017 for (int i = 0; i < count; i++)
1018   {
1019   int wordmask;
1020   if (mask == 0) wordmask = 0;
1021   else if (mask < 32)
1022     {
1023     wordmask = (uint)(-1) << (32 - mask);
1024     mask = 0;
1025     }
1026   else
1027     {
1028     wordmask = -1;
1029     mask -= 32;
1030     }
1031   binary[i] &= wordmask;
1032   }
1033 }
1034
1035
1036
1037
1038 /*************************************************
1039 *     Convert masked IP address in ints to text  *
1040 *************************************************/
1041
1042 /* We can't use host_ntoa() because it assumes the binary values are in network
1043 byte order, and these are the result of host_aton(), which puts them in ints in
1044 host byte order. Also, we really want IPv6 addresses to be in a canonical
1045 format, so we output them with no abbreviation. In a number of cases we can't
1046 use the normal colon separator in them because it terminates keys in lsearch
1047 files, so we want to use dot instead. There's an argument that specifies what
1048 to use for IPv6 addresses.
1049
1050 Arguments:
1051   count       1 or 4 (number of ints)
1052   binary      points to the ints
1053   mask        mask value; if < 0 don't add to result
1054   buffer      big enough to hold the result
1055   sep         component separator character for IPv6 addresses
1056
1057 Returns:      the number of characters placed in buffer, not counting
1058               the final nul.
1059 */
1060
1061 int
1062 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1063 {
1064 int j;
1065 uschar *tt = buffer;
1066
1067 if (count == 1)
1068   {
1069   j = binary[0];
1070   for (int i = 24; i >= 0; i -= 8)
1071     tt += sprintf(CS tt, "%d.", (j >> i) & 255);
1072   }
1073 else
1074   for (int i = 0; i < 4; i++)
1075     {
1076     j = binary[i];
1077     tt += sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1078     }
1079
1080 tt--;   /* lose final separator */
1081
1082 if (mask < 0)
1083   *tt = 0;
1084 else
1085   tt += sprintf(CS tt, "/%d", mask);
1086
1087 return tt - buffer;
1088 }
1089
1090
1091 /* Like host_nmtoa() but: ipv6-only, canonical output, no mask
1092
1093 Arguments:
1094   binary      points to the ints
1095   buffer      big enough to hold the result
1096
1097 Returns:      the number of characters placed in buffer, not counting
1098               the final nul.
1099 */
1100
1101 int
1102 ipv6_nmtoa(int * binary, uschar * buffer)
1103 {
1104 int i, j, k;
1105 uschar * c = buffer;
1106 uschar * d = NULL;      /* shut insufficiently "clever" compiler up */
1107
1108 for (i = 0; i < 4; i++)
1109   {                     /* expand to text */
1110   j = binary[i];
1111   c += sprintf(CS c, "%x:%x:", (j >> 16) & 0xffff, j & 0xffff);
1112   }
1113
1114 for (c = buffer, k = -1, i = 0; i < 8; i++)
1115   {                     /* find longest 0-group sequence */
1116   if (*c == '0')        /* must be "0:" */
1117     {
1118     uschar * s = c;
1119     j = i;
1120     while (c[2] == '0') i++, c += 2;
1121     if (i-j > k)
1122       {
1123       k = i-j;          /* length of sequence */
1124       d = s;            /* start of sequence */
1125       }
1126     }
1127   while (*++c != ':') ;
1128   c++;
1129   }
1130
1131 *--c = '\0';    /* drop trailing colon */
1132
1133 /* debug_printf("%s: D k %d <%s> <%s>\n", __FUNCTION__, k, buffer, buffer + 2*(k+1)); */
1134 if (k >= 0)
1135   {                     /* collapse */
1136   c = d + 2*(k+1);
1137   if (d == buffer) c--; /* need extra colon */
1138   *d++ = ':';   /* 1st 0 */
1139   while ((*d++ = *c++)) ;
1140   }
1141 else
1142   d = c;
1143
1144 return d - buffer;
1145 }
1146
1147
1148
1149 /*************************************************
1150 *        Check port for tls_on_connect           *
1151 *************************************************/
1152
1153 /* This function checks whether a given incoming port is configured for tls-
1154 on-connect. It is called from the daemon and from inetd handling. If the global
1155 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1156 check the tls_on_connect_ports option for a list of ports.
1157
1158 Argument:  a port number
1159 Returns:   TRUE or FALSE
1160 */
1161
1162 BOOL
1163 host_is_tls_on_connect_port(int port)
1164 {
1165 int sep = 0;
1166 const uschar * list = tls_in.on_connect_ports;
1167
1168 if (tls_in.on_connect) return TRUE;
1169
1170 for (uschar * s, * end; s = string_nextinlist(&list, &sep, NULL, 0); )
1171   if (Ustrtol(s, &end, 10) == port)
1172     return TRUE;
1173
1174 return FALSE;
1175 }
1176
1177
1178
1179 /*************************************************
1180 *        Check whether host is in a network      *
1181 *************************************************/
1182
1183 /* This function checks whether a given IP address matches a pattern that
1184 represents either a single host, or a network (using CIDR notation). The caller
1185 of this function must check the syntax of the arguments before calling it.
1186
1187 Arguments:
1188   host        string representation of the ip-address to check
1189   net         string representation of the network, with optional CIDR mask
1190   maskoffset  offset to the / that introduces the mask in the key
1191               zero if there is no mask
1192
1193 Returns:
1194   TRUE   the host is inside the network
1195   FALSE  the host is NOT inside the network
1196 */
1197
1198 BOOL
1199 host_is_in_net(const uschar *host, const uschar *net, int maskoffset)
1200 {
1201 int address[4];
1202 int incoming[4];
1203 int mlen;
1204 int size = host_aton(net, address);
1205 int insize;
1206
1207 /* No mask => all bits to be checked */
1208
1209 if (maskoffset == 0) mlen = 99999;    /* Big number */
1210   else mlen = Uatoi(net + maskoffset + 1);
1211
1212 /* Convert the incoming address to binary. */
1213
1214 insize = host_aton(host, incoming);
1215
1216 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1217    connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1218    ::ffff:<v4address>, to IPv4 format. */
1219
1220 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1221     incoming[2] == 0xffff)
1222   {
1223   insize = 1;
1224   incoming[0] = incoming[3];
1225   }
1226
1227 /* No match if the sizes don't agree. */
1228
1229 if (insize != size) return FALSE;
1230
1231 /* Else do the masked comparison. */
1232
1233 for (int i = 0; i < size; i++)
1234   {
1235   int mask;
1236   if (mlen == 0) mask = 0;
1237   else if (mlen < 32)
1238     {
1239     mask = (uint)(-1) << (32 - mlen);
1240     mlen = 0;
1241     }
1242   else
1243     {
1244     mask = -1;
1245     mlen -= 32;
1246     }
1247   if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1248   }
1249
1250 return TRUE;
1251 }
1252
1253
1254
1255 /*************************************************
1256 *       Scan host list for local hosts           *
1257 *************************************************/
1258
1259 /* Scan through a chain of addresses and check whether any of them is the
1260 address of an interface on the local machine. If so, remove that address and
1261 any previous ones with the same MX value, and all subsequent ones (which will
1262 have greater or equal MX values) from the chain. Note: marking them as unusable
1263 is NOT the right thing to do because it causes the hosts not to be used for
1264 other domains, for which they may well be correct.
1265
1266 The hosts may be part of a longer chain; we only process those between the
1267 initial pointer and the "last" pointer.
1268
1269 There is also a list of "pseudo-local" host names which are checked against the
1270 host names. Any match causes that host item to be treated the same as one which
1271 matches a local IP address.
1272
1273 If the very first host is a local host, then all MX records had a precedence
1274 greater than or equal to that of the local host. Either there's a problem in
1275 the DNS, or an apparently remote name turned out to be an abbreviation for the
1276 local host. Give a specific return code, and let the caller decide what to do.
1277 Otherwise, give a success code if at least one host address has been found.
1278
1279 Arguments:
1280   host        pointer to the first host in the chain
1281   lastptr     pointer to pointer to the last host in the chain (may be updated)
1282   removed     if not NULL, set TRUE if some local addresses were removed
1283                 from the list
1284
1285 Returns:
1286   HOST_FOUND       if there is at least one host with an IP address on the chain
1287                      and an MX value less than any MX value associated with the
1288                      local host
1289   HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1290                      the host addresses were obtained from A records or
1291                      gethostbyname(), the MX values are set to -1.
1292   HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1293 */
1294
1295 int
1296 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1297 {
1298 int yield = HOST_FIND_FAILED;
1299 host_item *last = *lastptr;
1300 host_item *prev = NULL;
1301 host_item *h;
1302
1303 if (removed != NULL) *removed = FALSE;
1304
1305 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1306
1307 for (h = host; h != last->next; h = h->next)
1308   {
1309   #ifndef STAND_ALONE
1310   if (hosts_treat_as_local != NULL)
1311     {
1312     int rc;
1313     const uschar *save = deliver_domain;
1314     deliver_domain = h->name;   /* set $domain */
1315     rc = match_isinlist(string_copylc(h->name), CUSS &hosts_treat_as_local, 0,
1316       &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1317     deliver_domain = save;
1318     if (rc == OK) goto FOUND_LOCAL;
1319     }
1320   #endif
1321
1322   /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1323   for 127.0.0.1 and refers to the local host. We therefore force it always to
1324   be treated as local. */
1325
1326   if (h->address != NULL)
1327     {
1328     if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1329     for (ip_address_item * ip = local_interface_data; ip; ip = ip->next)
1330       if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1331     yield = HOST_FOUND;  /* At least one remote address has been found */
1332     }
1333
1334   /* Update prev to point to the last host item before any that have
1335   the same MX value as the one we have just considered. */
1336
1337   if (h->next == NULL || h->next->mx != h->mx) prev = h;
1338   }
1339
1340 return yield;  /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1341
1342 /* A host whose IP address matches a local IP address, or whose name matches
1343 something in hosts_treat_as_local has been found. */
1344
1345 FOUND_LOCAL:
1346
1347 if (prev == NULL)
1348   {
1349   HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1350     "local host has lowest MX\n" :
1351     "local host found for non-MX address\n");
1352   return HOST_FOUND_LOCAL;
1353   }
1354
1355 HDEBUG(D_host_lookup)
1356   {
1357   debug_printf("local host in host list - removed hosts:\n");
1358   for (h = prev->next; h != last->next; h = h->next)
1359     debug_printf("  %s %s %d\n", h->name, h->address, h->mx);
1360   }
1361
1362 if (removed != NULL) *removed = TRUE;
1363 prev->next = last->next;
1364 *lastptr = prev;
1365 return yield;
1366 }
1367
1368
1369
1370
1371 /*************************************************
1372 *        Remove duplicate IPs in host list       *
1373 *************************************************/
1374
1375 /* You would think that administrators could set up their DNS records so that
1376 one ended up with a list of unique IP addresses after looking up A or MX
1377 records, but apparently duplication is common. So we scan such lists and
1378 remove the later duplicates. Note that we may get lists in which some host
1379 addresses are not set.
1380
1381 Arguments:
1382   host        pointer to the first host in the chain
1383   lastptr     pointer to pointer to the last host in the chain (may be updated)
1384
1385 Returns:      nothing
1386 */
1387
1388 static void
1389 host_remove_duplicates(host_item *host, host_item **lastptr)
1390 {
1391 while (host != *lastptr)
1392   {
1393   if (host->address != NULL)
1394     {
1395     host_item *h = host;
1396     while (h != *lastptr)
1397       {
1398       if (h->next->address != NULL &&
1399           Ustrcmp(h->next->address, host->address) == 0)
1400         {
1401         DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1402           "removed\n", host->address, h->next->mx);
1403         if (h->next == *lastptr) *lastptr = h;
1404         h->next = h->next->next;
1405         }
1406       else h = h->next;
1407       }
1408     }
1409   /* If the last item was removed, host may have become == *lastptr */
1410   if (host != *lastptr) host = host->next;
1411   }
1412 }
1413
1414
1415
1416
1417 /*************************************************
1418 *    Find sender host name by gethostbyaddr()    *
1419 *************************************************/
1420
1421 /* This used to be the only way it was done, but it turns out that not all
1422 systems give aliases for calls to gethostbyaddr() - or one of the modern
1423 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1424 but they can still exist. This function is now used only when a DNS lookup of
1425 the IP address fails, in order to give access to /etc/hosts.
1426
1427 Arguments:   none
1428 Returns:     OK, DEFER, FAIL
1429 */
1430
1431 static int
1432 host_name_lookup_byaddr(void)
1433 {
1434 struct hostent * hosts;
1435 struct in_addr addr;
1436 unsigned long time_msec = 0;    /* init to quieten dumb static analysis */
1437
1438 if (slow_lookup_log) time_msec = get_time_in_ms();
1439
1440 /* Lookup on IPv6 system */
1441
1442 #if HAVE_IPV6
1443 if (Ustrchr(sender_host_address, ':') != NULL)
1444   {
1445   struct in6_addr addr6;
1446   if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1447     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1448       "IPv6 address", sender_host_address);
1449   #if HAVE_GETIPNODEBYADDR
1450   hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1451   #else
1452   hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1453   #endif
1454   }
1455 else
1456   {
1457   if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1458     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1459       "IPv4 address", sender_host_address);
1460   #if HAVE_GETIPNODEBYADDR
1461   hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1462   #else
1463   hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1464   #endif
1465   }
1466
1467 /* Do lookup on IPv4 system */
1468
1469 #else
1470 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1471 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1472 #endif
1473
1474 if (  slow_lookup_log
1475    && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
1476    )
1477   log_long_lookup(US"gethostbyaddr", sender_host_address, time_msec);
1478
1479 /* Failed to look up the host. */
1480
1481 if (!hosts)
1482   {
1483   HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1484     h_errno);
1485   return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1486   }
1487
1488 /* It seems there are some records in the DNS that yield an empty name. We
1489 treat this as non-existent. In some operating systems, this is returned as an
1490 empty string; in others as a single dot. */
1491
1492 if (!hosts->h_name || !hosts->h_name[0] || hosts->h_name[0] == '.')
1493   {
1494   HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1495     "treated as non-existent host name\n");
1496   return FAIL;
1497   }
1498
1499 /* Copy and lowercase the name, which is in static storage in many systems.
1500 Put it in permanent memory. */
1501
1502   {
1503   int old_pool = store_pool;
1504   store_pool = POOL_TAINT_PERM;         /* names are tainted */
1505
1506   sender_host_name = string_copylc(US hosts->h_name);
1507
1508   /* If the host has aliases, build a copy of the alias list */
1509
1510   if (hosts->h_aliases)
1511     {
1512     int count = 1;  /* need 1 more for terminating NULL */
1513     uschar **ptr;
1514
1515     for (uschar ** aliases = USS hosts->h_aliases; *aliases; aliases++) count++;
1516     store_pool = POOL_PERM;
1517     ptr = sender_host_aliases = store_get(count * sizeof(uschar *), GET_UNTAINTED);
1518     store_pool = POOL_TAINT_PERM;
1519
1520     for (uschar ** aliases = USS hosts->h_aliases; *aliases; aliases++)
1521       *ptr++ = string_copylc(*aliases);
1522     *ptr = NULL;
1523     }
1524   store_pool = old_pool;
1525   }
1526
1527 return OK;
1528 }
1529
1530
1531
1532 /*************************************************
1533 *        Find host name for incoming call        *
1534 *************************************************/
1535
1536 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1537 up a list of alias names, pointed to by sender_host_alias. The list is
1538 NULL-terminated. The incoming address is in sender_host_address, either in
1539 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1540
1541 This function does a thorough check that the names it finds point back to the
1542 incoming IP address. Any that do not are discarded. Note that this is relied on
1543 by the ACL reverse_host_lookup check.
1544
1545 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1546 this it not universally true. Also, for release 4.30, this function was changed
1547 to do a direct DNS lookup first, by default[1], because it turns out that that
1548 is the only guaranteed way to find all the aliases on some systems. My
1549 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1550 Linux does not.
1551
1552 [1] The actual order is controlled by the host_lookup_order option.
1553
1554 Arguments:    none
1555 Returns:      OK on success, the answer being placed in the global variable
1556                 sender_host_name, with any aliases in a list hung off
1557                 sender_host_aliases
1558               FAIL if no host name can be found
1559               DEFER if a temporary error was encountered
1560
1561 The variable host_lookup_msg is set to an empty string on success, or to a
1562 reason for the failure otherwise, in a form suitable for tagging onto an error
1563 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1564 was a defer, host_lookup_deferred is set TRUE.
1565
1566 Any dynamically constructed string for host_lookup_msg must be in permanent
1567 store, because it might be used for several incoming messages on the same SMTP
1568 connection. */
1569
1570 int
1571 host_name_lookup(void)
1572 {
1573 int old_pool, rc;
1574 int sep = 0;
1575 uschar *save_hostname;
1576 uschar **aliases;
1577 uschar *ordername;
1578 const uschar *list = host_lookup_order;
1579 dns_answer * dnsa = store_get_dns_answer();
1580 dns_scan dnss;
1581
1582 sender_host_dnssec = host_lookup_deferred = host_lookup_failed = FALSE;
1583
1584 HDEBUG(D_host_lookup)
1585   debug_printf("looking up host name for %s\n", sender_host_address);
1586
1587 /* For testing the case when a lookup does not complete, we have a special
1588 reserved IP address. */
1589
1590 if (f.running_in_test_harness &&
1591     Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1592   {
1593   HDEBUG(D_host_lookup)
1594     debug_printf("Test harness: host name lookup returns DEFER\n");
1595   host_lookup_deferred = TRUE;
1596   return DEFER;
1597   }
1598
1599 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1600 the order specified by the host_lookup_order option. */
1601
1602 while ((ordername = string_nextinlist(&list, &sep, NULL, 0)))
1603   {
1604   if (strcmpic(ordername, US"bydns") == 0)
1605     {
1606     uschar * name = dns_build_reverse(sender_host_address);
1607
1608     dns_init(FALSE, FALSE, FALSE);    /* dnssec ctrl by dns_dnssec_ok glbl */
1609     rc = dns_lookup_timerwrap(dnsa, name, T_PTR, NULL);
1610
1611     /* The first record we come across is used for the name; others are
1612     considered to be aliases. We have to scan twice, in order to find out the
1613     number of aliases. However, if all the names are empty, we will behave as
1614     if failure. (PTR records that yield empty names have been encountered in
1615     the DNS.) */
1616
1617     if (rc == DNS_SUCCEED)
1618       {
1619       uschar **aptr = NULL;
1620       int ssize = 264;
1621       int count = 1;  /* need 1 more for terminating NULL */
1622       int old_pool = store_pool;
1623
1624       sender_host_dnssec = dns_is_secure(dnsa);
1625       DEBUG(D_dns)
1626         debug_printf("Reverse DNS security status: %s\n",
1627             sender_host_dnssec ? "DNSSEC verified (AD)" : "unverified");
1628
1629       store_pool = POOL_PERM;        /* Save names in permanent storage */
1630
1631       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1632            rr;
1633            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_PTR)
1634         count++;
1635
1636       /* Get store for the list of aliases. For compatibility with
1637       gethostbyaddr, we make an empty list if there are none. */
1638
1639       aptr = sender_host_aliases = store_get(count * sizeof(uschar *), GET_UNTAINTED);
1640
1641       /* Re-scan and extract the names */
1642
1643       for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
1644            rr;
1645            rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_PTR)
1646         {
1647         uschar * s = store_get(ssize, GET_TAINTED);     /* names are tainted */
1648         unsigned slen;
1649
1650         /* If an overlong response was received, the data will have been
1651         truncated and dn_expand may fail. */
1652
1653         if (dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
1654              US (rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1655           {
1656           log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1657             sender_host_address);
1658           break;
1659           }
1660
1661         store_release_above(s + (slen = Ustrlen(s)) + 1);
1662         if (!*s)
1663           {
1664           HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1665             "empty name: treated as non-existent host name\n");
1666           continue;
1667           }
1668         if (Ustrspn(s, letter_digit_hyphen_dot) != slen)
1669           {
1670           HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1671             "illegal name (bad char): treated as non-existent host name\n");
1672           continue;
1673           }
1674         if (!sender_host_name) sender_host_name = s;
1675         else *aptr++ = s;
1676         while (*s) { *s = tolower(*s); s++; }
1677         }
1678
1679       *aptr = NULL;            /* End of alias list */
1680       store_pool = old_pool;   /* Reset store pool */
1681
1682       /* If we've found a name, break out of the "order" loop */
1683
1684       if (sender_host_name) break;
1685       }
1686
1687     /* If the DNS lookup deferred, we must also defer. */
1688
1689     if (rc == DNS_AGAIN)
1690       {
1691       HDEBUG(D_host_lookup)
1692         debug_printf("IP address PTR lookup gave temporary error\n");
1693       host_lookup_deferred = TRUE;
1694       return DEFER;
1695       }
1696     }
1697
1698   /* Do a lookup using gethostbyaddr() - or equivalent */
1699
1700   else if (strcmpic(ordername, US"byaddr") == 0)
1701     {
1702     HDEBUG(D_host_lookup)
1703       debug_printf("IP address lookup using gethostbyaddr()\n");
1704     rc = host_name_lookup_byaddr();
1705     if (rc == DEFER)
1706       {
1707       host_lookup_deferred = TRUE;
1708       return rc;                       /* Can't carry on */
1709       }
1710     if (rc == OK) break;               /* Found a name */
1711     }
1712   }      /* Loop for bydns/byaddr scanning */
1713
1714 /* If we have failed to find a name, return FAIL and log when required.
1715 NB host_lookup_msg must be in permanent store.  */
1716
1717 if (!sender_host_name)
1718   {
1719   if (host_checking || !f.log_testing_mode)
1720     log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1721       "address %s", sender_host_address);
1722   host_lookup_msg = US" (failed to find host name from IP address)";
1723   host_lookup_failed = TRUE;
1724   return FAIL;
1725   }
1726
1727 HDEBUG(D_host_lookup)
1728   {
1729   uschar **aliases = sender_host_aliases;
1730   debug_printf("IP address lookup yielded \"%s\"\n", sender_host_name);
1731   while (*aliases) debug_printf("  alias \"%s\"\n", *aliases++);
1732   }
1733
1734 /* We need to verify that a forward lookup on the name we found does indeed
1735 correspond to the address. This is for security: in principle a malefactor who
1736 happened to own a reverse zone could set it to point to any names at all.
1737
1738 This code was present in versions of Exim before 3.20. At that point I took it
1739 out because I thought that gethostbyaddr() did the check anyway. It turns out
1740 that this isn't always the case, so it's coming back in at 4.01. This version
1741 is actually better, because it also checks aliases.
1742
1743 The code was made more robust at release 4.21. Prior to that, it accepted all
1744 the names if any of them had the correct IP address. Now the code checks all
1745 the names, and accepts only those that have the correct IP address. */
1746
1747 save_hostname = sender_host_name;   /* Save for error messages */
1748 aliases = sender_host_aliases;
1749 for (uschar * hname = sender_host_name; hname; hname = *aliases++)
1750   {
1751   int rc;
1752   BOOL ok = FALSE;
1753   host_item h = { .next = NULL, .name = hname, .mx = MX_NONE, .address = NULL };
1754   dnssec_domains d =
1755     { .request = sender_host_dnssec ? US"*" : NULL, .require = NULL };
1756
1757   if (  (rc = host_find_bydns(&h, NULL, HOST_FIND_BY_A | HOST_FIND_BY_AAAA,
1758           NULL, NULL, NULL, &d, NULL, NULL)) == HOST_FOUND
1759      || rc == HOST_FOUND_LOCAL
1760      )
1761     {
1762     HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1763
1764     /* If the forward lookup was not secure we cancel the is-secure variable */
1765
1766     DEBUG(D_dns) debug_printf("Forward DNS security status: %s\n",
1767           h.dnssec == DS_YES ? "DNSSEC verified (AD)" : "unverified");
1768     if (h.dnssec != DS_YES) sender_host_dnssec = FALSE;
1769
1770     for (host_item * hh = &h; hh; hh = hh->next)
1771       if (host_is_in_net(hh->address, sender_host_address, 0))
1772         {
1773         HDEBUG(D_host_lookup) debug_printf("  %s OK\n", hh->address);
1774         ok = TRUE;
1775         break;
1776         }
1777       else
1778         HDEBUG(D_host_lookup) debug_printf("  %s\n", hh->address);
1779
1780     if (!ok) HDEBUG(D_host_lookup)
1781       debug_printf("no IP address for %s matched %s\n", hname,
1782         sender_host_address);
1783     }
1784   else if (rc == HOST_FIND_AGAIN)
1785     {
1786     HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1787     host_lookup_deferred = TRUE;
1788     sender_host_name = NULL;
1789     return DEFER;
1790     }
1791   else
1792     HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1793
1794   /* If this name is no good, and it's the sender name, set it null pro tem;
1795   if it's an alias, just remove it from the list. */
1796
1797   if (!ok)
1798     {
1799     if (hname == sender_host_name) sender_host_name = NULL; else
1800       {
1801       uschar **a;                              /* Don't amalgamate - some */
1802       a = --aliases;                           /* compilers grumble */
1803       while (*a != NULL) { *a = a[1]; a++; }
1804       }
1805     }
1806   }
1807
1808 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1809 it with the first alias, if there is one. */
1810
1811 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1812   sender_host_name = *sender_host_aliases++;
1813
1814 /* If we now have a main name, all is well. */
1815
1816 if (sender_host_name != NULL) return OK;
1817
1818 /* We have failed to find an address that matches. */
1819
1820 HDEBUG(D_host_lookup)
1821   debug_printf("%s does not match any IP address for %s\n",
1822     sender_host_address, save_hostname);
1823
1824 /* This message must be in permanent store */
1825
1826 old_pool = store_pool;
1827 store_pool = POOL_PERM;
1828 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1829   sender_host_address, save_hostname);
1830 store_pool = old_pool;
1831 host_lookup_failed = TRUE;
1832 return FAIL;
1833 }
1834
1835
1836
1837
1838 /*************************************************
1839 *    Find IP address(es) for host by name        *
1840 *************************************************/
1841
1842 /* The input is a host_item structure with the name filled in and the address
1843 field set to NULL. We use gethostbyname() or getipnodebyname() or
1844 gethostbyname2(), as appropriate. Of course, these functions may use the DNS,
1845 but they do not do MX processing. It appears, however, that in some systems the
1846 current setting of resolver options is used when one of these functions calls
1847 the resolver. For this reason, we call dns_init() at the start, with arguments
1848 influenced by bits in "flags", just as we do for host_find_bydns().
1849
1850 The second argument provides a host list (usually an IP list) of hosts to
1851 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1852 addresses in unreasonable places.
1853
1854 The lookup may result in a change of name. For compatibility with the dns
1855 lookup, return this via fully_qualified_name as well as updating the host item.
1856 The lookup may also yield more than one IP address, in which case chain on
1857 subsequent host_item structures.
1858
1859 Arguments:
1860   host                   a host item with the name and MX filled in;
1861                            the address is to be filled in;
1862                            multiple IP addresses cause other host items to be
1863                              chained on.
1864   ignore_target_hosts    a list of hosts to ignore
1865   flags                  HOST_FIND_QUALIFY_SINGLE   ) passed to
1866                          HOST_FIND_SEARCH_PARENTS   )   dns_init()
1867   fully_qualified_name   if not NULL, set to point to host name for
1868                          compatibility with host_find_bydns
1869   local_host_check       TRUE if a check for the local host is wanted
1870
1871 Returns:                 HOST_FIND_FAILED  Failed to find the host or domain
1872                          HOST_FIND_AGAIN   Try again later
1873                          HOST_FOUND        Host found - data filled in
1874                          HOST_FOUND_LOCAL  Host found and is the local host
1875 */
1876
1877 int
1878 host_find_byname(host_item *host, const uschar *ignore_target_hosts, int flags,
1879   const uschar **fully_qualified_name, BOOL local_host_check)
1880 {
1881 int yield, times;
1882 host_item *last = NULL;
1883 BOOL temp_error = FALSE;
1884 int af;
1885
1886 #ifndef DISABLE_TLS
1887 /* Copy the host name at this point to the value which is used for
1888 TLS certificate name checking, before anything modifies it.  */
1889
1890 host->certname = host->name;
1891 #endif
1892
1893 /* Make sure DNS options are set as required. This appears to be necessary in
1894 some circumstances when the get..byname() function actually calls the DNS. */
1895
1896 dns_init((flags & HOST_FIND_QUALIFY_SINGLE) != 0,
1897          (flags & HOST_FIND_SEARCH_PARENTS) != 0,
1898          FALSE);                /* Cannot retrieve dnssec status so do not request */
1899
1900 /* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
1901 kinds of address, so go round the loop twice. Note that we have ensured that
1902 AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
1903 code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
1904 lookups here (except when testing standalone). */
1905
1906 #if HAVE_IPV6
1907   #ifdef STAND_ALONE
1908   if (disable_ipv6)
1909   #else
1910   if (  disable_ipv6
1911      ||    dns_ipv4_lookup
1912         && match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0,
1913             &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK)
1914   #endif
1915
1916     { af = AF_INET; times = 1; }
1917   else
1918     { af = AF_INET6; times = 2; }
1919
1920 /* No IPv6 support */
1921
1922 #else   /* HAVE_IPV6 */
1923   af = AF_INET; times = 1;
1924 #endif  /* HAVE_IPV6 */
1925
1926 /* Initialize the flag that gets set for DNS syntax check errors, so that the
1927 interface to this function can be similar to host_find_bydns. */
1928
1929 f.host_find_failed_syntax = FALSE;
1930
1931 /* Loop to look up both kinds of address in an IPv6 world */
1932
1933 for (int i = 1; i <= times;
1934      #if HAVE_IPV6
1935        af = AF_INET,     /* If 2 passes, IPv4 on the second */
1936      #endif
1937      i++)
1938   {
1939   BOOL ipv4_addr;
1940   int error_num = 0;
1941   struct hostent *hostdata;
1942   unsigned long time_msec = 0;  /* compiler quietening */
1943
1944   #ifdef STAND_ALONE
1945   printf("Looking up: %s\n", host->name);
1946   #endif
1947
1948   if (slow_lookup_log) time_msec = get_time_in_ms();
1949
1950   #if HAVE_IPV6
1951   if (f.running_in_test_harness)
1952     hostdata = host_fake_gethostbyname(host->name, af, &error_num);
1953   else
1954     {
1955     #if HAVE_GETIPNODEBYNAME
1956     hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
1957     #else
1958     hostdata = gethostbyname2(CS host->name, af);
1959     error_num = h_errno;
1960     #endif
1961     }
1962
1963   #else    /* not HAVE_IPV6 */
1964   if (f.running_in_test_harness)
1965     hostdata = host_fake_gethostbyname(host->name, af, &error_num);
1966   else
1967     {
1968     hostdata = gethostbyname(CS host->name);
1969     error_num = h_errno;
1970     }
1971   #endif   /* HAVE_IPV6 */
1972
1973   if (   slow_lookup_log
1974       && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
1975     log_long_lookup(US"gethostbyname", host->name, time_msec);
1976
1977   if (!hostdata)
1978     {
1979     uschar * error;
1980     switch (error_num)
1981       {
1982       case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND";  break;
1983       case TRY_AGAIN:      error = US"TRY_AGAIN";   temp_error = TRUE; break;
1984       case NO_RECOVERY:    error = US"NO_RECOVERY"; temp_error = TRUE; break;
1985       case NO_DATA:        error = US"NO_DATA";         break;
1986     #if NO_DATA != NO_ADDRESS
1987       case NO_ADDRESS:     error = US"NO_ADDRESS";      break;
1988     #endif
1989       default: error = US"?"; break;
1990       }
1991
1992     DEBUG(D_host_lookup) debug_printf("%s(af=%s) returned %d (%s)\n",
1993       f.running_in_test_harness ? "host_fake_gethostbyname" :
1994 #if HAVE_IPV6
1995 # if HAVE_GETIPNODEBYNAME
1996         "getipnodebyname",
1997 # else
1998         "gethostbyname2",
1999 # endif
2000 #else
2001         "gethostbyname",
2002 #endif
2003       af == AF_INET ? "inet" : "inet6", error_num, error);
2004
2005     continue;
2006     }
2007   if (!(hostdata->h_addr_list)[0]) continue;
2008
2009   /* Replace the name with the fully qualified one if necessary, and fill in
2010   the fully_qualified_name pointer. */
2011
2012   if (hostdata->h_name[0] && Ustrcmp(host->name, hostdata->h_name) != 0)
2013     host->name = string_copy_dnsdomain(US hostdata->h_name);
2014   if (fully_qualified_name) *fully_qualified_name = host->name;
2015
2016   /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2017   by their different lengths. Scan the list, ignoring any that are to be
2018   ignored, and build a chain from the rest. */
2019
2020   ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2021
2022   for (uschar ** addrlist = USS hostdata->h_addr_list; *addrlist; addrlist++)
2023     {
2024     uschar *text_address =
2025       host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2026
2027     #ifndef STAND_ALONE
2028     if (  ignore_target_hosts
2029        && verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2030             text_address, NULL) == OK)
2031       {
2032       DEBUG(D_host_lookup)
2033         debug_printf("ignored host %s [%s]\n", host->name, text_address);
2034       continue;
2035       }
2036     #endif
2037
2038     /* If this is the first address, last is NULL and we put the data in the
2039     original block. */
2040
2041     if (!last)
2042       {
2043       host->address = text_address;
2044       host->port = PORT_NONE;
2045       host->status = hstatus_unknown;
2046       host->why = hwhy_unknown;
2047       host->dnssec = DS_UNK;
2048       last = host;
2049       }
2050
2051     /* Else add further host item blocks for any other addresses, keeping
2052     the order. */
2053
2054     else
2055       {
2056       host_item *next = store_get(sizeof(host_item), GET_UNTAINTED);
2057       next->name = host->name;
2058 #ifndef DISABLE_TLS
2059       next->certname = host->certname;
2060 #endif
2061       next->mx = host->mx;
2062       next->address = text_address;
2063       next->port = PORT_NONE;
2064       next->status = hstatus_unknown;
2065       next->why = hwhy_unknown;
2066       next->dnssec = DS_UNK;
2067       next->last_try = 0;
2068       next->next = last->next;
2069       last->next = next;
2070       last = next;
2071       }
2072     }
2073   }
2074
2075 /* If no hosts were found, the address field in the original host block will be
2076 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2077 so we pass that back. */
2078
2079 if (!host->address)
2080   {
2081   uschar *msg =
2082 #ifndef STAND_ALONE
2083     !message_id[0] && smtp_in
2084       ? string_sprintf("no IP address found for host %s (during %s)", host->name,
2085           smtp_get_connection_info()) :
2086 #endif
2087     string_sprintf("no IP address found for host %s", host->name);
2088
2089   HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2090   if (temp_error) goto RETURN_AGAIN;
2091   if (host_checking || !f.log_testing_mode)
2092     log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2093   return HOST_FIND_FAILED;
2094   }
2095
2096 /* Remove any duplicate IP addresses, then check to see if this is the local
2097 host if required. */
2098
2099 host_remove_duplicates(host, &last);
2100 yield = local_host_check?
2101   host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2102
2103 HDEBUG(D_host_lookup)
2104   {
2105   if (fully_qualified_name)
2106     debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2107   debug_printf("%s looked up these IP addresses:\n",
2108     #if HAVE_IPV6
2109       #if HAVE_GETIPNODEBYNAME
2110       "getipnodebyname"
2111       #else
2112       "gethostbyname2"
2113       #endif
2114     #else
2115     "gethostbyname"
2116     #endif
2117     );
2118   for (const host_item * h = host; h != last->next; h = h->next)
2119     debug_printf("  name=%s address=%s\n", h->name,
2120       h->address ? h->address : US"<null>");
2121   }
2122
2123 /* Return the found status. */
2124
2125 return yield;
2126
2127 /* Handle the case when there is a temporary error. If the name matches
2128 dns_again_means_nonexist, return permanent rather than temporary failure. */
2129
2130 RETURN_AGAIN:
2131   {
2132 #ifndef STAND_ALONE
2133   int rc;
2134   const uschar *save = deliver_domain;
2135   deliver_domain = host->name;  /* set $domain */
2136   rc = match_isinlist(host->name, CUSS &dns_again_means_nonexist, 0,
2137     &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
2138   deliver_domain = save;
2139   if (rc == OK)
2140     {
2141     DEBUG(D_host_lookup) debug_printf("%s is in dns_again_means_nonexist: "
2142       "returning HOST_FIND_FAILED\n", host->name);
2143     return HOST_FIND_FAILED;
2144     }
2145 #endif
2146   return HOST_FIND_AGAIN;
2147   }
2148 }
2149
2150
2151
2152 /*************************************************
2153 *        Fill in a host address from the DNS     *
2154 *************************************************/
2155
2156 /* Given a host item, with its name, port and mx fields set, and its address
2157 field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
2158 create additional host items for the additional addresses, copying all the
2159 other fields, and randomizing the order.
2160
2161 On IPv6 systems, AAAA records are sought first, then A records.
2162
2163 The host name may be changed if the DNS returns a different name - e.g. fully
2164 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2165 ensures that it points to the fully qualified name. However, this is the fully
2166 qualified version of the original name; if a CNAME is involved, the actual
2167 canonical host name may be different again, and so we get it directly from the
2168 relevant RR. Note that we do NOT change the mx field of the host item in this
2169 function as it may be called to set the addresses of hosts taken from MX
2170 records.
2171
2172 Arguments:
2173   host                  points to the host item we're filling in
2174   lastptr               points to pointer to last host item in a chain of
2175                           host items (may be updated if host is last and gets
2176                           extended because multihomed)
2177   ignore_target_hosts   list of hosts to ignore
2178   allow_ip              if TRUE, recognize an IP address and return it
2179   fully_qualified_name  if not NULL, return fully qualified name here if
2180                           the contents are different (i.e. it must be preset
2181                           to something)
2182   dnssec_request        if TRUE request the AD bit
2183   dnssec_require        if TRUE require the AD bit
2184   whichrrs              select ipv4, ipv6 results
2185
2186 Returns:       HOST_FIND_FAILED     couldn't find A record
2187                HOST_FIND_AGAIN      try again later
2188                HOST_FIND_SECURITY   dnssec required but not acheived
2189                HOST_FOUND           found AAAA and/or A record(s)
2190                HOST_IGNORED         found, but all IPs ignored
2191 */
2192
2193 static int
2194 set_address_from_dns(host_item *host, host_item **lastptr,
2195   const uschar *ignore_target_hosts, BOOL allow_ip,
2196   const uschar **fully_qualified_name,
2197   BOOL dnssec_request, BOOL dnssec_require, int whichrrs)
2198 {
2199 host_item *thishostlast = NULL;    /* Indicates not yet filled in anything */
2200 BOOL v6_find_again = FALSE;
2201 BOOL dnssec_fail = FALSE;
2202 int i;
2203 dns_answer * dnsa;
2204
2205 #ifndef DISABLE_TLS
2206 /* Copy the host name at this point to the value which is used for
2207 TLS certificate name checking, before any CNAME-following modifies it.  */
2208
2209 host->certname = host->name;
2210 #endif
2211
2212 /* If allow_ip is set, a name which is an IP address returns that value
2213 as its address. This is used for MX records when allow_mx_to_ip is set, for
2214 those sites that feel they have to flaunt the RFC rules. */
2215
2216 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2217   {
2218   #ifndef STAND_ALONE
2219   if (  ignore_target_hosts
2220      && verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2221         host->name, NULL) == OK)
2222     return HOST_IGNORED;
2223   #endif
2224
2225   host->address = host->name;
2226   return HOST_FOUND;
2227   }
2228
2229 dnsa = store_get_dns_answer();
2230
2231 /* On an IPv6 system, unless IPv6 is disabled, go round the loop up to twice,
2232 looking for AAAA records the first time. However, unless doing standalone
2233 testing, we force an IPv4 lookup if the domain matches dns_ipv4_lookup global.
2234 On an IPv4 system, go round the loop once only, looking only for A records. */
2235
2236 #if HAVE_IPV6
2237   #ifndef STAND_ALONE
2238     if (  disable_ipv6
2239        || !(whichrrs & HOST_FIND_BY_AAAA)
2240        ||    dns_ipv4_lookup
2241           && match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0,
2242               &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK
2243        )
2244       i = 0;    /* look up A records only */
2245     else
2246   #endif        /* STAND_ALONE */
2247
2248   i = 1;        /* look up AAAA and A records */
2249
2250 /* The IPv4 world */
2251
2252 #else           /* HAVE_IPV6 */
2253   i = 0;        /* look up A records only */
2254 #endif          /* HAVE_IPV6 */
2255
2256 for (; i >= 0; i--)
2257   {
2258   static int types[] = { T_A, T_AAAA };
2259   int type = types[i];
2260   int randoffset = i == (whichrrs & HOST_FIND_IPV4_FIRST ? 1 : 0)
2261     ? 500 : 0;  /* Ensures v6/4 sort order */
2262   dns_scan dnss;
2263
2264   int rc = dns_lookup_timerwrap(dnsa, host->name, type, fully_qualified_name);
2265   lookup_dnssec_authenticated = !dnssec_request ? NULL
2266     : dns_is_secure(dnsa) ? US"yes" : US"no";
2267
2268   DEBUG(D_dns)
2269     if (  (dnssec_request || dnssec_require)
2270        && !dns_is_secure(dnsa)
2271        && dns_is_aa(dnsa)
2272        )
2273       debug_printf("DNS lookup of %.256s (A/AAAA) requested AD, but got AA\n", host->name);
2274
2275   /* We want to return HOST_FIND_AGAIN if one of the A or AAAA lookups
2276   fails or times out, but not if another one succeeds. (In the early
2277   IPv6 days there are name servers that always fail on AAAA, but are happy
2278   to give out an A record. We want to proceed with that A record.) */
2279
2280   if (rc != DNS_SUCCEED)
2281     {
2282     if (i == 0)  /* Just tried for an A record, i.e. end of loop */
2283       {
2284       if (host->address != NULL)
2285         i = HOST_FOUND;  /* AAAA was found */
2286       else if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2287         i = HOST_FIND_AGAIN;
2288       else
2289         i = HOST_FIND_FAILED;    /* DNS_NOMATCH or DNS_NODATA */
2290       goto out;
2291       }
2292
2293     /* Tried for an AAAA record: remember if this was a temporary
2294     error, and look for the next record type. */
2295
2296     if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2297     continue;
2298     }
2299
2300   if (dnssec_request)
2301     {
2302     if (dns_is_secure(dnsa))
2303       {
2304       DEBUG(D_host_lookup) debug_printf("%s A DNSSEC\n", host->name);
2305       if (host->dnssec == DS_UNK) /* set in host_find_bydns() */
2306         host->dnssec = DS_YES;
2307       }
2308     else
2309       {
2310       if (dnssec_require)
2311         {
2312         dnssec_fail = TRUE;
2313         DEBUG(D_host_lookup) debug_printf("dnssec fail on %s for %.256s",
2314                 i>0 ? "AAAA" : "A", host->name);
2315         continue;
2316         }
2317       if (host->dnssec == DS_YES) /* set in host_find_bydns() */
2318         {
2319         DEBUG(D_host_lookup) debug_printf("%s A cancel DNSSEC\n", host->name);
2320         host->dnssec = DS_NO;
2321         lookup_dnssec_authenticated = US"no";
2322         }
2323       }
2324     }
2325
2326   /* Lookup succeeded: fill in the given host item with the first non-ignored
2327   address found; create additional items for any others. A single A6 record
2328   may generate more than one address.  The lookup had a chance to update the
2329   fqdn; we do not want any later times round the loop to do so. */
2330
2331   fully_qualified_name = NULL;
2332
2333   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2334        rr;
2335        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
2336     {
2337     dns_address * da = dns_address_from_rr(dnsa, rr);
2338
2339     DEBUG(D_host_lookup)
2340       if (!da) debug_printf("no addresses extracted from A6 RR for %s\n",
2341           host->name);
2342
2343     /* This loop runs only once for A and AAAA records, but may run
2344     several times for an A6 record that generated multiple addresses. */
2345
2346     for (; da; da = da->next)
2347       {
2348       #ifndef STAND_ALONE
2349       if (ignore_target_hosts != NULL &&
2350             verify_check_this_host(&ignore_target_hosts, NULL,
2351               host->name, da->address, NULL) == OK)
2352         {
2353         DEBUG(D_host_lookup)
2354           debug_printf("ignored host %s [%s]\n", host->name, da->address);
2355         continue;
2356         }
2357       #endif
2358
2359       /* If this is the first address, stick it in the given host block,
2360       and change the name if the returned RR has a different name. */
2361
2362       if (thishostlast == NULL)
2363         {
2364         if (strcmpic(host->name, rr->name) != 0)
2365           host->name = string_copy_dnsdomain(rr->name);
2366         host->address = da->address;
2367         host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2368         host->status = hstatus_unknown;
2369         host->why = hwhy_unknown;
2370         thishostlast = host;
2371         }
2372
2373       /* Not the first address. Check for, and ignore, duplicates. Then
2374       insert in the chain at a random point. */
2375
2376       else
2377         {
2378         int new_sort_key;
2379         host_item *next;
2380
2381         /* End of our local chain is specified by "thishostlast". */
2382
2383         for (next = host;; next = next->next)
2384           {
2385           if (Ustrcmp(CS da->address, next->address) == 0) break;
2386           if (next == thishostlast) { next = NULL; break; }
2387           }
2388         if (next != NULL) continue;  /* With loop for next address */
2389
2390         /* Not a duplicate */
2391
2392         new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2393         next = store_get(sizeof(host_item), GET_UNTAINTED);
2394
2395         /* New address goes first: insert the new block after the first one
2396         (so as not to disturb the original pointer) but put the new address
2397         in the original block. */
2398
2399         if (new_sort_key < host->sort_key)
2400           {
2401           *next = *host;                                  /* Copies port */
2402           host->next = next;
2403           host->address = da->address;
2404           host->sort_key = new_sort_key;
2405           if (thishostlast == host) thishostlast = next;  /* Local last */
2406           if (*lastptr == host) *lastptr = next;          /* Global last */
2407           }
2408
2409         /* Otherwise scan down the addresses for this host to find the
2410         one to insert after. */
2411
2412         else
2413           {
2414           host_item *h = host;
2415           while (h != thishostlast)
2416             {
2417             if (new_sort_key < h->next->sort_key) break;
2418             h = h->next;
2419             }
2420           *next = *h;                                 /* Copies port */
2421           h->next = next;
2422           next->address = da->address;
2423           next->sort_key = new_sort_key;
2424           if (h == thishostlast) thishostlast = next; /* Local last */
2425           if (h == *lastptr) *lastptr = next;         /* Global last */
2426           }
2427         }
2428       }
2429     }
2430   }
2431
2432 /* Control gets here only if the second lookup (the A record) succeeded.
2433 However, the address may not be filled in if it was ignored. */
2434
2435 i = host->address
2436   ? HOST_FOUND
2437   : dnssec_fail
2438   ? HOST_FIND_SECURITY
2439   : HOST_IGNORED;
2440
2441 out:
2442   store_free_dns_answer(dnsa);
2443   return i;
2444 }
2445
2446
2447
2448
2449 /*************************************************
2450 *    Find IP addresses and host names via DNS    *
2451 *************************************************/
2452
2453 /* The input is a host_item structure with the name field filled in and the
2454 address field set to NULL. This may be in a chain of other host items. The
2455 lookup may result in more than one IP address, in which case we must created
2456 new host blocks for the additional addresses, and insert them into the chain.
2457 The original name may not be fully qualified. Use the fully_qualified_name
2458 argument to return the official name, as returned by the resolver.
2459
2460 Arguments:
2461   host                  point to initial host item
2462   ignore_target_hosts   a list of hosts to ignore
2463   whichrrs              flags indicating which RRs to look for:
2464                           HOST_FIND_BY_SRV  => look for SRV
2465                           HOST_FIND_BY_MX   => look for MX
2466                           HOST_FIND_BY_A    => look for A
2467                           HOST_FIND_BY_AAAA => look for AAAA
2468                         also flags indicating how the lookup is done
2469                           HOST_FIND_QUALIFY_SINGLE   ) passed to the
2470                           HOST_FIND_SEARCH_PARENTS   )   resolver
2471                           HOST_FIND_IPV4_FIRST => reverse usual result ordering
2472                           HOST_FIND_IPV4_ONLY  => MX results elide ipv6
2473   srv_service           when SRV used, the service name
2474   srv_fail_domains      DNS errors for these domains => assume nonexist
2475   mx_fail_domains       DNS errors for these domains => assume nonexist
2476   dnssec_d.request =>   make dnssec request: domainlist
2477   dnssec_d.require =>   ditto and nonexist failures
2478   fully_qualified_name  if not NULL, return fully-qualified name
2479   removed               set TRUE if local host was removed from the list
2480
2481 Returns:                HOST_FIND_FAILED  Failed to find the host or domain;
2482                                           if there was a syntax error,
2483                                           host_find_failed_syntax is set.
2484                         HOST_FIND_AGAIN   Could not resolve at this time
2485                         HOST_FIND_SECURITY dnsssec required but not acheived
2486                         HOST_FOUND        Host found
2487                         HOST_FOUND_LOCAL  The lowest MX record points to this
2488                                           machine, if MX records were found, or
2489                                           an A record that was found contains
2490                                           an address of the local host
2491 */
2492
2493 int
2494 host_find_bydns(host_item *host, const uschar *ignore_target_hosts, int whichrrs,
2495   uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2496   const dnssec_domains *dnssec_d,
2497   const uschar **fully_qualified_name, BOOL *removed)
2498 {
2499 host_item *h, *last;
2500 int rc = DNS_FAIL;
2501 int ind_type = 0;
2502 int yield;
2503 dns_answer * dnsa = store_get_dns_answer();
2504 dns_scan dnss;
2505 BOOL dnssec_require = dnssec_d
2506   && match_isinlist(host->name, CUSS &dnssec_d->require,
2507                   0, &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
2508 BOOL dnssec_request = dnssec_require
2509     || (  dnssec_d
2510        && match_isinlist(host->name, CUSS &dnssec_d->request,
2511                     0, &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK);
2512 dnssec_status_t dnssec;
2513
2514 /* Set the default fully qualified name to the incoming name, initialize the
2515 resolver if necessary, set up the relevant options, and initialize the flag
2516 that gets set for DNS syntax check errors. */
2517
2518 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2519 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2520          (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0,
2521          dnssec_request);
2522 f.host_find_failed_syntax = FALSE;
2523
2524 /* First, if requested, look for SRV records. The service name is given; we
2525 assume TCP protocol. DNS domain names are constrained to a maximum of 256
2526 characters, so the code below should be safe. */
2527
2528 if (whichrrs & HOST_FIND_BY_SRV)
2529   {
2530   gstring * g;
2531   uschar * temp_fully_qualified_name;
2532   int prefix_length;
2533
2534   g = string_fmt_append(NULL, "_%s._tcp.%n%.256s",
2535         srv_service, &prefix_length, host->name);
2536   temp_fully_qualified_name = string_from_gstring(g);
2537   ind_type = T_SRV;
2538
2539   /* Search for SRV records. If the fully qualified name is different to
2540   the input name, pass back the new original domain, without the prepended
2541   magic. */
2542
2543   dnssec = DS_UNK;
2544   lookup_dnssec_authenticated = NULL;
2545   rc = dns_lookup_timerwrap(dnsa, temp_fully_qualified_name, ind_type,
2546         CUSS &temp_fully_qualified_name);
2547
2548   DEBUG(D_dns)
2549     if ((dnssec_request || dnssec_require)
2550         && !dns_is_secure(dnsa)
2551         && dns_is_aa(dnsa))
2552       debug_printf("DNS lookup of %.256s (SRV) requested AD, but got AA\n", host->name);
2553
2554   if (dnssec_request)
2555     {
2556     if (dns_is_secure(dnsa))
2557       { dnssec = DS_YES; lookup_dnssec_authenticated = US"yes"; }
2558     else
2559       { dnssec = DS_NO; lookup_dnssec_authenticated = US"no"; }
2560     }
2561
2562   if (temp_fully_qualified_name != g->s && fully_qualified_name != NULL)
2563     *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2564
2565   /* On DNS failures, we give the "try again" error unless the domain is
2566   listed as one for which we continue. */
2567
2568   if (rc == DNS_SUCCEED && dnssec_require && !dns_is_secure(dnsa))
2569     {
2570     log_write(L_host_lookup_failed, LOG_MAIN,
2571                 "dnssec fail on SRV for %.256s", host->name);
2572     rc = DNS_FAIL;
2573     }
2574   if (rc == DNS_FAIL || rc == DNS_AGAIN)
2575     {
2576 #ifndef STAND_ALONE
2577     if (match_isinlist(host->name, CUSS &srv_fail_domains, 0,
2578         &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
2579 #endif
2580       { yield = HOST_FIND_AGAIN; goto out; }
2581     DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2582       "(domain in srv_fail_domains)\n", rc == DNS_FAIL ? "FAIL":"AGAIN");
2583     }
2584   }
2585
2586 /* If we did not find any SRV records, search the DNS for MX records, if
2587 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2588 domain, and there's no point in going on to look for address records with the
2589 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2590 records. On DNS failures, we give the "try again" error unless the domain is
2591 listed as one for which we continue. */
2592
2593 if (rc != DNS_SUCCEED  &&  whichrrs & HOST_FIND_BY_MX)
2594   {
2595   ind_type = T_MX;
2596   dnssec = DS_UNK;
2597   lookup_dnssec_authenticated = NULL;
2598   rc = dns_lookup_timerwrap(dnsa, host->name, ind_type, fully_qualified_name);
2599
2600   DEBUG(D_dns)
2601     if (  (dnssec_request || dnssec_require)
2602        && !dns_is_secure(dnsa)
2603        && dns_is_aa(dnsa))
2604       debug_printf("DNS lookup of %.256s (MX) requested AD, but got AA\n", host->name);
2605
2606   if (dnssec_request)
2607     if (dns_is_secure(dnsa))
2608       {
2609       DEBUG(D_host_lookup) debug_printf("%s (MX resp) DNSSEC\n", host->name);
2610       dnssec = DS_YES; lookup_dnssec_authenticated = US"yes";
2611       }
2612     else
2613       {
2614       dnssec = DS_NO; lookup_dnssec_authenticated = US"no";
2615       }
2616
2617   switch (rc)
2618     {
2619     case DNS_NOMATCH:
2620       yield = HOST_FIND_FAILED; goto out;
2621
2622     case DNS_SUCCEED:
2623       if (!dnssec_require || dns_is_secure(dnsa))
2624         break;
2625       DEBUG(D_host_lookup)
2626         debug_printf("dnssec fail on MX for %.256s", host->name);
2627 #ifndef STAND_ALONE
2628       if (match_isinlist(host->name, CUSS &mx_fail_domains, 0,
2629           &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
2630         { yield = HOST_FIND_SECURITY; goto out; }
2631 #endif
2632       rc = DNS_FAIL;
2633       /*FALLTHROUGH*/
2634
2635     case DNS_FAIL:
2636     case DNS_AGAIN:
2637 #ifndef STAND_ALONE
2638       if (match_isinlist(host->name, CUSS &mx_fail_domains, 0,
2639           &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
2640 #endif
2641         { yield = HOST_FIND_AGAIN; goto out; }
2642       DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2643         "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2644       break;
2645     }
2646   }
2647
2648 /* If we haven't found anything yet, and we are requested to do so, try for an
2649 A or AAAA record. If we find it (or them) check to see that it isn't the local
2650 host. */
2651
2652 if (rc != DNS_SUCCEED)
2653   {
2654   if (!(whichrrs & (HOST_FIND_BY_A | HOST_FIND_BY_AAAA)))
2655     {
2656     DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2657     yield = HOST_FIND_FAILED;
2658     goto out;
2659     }
2660
2661   last = host;        /* End of local chainlet */
2662   host->mx = MX_NONE;
2663   host->port = PORT_NONE;
2664   host->dnssec = DS_UNK;
2665   lookup_dnssec_authenticated = NULL;
2666   rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2667     fully_qualified_name, dnssec_request, dnssec_require, whichrrs);
2668
2669   /* If one or more address records have been found, check that none of them
2670   are local. Since we know the host items all have their IP addresses
2671   inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2672   HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2673   because set_address_from_dns() removes them. */
2674
2675   if (rc == HOST_FOUND)
2676     rc = host_scan_for_local_hosts(host, &last, removed);
2677   else
2678     if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED;  /* No special action */
2679
2680   DEBUG(D_host_lookup)
2681     if (host->address)
2682       {
2683       if (fully_qualified_name)
2684         debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2685       for (host_item * h = host; h != last->next; h = h->next)
2686         debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2687           h->address ? h->address : US"<null>", h->mx, h->sort_key,
2688           h->status >= hstatus_unusable ? US"*" : US"");
2689       }
2690
2691   yield = rc;
2692   goto out;
2693   }
2694
2695 /* We have found one or more MX or SRV records. Sort them according to
2696 precedence. Put the data for the first one into the existing host block, and
2697 insert new host_item blocks into the chain for the remainder. For equal
2698 precedences one is supposed to randomize the order. To make this happen, the
2699 sorting is actually done on the MX value * 1000 + a random number. This is put
2700 into a host field called sort_key.
2701
2702 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2703 IPv6 address in preference. At this stage, we don't know what kind of address
2704 the host has. We choose a random number < 500; if later we find an A record
2705 first, we add 500 to the random number. Then for any other address records, we
2706 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2707 records.
2708
2709 At this point we remove any duplicates that point to the same host, retaining
2710 only the one with the lowest precedence. We cannot yet check for precedence
2711 greater than that of the local host, because that test cannot be properly done
2712 until the addresses have been found - an MX record may point to a name for this
2713 host which is not the primary hostname. */
2714
2715 last = NULL;    /* Indicates that not even the first item is filled yet */
2716
2717 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2718      rr;
2719      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == ind_type)
2720   {
2721   int precedence, weight;
2722   int port = PORT_NONE;
2723   const uschar * s = rr->data;  /* MUST be unsigned for GETSHORT */
2724   uschar data[256];
2725
2726   GETSHORT(precedence, s);      /* Pointer s is advanced */
2727
2728   /* For MX records, we use a random "weight" which causes multiple records of
2729   the same precedence to sort randomly. */
2730
2731   if (ind_type == T_MX)
2732     weight = random_number(500);
2733   else
2734     {
2735     /* SRV records are specified with a port and a weight. The weight is used
2736     in a special algorithm. However, to start with, we just use it to order the
2737     records of equal priority (precedence). */
2738     GETSHORT(weight, s);
2739     GETSHORT(port, s);
2740     }
2741
2742   /* Get the name of the host pointed to. */
2743
2744   (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, s,
2745     (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2746
2747   /* Check that we haven't already got this host on the chain; if we have,
2748   keep only the lower precedence. This situation shouldn't occur, but you
2749   never know what junk might get into the DNS (and this case has been seen on
2750   more than one occasion). */
2751
2752   if (last)       /* This is not the first record */
2753     {
2754     host_item *prev = NULL;
2755
2756     for (h = host; h != last->next; prev = h, h = h->next)
2757       if (strcmpic(h->name, data) == 0)
2758         {
2759         DEBUG(D_host_lookup)
2760           debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2761             precedence > h->mx ? precedence : h->mx);
2762         if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2763         if (h == host)                            /* Override first item */
2764           {
2765           h->mx = precedence;
2766           host->sort_key = precedence * 1000 + weight;
2767           goto NEXT_MX_RR;
2768           }
2769
2770         /* Unwanted host item is not the first in the chain, so we can get
2771         get rid of it by cutting it out. */
2772
2773         prev->next = h->next;
2774         if (h == last) last = prev;
2775         break;
2776         }
2777     }
2778
2779   /* If this is the first MX or SRV record, put the data into the existing host
2780   block. Otherwise, add a new block in the correct place; if it has to be
2781   before the first block, copy the first block's data to a new second block. */
2782
2783   if (!last)
2784     {
2785     host->name = string_copy_dnsdomain(data);
2786     host->address = NULL;
2787     host->port = port;
2788     host->mx = precedence;
2789     host->sort_key = precedence * 1000 + weight;
2790     host->status = hstatus_unknown;
2791     host->why = hwhy_unknown;
2792     host->dnssec = dnssec;
2793     last = host;
2794     }
2795   else
2796
2797   /* Make a new host item and seek the correct insertion place */
2798     {
2799     int sort_key = precedence * 1000 + weight;
2800     host_item * next = store_get(sizeof(host_item), GET_UNTAINTED);
2801     next->name = string_copy_dnsdomain(data);
2802     next->address = NULL;
2803     next->port = port;
2804     next->mx = precedence;
2805     next->sort_key = sort_key;
2806     next->status = hstatus_unknown;
2807     next->why = hwhy_unknown;
2808     next->dnssec = dnssec;
2809     next->last_try = 0;
2810
2811     /* Handle the case when we have to insert before the first item. */
2812
2813     if (sort_key < host->sort_key)
2814       {
2815       host_item htemp;
2816       htemp = *host;
2817       *host = *next;
2818       *next = htemp;
2819       host->next = next;
2820       if (last == host) last = next;
2821       }
2822     else
2823
2824     /* Else scan down the items we have inserted as part of this exercise;
2825     don't go further. */
2826       {
2827       for (h = host; h != last; h = h->next)
2828         if (sort_key < h->next->sort_key)
2829           {
2830           next->next = h->next;
2831           h->next = next;
2832           break;
2833           }
2834
2835       /* Join on after the last host item that's part of this
2836       processing if we haven't stopped sooner. */
2837
2838       if (h == last)
2839         {
2840         next->next = last->next;
2841         last->next = next;
2842         last = next;
2843         }
2844       }
2845     }
2846
2847   NEXT_MX_RR: continue;
2848   }
2849
2850 if (!last)      /* No rr of correct type; give up */
2851   {
2852   yield = HOST_FIND_FAILED;
2853   goto out;
2854   }
2855
2856 /* If the list of hosts was obtained from SRV records, there are two things to
2857 do. First, if there is only one host, and it's name is ".", it means there is
2858 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2859 priority according to their weights, using an algorithm that is defined in RFC
2860 2782. The hosts are currently sorted by priority and weight. For each priority
2861 group we have to pick off one host and put it first, and then repeat for any
2862 remaining in the same priority group. */
2863
2864 if (ind_type == T_SRV)
2865   {
2866   host_item ** pptr;
2867
2868   if (host == last && host->name[0] == 0)
2869     {
2870     DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2871     yield = HOST_FIND_FAILED;
2872     goto out;
2873     }
2874
2875   DEBUG(D_host_lookup)
2876     {
2877     debug_printf("original ordering of hosts from SRV records:\n");
2878     for (h = host; h != last->next; h = h->next)
2879       debug_printf("  %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2880     }
2881
2882   for (pptr = &host, h = host; h != last; pptr = &h->next, h = h->next)
2883     {
2884     int sum = 0;
2885     host_item *hh;
2886
2887     /* Find the last following host that has the same precedence. At the same
2888     time, compute the sum of the weights and the running totals. These can be
2889     stored in the sort_key field. */
2890
2891     for (hh = h; hh != last; hh = hh->next)
2892       {
2893       int weight = hh->sort_key % 1000;   /* was precedence * 1000 + weight */
2894       sum += weight;
2895       hh->sort_key = sum;
2896       if (hh->mx != hh->next->mx) break;
2897       }
2898
2899     /* If there's more than one host at this precedence (priority), we need to
2900     pick one to go first. */
2901
2902     if (hh != h)
2903       {
2904       host_item *hhh;
2905       host_item **ppptr;
2906       int randomizer = random_number(sum + 1);
2907
2908       for (ppptr = pptr, hhh = h;
2909            hhh != hh;
2910            ppptr = &hhh->next, hhh = hhh->next)
2911         if (hhh->sort_key >= randomizer)
2912           break;
2913
2914       /* hhh now points to the host that should go first; ppptr points to the
2915       place that points to it. Unfortunately, if the start of the minilist is
2916       the start of the entire list, we can't just swap the items over, because
2917       we must not change the value of host, since it is passed in from outside.
2918       One day, this could perhaps be changed.
2919
2920       The special case is fudged by putting the new item *second* in the chain,
2921       and then transferring the data between the first and second items. We
2922       can't just swap the first and the chosen item, because that would mean
2923       that an item with zero weight might no longer be first. */
2924
2925       if (hhh != h)
2926         {
2927         *ppptr = hhh->next;          /* Cuts it out of the chain */
2928
2929         if (h == host)
2930           {
2931           host_item temp = *h;
2932           *h = *hhh;
2933           *hhh = temp;
2934           hhh->next = temp.next;
2935           h->next = hhh;
2936           }
2937         else
2938           {
2939           hhh->next = h;               /* The rest of the chain follows it */
2940           *pptr = hhh;                 /* It takes the place of h */
2941           h = hhh;                     /* It's now the start of this minilist */
2942           }
2943         }
2944       }
2945
2946     /* A host has been chosen to be first at this priority and h now points
2947     to this host. There may be others at the same priority, or others at a
2948     different priority. Before we leave this host, we need to put back a sort
2949     key of the traditional MX kind, in case this host is multihomed, because
2950     the sort key is used for ordering the multiple IP addresses. We do not need
2951     to ensure that these new sort keys actually reflect the order of the hosts,
2952     however. */
2953
2954     h->sort_key = h->mx * 1000 + random_number(500);
2955     }   /* Move on to the next host */
2956   }
2957
2958 /* Now we have to find IP addresses for all the hosts. We have ensured above
2959 that the names in all the host items are unique. Before release 4.61 we used to
2960 process records from the additional section in the DNS packet that returned the
2961 MX or SRV records. However, a DNS name server is free to drop any resource
2962 records from the additional section. In theory, this has always been a
2963 potential problem, but it is exacerbated by the advent of IPv6. If a host had
2964 several IPv4 addresses and some were not in the additional section, at least
2965 Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
2966 and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
2967 connection, and never try an IPv4 address. When there was only IPv4
2968 connectivity, this was a disaster that did in practice occur.
2969
2970 So, from release 4.61 onwards, we always search for A and AAAA records
2971 explicitly. The names shouldn't point to CNAMES, but we use the general lookup
2972 function that handles them, just in case. If any lookup gives a soft error,
2973 change the default yield.
2974
2975 For these DNS lookups, we must disable qualify_single and search_parents;
2976 otherwise invalid host names obtained from MX or SRV records can cause trouble
2977 if they happen to match something local. */
2978
2979 yield = HOST_FIND_FAILED;    /* Default yield */
2980 dns_init(FALSE, FALSE,       /* Disable qualify_single and search_parents */
2981          dnssec_request || dnssec_require);
2982
2983 for (h = host; h != last->next; h = h->next)
2984   {
2985   if (h->address) continue;  /* Inserted by a multihomed host */
2986
2987   rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip,
2988     NULL, dnssec_request, dnssec_require,
2989     whichrrs & HOST_FIND_IPV4_ONLY
2990     ?  HOST_FIND_BY_A  :  HOST_FIND_BY_A | HOST_FIND_BY_AAAA);
2991   if (rc != HOST_FOUND)
2992     {
2993     h->status = hstatus_unusable;
2994     switch (rc)
2995       {
2996       case HOST_FIND_AGAIN:     yield = rc; h->why = hwhy_deferred; break;
2997       case HOST_FIND_SECURITY:  yield = rc; h->why = hwhy_insecure; break;
2998       case HOST_IGNORED:        h->why = hwhy_ignored; break;
2999       default:                  h->why = hwhy_failed; break;
3000       }
3001     }
3002   }
3003
3004 /* Scan the list for any hosts that are marked unusable because they have
3005 been explicitly ignored, and remove them from the list, as if they did not
3006 exist. If we end up with just a single, ignored host, flatten its fields as if
3007 nothing was found. */
3008
3009 if (ignore_target_hosts)
3010   {
3011   host_item *prev = NULL;
3012   for (h = host; h != last->next; h = h->next)
3013     {
3014     REDO:
3015     if (h->why != hwhy_ignored)        /* Non ignored host, just continue */
3016       prev = h;
3017     else if (prev == NULL)             /* First host is ignored */
3018       {
3019       if (h != last)                   /* First is not last */
3020         {
3021         if (h->next == last) last = h; /* Overwrite it with next */
3022         *h = *(h->next);               /* and reprocess it. */
3023         goto REDO;                     /* C should have redo, like Perl */
3024         }
3025       }
3026     else                               /* Ignored host is not first - */
3027       {                                /*   cut it out */
3028       prev->next = h->next;
3029       if (h == last) last = prev;
3030       }
3031     }
3032
3033   if (host->why == hwhy_ignored) host->address = NULL;
3034   }
3035
3036 /* There is still one complication in the case of IPv6. Although the code above
3037 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3038 hosts, it doesn't do this for addresses that apply to different hosts with the
3039 same MX precedence, because the sorting on MX precedence happens first. So we
3040 have to make another pass to check for this case. We ensure that, within a
3041 single MX preference value, IPv6 addresses come first. This can separate the
3042 addresses of a multihomed host, but that should not matter. */
3043
3044 #if HAVE_IPV6
3045 if (h != last && !disable_ipv6) for (h = host; h != last; h = h->next)
3046   {
3047   host_item temp;
3048   host_item *next = h->next;
3049
3050   if (  h->mx != next->mx                       /* If next is different MX */
3051      || !h->address                             /* OR this one is unset */
3052      )
3053     continue;                                   /* move on to next */
3054
3055   if (  whichrrs & HOST_FIND_IPV4_FIRST
3056      ?     !Ustrchr(h->address, ':')            /* OR this one is IPv4 */
3057         || next->address
3058            && Ustrchr(next->address, ':')       /* OR next is IPv6 */
3059
3060      :     Ustrchr(h->address, ':')             /* OR this one is IPv6 */
3061         || next->address
3062            && !Ustrchr(next->address, ':')      /* OR next is IPv4 */
3063      )
3064     continue;                                /* move on to next */
3065
3066   temp = *h;                                 /* otherwise, swap */
3067   temp.next = next->next;
3068   *h = *next;
3069   h->next = next;
3070   *next = temp;
3071   }
3072 #endif
3073
3074 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3075 whose IP addresses are on the local host. If any are found, all hosts with the
3076 same or higher MX values are removed. However, if the local host has the lowest
3077 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3078 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3079 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3080 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3081 be HOST_FIND_FAILED. */
3082
3083 host_remove_duplicates(host, &last);
3084 rc = host_scan_for_local_hosts(host, &last, removed);
3085 if (rc != HOST_FIND_FAILED) yield = rc;
3086
3087 DEBUG(D_host_lookup)
3088   {
3089   if (fully_qualified_name)
3090     debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3091   debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3092     yield == HOST_FOUND         ? "HOST_FOUND" :
3093     yield == HOST_FOUND_LOCAL   ? "HOST_FOUND_LOCAL" :
3094     yield == HOST_FIND_SECURITY ? "HOST_FIND_SECURITY" :
3095     yield == HOST_FIND_AGAIN    ? "HOST_FIND_AGAIN" :
3096     yield == HOST_FIND_FAILED   ? "HOST_FIND_FAILED" : "?",
3097     yield);
3098   for (h = host; h != last->next; h = h->next)
3099     {
3100     debug_printf("  %s %s MX=%d %s", h->name,
3101       !h->address ? US"<null>" : h->address, h->mx,
3102       h->dnssec == DS_YES ? US"DNSSEC " : US"");
3103     if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3104     if (h->status >= hstatus_unusable) debug_printf("*");
3105     debug_printf("\n");
3106     }
3107   }
3108
3109 out:
3110
3111 dns_init(FALSE, FALSE, FALSE);  /* clear the dnssec bit for getaddrbyname */
3112 store_free_dns_answer(dnsa);
3113 return yield;
3114 }
3115
3116
3117
3118
3119 #ifdef SUPPORT_DANE
3120 /* Lookup TLSA record for host/port.
3121 Return:  OK             success with dnssec; DANE mode
3122          DEFER          Do not use this host now, may retry later
3123          FAIL_FORCED    No TLSA record; DANE not usable
3124          FAIL           Do not use this connection
3125 */
3126
3127 int
3128 tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
3129 {
3130 uschar buffer[300];
3131 const uschar * fullname = buffer;
3132 int rc;
3133 BOOL sec;
3134
3135 /* TLSA lookup string */
3136 (void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
3137
3138 rc = dns_lookup_timerwrap(dnsa, buffer, T_TLSA, &fullname);
3139 sec = dns_is_secure(dnsa);
3140 DEBUG(D_transport)
3141   debug_printf("TLSA lookup ret %s %sDNSSEC\n", dns_rc_names[rc], sec ? "" : "not ");
3142
3143 switch (rc)
3144   {
3145   case DNS_AGAIN:
3146     return DEFER; /* just defer this TLS'd conn */
3147
3148   case DNS_SUCCEED:
3149     if (sec)
3150       {
3151       DEBUG(D_transport)
3152         {
3153         dns_scan dnss;
3154         for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3155              rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
3156           if (rr->type == T_TLSA && rr->size > 3)
3157             {
3158             uint16_t payload_length = rr->size - 3;
3159             uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
3160
3161             sp += sprintf(CS sp, "%d ", *p++); /* usage */
3162             sp += sprintf(CS sp, "%d ", *p++); /* selector */
3163             sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
3164             while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
3165               sp += sprintf(CS sp, "%02x", *p++);
3166
3167             debug_printf(" %s\n", s);
3168             }
3169         }
3170       return OK;
3171       }
3172     log_write(0, LOG_MAIN,
3173       "DANE error: TLSA lookup for %s not DNSSEC", host->name);
3174     /*FALLTRHOUGH*/
3175
3176   case DNS_NODATA:      /* no TLSA RR for this lookup */
3177   case DNS_NOMATCH:     /* no records at all for this lookup */
3178     return dane_required ? FAIL : FAIL_FORCED;
3179
3180   default:
3181   case DNS_FAIL:
3182     return dane_required ? FAIL : DEFER;
3183   }
3184 }
3185 #endif  /*SUPPORT_DANE*/
3186
3187
3188
3189 /*************************************************
3190 **************************************************
3191 *             Stand-alone test program           *
3192 **************************************************
3193 *************************************************/
3194
3195 #ifdef STAND_ALONE
3196
3197 int main(int argc, char **cargv)
3198 {
3199 host_item h;
3200 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3201 BOOL byname = FALSE;
3202 BOOL qualify_single = TRUE;
3203 BOOL search_parents = FALSE;
3204 BOOL request_dnssec = FALSE;
3205 BOOL require_dnssec = FALSE;
3206 uschar **argv = USS cargv;
3207 uschar buffer[256];
3208
3209 disable_ipv6 = FALSE;
3210 primary_hostname = US"";
3211 store_init();
3212 store_pool = POOL_MAIN;
3213 debug_selector = D_host_lookup|D_interface;
3214 debug_file = stdout;
3215 debug_fd = fileno(debug_file);
3216
3217 printf("Exim stand-alone host functions test\n");
3218
3219 host_find_interfaces();
3220 debug_selector = D_host_lookup | D_dns;
3221
3222 if (argc > 1) primary_hostname = argv[1];
3223
3224 /* So that debug level changes can be done first */
3225
3226 dns_init(qualify_single, search_parents, FALSE);
3227
3228 printf("Testing host lookup\n");
3229 printf("> ");
3230 while (Ufgets(buffer, 256, stdin) != NULL)
3231   {
3232   int rc;
3233   int len = Ustrlen(buffer);
3234   uschar *fully_qualified_name;
3235
3236   while (len > 0 && isspace(buffer[len-1])) len--;
3237   buffer[len] = 0;
3238
3239   if (Ustrcmp(buffer, "q") == 0) break;
3240
3241   if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3242   else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3243   else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3244   else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3245   else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3246   else if (Ustrcmp(buffer, "srv+a") == 0)
3247     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3248   else if (Ustrcmp(buffer, "srv+mx") == 0)
3249     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3250   else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3251     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3252   else if (Ustrcmp(buffer, "qualify_single")    == 0) qualify_single = TRUE;
3253   else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3254   else if (Ustrcmp(buffer, "search_parents")    == 0) search_parents = TRUE;
3255   else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3256   else if (Ustrcmp(buffer, "request_dnssec")    == 0) request_dnssec = TRUE;
3257   else if (Ustrcmp(buffer, "no_request_dnssec") == 0) request_dnssec = FALSE;
3258   else if (Ustrcmp(buffer, "require_dnssec")    == 0) require_dnssec = TRUE;
3259   else if (Ustrcmp(buffer, "no_require_dnssec") == 0) require_dnssec = FALSE;
3260   else if (Ustrcmp(buffer, "test_harness") == 0)
3261     f.running_in_test_harness = !f.running_in_test_harness;
3262   else if (Ustrcmp(buffer, "ipv6") == 0) disable_ipv6 = !disable_ipv6;
3263   else if (Ustrcmp(buffer, "res_debug") == 0)
3264     {
3265     _res.options ^= RES_DEBUG;
3266     }
3267   else if (Ustrncmp(buffer, "retrans", 7) == 0)
3268     {
3269     (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3270     _res.retrans = dns_retrans;
3271     }
3272   else if (Ustrncmp(buffer, "retry", 5) == 0)
3273     {
3274     (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3275     _res.retry = dns_retry;
3276     }
3277   else
3278     {
3279     int flags = whichrrs;
3280     dnssec_domains d;
3281
3282     h.name = buffer;
3283     h.next = NULL;
3284     h.mx = MX_NONE;
3285     h.port = PORT_NONE;
3286     h.status = hstatus_unknown;
3287     h.why = hwhy_unknown;
3288     h.address = NULL;
3289
3290     if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3291     if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3292
3293     d.request = request_dnssec ? &h.name : NULL;
3294     d.require = require_dnssec ? &h.name : NULL;
3295
3296     rc = byname
3297       ? host_find_byname(&h, NULL, flags, &fully_qualified_name, TRUE)
3298       : host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3299                         &d, &fully_qualified_name, NULL);
3300
3301     switch (rc)
3302       {
3303       case HOST_FIND_FAILED:    printf("Failed\n");     break;
3304       case HOST_FIND_AGAIN:     printf("Again\n");      break;
3305       case HOST_FIND_SECURITY:  printf("Security\n");   break;
3306       case HOST_FOUND_LOCAL:    printf("Local\n");      break;
3307       }
3308     }
3309
3310   printf("\n> ");
3311   }
3312
3313 printf("Testing host_aton\n");
3314 printf("> ");
3315 while (Ufgets(buffer, 256, stdin) != NULL)
3316   {
3317   int x[4];
3318   int len = Ustrlen(buffer);
3319
3320   while (len > 0 && isspace(buffer[len-1])) len--;
3321   buffer[len] = 0;
3322
3323   if (Ustrcmp(buffer, "q") == 0) break;
3324
3325   len = host_aton(buffer, x);
3326   printf("length = %d ", len);
3327   for (int i = 0; i < len; i++)
3328     {
3329     printf("%04x ", (x[i] >> 16) & 0xffff);
3330     printf("%04x ", x[i] & 0xffff);
3331     }
3332   printf("\n> ");
3333   }
3334
3335 printf("\n");
3336
3337 printf("Testing host_name_lookup\n");
3338 printf("> ");
3339 while (Ufgets(buffer, 256, stdin) != NULL)
3340   {
3341   int len = Ustrlen(buffer);
3342   while (len > 0 && isspace(buffer[len-1])) len--;
3343   buffer[len] = 0;
3344   if (Ustrcmp(buffer, "q") == 0) break;
3345   sender_host_address = buffer;
3346   sender_host_name = NULL;
3347   sender_host_aliases = NULL;
3348   host_lookup_msg = US"";
3349   host_lookup_failed = FALSE;
3350   if (host_name_lookup() == FAIL)  /* Debug causes printing */
3351     printf("Lookup failed:%s\n", host_lookup_msg);
3352   printf("\n> ");
3353   }
3354
3355 printf("\n");
3356
3357 return 0;
3358 }
3359 #endif  /* STAND_ALONE */
3360
3361 /* vi: aw ai sw=2
3362 */
3363 /* End of host.c */