src/src/host.c

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