src/src/host.c

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