src/src/host.c

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