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