src/src/host.c

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