src/src/host.c

   1 /* $Cambridge: exim/src/src/host.c,v 1.21 2006/02/07 16:36:25 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2006 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 /* Functions for 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 ipv;
 778   int port = host_address_extract_port(s);            /* Leaves just the IP address */
 779   if ((ipv = string_is_ip_address(s, NULL)) == 0)
 780     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
 781       s, name);
 782
 783   /* Skip IPv6 addresses if IPv6 is disabled. */
 784
 785   if (disable_ipv6 && ipv == 6) continue;
 786
 787   /* This use of strcpy() is OK because we have checked that s is a valid IP
 788   address above. The field in the ip_address_item is large enough to hold an
 789   IPv6 address. */
 790
 791   next = store_get(sizeof(ip_address_item));
 792   next->next = NULL;
 793   Ustrcpy(next->address, s);
 794   next->port = port;
 795   next->v6_include_v4 = FALSE;
 796
 797   if (yield == NULL) yield = last = next; else
 798     {
 799     last->next = next;
 800     last = next;
 801     }
 802   }
 803
 804 return yield;
 805 }
 806
 807
 808
 809
 810
 811 /*************************************************
 812 *         Find addresses on local interfaces     *
 813 *************************************************/
 814
 815 /* This function finds the addresses of local IP interfaces. These are used
 816 when testing for routing to the local host. As the function may be called more
 817 than once, the list is preserved in permanent store, pointed to by a static
 818 variable, to save doing the work more than once per process.
 819
 820 The generic list of interfaces is obtained by calling host_build_ifacelist()
 821 for local_interfaces and extra_local_interfaces. This list scanned to remove
 822 duplicates (which may exist with different ports - not relevant here). If
 823 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
 824 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
 825 obtained from os_find_running_interfaces().
 826
 827 Arguments:    none
 828 Returns:      a chain of ip_address_items, each containing to a textual
 829               version of an IP address; the port numbers are not relevant
 830 */
 831
 832
 833 /* First, a local subfunction to add an interface to a list in permanent store,
 834 but only if there isn't a previous copy of that address on the list. */
 835
 836 static ip_address_item *
 837 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
 838 {
 839 ip_address_item *ipa2;
 840 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
 841   if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
 842 ipa2 = store_get_perm(sizeof(ip_address_item));
 843 *ipa2 = *ipa;
 844 ipa2->next = list;
 845 return ipa2;
 846 }
 847
 848
 849 /* This is the globally visible function */
 850
 851 ip_address_item *
 852 host_find_interfaces(void)
 853 {
 854 ip_address_item *running_interfaces = NULL;
 855
 856 if (local_interface_data == NULL)
 857   {
 858   void *reset_item = store_get(0);
 859   ip_address_item *dlist = host_build_ifacelist(local_interfaces,
 860     US"local_interfaces");
 861   ip_address_item *xlist = host_build_ifacelist(extra_local_interfaces,
 862     US"extra_local_interfaces");
 863   ip_address_item *ipa;
 864
 865   if (dlist == NULL) dlist = xlist; else
 866     {
 867     for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
 868     ipa->next = xlist;
 869     }
 870
 871   for (ipa = dlist; ipa != NULL; ipa = ipa->next)
 872     {
 873     if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
 874         Ustrcmp(ipa->address, "::0") == 0)
 875       {
 876       ip_address_item *ipa2;
 877       BOOL ipv6 = ipa->address[0] == ':';
 878       if (running_interfaces == NULL)
 879         running_interfaces = os_find_running_interfaces();
 880       for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
 881         {
 882         if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
 883           local_interface_data = add_unique_interface(local_interface_data,
 884           ipa2);
 885         }
 886       }
 887     else
 888       {
 889       local_interface_data = add_unique_interface(local_interface_data, ipa);
 890       DEBUG(D_interface)
 891         {
 892         debug_printf("Configured local interface: address=%s", ipa->address);
 893         if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
 894         debug_printf("\n");
 895         }
 896       }
 897     }
 898   store_reset(reset_item);
 899   }
 900
 901 return local_interface_data;
 902 }
 903
 904
 905
 906
 907
 908 /*************************************************
 909 *        Convert network IP address to text      *
 910 *************************************************/
 911
 912 /* Given an IPv4 or IPv6 address in binary, convert it to a text
 913 string and return the result in a piece of new store. The address can
 914 either be given directly, or passed over in a sockaddr structure. Note
 915 that this isn't the converse of host_aton() because of byte ordering
 916 differences. See host_nmtoa() below.
 917
 918 Arguments:
 919   type       if < 0 then arg points to a sockaddr, else
 920              either AF_INET or AF_INET6
 921   arg        points to a sockaddr if type is < 0, or
 922              points to an IPv4 address (32 bits), or
 923              points to an IPv6 address (128 bits),
 924              in both cases, in network byte order
 925   buffer     if NULL, the result is returned in gotten store;
 926              else points to a buffer to hold the answer
 927   portptr    points to where to put the port number, if non NULL; only
 928              used when type < 0
 929
 930 Returns:     pointer to character string
 931 */
 932
 933 uschar *
 934 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
 935 {
 936 uschar *yield;
 937
 938 /* The new world. It is annoying that we have to fish out the address from
 939 different places in the block, depending on what kind of address it is. It
 940 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
 941 function inet_ntoa() returns just uschar *, and some picky compilers insist
 942 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
 943
 944 #if HAVE_IPV6
 945 uschar addr_buffer[46];
 946 if (type < 0)
 947   {
 948   int family = ((struct sockaddr *)arg)->sa_family;
 949   if (family == AF_INET6)
 950     {
 951     struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
 952     yield = (uschar *)inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
 953       sizeof(addr_buffer));
 954     if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
 955     }
 956   else
 957     {
 958     struct sockaddr_in *sk = (struct sockaddr_in *)arg;
 959     yield = (uschar *)inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
 960       sizeof(addr_buffer));
 961     if (portptr != NULL) *portptr = ntohs(sk->sin_port);
 962     }
 963   }
 964 else
 965   {
 966   yield = (uschar *)inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
 967   }
 968
 969 /* If the result is a mapped IPv4 address, show it in V4 format. */
 970
 971 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
 972
 973 #else  /* HAVE_IPV6 */
 974
 975 /* The old world */
 976
 977 if (type < 0)
 978   {
 979   yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
 980   if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
 981   }
 982 else
 983   yield = US inet_ntoa(*((struct in_addr *)arg));
 984 #endif
 985
 986 /* If there is no buffer, put the string into some new store. */
 987
 988 if (buffer == NULL) return string_copy(yield);
 989
 990 /* Callers of this function with a non-NULL buffer must ensure that it is
 991 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
 992 makes this use of strcpy() OK. */
 993
 994 Ustrcpy(buffer, yield);
 995 return buffer;
 996 }
 997
 998
 999
1000
1001 /*************************************************
1002 *         Convert address text to binary         *
1003 *************************************************/
1004
1005 /* Given the textual form of an IP address, convert it to binary in an
1006 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
1007 The result has the first byte in the most significant byte of the first int. In
1008 other words, the result is not in network byte order, but in host byte order.
1009 As a result, this is not the converse of host_ntoa(), which expects network
1010 byte order. See host_nmtoa() below.
1011
1012 Arguments:
1013   address    points to the textual address, checked for syntax
1014   bin        points to an array of 4 ints
1015
1016 Returns:     the number of ints used
1017 */
1018
1019 int
1020 host_aton(uschar *address, int *bin)
1021 {
1022 int x[4];
1023 int v4offset = 0;
1024
1025 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
1026 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
1027 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
1028 supported. */
1029
1030 if (Ustrchr(address, ':') != NULL)
1031   {
1032   uschar *p = address;
1033   uschar *component[8];
1034   BOOL ipv4_ends = FALSE;
1035   int ci = 0;
1036   int nulloffset = 0;
1037   int v6count = 8;
1038   int i;
1039
1040   /* If the address starts with a colon, it will start with two colons.
1041   Just lose the first one, which will leave a null first component. */
1042
1043   if (*p == ':') p++;
1044
1045   /* Split the address into components separated by colons. The input address
1046   is supposed to be checked for syntax. There was a case where this was
1047   overlooked; to guard against that happening again, check here and crash if
1048   there are too many components. */
1049
1050   while (*p != 0 && *p != '%')
1051     {
1052     int len = Ustrcspn(p, ":%");
1053     if (len == 0) nulloffset = ci;
1054     if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1055       "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
1056       address);
1057     component[ci++] = p;
1058     p += len;
1059     if (*p == ':') p++;
1060     }
1061
1062   /* If the final component contains a dot, it is a trailing v4 address.
1063   As the syntax is known to be checked, just set up for a trailing
1064   v4 address and restrict the v6 part to 6 components. */
1065
1066   if (Ustrchr(component[ci-1], '.') != NULL)
1067     {
1068     address = component[--ci];
1069     ipv4_ends = TRUE;
1070     v4offset = 3;
1071     v6count = 6;
1072     }
1073
1074   /* If there are fewer than 6 or 8 components, we have to insert some
1075   more empty ones in the middle. */
1076
1077   if (ci < v6count)
1078     {
1079     int insert_count = v6count - ci;
1080     for (i = v6count-1; i > nulloffset + insert_count; i--)
1081       component[i] = component[i - insert_count];
1082     while (i > nulloffset) component[i--] = US"";
1083     }
1084
1085   /* Now turn the components into binary in pairs and bung them
1086   into the vector of ints. */
1087
1088   for (i = 0; i < v6count; i += 2)
1089     bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1090       Ustrtol(component[i+1], NULL, 16);
1091
1092   /* If there was no terminating v4 component, we are done. */
1093
1094   if (!ipv4_ends) return 4;
1095   }
1096
1097 /* Handle IPv4 address */
1098
1099 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
1100 bin[v4offset] = (x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
1101 return v4offset+1;
1102 }
1103
1104
1105 /*************************************************
1106 *           Apply mask to an IP address          *
1107 *************************************************/
1108
1109 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1110 first int, etc.
1111
1112 Arguments:
1113   count        the number of ints
1114   binary       points to the ints to be masked
1115   mask         the count of ms bits to leave, or -1 if no masking
1116
1117 Returns:       nothing
1118 */
1119
1120 void
1121 host_mask(int count, int *binary, int mask)
1122 {
1123 int i;
1124 if (mask < 0) mask = 99999;
1125 for (i = 0; i < count; i++)
1126   {
1127   int wordmask;
1128   if (mask == 0) wordmask = 0;
1129   else if (mask < 32)
1130     {
1131     wordmask = (-1) << (32 - mask);
1132     mask = 0;
1133     }
1134   else
1135     {
1136     wordmask = -1;
1137     mask -= 32;
1138     }
1139   binary[i] &= wordmask;
1140   }
1141 }
1142
1143
1144
1145
1146 /*************************************************
1147 *     Convert masked IP address in ints to text  *
1148 *************************************************/
1149
1150 /* We can't use host_ntoa() because it assumes the binary values are in network
1151 byte order, and these are the result of host_aton(), which puts them in ints in
1152 host byte order. Also, we really want IPv6 addresses to be in a canonical
1153 format, so we output them with no abbreviation. In a number of cases we can't
1154 use the normal colon separator in them because it terminates keys in lsearch
1155 files, so we want to use dot instead. There's an argument that specifies what
1156 to use for IPv6 addresses.
1157
1158 Arguments:
1159   count       1 or 4 (number of ints)
1160   binary      points to the ints
1161   mask        mask value; if < 0 don't add to result
1162   buffer      big enough to hold the result
1163   sep         component separator character for IPv6 addresses
1164
1165 Returns:      the number of characters placed in buffer, not counting
1166               the final nul.
1167 */
1168
1169 int
1170 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1171 {
1172 int i, j;
1173 uschar *tt = buffer;
1174
1175 if (count == 1)
1176   {
1177   j = binary[0];
1178   for (i = 24; i >= 0; i -= 8)
1179     {
1180     sprintf(CS tt, "%d.", (j >> i) & 255);
1181     while (*tt) tt++;
1182     }
1183   }
1184 else
1185   {
1186   for (i = 0; i < 4; i++)
1187     {
1188     j = binary[i];
1189     sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1190     while (*tt) tt++;
1191     }
1192   }
1193
1194 tt--;   /* lose final separator */
1195
1196 if (mask < 0)
1197   *tt = 0;
1198 else
1199   {
1200   sprintf(CS tt, "/%d", mask);
1201   while (*tt) tt++;
1202   }
1203
1204 return tt - buffer;
1205 }
1206
1207
1208
1209 /*************************************************
1210 *        Check port for tls_on_connect           *
1211 *************************************************/
1212
1213 /* This function checks whether a given incoming port is configured for tls-
1214 on-connect. It is called from the daemon and from inetd handling. If the global
1215 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1216 check the tls_on_connect_ports option for a list of ports.
1217
1218 Argument:  a port number
1219 Returns:   TRUE or FALSE
1220 */
1221
1222 BOOL
1223 host_is_tls_on_connect_port(int port)
1224 {
1225 int sep = 0;
1226 uschar buffer[32];
1227 uschar *list = tls_on_connect_ports;
1228 uschar *s;
1229
1230 if (tls_on_connect) return TRUE;
1231
1232 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1233   {
1234   uschar *end;
1235   int lport = Ustrtol(s, &end, 10);
1236   if (*end != 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "tls_on_connect_ports "
1237     "contains \"%s\", which is not a port number: exim abandoned", s);
1238   if (lport == port) return TRUE;
1239   }
1240
1241 return FALSE;
1242 }
1243
1244
1245
1246 /*************************************************
1247 *        Check whether host is in a network      *
1248 *************************************************/
1249
1250 /* This function checks whether a given IP address matches a pattern that
1251 represents either a single host, or a network (using CIDR notation). The caller
1252 of this function must check the syntax of the arguments before calling it.
1253
1254 Arguments:
1255   host        string representation of the ip-address to check
1256   net         string representation of the network, with optional CIDR mask
1257   maskoffset  offset to the / that introduces the mask in the key
1258               zero if there is no mask
1259
1260 Returns:
1261   TRUE   the host is inside the network
1262   FALSE  the host is NOT inside the network
1263 */
1264
1265 BOOL
1266 host_is_in_net(uschar *host, uschar *net, int maskoffset)
1267 {
1268 int i;
1269 int address[4];
1270 int incoming[4];
1271 int mlen;
1272 int size = host_aton(net, address);
1273 int insize;
1274
1275 /* No mask => all bits to be checked */
1276
1277 if (maskoffset == 0) mlen = 99999;    /* Big number */
1278   else mlen = Uatoi(net + maskoffset + 1);
1279
1280 /* Convert the incoming address to binary. */
1281
1282 insize = host_aton(host, incoming);
1283
1284 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1285    connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1286    ::ffff:<v4address>, to IPv4 format. */
1287
1288 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1289     incoming[2] == 0xffff)
1290   {
1291   insize = 1;
1292   incoming[0] = incoming[3];
1293   }
1294
1295 /* No match if the sizes don't agree. */
1296
1297 if (insize != size) return FALSE;
1298
1299 /* Else do the masked comparison. */
1300
1301 for (i = 0; i < size; i++)
1302   {
1303   int mask;
1304   if (mlen == 0) mask = 0;
1305   else if (mlen < 32)
1306     {
1307     mask = (-1) << (32 - mlen);
1308     mlen = 0;
1309     }
1310   else
1311     {
1312     mask = -1;
1313     mlen -= 32;
1314     }
1315   if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1316   }
1317
1318 return TRUE;
1319 }
1320
1321
1322
1323 /*************************************************
1324 *       Scan host list for local hosts           *
1325 *************************************************/
1326
1327 /* Scan through a chain of addresses and check whether any of them is the
1328 address of an interface on the local machine. If so, remove that address and
1329 any previous ones with the same MX value, and all subsequent ones (which will
1330 have greater or equal MX values) from the chain. Note: marking them as unusable
1331 is NOT the right thing to do because it causes the hosts not to be used for
1332 other domains, for which they may well be correct.
1333
1334 The hosts may be part of a longer chain; we only process those between the
1335 initial pointer and the "last" pointer.
1336
1337 There is also a list of "pseudo-local" host names which are checked against the
1338 host names. Any match causes that host item to be treated the same as one which
1339 matches a local IP address.
1340
1341 If the very first host is a local host, then all MX records had a precedence
1342 greater than or equal to that of the local host. Either there's a problem in
1343 the DNS, or an apparently remote name turned out to be an abbreviation for the
1344 local host. Give a specific return code, and let the caller decide what to do.
1345 Otherwise, give a success code if at least one host address has been found.
1346
1347 Arguments:
1348   host        pointer to the first host in the chain
1349   lastptr     pointer to pointer to the last host in the chain (may be updated)
1350   removed     if not NULL, set TRUE if some local addresses were removed
1351                 from the list
1352
1353 Returns:
1354   HOST_FOUND       if there is at least one host with an IP address on the chain
1355                      and an MX value less than any MX value associated with the
1356                      local host
1357   HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1358                      the host addresses were obtained from A records or
1359                      gethostbyname(), the MX values are set to -1.
1360   HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1361 */
1362
1363 int
1364 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1365 {
1366 int yield = HOST_FIND_FAILED;
1367 host_item *last = *lastptr;
1368 host_item *prev = NULL;
1369 host_item *h;
1370
1371 if (removed != NULL) *removed = FALSE;
1372
1373 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1374
1375 for (h = host; h != last->next; h = h->next)
1376   {
1377   #ifndef STAND_ALONE
1378   if (hosts_treat_as_local != NULL)
1379     {
1380     int rc;
1381     uschar *save = deliver_domain;
1382     deliver_domain = h->name;   /* set $domain */
1383     rc = match_isinlist(string_copylc(h->name), &hosts_treat_as_local, 0,
1384       &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1385     deliver_domain = save;
1386     if (rc == OK) goto FOUND_LOCAL;
1387     }
1388   #endif
1389
1390   /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1391   for 127.0.0.1 and refers to the local host. We therefore force it always to
1392   be treated as local. */
1393
1394   if (h->address != NULL)
1395     {
1396     ip_address_item *ip;
1397     if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1398     for (ip = local_interface_data; ip != NULL; ip = ip->next)
1399       if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1400     yield = HOST_FOUND;  /* At least one remote address has been found */
1401     }
1402
1403   /* Update prev to point to the last host item before any that have
1404   the same MX value as the one we have just considered. */
1405
1406   if (h->next == NULL || h->next->mx != h->mx) prev = h;
1407   }
1408
1409 return yield;  /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1410
1411 /* A host whose IP address matches a local IP address, or whose name matches
1412 something in hosts_treat_as_local has been found. */
1413
1414 FOUND_LOCAL:
1415
1416 if (prev == NULL)
1417   {
1418   HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1419     "local host has lowest MX\n" :
1420     "local host found for non-MX address\n");
1421   return HOST_FOUND_LOCAL;
1422   }
1423
1424 HDEBUG(D_host_lookup)
1425   {
1426   debug_printf("local host in host list - removed hosts:\n");
1427   for (h = prev->next; h != last->next; h = h->next)
1428     debug_printf("  %s %s %d\n", h->name, h->address, h->mx);
1429   }
1430
1431 if (removed != NULL) *removed = TRUE;
1432 prev->next = last->next;
1433 *lastptr = prev;
1434 return yield;
1435 }
1436
1437
1438
1439
1440 /*************************************************
1441 *        Remove duplicate IPs in host list       *
1442 *************************************************/
1443
1444 /* You would think that administrators could set up their DNS records so that
1445 one ended up with a list of unique IP addresses after looking up A or MX
1446 records, but apparently duplication is common. So we scan such lists and
1447 remove the later duplicates. Note that we may get lists in which some host
1448 addresses are not set.
1449
1450 Arguments:
1451   host        pointer to the first host in the chain
1452   lastptr     pointer to pointer to the last host in the chain (may be updated)
1453
1454 Returns:      nothing
1455 */
1456
1457 static void
1458 host_remove_duplicates(host_item *host, host_item **lastptr)
1459 {
1460 while (host != *lastptr)
1461   {
1462   if (host->address != NULL)
1463     {
1464     host_item *h = host;
1465     while (h != *lastptr)
1466       {
1467       if (h->next->address != NULL &&
1468           Ustrcmp(h->next->address, host->address) == 0)
1469         {
1470         DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1471           "removed\n", host->address, h->next->mx);
1472         if (h->next == *lastptr) *lastptr = h;
1473         h->next = h->next->next;
1474         }
1475       else h = h->next;
1476       }
1477     }
1478   /* If the last item was removed, host may have become == *lastptr */
1479   if (host != *lastptr) host = host->next;
1480   }
1481 }
1482
1483
1484
1485
1486 /*************************************************
1487 *    Find sender host name by gethostbyaddr()    *
1488 *************************************************/
1489
1490 /* This used to be the only way it was done, but it turns out that not all
1491 systems give aliases for calls to gethostbyaddr() - or one of the modern
1492 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1493 but they can still exist. This function is now used only when a DNS lookup of
1494 the IP address fails, in order to give access to /etc/hosts.
1495
1496 Arguments:   none
1497 Returns:     OK, DEFER, FAIL
1498 */
1499
1500 static int
1501 host_name_lookup_byaddr(void)
1502 {
1503 int len;
1504 uschar *s, *t;
1505 struct hostent *hosts;
1506 struct in_addr addr;
1507
1508 /* Lookup on IPv6 system */
1509
1510 #if HAVE_IPV6
1511 if (Ustrchr(sender_host_address, ':') != NULL)
1512   {
1513   struct in6_addr addr6;
1514   if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1515     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1516       "IPv6 address", sender_host_address);
1517   #if HAVE_GETIPNODEBYADDR
1518   hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1519   #else
1520   hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1521   #endif
1522   }
1523 else
1524   {
1525   if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1526     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1527       "IPv4 address", sender_host_address);
1528   #if HAVE_GETIPNODEBYADDR
1529   hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1530   #else
1531   hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1532   #endif
1533   }
1534
1535 /* Do lookup on IPv4 system */
1536
1537 #else
1538 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1539 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1540 #endif
1541
1542 /* Failed to look up the host. */
1543
1544 if (hosts == NULL)
1545   {
1546   HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1547     h_errno);
1548   return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1549   }
1550
1551 /* It seems there are some records in the DNS that yield an empty name. We
1552 treat this as non-existent. In some operating systems, this is returned as an
1553 empty string; in others as a single dot. */
1554
1555 if (hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1556   {
1557   HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1558     "treated as non-existent host name\n");
1559   return FAIL;
1560   }
1561
1562 /* Copy and lowercase the name, which is in static storage in many systems.
1563 Put it in permanent memory. */
1564
1565 s = (uschar *)hosts->h_name;
1566 len = Ustrlen(s) + 1;
1567 t = sender_host_name = store_get_perm(len);
1568 while (*s != 0) *t++ = tolower(*s++);
1569 *t = 0;
1570
1571 /* If the host has aliases, build a copy of the alias list */
1572
1573 if (hosts->h_aliases != NULL)
1574   {
1575   int count = 1;
1576   uschar **aliases, **ptr;
1577   for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1578   ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1579   for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1580     {
1581     uschar *s = *aliases;
1582     int len = Ustrlen(s) + 1;
1583     uschar *t = *ptr++ = store_get_perm(len);
1584     while (*s != 0) *t++ = tolower(*s++);
1585     *t = 0;
1586     }
1587   *ptr = NULL;
1588   }
1589
1590 return OK;
1591 }
1592
1593
1594
1595 /*************************************************
1596 *        Find host name for incoming call        *
1597 *************************************************/
1598
1599 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1600 up a list of alias names, pointed to by sender_host_alias. The list is
1601 NULL-terminated. The incoming address is in sender_host_address, either in
1602 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1603
1604 This function does a thorough check that the names it finds point back to the
1605 incoming IP address. Any that do not are discarded. Note that this is relied on
1606 by the ACL reverse_host_lookup check.
1607
1608 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1609 this it not universally true. Also, for release 4.30, this function was changed
1610 to do a direct DNS lookup first, by default[1], because it turns out that that
1611 is the only guaranteed way to find all the aliases on some systems. My
1612 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1613 Linux does not.
1614
1615 [1] The actual order is controlled by the host_lookup_order option.
1616
1617 Arguments:    none
1618 Returns:      OK on success, the answer being placed in the global variable
1619                 sender_host_name, with any aliases in a list hung off
1620                 sender_host_aliases
1621               FAIL if no host name can be found
1622               DEFER if a temporary error was encountered
1623
1624 The variable host_lookup_msg is set to an empty string on sucess, or to a
1625 reason for the failure otherwise, in a form suitable for tagging onto an error
1626 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1627 was a defer, host_lookup_deferred is set TRUE.
1628
1629 Any dynamically constructed string for host_lookup_msg must be in permanent
1630 store, because it might be used for several incoming messages on the same SMTP
1631 connection. */
1632
1633 int
1634 host_name_lookup(void)
1635 {
1636 int old_pool, rc;
1637 int sep = 0;
1638 uschar *hname, *save_hostname;
1639 uschar **aliases;
1640 uschar buffer[256];
1641 uschar *ordername;
1642 uschar *list = host_lookup_order;
1643 dns_record *rr;
1644 dns_answer dnsa;
1645 dns_scan dnss;
1646
1647 host_lookup_deferred = host_lookup_failed = FALSE;
1648
1649 HDEBUG(D_host_lookup)
1650   debug_printf("looking up host name for %s\n", sender_host_address);
1651
1652 /* For testing the case when a lookup does not complete, we have a special
1653 reserved IP address. */
1654
1655 if (running_in_test_harness &&
1656     Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1657   {
1658   HDEBUG(D_host_lookup)
1659     debug_printf("Test harness: host name lookup returns DEFER\n");
1660   host_lookup_deferred = TRUE;
1661   return DEFER;
1662   }
1663
1664 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1665 the order specified by the host_lookup_order option. */
1666
1667 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1668         != NULL)
1669   {
1670   if (strcmpic(ordername, US"bydns") == 0)
1671     {
1672     dns_init(FALSE, FALSE);
1673     dns_build_reverse(sender_host_address, buffer);
1674     rc = dns_lookup(&dnsa, buffer, T_PTR, NULL);
1675
1676     /* The first record we come across is used for the name; others are
1677     considered to be aliases. We have to scan twice, in order to find out the
1678     number of aliases. However, if all the names are empty, we will behave as
1679     if failure. (PTR records that yield empty names have been encountered in
1680     the DNS.) */
1681
1682     if (rc == DNS_SUCCEED)
1683       {
1684       uschar **aptr = NULL;
1685       int ssize = 264;
1686       int count = 0;
1687       int old_pool = store_pool;
1688
1689       store_pool = POOL_PERM;        /* Save names in permanent storage */
1690
1691       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1692            rr != NULL;
1693            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1694         {
1695         if (rr->type == T_PTR) count++;
1696         }
1697
1698       /* Get store for the list of aliases. For compatibility with
1699       gethostbyaddr, we make an empty list if there are none. */
1700
1701       aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1702
1703       /* Re-scan and extract the names */
1704
1705       for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1706            rr != NULL;
1707            rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1708         {
1709         uschar *s = NULL;
1710         if (rr->type != T_PTR) continue;
1711         s = store_get(ssize);
1712
1713         /* If an overlong response was received, the data will have been
1714         truncated and dn_expand may fail. */
1715
1716         if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1717              (uschar *)(rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1718           {
1719           log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1720             sender_host_address);
1721           break;
1722           }
1723
1724         store_reset(s + Ustrlen(s) + 1);
1725         if (s[0] == 0)
1726           {
1727           HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1728             "empty name: treated as non-existent host name\n");
1729           continue;
1730           }
1731         if (sender_host_name == NULL) sender_host_name = s;
1732           else *aptr++ = s;
1733         while (*s != 0) { *s = tolower(*s); s++; }
1734         }
1735
1736       *aptr = NULL;            /* End of alias list */
1737       store_pool = old_pool;   /* Reset store pool */
1738
1739       /* If we've found a names, break out of the "order" loop */
1740
1741       if (sender_host_name != NULL) break;
1742       }
1743
1744     /* If the DNS lookup deferred, we must also defer. */
1745
1746     if (rc == DNS_AGAIN)
1747       {
1748       HDEBUG(D_host_lookup)
1749         debug_printf("IP address PTR lookup gave temporary error\n");
1750       host_lookup_deferred = TRUE;
1751       return DEFER;
1752       }
1753     }
1754
1755   /* Do a lookup using gethostbyaddr() - or equivalent */
1756
1757   else if (strcmpic(ordername, US"byaddr") == 0)
1758     {
1759     HDEBUG(D_host_lookup)
1760       debug_printf("IP address lookup using gethostbyaddr()\n");
1761     rc = host_name_lookup_byaddr();
1762     if (rc == DEFER)
1763       {
1764       host_lookup_deferred = TRUE;
1765       return rc;                       /* Can't carry on */
1766       }
1767     if (rc == OK) break;               /* Found a name */
1768     }
1769   }      /* Loop for bydns/byaddr scanning */
1770
1771 /* If we have failed to find a name, return FAIL and log when required.
1772 NB host_lookup_msg must be in permanent store.  */
1773
1774 if (sender_host_name == NULL)
1775   {
1776   if (host_checking || !log_testing_mode)
1777     log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1778       "address %s", sender_host_address);
1779   host_lookup_msg = US" (failed to find host name from IP address)";
1780   host_lookup_failed = TRUE;
1781   return FAIL;
1782   }
1783
1784 /* We have a host name. If we are running in the test harness, we want the host
1785 name and its alias to appear always the same way round. There are only ever two
1786 names in these tests. If one of them contains "alias", make sure it is second;
1787 otherwise put them in alphabetical order. */
1788
1789 if (running_in_test_harness && *sender_host_aliases != NULL &&
1790     (
1791     Ustrstr(sender_host_name, "alias") != NULL ||
1792       (
1793       Ustrstr(*sender_host_aliases, "alias") == NULL &&
1794       Ustrcmp(sender_host_name, *sender_host_aliases) > 0
1795       )
1796     ))
1797   {
1798   uschar *temp = sender_host_name;
1799   sender_host_name = *sender_host_aliases;
1800   *sender_host_aliases = temp;
1801   }
1802
1803 /* Debug output what was found, after test harness swapping, for consistency */
1804
1805 HDEBUG(D_host_lookup)
1806   {
1807   uschar **aliases = sender_host_aliases;
1808   debug_printf("IP address lookup yielded %s\n", sender_host_name);
1809   while (*aliases != NULL) debug_printf("  alias %s\n", *aliases++);
1810   }
1811
1812 /* We need to verify that a forward lookup on the name we found does indeed
1813 correspond to the address. This is for security: in principle a malefactor who
1814 happened to own a reverse zone could set it to point to any names at all.
1815
1816 This code was present in versions of Exim before 3.20. At that point I took it
1817 out because I thought that gethostbyaddr() did the check anyway. It turns out
1818 that this isn't always the case, so it's coming back in at 4.01. This version
1819 is actually better, because it also checks aliases.
1820
1821 The code was made more robust at release 4.21. Prior to that, it accepted all
1822 the names if any of them had the correct IP address. Now the code checks all
1823 the names, and accepts only those that have the correct IP address. */
1824
1825 save_hostname = sender_host_name;   /* Save for error messages */
1826 aliases = sender_host_aliases;
1827 for (hname = sender_host_name; hname != NULL; hname = *aliases++)
1828   {
1829   int rc;
1830   BOOL ok = FALSE;
1831   host_item h;
1832   h.next = NULL;
1833   h.name = hname;
1834   h.mx = MX_NONE;
1835   h.address = NULL;
1836
1837   /* When called with the 5th argument FALSE, host_find_byname() won't return
1838   HOST_FOUND_LOCAL. If the incoming address is an IPv4 address expressed in
1839   IPv6 format, we must compare the IPv4 part to any IPv4 addresses. */
1840
1841   if ((rc = host_find_byname(&h, NULL, NULL, FALSE)) == HOST_FOUND)
1842     {
1843     host_item *hh;
1844     HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1845     for (hh = &h; hh != NULL; hh = hh->next)
1846       {
1847       if (host_is_in_net(hh->address, sender_host_address, 0))
1848         {
1849         HDEBUG(D_host_lookup) debug_printf("  %s OK\n", hh->address);
1850         ok = TRUE;
1851         break;
1852         }
1853       else
1854         {
1855         HDEBUG(D_host_lookup) debug_printf("  %s\n", hh->address);
1856         }
1857       }
1858     if (!ok) HDEBUG(D_host_lookup)
1859       debug_printf("no IP address for %s matched %s\n", hname,
1860         sender_host_address);
1861     }
1862   else if (rc == HOST_FIND_AGAIN)
1863     {
1864     HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1865     host_lookup_deferred = TRUE;
1866     return DEFER;
1867     }
1868   else
1869     {
1870     HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1871     }
1872
1873   /* If this name is no good, and it's the sender name, set it null pro tem;
1874   if it's an alias, just remove it from the list. */
1875
1876   if (!ok)
1877     {
1878     if (hname == sender_host_name) sender_host_name = NULL; else
1879       {
1880       uschar **a;                              /* Don't amalgamate - some */
1881       a = --aliases;                           /* compilers grumble */
1882       while (*a != NULL) { *a = a[1]; a++; }
1883       }
1884     }
1885   }
1886
1887 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1888 it with the first alias, if there is one. */
1889
1890 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1891   sender_host_name = *sender_host_aliases++;
1892
1893 /* If we now have a main name, all is well. */
1894
1895 if (sender_host_name != NULL) return OK;
1896
1897 /* We have failed to find an address that matches. */
1898
1899 HDEBUG(D_host_lookup)
1900   debug_printf("%s does not match any IP address for %s\n",
1901     sender_host_address, save_hostname);
1902
1903 /* This message must be in permanent store */
1904
1905 old_pool = store_pool;
1906 store_pool = POOL_PERM;
1907 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1908   sender_host_address, save_hostname);
1909 store_pool = old_pool;
1910 host_lookup_failed = TRUE;
1911 return FAIL;
1912 }
1913
1914
1915
1916
1917 /*************************************************
1918 *    Find IP address(es) for host by name        *
1919 *************************************************/
1920
1921 /* The input is a host_item structure with the name filled in and the address
1922 field set to NULL. We use gethostbyname(). Of course, gethostbyname() may use
1923 the DNS, but it doesn't do MX processing. If more than one address is given,
1924 chain on additional host items, with other relevant fields copied.
1925
1926 The second argument provides a host list (usually an IP list) of hosts to
1927 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1928 addresses in unreasonable places.
1929
1930 The lookup may result in a change of name. For compatibility with the dns
1931 lookup, return this via fully_qualified_name as well as updating the host item.
1932 The lookup may also yield more than one IP address, in which case chain on
1933 subsequent host_item structures.
1934
1935 Arguments:
1936   host                   a host item with the name and MX filled in;
1937                            the address is to be filled in;
1938                            multiple IP addresses cause other host items to be
1939                              chained on.
1940   ignore_target_hosts    a list of hosts to ignore
1941   fully_qualified_name   if not NULL, set to point to host name for
1942                          compatibility with host_find_bydns
1943   local_host_check       TRUE if a check for the local host is wanted
1944
1945 Returns:                 HOST_FIND_FAILED  Failed to find the host or domain
1946                          HOST_FIND_AGAIN   Try again later
1947                          HOST_FOUND        Host found - data filled in
1948                          HOST_FOUND_LOCAL  Host found and is the local host
1949 */
1950
1951 int
1952 host_find_byname(host_item *host, uschar *ignore_target_hosts,
1953   uschar **fully_qualified_name, BOOL local_host_check)
1954 {
1955 int i, yield, times;
1956 uschar **addrlist;
1957 host_item *last = NULL;
1958 BOOL temp_error = FALSE;
1959 #if HAVE_IPV6
1960 int af;
1961 #endif
1962
1963 /* If we are in the test harness, a name ending in .test.again.dns always
1964 forces a temporary error response. */
1965
1966 if (running_in_test_harness)
1967   {
1968   uschar *endname = host->name + Ustrlen(host->name);
1969   if (Ustrcmp(endname - 14, "test.again.dns") == 0)
1970     return HOST_FIND_AGAIN;
1971   }
1972
1973 /* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
1974 kinds of address, so go round the loop twice. Note that we have ensured that
1975 AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
1976 code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
1977 lookups here (except when testing standalone). */
1978
1979 #if HAVE_IPV6
1980   #ifndef STAND_ALONE
1981   if (disable_ipv6 || (dns_ipv4_lookup != NULL &&
1982         match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
1983           TRUE, NULL) == OK))
1984     { af = AF_INET; times = 1; }
1985   else
1986   #endif  /* STAND_ALONE */
1987
1988     { af = AF_INET6; times = 2; }
1989
1990 /* No IPv6 support */
1991
1992 #else   /* HAVE_IPV6 */
1993   times = 1;
1994 #endif  /* HAVE_IPV6 */
1995
1996 /* Initialize the flag that gets set for DNS syntax check errors, so that the
1997 interface to this function can be similar to host_find_bydns. */
1998
1999 host_find_failed_syntax = FALSE;
2000
2001 /* Loop to look up both kinds of address in an IPv6 world */
2002
2003 for (i = 1; i <= times;
2004      #if HAVE_IPV6
2005        af = AF_INET,     /* If 2 passes, IPv4 on the second */
2006      #endif
2007      i++)
2008   {
2009   BOOL ipv4_addr;
2010   int error_num;
2011   struct hostent *hostdata;
2012
2013   #if HAVE_IPV6
2014   if (running_in_test_harness)
2015     hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2016   else
2017     {
2018     #if HAVE_GETIPNODEBYNAME
2019     hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2020     #else
2021     hostdata = gethostbyname2(CS host->name, af);
2022     error_num = h_errno;
2023     #endif
2024     }
2025
2026   #else    /* not HAVE_IPV6 */
2027   if (running_in_test_harness)
2028     hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2029   else
2030     {
2031     hostdata = gethostbyname(CS host->name);
2032     error_num = h_errno;
2033     }
2034   #endif   /* HAVE_IPV6 */
2035
2036   if (hostdata == NULL)
2037     {
2038     uschar *error;
2039     switch (error_num)
2040       {
2041       case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
2042       case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2043       case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2044       case NO_DATA: error = US"NO_DATA"; break;
2045       #if NO_DATA != NO_ADDRESS
2046       case NO_ADDRESS: error = US"NO_ADDRESS"; break;
2047       #endif
2048       default: error = US"?"; break;
2049       }
2050
2051     DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2052       #if HAVE_IPV6
2053         #if HAVE_GETIPNODEBYNAME
2054         (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2055         #else
2056         (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2057         #endif
2058       #else
2059       "gethostbyname",
2060       #endif
2061       error_num, error);
2062
2063     if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2064     continue;
2065     }
2066   if ((hostdata->h_addr_list)[0] == NULL) continue;
2067
2068   /* Replace the name with the fully qualified one if necessary, and fill in
2069   the fully_qualified_name pointer. */
2070
2071   if (hostdata->h_name[0] != 0 &&
2072       Ustrcmp(host->name, hostdata->h_name) != 0)
2073     host->name = string_copy_dnsdomain((uschar *)hostdata->h_name);
2074   if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2075
2076   /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2077   by their different lengths. Scan the list, ignoring any that are to be
2078   ignored, and build a chain from the rest. */
2079
2080   ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2081
2082   for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2083     {
2084     uschar *text_address =
2085       host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2086
2087     #ifndef STAND_ALONE
2088     if (ignore_target_hosts != NULL &&
2089         verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2090           text_address, NULL) == OK)
2091       {
2092       DEBUG(D_host_lookup)
2093         debug_printf("ignored host %s [%s]\n", host->name, text_address);
2094       continue;
2095       }
2096     #endif
2097
2098     /* If this is the first address, last == NULL and we put the data in the
2099     original block. */
2100
2101     if (last == NULL)
2102       {
2103       host->address = text_address;
2104       host->port = PORT_NONE;
2105       host->status = hstatus_unknown;
2106       host->why = hwhy_unknown;
2107       last = host;
2108       }
2109
2110     /* Else add further host item blocks for any other addresses, keeping
2111     the order. */
2112
2113     else
2114       {
2115       host_item *next = store_get(sizeof(host_item));
2116       next->name = host->name;
2117       next->mx = host->mx;
2118       next->address = text_address;
2119       next->port = PORT_NONE;
2120       next->status = hstatus_unknown;
2121       next->why = hwhy_unknown;
2122       next->last_try = 0;
2123       next->next = last->next;
2124       last->next = next;
2125       last = next;
2126       }
2127     }
2128   }
2129
2130 /* If no hosts were found, the address field in the original host block will be
2131 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2132 so we pass that back. */
2133
2134 if (host->address == NULL)
2135   {
2136   uschar *msg =
2137     #ifndef STAND_ALONE
2138     (message_id[0] == 0 && smtp_in != NULL)?
2139       string_sprintf("no IP address found for host %s (during %s)", host->name,
2140           smtp_get_connection_info()) :
2141     #endif
2142     string_sprintf("no IP address found for host %s", host->name);
2143
2144   HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2145   if (temp_error) return HOST_FIND_AGAIN;
2146   if (host_checking || !log_testing_mode)
2147     log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2148   return HOST_FIND_FAILED;
2149   }
2150
2151 /* Remove any duplicate IP addresses, then check to see if this is the local
2152 host if required. */
2153
2154 host_remove_duplicates(host, &last);
2155 yield = local_host_check?
2156   host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2157
2158 /* When running in the test harness, sort into the order of addresses so as to
2159 get repeatability. */
2160
2161 if (running_in_test_harness) sort_addresses(host, last);
2162
2163 HDEBUG(D_host_lookup)
2164   {
2165   host_item *h;
2166   if (fully_qualified_name != NULL)
2167     debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2168   debug_printf("%s looked up these IP addresses:\n",
2169     #if HAVE_IPV6
2170       #if HAVE_GETIPNODEBYNAME
2171       "getipnodebyname"
2172       #else
2173       "gethostbyname2"
2174       #endif
2175     #else
2176     "gethostbyname"
2177     #endif
2178     );
2179   for (h = host; h != last->next; h = h->next)
2180     debug_printf("  name=%s address=%s\n", h->name,
2181       (h->address == NULL)? US"<null>" : h->address);
2182   }
2183
2184 /* Return the found status. */
2185
2186 return yield;
2187 }
2188
2189
2190
2191 /*************************************************
2192 *        Fill in a host address from the DNS     *
2193 *************************************************/
2194
2195 /* Given a host item, with its name, port and mx fields set, and its address
2196 field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
2197 create additional host items for the additional addresses, copying all the
2198 other fields, and randomizing the order.
2199
2200 On IPv6 systems, A6 records are sought first (but only if support for A6 is
2201 configured - they may never become mainstream), then AAAA records are sought,
2202 and finally A records are sought as well.
2203
2204 The host name may be changed if the DNS returns a different name - e.g. fully
2205 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2206 ensures that it points to the fully qualified name. However, this is the fully
2207 qualified version of the original name; if a CNAME is involved, the actual
2208 canonical host name may be different again, and so we get it directly from the
2209 relevant RR. Note that we do NOT change the mx field of the host item in this
2210 function as it may be called to set the addresses of hosts taken from MX
2211 records.
2212
2213 Arguments:
2214   host                  points to the host item we're filling in
2215   lastptr               points to pointer to last host item in a chain of
2216                           host items (may be updated if host is last and gets
2217                           extended because multihomed)
2218   ignore_target_hosts   list of hosts to ignore
2219   allow_ip              if TRUE, recognize an IP address and return it
2220   fully_qualified_name  if not NULL, return fully qualified name here if
2221                           the contents are different (i.e. it must be preset
2222                           to something)
2223
2224 Returns:       HOST_FIND_FAILED     couldn't find A record
2225                HOST_FIND_AGAIN      try again later
2226                HOST_FOUND           found AAAA and/or A record(s)
2227                HOST_IGNORED         found, but all IPs ignored
2228 */
2229
2230 static int
2231 set_address_from_dns(host_item *host, host_item **lastptr,
2232   uschar *ignore_target_hosts, BOOL allow_ip, uschar **fully_qualified_name)
2233 {
2234 dns_record *rr;
2235 host_item *thishostlast = NULL;    /* Indicates not yet filled in anything */
2236 BOOL v6_find_again = FALSE;
2237 int i;
2238
2239 /* If allow_ip is set, a name which is an IP address returns that value
2240 as its address. This is used for MX records when allow_mx_to_ip is set, for
2241 those sites that feel they have to flaunt the RFC rules. */
2242
2243 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2244   {
2245   #ifndef STAND_ALONE
2246   if (ignore_target_hosts != NULL &&
2247         verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2248         host->name, NULL) == OK)
2249     return HOST_IGNORED;
2250   #endif
2251
2252   host->address = host->name;
2253   return HOST_FOUND;
2254   }
2255
2256 /* On an IPv6 system, unless IPv6 is disabled, go round the loop up to three
2257 times, looking for A6 and AAAA records the first two times. However, unless
2258 doing standalone testing, we force an IPv4 lookup if the domain matches
2259 dns_ipv4_lookup is set. Since A6 records look like being abandoned, support
2260 them only if explicitly configured to do so. On an IPv4 system, go round the
2261 loop once only, looking only for A records. */
2262
2263 #if HAVE_IPV6
2264   #ifndef STAND_ALONE
2265     if (disable_ipv6 || (dns_ipv4_lookup != NULL &&
2266         match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2267         TRUE, NULL) == OK))
2268       i = 0;    /* look up A records only */
2269     else
2270   #endif        /* STAND_ALONE */
2271
2272   #ifdef SUPPORT_A6
2273   i = 2;        /* look up A6 and AAAA and A records */
2274   #else
2275   i = 1;        /* look up AAAA and A records */
2276   #endif        /* SUPPORT_A6 */
2277
2278 /* The IPv4 world */
2279
2280 #else           /* HAVE_IPV6 */
2281   i = 0;        /* look up A records only */
2282 #endif          /* HAVE_IPV6 */
2283
2284 for (; i >= 0; i--)
2285   {
2286   static int types[] = { T_A, T_AAAA, T_A6 };
2287   int type = types[i];
2288   int randoffset = (i == 0)? 500 : 0;  /* Ensures v6 sorts before v4 */
2289   dns_answer dnsa;
2290   dns_scan dnss;
2291
2292   int rc = dns_lookup(&dnsa, host->name, type, fully_qualified_name);
2293
2294   /* We want to return HOST_FIND_AGAIN if one of the A, A6, or AAAA lookups
2295   fails or times out, but not if another one succeeds. (In the early
2296   IPv6 days there are name servers that always fail on AAAA, but are happy
2297   to give out an A record. We want to proceed with that A record.) */
2298
2299   if (rc != DNS_SUCCEED)
2300     {
2301     if (i == 0)  /* Just tried for an A record, i.e. end of loop */
2302       {
2303       if (host->address != NULL) return HOST_FOUND;  /* A6 or AAAA was found */
2304       if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2305         return HOST_FIND_AGAIN;
2306       return HOST_FIND_FAILED;    /* DNS_NOMATCH or DNS_NODATA */
2307       }
2308
2309     /* Tried for an A6 or AAAA record: remember if this was a temporary
2310     error, and look for the next record type. */
2311
2312     if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2313     continue;
2314     }
2315
2316   /* Lookup succeeded: fill in the given host item with the first non-ignored
2317   address found; create additional items for any others. A single A6 record
2318   may generate more than one address. */
2319
2320   for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2321        rr != NULL;
2322        rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2323     {
2324     if (rr->type == type)
2325       {
2326       /* dns_address *da = dns_address_from_rr(&dnsa, rr); */
2327
2328       dns_address *da;
2329       da = dns_address_from_rr(&dnsa, rr);
2330
2331       DEBUG(D_host_lookup)
2332         {
2333         if (da == NULL)
2334           debug_printf("no addresses extracted from A6 RR for %s\n",
2335             host->name);
2336         }
2337
2338       /* This loop runs only once for A and AAAA records, but may run
2339       several times for an A6 record that generated multiple addresses. */
2340
2341       for (; da != NULL; da = da->next)
2342         {
2343         #ifndef STAND_ALONE
2344         if (ignore_target_hosts != NULL &&
2345               verify_check_this_host(&ignore_target_hosts, NULL,
2346                 host->name, da->address, NULL) == OK)
2347           {
2348           DEBUG(D_host_lookup)
2349             debug_printf("ignored host %s [%s]\n", host->name, da->address);
2350           continue;
2351           }
2352         #endif
2353
2354         /* If this is the first address, stick it in the given host block,
2355         and change the name if the returned RR has a different name. */
2356
2357         if (thishostlast == NULL)
2358           {
2359           if (strcmpic(host->name, rr->name) != 0)
2360             host->name = string_copy_dnsdomain(rr->name);
2361           host->address = da->address;
2362           host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2363           host->status = hstatus_unknown;
2364           host->why = hwhy_unknown;
2365           thishostlast = host;
2366           }
2367
2368         /* Not the first address. Check for, and ignore, duplicates. Then
2369         insert in the chain at a random point. */
2370
2371         else
2372           {
2373           int new_sort_key;
2374           host_item *next;
2375
2376           /* End of our local chain is specified by "thishostlast". */
2377
2378           for (next = host;; next = next->next)
2379             {
2380             if (Ustrcmp(CS da->address, next->address) == 0) break;
2381             if (next == thishostlast) { next = NULL; break; }
2382             }
2383           if (next != NULL) continue;  /* With loop for next address */
2384
2385           /* Not a duplicate */
2386
2387           new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2388           next = store_get(sizeof(host_item));
2389
2390           /* New address goes first: insert the new block after the first one
2391           (so as not to disturb the original pointer) but put the new address
2392           in the original block. */
2393
2394           if (new_sort_key < host->sort_key)
2395             {
2396             *next = *host;                                  /* Copies port */
2397             host->next = next;
2398             host->address = da->address;
2399             host->sort_key = new_sort_key;
2400             if (thishostlast == host) thishostlast = next;  /* Local last */
2401             if (*lastptr == host) *lastptr = next;          /* Global last */
2402             }
2403
2404           /* Otherwise scan down the addresses for this host to find the
2405           one to insert after. */
2406
2407           else
2408             {
2409             host_item *h = host;
2410             while (h != thishostlast)
2411               {
2412               if (new_sort_key < h->next->sort_key) break;
2413               h = h->next;
2414               }
2415             *next = *h;                                 /* Copies port */
2416             h->next = next;
2417             next->address = da->address;
2418             next->sort_key = new_sort_key;
2419             if (h == thishostlast) thishostlast = next; /* Local last */
2420             if (h == *lastptr) *lastptr = next;         /* Global last */
2421             }
2422           }
2423         }
2424       }
2425     }
2426   }
2427
2428 /* Control gets here only if the third lookup (the A record) succeeded.
2429 However, the address may not be filled in if it was ignored. */
2430
2431 return (host->address == NULL)? HOST_IGNORED : HOST_FOUND;
2432 }
2433
2434
2435
2436
2437 /*************************************************
2438 *    Find IP addresses and host names via DNS    *
2439 *************************************************/
2440
2441 /* The input is a host_item structure with the name field filled in and the
2442 address field set to NULL. This may be in a chain of other host items. The
2443 lookup may result in more than one IP address, in which case we must created
2444 new host blocks for the additional addresses, and insert them into the chain.
2445 The original name may not be fully qualified. Use the fully_qualified_name
2446 argument to return the official name, as returned by the resolver.
2447
2448 Arguments:
2449   host                  point to initial host item
2450   ignore_target_hosts   a list of hosts to ignore
2451   whichrrs              flags indicating which RRs to look for:
2452                           HOST_FIND_BY_SRV  => look for SRV
2453                           HOST_FIND_BY_MX   => look for MX
2454                           HOST_FIND_BY_A    => look for A or AAAA
2455                         also flags indicating how the lookup is done
2456                           HOST_FIND_QUALIFY_SINGLE   ) passed to the
2457                           HOST_FIND_SEARCH_PARENTS   )   resolver
2458   srv_service           when SRV used, the service name
2459   srv_fail_domains      DNS errors for these domains => assume nonexist
2460   mx_fail_domains       DNS errors for these domains => assume nonexist
2461   fully_qualified_name  if not NULL, return fully-qualified name
2462   removed               set TRUE if local host was removed from the list
2463
2464 Returns:                HOST_FIND_FAILED  Failed to find the host or domain;
2465                                           if there was a syntax error,
2466                                           host_find_failed_syntax is set.
2467                         HOST_FIND_AGAIN   Could not resolve at this time
2468                         HOST_FOUND        Host found
2469                         HOST_FOUND_LOCAL  The lowest MX record points to this
2470                                           machine, if MX records were found, or
2471                                           an A record that was found contains
2472                                           an address of the local host
2473 */
2474
2475 int
2476 host_find_bydns(host_item *host, uschar *ignore_target_hosts, int whichrrs,
2477   uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2478   uschar **fully_qualified_name, BOOL *removed)
2479 {
2480 host_item *h, *last;
2481 dns_record *rr;
2482 int rc = DNS_FAIL;
2483 int ind_type = 0;
2484 int yield;
2485 dns_answer dnsa;
2486 dns_scan dnss;
2487
2488 /* Set the default fully qualified name to the incoming name, initialize the
2489 resolver if necessary, set up the relevant options, and initialize the flag
2490 that gets set for DNS syntax check errors. */
2491
2492 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2493 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2494          (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0);
2495 host_find_failed_syntax = FALSE;
2496
2497 /* First, if requested, look for SRV records. The service name is given; we
2498 assume TCP progocol. DNS domain names are constrained to a maximum of 256
2499 characters, so the code below should be safe. */
2500
2501 if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2502   {
2503   uschar buffer[300];
2504   uschar *temp_fully_qualified_name = buffer;
2505   int prefix_length;
2506
2507   (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2508     host->name);
2509   ind_type = T_SRV;
2510
2511   /* Search for SRV records. If the fully qualified name is different to
2512   the input name, pass back the new original domain, without the prepended
2513   magic. */
2514
2515   rc = dns_lookup(&dnsa, buffer, ind_type, &temp_fully_qualified_name);
2516   if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2517     *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2518
2519   /* On DNS failures, we give the "try again" error unless the domain is
2520   listed as one for which we continue. */
2521
2522   if (rc == DNS_FAIL || rc == DNS_AGAIN)
2523     {
2524     #ifndef STAND_ALONE
2525     if (match_isinlist(host->name, &srv_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2526         TRUE, NULL) != OK)
2527     #endif
2528       return HOST_FIND_AGAIN;
2529     DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2530       "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2531     }
2532   }
2533
2534 /* If we did not find any SRV records, search the DNS for MX records, if
2535 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2536 domain, and there's no point in going on to look for address records with the
2537 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2538 records. On DNS failures, we give the "try again" error unless the domain is
2539 listed as one for which we continue. */
2540
2541 if (rc != DNS_SUCCEED && (whichrrs & HOST_FIND_BY_MX) != 0)
2542   {
2543   ind_type = T_MX;
2544   rc = dns_lookup(&dnsa, host->name, ind_type, fully_qualified_name);
2545   if (rc == DNS_NOMATCH) return HOST_FIND_FAILED;
2546   if (rc == DNS_FAIL || rc == DNS_AGAIN)
2547     {
2548     #ifndef STAND_ALONE
2549     if (match_isinlist(host->name, &mx_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2550         TRUE, NULL) != OK)
2551     #endif
2552       return HOST_FIND_AGAIN;
2553     DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2554       "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2555     }
2556   }
2557
2558 /* If we haven't found anything yet, and we are requested to do so, try for an
2559 A or AAAA record. If we find it (or them) check to see that it isn't the local
2560 host. */
2561
2562 if (rc != DNS_SUCCEED)
2563   {
2564   if ((whichrrs & HOST_FIND_BY_A) == 0)
2565     {
2566     DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2567     return HOST_FIND_FAILED;
2568     }
2569
2570   last = host;        /* End of local chainlet */
2571   host->mx = MX_NONE;
2572   host->port = PORT_NONE;
2573   rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2574     fully_qualified_name);
2575
2576   /* If one or more address records have been found, check that none of them
2577   are local. Since we know the host items all have their IP addresses
2578   inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2579   HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2580   because set_address_from_dns() removes them. */
2581
2582   if (rc == HOST_FOUND)
2583     rc = host_scan_for_local_hosts(host, &last, removed);
2584   else
2585     if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED;  /* No special action */
2586
2587   /* When running in the test harness, sort into the order of addresses so as
2588   to get repeatability. */
2589
2590   if (running_in_test_harness) sort_addresses(host, last);
2591
2592   DEBUG(D_host_lookup)
2593     {
2594     host_item *h;
2595     if (host->address != NULL)
2596       {
2597       if (fully_qualified_name != NULL)
2598         debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2599       for (h = host; h != last->next; h = h->next)
2600         debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2601           (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2602           (h->status >= hstatus_unusable)? US"*" : US"");
2603       }
2604     }
2605
2606   return rc;
2607   }
2608
2609 /* We have found one or more MX or SRV records. Sort them according to
2610 precedence. Put the data for the first one into the existing host block, and
2611 insert new host_item blocks into the chain for the remainder. For equal
2612 precedences one is supposed to randomize the order. To make this happen, the
2613 sorting is actually done on the MX value * 1000 + a random number. This is put
2614 into a host field called sort_key.
2615
2616 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2617 IPv6 address in preference. At this stage, we don't know what kind of address
2618 the host has. We choose a random number < 500; if later we find an A record
2619 first, we add 500 to the random number. Then for any other address records, we
2620 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2621 records.
2622
2623 At this point we remove any duplicates that point to the same host, retaining
2624 only the one with the lowest precedence. We cannot yet check for precedence
2625 greater than that of the local host, because that test cannot be properly done
2626 until the addresses have been found - an MX record may point to a name for this
2627 host which is not the primary hostname. */
2628
2629 last = NULL;    /* Indicates that not even the first item is filled yet */
2630
2631 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2632      rr != NULL;
2633      rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2634   {
2635   int precedence;
2636   int weight = 0;        /* For SRV records */
2637   int port = PORT_NONE;
2638   uschar *s;             /* MUST be unsigned for GETSHORT */
2639   uschar data[256];
2640
2641   if (rr->type != ind_type) continue;
2642   s = rr->data;
2643   GETSHORT(precedence, s);      /* Pointer s is advanced */
2644
2645   /* For MX records, we use a random "weight" which causes multiple records of
2646   the same precedence to sort randomly. */
2647
2648   if (ind_type == T_MX)
2649     {
2650     weight = random_number(500);
2651     }
2652
2653   /* SRV records are specified with a port and a weight. The weight is used
2654   in a special algorithm. However, to start with, we just use it to order the
2655   records of equal priority (precedence). */
2656
2657   else
2658     {
2659     GETSHORT(weight, s);
2660     GETSHORT(port, s);
2661     }
2662
2663   /* Get the name of the host pointed to. */
2664
2665   (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2666     (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2667
2668   /* Check that we haven't already got this host on the chain; if we have,
2669   keep only the lower precedence. This situation shouldn't occur, but you
2670   never know what junk might get into the DNS (and this case has been seen on
2671   more than one occasion). */
2672
2673   if (last != NULL)       /* This is not the first record */
2674     {
2675     host_item *prev = NULL;
2676
2677     for (h = host; h != last->next; prev = h, h = h->next)
2678       {
2679       if (strcmpic(h->name, data) == 0)
2680         {
2681         DEBUG(D_host_lookup)
2682           debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2683             (precedence > h->mx)? precedence : h->mx);
2684         if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2685         if (h == host)                            /* Override first item */
2686           {
2687           h->mx = precedence;
2688           host->sort_key = precedence * 1000 + weight;
2689           goto NEXT_MX_RR;
2690           }
2691
2692         /* Unwanted host item is not the first in the chain, so we can get
2693         get rid of it by cutting it out. */
2694
2695         prev->next = h->next;
2696         if (h == last) last = prev;
2697         break;
2698         }
2699       }
2700     }
2701
2702   /* If this is the first MX or SRV record, put the data into the existing host
2703   block. Otherwise, add a new block in the correct place; if it has to be
2704   before the first block, copy the first block's data to a new second block. */
2705
2706   if (last == NULL)
2707     {
2708     host->name = string_copy_dnsdomain(data);
2709     host->address = NULL;
2710     host->port = port;
2711     host->mx = precedence;
2712     host->sort_key = precedence * 1000 + weight;
2713     host->status = hstatus_unknown;
2714     host->why = hwhy_unknown;
2715     last = host;
2716     }
2717
2718   /* Make a new host item and seek the correct insertion place */
2719
2720   else
2721     {
2722     int sort_key = precedence * 1000 + weight;
2723     host_item *next = store_get(sizeof(host_item));
2724     next->name = string_copy_dnsdomain(data);
2725     next->address = NULL;
2726     next->port = port;
2727     next->mx = precedence;
2728     next->sort_key = sort_key;
2729     next->status = hstatus_unknown;
2730     next->why = hwhy_unknown;
2731     next->last_try = 0;
2732
2733     /* Handle the case when we have to insert before the first item. */
2734
2735     if (sort_key < host->sort_key)
2736       {
2737       host_item htemp;
2738       htemp = *host;
2739       *host = *next;
2740       *next = htemp;
2741       host->next = next;
2742       if (last == host) last = next;
2743       }
2744
2745     /* Else scan down the items we have inserted as part of this exercise;
2746     don't go further. */
2747
2748     else
2749       {
2750       for (h = host; h != last; h = h->next)
2751         {
2752         if (sort_key < h->next->sort_key)
2753           {
2754           next->next = h->next;
2755           h->next = next;
2756           break;
2757           }
2758         }
2759
2760       /* Join on after the last host item that's part of this
2761       processing if we haven't stopped sooner. */
2762
2763       if (h == last)
2764         {
2765         next->next = last->next;
2766         last->next = next;
2767         last = next;
2768         }
2769       }
2770     }
2771
2772   NEXT_MX_RR: continue;
2773   }
2774
2775 /* If the list of hosts was obtained from SRV records, there are two things to
2776 do. First, if there is only one host, and it's name is ".", it means there is
2777 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2778 priority according to their weights, using an algorithm that is defined in RFC
2779 2782. The hosts are currently sorted by priority and weight. For each priority
2780 group we have to pick off one host and put it first, and then repeat for any
2781 remaining in the same priority group. */
2782
2783 if (ind_type == T_SRV)
2784   {
2785   host_item **pptr;
2786
2787   if (host == last && host->name[0] == 0)
2788     {
2789     DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2790     return HOST_FIND_FAILED;
2791     }
2792
2793   DEBUG(D_host_lookup)
2794     {
2795     debug_printf("original ordering of hosts from SRV records:\n");
2796     for (h = host; h != last->next; h = h->next)
2797       debug_printf("  %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2798     }
2799
2800   for (pptr = &host, h = host; h != last; pptr = &(h->next), h = h->next)
2801     {
2802     int sum = 0;
2803     host_item *hh;
2804
2805     /* Find the last following host that has the same precedence. At the same
2806     time, compute the sum of the weights and the running totals. These can be
2807     stored in the sort_key field. */
2808
2809     for (hh = h; hh != last; hh = hh->next)
2810       {
2811       int weight = hh->sort_key % 1000;   /* was precedence * 1000 + weight */
2812       sum += weight;
2813       hh->sort_key = sum;
2814       if (hh->mx != hh->next->mx) break;
2815       }
2816
2817     /* If there's more than one host at this precedence (priority), we need to
2818     pick one to go first. */
2819
2820     if (hh != h)
2821       {
2822       host_item *hhh;
2823       host_item **ppptr;
2824       int randomizer = random_number(sum + 1);
2825
2826       for (ppptr = pptr, hhh = h;
2827            hhh != hh;
2828            ppptr = &(hhh->next), hhh = hhh->next)
2829         {
2830         if (hhh->sort_key >= randomizer) break;
2831         }
2832
2833       /* hhh now points to the host that should go first; ppptr points to the
2834       place that points to it. Unfortunately, if the start of the minilist is
2835       the start of the entire list, we can't just swap the items over, because
2836       we must not change the value of host, since it is passed in from outside.
2837       One day, this could perhaps be changed.
2838
2839       The special case is fudged by putting the new item *second* in the chain,
2840       and then transferring the data between the first and second items. We
2841       can't just swap the first and the chosen item, because that would mean
2842       that an item with zero weight might no longer be first. */
2843
2844       if (hhh != h)
2845         {
2846         *ppptr = hhh->next;          /* Cuts it out of the chain */
2847
2848         if (h == host)
2849           {
2850           host_item temp = *h;
2851           *h = *hhh;
2852           *hhh = temp;
2853           hhh->next = temp.next;
2854           h->next = hhh;
2855           }
2856
2857         else
2858           {
2859           hhh->next = h;               /* The rest of the chain follows it */
2860           *pptr = hhh;                 /* It takes the place of h */
2861           h = hhh;                     /* It's now the start of this minilist */
2862           }
2863         }
2864       }
2865
2866     /* A host has been chosen to be first at this priority and h now points
2867     to this host. There may be others at the same priority, or others at a
2868     different priority. Before we leave this host, we need to put back a sort
2869     key of the traditional MX kind, in case this host is multihomed, because
2870     the sort key is used for ordering the multiple IP addresses. We do not need
2871     to ensure that these new sort keys actually reflect the order of the hosts,
2872     however. */
2873
2874     h->sort_key = h->mx * 1000 + random_number(500);
2875     }   /* Move on to the next host */
2876   }
2877
2878 /* Now we have to find IP addresses for all the hosts. We have ensured above
2879 that the names in all the host items are unique. Before release 4.61 we used to
2880 process records from the additional section in the DNS packet that returned the
2881 MX or SRV records. However, a DNS name server is free to drop any resource
2882 records from the additional section. In theory, this has always been a
2883 potential problem, but it is exacerbated by the advent of IPv6. If a host had
2884 several IPv4 addresses and some were not in the additional section, at least
2885 Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
2886 and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
2887 connection, and never try an IPv4 address. When there was only IPv4
2888 connectivity, this was a disaster that did in practice occur.
2889
2890 So, from release 4.61 onwards, we always search for A and AAAA records
2891 explicitly. The names shouldn't point to CNAMES, but we use the general lookup
2892 function that handles them, just in case. If any lookup gives a soft error,
2893 change the default yield.
2894
2895 For these DNS lookups, we must disable qualify_single and search_parents;
2896 otherwise invalid host names obtained from MX or SRV records can cause trouble
2897 if they happen to match something local. */
2898
2899 yield = HOST_FIND_FAILED;    /* Default yield */
2900 dns_init(FALSE, FALSE);      /* Disable qualify_single and search_parents */
2901
2902 for (h = host; h != last->next; h = h->next)
2903   {
2904   if (h->address != NULL) continue;  /* Inserted by a multihomed host */
2905   rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip, NULL);
2906   if (rc != HOST_FOUND)
2907     {
2908     h->status = hstatus_unusable;
2909     if (rc == HOST_FIND_AGAIN)
2910       {
2911       yield = rc;
2912       h->why = hwhy_deferred;
2913       }
2914     else
2915       h->why = (rc == HOST_IGNORED)? hwhy_ignored : hwhy_failed;
2916     }
2917   }
2918
2919 /* Scan the list for any hosts that are marked unusable because they have
2920 been explicitly ignored, and remove them from the list, as if they did not
2921 exist. If we end up with just a single, ignored host, flatten its fields as if
2922 nothing was found. */
2923
2924 if (ignore_target_hosts != NULL)
2925   {
2926   host_item *prev = NULL;
2927   for (h = host; h != last->next; h = h->next)
2928     {
2929     REDO:
2930     if (h->why != hwhy_ignored)        /* Non ignored host, just continue */
2931       prev = h;
2932     else if (prev == NULL)             /* First host is ignored */
2933       {
2934       if (h != last)                   /* First is not last */
2935         {
2936         if (h->next == last) last = h; /* Overwrite it with next */
2937         *h = *(h->next);               /* and reprocess it. */
2938         goto REDO;                     /* C should have redo, like Perl */
2939         }
2940       }
2941     else                               /* Ignored host is not first - */
2942       {                                /*   cut it out */
2943       prev->next = h->next;
2944       if (h == last) last = prev;
2945       }
2946     }
2947
2948   if (host->why == hwhy_ignored) host->address = NULL;
2949   }
2950
2951 /* There is still one complication in the case of IPv6. Although the code above
2952 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
2953 hosts, it doesn't do this for addresses that apply to different hosts with the
2954 same MX precedence, because the sorting on MX precedence happens first. So we
2955 have to make another pass to check for this case. We ensure that, within a
2956 single MX preference value, IPv6 addresses come first. This can separate the
2957 addresses of a multihomed host, but that should not matter. */
2958
2959 #if HAVE_IPV6
2960 if (h != last)
2961   {
2962   for (h = host; h != last; h = h->next)
2963     {
2964     host_item temp;
2965     host_item *next = h->next;
2966     if (h->mx != next->mx ||                /* If next is different MX value */
2967         (h->sort_key % 1000) < 500 ||       /* OR this one is IPv6 */
2968         (next->sort_key % 1000) >= 500)     /* OR next is IPv4 */
2969       continue;                             /* move on to next */
2970     temp = *h;
2971     temp.next = next->next;
2972     *h = *next;
2973     h->next = next;
2974     *next = temp;
2975     }
2976   }
2977 #endif
2978
2979 /* When running in the test harness, we want the hosts always to be in the same
2980 order so that the debugging output is the same and can be compared. Having a
2981 fixed set of "random" numbers doesn't actually achieve this, because the RRs
2982 come back from the resolver in a random order, so the non-random random numbers
2983 get used in a different order. We therefore have to sort the hosts that have
2984 the same MX values. We chose do to this by their name and then by IP address.
2985 The fact that the sort is slow matters not - this is testing only! */
2986
2987 if (running_in_test_harness)
2988   {
2989   BOOL done;
2990   do
2991     {
2992     done = TRUE;
2993     for (h = host; h != last; h = h->next)
2994       {
2995       int c = Ustrcmp(h->name, h->next->name);
2996       if (c == 0) c = Ustrcmp(h->address, h->next->address);
2997       if (h->mx == h->next->mx && c > 0)
2998         {
2999         host_item *next = h->next;
3000         host_item temp = *h;
3001         temp.next = next->next;
3002         *h = *next;
3003         h->next = next;
3004         *next = temp;
3005         done = FALSE;
3006         }
3007       }
3008     }
3009   while (!done);
3010   }
3011
3012 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3013 whose IP addresses are on the local host. If any are found, all hosts with the
3014 same or higher MX values are removed. However, if the local host has the lowest
3015 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3016 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3017 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3018 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3019 be HOST_FIND_FAILED. */
3020
3021 host_remove_duplicates(host, &last);
3022 rc = host_scan_for_local_hosts(host, &last, removed);
3023 if (rc != HOST_FIND_FAILED) yield = rc;
3024
3025 DEBUG(D_host_lookup)
3026   {
3027   if (fully_qualified_name != NULL)
3028     debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3029   debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3030     (yield == HOST_FOUND)? "HOST_FOUND" :
3031     (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
3032     (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3033     (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3034     yield);
3035   for (h = host; h != last->next; h = h->next)
3036     {
3037     debug_printf("  %s %s MX=%d ", h->name,
3038       (h->address == NULL)? US"<null>" : h->address, h->mx);
3039     if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3040     if (h->status >= hstatus_unusable) debug_printf("*");
3041     debug_printf("\n");
3042     }
3043   }
3044
3045 return yield;
3046 }
3047
3048
3049
3050
3051 /*************************************************
3052 **************************************************
3053 *             Stand-alone test program           *
3054 **************************************************
3055 *************************************************/
3056
3057 #ifdef STAND_ALONE
3058
3059 int main(int argc, char **cargv)
3060 {
3061 host_item h;
3062 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
3063 BOOL byname = FALSE;
3064 BOOL qualify_single = TRUE;
3065 BOOL search_parents = FALSE;
3066 uschar **argv = USS cargv;
3067 uschar buffer[256];
3068
3069 primary_hostname = US"";
3070 store_pool = POOL_MAIN;
3071 debug_selector = D_host_lookup|D_interface;
3072 debug_file = stdout;
3073 debug_fd = fileno(debug_file);
3074
3075 printf("Exim stand-alone host functions test\n");
3076
3077 host_find_interfaces();
3078 debug_selector = D_host_lookup | D_dns;
3079
3080 if (argc > 1) primary_hostname = argv[1];
3081
3082 /* So that debug level changes can be done first */
3083
3084 dns_init(qualify_single, search_parents);
3085
3086 printf("Testing host lookup\n");
3087 printf("> ");
3088 while (Ufgets(buffer, 256, stdin) != NULL)
3089   {
3090   int rc;
3091   int len = Ustrlen(buffer);
3092   uschar *fully_qualified_name;
3093
3094   while (len > 0 && isspace(buffer[len-1])) len--;
3095   buffer[len] = 0;
3096
3097   if (Ustrcmp(buffer, "q") == 0) break;
3098
3099   if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3100   else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3101   else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3102   else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3103   else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3104   else if (Ustrcmp(buffer, "srv+a") == 0)
3105     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3106   else if (Ustrcmp(buffer, "srv+mx") == 0)
3107     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3108   else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3109     whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
3110   else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3111   else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3112   else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3113   else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3114   else if (Ustrcmp(buffer, "test_harness") == 0)
3115     running_in_test_harness = !running_in_test_harness;
3116   else if (Ustrcmp(buffer, "res_debug") == 0)
3117     {
3118     _res.options ^= RES_DEBUG;
3119     }
3120   else if (Ustrncmp(buffer, "retrans", 7) == 0)
3121     {
3122     (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3123     _res.retrans = dns_retrans;
3124     }
3125   else if (Ustrncmp(buffer, "retry", 5) == 0)
3126     {
3127     (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3128     _res.retry = dns_retry;
3129     }
3130   else
3131     {
3132     int flags = whichrrs;
3133
3134     h.name = buffer;
3135     h.next = NULL;
3136     h.mx = MX_NONE;
3137     h.port = PORT_NONE;
3138     h.status = hstatus_unknown;
3139     h.why = hwhy_unknown;
3140     h.address = NULL;
3141
3142     if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3143     if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3144
3145     rc = byname?
3146       host_find_byname(&h, NULL, &fully_qualified_name, TRUE)
3147       :
3148       host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3149         &fully_qualified_name, NULL);
3150
3151     if (rc == HOST_FIND_FAILED) printf("Failed\n");
3152       else if (rc == HOST_FIND_AGAIN) printf("Again\n");
3153         else if (rc == HOST_FOUND_LOCAL) printf("Local\n");
3154     }
3155
3156   printf("\n> ");
3157   }
3158
3159 printf("Testing host_aton\n");
3160 printf("> ");
3161 while (Ufgets(buffer, 256, stdin) != NULL)
3162   {
3163   int i;
3164   int x[4];
3165   int len = Ustrlen(buffer);
3166
3167   while (len > 0 && isspace(buffer[len-1])) len--;
3168   buffer[len] = 0;
3169
3170   if (Ustrcmp(buffer, "q") == 0) break;
3171
3172   len = host_aton(buffer, x);
3173   printf("length = %d ", len);
3174   for (i = 0; i < len; i++)
3175     {
3176     printf("%04x ", (x[i] >> 16) & 0xffff);
3177     printf("%04x ", x[i] & 0xffff);
3178     }
3179   printf("\n> ");
3180   }
3181
3182 printf("\n");
3183
3184 printf("Testing host_name_lookup\n");
3185 printf("> ");
3186 while (Ufgets(buffer, 256, stdin) != NULL)
3187   {
3188   int len = Ustrlen(buffer);
3189   while (len > 0 && isspace(buffer[len-1])) len--;
3190   buffer[len] = 0;
3191   if (Ustrcmp(buffer, "q") == 0) break;
3192   sender_host_address = buffer;
3193   sender_host_name = NULL;
3194   sender_host_aliases = NULL;
3195   host_lookup_msg = US"";
3196   host_lookup_failed = FALSE;
3197   if (host_name_lookup() == FAIL)  /* Debug causes printing */
3198     printf("Lookup failed:%s\n", host_lookup_msg);
3199   printf("\n> ");
3200   }
3201
3202 printf("\n");
3203
3204 return 0;
3205 }
3206 #endif  /* STAND_ALONE */
3207
3208 /* End of host.c */