src/src/host.c

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