1 /* $Cambridge: exim/src/src/host.c,v 1.17 2005/11/11 10:02:04 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions for finding hosts, either by gethostbyname(), gethostbyaddr(), or
11 directly via the DNS. When IPv6 is supported, getipnodebyname() and
12 getipnodebyaddr() may be used instead of gethostbyname() and gethostbyaddr(),
13 if the newer functions are available. This module also contains various other
14 functions concerned with hosts and addresses, and a random number function,
15 used for randomizing hosts with equal MXs but available for use in other parts
22 /* Static variable for preserving the list of interface addresses in case it is
23 used more than once. */
25 static ip_address_item *local_interface_data = NULL;
28 #ifdef USE_INET_NTOA_FIX
29 /*************************************************
30 * Replacement for broken inet_ntoa() *
31 *************************************************/
33 /* On IRIX systems, gcc uses a different structure passing convention to the
34 native libraries. This causes inet_ntoa() to always yield 0.0.0.0 or
35 255.255.255.255. To get round this, we provide a private version of the
36 function here. It is used only if USE_INET_NTOA_FIX is set, which should happen
37 only when gcc is in use on an IRIX system. Code send to me by J.T. Breitner,
41 as seen in comp.sys.sgi.admin
43 August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
44 should now be set for them as well.
46 Arguments: sa an in_addr structure
47 Returns: pointer to static text string
51 inet_ntoa(struct in_addr sa)
53 static uschar addr[20];
54 sprintf(addr, "%d.%d.%d.%d",
65 /*************************************************
66 * Random number generator *
67 *************************************************/
69 /* This is a simple pseudo-random number generator. It does not have to be
70 very good for the uses to which it is put. When running the regression tests,
71 start with a fixed seed.
74 limit: one more than the largest number required
76 Returns: a pseudo-random number in the range 0 to limit-1
80 random_number(int limit)
84 if (running_in_test_harness) random_seed = 42; else
86 int p = (int)getpid();
87 random_seed = (int)time(NULL) ^ ((p << 16) | p);
90 random_seed = 1103515245 * random_seed + 12345;
91 return (unsigned int)(random_seed >> 16) % limit;
96 /*************************************************
97 * Sort addresses when testing *
98 *************************************************/
100 /* This function is called only when running in the test harness. It sorts a
101 number of multihomed host IP addresses into the order, so as to get
102 repeatability. This doesn't have to be efficient. But don't interchange IPv4
106 This sorting is not necessary for the new test harness, because it
107 doesn't call the real DNS resolver, and its output is repeatable. However,
108 until the old test harness is discarded, we need to retain this capability.
109 The new harness is being developed towards the end of 2005. It will be some
110 time before it can do everything that the old one can do.
113 host -> the first host item
114 last -> the last host item
120 sort_addresses(host_item *host, host_item *last)
127 for (h = host; h != last; h = h->next)
129 if ((Ustrchr(h->address, ':') == NULL) !=
130 (Ustrchr(h->next->address, ':') == NULL))
132 if (Ustrcmp(h->address, h->next->address) > 0)
134 uschar *temp = h->address;
135 h->address = h->next->address;
136 h->next->address = temp;
145 /*************************************************
146 * Replace gethostbyname() when testing *
147 *************************************************/
149 /* This function is called instead of gethostbyname(), gethostbyname2(), or
150 getipnodebyname() when running in the test harness. It recognizes the name
151 "manyhome.test.ex" and generates a humungous number of IP addresses. It also
152 recognizes an unqualified "localhost" and forces it to the appropriate loopback
153 address. IP addresses are treated as literals. For other names, it uses the DNS
154 to find the host name. In the new test harness, this means it will access only
155 the fake DNS resolver. In the old harness it will call the real resolver and
156 access the test zone.
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(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 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(&dnsa, lname, type, NULL);
272 case DNS_SUCCEED: break;
273 case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
274 case DNS_NODATA: *error_num = NO_DATA; return NULL;
275 case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
277 case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
280 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
282 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
284 if (rr->type == type) count++;
287 yield = store_get(sizeof(struct hostent));
288 alist = store_get((count + 1) * sizeof(char **));
289 adds = store_get(count *alen);
291 yield->h_name = CS name;
292 yield->h_aliases = NULL;
293 yield->h_addrtype = af;
294 yield->h_length = alen;
295 yield->h_addr_list = CSS alist;
297 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
299 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
304 if (rr->type != type) continue;
305 da = dns_address_from_rr(&dnsa, rr);
307 n = host_aton(da->address, x);
308 for (i = 0; i < n; i++)
311 *adds++ = (y >> 24) & 255;
312 *adds++ = (y >> 16) & 255;
313 *adds++ = (y >> 8) & 255;
325 /*************************************************
326 * Build chain of host items from list *
327 *************************************************/
329 /* This function builds a chain of host items from a textual list of host
330 names. It does not do any lookups. If randomize is true, the chain is build in
331 a randomized order. There may be multiple groups of independently randomized
332 hosts; they are delimited by a host name consisting of just "+".
335 anchor anchor for the chain
337 randomize TRUE for randomizing
343 host_build_hostlist(host_item **anchor, uschar *list, BOOL randomize)
346 int fake_mx = MX_NONE; /* This value is actually -1 */
350 if (list == NULL) return;
351 if (randomize) fake_mx--; /* Start at -2 for randomizing */
355 while ((name = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
359 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
360 { /* ignore if not randomizing */
361 if (randomize) fake_mx--;
365 h = store_get(sizeof(host_item));
366 h->name = string_copy(name);
370 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
371 h->status = hstatus_unknown;
372 h->why = hwhy_unknown;
382 host_item *hh = *anchor;
383 if (h->sort_key < hh->sort_key)
390 while (hh->next != NULL && h->sort_key >= (hh->next)->sort_key)
403 /*************************************************
404 * Extract port from address string *
405 *************************************************/
407 /* In the spool file, and in the -oMa and -oMi options, a host plus port is
408 given as an IP address followed by a dot and a port number. This function
411 An alternative format for the -oMa and -oMi options is [ip address]:port which
412 is what Exim 4 uses for output, because it seems to becoming commonly used,
413 whereas the dot form confuses some programs/people. So we recognize that form
417 address points to the string; if there is a port, the '.' in the string
418 is overwritten with zero to terminate the address; if the string
419 is in the [xxx]:ppp format, the address is shifted left and the
422 Returns: 0 if there is no port, else the port number. If there's a syntax
423 error, leave the incoming address alone, and return 0.
427 host_address_extract_port(uschar *address)
432 /* Handle the "bracketed with colon on the end" format */
436 uschar *rb = address + 1;
437 while (*rb != 0 && *rb != ']') rb++;
438 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
441 port = Ustrtol(rb + 1, &endptr, 10);
442 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
444 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
445 memmove(address, address + 1, rb - address - 2);
449 /* Handle the "dot on the end" format */
453 int skip = -3; /* Skip 3 dots in IPv4 addresses */
455 while (*(++address) != 0)
458 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
459 else if (ch == '.' && skip++ >= 0) break;
461 if (*address == 0) return 0;
462 port = Ustrtol(address + 1, &endptr, 10);
463 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
471 /*************************************************
472 * Get port from a host item's name *
473 *************************************************/
475 /* This function is called when finding the IP address for a host that is in a
476 list of hosts explicitly configured, such as in the manualroute router, or in a
477 fallback hosts list. We see if there is a port specification at the end of the
478 host name, and if so, remove it. A minimum length of 3 is required for the
479 original name; nothing shorter is recognized as having a port.
481 We test for a name ending with a sequence of digits; if preceded by colon we
482 have a port if the character before the colon is ] and the name starts with [
483 or if there are no other colons in the name (i.e. it's not an IPv6 address).
485 Arguments: pointer to the host item
486 Returns: a port number or PORT_NONE
490 host_item_get_port(host_item *h)
494 int len = Ustrlen(h->name);
496 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
498 /* Extract potential port number */
503 while (p > h->name + 1 && isdigit(*p))
505 port += (*p-- - '0') * x;
509 /* The smallest value of p at this point is h->name + 1. */
511 if (*p != ':') return PORT_NONE;
513 if (p[-1] == ']' && h->name[0] == '[')
514 h->name = string_copyn(h->name + 1, p - h->name - 2);
515 else if (Ustrchr(h->name, ':') == p)
516 h->name = string_copyn(h->name, p - h->name);
517 else return PORT_NONE;
519 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
525 #ifndef STAND_ALONE /* Omit when standalone testing */
527 /*************************************************
528 * Build sender_fullhost and sender_rcvhost *
529 *************************************************/
531 /* This function is called when sender_host_name and/or sender_helo_name
532 have been set. Or might have been set - for a local message read off the spool
533 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
536 (a) No sender_host_name or sender_helo_name: "[ip address]"
537 (b) Just sender_host_name: "host_name [ip address]"
538 (c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
539 in which case: "[ip address}"
540 (d) The two are identical: "host_name [ip address]" includes helo = IP
541 (e) The two are different: "host_name (helo_name) [ip address]"
543 If log_incoming_port is set, the sending host's port number is added to the IP
546 This function also builds sender_rcvhost for use in Received: lines, whose
547 syntax is a bit different. This value also includes the RFC 1413 identity.
548 There wouldn't be two different variables if I had got all this right in the
551 Because this data may survive over more than one incoming SMTP message, it has
552 to be in permanent store.
559 host_build_sender_fullhost(void)
561 BOOL show_helo = TRUE;
564 int old_pool = store_pool;
566 if (sender_host_address == NULL) return;
568 store_pool = POOL_PERM;
570 /* Set up address, with or without the port. After discussion, it seems that
571 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
572 use this directly as the first item for Received: because it ain't an RFC 2822
575 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
576 if ((log_extra_selector & LX_incoming_port) == 0 || sender_host_port <= 0)
577 *(Ustrrchr(address, ':')) = 0;
579 /* If there's no EHLO/HELO data, we can't show it. */
581 if (sender_helo_name == NULL) show_helo = FALSE;
583 /* If HELO/EHLO was followed by an IP literal, it's messy because of two
584 features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
585 doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
586 be given in canonical form, so we have to canonicize them before comparing. As
587 it happens, the code works for both IPv4 and IPv6. */
589 else if (sender_helo_name[0] == '[' &&
590 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
595 if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
596 if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
598 helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
600 if (string_is_ip_address(helo_ip, NULL) != 0)
604 uschar ipx[48], ipy[48]; /* large enough for full IPv6 */
606 sizex = host_aton(helo_ip, x);
607 sizey = host_aton(sender_host_address, y);
609 (void)host_nmtoa(sizex, x, -1, ipx, ':');
610 (void)host_nmtoa(sizey, y, -1, ipy, ':');
612 if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
616 /* Host name is not verified */
618 if (sender_host_name == NULL)
620 uschar *portptr = Ustrstr(address, "]:");
623 int adlen; /* Sun compiler doesn't like ++ in initializers */
625 adlen = (portptr == NULL)? Ustrlen(address) : (++portptr - address);
626 sender_fullhost = (sender_helo_name == NULL)? address :
627 string_sprintf("(%s) %s", sender_helo_name, address);
629 sender_rcvhost = string_cat(NULL, &size, &ptr, address, adlen);
631 if (sender_ident != NULL || show_helo || portptr != NULL)
634 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US" (", 2);
638 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2, US"port=",
642 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
643 (firstptr == ptr)? US"helo=" : US" helo=", sender_helo_name);
645 if (sender_ident != NULL)
646 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
647 (firstptr == ptr)? US"ident=" : US" ident=", sender_ident);
649 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US")", 1);
652 sender_rcvhost[ptr] = 0; /* string_cat() always leaves room */
654 /* Release store, because string_cat allocated a minimum of 100 bytes that
655 are rarely completely used. */
657 store_reset(sender_rcvhost + ptr + 1);
660 /* Host name is known and verified. Unless we've already found that the HELO
661 data matches the IP address, compare it with the name. */
665 if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
670 sender_fullhost = string_sprintf("%s (%s) %s", sender_host_name,
671 sender_helo_name, address);
672 sender_rcvhost = (sender_ident == NULL)?
673 string_sprintf("%s (%s helo=%s)", sender_host_name,
674 address, sender_helo_name) :
675 string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
676 address, sender_helo_name, sender_ident);
680 sender_fullhost = string_sprintf("%s %s", sender_host_name, address);
681 sender_rcvhost = (sender_ident == NULL)?
682 string_sprintf("%s (%s)", sender_host_name, address) :
683 string_sprintf("%s (%s ident=%s)", sender_host_name, address,
688 store_pool = old_pool;
690 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
691 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
696 /*************************************************
697 * Build host+ident message *
698 *************************************************/
700 /* Used when logging rejections and various ACL and SMTP incidents. The text
701 return depends on whether sender_fullhost and sender_ident are set or not:
703 no ident, no host => U=unknown
704 no ident, host set => H=sender_fullhost
705 ident set, no host => U=ident
706 ident set, host set => H=sender_fullhost U=ident
709 useflag TRUE if first item to be flagged (H= or U=); if there are two
710 items, the second is always flagged
712 Returns: pointer to a string in big_buffer
716 host_and_ident(BOOL useflag)
718 if (sender_fullhost == NULL)
720 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag? "U=" : "",
721 (sender_ident == NULL)? US"unknown" : sender_ident);
725 uschar *flag = useflag? US"H=" : US"";
726 uschar *iface = US"";
727 if ((log_extra_selector & LX_incoming_interface) != 0 &&
728 interface_address != NULL)
729 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
730 if (sender_ident == NULL)
731 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
732 flag, sender_fullhost, iface);
734 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
735 flag, sender_fullhost, iface, sender_ident);
740 #endif /* STAND_ALONE */
745 /*************************************************
746 * Build list of local interfaces *
747 *************************************************/
749 /* This function interprets the contents of the local_interfaces or
750 extra_local_interfaces options, and creates an ip_address_item block for each
751 item on the list. There is no special interpretation of any IP addresses; in
752 particular, 0.0.0.0 and ::0 are returned without modification. If any address
753 includes a port, it is set in the block. Otherwise the port value is set to
758 name the name of the option being expanded
760 Returns: a chain of ip_address_items, each containing to a textual
761 version of an IP address, and a port number (host order) or
762 zero if no port was given with the address
766 host_build_ifacelist(uschar *list, uschar *name)
771 ip_address_item *yield = NULL;
772 ip_address_item *last = NULL;
773 ip_address_item *next;
775 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
777 int port = host_address_extract_port(s); /* Leaves just the IP address */
778 if (string_is_ip_address(s, NULL) == 0)
779 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
782 /* This use of strcpy() is OK because we have checked that s is a valid IP
783 address above. The field in the ip_address_item is large enough to hold an
786 next = store_get(sizeof(ip_address_item));
788 Ustrcpy(next->address, s);
790 next->v6_include_v4 = FALSE;
792 if (yield == NULL) yield = last = next; else
806 /*************************************************
807 * Find addresses on local interfaces *
808 *************************************************/
810 /* This function finds the addresses of local IP interfaces. These are used
811 when testing for routing to the local host. As the function may be called more
812 than once, the list is preserved in permanent store, pointed to by a static
813 variable, to save doing the work more than once per process.
815 The generic list of interfaces is obtained by calling host_build_ifacelist()
816 for local_interfaces and extra_local_interfaces. This list scanned to remove
817 duplicates (which may exist with different ports - not relevant here). If
818 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
819 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
820 obtained from os_find_running_interfaces().
823 Returns: a chain of ip_address_items, each containing to a textual
824 version of an IP address; the port numbers are not relevant
828 /* First, a local subfunction to add an interface to a list in permanent store,
829 but only if there isn't a previous copy of that address on the list. */
831 static ip_address_item *
832 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
834 ip_address_item *ipa2;
835 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
836 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
837 ipa2 = store_get_perm(sizeof(ip_address_item));
844 /* This is the globally visible function */
847 host_find_interfaces(void)
849 ip_address_item *running_interfaces = NULL;
851 if (local_interface_data == NULL)
853 void *reset_item = store_get(0);
854 ip_address_item *dlist = host_build_ifacelist(local_interfaces,
855 US"local_interfaces");
856 ip_address_item *xlist = host_build_ifacelist(extra_local_interfaces,
857 US"extra_local_interfaces");
858 ip_address_item *ipa;
860 if (dlist == NULL) dlist = xlist; else
862 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
866 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
868 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
869 Ustrcmp(ipa->address, "::0") == 0)
871 ip_address_item *ipa2;
872 BOOL ipv6 = ipa->address[0] == ':';
873 if (running_interfaces == NULL)
874 running_interfaces = os_find_running_interfaces();
875 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
877 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
878 local_interface_data = add_unique_interface(local_interface_data,
884 local_interface_data = add_unique_interface(local_interface_data, ipa);
887 debug_printf("Configured local interface: address=%s", ipa->address);
888 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
893 store_reset(reset_item);
896 return local_interface_data;
903 /*************************************************
904 * Convert network IP address to text *
905 *************************************************/
907 /* Given an IPv4 or IPv6 address in binary, convert it to a text
908 string and return the result in a piece of new store. The address can
909 either be given directly, or passed over in a sockaddr structure. Note
910 that this isn't the converse of host_aton() because of byte ordering
911 differences. See host_nmtoa() below.
914 type if < 0 then arg points to a sockaddr, else
915 either AF_INET or AF_INET6
916 arg points to a sockaddr if type is < 0, or
917 points to an IPv4 address (32 bits), or
918 points to an IPv6 address (128 bits),
919 in both cases, in network byte order
920 buffer if NULL, the result is returned in gotten store;
921 else points to a buffer to hold the answer
922 portptr points to where to put the port number, if non NULL; only
925 Returns: pointer to character string
929 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
933 /* The new world. It is annoying that we have to fish out the address from
934 different places in the block, depending on what kind of address it is. It
935 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
936 function inet_ntoa() returns just uschar *, and some picky compilers insist
937 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
940 uschar addr_buffer[46];
943 int family = ((struct sockaddr *)arg)->sa_family;
944 if (family == AF_INET6)
946 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
947 yield = (uschar *)inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
948 sizeof(addr_buffer));
949 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
953 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
954 yield = (uschar *)inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
955 sizeof(addr_buffer));
956 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
961 yield = (uschar *)inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
964 /* If the result is a mapped IPv4 address, show it in V4 format. */
966 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
968 #else /* HAVE_IPV6 */
974 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
975 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
978 yield = US inet_ntoa(*((struct in_addr *)arg));
981 /* If there is no buffer, put the string into some new store. */
983 if (buffer == NULL) return string_copy(yield);
985 /* Callers of this function with a non-NULL buffer must ensure that it is
986 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
987 makes this use of strcpy() OK. */
989 Ustrcpy(buffer, yield);
996 /*************************************************
997 * Convert address text to binary *
998 *************************************************/
1000 /* Given the textual form of an IP address, convert it to binary in an
1001 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
1002 The result has the first byte in the most significant byte of the first int. In
1003 other words, the result is not in network byte order, but in host byte order.
1004 As a result, this is not the converse of host_ntoa(), which expects network
1005 byte order. See host_nmtoa() below.
1008 address points to the textual address, checked for syntax
1009 bin points to an array of 4 ints
1011 Returns: the number of ints used
1015 host_aton(uschar *address, int *bin)
1020 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
1021 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
1022 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
1025 if (Ustrchr(address, ':') != NULL)
1027 uschar *p = address;
1028 uschar *component[8];
1029 BOOL ipv4_ends = FALSE;
1035 /* If the address starts with a colon, it will start with two colons.
1036 Just lose the first one, which will leave a null first component. */
1040 /* Split the address into components separated by colons. The input address
1041 is supposed to be checked for syntax. There was a case where this was
1042 overlooked; to guard against that happening again, check here and crash if
1043 there are too many components. */
1045 while (*p != 0 && *p != '%')
1047 int len = Ustrcspn(p, ":%");
1048 if (len == 0) nulloffset = ci;
1049 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1050 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
1052 component[ci++] = p;
1057 /* If the final component contains a dot, it is a trailing v4 address.
1058 As the syntax is known to be checked, just set up for a trailing
1059 v4 address and restrict the v6 part to 6 components. */
1061 if (Ustrchr(component[ci-1], '.') != NULL)
1063 address = component[--ci];
1069 /* If there are fewer than 6 or 8 components, we have to insert some
1070 more empty ones in the middle. */
1074 int insert_count = v6count - ci;
1075 for (i = v6count-1; i > nulloffset + insert_count; i--)
1076 component[i] = component[i - insert_count];
1077 while (i > nulloffset) component[i--] = US"";
1080 /* Now turn the components into binary in pairs and bung them
1081 into the vector of ints. */
1083 for (i = 0; i < v6count; i += 2)
1084 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1085 Ustrtol(component[i+1], NULL, 16);
1087 /* If there was no terminating v4 component, we are done. */
1089 if (!ipv4_ends) return 4;
1092 /* Handle IPv4 address */
1094 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
1095 bin[v4offset] = (x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
1100 /*************************************************
1101 * Apply mask to an IP address *
1102 *************************************************/
1104 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1108 count the number of ints
1109 binary points to the ints to be masked
1110 mask the count of ms bits to leave, or -1 if no masking
1116 host_mask(int count, int *binary, int mask)
1119 if (mask < 0) mask = 99999;
1120 for (i = 0; i < count; i++)
1123 if (mask == 0) wordmask = 0;
1126 wordmask = (-1) << (32 - mask);
1134 binary[i] &= wordmask;
1141 /*************************************************
1142 * Convert masked IP address in ints to text *
1143 *************************************************/
1145 /* We can't use host_ntoa() because it assumes the binary values are in network
1146 byte order, and these are the result of host_aton(), which puts them in ints in
1147 host byte order. Also, we really want IPv6 addresses to be in a canonical
1148 format, so we output them with no abbreviation. In a number of cases we can't
1149 use the normal colon separator in them because it terminates keys in lsearch
1150 files, so we want to use dot instead. There's an argument that specifies what
1151 to use for IPv6 addresses.
1154 count 1 or 4 (number of ints)
1155 binary points to the ints
1156 mask mask value; if < 0 don't add to result
1157 buffer big enough to hold the result
1158 sep component separator character for IPv6 addresses
1160 Returns: the number of characters placed in buffer, not counting
1165 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1168 uschar *tt = buffer;
1173 for (i = 24; i >= 0; i -= 8)
1175 sprintf(CS tt, "%d.", (j >> i) & 255);
1181 for (i = 0; i < 4; i++)
1184 sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1189 tt--; /* lose final separator */
1195 sprintf(CS tt, "/%d", mask);
1204 /*************************************************
1205 * Check port for tls_on_connect *
1206 *************************************************/
1208 /* This function checks whether a given incoming port is configured for tls-
1209 on-connect. It is called from the daemon and from inetd handling. If the global
1210 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1211 check the tls_on_connect_ports option for a list of ports.
1213 Argument: a port number
1214 Returns: TRUE or FALSE
1218 host_is_tls_on_connect_port(int port)
1222 uschar *list = tls_on_connect_ports;
1225 if (tls_on_connect) return TRUE;
1227 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1230 int lport = Ustrtol(s, &end, 10);
1231 if (*end != 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "tls_on_connect_ports "
1232 "contains \"%s\", which is not a port number: exim abandoned", s);
1233 if (lport == port) return TRUE;
1241 /*************************************************
1242 * Check whether host is in a network *
1243 *************************************************/
1245 /* This function checks whether a given IP address matches a pattern that
1246 represents either a single host, or a network (using CIDR notation). The caller
1247 of this function must check the syntax of the arguments before calling it.
1250 host string representation of the ip-address to check
1251 net string representation of the network, with optional CIDR mask
1252 maskoffset offset to the / that introduces the mask in the key
1253 zero if there is no mask
1256 TRUE the host is inside the network
1257 FALSE the host is NOT inside the network
1261 host_is_in_net(uschar *host, uschar *net, int maskoffset)
1267 int size = host_aton(net, address);
1270 /* No mask => all bits to be checked */
1272 if (maskoffset == 0) mlen = 99999; /* Big number */
1273 else mlen = Uatoi(net + maskoffset + 1);
1275 /* Convert the incoming address to binary. */
1277 insize = host_aton(host, incoming);
1279 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1280 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1281 ::ffff:<v4address>, to IPv4 format. */
1283 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1284 incoming[2] == 0xffff)
1287 incoming[0] = incoming[3];
1290 /* No match if the sizes don't agree. */
1292 if (insize != size) return FALSE;
1294 /* Else do the masked comparison. */
1296 for (i = 0; i < size; i++)
1299 if (mlen == 0) mask = 0;
1302 mask = (-1) << (32 - mlen);
1310 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1318 /*************************************************
1319 * Scan host list for local hosts *
1320 *************************************************/
1322 /* Scan through a chain of addresses and check whether any of them is the
1323 address of an interface on the local machine. If so, remove that address and
1324 any previous ones with the same MX value, and all subsequent ones (which will
1325 have greater or equal MX values) from the chain. Note: marking them as unusable
1326 is NOT the right thing to do because it causes the hosts not to be used for
1327 other domains, for which they may well be correct.
1329 The hosts may be part of a longer chain; we only process those between the
1330 initial pointer and the "last" pointer.
1332 There is also a list of "pseudo-local" host names which are checked against the
1333 host names. Any match causes that host item to be treated the same as one which
1334 matches a local IP address.
1336 If the very first host is a local host, then all MX records had a precedence
1337 greater than or equal to that of the local host. Either there's a problem in
1338 the DNS, or an apparently remote name turned out to be an abbreviation for the
1339 local host. Give a specific return code, and let the caller decide what to do.
1340 Otherwise, give a success code if at least one host address has been found.
1343 host pointer to the first host in the chain
1344 lastptr pointer to pointer to the last host in the chain (may be updated)
1345 removed if not NULL, set TRUE if some local addresses were removed
1349 HOST_FOUND if there is at least one host with an IP address on the chain
1350 and an MX value less than any MX value associated with the
1352 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1353 the host addresses were obtained from A records or
1354 gethostbyname(), the MX values are set to -1.
1355 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1359 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1361 int yield = HOST_FIND_FAILED;
1362 host_item *last = *lastptr;
1363 host_item *prev = NULL;
1366 if (removed != NULL) *removed = FALSE;
1368 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1370 for (h = host; h != last->next; h = h->next)
1373 if (hosts_treat_as_local != NULL)
1376 uschar *save = deliver_domain;
1377 deliver_domain = h->name; /* set $domain */
1378 rc = match_isinlist(string_copylc(h->name), &hosts_treat_as_local, 0,
1379 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1380 deliver_domain = save;
1381 if (rc == OK) goto FOUND_LOCAL;
1385 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1386 for 127.0.0.1 and refers to the local host. We therefore force it always to
1387 be treated as local. */
1389 if (h->address != NULL)
1391 ip_address_item *ip;
1392 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1393 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1394 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1395 yield = HOST_FOUND; /* At least one remote address has been found */
1398 /* Update prev to point to the last host item before any that have
1399 the same MX value as the one we have just considered. */
1401 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1404 return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1406 /* A host whose IP address matches a local IP address, or whose name matches
1407 something in hosts_treat_as_local has been found. */
1413 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1414 "local host has lowest MX\n" :
1415 "local host found for non-MX address\n");
1416 return HOST_FOUND_LOCAL;
1419 HDEBUG(D_host_lookup)
1421 debug_printf("local host in host list - removed hosts:\n");
1422 for (h = prev->next; h != last->next; h = h->next)
1423 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1426 if (removed != NULL) *removed = TRUE;
1427 prev->next = last->next;
1435 /*************************************************
1436 * Remove duplicate IPs in host list *
1437 *************************************************/
1439 /* You would think that administrators could set up their DNS records so that
1440 one ended up with a list of unique IP addresses after looking up A or MX
1441 records, but apparently duplication is common. So we scan such lists and
1442 remove the later duplicates. Note that we may get lists in which some host
1443 addresses are not set.
1446 host pointer to the first host in the chain
1447 lastptr pointer to pointer to the last host in the chain (may be updated)
1453 host_remove_duplicates(host_item *host, host_item **lastptr)
1455 while (host != *lastptr)
1457 if (host->address != NULL)
1459 host_item *h = host;
1460 while (h != *lastptr)
1462 if (h->next->address != NULL &&
1463 Ustrcmp(h->next->address, host->address) == 0)
1465 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1466 "removed\n", host->address, h->next->mx);
1467 if (h->next == *lastptr) *lastptr = h;
1468 h->next = h->next->next;
1473 /* If the last item was removed, host may have become == *lastptr */
1474 if (host != *lastptr) host = host->next;
1481 /*************************************************
1482 * Find sender host name by gethostbyaddr() *
1483 *************************************************/
1485 /* This used to be the only way it was done, but it turns out that not all
1486 systems give aliases for calls to gethostbyaddr() - or one of the modern
1487 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1488 but they can still exist. This function is now used only when a DNS lookup of
1489 the IP address fails, in order to give access to /etc/hosts.
1492 Returns: OK, DEFER, FAIL
1496 host_name_lookup_byaddr(void)
1500 struct hostent *hosts;
1501 struct in_addr addr;
1503 /* Lookup on IPv6 system */
1506 if (Ustrchr(sender_host_address, ':') != NULL)
1508 struct in6_addr addr6;
1509 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1510 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1511 "IPv6 address", sender_host_address);
1512 #if HAVE_GETIPNODEBYADDR
1513 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1515 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1520 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1521 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1522 "IPv4 address", sender_host_address);
1523 #if HAVE_GETIPNODEBYADDR
1524 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1526 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1530 /* Do lookup on IPv4 system */
1533 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1534 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1537 /* Failed to look up the host. */
1541 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1543 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1546 /* It seems there are some records in the DNS that yield an empty name. We
1547 treat this as non-existent. In some operating systems, this is returned as an
1548 empty string; in others as a single dot. */
1550 if (hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1552 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1553 "treated as non-existent host name\n");
1557 /* Copy and lowercase the name, which is in static storage in many systems.
1558 Put it in permanent memory. */
1560 s = (uschar *)hosts->h_name;
1561 len = Ustrlen(s) + 1;
1562 t = sender_host_name = store_get_perm(len);
1563 while (*s != 0) *t++ = tolower(*s++);
1566 /* If the host has aliases, build a copy of the alias list */
1568 if (hosts->h_aliases != NULL)
1571 uschar **aliases, **ptr;
1572 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1573 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1574 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1576 uschar *s = *aliases;
1577 int len = Ustrlen(s) + 1;
1578 uschar *t = *ptr++ = store_get_perm(len);
1579 while (*s != 0) *t++ = tolower(*s++);
1590 /*************************************************
1591 * Find host name for incoming call *
1592 *************************************************/
1594 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1595 up a list of alias names, pointed to by sender_host_alias. The list is
1596 NULL-terminated. The incoming address is in sender_host_address, either in
1597 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1599 This function does a thorough check that the names it finds point back to the
1600 incoming IP address. Any that do not are discarded. Note that this is relied on
1601 by the ACL reverse_host_lookup check.
1603 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1604 this it not universally true. Also, for release 4.30, this function was changed
1605 to do a direct DNS lookup first, by default[1], because it turns out that that
1606 is the only guaranteed way to find all the aliases on some systems. My
1607 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1610 [1] The actual order is controlled by the host_lookup_order option.
1613 Returns: OK on success, the answer being placed in the global variable
1614 sender_host_name, with any aliases in a list hung off
1616 FAIL if no host name can be found
1617 DEFER if a temporary error was encountered
1619 The variable host_lookup_msg is set to an empty string on sucess, or to a
1620 reason for the failure otherwise, in a form suitable for tagging onto an error
1621 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1622 was a defer, host_lookup_deferred is set TRUE.
1624 Any dynamically constructed string for host_lookup_msg must be in permanent
1625 store, because it might be used for several incoming messages on the same SMTP
1629 host_name_lookup(void)
1633 uschar *hname, *save_hostname;
1637 uschar *list = host_lookup_order;
1642 host_lookup_deferred = host_lookup_failed = FALSE;
1644 HDEBUG(D_host_lookup)
1645 debug_printf("looking up host name for %s\n", sender_host_address);
1647 /* For testing the case when a lookup does not complete, we have a special
1648 reserved IP address. */
1650 if (running_in_test_harness &&
1651 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1653 HDEBUG(D_host_lookup)
1654 debug_printf("Test harness: host name lookup returns DEFER\n");
1655 host_lookup_deferred = TRUE;
1659 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1660 the order specified by the host_lookup_order option. */
1662 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1665 if (strcmpic(ordername, US"bydns") == 0)
1667 dns_init(FALSE, FALSE);
1668 dns_build_reverse(sender_host_address, buffer);
1669 rc = dns_lookup(&dnsa, buffer, T_PTR, NULL);
1671 /* The first record we come across is used for the name; others are
1672 considered to be aliases. We have to scan twice, in order to find out the
1673 number of aliases. However, if all the names are empty, we will behave as
1674 if failure. (PTR records that yield empty names have been encountered in
1677 if (rc == DNS_SUCCEED)
1679 uschar **aptr = NULL;
1682 int old_pool = store_pool;
1684 store_pool = POOL_PERM; /* Save names in permanent storage */
1686 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1688 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1690 if (rr->type == T_PTR) count++;
1693 /* Get store for the list of aliases. For compatibility with
1694 gethostbyaddr, we make an empty list if there are none. */
1696 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1698 /* Re-scan and extract the names */
1700 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1702 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1705 if (rr->type != T_PTR) continue;
1706 s = store_get(ssize);
1708 /* If an overlong response was received, the data will have been
1709 truncated and dn_expand may fail. */
1711 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1712 (uschar *)(rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1714 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1715 sender_host_address);
1719 store_reset(s + Ustrlen(s) + 1);
1722 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1723 "empty name: treated as non-existent host name\n");
1726 if (sender_host_name == NULL) sender_host_name = s;
1728 while (*s != 0) { *s = tolower(*s); s++; }
1731 *aptr = NULL; /* End of alias list */
1732 store_pool = old_pool; /* Reset store pool */
1734 /* If we've found a names, break out of the "order" loop */
1736 if (sender_host_name != NULL) break;
1739 /* If the DNS lookup deferred, we must also defer. */
1741 if (rc == DNS_AGAIN)
1743 HDEBUG(D_host_lookup)
1744 debug_printf("IP address PTR lookup gave temporary error\n");
1745 host_lookup_deferred = TRUE;
1750 /* Do a lookup using gethostbyaddr() - or equivalent */
1752 else if (strcmpic(ordername, US"byaddr") == 0)
1754 HDEBUG(D_host_lookup)
1755 debug_printf("IP address lookup using gethostbyaddr()\n");
1756 rc = host_name_lookup_byaddr();
1759 host_lookup_deferred = TRUE;
1760 return rc; /* Can't carry on */
1762 if (rc == OK) break; /* Found a name */
1764 } /* Loop for bydns/byaddr scanning */
1766 /* If we have failed to find a name, return FAIL and log when required.
1767 NB host_lookup_msg must be in permanent store. */
1769 if (sender_host_name == NULL)
1771 if (host_checking || !log_testing_mode)
1772 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1773 "address %s", sender_host_address);
1774 host_lookup_msg = US" (failed to find host name from IP address)";
1775 host_lookup_failed = TRUE;
1779 /* We have a host name. If we are running in the test harness, we want the host
1780 name and its alias to appear always the same way round. There are only ever two
1781 names in these tests. If one of them contains "alias", make sure it is second;
1782 otherwise put them in alphabetical order. */
1784 if (running_in_test_harness && *sender_host_aliases != NULL &&
1786 Ustrstr(sender_host_name, "alias") != NULL ||
1788 Ustrstr(*sender_host_aliases, "alias") == NULL &&
1789 Ustrcmp(sender_host_name, *sender_host_aliases) > 0
1793 uschar *temp = sender_host_name;
1794 sender_host_name = *sender_host_aliases;
1795 *sender_host_aliases = temp;
1798 /* Debug output what was found, after test harness swapping, for consistency */
1800 HDEBUG(D_host_lookup)
1802 uschar **aliases = sender_host_aliases;
1803 debug_printf("IP address lookup yielded %s\n", sender_host_name);
1804 while (*aliases != NULL) debug_printf(" alias %s\n", *aliases++);
1807 /* We need to verify that a forward lookup on the name we found does indeed
1808 correspond to the address. This is for security: in principle a malefactor who
1809 happened to own a reverse zone could set it to point to any names at all.
1811 This code was present in versions of Exim before 3.20. At that point I took it
1812 out because I thought that gethostbyaddr() did the check anyway. It turns out
1813 that this isn't always the case, so it's coming back in at 4.01. This version
1814 is actually better, because it also checks aliases.
1816 The code was made more robust at release 4.21. Prior to that, it accepted all
1817 the names if any of them had the correct IP address. Now the code checks all
1818 the names, and accepts only those that have the correct IP address. */
1820 save_hostname = sender_host_name; /* Save for error messages */
1821 aliases = sender_host_aliases;
1822 for (hname = sender_host_name; hname != NULL; hname = *aliases++)
1832 /* When called with the 5th argument FALSE, host_find_byname() won't return
1833 HOST_FOUND_LOCAL. If the incoming address is an IPv4 address expressed in
1834 IPv6 format, we must compare the IPv4 part to any IPv4 addresses. */
1836 if ((rc = host_find_byname(&h, NULL, NULL, FALSE)) == HOST_FOUND)
1839 uschar *address_ipv4 = (Ustrncmp(sender_host_address, "::ffff:", 7) == 0)?
1840 sender_host_address + 7 : sender_host_address;
1841 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1842 for (hh = &h; hh != NULL; hh = hh->next)
1844 if ((Ustrcmp(hh->address, (Ustrchr(hh->address, ':') == NULL)?
1845 address_ipv4 : sender_host_address)) == 0)
1847 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1853 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1856 if (!ok) HDEBUG(D_host_lookup)
1857 debug_printf("no IP address for %s matched %s\n", hname,
1858 sender_host_address);
1860 else if (rc == HOST_FIND_AGAIN)
1862 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1863 host_lookup_deferred = TRUE;
1868 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1871 /* If this name is no good, and it's the sender name, set it null pro tem;
1872 if it's an alias, just remove it from the list. */
1876 if (hname == sender_host_name) sender_host_name = NULL; else
1878 uschar **a; /* Don't amalgamate - some */
1879 a = --aliases; /* compilers grumble */
1880 while (*a != NULL) { *a = a[1]; a++; }
1885 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1886 it with the first alias, if there is one. */
1888 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1889 sender_host_name = *sender_host_aliases++;
1891 /* If we now have a main name, all is well. */
1893 if (sender_host_name != NULL) return OK;
1895 /* We have failed to find an address that matches. */
1897 HDEBUG(D_host_lookup)
1898 debug_printf("%s does not match any IP address for %s\n",
1899 sender_host_address, save_hostname);
1901 /* This message must be in permanent store */
1903 old_pool = store_pool;
1904 store_pool = POOL_PERM;
1905 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1906 sender_host_address, save_hostname);
1907 store_pool = old_pool;
1908 host_lookup_failed = TRUE;
1915 /*************************************************
1916 * Find IP address(es) for host by name *
1917 *************************************************/
1919 /* The input is a host_item structure with the name filled in and the address
1920 field set to NULL. We use gethostbyname(). Of course, gethostbyname() may use
1921 the DNS, but it doesn't do MX processing. If more than one address is given,
1922 chain on additional host items, with other relevant fields copied.
1924 The second argument provides a host list (usually an IP list) of hosts to
1925 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1926 addresses in unreasonable places.
1928 The lookup may result in a change of name. For compatibility with the dns
1929 lookup, return this via fully_qualified_name as well as updating the host item.
1930 The lookup may also yield more than one IP address, in which case chain on
1931 subsequent host_item structures.
1934 host a host item with the name and MX filled in;
1935 the address is to be filled in;
1936 multiple IP addresses cause other host items to be
1938 ignore_target_hosts a list of hosts to ignore
1939 fully_qualified_name if not NULL, set to point to host name for
1940 compatibility with host_find_bydns
1941 local_host_check TRUE if a check for the local host is wanted
1943 Returns: HOST_FIND_FAILED Failed to find the host or domain
1944 HOST_FIND_AGAIN Try again later
1945 HOST_FOUND Host found - data filled in
1946 HOST_FOUND_LOCAL Host found and is the local host
1950 host_find_byname(host_item *host, uschar *ignore_target_hosts,
1951 uschar **fully_qualified_name, BOOL local_host_check)
1953 int i, yield, times;
1955 host_item *last = NULL;
1956 BOOL temp_error = FALSE;
1961 /* If we are in the test harness, a name ending in .test.again.dns always
1962 forces a temporary error response. */
1964 if (running_in_test_harness)
1966 uschar *endname = host->name + Ustrlen(host->name);
1967 if (Ustrcmp(endname - 14, "test.again.dns") == 0)
1968 return HOST_FIND_AGAIN;
1971 /* In an IPv6 world, we need to scan for both kinds of address, so go round the
1972 loop twice. Note that we have ensured that AF_INET6 is defined even in an IPv4
1973 world, which makes for slightly tidier code. However, if dns_ipv4_lookup
1974 matches the domain, we also just do IPv4 lookups here (except when testing
1979 if (dns_ipv4_lookup != NULL &&
1980 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
1982 { af = AF_INET; times = 1; }
1984 #endif /* STAND_ALONE */
1986 { af = AF_INET6; times = 2; }
1988 /* No IPv6 support */
1990 #else /* HAVE_IPV6 */
1992 #endif /* HAVE_IPV6 */
1994 /* Initialize the flag that gets set for DNS syntax check errors, so that the
1995 interface to this function can be similar to host_find_bydns. */
1997 host_find_failed_syntax = FALSE;
1999 /* Loop to look up both kinds of address in an IPv6 world */
2001 for (i = 1; i <= times;
2003 af = AF_INET, /* If 2 passes, IPv4 on the second */
2009 struct hostent *hostdata;
2012 if (running_in_test_harness)
2013 hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2016 #if HAVE_GETIPNODEBYNAME
2017 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2019 hostdata = gethostbyname2(CS host->name, af);
2020 error_num = h_errno;
2024 #else /* not HAVE_IPV6 */
2025 if (running_in_test_harness)
2026 hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2029 hostdata = gethostbyname(CS host->name);
2030 error_num = h_errno;
2032 #endif /* HAVE_IPV6 */
2034 if (hostdata == NULL)
2039 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
2040 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2041 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2042 case NO_DATA: error = US"NO_DATA"; break;
2043 #if NO_DATA != NO_ADDRESS
2044 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
2046 default: error = US"?"; break;
2049 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2051 #if HAVE_GETIPNODEBYNAME
2052 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2054 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2061 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2064 if ((hostdata->h_addr_list)[0] == NULL) continue;
2066 /* Replace the name with the fully qualified one if necessary, and fill in
2067 the fully_qualified_name pointer. */
2069 if (hostdata->h_name[0] != 0 &&
2070 Ustrcmp(host->name, hostdata->h_name) != 0)
2071 host->name = string_copy_dnsdomain((uschar *)hostdata->h_name);
2072 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2074 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2075 by their different lengths. Scan the list, ignoring any that are to be
2076 ignored, and build a chain from the rest. */
2078 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2080 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2082 uschar *text_address =
2083 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2086 if (ignore_target_hosts != NULL &&
2087 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2088 text_address, NULL) == OK)
2090 DEBUG(D_host_lookup)
2091 debug_printf("ignored host %s [%s]\n", host->name, text_address);
2096 /* If this is the first address, last == NULL and we put the data in the
2101 host->address = text_address;
2102 host->port = PORT_NONE;
2103 host->status = hstatus_unknown;
2104 host->why = hwhy_unknown;
2108 /* Else add further host item blocks for any other addresses, keeping
2113 host_item *next = store_get(sizeof(host_item));
2114 next->name = host->name;
2115 next->mx = host->mx;
2116 next->address = text_address;
2117 next->port = PORT_NONE;
2118 next->status = hstatus_unknown;
2119 next->why = hwhy_unknown;
2121 next->next = last->next;
2128 /* If no hosts were found, the address field in the original host block will be
2129 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2130 so we pass that back. */
2132 if (host->address == NULL)
2136 (message_id[0] == 0 && smtp_in != NULL)?
2137 string_sprintf("no IP address found for host %s (during %s)", host->name,
2138 smtp_get_connection_info()) :
2140 string_sprintf("no IP address found for host %s", host->name);
2142 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2143 if (temp_error) return HOST_FIND_AGAIN;
2144 if (host_checking || !log_testing_mode)
2145 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2146 return HOST_FIND_FAILED;
2149 /* Remove any duplicate IP addresses, then check to see if this is the local
2150 host if required. */
2152 host_remove_duplicates(host, &last);
2153 yield = local_host_check?
2154 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2156 /* When running in the test harness, sort into the order of addresses so as to
2157 get repeatability. */
2159 if (running_in_test_harness) sort_addresses(host, last);
2161 HDEBUG(D_host_lookup)
2164 if (fully_qualified_name != NULL)
2165 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2166 debug_printf("%s looked up these IP addresses:\n",
2168 #if HAVE_GETIPNODEBYNAME
2177 for (h = host; h != last->next; h = h->next)
2178 debug_printf(" name=%s address=%s\n", h->name,
2179 (h->address == NULL)? US"<null>" : h->address);
2182 /* Return the found status. */
2189 /*************************************************
2190 * Fill in a host address from the DNS *
2191 *************************************************/
2193 /* Given a host item, with its name and mx fields set, and its address field
2194 set to NULL, fill in its IP address from the DNS. If it is multi-homed, create
2195 additional host items for the additional addresses, copying all the other
2196 fields, and randomizing the order.
2198 On IPv6 systems, A6 records are sought first (but only if support for A6 is
2199 configured - they may never become mainstream), then AAAA records are sought,
2200 and finally A records are sought as well.
2202 The host name may be changed if the DNS returns a different name - e.g. fully
2203 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2204 ensures that it points to the fully qualified name. However, this is the fully
2205 qualified version of the original name; if a CNAME is involved, the actual
2206 canonical host name may be different again, and so we get it directly from the
2207 relevant RR. Note that we do NOT change the mx field of the host item in this
2208 function as it may be called to set the addresses of hosts taken from MX
2212 host points to the host item we're filling in
2213 lastptr points to pointer to last host item in a chain of
2214 host items (may be updated if host is last and gets
2215 extended because multihomed)
2216 ignore_target_hosts list of hosts to ignore
2217 allow_ip if TRUE, recognize an IP address and return it
2218 fully_qualified_name if not NULL, return fully qualified name here if
2219 the contents are different (i.e. it must be preset
2222 Returns: HOST_FIND_FAILED couldn't find A record
2223 HOST_FIND_AGAIN try again later
2224 HOST_FOUND found AAAA and/or A record(s)
2225 HOST_IGNORED found, but all IPs ignored
2229 set_address_from_dns(host_item *host, host_item **lastptr,
2230 uschar *ignore_target_hosts, BOOL allow_ip, uschar **fully_qualified_name)
2233 host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
2234 BOOL v6_find_again = FALSE;
2237 /* If allow_ip is set, a name which is an IP address returns that value
2238 as its address. This is used for MX records when allow_mx_to_ip is set, for
2239 those sites that feel they have to flaunt the RFC rules. */
2241 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2244 if (ignore_target_hosts != NULL &&
2245 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2246 host->name, NULL) == OK)
2247 return HOST_IGNORED;
2250 host->address = host->name;
2251 host->port = PORT_NONE;
2255 /* On an IPv6 system, go round the loop up to three times, looking for A6 and
2256 AAAA records the first two times. However, unless doing standalone testing, we
2257 force an IPv4 lookup if the domain matches dns_ipv4_lookup is set. Since A6
2258 records look like being abandoned, support them only if explicitly configured
2259 to do so. On an IPv4 system, go round the loop once only, looking only for A
2264 if (dns_ipv4_lookup != NULL &&
2265 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2267 i = 0; /* look up A records only */
2269 #endif /* STAND_ALONE */
2272 i = 2; /* look up A6 and AAAA and A records */
2274 i = 1; /* look up AAAA and A records */
2275 #endif /* SUPPORT_A6 */
2277 /* The IPv4 world */
2279 #else /* HAVE_IPV6 */
2280 i = 0; /* look up A records only */
2281 #endif /* HAVE_IPV6 */
2285 static int types[] = { T_A, T_AAAA, T_A6 };
2286 int type = types[i];
2287 int randoffset = (i == 0)? 500 : 0; /* Ensures v6 sorts before v4 */
2291 int rc = dns_lookup(&dnsa, host->name, type, fully_qualified_name);
2293 /* We want to return HOST_FIND_AGAIN if one of the A, A6, or AAAA lookups
2294 fails or times out, but not if another one succeeds. (In the early
2295 IPv6 days there are name servers that always fail on AAAA, but are happy
2296 to give out an A record. We want to proceed with that A record.) */
2298 if (rc != DNS_SUCCEED)
2300 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2302 if (host->address != NULL) return HOST_FOUND; /* A6 or AAAA was found */
2303 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2304 return HOST_FIND_AGAIN;
2305 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2308 /* Tried for an A6 or AAAA record: remember if this was a temporary
2309 error, and look for the next record type. */
2311 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2315 /* Lookup succeeded: fill in the given host item with the first non-ignored
2316 address found; create additional items for any others. A single A6 record
2317 may generate more than one address. */
2319 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2321 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2323 if (rr->type == type)
2325 /* dns_address *da = dns_address_from_rr(&dnsa, rr); */
2328 da = dns_address_from_rr(&dnsa, rr);
2330 DEBUG(D_host_lookup)
2333 debug_printf("no addresses extracted from A6 RR for %s\n",
2337 /* This loop runs only once for A and AAAA records, but may run
2338 several times for an A6 record that generated multiple addresses. */
2340 for (; da != NULL; da = da->next)
2343 if (ignore_target_hosts != NULL &&
2344 verify_check_this_host(&ignore_target_hosts, NULL,
2345 host->name, da->address, NULL) == OK)
2347 DEBUG(D_host_lookup)
2348 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2353 /* If this is the first address, stick it in the given host block,
2354 and change the name if the returned RR has a different name. */
2356 if (thishostlast == NULL)
2358 if (strcmpic(host->name, rr->name) != 0)
2359 host->name = string_copy_dnsdomain(rr->name);
2360 host->address = da->address;
2361 host->port = PORT_NONE;
2362 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2363 host->status = hstatus_unknown;
2364 host->why = hwhy_unknown;
2365 thishostlast = host;
2368 /* Not the first address. Check for, and ignore, duplicates. Then
2369 insert in the chain at a random point. */
2376 /* End of our local chain is specified by "thishostlast". */
2378 for (next = host;; next = next->next)
2380 if (Ustrcmp(CS da->address, next->address) == 0) break;
2381 if (next == thishostlast) { next = NULL; break; }
2383 if (next != NULL) continue; /* With loop for next address */
2385 /* Not a duplicate */
2387 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2388 next = store_get(sizeof(host_item));
2390 /* New address goes first: insert the new block after the first one
2391 (so as not to disturb the original pointer) but put the new address
2392 in the original block. */
2394 if (new_sort_key < host->sort_key)
2398 host->address = da->address;
2399 host->port = PORT_NONE;
2400 host->sort_key = new_sort_key;
2401 if (thishostlast == host) thishostlast = next; /* Local last */
2402 if (*lastptr == host) *lastptr = next; /* Global last */
2405 /* Otherwise scan down the addresses for this host to find the
2406 one to insert after. */
2410 host_item *h = host;
2411 while (h != thishostlast)
2413 if (new_sort_key < h->next->sort_key) break;
2418 next->address = da->address;
2419 next->port = PORT_NONE;
2420 next->sort_key = new_sort_key;
2421 if (h == thishostlast) thishostlast = next; /* Local last */
2422 if (h == *lastptr) *lastptr = next; /* Global last */
2430 /* Control gets here only if the third lookup (the A record) succeeded.
2431 However, the address may not be filled in if it was ignored. */
2433 return (host->address == NULL)? HOST_IGNORED : HOST_FOUND;
2439 /*************************************************
2440 * Find IP addresses and names for host via DNS *
2441 *************************************************/
2443 /* The input is a host_item structure with the name filled in and the address
2444 field set to NULL. This may be in a chain of other host items. The lookup may
2445 result in more than one IP address, in which case we must created new host
2446 blocks for the additional addresses, and insert them into the chain. The
2447 original name may not be fully qualified. Use the fully_qualified_name argument
2448 to return the official name, as returned by the resolver.
2451 host point to initial host item
2452 ignore_target_hosts a list of hosts to ignore
2453 whichrrs flags indicating which RRs to look for:
2454 HOST_FIND_BY_SRV => look for SRV
2455 HOST_FIND_BY_MX => look for MX
2456 HOST_FIND_BY_A => look for A or AAAA
2457 also flags indicating how the lookup is done
2458 HOST_FIND_QUALIFY_SINGLE ) passed to the
2459 HOST_FIND_SEARCH_PARENTS ) resolver
2460 srv_service when SRV used, the service name
2461 srv_fail_domains DNS errors for these domains => assume nonexist
2462 mx_fail_domains DNS errors for these domains => assume nonexist
2463 fully_qualified_name if not NULL, return fully-qualified name
2464 removed set TRUE if local host was removed from the list
2466 Returns: HOST_FIND_FAILED Failed to find the host or domain;
2467 if there was a syntax error,
2468 host_find_failed_syntax is set.
2469 HOST_FIND_AGAIN Could not resolve at this time
2470 HOST_FOUND Host found
2471 HOST_FOUND_LOCAL The lowest MX record points to this
2472 machine, if MX records were found, or
2473 an A record that was found contains
2474 an address of the local host
2478 host_find_bydns(host_item *host, uschar *ignore_target_hosts, int whichrrs,
2479 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2480 uschar **fully_qualified_name, BOOL *removed)
2482 host_item *h, *last;
2490 /* Set the default fully qualified name to the incoming name, initialize the
2491 resolver if necessary, set up the relevant options, and initialize the flag
2492 that gets set for DNS syntax check errors. */
2494 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2495 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2496 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0);
2497 host_find_failed_syntax = FALSE;
2499 /* First, if requested, look for SRV records. The service name is given; we
2500 assume TCP progocol. DNS domain names are constrained to a maximum of 256
2501 characters, so the code below should be safe. */
2503 if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2506 uschar *temp_fully_qualified_name = buffer;
2509 (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2513 /* Search for SRV records. If the fully qualified name is different to
2514 the input name, pass back the new original domain, without the prepended
2517 rc = dns_lookup(&dnsa, buffer, ind_type, &temp_fully_qualified_name);
2518 if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2519 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2521 /* On DNS failures, we give the "try again" error unless the domain is
2522 listed as one for which we continue. */
2524 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2527 if (match_isinlist(host->name, &srv_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2530 return HOST_FIND_AGAIN;
2531 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2532 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2536 /* If we did not find any SRV records, search the DNS for MX records, if
2537 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2538 domain, and there's no point in going on to look for address records with the
2539 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2540 records. On DNS failures, we give the "try again" error unless the domain is
2541 listed as one for which we continue. */
2543 if (rc != DNS_SUCCEED && (whichrrs & HOST_FIND_BY_MX) != 0)
2546 rc = dns_lookup(&dnsa, host->name, ind_type, fully_qualified_name);
2547 if (rc == DNS_NOMATCH) return HOST_FIND_FAILED;
2548 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2551 if (match_isinlist(host->name, &mx_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2554 return HOST_FIND_AGAIN;
2555 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2556 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2560 /* If we haven't found anything yet, and we are requested to do so, try for an
2561 A or AAAA record. If we find it (or them) check to see that it isn't the local
2564 if (rc != DNS_SUCCEED)
2566 if ((whichrrs & HOST_FIND_BY_A) == 0)
2568 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2569 return HOST_FIND_FAILED;
2572 last = host; /* End of local chainlet */
2574 host->port = PORT_NONE;
2575 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2576 fully_qualified_name);
2578 /* If one or more address records have been found, check that none of them
2579 are local. Since we know the host items all have their IP addresses
2580 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2581 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2582 because set_address_from_dns() removes them. */
2584 if (rc == HOST_FOUND)
2585 rc = host_scan_for_local_hosts(host, &last, removed);
2587 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2589 /* When running in the test harness, sort into the order of addresses so as
2590 to get repeatability. */
2592 if (running_in_test_harness) sort_addresses(host, last);
2594 DEBUG(D_host_lookup)
2597 if (host->address != NULL)
2599 if (fully_qualified_name != NULL)
2600 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2601 for (h = host; h != last->next; h = h->next)
2602 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2603 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2604 (h->status >= hstatus_unusable)? US"*" : US"");
2611 /* We have found one or more MX or SRV records. Sort them according to
2612 precedence. Put the data for the first one into the existing host block, and
2613 insert new host_item blocks into the chain for the remainder. For equal
2614 precedences one is supposed to randomize the order. To make this happen, the
2615 sorting is actually done on the MX value * 1000 + a random number. This is put
2616 into a host field called sort_key.
2618 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2619 IPv6 address in preference. At this stage, we don't know what kind of address
2620 the host has. We choose a random number < 500; if later we find an A record
2621 first, we add 500 to the random number. Then for any other address records, we
2622 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2625 At this point we remove any duplicates that point to the same host, retaining
2626 only the one with the lowest precedence. We cannot yet check for precedence
2627 greater than that of the local host, because that test cannot be properly done
2628 until the addresses have been found - an MX record may point to a name for this
2629 host which is not the primary hostname. */
2631 last = NULL; /* Indicates that not even the first item is filled yet */
2633 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2635 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2638 int weight = 0; /* For SRV records */
2639 int port = PORT_NONE; /* For SRV records */
2640 uschar *s; /* MUST be unsigned for GETSHORT */
2643 if (rr->type != ind_type) continue;
2645 GETSHORT(precedence, s); /* Pointer s is advanced */
2647 /* For MX records, we use a random "weight" which causes multiple records of
2648 the same precedence to sort randomly. */
2650 if (ind_type == T_MX)
2652 weight = random_number(500);
2655 /* SRV records are specified with a port and a weight. The weight is used
2656 in a special algorithm. However, to start with, we just use it to order the
2657 records of equal priority (precedence). */
2661 GETSHORT(weight, s);
2665 /* Get the name of the host pointed to. */
2667 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2668 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2670 /* Check that we haven't already got this host on the chain; if we have,
2671 keep only the lower precedence. This situation shouldn't occur, but you
2672 never know what junk might get into the DNS (and this case has been seen on
2673 more than one occasion). */
2675 if (last != NULL) /* This is not the first record */
2677 host_item *prev = NULL;
2679 for (h = host; h != last->next; prev = h, h = h->next)
2681 if (strcmpic(h->name, data) == 0)
2683 DEBUG(D_host_lookup)
2684 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2685 (precedence > h->mx)? precedence : h->mx);
2686 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2687 if (h == host) /* Override first item */
2690 host->sort_key = precedence * 1000 + weight;
2694 /* Unwanted host item is not the first in the chain, so we can get
2695 get rid of it by cutting it out. */
2697 prev->next = h->next;
2698 if (h == last) last = prev;
2704 /* If this is the first MX or SRV record, put the data into the existing host
2705 block. Otherwise, add a new block in the correct place; if it has to be
2706 before the first block, copy the first block's data to a new second block. */
2710 host->name = string_copy_dnsdomain(data);
2711 host->address = NULL;
2713 host->mx = precedence;
2714 host->sort_key = precedence * 1000 + weight;
2715 host->status = hstatus_unknown;
2716 host->why = hwhy_unknown;
2720 /* Make a new host item and seek the correct insertion place */
2724 int sort_key = precedence * 1000 + weight;
2725 host_item *next = store_get(sizeof(host_item));
2726 next->name = string_copy_dnsdomain(data);
2727 next->address = NULL;
2729 next->mx = precedence;
2730 next->sort_key = sort_key;
2731 next->status = hstatus_unknown;
2732 next->why = hwhy_unknown;
2735 /* Handle the case when we have to insert before the first item. */
2737 if (sort_key < host->sort_key)
2744 if (last == host) last = next;
2747 /* Else scan down the items we have inserted as part of this exercise;
2748 don't go further. */
2752 for (h = host; h != last; h = h->next)
2754 if (sort_key < h->next->sort_key)
2756 next->next = h->next;
2762 /* Join on after the last host item that's part of this
2763 processing if we haven't stopped sooner. */
2767 next->next = last->next;
2774 NEXT_MX_RR: continue;
2777 /* If the list of hosts was obtained from SRV records, there are two things to
2778 do. First, if there is only one host, and it's name is ".", it means there is
2779 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2780 priority according to their weights, using an algorithm that is defined in RFC
2781 2782. The hosts are currently sorted by priority and weight. For each priority
2782 group we have to pick off one host and put it first, and then repeat for any
2783 remaining in the same priority group. */
2785 if (ind_type == T_SRV)
2789 if (host == last && host->name[0] == 0)
2791 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2792 return HOST_FIND_FAILED;
2795 DEBUG(D_host_lookup)
2797 debug_printf("original ordering of hosts from SRV records:\n");
2798 for (h = host; h != last->next; h = h->next)
2799 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2802 for (pptr = &host, h = host; h != last; pptr = &(h->next), h = h->next)
2807 /* Find the last following host that has the same precedence. At the same
2808 time, compute the sum of the weights and the running totals. These can be
2809 stored in the sort_key field. */
2811 for (hh = h; hh != last; hh = hh->next)
2813 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2816 if (hh->mx != hh->next->mx) break;
2819 /* If there's more than one host at this precedence (priority), we need to
2820 pick one to go first. */
2826 int randomizer = random_number(sum + 1);
2828 for (ppptr = pptr, hhh = h;
2830 ppptr = &(hhh->next), hhh = hhh->next)
2832 if (hhh->sort_key >= randomizer) break;
2835 /* hhh now points to the host that should go first; ppptr points to the
2836 place that points to it. Unfortunately, if the start of the minilist is
2837 the start of the entire list, we can't just swap the items over, because
2838 we must not change the value of host, since it is passed in from outside.
2839 One day, this could perhaps be changed.
2841 The special case is fudged by putting the new item *second* in the chain,
2842 and then transferring the data between the first and second items. We
2843 can't just swap the first and the chosen item, because that would mean
2844 that an item with zero weight might no longer be first. */
2848 *ppptr = hhh->next; /* Cuts it out of the chain */
2852 host_item temp = *h;
2855 hhh->next = temp.next;
2861 hhh->next = h; /* The rest of the chain follows it */
2862 *pptr = hhh; /* It takes the place of h */
2863 h = hhh; /* It's now the start of this minilist */
2868 /* A host has been chosen to be first at this priority and h now points
2869 to this host. There may be others at the same priority, or others at a
2870 different priority. Before we leave this host, we need to put back a sort
2871 key of the traditional MX kind, in case this host is multihomed, because
2872 the sort key is used for ordering the multiple IP addresses. We do not need
2873 to ensure that these new sort keys actually reflect the order of the hosts,
2876 h->sort_key = h->mx * 1000 + random_number(500);
2877 } /* Move on to the next host */
2880 /* Now we have to ensure addresses exist for all the hosts. We have ensured
2881 above that the names in the host items are all unique. The addresses may have
2882 been returned in the additional data section of the DNS query. Because it is
2883 more expensive to scan the returned DNS records (because you have to expand the
2884 names) we do a single scan over them, and multiple scans of the chain of host
2885 items (which is typically only 3 or 4 long anyway.) Add extra host items for
2886 multi-homed hosts. */
2888 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ADDITIONAL);
2890 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2893 int status = hstatus_unknown;
2894 int why = hwhy_unknown;
2899 && rr->type != T_AAAA
2906 /* Find the first host that matches this record's name. If there isn't
2907 one, move on to the next RR. */
2909 for (h = host; h != last->next; h = h->next)
2910 { if (strcmpic(h->name, rr->name) == 0) break; }
2911 if (h == last->next) continue;
2913 /* For IPv4 addresses, add 500 to the random part of the sort key, to ensure
2914 they sort after IPv6 addresses. */
2916 randoffset = (rr->type == T_A)? 500 : 0;
2918 /* Get the list of textual addresses for this RR. There may be more than one
2919 if it is an A6 RR. Then loop to handle multiple addresses from an A6 record.
2920 If there are none, nothing will get done - the record is ignored. */
2922 for (da = dns_address_from_rr(&dnsa, rr); da != NULL; da = da->next)
2924 /* Set status for an ignorable host. */
2927 if (ignore_target_hosts != NULL &&
2928 verify_check_this_host(&ignore_target_hosts, NULL, h->name,
2929 da->address, NULL) == OK)
2931 DEBUG(D_host_lookup)
2932 debug_printf("ignored host %s [%s]\n", h->name, da->address);
2933 status = hstatus_unusable;
2938 /* If the address is already set for this host, it may be that
2939 we just have a duplicate DNS record. Alternatively, this may be
2940 a multi-homed host. Search all items with the same host name
2941 (they will all be together) and if this address is found, skip
2944 if (h->address != NULL)
2947 host_item *thishostlast;
2952 if (hh->address != NULL && Ustrcmp(CS da->address, hh->address) == 0)
2953 goto DNS_NEXT_RR; /* Need goto to escape from inner loop */
2957 while (hh != last->next && strcmpic(hh->name, rr->name) == 0);
2959 /* We have a multi-homed host, since we have a new address for
2960 an existing name. Create a copy of the current item, and give it
2961 the new address. RRs can be in arbitrary order, but one is supposed
2962 to randomize the addresses of multi-homed hosts, so compute a new
2963 sorting key and do that. [Latest SMTP RFC says not to randomize multi-
2964 homed hosts, but to rely on the resolver. I'm not happy about that -
2965 caching in the resolver will not rotate as often as the name server
2968 new_sort_key = h->mx * 1000 + random_number(500) + randoffset;
2969 hh = store_get(sizeof(host_item));
2971 /* New address goes first: insert the new block after the first one
2972 (so as not to disturb the original pointer) but put the new address
2973 in the original block. */
2975 if (new_sort_key < h->sort_key)
2977 *hh = *h; /* Note: copies the port */
2979 h->address = da->address;
2980 h->sort_key = new_sort_key;
2985 /* Otherwise scan down the addresses for this host to find the
2986 one to insert after. */
2990 while (h != thishostlast)
2992 if (new_sort_key < h->next->sort_key) break;
2995 *hh = *h; /* Note: copies the port */
2997 hh->address = da->address;
2998 hh->sort_key = new_sort_key;
2999 hh->status = status;
3003 if (h == last) last = hh; /* Inserted after last */
3006 /* The existing item doesn't have its address set yet, so just set it.
3007 Ensure that an IPv4 address gets its sort key incremented in case an IPv6
3008 address is found later. */
3012 h->address = da->address; /* Port should be set already */
3015 h->sort_key += randoffset;
3017 } /* Loop for addresses extracted from one RR */
3019 /* Carry on to the next RR. It would be nice to be able to be able to stop
3020 when every host on the list has an address, but we can't be sure there won't
3021 be an additional address for a multi-homed host further down the list, so
3022 we have to continue to the end. */
3024 DNS_NEXT_RR: continue;
3027 /* Set the default yield to failure */
3029 yield = HOST_FIND_FAILED;
3031 /* If we haven't found all the addresses in the additional section, we
3032 need to search for A or AAAA records explicitly. The names shouldn't point to
3033 CNAMES, but we use the general lookup function that handles them, just
3034 in case. If any lookup gives a soft error, change the default yield.
3036 For these DNS lookups, we must disable qualify_single and search_parents;
3037 otherwise invalid host names obtained from MX or SRV records can cause trouble
3038 if they happen to match something local. */
3040 dns_init(FALSE, FALSE);
3042 for (h = host; h != last->next; h = h->next)
3044 if (h->address != NULL || h->status == hstatus_unusable) continue;
3045 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip, NULL);
3046 if (rc != HOST_FOUND)
3048 h->status = hstatus_unusable;
3049 if (rc == HOST_FIND_AGAIN)
3052 h->why = hwhy_deferred;
3055 h->why = (rc == HOST_IGNORED)? hwhy_ignored : hwhy_failed;
3059 /* Scan the list for any hosts that are marked unusable because they have
3060 been explicitly ignored, and remove them from the list, as if they did not
3061 exist. If we end up with just a single, ignored host, flatten its fields as if
3062 nothing was found. */
3064 if (ignore_target_hosts != NULL)
3066 host_item *prev = NULL;
3067 for (h = host; h != last->next; h = h->next)
3070 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
3072 else if (prev == NULL) /* First host is ignored */
3074 if (h != last) /* First is not last */
3076 if (h->next == last) last = h; /* Overwrite it with next */
3077 *h = *(h->next); /* and reprocess it. */
3078 goto REDO; /* C should have redo, like Perl */
3081 else /* Ignored host is not first - */
3083 prev->next = h->next;
3084 if (h == last) last = prev;
3088 if (host->why == hwhy_ignored) host->address = NULL;
3091 /* There is still one complication in the case of IPv6. Although the code above
3092 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3093 hosts, it doesn't do this for addresses that apply to different hosts with the
3094 same MX precedence, because the sorting on MX precedence happens first. So we
3095 have to make another pass to check for this case. We ensure that, within a
3096 single MX preference value, IPv6 addresses come first. This can separate the
3097 addresses of a multihomed host, but that should not matter. */
3102 for (h = host; h != last; h = h->next)
3105 host_item *next = h->next;
3106 if (h->mx != next->mx || /* If next is different MX value */
3107 (h->sort_key % 1000) < 500 || /* OR this one is IPv6 */
3108 (next->sort_key % 1000) >= 500) /* OR next is IPv4 */
3109 continue; /* move on to next */
3111 temp.next = next->next;
3119 /* When running in the test harness, we want the hosts always to be in the same
3120 order so that the debugging output is the same and can be compared. Having a
3121 fixed set of "random" numbers doesn't actually achieve this, because the RRs
3122 come back from the resolver in a random order, so the non-random random numbers
3123 get used in a different order. We therefore have to sort the hosts that have
3124 the same MX values. We chose do to this by their name and then by IP address.
3125 The fact that the sort is slow matters not - this is testing only! */
3127 if (running_in_test_harness)
3133 for (h = host; h != last; h = h->next)
3135 int c = Ustrcmp(h->name, h->next->name);
3136 if (c == 0) c = Ustrcmp(h->address, h->next->address);
3137 if (h->mx == h->next->mx && c > 0)
3139 host_item *next = h->next;
3140 host_item temp = *h;
3141 temp.next = next->next;
3152 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3153 whose IP addresses are on the local host. If any are found, all hosts with the
3154 same or higher MX values are removed. However, if the local host has the lowest
3155 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3156 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3157 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3158 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3159 be HOST_FIND_FAILED. */
3161 host_remove_duplicates(host, &last);
3162 rc = host_scan_for_local_hosts(host, &last, removed);
3163 if (rc != HOST_FIND_FAILED) yield = rc;
3165 DEBUG(D_host_lookup)
3167 if (fully_qualified_name != NULL)
3168 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3169 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3170 (yield == HOST_FOUND)? "HOST_FOUND" :
3171 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
3172 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3173 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3175 for (h = host; h != last->next; h = h->next)
3177 debug_printf(" %s %s MX=%d ", h->name,
3178 (h->address == NULL)? US"<null>" : h->address, h->mx);
3179 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3180 if (h->status >= hstatus_unusable) debug_printf("*");
3191 /*************************************************
3192 **************************************************
3193 * Stand-alone test program *
3194 **************************************************
3195 *************************************************/
3199 int main(int argc, char **cargv)
3202 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
3203 BOOL byname = FALSE;
3204 BOOL qualify_single = TRUE;
3205 BOOL search_parents = FALSE;
3206 uschar **argv = USS cargv;
3209 primary_hostname = US"";
3210 store_pool = POOL_MAIN;
3211 debug_selector = D_host_lookup|D_interface;
3212 debug_file = stdout;
3213 debug_fd = fileno(debug_file);
3215 printf("Exim stand-alone host functions test\n");
3217 host_find_interfaces();
3218 debug_selector = D_host_lookup | D_dns;
3220 if (argc > 1) primary_hostname = argv[1];
3222 /* So that debug level changes can be done first */
3224 dns_init(qualify_single, search_parents);
3226 printf("Testing host lookup\n");
3228 while (Ufgets(buffer, 256, stdin) != NULL)
3231 int len = Ustrlen(buffer);
3232 uschar *fully_qualified_name;
3234 while (len > 0 && isspace(buffer[len-1])) len--;
3237 if (Ustrcmp(buffer, "q") == 0) break;
3239 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3240 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3241 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3242 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3243 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3244 else if (Ustrcmp(buffer, "srv+a") == 0)
3245 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3246 else if (Ustrcmp(buffer, "srv+mx") == 0)
3247 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3248 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3249 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
3250 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3251 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3252 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3253 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3254 else if (Ustrcmp(buffer, "test_harness") == 0)
3255 running_in_test_harness = !running_in_test_harness;
3256 else if (Ustrcmp(buffer, "res_debug") == 0)
3258 _res.options ^= RES_DEBUG;
3260 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3262 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3263 _res.retrans = dns_retrans;
3265 else if (Ustrncmp(buffer, "retry", 5) == 0)
3267 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3268 _res.retry = dns_retry;
3272 int flags = whichrrs;
3278 h.status = hstatus_unknown;
3279 h.why = hwhy_unknown;
3282 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3283 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3286 host_find_byname(&h, NULL, &fully_qualified_name, TRUE)
3288 host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3289 &fully_qualified_name, NULL);
3291 if (rc == HOST_FIND_FAILED) printf("Failed\n");
3292 else if (rc == HOST_FIND_AGAIN) printf("Again\n");
3293 else if (rc == HOST_FOUND_LOCAL) printf("Local\n");
3299 printf("Testing host_aton\n");
3301 while (Ufgets(buffer, 256, stdin) != NULL)
3305 int len = Ustrlen(buffer);
3307 while (len > 0 && isspace(buffer[len-1])) len--;
3310 if (Ustrcmp(buffer, "q") == 0) break;
3312 len = host_aton(buffer, x);
3313 printf("length = %d ", len);
3314 for (i = 0; i < len; i++)
3316 printf("%04x ", (x[i] >> 16) & 0xffff);
3317 printf("%04x ", x[i] & 0xffff);
3324 printf("Testing host_name_lookup\n");
3326 while (Ufgets(buffer, 256, stdin) != NULL)
3328 int len = Ustrlen(buffer);
3329 while (len > 0 && isspace(buffer[len-1])) len--;
3331 if (Ustrcmp(buffer, "q") == 0) break;
3332 sender_host_address = buffer;
3333 sender_host_name = NULL;
3334 sender_host_aliases = NULL;
3335 host_lookup_msg = US"";
3336 host_lookup_failed = FALSE;
3337 if (host_name_lookup() == FAIL) /* Debug causes printing */
3338 printf("Lookup failed:%s\n", host_lookup_msg);
3346 #endif /* STAND_ALONE */