1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
6 /* See the file NOTICE for conditions of use and distribution. */
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
20 /* Static variable for preserving the list of interface addresses in case it is
21 used more than once. */
23 static ip_address_item *local_interface_data = NULL;
26 #ifdef USE_INET_NTOA_FIX
27 /*************************************************
28 * Replacement for broken inet_ntoa() *
29 *************************************************/
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,
39 as seen in comp.sys.sgi.admin
41 August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
42 should now be set for them as well.
44 Arguments: sa an in_addr structure
45 Returns: pointer to static text string
49 inet_ntoa(struct in_addr sa)
51 static uschar addr[20];
52 sprintf(addr, "%d.%d.%d.%d",
63 /*************************************************
64 * Random number generator *
65 *************************************************/
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.
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.
75 limit: one more than the largest number required
77 Returns: a pseudo-random number in the range 0 to limit-1
81 random_number(int limit)
87 if (running_in_test_harness) random_seed = 42; else
89 int p = (int)getpid();
90 random_seed = (int)time(NULL) ^ ((p << 16) | p);
93 random_seed = 1103515245 * random_seed + 12345;
94 return (unsigned int)(random_seed >> 16) % limit;
97 /*************************************************
98 * Wrappers for logging lookup times *
99 *************************************************/
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
107 log_long_lookup(const uschar * type, const uschar * data, unsigned long msec)
109 log_write(0, LOG_MAIN, "Long %s lookup for '%s': %lu msec",
114 /* returns the current system epoch time in milliseconds. */
118 struct timeval tmp_time;
119 unsigned long seconds, microseconds;
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;
129 dns_lookup_timerwrap(dns_answer *dnsa, const uschar *name, int type,
130 const uschar **fully_qualified_name)
133 unsigned long time_msec;
135 if (!slow_lookup_log)
136 return dns_lookup(dnsa, name, type, fully_qualified_name);
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);
146 /*************************************************
147 * Replace gethostbyname() when testing *
148 *************************************************/
150 /* This function is called instead of gethostbyname(), gethostbyname2(), or
151 getipnodebyname() when running in the test harness. It recognizes the name
152 "manyhome.test.ex" and generates a humungous number of IP addresses. It also
153 recognizes an unqualified "localhost" and forces it to the appropriate loopback
154 address. IP addresses are treated as literals. For other names, it uses the DNS
155 to find the host name. In the test harness, this means it will access only the
159 name the host name or a textual IP address
160 af AF_INET or AF_INET6
161 error_num where to put an error code:
162 HOST_NOT_FOUND/TRY_AGAIN/NO_RECOVERY/NO_DATA
164 Returns: a hostent structure or NULL for an error
167 static struct hostent *
168 host_fake_gethostbyname(const uschar *name, int af, int *error_num)
171 int alen = (af == AF_INET)? sizeof(struct in_addr):sizeof(struct in6_addr);
173 int alen = sizeof(struct in_addr);
177 const uschar *lname = name;
180 struct hostent *yield;
186 debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
187 (af == AF_INET)? "IPv4" : "IPv6");
189 /* Handle the name that needs a vast number of IP addresses */
191 if (Ustrcmp(name, "manyhome.test.ex") == 0 && af == AF_INET)
194 yield = store_get(sizeof(struct hostent));
195 alist = store_get(2049 * sizeof(char *));
196 adds = store_get(2048 * alen);
197 yield->h_name = CS name;
198 yield->h_aliases = NULL;
199 yield->h_addrtype = af;
200 yield->h_length = alen;
201 yield->h_addr_list = CSS alist;
202 for (i = 104; i <= 111; i++)
204 for (j = 0; j <= 255; j++)
217 /* Handle unqualified "localhost" */
219 if (Ustrcmp(name, "localhost") == 0)
220 lname = (af == AF_INET)? US"127.0.0.1" : US"::1";
222 /* Handle a literal IP address */
224 ipa = string_is_ip_address(lname, NULL);
227 if ((ipa == 4 && af == AF_INET) ||
228 (ipa == 6 && af == AF_INET6))
232 yield = store_get(sizeof(struct hostent));
233 alist = store_get(2 * sizeof(char *));
234 adds = store_get(alen);
235 yield->h_name = CS name;
236 yield->h_aliases = NULL;
237 yield->h_addrtype = af;
238 yield->h_length = alen;
239 yield->h_addr_list = CSS alist;
241 n = host_aton(lname, x);
242 for (i = 0; i < n; i++)
245 *adds++ = (y >> 24) & 255;
246 *adds++ = (y >> 16) & 255;
247 *adds++ = (y >> 8) & 255;
253 /* Wrong kind of literal address */
257 *error_num = HOST_NOT_FOUND;
262 /* Handle a host name */
266 int type = (af == AF_INET)? T_A:T_AAAA;
267 int rc = dns_lookup_timerwrap(&dnsa, lname, type, NULL);
270 lookup_dnssec_authenticated = NULL;
274 case DNS_SUCCEED: break;
275 case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
276 case DNS_NODATA: *error_num = NO_DATA; return NULL;
277 case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
279 case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
282 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
284 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
286 if (rr->type == type) count++;
289 yield = store_get(sizeof(struct hostent));
290 alist = store_get((count + 1) * sizeof(char **));
291 adds = store_get(count *alen);
293 yield->h_name = CS name;
294 yield->h_aliases = NULL;
295 yield->h_addrtype = af;
296 yield->h_length = alen;
297 yield->h_addr_list = CSS alist;
299 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
301 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
306 if (rr->type != type) continue;
307 da = dns_address_from_rr(&dnsa, rr);
309 n = host_aton(da->address, x);
310 for (i = 0; i < n; i++)
313 *adds++ = (y >> 24) & 255;
314 *adds++ = (y >> 16) & 255;
315 *adds++ = (y >> 8) & 255;
327 /*************************************************
328 * Build chain of host items from list *
329 *************************************************/
331 /* This function builds a chain of host items from a textual list of host
332 names. It does not do any lookups. If randomize is true, the chain is build in
333 a randomized order. There may be multiple groups of independently randomized
334 hosts; they are delimited by a host name consisting of just "+".
337 anchor anchor for the chain
339 randomize TRUE for randomizing
345 host_build_hostlist(host_item **anchor, const uschar *list, BOOL randomize)
348 int fake_mx = MX_NONE; /* This value is actually -1 */
351 if (list == NULL) return;
352 if (randomize) fake_mx--; /* Start at -2 for randomizing */
356 while ((name = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
360 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
361 { /* ignore if not randomizing */
362 if (randomize) fake_mx--;
366 h = store_get(sizeof(host_item));
371 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
372 h->status = hstatus_unknown;
373 h->why = hwhy_unknown;
383 host_item *hh = *anchor;
384 if (h->sort_key < hh->sort_key)
391 while (hh->next != NULL && h->sort_key >= (hh->next)->sort_key)
404 /*************************************************
405 * Extract port from address string *
406 *************************************************/
408 /* In the spool file, and in the -oMa and -oMi options, a host plus port is
409 given as an IP address followed by a dot and a port number. This function
412 An alternative format for the -oMa and -oMi options is [ip address]:port which
413 is what Exim 4 uses for output, because it seems to becoming commonly used,
414 whereas the dot form confuses some programs/people. So we recognize that form
418 address points to the string; if there is a port, the '.' in the string
419 is overwritten with zero to terminate the address; if the string
420 is in the [xxx]:ppp format, the address is shifted left and the
423 Returns: 0 if there is no port, else the port number. If there's a syntax
424 error, leave the incoming address alone, and return 0.
428 host_address_extract_port(uschar *address)
433 /* Handle the "bracketed with colon on the end" format */
437 uschar *rb = address + 1;
438 while (*rb != 0 && *rb != ']') rb++;
439 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
442 port = Ustrtol(rb + 1, &endptr, 10);
443 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
445 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
446 memmove(address, address + 1, rb - address - 2);
450 /* Handle the "dot on the end" format */
454 int skip = -3; /* Skip 3 dots in IPv4 addresses */
456 while (*(++address) != 0)
459 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
460 else if (ch == '.' && skip++ >= 0) break;
462 if (*address == 0) return 0;
463 port = Ustrtol(address + 1, &endptr, 10);
464 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
472 /*************************************************
473 * Get port from a host item's name *
474 *************************************************/
476 /* This function is called when finding the IP address for a host that is in a
477 list of hosts explicitly configured, such as in the manualroute router, or in a
478 fallback hosts list. We see if there is a port specification at the end of the
479 host name, and if so, remove it. A minimum length of 3 is required for the
480 original name; nothing shorter is recognized as having a port.
482 We test for a name ending with a sequence of digits; if preceded by colon we
483 have a port if the character before the colon is ] and the name starts with [
484 or if there are no other colons in the name (i.e. it's not an IPv6 address).
486 Arguments: pointer to the host item
487 Returns: a port number or PORT_NONE
491 host_item_get_port(host_item *h)
495 int len = Ustrlen(h->name);
497 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
499 /* Extract potential port number */
504 while (p > h->name + 1 && isdigit(*p))
506 port += (*p-- - '0') * x;
510 /* The smallest value of p at this point is h->name + 1. */
512 if (*p != ':') return PORT_NONE;
514 if (p[-1] == ']' && h->name[0] == '[')
515 h->name = string_copyn(h->name + 1, p - h->name - 2);
516 else if (Ustrchr(h->name, ':') == p)
517 h->name = string_copyn(h->name, p - h->name);
518 else return PORT_NONE;
520 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
526 #ifndef STAND_ALONE /* Omit when standalone testing */
528 /*************************************************
529 * Build sender_fullhost and sender_rcvhost *
530 *************************************************/
532 /* This function is called when sender_host_name and/or sender_helo_name
533 have been set. Or might have been set - for a local message read off the spool
534 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
537 (a) No sender_host_name or sender_helo_name: "[ip address]"
538 (b) Just sender_host_name: "host_name [ip address]"
539 (c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
540 in which case: "[ip address}"
541 (d) The two are identical: "host_name [ip address]" includes helo = IP
542 (e) The two are different: "host_name (helo_name) [ip address]"
544 If log_incoming_port is set, the sending host's port number is added to the IP
547 This function also builds sender_rcvhost for use in Received: lines, whose
548 syntax is a bit different. This value also includes the RFC 1413 identity.
549 There wouldn't be two different variables if I had got all this right in the
552 Because this data may survive over more than one incoming SMTP message, it has
553 to be in permanent store.
560 host_build_sender_fullhost(void)
562 BOOL show_helo = TRUE;
565 int old_pool = store_pool;
567 if (sender_host_address == NULL) return;
569 store_pool = POOL_PERM;
571 /* Set up address, with or without the port. After discussion, it seems that
572 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
573 use this directly as the first item for Received: because it ain't an RFC 2822
576 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
577 if ((log_extra_selector & LX_incoming_port) == 0 || sender_host_port <= 0)
578 *(Ustrrchr(address, ':')) = 0;
580 /* If there's no EHLO/HELO data, we can't show it. */
582 if (sender_helo_name == NULL) show_helo = FALSE;
584 /* If HELO/EHLO was followed by an IP literal, it's messy because of two
585 features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
586 doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
587 be given in canonical form, so we have to canonicize them before comparing. As
588 it happens, the code works for both IPv4 and IPv6. */
590 else if (sender_helo_name[0] == '[' &&
591 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
596 if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
597 if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
599 helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
601 if (string_is_ip_address(helo_ip, NULL) != 0)
605 uschar ipx[48], ipy[48]; /* large enough for full IPv6 */
607 sizex = host_aton(helo_ip, x);
608 sizey = host_aton(sender_host_address, y);
610 (void)host_nmtoa(sizex, x, -1, ipx, ':');
611 (void)host_nmtoa(sizey, y, -1, ipy, ':');
613 if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
617 /* Host name is not verified */
619 if (sender_host_name == NULL)
621 uschar *portptr = Ustrstr(address, "]:");
624 int adlen; /* Sun compiler doesn't like ++ in initializers */
626 adlen = (portptr == NULL)? Ustrlen(address) : (++portptr - address);
627 sender_fullhost = (sender_helo_name == NULL)? address :
628 string_sprintf("(%s) %s", sender_helo_name, address);
630 sender_rcvhost = string_cat(NULL, &size, &ptr, address, adlen);
632 if (sender_ident != NULL || show_helo || portptr != NULL)
635 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US" (", 2);
639 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2, US"port=",
643 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
644 (firstptr == ptr)? US"helo=" : US" helo=", sender_helo_name);
646 if (sender_ident != NULL)
647 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
648 (firstptr == ptr)? US"ident=" : US" ident=", sender_ident);
650 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US")", 1);
653 sender_rcvhost[ptr] = 0; /* string_cat() always leaves room */
655 /* Release store, because string_cat allocated a minimum of 100 bytes that
656 are rarely completely used. */
658 store_reset(sender_rcvhost + ptr + 1);
661 /* Host name is known and verified. Unless we've already found that the HELO
662 data matches the IP address, compare it with the name. */
666 if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
671 sender_fullhost = string_sprintf("%s (%s) %s", sender_host_name,
672 sender_helo_name, address);
673 sender_rcvhost = (sender_ident == NULL)?
674 string_sprintf("%s (%s helo=%s)", sender_host_name,
675 address, sender_helo_name) :
676 string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
677 address, sender_helo_name, sender_ident);
681 sender_fullhost = string_sprintf("%s %s", sender_host_name, address);
682 sender_rcvhost = (sender_ident == NULL)?
683 string_sprintf("%s (%s)", sender_host_name, address) :
684 string_sprintf("%s (%s ident=%s)", sender_host_name, address,
689 store_pool = old_pool;
691 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
692 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
697 /*************************************************
698 * Build host+ident message *
699 *************************************************/
701 /* Used when logging rejections and various ACL and SMTP incidents. The text
702 return depends on whether sender_fullhost and sender_ident are set or not:
704 no ident, no host => U=unknown
705 no ident, host set => H=sender_fullhost
706 ident set, no host => U=ident
707 ident set, host set => H=sender_fullhost U=ident
710 useflag TRUE if first item to be flagged (H= or U=); if there are two
711 items, the second is always flagged
713 Returns: pointer to a string in big_buffer
717 host_and_ident(BOOL useflag)
719 if (sender_fullhost == NULL)
721 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag? "U=" : "",
722 (sender_ident == NULL)? US"unknown" : sender_ident);
726 uschar *flag = useflag? US"H=" : US"";
727 uschar *iface = US"";
728 if ((log_extra_selector & LX_incoming_interface) != 0 &&
729 interface_address != NULL)
730 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
731 if (sender_ident == NULL)
732 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
733 flag, sender_fullhost, iface);
735 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
736 flag, sender_fullhost, iface, sender_ident);
741 #endif /* STAND_ALONE */
746 /*************************************************
747 * Build list of local interfaces *
748 *************************************************/
750 /* This function interprets the contents of the local_interfaces or
751 extra_local_interfaces options, and creates an ip_address_item block for each
752 item on the list. There is no special interpretation of any IP addresses; in
753 particular, 0.0.0.0 and ::0 are returned without modification. If any address
754 includes a port, it is set in the block. Otherwise the port value is set to
759 name the name of the option being expanded
761 Returns: a chain of ip_address_items, each containing to a textual
762 version of an IP address, and a port number (host order) or
763 zero if no port was given with the address
767 host_build_ifacelist(const uschar *list, uschar *name)
772 ip_address_item *yield = NULL;
773 ip_address_item *last = NULL;
774 ip_address_item *next;
776 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
779 int port = host_address_extract_port(s); /* Leaves just the IP address */
780 if ((ipv = string_is_ip_address(s, NULL)) == 0)
781 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
784 /* Skip IPv6 addresses if IPv6 is disabled. */
786 if (disable_ipv6 && ipv == 6) continue;
788 /* This use of strcpy() is OK because we have checked that s is a valid IP
789 address above. The field in the ip_address_item is large enough to hold an
792 next = store_get(sizeof(ip_address_item));
794 Ustrcpy(next->address, s);
796 next->v6_include_v4 = FALSE;
798 if (yield == NULL) yield = last = next; else
812 /*************************************************
813 * Find addresses on local interfaces *
814 *************************************************/
816 /* This function finds the addresses of local IP interfaces. These are used
817 when testing for routing to the local host. As the function may be called more
818 than once, the list is preserved in permanent store, pointed to by a static
819 variable, to save doing the work more than once per process.
821 The generic list of interfaces is obtained by calling host_build_ifacelist()
822 for local_interfaces and extra_local_interfaces. This list scanned to remove
823 duplicates (which may exist with different ports - not relevant here). If
824 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
825 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
826 obtained from os_find_running_interfaces().
829 Returns: a chain of ip_address_items, each containing to a textual
830 version of an IP address; the port numbers are not relevant
834 /* First, a local subfunction to add an interface to a list in permanent store,
835 but only if there isn't a previous copy of that address on the list. */
837 static ip_address_item *
838 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
840 ip_address_item *ipa2;
841 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
842 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
843 ipa2 = store_get_perm(sizeof(ip_address_item));
850 /* This is the globally visible function */
853 host_find_interfaces(void)
855 ip_address_item *running_interfaces = NULL;
857 if (local_interface_data == NULL)
859 void *reset_item = store_get(0);
860 ip_address_item *dlist = host_build_ifacelist(CUS local_interfaces,
861 US"local_interfaces");
862 ip_address_item *xlist = host_build_ifacelist(CUS extra_local_interfaces,
863 US"extra_local_interfaces");
864 ip_address_item *ipa;
866 if (dlist == NULL) dlist = xlist; else
868 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
872 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
874 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
875 Ustrcmp(ipa->address, "::0") == 0)
877 ip_address_item *ipa2;
878 BOOL ipv6 = ipa->address[0] == ':';
879 if (running_interfaces == NULL)
880 running_interfaces = os_find_running_interfaces();
881 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
883 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
884 local_interface_data = add_unique_interface(local_interface_data,
890 local_interface_data = add_unique_interface(local_interface_data, ipa);
893 debug_printf("Configured local interface: address=%s", ipa->address);
894 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
899 store_reset(reset_item);
902 return local_interface_data;
909 /*************************************************
910 * Convert network IP address to text *
911 *************************************************/
913 /* Given an IPv4 or IPv6 address in binary, convert it to a text
914 string and return the result in a piece of new store. The address can
915 either be given directly, or passed over in a sockaddr structure. Note
916 that this isn't the converse of host_aton() because of byte ordering
917 differences. See host_nmtoa() below.
920 type if < 0 then arg points to a sockaddr, else
921 either AF_INET or AF_INET6
922 arg points to a sockaddr if type is < 0, or
923 points to an IPv4 address (32 bits), or
924 points to an IPv6 address (128 bits),
925 in both cases, in network byte order
926 buffer if NULL, the result is returned in gotten store;
927 else points to a buffer to hold the answer
928 portptr points to where to put the port number, if non NULL; only
931 Returns: pointer to character string
935 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
939 /* The new world. It is annoying that we have to fish out the address from
940 different places in the block, depending on what kind of address it is. It
941 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
942 function inet_ntoa() returns just uschar *, and some picky compilers insist
943 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
946 uschar addr_buffer[46];
949 int family = ((struct sockaddr *)arg)->sa_family;
950 if (family == AF_INET6)
952 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
953 yield = (uschar *)inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
954 sizeof(addr_buffer));
955 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
959 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
960 yield = (uschar *)inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
961 sizeof(addr_buffer));
962 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
967 yield = (uschar *)inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
970 /* If the result is a mapped IPv4 address, show it in V4 format. */
972 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
974 #else /* HAVE_IPV6 */
980 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
981 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
984 yield = US inet_ntoa(*((struct in_addr *)arg));
987 /* If there is no buffer, put the string into some new store. */
989 if (buffer == NULL) return string_copy(yield);
991 /* Callers of this function with a non-NULL buffer must ensure that it is
992 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
993 makes this use of strcpy() OK. */
995 Ustrcpy(buffer, yield);
1002 /*************************************************
1003 * Convert address text to binary *
1004 *************************************************/
1006 /* Given the textual form of an IP address, convert it to binary in an
1007 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
1008 The result has the first byte in the most significant byte of the first int. In
1009 other words, the result is not in network byte order, but in host byte order.
1010 As a result, this is not the converse of host_ntoa(), which expects network
1011 byte order. See host_nmtoa() below.
1014 address points to the textual address, checked for syntax
1015 bin points to an array of 4 ints
1017 Returns: the number of ints used
1021 host_aton(const uschar *address, int *bin)
1026 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
1027 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
1028 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
1031 if (Ustrchr(address, ':') != NULL)
1033 const uschar *p = address;
1034 const uschar *component[8];
1035 BOOL ipv4_ends = FALSE;
1041 /* If the address starts with a colon, it will start with two colons.
1042 Just lose the first one, which will leave a null first component. */
1046 /* Split the address into components separated by colons. The input address
1047 is supposed to be checked for syntax. There was a case where this was
1048 overlooked; to guard against that happening again, check here and crash if
1049 there are too many components. */
1051 while (*p != 0 && *p != '%')
1053 int len = Ustrcspn(p, ":%");
1054 if (len == 0) nulloffset = ci;
1055 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1056 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
1058 component[ci++] = p;
1063 /* If the final component contains a dot, it is a trailing v4 address.
1064 As the syntax is known to be checked, just set up for a trailing
1065 v4 address and restrict the v6 part to 6 components. */
1067 if (Ustrchr(component[ci-1], '.') != NULL)
1069 address = component[--ci];
1075 /* If there are fewer than 6 or 8 components, we have to insert some
1076 more empty ones in the middle. */
1080 int insert_count = v6count - ci;
1081 for (i = v6count-1; i > nulloffset + insert_count; i--)
1082 component[i] = component[i - insert_count];
1083 while (i > nulloffset) component[i--] = US"";
1086 /* Now turn the components into binary in pairs and bung them
1087 into the vector of ints. */
1089 for (i = 0; i < v6count; i += 2)
1090 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1091 Ustrtol(component[i+1], NULL, 16);
1093 /* If there was no terminating v4 component, we are done. */
1095 if (!ipv4_ends) return 4;
1098 /* Handle IPv4 address */
1100 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
1101 bin[v4offset] = (x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
1106 /*************************************************
1107 * Apply mask to an IP address *
1108 *************************************************/
1110 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1114 count the number of ints
1115 binary points to the ints to be masked
1116 mask the count of ms bits to leave, or -1 if no masking
1122 host_mask(int count, int *binary, int mask)
1125 if (mask < 0) mask = 99999;
1126 for (i = 0; i < count; i++)
1129 if (mask == 0) wordmask = 0;
1132 wordmask = (-1) << (32 - mask);
1140 binary[i] &= wordmask;
1147 /*************************************************
1148 * Convert masked IP address in ints to text *
1149 *************************************************/
1151 /* We can't use host_ntoa() because it assumes the binary values are in network
1152 byte order, and these are the result of host_aton(), which puts them in ints in
1153 host byte order. Also, we really want IPv6 addresses to be in a canonical
1154 format, so we output them with no abbreviation. In a number of cases we can't
1155 use the normal colon separator in them because it terminates keys in lsearch
1156 files, so we want to use dot instead. There's an argument that specifies what
1157 to use for IPv6 addresses.
1160 count 1 or 4 (number of ints)
1161 binary points to the ints
1162 mask mask value; if < 0 don't add to result
1163 buffer big enough to hold the result
1164 sep component separator character for IPv6 addresses
1166 Returns: the number of characters placed in buffer, not counting
1171 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1174 uschar *tt = buffer;
1179 for (i = 24; i >= 0; i -= 8)
1181 sprintf(CS tt, "%d.", (j >> i) & 255);
1187 for (i = 0; i < 4; i++)
1190 sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1195 tt--; /* lose final separator */
1201 sprintf(CS tt, "/%d", mask);
1210 /*************************************************
1211 * Check port for tls_on_connect *
1212 *************************************************/
1214 /* This function checks whether a given incoming port is configured for tls-
1215 on-connect. It is called from the daemon and from inetd handling. If the global
1216 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1217 check the tls_on_connect_ports option for a list of ports.
1219 Argument: a port number
1220 Returns: TRUE or FALSE
1224 host_is_tls_on_connect_port(int port)
1228 const uschar *list = tls_in.on_connect_ports;
1232 if (tls_in.on_connect) return TRUE;
1234 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
1235 if (Ustrtol(s, &end, 10) == port)
1243 /*************************************************
1244 * Check whether host is in a network *
1245 *************************************************/
1247 /* This function checks whether a given IP address matches a pattern that
1248 represents either a single host, or a network (using CIDR notation). The caller
1249 of this function must check the syntax of the arguments before calling it.
1252 host string representation of the ip-address to check
1253 net string representation of the network, with optional CIDR mask
1254 maskoffset offset to the / that introduces the mask in the key
1255 zero if there is no mask
1258 TRUE the host is inside the network
1259 FALSE the host is NOT inside the network
1263 host_is_in_net(const uschar *host, const uschar *net, int maskoffset)
1269 int size = host_aton(net, address);
1272 /* No mask => all bits to be checked */
1274 if (maskoffset == 0) mlen = 99999; /* Big number */
1275 else mlen = Uatoi(net + maskoffset + 1);
1277 /* Convert the incoming address to binary. */
1279 insize = host_aton(host, incoming);
1281 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1282 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1283 ::ffff:<v4address>, to IPv4 format. */
1285 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1286 incoming[2] == 0xffff)
1289 incoming[0] = incoming[3];
1292 /* No match if the sizes don't agree. */
1294 if (insize != size) return FALSE;
1296 /* Else do the masked comparison. */
1298 for (i = 0; i < size; i++)
1301 if (mlen == 0) mask = 0;
1304 mask = (-1) << (32 - mlen);
1312 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1320 /*************************************************
1321 * Scan host list for local hosts *
1322 *************************************************/
1324 /* Scan through a chain of addresses and check whether any of them is the
1325 address of an interface on the local machine. If so, remove that address and
1326 any previous ones with the same MX value, and all subsequent ones (which will
1327 have greater or equal MX values) from the chain. Note: marking them as unusable
1328 is NOT the right thing to do because it causes the hosts not to be used for
1329 other domains, for which they may well be correct.
1331 The hosts may be part of a longer chain; we only process those between the
1332 initial pointer and the "last" pointer.
1334 There is also a list of "pseudo-local" host names which are checked against the
1335 host names. Any match causes that host item to be treated the same as one which
1336 matches a local IP address.
1338 If the very first host is a local host, then all MX records had a precedence
1339 greater than or equal to that of the local host. Either there's a problem in
1340 the DNS, or an apparently remote name turned out to be an abbreviation for the
1341 local host. Give a specific return code, and let the caller decide what to do.
1342 Otherwise, give a success code if at least one host address has been found.
1345 host pointer to the first host in the chain
1346 lastptr pointer to pointer to the last host in the chain (may be updated)
1347 removed if not NULL, set TRUE if some local addresses were removed
1351 HOST_FOUND if there is at least one host with an IP address on the chain
1352 and an MX value less than any MX value associated with the
1354 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1355 the host addresses were obtained from A records or
1356 gethostbyname(), the MX values are set to -1.
1357 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1361 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1363 int yield = HOST_FIND_FAILED;
1364 host_item *last = *lastptr;
1365 host_item *prev = NULL;
1368 if (removed != NULL) *removed = FALSE;
1370 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1372 for (h = host; h != last->next; h = h->next)
1375 if (hosts_treat_as_local != NULL)
1378 const uschar *save = deliver_domain;
1379 deliver_domain = h->name; /* set $domain */
1380 rc = match_isinlist(string_copylc(h->name), CUSS &hosts_treat_as_local, 0,
1381 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1382 deliver_domain = save;
1383 if (rc == OK) goto FOUND_LOCAL;
1387 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1388 for 127.0.0.1 and refers to the local host. We therefore force it always to
1389 be treated as local. */
1391 if (h->address != NULL)
1393 ip_address_item *ip;
1394 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1395 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1396 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1397 yield = HOST_FOUND; /* At least one remote address has been found */
1400 /* Update prev to point to the last host item before any that have
1401 the same MX value as the one we have just considered. */
1403 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1406 return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1408 /* A host whose IP address matches a local IP address, or whose name matches
1409 something in hosts_treat_as_local has been found. */
1415 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1416 "local host has lowest MX\n" :
1417 "local host found for non-MX address\n");
1418 return HOST_FOUND_LOCAL;
1421 HDEBUG(D_host_lookup)
1423 debug_printf("local host in host list - removed hosts:\n");
1424 for (h = prev->next; h != last->next; h = h->next)
1425 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1428 if (removed != NULL) *removed = TRUE;
1429 prev->next = last->next;
1437 /*************************************************
1438 * Remove duplicate IPs in host list *
1439 *************************************************/
1441 /* You would think that administrators could set up their DNS records so that
1442 one ended up with a list of unique IP addresses after looking up A or MX
1443 records, but apparently duplication is common. So we scan such lists and
1444 remove the later duplicates. Note that we may get lists in which some host
1445 addresses are not set.
1448 host pointer to the first host in the chain
1449 lastptr pointer to pointer to the last host in the chain (may be updated)
1455 host_remove_duplicates(host_item *host, host_item **lastptr)
1457 while (host != *lastptr)
1459 if (host->address != NULL)
1461 host_item *h = host;
1462 while (h != *lastptr)
1464 if (h->next->address != NULL &&
1465 Ustrcmp(h->next->address, host->address) == 0)
1467 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1468 "removed\n", host->address, h->next->mx);
1469 if (h->next == *lastptr) *lastptr = h;
1470 h->next = h->next->next;
1475 /* If the last item was removed, host may have become == *lastptr */
1476 if (host != *lastptr) host = host->next;
1483 /*************************************************
1484 * Find sender host name by gethostbyaddr() *
1485 *************************************************/
1487 /* This used to be the only way it was done, but it turns out that not all
1488 systems give aliases for calls to gethostbyaddr() - or one of the modern
1489 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1490 but they can still exist. This function is now used only when a DNS lookup of
1491 the IP address fails, in order to give access to /etc/hosts.
1494 Returns: OK, DEFER, FAIL
1498 host_name_lookup_byaddr(void)
1502 struct hostent *hosts;
1503 struct in_addr addr;
1504 unsigned long time_msec;
1506 if (slow_lookup_log) time_msec = get_time_in_ms();
1508 /* Lookup on IPv6 system */
1511 if (Ustrchr(sender_host_address, ':') != NULL)
1513 struct in6_addr addr6;
1514 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1515 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1516 "IPv6 address", sender_host_address);
1517 #if HAVE_GETIPNODEBYADDR
1518 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1520 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1525 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1526 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1527 "IPv4 address", sender_host_address);
1528 #if HAVE_GETIPNODEBYADDR
1529 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1531 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1535 /* Do lookup on IPv4 system */
1538 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1539 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1542 if ( slow_lookup_log
1543 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
1545 log_long_lookup(US"name", sender_host_address, time_msec);
1547 /* Failed to look up the host. */
1551 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1553 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1556 /* It seems there are some records in the DNS that yield an empty name. We
1557 treat this as non-existent. In some operating systems, this is returned as an
1558 empty string; in others as a single dot. */
1560 if (hosts->h_name == NULL || hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1562 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1563 "treated as non-existent host name\n");
1567 /* Copy and lowercase the name, which is in static storage in many systems.
1568 Put it in permanent memory. */
1570 s = (uschar *)hosts->h_name;
1571 len = Ustrlen(s) + 1;
1572 t = sender_host_name = store_get_perm(len);
1573 while (*s != 0) *t++ = tolower(*s++);
1576 /* If the host has aliases, build a copy of the alias list */
1578 if (hosts->h_aliases != NULL)
1581 uschar **aliases, **ptr;
1582 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1583 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1584 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1586 uschar *s = *aliases;
1587 int len = Ustrlen(s) + 1;
1588 uschar *t = *ptr++ = store_get_perm(len);
1589 while (*s != 0) *t++ = tolower(*s++);
1600 /*************************************************
1601 * Find host name for incoming call *
1602 *************************************************/
1604 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1605 up a list of alias names, pointed to by sender_host_alias. The list is
1606 NULL-terminated. The incoming address is in sender_host_address, either in
1607 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1609 This function does a thorough check that the names it finds point back to the
1610 incoming IP address. Any that do not are discarded. Note that this is relied on
1611 by the ACL reverse_host_lookup check.
1613 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1614 this it not universally true. Also, for release 4.30, this function was changed
1615 to do a direct DNS lookup first, by default[1], because it turns out that that
1616 is the only guaranteed way to find all the aliases on some systems. My
1617 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1620 [1] The actual order is controlled by the host_lookup_order option.
1623 Returns: OK on success, the answer being placed in the global variable
1624 sender_host_name, with any aliases in a list hung off
1626 FAIL if no host name can be found
1627 DEFER if a temporary error was encountered
1629 The variable host_lookup_msg is set to an empty string on sucess, or to a
1630 reason for the failure otherwise, in a form suitable for tagging onto an error
1631 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1632 was a defer, host_lookup_deferred is set TRUE.
1634 Any dynamically constructed string for host_lookup_msg must be in permanent
1635 store, because it might be used for several incoming messages on the same SMTP
1639 host_name_lookup(void)
1643 uschar *hname, *save_hostname;
1647 const uschar *list = host_lookup_order;
1652 sender_host_dnssec = host_lookup_deferred = host_lookup_failed = FALSE;
1654 HDEBUG(D_host_lookup)
1655 debug_printf("looking up host name for %s\n", sender_host_address);
1657 /* For testing the case when a lookup does not complete, we have a special
1658 reserved IP address. */
1660 if (running_in_test_harness &&
1661 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1663 HDEBUG(D_host_lookup)
1664 debug_printf("Test harness: host name lookup returns DEFER\n");
1665 host_lookup_deferred = TRUE;
1669 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1670 the order specified by the host_lookup_order option. */
1672 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1675 if (strcmpic(ordername, US"bydns") == 0)
1677 dns_init(FALSE, FALSE, FALSE); /* dnssec ctrl by dns_dnssec_ok glbl */
1678 dns_build_reverse(sender_host_address, buffer);
1679 rc = dns_lookup_timerwrap(&dnsa, buffer, T_PTR, NULL);
1681 /* The first record we come across is used for the name; others are
1682 considered to be aliases. We have to scan twice, in order to find out the
1683 number of aliases. However, if all the names are empty, we will behave as
1684 if failure. (PTR records that yield empty names have been encountered in
1687 if (rc == DNS_SUCCEED)
1689 uschar **aptr = NULL;
1692 int old_pool = store_pool;
1694 /* Ideally we'd check DNSSEC both forward and reverse, but we use the
1695 gethost* routines for forward, so can't do that unless/until we rewrite. */
1696 sender_host_dnssec = dns_is_secure(&dnsa);
1698 debug_printf("Reverse DNS security status: %s\n",
1699 sender_host_dnssec ? "DNSSEC verified (AD)" : "unverified");
1701 store_pool = POOL_PERM; /* Save names in permanent storage */
1703 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1705 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1707 if (rr->type == T_PTR) count++;
1710 /* Get store for the list of aliases. For compatibility with
1711 gethostbyaddr, we make an empty list if there are none. */
1713 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1715 /* Re-scan and extract the names */
1717 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1719 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1722 if (rr->type != T_PTR) continue;
1723 s = store_get(ssize);
1725 /* If an overlong response was received, the data will have been
1726 truncated and dn_expand may fail. */
1728 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1729 (uschar *)(rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1731 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1732 sender_host_address);
1736 store_reset(s + Ustrlen(s) + 1);
1739 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1740 "empty name: treated as non-existent host name\n");
1743 if (sender_host_name == NULL) sender_host_name = s;
1745 while (*s != 0) { *s = tolower(*s); s++; }
1748 *aptr = NULL; /* End of alias list */
1749 store_pool = old_pool; /* Reset store pool */
1751 /* If we've found a names, break out of the "order" loop */
1753 if (sender_host_name != NULL) break;
1756 /* If the DNS lookup deferred, we must also defer. */
1758 if (rc == DNS_AGAIN)
1760 HDEBUG(D_host_lookup)
1761 debug_printf("IP address PTR lookup gave temporary error\n");
1762 host_lookup_deferred = TRUE;
1767 /* Do a lookup using gethostbyaddr() - or equivalent */
1769 else if (strcmpic(ordername, US"byaddr") == 0)
1771 HDEBUG(D_host_lookup)
1772 debug_printf("IP address lookup using gethostbyaddr()\n");
1773 rc = host_name_lookup_byaddr();
1776 host_lookup_deferred = TRUE;
1777 return rc; /* Can't carry on */
1779 if (rc == OK) break; /* Found a name */
1781 } /* Loop for bydns/byaddr scanning */
1783 /* If we have failed to find a name, return FAIL and log when required.
1784 NB host_lookup_msg must be in permanent store. */
1786 if (sender_host_name == NULL)
1788 if (host_checking || !log_testing_mode)
1789 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1790 "address %s", sender_host_address);
1791 host_lookup_msg = US" (failed to find host name from IP address)";
1792 host_lookup_failed = TRUE;
1796 HDEBUG(D_host_lookup)
1798 uschar **aliases = sender_host_aliases;
1799 debug_printf("IP address lookup yielded \"%s\"\n", sender_host_name);
1800 while (*aliases != NULL) debug_printf(" alias \"%s\"\n", *aliases++);
1803 /* We need to verify that a forward lookup on the name we found does indeed
1804 correspond to the address. This is for security: in principle a malefactor who
1805 happened to own a reverse zone could set it to point to any names at all.
1807 This code was present in versions of Exim before 3.20. At that point I took it
1808 out because I thought that gethostbyaddr() did the check anyway. It turns out
1809 that this isn't always the case, so it's coming back in at 4.01. This version
1810 is actually better, because it also checks aliases.
1812 The code was made more robust at release 4.21. Prior to that, it accepted all
1813 the names if any of them had the correct IP address. Now the code checks all
1814 the names, and accepts only those that have the correct IP address. */
1816 save_hostname = sender_host_name; /* Save for error messages */
1817 aliases = sender_host_aliases;
1818 for (hname = sender_host_name; hname != NULL; hname = *aliases++)
1828 /* When called with the last argument FALSE, host_find_byname() won't return
1829 HOST_FOUND_LOCAL. If the incoming address is an IPv4 address expressed in
1830 IPv6 format, we must compare the IPv4 part to any IPv4 addresses. */
1832 if ((rc = host_find_byname(&h, NULL, 0, NULL, FALSE)) == HOST_FOUND)
1835 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1836 for (hh = &h; hh != NULL; hh = hh->next)
1838 if (host_is_in_net(hh->address, sender_host_address, 0))
1840 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1846 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1849 if (!ok) HDEBUG(D_host_lookup)
1850 debug_printf("no IP address for %s matched %s\n", hname,
1851 sender_host_address);
1853 else if (rc == HOST_FIND_AGAIN)
1855 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1856 host_lookup_deferred = TRUE;
1857 sender_host_name = NULL;
1862 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1865 /* If this name is no good, and it's the sender name, set it null pro tem;
1866 if it's an alias, just remove it from the list. */
1870 if (hname == sender_host_name) sender_host_name = NULL; else
1872 uschar **a; /* Don't amalgamate - some */
1873 a = --aliases; /* compilers grumble */
1874 while (*a != NULL) { *a = a[1]; a++; }
1879 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1880 it with the first alias, if there is one. */
1882 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1883 sender_host_name = *sender_host_aliases++;
1885 /* If we now have a main name, all is well. */
1887 if (sender_host_name != NULL) return OK;
1889 /* We have failed to find an address that matches. */
1891 HDEBUG(D_host_lookup)
1892 debug_printf("%s does not match any IP address for %s\n",
1893 sender_host_address, save_hostname);
1895 /* This message must be in permanent store */
1897 old_pool = store_pool;
1898 store_pool = POOL_PERM;
1899 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1900 sender_host_address, save_hostname);
1901 store_pool = old_pool;
1902 host_lookup_failed = TRUE;
1909 /*************************************************
1910 * Find IP address(es) for host by name *
1911 *************************************************/
1913 /* The input is a host_item structure with the name filled in and the address
1914 field set to NULL. We use gethostbyname() or getipnodebyname() or
1915 gethostbyname2(), as appropriate. Of course, these functions may use the DNS,
1916 but they do not do MX processing. It appears, however, that in some systems the
1917 current setting of resolver options is used when one of these functions calls
1918 the resolver. For this reason, we call dns_init() at the start, with arguments
1919 influenced by bits in "flags", just as we do for host_find_bydns().
1921 The second argument provides a host list (usually an IP list) of hosts to
1922 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1923 addresses in unreasonable places.
1925 The lookup may result in a change of name. For compatibility with the dns
1926 lookup, return this via fully_qualified_name as well as updating the host item.
1927 The lookup may also yield more than one IP address, in which case chain on
1928 subsequent host_item structures.
1931 host a host item with the name and MX filled in;
1932 the address is to be filled in;
1933 multiple IP addresses cause other host items to be
1935 ignore_target_hosts a list of hosts to ignore
1936 flags HOST_FIND_QUALIFY_SINGLE ) passed to
1937 HOST_FIND_SEARCH_PARENTS ) dns_init()
1938 fully_qualified_name if not NULL, set to point to host name for
1939 compatibility with host_find_bydns
1940 local_host_check TRUE if a check for the local host is wanted
1942 Returns: HOST_FIND_FAILED Failed to find the host or domain
1943 HOST_FIND_AGAIN Try again later
1944 HOST_FOUND Host found - data filled in
1945 HOST_FOUND_LOCAL Host found and is the local host
1949 host_find_byname(host_item *host, const uschar *ignore_target_hosts, int flags,
1950 const uschar **fully_qualified_name, BOOL local_host_check)
1952 int i, yield, times;
1954 host_item *last = NULL;
1955 BOOL temp_error = FALSE;
1960 /* If we are in the test harness, a name ending in .test.again.dns always
1961 forces a temporary error response, unless the name is in
1962 dns_again_means_nonexist. */
1964 if (running_in_test_harness)
1966 const uschar *endname = host->name + Ustrlen(host->name);
1967 if (Ustrcmp(endname - 14, "test.again.dns") == 0) goto RETURN_AGAIN;
1970 /* Make sure DNS options are set as required. This appears to be necessary in
1971 some circumstances when the get..byname() function actually calls the DNS. */
1973 dns_init((flags & HOST_FIND_QUALIFY_SINGLE) != 0,
1974 (flags & HOST_FIND_SEARCH_PARENTS) != 0,
1975 FALSE); /*XXX dnssec? */
1977 /* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
1978 kinds of address, so go round the loop twice. Note that we have ensured that
1979 AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
1980 code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
1981 lookups here (except when testing standalone). */
1988 (dns_ipv4_lookup != NULL &&
1989 match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
1990 MCL_DOMAIN, TRUE, NULL) == OK))
1993 { af = AF_INET; times = 1; }
1995 { af = AF_INET6; times = 2; }
1997 /* No IPv6 support */
1999 #else /* HAVE_IPV6 */
2001 #endif /* HAVE_IPV6 */
2003 /* Initialize the flag that gets set for DNS syntax check errors, so that the
2004 interface to this function can be similar to host_find_bydns. */
2006 host_find_failed_syntax = FALSE;
2008 /* Loop to look up both kinds of address in an IPv6 world */
2010 for (i = 1; i <= times;
2012 af = AF_INET, /* If 2 passes, IPv4 on the second */
2018 struct hostent *hostdata;
2019 unsigned long time_msec;
2022 printf("Looking up: %s\n", host->name);
2025 if (slow_lookup_log) time_msec = get_time_in_ms();
2028 if (running_in_test_harness)
2029 hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2032 #if HAVE_GETIPNODEBYNAME
2033 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2035 hostdata = gethostbyname2(CS host->name, af);
2036 error_num = h_errno;
2040 #else /* not HAVE_IPV6 */
2041 if (running_in_test_harness)
2042 hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2045 hostdata = gethostbyname(CS host->name);
2046 error_num = h_errno;
2048 #endif /* HAVE_IPV6 */
2050 if ( slow_lookup_log
2051 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
2053 log_long_lookup(US"name", host->name, time_msec);
2055 if (hostdata == NULL)
2060 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
2061 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2062 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2063 case NO_DATA: error = US"NO_DATA"; break;
2064 #if NO_DATA != NO_ADDRESS
2065 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
2067 default: error = US"?"; break;
2070 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2072 #if HAVE_GETIPNODEBYNAME
2073 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2075 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2082 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2085 if ((hostdata->h_addr_list)[0] == NULL) continue;
2087 /* Replace the name with the fully qualified one if necessary, and fill in
2088 the fully_qualified_name pointer. */
2090 if (hostdata->h_name[0] != 0 &&
2091 Ustrcmp(host->name, hostdata->h_name) != 0)
2092 host->name = string_copy_dnsdomain((uschar *)hostdata->h_name);
2093 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2095 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2096 by their different lengths. Scan the list, ignoring any that are to be
2097 ignored, and build a chain from the rest. */
2099 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2101 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2103 uschar *text_address =
2104 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2107 if (ignore_target_hosts != NULL &&
2108 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2109 text_address, NULL) == OK)
2111 DEBUG(D_host_lookup)
2112 debug_printf("ignored host %s [%s]\n", host->name, text_address);
2117 /* If this is the first address, last == NULL and we put the data in the
2122 host->address = text_address;
2123 host->port = PORT_NONE;
2124 host->status = hstatus_unknown;
2125 host->why = hwhy_unknown;
2126 host->dnssec = DS_UNK;
2130 /* Else add further host item blocks for any other addresses, keeping
2135 host_item *next = store_get(sizeof(host_item));
2136 next->name = host->name;
2137 next->mx = host->mx;
2138 next->address = text_address;
2139 next->port = PORT_NONE;
2140 next->status = hstatus_unknown;
2141 next->why = hwhy_unknown;
2142 next->dnssec = DS_UNK;
2144 next->next = last->next;
2151 /* If no hosts were found, the address field in the original host block will be
2152 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2153 so we pass that back. */
2155 if (host->address == NULL)
2159 (message_id[0] == 0 && smtp_in != NULL)?
2160 string_sprintf("no IP address found for host %s (during %s)", host->name,
2161 smtp_get_connection_info()) :
2163 string_sprintf("no IP address found for host %s", host->name);
2165 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2166 if (temp_error) goto RETURN_AGAIN;
2167 if (host_checking || !log_testing_mode)
2168 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2169 return HOST_FIND_FAILED;
2172 /* Remove any duplicate IP addresses, then check to see if this is the local
2173 host if required. */
2175 host_remove_duplicates(host, &last);
2176 yield = local_host_check?
2177 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2179 HDEBUG(D_host_lookup)
2182 if (fully_qualified_name != NULL)
2183 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2184 debug_printf("%s looked up these IP addresses:\n",
2186 #if HAVE_GETIPNODEBYNAME
2195 for (h = host; h != last->next; h = h->next)
2196 debug_printf(" name=%s address=%s\n", h->name,
2197 (h->address == NULL)? US"<null>" : h->address);
2200 /* Return the found status. */
2204 /* Handle the case when there is a temporary error. If the name matches
2205 dns_again_means_nonexist, return permanent rather than temporary failure. */
2211 const uschar *save = deliver_domain;
2212 deliver_domain = host->name; /* set $domain */
2213 rc = match_isinlist(host->name, CUSS &dns_again_means_nonexist, 0, NULL, NULL,
2214 MCL_DOMAIN, TRUE, NULL);
2215 deliver_domain = save;
2218 DEBUG(D_host_lookup) debug_printf("%s is in dns_again_means_nonexist: "
2219 "returning HOST_FIND_FAILED\n", host->name);
2220 return HOST_FIND_FAILED;
2223 return HOST_FIND_AGAIN;
2229 /*************************************************
2230 * Fill in a host address from the DNS *
2231 *************************************************/
2233 /* Given a host item, with its name, port and mx fields set, and its address
2234 field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
2235 create additional host items for the additional addresses, copying all the
2236 other fields, and randomizing the order.
2238 On IPv6 systems, A6 records are sought first (but only if support for A6 is
2239 configured - they may never become mainstream), then AAAA records are sought,
2240 and finally A records are sought as well.
2242 The host name may be changed if the DNS returns a different name - e.g. fully
2243 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2244 ensures that it points to the fully qualified name. However, this is the fully
2245 qualified version of the original name; if a CNAME is involved, the actual
2246 canonical host name may be different again, and so we get it directly from the
2247 relevant RR. Note that we do NOT change the mx field of the host item in this
2248 function as it may be called to set the addresses of hosts taken from MX
2252 host points to the host item we're filling in
2253 lastptr points to pointer to last host item in a chain of
2254 host items (may be updated if host is last and gets
2255 extended because multihomed)
2256 ignore_target_hosts list of hosts to ignore
2257 allow_ip if TRUE, recognize an IP address and return it
2258 fully_qualified_name if not NULL, return fully qualified name here if
2259 the contents are different (i.e. it must be preset
2261 dnnssec_require if TRUE check the DNS result AD bit
2263 Returns: HOST_FIND_FAILED couldn't find A record
2264 HOST_FIND_AGAIN try again later
2265 HOST_FOUND found AAAA and/or A record(s)
2266 HOST_IGNORED found, but all IPs ignored
2270 set_address_from_dns(host_item *host, host_item **lastptr,
2271 const uschar *ignore_target_hosts, BOOL allow_ip,
2272 const uschar **fully_qualified_name,
2273 BOOL dnssec_request, BOOL dnssec_require)
2276 host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
2277 BOOL v6_find_again = FALSE;
2280 /* If allow_ip is set, a name which is an IP address returns that value
2281 as its address. This is used for MX records when allow_mx_to_ip is set, for
2282 those sites that feel they have to flaunt the RFC rules. */
2284 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2287 if (ignore_target_hosts != NULL &&
2288 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2289 host->name, NULL) == OK)
2290 return HOST_IGNORED;
2293 host->address = host->name;
2297 /* On an IPv6 system, unless IPv6 is disabled, go round the loop up to three
2298 times, looking for A6 and AAAA records the first two times. However, unless
2299 doing standalone testing, we force an IPv4 lookup if the domain matches
2300 dns_ipv4_lookup is set. Since A6 records look like being abandoned, support
2301 them only if explicitly configured to do so. On an IPv4 system, go round the
2302 loop once only, looking only for A records. */
2306 if (disable_ipv6 || (dns_ipv4_lookup != NULL &&
2307 match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
2308 MCL_DOMAIN, TRUE, NULL) == OK))
2309 i = 0; /* look up A records only */
2311 #endif /* STAND_ALONE */
2313 i = 1; /* look up AAAA and A records */
2315 /* The IPv4 world */
2317 #else /* HAVE_IPV6 */
2318 i = 0; /* look up A records only */
2319 #endif /* HAVE_IPV6 */
2323 static int types[] = { T_A, T_AAAA, T_A6 };
2324 int type = types[i];
2325 int randoffset = (i == 0)? 500 : 0; /* Ensures v6 sorts before v4 */
2329 int rc = dns_lookup_timerwrap(&dnsa, host->name, type, fully_qualified_name);
2330 lookup_dnssec_authenticated = !dnssec_request ? NULL
2331 : dns_is_secure(&dnsa) ? US"yes" : US"no";
2333 /* We want to return HOST_FIND_AGAIN if one of the A, A6, or AAAA lookups
2334 fails or times out, but not if another one succeeds. (In the early
2335 IPv6 days there are name servers that always fail on AAAA, but are happy
2336 to give out an A record. We want to proceed with that A record.) */
2338 if (rc != DNS_SUCCEED)
2340 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2342 if (host->address != NULL) return HOST_FOUND; /* A6 or AAAA was found */
2343 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2344 return HOST_FIND_AGAIN;
2345 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2348 /* Tried for an A6 or AAAA record: remember if this was a temporary
2349 error, and look for the next record type. */
2351 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2357 if (dns_is_secure(&dnsa))
2359 DEBUG(D_host_lookup) debug_printf("%s A DNSSEC\n", host->name);
2360 if (host->dnssec == DS_UNK) /* set in host_find_bydns() */
2361 host->dnssec = DS_YES;
2367 log_write(L_host_lookup_failed, LOG_MAIN,
2368 "dnssec fail on %s for %.256s",
2369 i>1 ? "A6" : i>0 ? "AAAA" : "A", host->name);
2372 if (host->dnssec == DS_YES) /* set in host_find_bydns() */
2374 DEBUG(D_host_lookup) debug_printf("%s A cancel DNSSEC\n", host->name);
2375 host->dnssec = DS_NO;
2376 lookup_dnssec_authenticated = US"no";
2381 /* Lookup succeeded: fill in the given host item with the first non-ignored
2382 address found; create additional items for any others. A single A6 record
2383 may generate more than one address. */
2385 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2387 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2389 if (rr->type == type)
2391 /* dns_address *da = dns_address_from_rr(&dnsa, rr); */
2394 da = dns_address_from_rr(&dnsa, rr);
2396 DEBUG(D_host_lookup)
2399 debug_printf("no addresses extracted from A6 RR for %s\n",
2403 /* This loop runs only once for A and AAAA records, but may run
2404 several times for an A6 record that generated multiple addresses. */
2406 for (; da != NULL; da = da->next)
2409 if (ignore_target_hosts != NULL &&
2410 verify_check_this_host(&ignore_target_hosts, NULL,
2411 host->name, da->address, NULL) == OK)
2413 DEBUG(D_host_lookup)
2414 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2419 /* If this is the first address, stick it in the given host block,
2420 and change the name if the returned RR has a different name. */
2422 if (thishostlast == NULL)
2424 if (strcmpic(host->name, rr->name) != 0)
2425 host->name = string_copy_dnsdomain(rr->name);
2426 host->address = da->address;
2427 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2428 host->status = hstatus_unknown;
2429 host->why = hwhy_unknown;
2430 thishostlast = host;
2433 /* Not the first address. Check for, and ignore, duplicates. Then
2434 insert in the chain at a random point. */
2441 /* End of our local chain is specified by "thishostlast". */
2443 for (next = host;; next = next->next)
2445 if (Ustrcmp(CS da->address, next->address) == 0) break;
2446 if (next == thishostlast) { next = NULL; break; }
2448 if (next != NULL) continue; /* With loop for next address */
2450 /* Not a duplicate */
2452 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2453 next = store_get(sizeof(host_item));
2455 /* New address goes first: insert the new block after the first one
2456 (so as not to disturb the original pointer) but put the new address
2457 in the original block. */
2459 if (new_sort_key < host->sort_key)
2461 *next = *host; /* Copies port */
2463 host->address = da->address;
2464 host->sort_key = new_sort_key;
2465 if (thishostlast == host) thishostlast = next; /* Local last */
2466 if (*lastptr == host) *lastptr = next; /* Global last */
2469 /* Otherwise scan down the addresses for this host to find the
2470 one to insert after. */
2474 host_item *h = host;
2475 while (h != thishostlast)
2477 if (new_sort_key < h->next->sort_key) break;
2480 *next = *h; /* Copies port */
2482 next->address = da->address;
2483 next->sort_key = new_sort_key;
2484 if (h == thishostlast) thishostlast = next; /* Local last */
2485 if (h == *lastptr) *lastptr = next; /* Global last */
2493 /* Control gets here only if the third lookup (the A record) succeeded.
2494 However, the address may not be filled in if it was ignored. */
2496 return (host->address == NULL)? HOST_IGNORED : HOST_FOUND;
2502 /*************************************************
2503 * Find IP addresses and host names via DNS *
2504 *************************************************/
2506 /* The input is a host_item structure with the name field filled in and the
2507 address field set to NULL. This may be in a chain of other host items. The
2508 lookup may result in more than one IP address, in which case we must created
2509 new host blocks for the additional addresses, and insert them into the chain.
2510 The original name may not be fully qualified. Use the fully_qualified_name
2511 argument to return the official name, as returned by the resolver.
2514 host point to initial host item
2515 ignore_target_hosts a list of hosts to ignore
2516 whichrrs flags indicating which RRs to look for:
2517 HOST_FIND_BY_SRV => look for SRV
2518 HOST_FIND_BY_MX => look for MX
2519 HOST_FIND_BY_A => look for A or AAAA
2520 also flags indicating how the lookup is done
2521 HOST_FIND_QUALIFY_SINGLE ) passed to the
2522 HOST_FIND_SEARCH_PARENTS ) resolver
2523 srv_service when SRV used, the service name
2524 srv_fail_domains DNS errors for these domains => assume nonexist
2525 mx_fail_domains DNS errors for these domains => assume nonexist
2526 dnssec_request_domains => make dnssec request
2527 dnssec_require_domains => ditto and nonexist failures
2528 fully_qualified_name if not NULL, return fully-qualified name
2529 removed set TRUE if local host was removed from the list
2531 Returns: HOST_FIND_FAILED Failed to find the host or domain;
2532 if there was a syntax error,
2533 host_find_failed_syntax is set.
2534 HOST_FIND_AGAIN Could not resolve at this time
2535 HOST_FOUND Host found
2536 HOST_FOUND_LOCAL The lowest MX record points to this
2537 machine, if MX records were found, or
2538 an A record that was found contains
2539 an address of the local host
2543 host_find_bydns(host_item *host, const uschar *ignore_target_hosts, int whichrrs,
2544 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2545 uschar *dnssec_request_domains, uschar *dnssec_require_domains,
2546 const uschar **fully_qualified_name, BOOL *removed)
2548 host_item *h, *last;
2555 BOOL dnssec_require = match_isinlist(host->name, CUSS &dnssec_require_domains,
2556 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
2557 BOOL dnssec_request = dnssec_require
2558 || match_isinlist(host->name, CUSS &dnssec_request_domains,
2559 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
2560 dnssec_status_t dnssec;
2562 /* Set the default fully qualified name to the incoming name, initialize the
2563 resolver if necessary, set up the relevant options, and initialize the flag
2564 that gets set for DNS syntax check errors. */
2566 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2567 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2568 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0,
2571 host_find_failed_syntax = FALSE;
2573 /* First, if requested, look for SRV records. The service name is given; we
2574 assume TCP progocol. DNS domain names are constrained to a maximum of 256
2575 characters, so the code below should be safe. */
2577 if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2580 uschar *temp_fully_qualified_name = buffer;
2583 (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2587 /* Search for SRV records. If the fully qualified name is different to
2588 the input name, pass back the new original domain, without the prepended
2592 lookup_dnssec_authenticated = NULL;
2593 rc = dns_lookup_timerwrap(&dnsa, buffer, ind_type, CUSS &temp_fully_qualified_name);
2597 if (dns_is_secure(&dnsa))
2598 { dnssec = DS_YES; lookup_dnssec_authenticated = US"yes"; }
2600 { dnssec = DS_NO; lookup_dnssec_authenticated = US"no"; }
2603 if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2604 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2606 /* On DNS failures, we give the "try again" error unless the domain is
2607 listed as one for which we continue. */
2609 if (rc == DNS_SUCCEED && dnssec_require && !dns_is_secure(&dnsa))
2611 log_write(L_host_lookup_failed, LOG_MAIN,
2612 "dnssec fail on SRV for %.256s", host->name);
2615 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2618 if (match_isinlist(host->name, CUSS &srv_fail_domains, 0, NULL, NULL,
2619 MCL_DOMAIN, TRUE, NULL) != OK)
2621 { yield = HOST_FIND_AGAIN; goto out; }
2622 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2623 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2627 /* If we did not find any SRV records, search the DNS for MX records, if
2628 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2629 domain, and there's no point in going on to look for address records with the
2630 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2631 records. On DNS failures, we give the "try again" error unless the domain is
2632 listed as one for which we continue. */
2634 if (rc != DNS_SUCCEED && (whichrrs & HOST_FIND_BY_MX) != 0)
2638 lookup_dnssec_authenticated = NULL;
2639 rc = dns_lookup_timerwrap(&dnsa, host->name, ind_type, fully_qualified_name);
2643 if (dns_is_secure(&dnsa))
2645 DEBUG(D_host_lookup) debug_printf("%s MX DNSSEC\n", host->name);
2646 dnssec = DS_YES; lookup_dnssec_authenticated = US"yes";
2650 dnssec = DS_NO; lookup_dnssec_authenticated = US"no";
2657 yield = HOST_FIND_FAILED; goto out;
2660 if (!dnssec_require || dns_is_secure(&dnsa))
2662 log_write(L_host_lookup_failed, LOG_MAIN,
2663 "dnssec fail on MX for %.256s", host->name);
2670 if (match_isinlist(host->name, CUSS &mx_fail_domains, 0, NULL, NULL,
2671 MCL_DOMAIN, TRUE, NULL) != OK)
2673 { yield = HOST_FIND_AGAIN; goto out; }
2674 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2675 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2680 /* If we haven't found anything yet, and we are requested to do so, try for an
2681 A or AAAA record. If we find it (or them) check to see that it isn't the local
2684 if (rc != DNS_SUCCEED)
2686 if ((whichrrs & HOST_FIND_BY_A) == 0)
2688 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2689 yield = HOST_FIND_FAILED;
2693 last = host; /* End of local chainlet */
2695 host->port = PORT_NONE;
2696 host->dnssec = DS_UNK;
2697 lookup_dnssec_authenticated = NULL;
2698 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2699 fully_qualified_name, dnssec_request, dnssec_require);
2701 /* If one or more address records have been found, check that none of them
2702 are local. Since we know the host items all have their IP addresses
2703 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2704 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2705 because set_address_from_dns() removes them. */
2707 if (rc == HOST_FOUND)
2708 rc = host_scan_for_local_hosts(host, &last, removed);
2710 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2712 DEBUG(D_host_lookup)
2715 if (host->address != NULL)
2717 if (fully_qualified_name != NULL)
2718 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2719 for (h = host; h != last->next; h = h->next)
2720 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2721 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2722 (h->status >= hstatus_unusable)? US"*" : US"");
2730 /* We have found one or more MX or SRV records. Sort them according to
2731 precedence. Put the data for the first one into the existing host block, and
2732 insert new host_item blocks into the chain for the remainder. For equal
2733 precedences one is supposed to randomize the order. To make this happen, the
2734 sorting is actually done on the MX value * 1000 + a random number. This is put
2735 into a host field called sort_key.
2737 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2738 IPv6 address in preference. At this stage, we don't know what kind of address
2739 the host has. We choose a random number < 500; if later we find an A record
2740 first, we add 500 to the random number. Then for any other address records, we
2741 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2744 At this point we remove any duplicates that point to the same host, retaining
2745 only the one with the lowest precedence. We cannot yet check for precedence
2746 greater than that of the local host, because that test cannot be properly done
2747 until the addresses have been found - an MX record may point to a name for this
2748 host which is not the primary hostname. */
2750 last = NULL; /* Indicates that not even the first item is filled yet */
2752 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2754 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2757 int weight = 0; /* For SRV records */
2758 int port = PORT_NONE;
2759 uschar *s; /* MUST be unsigned for GETSHORT */
2762 if (rr->type != ind_type) continue;
2764 GETSHORT(precedence, s); /* Pointer s is advanced */
2766 /* For MX records, we use a random "weight" which causes multiple records of
2767 the same precedence to sort randomly. */
2769 if (ind_type == T_MX)
2770 weight = random_number(500);
2772 /* SRV records are specified with a port and a weight. The weight is used
2773 in a special algorithm. However, to start with, we just use it to order the
2774 records of equal priority (precedence). */
2778 GETSHORT(weight, s);
2782 /* Get the name of the host pointed to. */
2784 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2785 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2787 /* Check that we haven't already got this host on the chain; if we have,
2788 keep only the lower precedence. This situation shouldn't occur, but you
2789 never know what junk might get into the DNS (and this case has been seen on
2790 more than one occasion). */
2792 if (last != NULL) /* This is not the first record */
2794 host_item *prev = NULL;
2796 for (h = host; h != last->next; prev = h, h = h->next)
2798 if (strcmpic(h->name, data) == 0)
2800 DEBUG(D_host_lookup)
2801 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2802 (precedence > h->mx)? precedence : h->mx);
2803 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2804 if (h == host) /* Override first item */
2807 host->sort_key = precedence * 1000 + weight;
2811 /* Unwanted host item is not the first in the chain, so we can get
2812 get rid of it by cutting it out. */
2814 prev->next = h->next;
2815 if (h == last) last = prev;
2821 /* If this is the first MX or SRV record, put the data into the existing host
2822 block. Otherwise, add a new block in the correct place; if it has to be
2823 before the first block, copy the first block's data to a new second block. */
2827 host->name = string_copy_dnsdomain(data);
2828 host->address = NULL;
2830 host->mx = precedence;
2831 host->sort_key = precedence * 1000 + weight;
2832 host->status = hstatus_unknown;
2833 host->why = hwhy_unknown;
2834 host->dnssec = dnssec;
2838 /* Make a new host item and seek the correct insertion place */
2842 int sort_key = precedence * 1000 + weight;
2843 host_item *next = store_get(sizeof(host_item));
2844 next->name = string_copy_dnsdomain(data);
2845 next->address = NULL;
2847 next->mx = precedence;
2848 next->sort_key = sort_key;
2849 next->status = hstatus_unknown;
2850 next->why = hwhy_unknown;
2851 next->dnssec = dnssec;
2854 /* Handle the case when we have to insert before the first item. */
2856 if (sort_key < host->sort_key)
2863 if (last == host) last = next;
2866 /* Else scan down the items we have inserted as part of this exercise;
2867 don't go further. */
2871 for (h = host; h != last; h = h->next)
2873 if (sort_key < h->next->sort_key)
2875 next->next = h->next;
2881 /* Join on after the last host item that's part of this
2882 processing if we haven't stopped sooner. */
2886 next->next = last->next;
2893 NEXT_MX_RR: continue;
2896 /* If the list of hosts was obtained from SRV records, there are two things to
2897 do. First, if there is only one host, and it's name is ".", it means there is
2898 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2899 priority according to their weights, using an algorithm that is defined in RFC
2900 2782. The hosts are currently sorted by priority and weight. For each priority
2901 group we have to pick off one host and put it first, and then repeat for any
2902 remaining in the same priority group. */
2904 if (ind_type == T_SRV)
2908 if (host == last && host->name[0] == 0)
2910 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2911 yield = HOST_FIND_FAILED;
2915 DEBUG(D_host_lookup)
2917 debug_printf("original ordering of hosts from SRV records:\n");
2918 for (h = host; h != last->next; h = h->next)
2919 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2922 for (pptr = &host, h = host; h != last; pptr = &(h->next), h = h->next)
2927 /* Find the last following host that has the same precedence. At the same
2928 time, compute the sum of the weights and the running totals. These can be
2929 stored in the sort_key field. */
2931 for (hh = h; hh != last; hh = hh->next)
2933 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2936 if (hh->mx != hh->next->mx) break;
2939 /* If there's more than one host at this precedence (priority), we need to
2940 pick one to go first. */
2946 int randomizer = random_number(sum + 1);
2948 for (ppptr = pptr, hhh = h;
2950 ppptr = &(hhh->next), hhh = hhh->next)
2952 if (hhh->sort_key >= randomizer) break;
2955 /* hhh now points to the host that should go first; ppptr points to the
2956 place that points to it. Unfortunately, if the start of the minilist is
2957 the start of the entire list, we can't just swap the items over, because
2958 we must not change the value of host, since it is passed in from outside.
2959 One day, this could perhaps be changed.
2961 The special case is fudged by putting the new item *second* in the chain,
2962 and then transferring the data between the first and second items. We
2963 can't just swap the first and the chosen item, because that would mean
2964 that an item with zero weight might no longer be first. */
2968 *ppptr = hhh->next; /* Cuts it out of the chain */
2972 host_item temp = *h;
2975 hhh->next = temp.next;
2981 hhh->next = h; /* The rest of the chain follows it */
2982 *pptr = hhh; /* It takes the place of h */
2983 h = hhh; /* It's now the start of this minilist */
2988 /* A host has been chosen to be first at this priority and h now points
2989 to this host. There may be others at the same priority, or others at a
2990 different priority. Before we leave this host, we need to put back a sort
2991 key of the traditional MX kind, in case this host is multihomed, because
2992 the sort key is used for ordering the multiple IP addresses. We do not need
2993 to ensure that these new sort keys actually reflect the order of the hosts,
2996 h->sort_key = h->mx * 1000 + random_number(500);
2997 } /* Move on to the next host */
3000 /* Now we have to find IP addresses for all the hosts. We have ensured above
3001 that the names in all the host items are unique. Before release 4.61 we used to
3002 process records from the additional section in the DNS packet that returned the
3003 MX or SRV records. However, a DNS name server is free to drop any resource
3004 records from the additional section. In theory, this has always been a
3005 potential problem, but it is exacerbated by the advent of IPv6. If a host had
3006 several IPv4 addresses and some were not in the additional section, at least
3007 Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
3008 and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
3009 connection, and never try an IPv4 address. When there was only IPv4
3010 connectivity, this was a disaster that did in practice occur.
3012 So, from release 4.61 onwards, we always search for A and AAAA records
3013 explicitly. The names shouldn't point to CNAMES, but we use the general lookup
3014 function that handles them, just in case. If any lookup gives a soft error,
3015 change the default yield.
3017 For these DNS lookups, we must disable qualify_single and search_parents;
3018 otherwise invalid host names obtained from MX or SRV records can cause trouble
3019 if they happen to match something local. */
3021 yield = HOST_FIND_FAILED; /* Default yield */
3022 dns_init(FALSE, FALSE, /* Disable qualify_single and search_parents */
3023 dnssec_request || dnssec_require);
3025 for (h = host; h != last->next; h = h->next)
3027 if (h->address != NULL) continue; /* Inserted by a multihomed host */
3028 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip,
3029 NULL, dnssec_request, dnssec_require);
3030 if (rc != HOST_FOUND)
3032 h->status = hstatus_unusable;
3033 if (rc == HOST_FIND_AGAIN)
3036 h->why = hwhy_deferred;
3039 h->why = (rc == HOST_IGNORED)? hwhy_ignored : hwhy_failed;
3043 /* Scan the list for any hosts that are marked unusable because they have
3044 been explicitly ignored, and remove them from the list, as if they did not
3045 exist. If we end up with just a single, ignored host, flatten its fields as if
3046 nothing was found. */
3048 if (ignore_target_hosts != NULL)
3050 host_item *prev = NULL;
3051 for (h = host; h != last->next; h = h->next)
3054 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
3056 else if (prev == NULL) /* First host is ignored */
3058 if (h != last) /* First is not last */
3060 if (h->next == last) last = h; /* Overwrite it with next */
3061 *h = *(h->next); /* and reprocess it. */
3062 goto REDO; /* C should have redo, like Perl */
3065 else /* Ignored host is not first - */
3067 prev->next = h->next;
3068 if (h == last) last = prev;
3072 if (host->why == hwhy_ignored) host->address = NULL;
3075 /* There is still one complication in the case of IPv6. Although the code above
3076 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3077 hosts, it doesn't do this for addresses that apply to different hosts with the
3078 same MX precedence, because the sorting on MX precedence happens first. So we
3079 have to make another pass to check for this case. We ensure that, within a
3080 single MX preference value, IPv6 addresses come first. This can separate the
3081 addresses of a multihomed host, but that should not matter. */
3084 if (h != last && !disable_ipv6)
3086 for (h = host; h != last; h = h->next)
3089 host_item *next = h->next;
3090 if (h->mx != next->mx || /* If next is different MX */
3091 h->address == NULL || /* OR this one is unset */
3092 Ustrchr(h->address, ':') != NULL || /* OR this one is IPv6 */
3093 (next->address != NULL &&
3094 Ustrchr(next->address, ':') == NULL)) /* OR next is IPv4 */
3095 continue; /* move on to next */
3096 temp = *h; /* otherwise, swap */
3097 temp.next = next->next;
3105 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3106 whose IP addresses are on the local host. If any are found, all hosts with the
3107 same or higher MX values are removed. However, if the local host has the lowest
3108 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3109 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3110 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3111 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3112 be HOST_FIND_FAILED. */
3114 host_remove_duplicates(host, &last);
3115 rc = host_scan_for_local_hosts(host, &last, removed);
3116 if (rc != HOST_FIND_FAILED) yield = rc;
3118 DEBUG(D_host_lookup)
3120 if (fully_qualified_name != NULL)
3121 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3122 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3123 (yield == HOST_FOUND)? "HOST_FOUND" :
3124 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
3125 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3126 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3128 for (h = host; h != last->next; h = h->next)
3130 debug_printf(" %s %s MX=%d %s", h->name,
3131 !h->address ? US"<null>" : h->address, h->mx,
3132 h->dnssec == DS_YES ? US"DNSSEC " : US"");
3133 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3134 if (h->status >= hstatus_unusable) debug_printf("*");
3141 dns_init(FALSE, FALSE, FALSE); /* clear the dnssec bit for getaddrbyname */
3145 /*************************************************
3146 **************************************************
3147 * Stand-alone test program *
3148 **************************************************
3149 *************************************************/
3153 int main(int argc, char **cargv)
3156 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
3157 BOOL byname = FALSE;
3158 BOOL qualify_single = TRUE;
3159 BOOL search_parents = FALSE;
3160 BOOL request_dnssec = FALSE;
3161 BOOL require_dnssec = FALSE;
3162 uschar **argv = USS cargv;
3165 disable_ipv6 = FALSE;
3166 primary_hostname = US"";
3167 store_pool = POOL_MAIN;
3168 debug_selector = D_host_lookup|D_interface;
3169 debug_file = stdout;
3170 debug_fd = fileno(debug_file);
3172 printf("Exim stand-alone host functions test\n");
3174 host_find_interfaces();
3175 debug_selector = D_host_lookup | D_dns;
3177 if (argc > 1) primary_hostname = argv[1];
3179 /* So that debug level changes can be done first */
3181 dns_init(qualify_single, search_parents, FALSE);
3183 printf("Testing host lookup\n");
3185 while (Ufgets(buffer, 256, stdin) != NULL)
3188 int len = Ustrlen(buffer);
3189 uschar *fully_qualified_name;
3191 while (len > 0 && isspace(buffer[len-1])) len--;
3194 if (Ustrcmp(buffer, "q") == 0) break;
3196 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3197 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3198 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3199 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3200 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3201 else if (Ustrcmp(buffer, "srv+a") == 0)
3202 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3203 else if (Ustrcmp(buffer, "srv+mx") == 0)
3204 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3205 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3206 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
3207 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3208 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3209 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3210 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3211 else if (Ustrcmp(buffer, "request_dnssec") == 0) request_dnssec = TRUE;
3212 else if (Ustrcmp(buffer, "no_request_dnssec") == 0) request_dnssec = FALSE;
3213 else if (Ustrcmp(buffer, "require_dnssec") == 0) require_dnssec = TRUE;
3214 else if (Ustrcmp(buffer, "no_reqiret_dnssec") == 0) require_dnssec = FALSE;
3215 else if (Ustrcmp(buffer, "test_harness") == 0)
3216 running_in_test_harness = !running_in_test_harness;
3217 else if (Ustrcmp(buffer, "ipv6") == 0) disable_ipv6 = !disable_ipv6;
3218 else if (Ustrcmp(buffer, "res_debug") == 0)
3220 _res.options ^= RES_DEBUG;
3222 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3224 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3225 _res.retrans = dns_retrans;
3227 else if (Ustrncmp(buffer, "retry", 5) == 0)
3229 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3230 _res.retry = dns_retry;
3234 int flags = whichrrs;
3240 h.status = hstatus_unknown;
3241 h.why = hwhy_unknown;
3244 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3245 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3248 ? host_find_byname(&h, NULL, flags, &fully_qualified_name, TRUE)
3249 : host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3250 request_dnssec ? &h.name : NULL,
3251 require_dnssec ? &h.name : NULL,
3252 &fully_qualified_name, NULL);
3254 if (rc == HOST_FIND_FAILED) printf("Failed\n");
3255 else if (rc == HOST_FIND_AGAIN) printf("Again\n");
3256 else if (rc == HOST_FOUND_LOCAL) printf("Local\n");
3262 printf("Testing host_aton\n");
3264 while (Ufgets(buffer, 256, stdin) != NULL)
3268 int len = Ustrlen(buffer);
3270 while (len > 0 && isspace(buffer[len-1])) len--;
3273 if (Ustrcmp(buffer, "q") == 0) break;
3275 len = host_aton(buffer, x);
3276 printf("length = %d ", len);
3277 for (i = 0; i < len; i++)
3279 printf("%04x ", (x[i] >> 16) & 0xffff);
3280 printf("%04x ", x[i] & 0xffff);
3287 printf("Testing host_name_lookup\n");
3289 while (Ufgets(buffer, 256, stdin) != NULL)
3291 int len = Ustrlen(buffer);
3292 while (len > 0 && isspace(buffer[len-1])) len--;
3294 if (Ustrcmp(buffer, "q") == 0) break;
3295 sender_host_address = buffer;
3296 sender_host_name = NULL;
3297 sender_host_aliases = NULL;
3298 host_lookup_msg = US"";
3299 host_lookup_failed = FALSE;
3300 if (host_name_lookup() == FAIL) /* Debug causes printing */
3301 printf("Lookup failed:%s\n", host_lookup_msg);
3309 #endif /* STAND_ALONE */