1 /* $Cambridge: exim/src/src/host.c,v 1.15 2005/09/19 10:13:39 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);
172 uschar *lname = name;
175 struct hostent *yield;
181 debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
182 (af == AF_INET)? "IPv4" : "IPv6");
184 /* Handle the name that needs a vast number of IP addresses */
186 if (Ustrcmp(name, "manyhome.test.ex") == 0 && af == AF_INET)
189 yield = store_get(sizeof(struct hostent));
190 alist = store_get(2049 * sizeof(char *));
191 adds = store_get(2048 * alen);
192 yield->h_name = CS name;
193 yield->h_aliases = NULL;
194 yield->h_addrtype = af;
195 yield->h_length = alen;
196 yield->h_addr_list = CSS alist;
197 for (i = 104; i <= 111; i++)
199 for (j = 0; j <= 255; j++)
212 /* Handle unqualified "localhost" */
214 if (Ustrcmp(name, "localhost") == 0)
215 lname = (af == AF_INET)? US"127.0.0.1" : US"::1";
217 /* Handle a literal IP address */
219 ipa = string_is_ip_address(lname, NULL);
222 if ((ipa == 4 && af == AF_INET) ||
223 (ipa == 6 && af == AF_INET6))
227 yield = store_get(sizeof(struct hostent));
228 alist = store_get(2 * sizeof(char *));
229 adds = store_get(alen);
230 yield->h_name = CS name;
231 yield->h_aliases = NULL;
232 yield->h_addrtype = af;
233 yield->h_length = alen;
234 yield->h_addr_list = CSS alist;
236 n = host_aton(lname, x);
237 for (i = 0; i < n; i++)
240 *adds++ = (y >> 24) & 255;
241 *adds++ = (y >> 16) & 255;
242 *adds++ = (y >> 8) & 255;
248 /* Wrong kind of literal address */
252 *error_num = HOST_NOT_FOUND;
257 /* Handle a host name */
261 int type = (af == AF_INET)? T_A:T_AAAA;
262 int rc = dns_lookup(&dnsa, lname, type, NULL);
267 case DNS_SUCCEED: break;
268 case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
269 case DNS_NODATA: *error_num = NO_DATA; return NULL;
270 case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
272 case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
275 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
277 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
279 if (rr->type == type) count++;
282 yield = store_get(sizeof(struct hostent));
283 alist = store_get((count + 1) * sizeof(char **));
284 adds = store_get(count *alen);
286 yield->h_name = CS name;
287 yield->h_aliases = NULL;
288 yield->h_addrtype = af;
289 yield->h_length = alen;
290 yield->h_addr_list = CSS alist;
292 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
294 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
299 if (rr->type != type) continue;
300 da = dns_address_from_rr(&dnsa, rr);
302 n = host_aton(da->address, x);
303 for (i = 0; i < n; i++)
306 *adds++ = (y >> 24) & 255;
307 *adds++ = (y >> 16) & 255;
308 *adds++ = (y >> 8) & 255;
320 /*************************************************
321 * Build chain of host items from list *
322 *************************************************/
324 /* This function builds a chain of host items from a textual list of host
325 names. It does not do any lookups. If randomize is true, the chain is build in
326 a randomized order. There may be multiple groups of independently randomized
327 hosts; they are delimited by a host name consisting of just "+".
330 anchor anchor for the chain
332 randomize TRUE for randomizing
338 host_build_hostlist(host_item **anchor, uschar *list, BOOL randomize)
341 int fake_mx = MX_NONE; /* This value is actually -1 */
345 if (list == NULL) return;
346 if (randomize) fake_mx--; /* Start at -2 for randomizing */
350 while ((name = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
354 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
355 { /* ignore if not randomizing */
356 if (randomize) fake_mx--;
360 h = store_get(sizeof(host_item));
361 h->name = string_copy(name);
365 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
366 h->status = hstatus_unknown;
367 h->why = hwhy_unknown;
377 host_item *hh = *anchor;
378 if (h->sort_key < hh->sort_key)
385 while (hh->next != NULL && h->sort_key >= (hh->next)->sort_key)
398 /*************************************************
399 * Extract port from address string *
400 *************************************************/
402 /* In the spool file, and in the -oMa and -oMi options, a host plus port is
403 given as an IP address followed by a dot and a port number. This function
406 An alternative format for the -oMa and -oMi options is [ip address]:port which
407 is what Exim 4 uses for output, because it seems to becoming commonly used,
408 whereas the dot form confuses some programs/people. So we recognize that form
412 address points to the string; if there is a port, the '.' in the string
413 is overwritten with zero to terminate the address; if the string
414 is in the [xxx]:ppp format, the address is shifted left and the
417 Returns: 0 if there is no port, else the port number. If there's a syntax
418 error, leave the incoming address alone, and return 0.
422 host_address_extract_port(uschar *address)
427 /* Handle the "bracketed with colon on the end" format */
431 uschar *rb = address + 1;
432 while (*rb != 0 && *rb != ']') rb++;
433 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
436 port = Ustrtol(rb + 1, &endptr, 10);
437 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
439 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
440 memmove(address, address + 1, rb - address - 2);
444 /* Handle the "dot on the end" format */
448 int skip = -3; /* Skip 3 dots in IPv4 addresses */
450 while (*(++address) != 0)
453 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
454 else if (ch == '.' && skip++ >= 0) break;
456 if (*address == 0) return 0;
457 port = Ustrtol(address + 1, &endptr, 10);
458 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
466 /*************************************************
467 * Get port from a host item's name *
468 *************************************************/
470 /* This function is called when finding the IP address for a host that is in a
471 list of hosts explicitly configured, such as in the manualroute router, or in a
472 fallback hosts list. We see if there is a port specification at the end of the
473 host name, and if so, remove it. A minimum length of 3 is required for the
474 original name; nothing shorter is recognized as having a port.
476 We test for a name ending with a sequence of digits; if preceded by colon we
477 have a port if the character before the colon is ] and the name starts with [
478 or if there are no other colons in the name (i.e. it's not an IPv6 address).
480 Arguments: pointer to the host item
481 Returns: a port number or PORT_NONE
485 host_item_get_port(host_item *h)
489 int len = Ustrlen(h->name);
491 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
493 /* Extract potential port number */
498 while (p > h->name + 1 && isdigit(*p))
500 port += (*p-- - '0') * x;
504 /* The smallest value of p at this point is h->name + 1. */
506 if (*p != ':') return PORT_NONE;
508 if (p[-1] == ']' && h->name[0] == '[')
509 h->name = string_copyn(h->name + 1, p - h->name - 2);
510 else if (Ustrchr(h->name, ':') == p)
511 h->name = string_copyn(h->name, p - h->name);
512 else return PORT_NONE;
514 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
520 #ifndef STAND_ALONE /* Omit when standalone testing */
522 /*************************************************
523 * Build sender_fullhost and sender_rcvhost *
524 *************************************************/
526 /* This function is called when sender_host_name and/or sender_helo_name
527 have been set. Or might have been set - for a local message read off the spool
528 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
531 (a) No sender_host_name or sender_helo_name: "[ip address]"
532 (b) Just sender_host_name: "host_name [ip address]"
533 (c) Just sender_helo_name: "(helo_name) [ip address]"
534 (d) The two are identical: "host_name [ip address]"
535 (e) The two are different: "host_name (helo_name) [ip address]"
537 If log_incoming_port is set, the sending host's port number is added to the IP
540 This function also builds sender_rcvhost for use in Received: lines, whose
541 syntax is a bit different. This value also includes the RFC 1413 identity.
542 There wouldn't be two different variables if I had got all this right in the
545 Because this data may survive over more than one incoming SMTP message, it has
546 to be in permanent store.
553 host_build_sender_fullhost(void)
556 int old_pool = store_pool;
558 if (sender_host_address == NULL) return;
560 store_pool = POOL_PERM;
562 /* Set up address, with or without the port. After discussion, it seems that
563 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
564 use this directly as the first item for Received: because it ain't an RFC 2822
567 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
568 if ((log_extra_selector & LX_incoming_port) == 0 || sender_host_port <= 0)
569 *(Ustrrchr(address, ':')) = 0;
571 /* Host name is not verified */
573 if (sender_host_name == NULL)
575 uschar *portptr = Ustrstr(address, "]:");
578 int adlen; /* Sun compiler doesn't like ++ in initializers */
580 adlen = (portptr == NULL)? Ustrlen(address) : (++portptr - address);
581 sender_fullhost = (sender_helo_name == NULL)? address :
582 string_sprintf("(%s) %s", sender_helo_name, address);
584 sender_rcvhost = string_cat(NULL, &size, &ptr, address, adlen);
586 if (sender_ident != NULL || sender_helo_name != NULL || portptr != NULL)
589 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US" (", 2);
593 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2, US"port=",
596 if (sender_helo_name != NULL)
597 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
598 (firstptr == ptr)? US"helo=" : US" helo=", sender_helo_name);
600 if (sender_ident != NULL)
601 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
602 (firstptr == ptr)? US"ident=" : US" ident=", sender_ident);
604 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US")", 1);
607 sender_rcvhost[ptr] = 0; /* string_cat() always leaves room */
609 /* Release store, because string_cat allocated a minimum of 100 bytes that
610 are rarely completely used. */
612 store_reset(sender_rcvhost + ptr + 1);
615 /* Host name is known and verified. */
620 BOOL no_helo = FALSE;
622 /* Comparing a HELO name to a host name is easy */
624 if (sender_helo_name == NULL ||
625 strcmpic(sender_host_name, sender_helo_name) == 0)
628 /* If HELO/EHLO was followed by an IP literal, it's much more messy because
629 of two features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal
630 and doesn't require this, for historical reasons). Secondly, an IPv6 address
631 may not be given in canonical form, so we have to canonicize it before
632 comparing. As it happens, the code works for both IPv4 and IPv6. */
634 else if (sender_helo_name[0] == '[' &&
635 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
640 if (strncmpic(sender_helo_name+1, US"IPv6:",5) == 0) offset += 5;
641 helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
643 if (string_is_ip_address(helo_ip, NULL) != 0)
647 size = host_aton(helo_ip, x);
648 helo_ip = store_get(48); /* large enough for full IPv6 */
649 (void)host_nmtoa(size, x, -1, helo_ip, ':');
650 if (strcmpic(helo_ip, sender_host_address) == 0) no_helo = TRUE;
656 sender_fullhost = string_sprintf("%s %s", sender_host_name, address);
657 sender_rcvhost = (sender_ident == NULL)?
658 string_sprintf("%s (%s)", sender_host_name, address) :
659 string_sprintf("%s (%s ident=%s)", sender_host_name, address,
664 sender_fullhost = string_sprintf("%s (%s) %s", sender_host_name,
665 sender_helo_name, address);
666 sender_rcvhost = (sender_ident == NULL)?
667 string_sprintf("%s (%s helo=%s)", sender_host_name,
668 address, sender_helo_name) :
669 string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
670 address, sender_helo_name, sender_ident);
674 store_pool = old_pool;
676 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
677 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
682 /*************************************************
683 * Build host+ident message *
684 *************************************************/
686 /* Used when logging rejections and various ACL and SMTP incidents. The text
687 return depends on whether sender_fullhost and sender_ident are set or not:
689 no ident, no host => U=unknown
690 no ident, host set => H=sender_fullhost
691 ident set, no host => U=ident
692 ident set, host set => H=sender_fullhost U=ident
695 useflag TRUE if first item to be flagged (H= or U=); if there are two
696 items, the second is always flagged
698 Returns: pointer to a string in big_buffer
702 host_and_ident(BOOL useflag)
704 if (sender_fullhost == NULL)
706 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag? "U=" : "",
707 (sender_ident == NULL)? US"unknown" : sender_ident);
711 uschar *flag = useflag? US"H=" : US"";
712 uschar *iface = US"";
713 if ((log_extra_selector & LX_incoming_interface) != 0 &&
714 interface_address != NULL)
715 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
716 if (sender_ident == NULL)
717 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
718 flag, sender_fullhost, iface);
720 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
721 flag, sender_fullhost, iface, sender_ident);
726 #endif /* STAND_ALONE */
731 /*************************************************
732 * Build list of local interfaces *
733 *************************************************/
735 /* This function interprets the contents of the local_interfaces or
736 extra_local_interfaces options, and creates an ip_address_item block for each
737 item on the list. There is no special interpretation of any IP addresses; in
738 particular, 0.0.0.0 and ::0 are returned without modification. If any address
739 includes a port, it is set in the block. Otherwise the port value is set to
744 name the name of the option being expanded
746 Returns: a chain of ip_address_items, each containing to a textual
747 version of an IP address, and a port number (host order) or
748 zero if no port was given with the address
752 host_build_ifacelist(uschar *list, uschar *name)
757 ip_address_item *yield = NULL;
758 ip_address_item *last = NULL;
759 ip_address_item *next;
761 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
763 int port = host_address_extract_port(s); /* Leaves just the IP address */
764 if (string_is_ip_address(s, NULL) == 0)
765 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
768 /* This use of strcpy() is OK because we have checked that s is a valid IP
769 address above. The field in the ip_address_item is large enough to hold an
772 next = store_get(sizeof(ip_address_item));
774 Ustrcpy(next->address, s);
776 next->v6_include_v4 = FALSE;
778 if (yield == NULL) yield = last = next; else
792 /*************************************************
793 * Find addresses on local interfaces *
794 *************************************************/
796 /* This function finds the addresses of local IP interfaces. These are used
797 when testing for routing to the local host. As the function may be called more
798 than once, the list is preserved in permanent store, pointed to by a static
799 variable, to save doing the work more than once per process.
801 The generic list of interfaces is obtained by calling host_build_ifacelist()
802 for local_interfaces and extra_local_interfaces. This list scanned to remove
803 duplicates (which may exist with different ports - not relevant here). If
804 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
805 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
806 obtained from os_find_running_interfaces().
809 Returns: a chain of ip_address_items, each containing to a textual
810 version of an IP address; the port numbers are not relevant
814 /* First, a local subfunction to add an interface to a list in permanent store,
815 but only if there isn't a previous copy of that address on the list. */
817 static ip_address_item *
818 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
820 ip_address_item *ipa2;
821 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
822 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
823 ipa2 = store_get_perm(sizeof(ip_address_item));
830 /* This is the globally visible function */
833 host_find_interfaces(void)
835 ip_address_item *running_interfaces = NULL;
837 if (local_interface_data == NULL)
839 void *reset_item = store_get(0);
840 ip_address_item *dlist = host_build_ifacelist(local_interfaces,
841 US"local_interfaces");
842 ip_address_item *xlist = host_build_ifacelist(extra_local_interfaces,
843 US"extra_local_interfaces");
844 ip_address_item *ipa;
846 if (dlist == NULL) dlist = xlist; else
848 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
852 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
854 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
855 Ustrcmp(ipa->address, "::0") == 0)
857 ip_address_item *ipa2;
858 BOOL ipv6 = ipa->address[0] == ':';
859 if (running_interfaces == NULL)
860 running_interfaces = os_find_running_interfaces();
861 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
863 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
864 local_interface_data = add_unique_interface(local_interface_data,
870 local_interface_data = add_unique_interface(local_interface_data, ipa);
873 debug_printf("Configured local interface: address=%s", ipa->address);
874 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
879 store_reset(reset_item);
882 return local_interface_data;
889 /*************************************************
890 * Convert network IP address to text *
891 *************************************************/
893 /* Given an IPv4 or IPv6 address in binary, convert it to a text
894 string and return the result in a piece of new store. The address can
895 either be given directly, or passed over in a sockaddr structure. Note
896 that this isn't the converse of host_aton() because of byte ordering
897 differences. See host_nmtoa() below.
900 type if < 0 then arg points to a sockaddr, else
901 either AF_INET or AF_INET6
902 arg points to a sockaddr if type is < 0, or
903 points to an IPv4 address (32 bits), or
904 points to an IPv6 address (128 bits),
905 in both cases, in network byte order
906 buffer if NULL, the result is returned in gotten store;
907 else points to a buffer to hold the answer
908 portptr points to where to put the port number, if non NULL; only
911 Returns: pointer to character string
915 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
919 /* The new world. It is annoying that we have to fish out the address from
920 different places in the block, depending on what kind of address it is. It
921 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
922 function inet_ntoa() returns just uschar *, and some picky compilers insist
923 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
926 uschar addr_buffer[46];
929 int family = ((struct sockaddr *)arg)->sa_family;
930 if (family == AF_INET6)
932 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
933 yield = (uschar *)inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
934 sizeof(addr_buffer));
935 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
939 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
940 yield = (uschar *)inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
941 sizeof(addr_buffer));
942 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
947 yield = (uschar *)inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
950 /* If the result is a mapped IPv4 address, show it in V4 format. */
952 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
954 #else /* HAVE_IPV6 */
960 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
961 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
964 yield = US inet_ntoa(*((struct in_addr *)arg));
967 /* If there is no buffer, put the string into some new store. */
969 if (buffer == NULL) return string_copy(yield);
971 /* Callers of this function with a non-NULL buffer must ensure that it is
972 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
973 makes this use of strcpy() OK. */
975 Ustrcpy(buffer, yield);
982 /*************************************************
983 * Convert address text to binary *
984 *************************************************/
986 /* Given the textual form of an IP address, convert it to binary in an
987 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
988 The result has the first byte in the most significant byte of the first int. In
989 other words, the result is not in network byte order, but in host byte order.
990 As a result, this is not the converse of host_ntoa(), which expects network
991 byte order. See host_nmtoa() below.
994 address points to the textual address, checked for syntax
995 bin points to an array of 4 ints
997 Returns: the number of ints used
1001 host_aton(uschar *address, int *bin)
1006 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
1007 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
1008 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
1011 if (Ustrchr(address, ':') != NULL)
1013 uschar *p = address;
1014 uschar *component[8];
1015 BOOL ipv4_ends = FALSE;
1021 /* If the address starts with a colon, it will start with two colons.
1022 Just lose the first one, which will leave a null first component. */
1026 /* Split the address into components separated by colons. The input address
1027 is supposed to be checked for syntax. There was a case where this was
1028 overlooked; to guard against that happening again, check here and crash if
1029 there are too many components. */
1031 while (*p != 0 && *p != '%')
1033 int len = Ustrcspn(p, ":%");
1034 if (len == 0) nulloffset = ci;
1035 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1036 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
1038 component[ci++] = p;
1043 /* If the final component contains a dot, it is a trailing v4 address.
1044 As the syntax is known to be checked, just set up for a trailing
1045 v4 address and restrict the v6 part to 6 components. */
1047 if (Ustrchr(component[ci-1], '.') != NULL)
1049 address = component[--ci];
1055 /* If there are fewer than 6 or 8 components, we have to insert some
1056 more empty ones in the middle. */
1060 int insert_count = v6count - ci;
1061 for (i = v6count-1; i > nulloffset + insert_count; i--)
1062 component[i] = component[i - insert_count];
1063 while (i > nulloffset) component[i--] = US"";
1066 /* Now turn the components into binary in pairs and bung them
1067 into the vector of ints. */
1069 for (i = 0; i < v6count; i += 2)
1070 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1071 Ustrtol(component[i+1], NULL, 16);
1073 /* If there was no terminating v4 component, we are done. */
1075 if (!ipv4_ends) return 4;
1078 /* Handle IPv4 address */
1080 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
1081 bin[v4offset] = (x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
1086 /*************************************************
1087 * Apply mask to an IP address *
1088 *************************************************/
1090 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1094 count the number of ints
1095 binary points to the ints to be masked
1096 mask the count of ms bits to leave, or -1 if no masking
1102 host_mask(int count, int *binary, int mask)
1105 if (mask < 0) mask = 99999;
1106 for (i = 0; i < count; i++)
1109 if (mask == 0) wordmask = 0;
1112 wordmask = (-1) << (32 - mask);
1120 binary[i] &= wordmask;
1127 /*************************************************
1128 * Convert masked IP address in ints to text *
1129 *************************************************/
1131 /* We can't use host_ntoa() because it assumes the binary values are in network
1132 byte order, and these are the result of host_aton(), which puts them in ints in
1133 host byte order. Also, we really want IPv6 addresses to be in a canonical
1134 format, so we output them with no abbreviation. In a number of cases we can't
1135 use the normal colon separator in them because it terminates keys in lsearch
1136 files, so we want to use dot instead. There's an argument that specifies what
1137 to use for IPv6 addresses.
1140 count 1 or 4 (number of ints)
1141 binary points to the ints
1142 mask mask value; if < 0 don't add to result
1143 buffer big enough to hold the result
1144 sep component separator character for IPv6 addresses
1146 Returns: the number of characters placed in buffer, not counting
1151 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1154 uschar *tt = buffer;
1159 for (i = 24; i >= 0; i -= 8)
1161 sprintf(CS tt, "%d.", (j >> i) & 255);
1167 for (i = 0; i < 4; i++)
1170 sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1175 tt--; /* lose final separator */
1181 sprintf(CS tt, "/%d", mask);
1190 /*************************************************
1191 * Check port for tls_on_connect *
1192 *************************************************/
1194 /* This function checks whether a given incoming port is configured for tls-
1195 on-connect. It is called from the daemon and from inetd handling. If the global
1196 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1197 check the tls_on_connect_ports option for a list of ports.
1199 Argument: a port number
1200 Returns: TRUE or FALSE
1204 host_is_tls_on_connect_port(int port)
1208 uschar *list = tls_on_connect_ports;
1211 if (tls_on_connect) return TRUE;
1213 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1216 int lport = Ustrtol(s, &end, 10);
1217 if (*end != 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "tls_on_connect_ports "
1218 "contains \"%s\", which is not a port number: exim abandoned", s);
1219 if (lport == port) return TRUE;
1227 /*************************************************
1228 * Check whether host is in a network *
1229 *************************************************/
1231 /* This function checks whether a given IP address matches a pattern that
1232 represents either a single host, or a network (using CIDR notation). The caller
1233 of this function must check the syntax of the arguments before calling it.
1236 host string representation of the ip-address to check
1237 net string representation of the network, with optional CIDR mask
1238 maskoffset offset to the / that introduces the mask in the key
1239 zero if there is no mask
1242 TRUE the host is inside the network
1243 FALSE the host is NOT inside the network
1247 host_is_in_net(uschar *host, uschar *net, int maskoffset)
1253 int size = host_aton(net, address);
1256 /* No mask => all bits to be checked */
1258 if (maskoffset == 0) mlen = 99999; /* Big number */
1259 else mlen = Uatoi(net + maskoffset + 1);
1261 /* Convert the incoming address to binary. */
1263 insize = host_aton(host, incoming);
1265 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1266 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1267 ::ffff:<v4address>, to IPv4 format. */
1269 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1270 incoming[2] == 0xffff)
1273 incoming[0] = incoming[3];
1276 /* No match if the sizes don't agree. */
1278 if (insize != size) return FALSE;
1280 /* Else do the masked comparison. */
1282 for (i = 0; i < size; i++)
1285 if (mlen == 0) mask = 0;
1288 mask = (-1) << (32 - mlen);
1296 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1304 /*************************************************
1305 * Scan host list for local hosts *
1306 *************************************************/
1308 /* Scan through a chain of addresses and check whether any of them is the
1309 address of an interface on the local machine. If so, remove that address and
1310 any previous ones with the same MX value, and all subsequent ones (which will
1311 have greater or equal MX values) from the chain. Note: marking them as unusable
1312 is NOT the right thing to do because it causes the hosts not to be used for
1313 other domains, for which they may well be correct.
1315 The hosts may be part of a longer chain; we only process those between the
1316 initial pointer and the "last" pointer.
1318 There is also a list of "pseudo-local" host names which are checked against the
1319 host names. Any match causes that host item to be treated the same as one which
1320 matches a local IP address.
1322 If the very first host is a local host, then all MX records had a precedence
1323 greater than or equal to that of the local host. Either there's a problem in
1324 the DNS, or an apparently remote name turned out to be an abbreviation for the
1325 local host. Give a specific return code, and let the caller decide what to do.
1326 Otherwise, give a success code if at least one host address has been found.
1329 host pointer to the first host in the chain
1330 lastptr pointer to pointer to the last host in the chain (may be updated)
1331 removed if not NULL, set TRUE if some local addresses were removed
1335 HOST_FOUND if there is at least one host with an IP address on the chain
1336 and an MX value less than any MX value associated with the
1338 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1339 the host addresses were obtained from A records or
1340 gethostbyname(), the MX values are set to -1.
1341 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1345 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1347 int yield = HOST_FIND_FAILED;
1348 host_item *last = *lastptr;
1349 host_item *prev = NULL;
1352 if (removed != NULL) *removed = FALSE;
1354 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1356 for (h = host; h != last->next; h = h->next)
1359 if (hosts_treat_as_local != NULL)
1362 uschar *save = deliver_domain;
1363 deliver_domain = h->name; /* set $domain */
1364 rc = match_isinlist(string_copylc(h->name), &hosts_treat_as_local, 0,
1365 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1366 deliver_domain = save;
1367 if (rc == OK) goto FOUND_LOCAL;
1371 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1372 for 127.0.0.1 and refers to the local host. We therefore force it always to
1373 be treated as local. */
1375 if (h->address != NULL)
1377 ip_address_item *ip;
1378 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1379 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1380 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1381 yield = HOST_FOUND; /* At least one remote address has been found */
1384 /* Update prev to point to the last host item before any that have
1385 the same MX value as the one we have just considered. */
1387 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1390 return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1392 /* A host whose IP address matches a local IP address, or whose name matches
1393 something in hosts_treat_as_local has been found. */
1399 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1400 "local host has lowest MX\n" :
1401 "local host found for non-MX address\n");
1402 return HOST_FOUND_LOCAL;
1405 HDEBUG(D_host_lookup)
1407 debug_printf("local host in host list - removed hosts:\n");
1408 for (h = prev->next; h != last->next; h = h->next)
1409 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1412 if (removed != NULL) *removed = TRUE;
1413 prev->next = last->next;
1421 /*************************************************
1422 * Remove duplicate IPs in host list *
1423 *************************************************/
1425 /* You would think that administrators could set up their DNS records so that
1426 one ended up with a list of unique IP addresses after looking up A or MX
1427 records, but apparently duplication is common. So we scan such lists and
1428 remove the later duplicates. Note that we may get lists in which some host
1429 addresses are not set.
1432 host pointer to the first host in the chain
1433 lastptr pointer to pointer to the last host in the chain (may be updated)
1439 host_remove_duplicates(host_item *host, host_item **lastptr)
1441 while (host != *lastptr)
1443 if (host->address != NULL)
1445 host_item *h = host;
1446 while (h != *lastptr)
1448 if (h->next->address != NULL &&
1449 Ustrcmp(h->next->address, host->address) == 0)
1451 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1452 "removed\n", host->address, h->next->mx);
1453 if (h->next == *lastptr) *lastptr = h;
1454 h->next = h->next->next;
1459 /* If the last item was removed, host may have become == *lastptr */
1460 if (host != *lastptr) host = host->next;
1467 /*************************************************
1468 * Find sender host name by gethostbyaddr() *
1469 *************************************************/
1471 /* This used to be the only way it was done, but it turns out that not all
1472 systems give aliases for calls to gethostbyaddr() - or one of the modern
1473 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1474 but they can still exist. This function is now used only when a DNS lookup of
1475 the IP address fails, in order to give access to /etc/hosts.
1478 Returns: OK, DEFER, FAIL
1482 host_name_lookup_byaddr(void)
1486 struct hostent *hosts;
1487 struct in_addr addr;
1489 /* Lookup on IPv6 system */
1492 if (Ustrchr(sender_host_address, ':') != NULL)
1494 struct in6_addr addr6;
1495 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1496 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1497 "IPv6 address", sender_host_address);
1498 #if HAVE_GETIPNODEBYADDR
1499 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1501 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1506 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1507 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1508 "IPv4 address", sender_host_address);
1509 #if HAVE_GETIPNODEBYADDR
1510 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1512 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1516 /* Do lookup on IPv4 system */
1519 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1520 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1523 /* Failed to look up the host. */
1527 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1529 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1532 /* It seems there are some records in the DNS that yield an empty name. We
1533 treat this as non-existent. In some operating systems, this is returned as an
1534 empty string; in others as a single dot. */
1536 if (hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1538 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1539 "treated as non-existent host name\n");
1543 /* Copy and lowercase the name, which is in static storage in many systems.
1544 Put it in permanent memory. */
1546 s = (uschar *)hosts->h_name;
1547 len = Ustrlen(s) + 1;
1548 t = sender_host_name = store_get_perm(len);
1549 while (*s != 0) *t++ = tolower(*s++);
1552 /* If the host has aliases, build a copy of the alias list */
1554 if (hosts->h_aliases != NULL)
1557 uschar **aliases, **ptr;
1558 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1559 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1560 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1562 uschar *s = *aliases;
1563 int len = Ustrlen(s) + 1;
1564 uschar *t = *ptr++ = store_get_perm(len);
1565 while (*s != 0) *t++ = tolower(*s++);
1576 /*************************************************
1577 * Find host name for incoming call *
1578 *************************************************/
1580 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1581 up a list of alias names, pointed to by sender_host_alias. The list is
1582 NULL-terminated. The incoming address is in sender_host_address, either in
1583 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1585 This function does a thorough check that the names it finds point back to the
1586 incoming IP address. Any that do not are discarded. Note that this is relied on
1587 by the ACL reverse_host_lookup check.
1589 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1590 this it not universally true. Also, for release 4.30, this function was changed
1591 to do a direct DNS lookup first, by default[1], because it turns out that that
1592 is the only guaranteed way to find all the aliases on some systems. My
1593 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1596 [1] The actual order is controlled by the host_lookup_order option.
1599 Returns: OK on success, the answer being placed in the global variable
1600 sender_host_name, with any aliases in a list hung off
1602 FAIL if no host name can be found
1603 DEFER if a temporary error was encountered
1605 The variable host_lookup_msg is set to an empty string on sucess, or to a
1606 reason for the failure otherwise, in a form suitable for tagging onto an error
1607 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1608 was a defer, host_lookup_deferred is set TRUE.
1610 Any dynamically constructed string for host_lookup_msg must be in permanent
1611 store, because it might be used for several incoming messages on the same SMTP
1615 host_name_lookup(void)
1619 uschar *hname, *save_hostname;
1623 uschar *list = host_lookup_order;
1628 host_lookup_deferred = host_lookup_failed = FALSE;
1630 HDEBUG(D_host_lookup)
1631 debug_printf("looking up host name for %s\n", sender_host_address);
1633 /* For testing the case when a lookup does not complete, we have a special
1634 reserved IP address. */
1636 if (running_in_test_harness &&
1637 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1639 HDEBUG(D_host_lookup)
1640 debug_printf("Test harness: host name lookup returns DEFER\n");
1641 host_lookup_deferred = TRUE;
1645 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1646 the order specified by the host_lookup_order option. */
1648 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1651 if (strcmpic(ordername, US"bydns") == 0)
1653 dns_init(FALSE, FALSE);
1654 dns_build_reverse(sender_host_address, buffer);
1655 rc = dns_lookup(&dnsa, buffer, T_PTR, NULL);
1657 /* The first record we come across is used for the name; others are
1658 considered to be aliases. We have to scan twice, in order to find out the
1659 number of aliases. However, if all the names are empty, we will behave as
1660 if failure. (PTR records that yield empty names have been encountered in
1663 if (rc == DNS_SUCCEED)
1665 uschar **aptr = NULL;
1668 int old_pool = store_pool;
1670 store_pool = POOL_PERM; /* Save names in permanent storage */
1672 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1674 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1676 if (rr->type == T_PTR) count++;
1679 /* Get store for the list of aliases. For compatibility with
1680 gethostbyaddr, we make an empty list if there are none. */
1682 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1684 /* Re-scan and extract the names */
1686 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1688 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1691 if (rr->type != T_PTR) continue;
1692 s = store_get(ssize);
1694 /* If an overlong response was received, the data will have been
1695 truncated and dn_expand may fail. */
1697 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1698 (uschar *)(rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1700 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1701 sender_host_address);
1705 store_reset(s + Ustrlen(s) + 1);
1708 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1709 "empty name: treated as non-existent host name\n");
1712 if (sender_host_name == NULL) sender_host_name = s;
1714 while (*s != 0) { *s = tolower(*s); s++; }
1717 *aptr = NULL; /* End of alias list */
1718 store_pool = old_pool; /* Reset store pool */
1720 /* If we've found a names, break out of the "order" loop */
1722 if (sender_host_name != NULL) break;
1725 /* If the DNS lookup deferred, we must also defer. */
1727 if (rc == DNS_AGAIN)
1729 HDEBUG(D_host_lookup)
1730 debug_printf("IP address PTR lookup gave temporary error\n");
1731 host_lookup_deferred = TRUE;
1736 /* Do a lookup using gethostbyaddr() - or equivalent */
1738 else if (strcmpic(ordername, US"byaddr") == 0)
1740 HDEBUG(D_host_lookup)
1741 debug_printf("IP address lookup using gethostbyaddr()\n");
1742 rc = host_name_lookup_byaddr();
1745 host_lookup_deferred = TRUE;
1746 return rc; /* Can't carry on */
1748 if (rc == OK) break; /* Found a name */
1750 } /* Loop for bydns/byaddr scanning */
1752 /* If we have failed to find a name, return FAIL and log when required.
1753 NB host_lookup_msg must be in permanent store. */
1755 if (sender_host_name == NULL)
1757 if (host_checking || !log_testing_mode)
1758 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1759 "address %s", sender_host_address);
1760 host_lookup_msg = US" (failed to find host name from IP address)";
1761 host_lookup_failed = TRUE;
1765 /* We have a host name. If we are running in the test harness, we want the host
1766 name and its alias to appear always the same way round. There are only ever two
1767 names in these tests. If one of them contains "alias", make sure it is second;
1768 otherwise put them in alphabetical order. */
1770 if (running_in_test_harness && *sender_host_aliases != NULL &&
1772 Ustrstr(sender_host_name, "alias") != NULL ||
1774 Ustrstr(*sender_host_aliases, "alias") == NULL &&
1775 Ustrcmp(sender_host_name, *sender_host_aliases) > 0
1779 uschar *temp = sender_host_name;
1780 sender_host_name = *sender_host_aliases;
1781 *sender_host_aliases = temp;
1784 /* Debug output what was found, after test harness swapping, for consistency */
1786 HDEBUG(D_host_lookup)
1788 uschar **aliases = sender_host_aliases;
1789 debug_printf("IP address lookup yielded %s\n", sender_host_name);
1790 while (*aliases != NULL) debug_printf(" alias %s\n", *aliases++);
1793 /* We need to verify that a forward lookup on the name we found does indeed
1794 correspond to the address. This is for security: in principle a malefactor who
1795 happened to own a reverse zone could set it to point to any names at all.
1797 This code was present in versions of Exim before 3.20. At that point I took it
1798 out because I thought that gethostbyaddr() did the check anyway. It turns out
1799 that this isn't always the case, so it's coming back in at 4.01. This version
1800 is actually better, because it also checks aliases.
1802 The code was made more robust at release 4.21. Prior to that, it accepted all
1803 the names if any of them had the correct IP address. Now the code checks all
1804 the names, and accepts only those that have the correct IP address. */
1806 save_hostname = sender_host_name; /* Save for error messages */
1807 aliases = sender_host_aliases;
1808 for (hname = sender_host_name; hname != NULL; hname = *aliases++)
1818 /* When called with the 5th argument FALSE, host_find_byname() won't return
1819 HOST_FOUND_LOCAL. If the incoming address is an IPv4 address expressed in
1820 IPv6 format, we must compare the IPv4 part to any IPv4 addresses. */
1822 if ((rc = host_find_byname(&h, NULL, NULL, FALSE)) == HOST_FOUND)
1825 uschar *address_ipv4 = (Ustrncmp(sender_host_address, "::ffff:", 7) == 0)?
1826 sender_host_address + 7 : sender_host_address;
1827 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1828 for (hh = &h; hh != NULL; hh = hh->next)
1830 if ((Ustrcmp(hh->address, (Ustrchr(hh->address, ':') == NULL)?
1831 address_ipv4 : sender_host_address)) == 0)
1833 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1839 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1842 if (!ok) HDEBUG(D_host_lookup)
1843 debug_printf("no IP address for %s matched %s\n", hname,
1844 sender_host_address);
1846 else if (rc == HOST_FIND_AGAIN)
1848 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1849 host_lookup_deferred = TRUE;
1854 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1857 /* If this name is no good, and it's the sender name, set it null pro tem;
1858 if it's an alias, just remove it from the list. */
1862 if (hname == sender_host_name) sender_host_name = NULL; else
1864 uschar **a; /* Don't amalgamate - some */
1865 a = --aliases; /* compilers grumble */
1866 while (*a != NULL) { *a = a[1]; a++; }
1871 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1872 it with the first alias, if there is one. */
1874 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1875 sender_host_name = *sender_host_aliases++;
1877 /* If we now have a main name, all is well. */
1879 if (sender_host_name != NULL) return OK;
1881 /* We have failed to find an address that matches. */
1883 HDEBUG(D_host_lookup)
1884 debug_printf("%s does not match any IP address for %s\n",
1885 sender_host_address, save_hostname);
1887 /* This message must be in permanent store */
1889 old_pool = store_pool;
1890 store_pool = POOL_PERM;
1891 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1892 sender_host_address, save_hostname);
1893 store_pool = old_pool;
1894 host_lookup_failed = TRUE;
1901 /*************************************************
1902 * Find IP address(es) for host by name *
1903 *************************************************/
1905 /* The input is a host_item structure with the name filled in and the address
1906 field set to NULL. We use gethostbyname(). Of course, gethostbyname() may use
1907 the DNS, but it doesn't do MX processing. If more than one address is given,
1908 chain on additional host items, with other relevant fields copied.
1910 The second argument provides a host list (usually an IP list) of hosts to
1911 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1912 addresses in unreasonable places.
1914 The lookup may result in a change of name. For compatibility with the dns
1915 lookup, return this via fully_qualified_name as well as updating the host item.
1916 The lookup may also yield more than one IP address, in which case chain on
1917 subsequent host_item structures.
1920 host a host item with the name and MX filled in;
1921 the address is to be filled in;
1922 multiple IP addresses cause other host items to be
1924 ignore_target_hosts a list of hosts to ignore
1925 fully_qualified_name if not NULL, set to point to host name for
1926 compatibility with host_find_bydns
1927 local_host_check TRUE if a check for the local host is wanted
1929 Returns: HOST_FIND_FAILED Failed to find the host or domain
1930 HOST_FIND_AGAIN Try again later
1931 HOST_FOUND Host found - data filled in
1932 HOST_FOUND_LOCAL Host found and is the local host
1936 host_find_byname(host_item *host, uschar *ignore_target_hosts,
1937 uschar **fully_qualified_name, BOOL local_host_check)
1939 int i, yield, times;
1941 host_item *last = NULL;
1942 BOOL temp_error = FALSE;
1947 /* If we are in the test harness, a name ending in .test.again.dns always
1948 forces a temporary error response. */
1950 if (running_in_test_harness)
1952 uschar *endname = host->name + Ustrlen(host->name);
1953 if (Ustrcmp(endname - 14, "test.again.dns") == 0)
1954 return HOST_FIND_AGAIN;
1957 /* In an IPv6 world, we need to scan for both kinds of address, so go round the
1958 loop twice. Note that we have ensured that AF_INET6 is defined even in an IPv4
1959 world, which makes for slightly tidier code. However, if dns_ipv4_lookup
1960 matches the domain, we also just do IPv4 lookups here (except when testing
1965 if (dns_ipv4_lookup != NULL &&
1966 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
1968 { af = AF_INET; times = 1; }
1970 #endif /* STAND_ALONE */
1972 { af = AF_INET6; times = 2; }
1974 /* No IPv6 support */
1976 #else /* HAVE_IPV6 */
1978 #endif /* HAVE_IPV6 */
1980 /* Initialize the flag that gets set for DNS syntax check errors, so that the
1981 interface to this function can be similar to host_find_bydns. */
1983 host_find_failed_syntax = FALSE;
1985 /* Loop to look up both kinds of address in an IPv6 world */
1987 for (i = 1; i <= times;
1989 af = AF_INET, /* If 2 passes, IPv4 on the second */
1995 struct hostent *hostdata;
1998 if (running_in_test_harness)
1999 hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2002 #if HAVE_GETIPNODEBYNAME
2003 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2005 hostdata = gethostbyname2(CS host->name, af);
2006 error_num = h_errno;
2010 #else /* not HAVE_IPV6 */
2011 if (running_in_test_harness)
2012 hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2015 hostdata = gethostbyname(CS host->name);
2016 error_num = h_errno;
2018 #endif /* HAVE_IPV6 */
2020 if (hostdata == NULL)
2025 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
2026 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2027 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2028 case NO_DATA: error = US"NO_DATA"; break;
2029 #if NO_DATA != NO_ADDRESS
2030 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
2032 default: error = US"?"; break;
2035 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2037 #if HAVE_GETIPNODEBYNAME
2038 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2040 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2047 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2050 if ((hostdata->h_addr_list)[0] == NULL) continue;
2052 /* Replace the name with the fully qualified one if necessary, and fill in
2053 the fully_qualified_name pointer. */
2055 if (hostdata->h_name[0] != 0 &&
2056 Ustrcmp(host->name, hostdata->h_name) != 0)
2057 host->name = string_copy_dnsdomain((uschar *)hostdata->h_name);
2058 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2060 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2061 by their different lengths. Scan the list, ignoring any that are to be
2062 ignored, and build a chain from the rest. */
2064 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2066 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2068 uschar *text_address =
2069 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2072 if (ignore_target_hosts != NULL &&
2073 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2074 text_address, NULL) == OK)
2076 DEBUG(D_host_lookup)
2077 debug_printf("ignored host %s [%s]\n", host->name, text_address);
2082 /* If this is the first address, last == NULL and we put the data in the
2087 host->address = text_address;
2088 host->port = PORT_NONE;
2089 host->status = hstatus_unknown;
2090 host->why = hwhy_unknown;
2094 /* Else add further host item blocks for any other addresses, keeping
2099 host_item *next = store_get(sizeof(host_item));
2100 next->name = host->name;
2101 next->mx = host->mx;
2102 next->address = text_address;
2103 next->port = PORT_NONE;
2104 next->status = hstatus_unknown;
2105 next->why = hwhy_unknown;
2107 next->next = last->next;
2114 /* If no hosts were found, the address field in the original host block will be
2115 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2116 so we pass that back. */
2118 if (host->address == NULL)
2122 (message_id[0] == 0 && smtp_in != NULL)?
2123 string_sprintf("no IP address found for host %s (during %s)", host->name,
2124 smtp_get_connection_info()) :
2126 string_sprintf("no IP address found for host %s", host->name);
2128 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2129 if (temp_error) return HOST_FIND_AGAIN;
2130 if (host_checking || !log_testing_mode)
2131 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2132 return HOST_FIND_FAILED;
2135 /* Remove any duplicate IP addresses, then check to see if this is the local
2136 host if required. */
2138 host_remove_duplicates(host, &last);
2139 yield = local_host_check?
2140 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2142 /* When running in the test harness, sort into the order of addresses so as to
2143 get repeatability. */
2145 if (running_in_test_harness) sort_addresses(host, last);
2147 HDEBUG(D_host_lookup)
2150 if (fully_qualified_name != NULL)
2151 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2152 debug_printf("%s looked up these IP addresses:\n",
2154 #if HAVE_GETIPNODEBYNAME
2163 for (h = host; h != last->next; h = h->next)
2164 debug_printf(" name=%s address=%s\n", h->name,
2165 (h->address == NULL)? US"<null>" : h->address);
2168 /* Return the found status. */
2175 /*************************************************
2176 * Fill in a host address from the DNS *
2177 *************************************************/
2179 /* Given a host item, with its name and mx fields set, and its address field
2180 set to NULL, fill in its IP address from the DNS. If it is multi-homed, create
2181 additional host items for the additional addresses, copying all the other
2182 fields, and randomizing the order.
2184 On IPv6 systems, A6 records are sought first (but only if support for A6 is
2185 configured - they may never become mainstream), then AAAA records are sought,
2186 and finally A records are sought as well.
2188 The host name may be changed if the DNS returns a different name - e.g. fully
2189 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2190 ensures that it points to the fully qualified name. However, this is the fully
2191 qualified version of the original name; if a CNAME is involved, the actual
2192 canonical host name may be different again, and so we get it directly from the
2193 relevant RR. Note that we do NOT change the mx field of the host item in this
2194 function as it may be called to set the addresses of hosts taken from MX
2198 host points to the host item we're filling in
2199 lastptr points to pointer to last host item in a chain of
2200 host items (may be updated if host is last and gets
2201 extended because multihomed)
2202 ignore_target_hosts list of hosts to ignore
2203 allow_ip if TRUE, recognize an IP address and return it
2204 fully_qualified_name if not NULL, return fully qualified name here if
2205 the contents are different (i.e. it must be preset
2208 Returns: HOST_FIND_FAILED couldn't find A record
2209 HOST_FIND_AGAIN try again later
2210 HOST_FOUND found AAAA and/or A record(s)
2211 HOST_IGNORED found, but all IPs ignored
2215 set_address_from_dns(host_item *host, host_item **lastptr,
2216 uschar *ignore_target_hosts, BOOL allow_ip, uschar **fully_qualified_name)
2219 host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
2220 BOOL v6_find_again = FALSE;
2223 /* If allow_ip is set, a name which is an IP address returns that value
2224 as its address. This is used for MX records when allow_mx_to_ip is set, for
2225 those sites that feel they have to flaunt the RFC rules. */
2227 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2230 if (ignore_target_hosts != NULL &&
2231 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2232 host->name, NULL) == OK)
2233 return HOST_IGNORED;
2236 host->address = host->name;
2237 host->port = PORT_NONE;
2241 /* On an IPv6 system, go round the loop up to three times, looking for A6 and
2242 AAAA records the first two times. However, unless doing standalone testing, we
2243 force an IPv4 lookup if the domain matches dns_ipv4_lookup is set. Since A6
2244 records look like being abandoned, support them only if explicitly configured
2245 to do so. On an IPv4 system, go round the loop once only, looking only for A
2250 if (dns_ipv4_lookup != NULL &&
2251 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2253 i = 0; /* look up A records only */
2255 #endif /* STAND_ALONE */
2258 i = 2; /* look up A6 and AAAA and A records */
2260 i = 1; /* look up AAAA and A records */
2261 #endif /* SUPPORT_A6 */
2263 /* The IPv4 world */
2265 #else /* HAVE_IPV6 */
2266 i = 0; /* look up A records only */
2267 #endif /* HAVE_IPV6 */
2271 static int types[] = { T_A, T_AAAA, T_A6 };
2272 int type = types[i];
2273 int randoffset = (i == 0)? 500 : 0; /* Ensures v6 sorts before v4 */
2277 int rc = dns_lookup(&dnsa, host->name, type, fully_qualified_name);
2279 /* We want to return HOST_FIND_AGAIN if one of the A, A6, or AAAA lookups
2280 fails or times out, but not if another one succeeds. (In the early
2281 IPv6 days there are name servers that always fail on AAAA, but are happy
2282 to give out an A record. We want to proceed with that A record.) */
2284 if (rc != DNS_SUCCEED)
2286 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2288 if (host->address != NULL) return HOST_FOUND; /* A6 or AAAA was found */
2289 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2290 return HOST_FIND_AGAIN;
2291 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2294 /* Tried for an A6 or AAAA record: remember if this was a temporary
2295 error, and look for the next record type. */
2297 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2301 /* Lookup succeeded: fill in the given host item with the first non-ignored
2302 address found; create additional items for any others. A single A6 record
2303 may generate more than one address. */
2305 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2307 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2309 if (rr->type == type)
2311 /* dns_address *da = dns_address_from_rr(&dnsa, rr); */
2314 da = dns_address_from_rr(&dnsa, rr);
2316 DEBUG(D_host_lookup)
2319 debug_printf("no addresses extracted from A6 RR for %s\n",
2323 /* This loop runs only once for A and AAAA records, but may run
2324 several times for an A6 record that generated multiple addresses. */
2326 for (; da != NULL; da = da->next)
2329 if (ignore_target_hosts != NULL &&
2330 verify_check_this_host(&ignore_target_hosts, NULL,
2331 host->name, da->address, NULL) == OK)
2333 DEBUG(D_host_lookup)
2334 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2339 /* If this is the first address, stick it in the given host block,
2340 and change the name if the returned RR has a different name. */
2342 if (thishostlast == NULL)
2344 if (strcmpic(host->name, rr->name) != 0)
2345 host->name = string_copy_dnsdomain(rr->name);
2346 host->address = da->address;
2347 host->port = PORT_NONE;
2348 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2349 host->status = hstatus_unknown;
2350 host->why = hwhy_unknown;
2351 thishostlast = host;
2354 /* Not the first address. Check for, and ignore, duplicates. Then
2355 insert in the chain at a random point. */
2362 /* End of our local chain is specified by "thishostlast". */
2364 for (next = host;; next = next->next)
2366 if (Ustrcmp(CS da->address, next->address) == 0) break;
2367 if (next == thishostlast) { next = NULL; break; }
2369 if (next != NULL) continue; /* With loop for next address */
2371 /* Not a duplicate */
2373 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2374 next = store_get(sizeof(host_item));
2376 /* New address goes first: insert the new block after the first one
2377 (so as not to disturb the original pointer) but put the new address
2378 in the original block. */
2380 if (new_sort_key < host->sort_key)
2384 host->address = da->address;
2385 host->port = PORT_NONE;
2386 host->sort_key = new_sort_key;
2387 if (thishostlast == host) thishostlast = next; /* Local last */
2388 if (*lastptr == host) *lastptr = next; /* Global last */
2391 /* Otherwise scan down the addresses for this host to find the
2392 one to insert after. */
2396 host_item *h = host;
2397 while (h != thishostlast)
2399 if (new_sort_key < h->next->sort_key) break;
2404 next->address = da->address;
2405 next->port = PORT_NONE;
2406 next->sort_key = new_sort_key;
2407 if (h == thishostlast) thishostlast = next; /* Local last */
2408 if (h == *lastptr) *lastptr = next; /* Global last */
2416 /* Control gets here only if the third lookup (the A record) succeeded.
2417 However, the address may not be filled in if it was ignored. */
2419 return (host->address == NULL)? HOST_IGNORED : HOST_FOUND;
2425 /*************************************************
2426 * Find IP addresses and names for host via DNS *
2427 *************************************************/
2429 /* The input is a host_item structure with the name filled in and the address
2430 field set to NULL. This may be in a chain of other host items. The lookup may
2431 result in more than one IP address, in which case we must created new host
2432 blocks for the additional addresses, and insert them into the chain. The
2433 original name may not be fully qualified. Use the fully_qualified_name argument
2434 to return the official name, as returned by the resolver.
2437 host point to initial host item
2438 ignore_target_hosts a list of hosts to ignore
2439 whichrrs flags indicating which RRs to look for:
2440 HOST_FIND_BY_SRV => look for SRV
2441 HOST_FIND_BY_MX => look for MX
2442 HOST_FIND_BY_A => look for A or AAAA
2443 also flags indicating how the lookup is done
2444 HOST_FIND_QUALIFY_SINGLE ) passed to the
2445 HOST_FIND_SEARCH_PARENTS ) resolver
2446 srv_service when SRV used, the service name
2447 srv_fail_domains DNS errors for these domains => assume nonexist
2448 mx_fail_domains DNS errors for these domains => assume nonexist
2449 fully_qualified_name if not NULL, return fully-qualified name
2450 removed set TRUE if local host was removed from the list
2452 Returns: HOST_FIND_FAILED Failed to find the host or domain;
2453 if there was a syntax error,
2454 host_find_failed_syntax is set.
2455 HOST_FIND_AGAIN Could not resolve at this time
2456 HOST_FOUND Host found
2457 HOST_FOUND_LOCAL The lowest MX record points to this
2458 machine, if MX records were found, or
2459 an A record that was found contains
2460 an address of the local host
2464 host_find_bydns(host_item *host, uschar *ignore_target_hosts, int whichrrs,
2465 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2466 uschar **fully_qualified_name, BOOL *removed)
2468 host_item *h, *last;
2476 /* Set the default fully qualified name to the incoming name, initialize the
2477 resolver if necessary, set up the relevant options, and initialize the flag
2478 that gets set for DNS syntax check errors. */
2480 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2481 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2482 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0);
2483 host_find_failed_syntax = FALSE;
2485 /* First, if requested, look for SRV records. The service name is given; we
2486 assume TCP progocol. DNS domain names are constrained to a maximum of 256
2487 characters, so the code below should be safe. */
2489 if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2492 uschar *temp_fully_qualified_name = buffer;
2495 (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2499 /* Search for SRV records. If the fully qualified name is different to
2500 the input name, pass back the new original domain, without the prepended
2503 rc = dns_lookup(&dnsa, buffer, ind_type, &temp_fully_qualified_name);
2504 if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2505 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2507 /* On DNS failures, we give the "try again" error unless the domain is
2508 listed as one for which we continue. */
2510 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2513 if (match_isinlist(host->name, &srv_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2516 return HOST_FIND_AGAIN;
2517 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2518 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2522 /* If we did not find any SRV records, search the DNS for MX records, if
2523 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2524 domain, and there's no point in going on to look for address records with the
2525 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2526 records. On DNS failures, we give the "try again" error unless the domain is
2527 listed as one for which we continue. */
2529 if (rc != DNS_SUCCEED && (whichrrs & HOST_FIND_BY_MX) != 0)
2532 rc = dns_lookup(&dnsa, host->name, ind_type, fully_qualified_name);
2533 if (rc == DNS_NOMATCH) return HOST_FIND_FAILED;
2534 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2537 if (match_isinlist(host->name, &mx_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2540 return HOST_FIND_AGAIN;
2541 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2542 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2546 /* If we haven't found anything yet, and we are requested to do so, try for an
2547 A or AAAA record. If we find it (or them) check to see that it isn't the local
2550 if (rc != DNS_SUCCEED)
2552 if ((whichrrs & HOST_FIND_BY_A) == 0)
2554 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2555 return HOST_FIND_FAILED;
2558 last = host; /* End of local chainlet */
2560 host->port = PORT_NONE;
2561 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2562 fully_qualified_name);
2564 /* If one or more address records have been found, check that none of them
2565 are local. Since we know the host items all have their IP addresses
2566 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2567 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2568 because set_address_from_dns() removes them. */
2570 if (rc == HOST_FOUND)
2571 rc = host_scan_for_local_hosts(host, &last, removed);
2573 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2575 /* When running in the test harness, sort into the order of addresses so as
2576 to get repeatability. */
2578 if (running_in_test_harness) sort_addresses(host, last);
2580 DEBUG(D_host_lookup)
2583 if (host->address != NULL)
2585 if (fully_qualified_name != NULL)
2586 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2587 for (h = host; h != last->next; h = h->next)
2588 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2589 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2590 (h->status >= hstatus_unusable)? US"*" : US"");
2597 /* We have found one or more MX or SRV records. Sort them according to
2598 precedence. Put the data for the first one into the existing host block, and
2599 insert new host_item blocks into the chain for the remainder. For equal
2600 precedences one is supposed to randomize the order. To make this happen, the
2601 sorting is actually done on the MX value * 1000 + a random number. This is put
2602 into a host field called sort_key.
2604 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2605 IPv6 address in preference. At this stage, we don't know what kind of address
2606 the host has. We choose a random number < 500; if later we find an A record
2607 first, we add 500 to the random number. Then for any other address records, we
2608 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2611 At this point we remove any duplicates that point to the same host, retaining
2612 only the one with the lowest precedence. We cannot yet check for precedence
2613 greater than that of the local host, because that test cannot be properly done
2614 until the addresses have been found - an MX record may point to a name for this
2615 host which is not the primary hostname. */
2617 last = NULL; /* Indicates that not even the first item is filled yet */
2619 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2621 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2624 int weight = 0; /* For SRV records */
2625 int port = PORT_NONE; /* For SRV records */
2626 uschar *s; /* MUST be unsigned for GETSHORT */
2629 if (rr->type != ind_type) continue;
2631 GETSHORT(precedence, s); /* Pointer s is advanced */
2633 /* For MX records, we use a random "weight" which causes multiple records of
2634 the same precedence to sort randomly. */
2636 if (ind_type == T_MX)
2638 weight = random_number(500);
2641 /* SRV records are specified with a port and a weight. The weight is used
2642 in a special algorithm. However, to start with, we just use it to order the
2643 records of equal priority (precedence). */
2647 GETSHORT(weight, s);
2651 /* Get the name of the host pointed to. */
2653 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2654 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2656 /* Check that we haven't already got this host on the chain; if we have,
2657 keep only the lower precedence. This situation shouldn't occur, but you
2658 never know what junk might get into the DNS (and this case has been seen on
2659 more than one occasion). */
2661 if (last != NULL) /* This is not the first record */
2663 host_item *prev = NULL;
2665 for (h = host; h != last->next; prev = h, h = h->next)
2667 if (strcmpic(h->name, data) == 0)
2669 DEBUG(D_host_lookup)
2670 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2671 (precedence > h->mx)? precedence : h->mx);
2672 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2673 if (h == host) /* Override first item */
2676 host->sort_key = precedence * 1000 + weight;
2680 /* Unwanted host item is not the first in the chain, so we can get
2681 get rid of it by cutting it out. */
2683 prev->next = h->next;
2684 if (h == last) last = prev;
2690 /* If this is the first MX or SRV record, put the data into the existing host
2691 block. Otherwise, add a new block in the correct place; if it has to be
2692 before the first block, copy the first block's data to a new second block. */
2696 host->name = string_copy_dnsdomain(data);
2697 host->address = NULL;
2699 host->mx = precedence;
2700 host->sort_key = precedence * 1000 + weight;
2701 host->status = hstatus_unknown;
2702 host->why = hwhy_unknown;
2706 /* Make a new host item and seek the correct insertion place */
2710 int sort_key = precedence * 1000 + weight;
2711 host_item *next = store_get(sizeof(host_item));
2712 next->name = string_copy_dnsdomain(data);
2713 next->address = NULL;
2715 next->mx = precedence;
2716 next->sort_key = sort_key;
2717 next->status = hstatus_unknown;
2718 next->why = hwhy_unknown;
2721 /* Handle the case when we have to insert before the first item. */
2723 if (sort_key < host->sort_key)
2730 if (last == host) last = next;
2733 /* Else scan down the items we have inserted as part of this exercise;
2734 don't go further. */
2738 for (h = host; h != last; h = h->next)
2740 if (sort_key < h->next->sort_key)
2742 next->next = h->next;
2748 /* Join on after the last host item that's part of this
2749 processing if we haven't stopped sooner. */
2753 next->next = last->next;
2760 NEXT_MX_RR: continue;
2763 /* If the list of hosts was obtained from SRV records, there are two things to
2764 do. First, if there is only one host, and it's name is ".", it means there is
2765 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2766 priority according to their weights, using an algorithm that is defined in RFC
2767 2782. The hosts are currently sorted by priority and weight. For each priority
2768 group we have to pick off one host and put it first, and then repeat for any
2769 remaining in the same priority group. */
2771 if (ind_type == T_SRV)
2775 if (host == last && host->name[0] == 0)
2777 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2778 return HOST_FIND_FAILED;
2781 DEBUG(D_host_lookup)
2783 debug_printf("original ordering of hosts from SRV records:\n");
2784 for (h = host; h != last->next; h = h->next)
2785 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2788 for (pptr = &host, h = host; h != last; pptr = &(h->next), h = h->next)
2793 /* Find the last following host that has the same precedence. At the same
2794 time, compute the sum of the weights and the running totals. These can be
2795 stored in the sort_key field. */
2797 for (hh = h; hh != last; hh = hh->next)
2799 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2802 if (hh->mx != hh->next->mx) break;
2805 /* If there's more than one host at this precedence (priority), we need to
2806 pick one to go first. */
2812 int randomizer = random_number(sum + 1);
2814 for (ppptr = pptr, hhh = h;
2816 ppptr = &(hhh->next), hhh = hhh->next)
2818 if (hhh->sort_key >= randomizer) break;
2821 /* hhh now points to the host that should go first; ppptr points to the
2822 place that points to it. Unfortunately, if the start of the minilist is
2823 the start of the entire list, we can't just swap the items over, because
2824 we must not change the value of host, since it is passed in from outside.
2825 One day, this could perhaps be changed.
2827 The special case is fudged by putting the new item *second* in the chain,
2828 and then transferring the data between the first and second items. We
2829 can't just swap the first and the chosen item, because that would mean
2830 that an item with zero weight might no longer be first. */
2834 *ppptr = hhh->next; /* Cuts it out of the chain */
2838 host_item temp = *h;
2841 hhh->next = temp.next;
2847 hhh->next = h; /* The rest of the chain follows it */
2848 *pptr = hhh; /* It takes the place of h */
2849 h = hhh; /* It's now the start of this minilist */
2854 /* A host has been chosen to be first at this priority and h now points
2855 to this host. There may be others at the same priority, or others at a
2856 different priority. Before we leave this host, we need to put back a sort
2857 key of the traditional MX kind, in case this host is multihomed, because
2858 the sort key is used for ordering the multiple IP addresses. We do not need
2859 to ensure that these new sort keys actually reflect the order of the hosts,
2862 h->sort_key = h->mx * 1000 + random_number(500);
2863 } /* Move on to the next host */
2866 /* Now we have to ensure addresses exist for all the hosts. We have ensured
2867 above that the names in the host items are all unique. The addresses may have
2868 been returned in the additional data section of the DNS query. Because it is
2869 more expensive to scan the returned DNS records (because you have to expand the
2870 names) we do a single scan over them, and multiple scans of the chain of host
2871 items (which is typically only 3 or 4 long anyway.) Add extra host items for
2872 multi-homed hosts. */
2874 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ADDITIONAL);
2876 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2879 int status = hstatus_unknown;
2880 int why = hwhy_unknown;
2885 && rr->type != T_AAAA
2892 /* Find the first host that matches this record's name. If there isn't
2893 one, move on to the next RR. */
2895 for (h = host; h != last->next; h = h->next)
2896 { if (strcmpic(h->name, rr->name) == 0) break; }
2897 if (h == last->next) continue;
2899 /* For IPv4 addresses, add 500 to the random part of the sort key, to ensure
2900 they sort after IPv6 addresses. */
2902 randoffset = (rr->type == T_A)? 500 : 0;
2904 /* Get the list of textual addresses for this RR. There may be more than one
2905 if it is an A6 RR. Then loop to handle multiple addresses from an A6 record.
2906 If there are none, nothing will get done - the record is ignored. */
2908 for (da = dns_address_from_rr(&dnsa, rr); da != NULL; da = da->next)
2910 /* Set status for an ignorable host. */
2913 if (ignore_target_hosts != NULL &&
2914 verify_check_this_host(&ignore_target_hosts, NULL, h->name,
2915 da->address, NULL) == OK)
2917 DEBUG(D_host_lookup)
2918 debug_printf("ignored host %s [%s]\n", h->name, da->address);
2919 status = hstatus_unusable;
2924 /* If the address is already set for this host, it may be that
2925 we just have a duplicate DNS record. Alternatively, this may be
2926 a multi-homed host. Search all items with the same host name
2927 (they will all be together) and if this address is found, skip
2930 if (h->address != NULL)
2933 host_item *thishostlast;
2938 if (hh->address != NULL && Ustrcmp(CS da->address, hh->address) == 0)
2939 goto DNS_NEXT_RR; /* Need goto to escape from inner loop */
2943 while (hh != last->next && strcmpic(hh->name, rr->name) == 0);
2945 /* We have a multi-homed host, since we have a new address for
2946 an existing name. Create a copy of the current item, and give it
2947 the new address. RRs can be in arbitrary order, but one is supposed
2948 to randomize the addresses of multi-homed hosts, so compute a new
2949 sorting key and do that. [Latest SMTP RFC says not to randomize multi-
2950 homed hosts, but to rely on the resolver. I'm not happy about that -
2951 caching in the resolver will not rotate as often as the name server
2954 new_sort_key = h->mx * 1000 + random_number(500) + randoffset;
2955 hh = store_get(sizeof(host_item));
2957 /* New address goes first: insert the new block after the first one
2958 (so as not to disturb the original pointer) but put the new address
2959 in the original block. */
2961 if (new_sort_key < h->sort_key)
2963 *hh = *h; /* Note: copies the port */
2965 h->address = da->address;
2966 h->sort_key = new_sort_key;
2971 /* Otherwise scan down the addresses for this host to find the
2972 one to insert after. */
2976 while (h != thishostlast)
2978 if (new_sort_key < h->next->sort_key) break;
2981 *hh = *h; /* Note: copies the port */
2983 hh->address = da->address;
2984 hh->sort_key = new_sort_key;
2985 hh->status = status;
2989 if (h == last) last = hh; /* Inserted after last */
2992 /* The existing item doesn't have its address set yet, so just set it.
2993 Ensure that an IPv4 address gets its sort key incremented in case an IPv6
2994 address is found later. */
2998 h->address = da->address; /* Port should be set already */
3001 h->sort_key += randoffset;
3003 } /* Loop for addresses extracted from one RR */
3005 /* Carry on to the next RR. It would be nice to be able to be able to stop
3006 when every host on the list has an address, but we can't be sure there won't
3007 be an additional address for a multi-homed host further down the list, so
3008 we have to continue to the end. */
3010 DNS_NEXT_RR: continue;
3013 /* Set the default yield to failure */
3015 yield = HOST_FIND_FAILED;
3017 /* If we haven't found all the addresses in the additional section, we
3018 need to search for A or AAAA records explicitly. The names shouldn't point to
3019 CNAMES, but we use the general lookup function that handles them, just
3020 in case. If any lookup gives a soft error, change the default yield.
3022 For these DNS lookups, we must disable qualify_single and search_parents;
3023 otherwise invalid host names obtained from MX or SRV records can cause trouble
3024 if they happen to match something local. */
3026 dns_init(FALSE, FALSE);
3028 for (h = host; h != last->next; h = h->next)
3030 if (h->address != NULL || h->status == hstatus_unusable) continue;
3031 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip, NULL);
3032 if (rc != HOST_FOUND)
3034 h->status = hstatus_unusable;
3035 if (rc == HOST_FIND_AGAIN)
3038 h->why = hwhy_deferred;
3041 h->why = (rc == HOST_IGNORED)? hwhy_ignored : hwhy_failed;
3045 /* Scan the list for any hosts that are marked unusable because they have
3046 been explicitly ignored, and remove them from the list, as if they did not
3047 exist. If we end up with just a single, ignored host, flatten its fields as if
3048 nothing was found. */
3050 if (ignore_target_hosts != NULL)
3052 host_item *prev = NULL;
3053 for (h = host; h != last->next; h = h->next)
3056 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
3058 else if (prev == NULL) /* First host is ignored */
3060 if (h != last) /* First is not last */
3062 if (h->next == last) last = h; /* Overwrite it with next */
3063 *h = *(h->next); /* and reprocess it. */
3064 goto REDO; /* C should have redo, like Perl */
3067 else /* Ignored host is not first - */
3069 prev->next = h->next;
3070 if (h == last) last = prev;
3074 if (host->why == hwhy_ignored) host->address = NULL;
3077 /* There is still one complication in the case of IPv6. Although the code above
3078 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3079 hosts, it doesn't do this for addresses that apply to different hosts with the
3080 same MX precedence, because the sorting on MX precedence happens first. So we
3081 have to make another pass to check for this case. We ensure that, within a
3082 single MX preference value, IPv6 addresses come first. This can separate the
3083 addresses of a multihomed host, but that should not matter. */
3088 for (h = host; h != last; h = h->next)
3091 host_item *next = h->next;
3092 if (h->mx != next->mx || /* If next is different MX value */
3093 (h->sort_key % 1000) < 500 || /* OR this one is IPv6 */
3094 (next->sort_key % 1000) >= 500) /* OR next is IPv4 */
3095 continue; /* move on to next */
3097 temp.next = next->next;
3105 /* When running in the test harness, we want the hosts always to be in the same
3106 order so that the debugging output is the same and can be compared. Having a
3107 fixed set of "random" numbers doesn't actually achieve this, because the RRs
3108 come back from the resolver in a random order, so the non-random random numbers
3109 get used in a different order. We therefore have to sort the hosts that have
3110 the same MX values. We chose do to this by their name and then by IP address.
3111 The fact that the sort is slow matters not - this is testing only! */
3113 if (running_in_test_harness)
3119 for (h = host; h != last; h = h->next)
3121 int c = Ustrcmp(h->name, h->next->name);
3122 if (c == 0) c = Ustrcmp(h->address, h->next->address);
3123 if (h->mx == h->next->mx && c > 0)
3125 host_item *next = h->next;
3126 host_item temp = *h;
3127 temp.next = next->next;
3138 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3139 whose IP addresses are on the local host. If any are found, all hosts with the
3140 same or higher MX values are removed. However, if the local host has the lowest
3141 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3142 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3143 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3144 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3145 be HOST_FIND_FAILED. */
3147 host_remove_duplicates(host, &last);
3148 rc = host_scan_for_local_hosts(host, &last, removed);
3149 if (rc != HOST_FIND_FAILED) yield = rc;
3151 DEBUG(D_host_lookup)
3153 if (fully_qualified_name != NULL)
3154 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3155 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3156 (yield == HOST_FOUND)? "HOST_FOUND" :
3157 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
3158 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3159 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3161 for (h = host; h != last->next; h = h->next)
3163 debug_printf(" %s %s MX=%d ", h->name,
3164 (h->address == NULL)? US"<null>" : h->address, h->mx);
3165 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3166 if (h->status >= hstatus_unusable) debug_printf("*");
3177 /*************************************************
3178 **************************************************
3179 * Stand-alone test program *
3180 **************************************************
3181 *************************************************/
3185 int main(int argc, char **cargv)
3188 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
3189 BOOL byname = FALSE;
3190 BOOL qualify_single = TRUE;
3191 BOOL search_parents = FALSE;
3192 uschar **argv = USS cargv;
3195 primary_hostname = US"";
3196 store_pool = POOL_MAIN;
3197 debug_selector = D_host_lookup|D_interface;
3198 debug_file = stdout;
3199 debug_fd = fileno(debug_file);
3201 printf("Exim stand-alone host functions test\n");
3203 host_find_interfaces();
3204 debug_selector = D_host_lookup | D_dns;
3206 if (argc > 1) primary_hostname = argv[1];
3208 /* So that debug level changes can be done first */
3210 dns_init(qualify_single, search_parents);
3212 printf("Testing host lookup\n");
3214 while (Ufgets(buffer, 256, stdin) != NULL)
3217 int len = Ustrlen(buffer);
3218 uschar *fully_qualified_name;
3220 while (len > 0 && isspace(buffer[len-1])) len--;
3223 if (Ustrcmp(buffer, "q") == 0) break;
3225 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3226 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3227 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3228 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3229 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3230 else if (Ustrcmp(buffer, "srv+a") == 0)
3231 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3232 else if (Ustrcmp(buffer, "srv+mx") == 0)
3233 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3234 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3235 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
3236 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3237 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3238 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3239 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3240 else if (Ustrcmp(buffer, "test_harness") == 0)
3241 running_in_test_harness = !running_in_test_harness;
3242 else if (Ustrcmp(buffer, "res_debug") == 0)
3244 _res.options ^= RES_DEBUG;
3246 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3248 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3249 _res.retrans = dns_retrans;
3251 else if (Ustrncmp(buffer, "retry", 5) == 0)
3253 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3254 _res.retry = dns_retry;
3258 int flags = whichrrs;
3264 h.status = hstatus_unknown;
3265 h.why = hwhy_unknown;
3268 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3269 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3272 host_find_byname(&h, NULL, &fully_qualified_name, TRUE)
3274 host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3275 &fully_qualified_name, NULL);
3277 if (rc == HOST_FIND_FAILED) printf("Failed\n");
3278 else if (rc == HOST_FIND_AGAIN) printf("Again\n");
3279 else if (rc == HOST_FOUND_LOCAL) printf("Local\n");
3285 printf("Testing host_aton\n");
3287 while (Ufgets(buffer, 256, stdin) != NULL)
3291 int len = Ustrlen(buffer);
3293 while (len > 0 && isspace(buffer[len-1])) len--;
3296 if (Ustrcmp(buffer, "q") == 0) break;
3298 len = host_aton(buffer, x);
3299 printf("length = %d ", len);
3300 for (i = 0; i < len; i++)
3302 printf("%04x ", (x[i] >> 16) & 0xffff);
3303 printf("%04x ", x[i] & 0xffff);
3310 printf("Testing host_name_lookup\n");
3312 while (Ufgets(buffer, 256, stdin) != NULL)
3314 int len = Ustrlen(buffer);
3315 while (len > 0 && isspace(buffer[len-1])) len--;
3317 if (Ustrcmp(buffer, "q") == 0) break;
3318 sender_host_address = buffer;
3319 sender_host_name = NULL;
3320 sender_host_aliases = NULL;
3321 host_lookup_msg = US"";
3322 host_lookup_failed = FALSE;
3323 if (host_name_lookup() == FAIL) /* Debug causes printing */
3324 printf("Lookup failed:%s\n", host_lookup_msg);
3332 #endif /* STAND_ALONE */