1 /* $Cambridge: exim/src/src/host.c,v 1.12 2005/08/09 13:31:52 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 host -> the first host item
107 last -> the last host item
113 sort_addresses(host_item *host, host_item *last)
120 for (h = host; h != last; h = h->next)
122 if ((Ustrchr(h->address, ':') == NULL) !=
123 (Ustrchr(h->next->address, ':') == NULL))
125 if (Ustrcmp(h->address, h->next->address) > 0)
127 uschar *temp = h->address;
128 h->address = h->next->address;
129 h->next->address = temp;
138 /*************************************************
139 * Build chain of host items from list *
140 *************************************************/
142 /* This function builds a chain of host items from a textual list of host
143 names. It does not do any lookups. If randomize is true, the chain is build in
144 a randomized order. There may be multiple groups of independently randomized
145 hosts; they are delimited by a host name consisting of just "+".
148 anchor anchor for the chain
150 randomize TRUE for randomizing
156 host_build_hostlist(host_item **anchor, uschar *list, BOOL randomize)
159 int fake_mx = MX_NONE; /* This value is actually -1 */
163 if (list == NULL) return;
164 if (randomize) fake_mx--; /* Start at -2 for randomizing */
168 while ((name = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
172 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
173 { /* ignore if not randomizing */
174 if (randomize) fake_mx--;
178 h = store_get(sizeof(host_item));
179 h->name = string_copy(name);
183 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
184 h->status = hstatus_unknown;
185 h->why = hwhy_unknown;
195 host_item *hh = *anchor;
196 if (h->sort_key < hh->sort_key)
203 while (hh->next != NULL && h->sort_key >= (hh->next)->sort_key)
216 /*************************************************
217 * Extract port from address string *
218 *************************************************/
220 /* In the spool file, and in the -oMa and -oMi options, a host plus port is
221 given as an IP address followed by a dot and a port number. This function
224 An alternative format for the -oMa and -oMi options is [ip address]:port which
225 is what Exim 4 uses for output, because it seems to becoming commonly used,
226 whereas the dot form confuses some programs/people. So we recognize that form
230 address points to the string; if there is a port, the '.' in the string
231 is overwritten with zero to terminate the address; if the string
232 is in the [xxx]:ppp format, the address is shifted left and the
235 Returns: 0 if there is no port, else the port number. If there's a syntax
236 error, leave the incoming address alone, and return 0.
240 host_address_extract_port(uschar *address)
245 /* Handle the "bracketed with colon on the end" format */
249 uschar *rb = address + 1;
250 while (*rb != 0 && *rb != ']') rb++;
251 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
254 port = Ustrtol(rb + 1, &endptr, 10);
255 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
257 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
258 memmove(address, address + 1, rb - address - 2);
262 /* Handle the "dot on the end" format */
266 int skip = -3; /* Skip 3 dots in IPv4 addresses */
268 while (*(++address) != 0)
271 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
272 else if (ch == '.' && skip++ >= 0) break;
274 if (*address == 0) return 0;
275 port = Ustrtol(address + 1, &endptr, 10);
276 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
284 /*************************************************
285 * Get port from a host item's name *
286 *************************************************/
288 /* This function is called when finding the IP address for a host that is in a
289 list of hosts explicitly configured, such as in the manualroute router, or in a
290 fallback hosts list. We see if there is a port specification at the end of the
291 host name, and if so, remove it. A minimum length of 3 is required for the
292 original name; nothing shorter is recognized as having a port.
294 We test for a name ending with a sequence of digits; if preceded by colon we
295 have a port if the character before the colon is ] and the name starts with [
296 or if there are no other colons in the name (i.e. it's not an IPv6 address).
298 Arguments: pointer to the host item
299 Returns: a port number or PORT_NONE
303 host_item_get_port(host_item *h)
307 int len = Ustrlen(h->name);
309 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
311 /* Extract potential port number */
316 while (p > h->name + 1 && isdigit(*p))
318 port += (*p-- - '0') * x;
322 /* The smallest value of p at this point is h->name + 1. */
324 if (*p != ':') return PORT_NONE;
326 if (p[-1] == ']' && h->name[0] == '[')
327 h->name = string_copyn(h->name + 1, p - h->name - 2);
328 else if (Ustrchr(h->name, ':') == p)
329 h->name = string_copyn(h->name, p - h->name);
330 else return PORT_NONE;
332 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
338 #ifndef STAND_ALONE /* Omit when standalone testing */
340 /*************************************************
341 * Build sender_fullhost and sender_rcvhost *
342 *************************************************/
344 /* This function is called when sender_host_name and/or sender_helo_name
345 have been set. Or might have been set - for a local message read off the spool
346 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
349 (a) No sender_host_name or sender_helo_name: "[ip address]"
350 (b) Just sender_host_name: "host_name [ip address]"
351 (c) Just sender_helo_name: "(helo_name) [ip address]"
352 (d) The two are identical: "host_name [ip address]"
353 (e) The two are different: "host_name (helo_name) [ip address]"
355 If log_incoming_port is set, the sending host's port number is added to the IP
358 This function also builds sender_rcvhost for use in Received: lines, whose
359 syntax is a bit different. This value also includes the RFC 1413 identity.
360 There wouldn't be two different variables if I had got all this right in the
363 Because this data may survive over more than one incoming SMTP message, it has
364 to be in permanent store.
371 host_build_sender_fullhost(void)
374 int old_pool = store_pool;
376 if (sender_host_address == NULL) return;
378 store_pool = POOL_PERM;
380 /* Set up address, with or without the port. After discussion, it seems that
381 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
382 use this directly as the first item for Received: because it ain't an RFC 2822
385 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
386 if ((log_extra_selector & LX_incoming_port) == 0 || sender_host_port <= 0)
387 *(Ustrrchr(address, ':')) = 0;
389 /* Host name is not verified */
391 if (sender_host_name == NULL)
393 uschar *portptr = Ustrstr(address, "]:");
396 int adlen; /* Sun compiler doesn't like ++ in initializers */
398 adlen = (portptr == NULL)? Ustrlen(address) : (++portptr - address);
399 sender_fullhost = (sender_helo_name == NULL)? address :
400 string_sprintf("(%s) %s", sender_helo_name, address);
402 sender_rcvhost = string_cat(NULL, &size, &ptr, address, adlen);
404 if (sender_ident != NULL || sender_helo_name != NULL || portptr != NULL)
407 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US" (", 2);
411 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2, US"port=",
414 if (sender_helo_name != NULL)
415 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
416 (firstptr == ptr)? US"helo=" : US" helo=", sender_helo_name);
418 if (sender_ident != NULL)
419 sender_rcvhost = string_append(sender_rcvhost, &size, &ptr, 2,
420 (firstptr == ptr)? US"ident=" : US" ident=", sender_ident);
422 sender_rcvhost = string_cat(sender_rcvhost, &size, &ptr, US")", 1);
425 sender_rcvhost[ptr] = 0; /* string_cat() always leaves room */
427 /* Release store, because string_cat allocated a minimum of 100 bytes that
428 are rarely completely used. */
430 store_reset(sender_rcvhost + ptr + 1);
433 /* Host name is known and verified. */
438 if (sender_helo_name == NULL ||
439 strcmpic(sender_host_name, sender_helo_name) == 0 ||
440 (sender_helo_name[0] == '[' &&
441 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']' &&
442 strncmpic(sender_helo_name+1, sender_host_address, len - 2) == 0))
444 sender_fullhost = string_sprintf("%s %s", sender_host_name, address);
445 sender_rcvhost = (sender_ident == NULL)?
446 string_sprintf("%s (%s)", sender_host_name, address) :
447 string_sprintf("%s (%s ident=%s)", sender_host_name, address,
452 sender_fullhost = string_sprintf("%s (%s) %s", sender_host_name,
453 sender_helo_name, address);
454 sender_rcvhost = (sender_ident == NULL)?
455 string_sprintf("%s (%s helo=%s)", sender_host_name,
456 address, sender_helo_name) :
457 string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
458 address, sender_helo_name, sender_ident);
462 store_pool = old_pool;
464 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
465 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
470 /*************************************************
471 * Build host+ident message *
472 *************************************************/
474 /* Used when logging rejections and various ACL and SMTP incidents. The text
475 return depends on whether sender_fullhost and sender_ident are set or not:
477 no ident, no host => U=unknown
478 no ident, host set => H=sender_fullhost
479 ident set, no host => U=ident
480 ident set, host set => H=sender_fullhost U=ident
483 useflag TRUE if first item to be flagged (H= or U=); if there are two
484 items, the second is always flagged
486 Returns: pointer to a string in big_buffer
490 host_and_ident(BOOL useflag)
492 if (sender_fullhost == NULL)
494 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag? "U=" : "",
495 (sender_ident == NULL)? US"unknown" : sender_ident);
499 uschar *flag = useflag? US"H=" : US"";
500 uschar *iface = US"";
501 if ((log_extra_selector & LX_incoming_interface) != 0 &&
502 interface_address != NULL)
503 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
504 if (sender_ident == NULL)
505 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
506 flag, sender_fullhost, iface);
508 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
509 flag, sender_fullhost, iface, sender_ident);
514 #endif /* STAND_ALONE */
519 /*************************************************
520 * Build list of local interfaces *
521 *************************************************/
523 /* This function interprets the contents of the local_interfaces or
524 extra_local_interfaces options, and creates an ip_address_item block for each
525 item on the list. There is no special interpretation of any IP addresses; in
526 particular, 0.0.0.0 and ::0 are returned without modification. If any address
527 includes a port, it is set in the block. Otherwise the port value is set to
532 name the name of the option being expanded
534 Returns: a chain of ip_address_items, each containing to a textual
535 version of an IP address, and a port number (host order) or
536 zero if no port was given with the address
540 host_build_ifacelist(uschar *list, uschar *name)
545 ip_address_item *yield = NULL;
546 ip_address_item *last = NULL;
547 ip_address_item *next;
549 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
551 int port = host_address_extract_port(s); /* Leaves just the IP address */
552 if (string_is_ip_address(s, NULL) == 0)
553 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
556 /* This use of strcpy() is OK because we have checked that s is a valid IP
557 address above. The field in the ip_address_item is large enough to hold an
560 next = store_get(sizeof(ip_address_item));
562 Ustrcpy(next->address, s);
564 next->v6_include_v4 = FALSE;
566 if (yield == NULL) yield = last = next; else
580 /*************************************************
581 * Find addresses on local interfaces *
582 *************************************************/
584 /* This function finds the addresses of local IP interfaces. These are used
585 when testing for routing to the local host. As the function may be called more
586 than once, the list is preserved in permanent store, pointed to by a static
587 variable, to save doing the work more than once per process.
589 The generic list of interfaces is obtained by calling host_build_ifacelist()
590 for local_interfaces and extra_local_interfaces. This list scanned to remove
591 duplicates (which may exist with different ports - not relevant here). If
592 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
593 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
594 obtained from os_find_running_interfaces().
597 Returns: a chain of ip_address_items, each containing to a textual
598 version of an IP address; the port numbers are not relevant
602 /* First, a local subfunction to add an interface to a list in permanent store,
603 but only if there isn't a previous copy of that address on the list. */
605 static ip_address_item *
606 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
608 ip_address_item *ipa2;
609 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
610 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
611 ipa2 = store_get_perm(sizeof(ip_address_item));
618 /* This is the globally visible function */
621 host_find_interfaces(void)
623 ip_address_item *running_interfaces = NULL;
625 if (local_interface_data == NULL)
627 void *reset_item = store_get(0);
628 ip_address_item *dlist = host_build_ifacelist(local_interfaces,
629 US"local_interfaces");
630 ip_address_item *xlist = host_build_ifacelist(extra_local_interfaces,
631 US"extra_local_interfaces");
632 ip_address_item *ipa;
634 if (dlist == NULL) dlist = xlist; else
636 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
640 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
642 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
643 Ustrcmp(ipa->address, "::0") == 0)
645 ip_address_item *ipa2;
646 BOOL ipv6 = ipa->address[0] == ':';
647 if (running_interfaces == NULL)
648 running_interfaces = os_find_running_interfaces();
649 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
651 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
652 local_interface_data = add_unique_interface(local_interface_data,
658 local_interface_data = add_unique_interface(local_interface_data, ipa);
661 debug_printf("Configured local interface: address=%s", ipa->address);
662 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
667 store_reset(reset_item);
670 return local_interface_data;
677 /*************************************************
678 * Convert network IP address to text *
679 *************************************************/
681 /* Given an IPv4 or IPv6 address in binary, convert it to a text
682 string and return the result in a piece of new store. The address can
683 either be given directly, or passed over in a sockaddr structure. Note
684 that this isn't the converse of host_aton() because of byte ordering
685 differences. See host_nmtoa() below.
688 type if < 0 then arg points to a sockaddr, else
689 either AF_INET or AF_INET6
690 arg points to a sockaddr if type is < 0, or
691 points to an IPv4 address (32 bits), or
692 points to an IPv6 address (128 bits),
693 in both cases, in network byte order
694 buffer if NULL, the result is returned in gotten store;
695 else points to a buffer to hold the answer
696 portptr points to where to put the port number, if non NULL; only
699 Returns: pointer to character string
703 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
707 /* The new world. It is annoying that we have to fish out the address from
708 different places in the block, depending on what kind of address it is. It
709 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
710 function inet_ntoa() returns just uschar *, and some picky compilers insist
711 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
714 uschar addr_buffer[46];
717 int family = ((struct sockaddr *)arg)->sa_family;
718 if (family == AF_INET6)
720 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
721 yield = (uschar *)inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
722 sizeof(addr_buffer));
723 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
727 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
728 yield = (uschar *)inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
729 sizeof(addr_buffer));
730 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
735 yield = (uschar *)inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
738 /* If the result is a mapped IPv4 address, show it in V4 format. */
740 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
742 #else /* HAVE_IPV6 */
748 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
749 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
752 yield = US inet_ntoa(*((struct in_addr *)arg));
755 /* If there is no buffer, put the string into some new store. */
757 if (buffer == NULL) return string_copy(yield);
759 /* Callers of this function with a non-NULL buffer must ensure that it is
760 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
761 makes this use of strcpy() OK. */
763 Ustrcpy(buffer, yield);
770 /*************************************************
771 * Convert address text to binary *
772 *************************************************/
774 /* Given the textual form of an IP address, convert it to binary in an
775 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
776 The result has the first byte in the most significant byte of the first int. In
777 other words, the result is not in network byte order, but in host byte order.
778 As a result, this is not the converse of host_ntoa(), which expects network
779 byte order. See host_nmtoa() below.
782 address points to the textual address, checked for syntax
783 bin points to an array of 4 ints
785 Returns: the number of ints used
789 host_aton(uschar *address, int *bin)
794 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
795 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
796 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
799 if (Ustrchr(address, ':') != NULL)
802 uschar *component[8];
803 BOOL ipv4_ends = FALSE;
809 /* If the address starts with a colon, it will start with two colons.
810 Just lose the first one, which will leave a null first component. */
814 /* Split the address into components separated by colons. The input address
815 is supposed to be checked for syntax. There was a case where this was
816 overlooked; to guard against that happening again, check here and crash if
817 there are too many components. */
819 while (*p != 0 && *p != '%')
821 int len = Ustrcspn(p, ":%");
822 if (len == 0) nulloffset = ci;
823 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
824 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
831 /* If the final component contains a dot, it is a trailing v4 address.
832 As the syntax is known to be checked, just set up for a trailing
833 v4 address and restrict the v6 part to 6 components. */
835 if (Ustrchr(component[ci-1], '.') != NULL)
837 address = component[--ci];
843 /* If there are fewer than 6 or 8 components, we have to insert some
844 more empty ones in the middle. */
848 int insert_count = v6count - ci;
849 for (i = v6count-1; i > nulloffset + insert_count; i--)
850 component[i] = component[i - insert_count];
851 while (i > nulloffset) component[i--] = US"";
854 /* Now turn the components into binary in pairs and bung them
855 into the vector of ints. */
857 for (i = 0; i < v6count; i += 2)
858 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
859 Ustrtol(component[i+1], NULL, 16);
861 /* If there was no terminating v4 component, we are done. */
863 if (!ipv4_ends) return 4;
866 /* Handle IPv4 address */
868 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
869 bin[v4offset] = (x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
874 /*************************************************
875 * Apply mask to an IP address *
876 *************************************************/
878 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
882 count the number of ints
883 binary points to the ints to be masked
884 mask the count of ms bits to leave, or -1 if no masking
890 host_mask(int count, int *binary, int mask)
893 if (mask < 0) mask = 99999;
894 for (i = 0; i < count; i++)
897 if (mask == 0) wordmask = 0;
900 wordmask = (-1) << (32 - mask);
908 binary[i] &= wordmask;
915 /*************************************************
916 * Convert masked IP address in ints to text *
917 *************************************************/
919 /* We can't use host_ntoa() because it assumes the binary values are in network
920 byte order, and these are the result of host_aton(), which puts them in ints in
921 host byte order. Also, we really want IPv6 addresses to be in a canonical
922 format, so we output them with no abbreviation. In a number of cases we can't
923 use the normal colon separator in them because it terminates keys in lsearch
924 files, so we want to use dot instead. There's an argument that specifies what
925 to use for IPv6 addresses.
928 count 1 or 4 (number of ints)
929 binary points to the ints
930 mask mask value; if < 0 don't add to result
931 buffer big enough to hold the result
932 sep component separator character for IPv6 addresses
934 Returns: the number of characters placed in buffer, not counting
939 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
947 for (i = 24; i >= 0; i -= 8)
949 sprintf(CS tt, "%d.", (j >> i) & 255);
955 for (i = 0; i < 4; i++)
958 sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
963 tt--; /* lose final separator */
969 sprintf(CS tt, "/%d", mask);
978 /*************************************************
979 * Check port for tls_on_connect *
980 *************************************************/
982 /* This function checks whether a given incoming port is configured for tls-
983 on-connect. It is called from the daemon and from inetd handling. If the global
984 option tls_on_connect is already set, all ports operate this way. Otherwise, we
985 check the tls_on_connect_ports option for a list of ports.
987 Argument: a port number
988 Returns: TRUE or FALSE
992 host_is_tls_on_connect_port(int port)
996 uschar *list = tls_on_connect_ports;
999 if (tls_on_connect) return TRUE;
1001 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
1004 int lport = Ustrtol(s, &end, 10);
1005 if (*end != 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "tls_on_connect_ports "
1006 "contains \"%s\", which is not a port number: exim abandoned", s);
1007 if (lport == port) return TRUE;
1015 /*************************************************
1016 * Check whether host is in a network *
1017 *************************************************/
1019 /* This function checks whether a given IP address matches a pattern that
1020 represents either a single host, or a network (using CIDR notation). The caller
1021 of this function must check the syntax of the arguments before calling it.
1024 host string representation of the ip-address to check
1025 net string representation of the network, with optional CIDR mask
1026 maskoffset offset to the / that introduces the mask in the key
1027 zero if there is no mask
1030 TRUE the host is inside the network
1031 FALSE the host is NOT inside the network
1035 host_is_in_net(uschar *host, uschar *net, int maskoffset)
1041 int size = host_aton(net, address);
1044 /* No mask => all bits to be checked */
1046 if (maskoffset == 0) mlen = 99999; /* Big number */
1047 else mlen = Uatoi(net + maskoffset + 1);
1049 /* Convert the incoming address to binary. */
1051 insize = host_aton(host, incoming);
1053 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1054 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1055 ::ffff:<v4address>, to IPv4 format. */
1057 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1058 incoming[2] == 0xffff)
1061 incoming[0] = incoming[3];
1064 /* No match if the sizes don't agree. */
1066 if (insize != size) return FALSE;
1068 /* Else do the masked comparison. */
1070 for (i = 0; i < size; i++)
1073 if (mlen == 0) mask = 0;
1076 mask = (-1) << (32 - mlen);
1084 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1092 /*************************************************
1093 * Scan host list for local hosts *
1094 *************************************************/
1096 /* Scan through a chain of addresses and check whether any of them is the
1097 address of an interface on the local machine. If so, remove that address and
1098 any previous ones with the same MX value, and all subsequent ones (which will
1099 have greater or equal MX values) from the chain. Note: marking them as unusable
1100 is NOT the right thing to do because it causes the hosts not to be used for
1101 other domains, for which they may well be correct.
1103 The hosts may be part of a longer chain; we only process those between the
1104 initial pointer and the "last" pointer.
1106 There is also a list of "pseudo-local" host names which are checked against the
1107 host names. Any match causes that host item to be treated the same as one which
1108 matches a local IP address.
1110 If the very first host is a local host, then all MX records had a precedence
1111 greater than or equal to that of the local host. Either there's a problem in
1112 the DNS, or an apparently remote name turned out to be an abbreviation for the
1113 local host. Give a specific return code, and let the caller decide what to do.
1114 Otherwise, give a success code if at least one host address has been found.
1117 host pointer to the first host in the chain
1118 lastptr pointer to pointer to the last host in the chain (may be updated)
1119 removed if not NULL, set TRUE if some local addresses were removed
1123 HOST_FOUND if there is at least one host with an IP address on the chain
1124 and an MX value less than any MX value associated with the
1126 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1127 the host addresses were obtained from A records or
1128 gethostbyname(), the MX values are set to -1.
1129 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1133 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1135 int yield = HOST_FIND_FAILED;
1136 host_item *last = *lastptr;
1137 host_item *prev = NULL;
1140 if (removed != NULL) *removed = FALSE;
1142 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1144 for (h = host; h != last->next; h = h->next)
1147 if (hosts_treat_as_local != NULL)
1150 uschar *save = deliver_domain;
1151 deliver_domain = h->name; /* set $domain */
1152 rc = match_isinlist(string_copylc(h->name), &hosts_treat_as_local, 0,
1153 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1154 deliver_domain = save;
1155 if (rc == OK) goto FOUND_LOCAL;
1159 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1160 for 127.0.0.1 and refers to the local host. We therefore force it always to
1161 be treated as local. */
1163 if (h->address != NULL)
1165 ip_address_item *ip;
1166 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1167 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1168 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1169 yield = HOST_FOUND; /* At least one remote address has been found */
1172 /* Update prev to point to the last host item before any that have
1173 the same MX value as the one we have just considered. */
1175 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1178 return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1180 /* A host whose IP address matches a local IP address, or whose name matches
1181 something in hosts_treat_as_local has been found. */
1187 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1188 "local host has lowest MX\n" :
1189 "local host found for non-MX address\n");
1190 return HOST_FOUND_LOCAL;
1193 HDEBUG(D_host_lookup)
1195 debug_printf("local host in host list - removed hosts:\n");
1196 for (h = prev->next; h != last->next; h = h->next)
1197 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1200 if (removed != NULL) *removed = TRUE;
1201 prev->next = last->next;
1209 /*************************************************
1210 * Remove duplicate IPs in host list *
1211 *************************************************/
1213 /* You would think that administrators could set up their DNS records so that
1214 one ended up with a list of unique IP addresses after looking up A or MX
1215 records, but apparently duplication is common. So we scan such lists and
1216 remove the later duplicates. Note that we may get lists in which some host
1217 addresses are not set.
1220 host pointer to the first host in the chain
1221 lastptr pointer to pointer to the last host in the chain (may be updated)
1227 host_remove_duplicates(host_item *host, host_item **lastptr)
1229 while (host != *lastptr)
1231 if (host->address != NULL)
1233 host_item *h = host;
1234 while (h != *lastptr)
1236 if (h->next->address != NULL &&
1237 Ustrcmp(h->next->address, host->address) == 0)
1239 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1240 "removed\n", host->address, h->next->mx);
1241 if (h->next == *lastptr) *lastptr = h;
1242 h->next = h->next->next;
1247 /* If the last item was removed, host may have become == *lastptr */
1248 if (host != *lastptr) host = host->next;
1255 /*************************************************
1256 * Find sender host name by gethostbyaddr() *
1257 *************************************************/
1259 /* This used to be the only way it was done, but it turns out that not all
1260 systems give aliases for calls to gethostbyaddr() - or one of the modern
1261 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1262 but they can still exist. This function is now used only when a DNS lookup of
1263 the IP address fails, in order to give access to /etc/hosts.
1266 Returns: OK, DEFER, FAIL
1270 host_name_lookup_byaddr(void)
1274 struct hostent *hosts;
1275 struct in_addr addr;
1277 /* Lookup on IPv6 system */
1280 if (Ustrchr(sender_host_address, ':') != NULL)
1282 struct in6_addr addr6;
1283 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1284 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1285 "IPv6 address", sender_host_address);
1286 #if HAVE_GETIPNODEBYADDR
1287 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1289 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1294 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1295 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1296 "IPv4 address", sender_host_address);
1297 #if HAVE_GETIPNODEBYADDR
1298 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1300 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1304 /* Do lookup on IPv4 system */
1307 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1308 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1311 /* Failed to look up the host. */
1315 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1317 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1320 /* It seems there are some records in the DNS that yield an empty name. We
1321 treat this as non-existent. In some operating systems, this is returned as an
1322 empty string; in others as a single dot. */
1324 if (hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1326 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1327 "treated as non-existent host name\n");
1331 /* Copy and lowercase the name, which is in static storage in many systems.
1332 Put it in permanent memory. */
1334 s = (uschar *)hosts->h_name;
1335 len = Ustrlen(s) + 1;
1336 t = sender_host_name = store_get_perm(len);
1337 while (*s != 0) *t++ = tolower(*s++);
1340 /* If the host has aliases, build a copy of the alias list */
1342 if (hosts->h_aliases != NULL)
1345 uschar **aliases, **ptr;
1346 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1347 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1348 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1350 uschar *s = *aliases;
1351 int len = Ustrlen(s) + 1;
1352 uschar *t = *ptr++ = store_get_perm(len);
1353 while (*s != 0) *t++ = tolower(*s++);
1364 /*************************************************
1365 * Find host name for incoming call *
1366 *************************************************/
1368 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1369 up a list of alias names, pointed to by sender_host_alias. The list is
1370 NULL-terminated. The incoming address is in sender_host_address, either in
1371 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1373 This function does a thorough check that the names it finds point back to the
1374 incoming IP address. Any that do not are discarded. Note that this is relied on
1375 by the ACL reverse_host_lookup check.
1377 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1378 this it not universally true. Also, for release 4.30, this function was changed
1379 to do a direct DNS lookup first, by default[1], because it turns out that that
1380 is the only guaranteed way to find all the aliases on some systems. My
1381 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1384 [1] The actual order is controlled by the host_lookup_order option.
1387 Returns: OK on success, the answer being placed in the global variable
1388 sender_host_name, with any aliases in a list hung off
1390 FAIL if no host name can be found
1391 DEFER if a temporary error was encountered
1393 The variable host_lookup_msg is set to an empty string on sucess, or to a
1394 reason for the failure otherwise, in a form suitable for tagging onto an error
1395 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1396 was a defer, host_lookup_deferred is set TRUE.
1398 Any dynamically constructed string for host_lookup_msg must be in permanent
1399 store, because it might be used for several incoming messages on the same SMTP
1403 host_name_lookup(void)
1407 uschar *hname, *save_hostname;
1411 uschar *list = host_lookup_order;
1416 host_lookup_deferred = host_lookup_failed = FALSE;
1418 HDEBUG(D_host_lookup)
1419 debug_printf("looking up host name for %s\n", sender_host_address);
1421 /* For testing the case when a lookup does not complete, we have a special
1422 reserved IP address. */
1424 if (running_in_test_harness &&
1425 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1427 HDEBUG(D_host_lookup)
1428 debug_printf("Test harness: host name lookup returns DEFER\n");
1429 host_lookup_deferred = TRUE;
1433 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1434 the order specified by the host_lookup_order option. */
1436 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer)))
1439 if (strcmpic(ordername, US"bydns") == 0)
1441 dns_init(FALSE, FALSE);
1442 dns_build_reverse(sender_host_address, buffer);
1443 rc = dns_lookup(&dnsa, buffer, T_PTR, NULL);
1445 /* The first record we come across is used for the name; others are
1446 considered to be aliases. We have to scan twice, in order to find out the
1447 number of aliases. However, if all the names are empty, we will behave as
1448 if failure. (PTR records that yield empty names have been encountered in
1451 if (rc == DNS_SUCCEED)
1453 uschar **aptr = NULL;
1456 int old_pool = store_pool;
1458 store_pool = POOL_PERM; /* Save names in permanent storage */
1460 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1462 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1464 if (rr->type == T_PTR) count++;
1467 /* Get store for the list of aliases. For compatibility with
1468 gethostbyaddr, we make an empty list if there are none. */
1470 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1472 /* Re-scan and extract the names */
1474 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1476 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1479 if (rr->type != T_PTR) continue;
1480 s = store_get(ssize);
1482 /* If an overlong response was received, the data will have been
1483 truncated and dn_expand may fail. */
1485 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1486 (uschar *)(rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1488 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1489 sender_host_address);
1493 store_reset(s + Ustrlen(s) + 1);
1496 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1497 "empty name: treated as non-existent host name\n");
1500 if (sender_host_name == NULL) sender_host_name = s;
1502 while (*s != 0) { *s = tolower(*s); s++; }
1505 *aptr = NULL; /* End of alias list */
1506 store_pool = old_pool; /* Reset store pool */
1508 /* If we've found a names, break out of the "order" loop */
1510 if (sender_host_name != NULL) break;
1513 /* If the DNS lookup deferred, we must also defer. */
1515 if (rc == DNS_AGAIN)
1517 HDEBUG(D_host_lookup)
1518 debug_printf("IP address PTR lookup gave temporary error\n");
1519 host_lookup_deferred = TRUE;
1524 /* Do a lookup using gethostbyaddr() - or equivalent */
1526 else if (strcmpic(ordername, US"byaddr") == 0)
1528 HDEBUG(D_host_lookup)
1529 debug_printf("IP address lookup using gethostbyaddr()\n");
1530 rc = host_name_lookup_byaddr();
1533 host_lookup_deferred = TRUE;
1534 return rc; /* Can't carry on */
1536 if (rc == OK) break; /* Found a name */
1538 } /* Loop for bydns/byaddr scanning */
1540 /* If we have failed to find a name, return FAIL and log when required.
1541 NB host_lookup_msg must be in permanent store. */
1543 if (sender_host_name == NULL)
1545 if (host_checking || !log_testing_mode)
1546 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1547 "address %s", sender_host_address);
1548 host_lookup_msg = US" (failed to find host name from IP address)";
1549 host_lookup_failed = TRUE;
1553 /* We have a host name. If we are running in the test harness, we want the host
1554 name and its alias to appear always the same way round. There are only ever two
1555 names in these tests. If one of them contains "alias", make sure it is second;
1556 otherwise put them in alphabetical order. */
1558 if (running_in_test_harness && *sender_host_aliases != NULL &&
1560 Ustrstr(sender_host_name, "alias") != NULL ||
1562 Ustrstr(*sender_host_aliases, "alias") == NULL &&
1563 Ustrcmp(sender_host_name, *sender_host_aliases) > 0
1567 uschar *temp = sender_host_name;
1568 sender_host_name = *sender_host_aliases;
1569 *sender_host_aliases = temp;
1572 /* Debug output what was found, after test harness swapping, for consistency */
1574 HDEBUG(D_host_lookup)
1576 uschar **aliases = sender_host_aliases;
1577 debug_printf("IP address lookup yielded %s\n", sender_host_name);
1578 while (*aliases != NULL) debug_printf(" alias %s\n", *aliases++);
1581 /* We need to verify that a forward lookup on the name we found does indeed
1582 correspond to the address. This is for security: in principle a malefactor who
1583 happened to own a reverse zone could set it to point to any names at all.
1585 This code was present in versions of Exim before 3.20. At that point I took it
1586 out because I thought that gethostbyaddr() did the check anyway. It turns out
1587 that this isn't always the case, so it's coming back in at 4.01. This version
1588 is actually better, because it also checks aliases.
1590 The code was made more robust at release 4.21. Prior to that, it accepted all
1591 the names if any of them had the correct IP address. Now the code checks all
1592 the names, and accepts only those that have the correct IP address. */
1594 save_hostname = sender_host_name; /* Save for error messages */
1595 aliases = sender_host_aliases;
1596 for (hname = sender_host_name; hname != NULL; hname = *aliases++)
1606 /* When called with the 5th argument FALSE, host_find_byname() won't return
1607 HOST_FOUND_LOCAL. If the incoming address is an IPv4 address expressed in
1608 IPv6 format, we must compare the IPv4 part to any IPv4 addresses. */
1610 if ((rc = host_find_byname(&h, NULL, NULL, FALSE)) == HOST_FOUND)
1613 uschar *address_ipv4 = (Ustrncmp(sender_host_address, "::ffff:", 7) == 0)?
1614 sender_host_address + 7 : sender_host_address;
1615 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1616 for (hh = &h; hh != NULL; hh = hh->next)
1618 if ((Ustrcmp(hh->address, (Ustrchr(hh->address, ':') == NULL)?
1619 address_ipv4 : sender_host_address)) == 0)
1621 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1627 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1630 if (!ok) HDEBUG(D_host_lookup)
1631 debug_printf("no IP address for %s matched %s\n", hname,
1632 sender_host_address);
1634 else if (rc == HOST_FIND_AGAIN)
1636 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1637 host_lookup_deferred = TRUE;
1642 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1645 /* If this name is no good, and it's the sender name, set it null pro tem;
1646 if it's an alias, just remove it from the list. */
1650 if (hname == sender_host_name) sender_host_name = NULL; else
1652 uschar **a; /* Don't amalgamate - some */
1653 a = --aliases; /* compilers grumble */
1654 while (*a != NULL) { *a = a[1]; a++; }
1659 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1660 it with the first alias, if there is one. */
1662 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1663 sender_host_name = *sender_host_aliases++;
1665 /* If we now have a main name, all is well. */
1667 if (sender_host_name != NULL) return OK;
1669 /* We have failed to find an address that matches. */
1671 HDEBUG(D_host_lookup)
1672 debug_printf("%s does not match any IP address for %s\n",
1673 sender_host_address, save_hostname);
1675 /* This message must be in permanent store */
1677 old_pool = store_pool;
1678 store_pool = POOL_PERM;
1679 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1680 sender_host_address, save_hostname);
1681 store_pool = old_pool;
1682 host_lookup_failed = TRUE;
1689 /*************************************************
1690 * Find IP address(es) for host by name *
1691 *************************************************/
1693 /* The input is a host_item structure with the name filled in and the address
1694 field set to NULL. We use gethostbyname(). Of course, gethostbyname() may use
1695 the DNS, but it doesn't do MX processing. If more than one address is given,
1696 chain on additional host items, with other relevant fields copied.
1698 The second argument provides a host list (usually an IP list) of hosts to
1699 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1700 addresses in unreasonable places.
1702 The lookup may result in a change of name. For compatibility with the dns
1703 lookup, return this via fully_qualified_name as well as updating the host item.
1704 The lookup may also yield more than one IP address, in which case chain on
1705 subsequent host_item structures.
1708 host a host item with the name and MX filled in;
1709 the address is to be filled in;
1710 multiple IP addresses cause other host items to be
1712 ignore_target_hosts a list of hosts to ignore
1713 fully_qualified_name if not NULL, set to point to host name for
1714 compatibility with host_find_bydns
1715 local_host_check TRUE if a check for the local host is wanted
1717 Returns: HOST_FIND_FAILED Failed to find the host or domain
1718 HOST_FIND_AGAIN Try again later
1719 HOST_FOUND Host found - data filled in
1720 HOST_FOUND_LOCAL Host found and is the local host
1724 host_find_byname(host_item *host, uschar *ignore_target_hosts,
1725 uschar **fully_qualified_name, BOOL local_host_check)
1727 int i, yield, times;
1729 host_item *last = NULL;
1730 BOOL temp_error = FALSE;
1735 /* If we are in the test harness, a name ending in .test.again.dns always
1736 forces a temporary error response. */
1738 if (running_in_test_harness)
1740 uschar *endname = host->name + Ustrlen(host->name);
1741 if (Ustrcmp(endname - 14, "test.again.dns") == 0)
1742 return HOST_FIND_AGAIN;
1745 /* In an IPv6 world, we need to scan for both kinds of address, so go round the
1746 loop twice. Note that we have ensured that AF_INET6 is defined even in an IPv4
1747 world, which makes for slightly tidier code. However, if dns_ipv4_lookup
1748 matches the domain, we also just do IPv4 lookups here (except when testing
1753 if (dns_ipv4_lookup != NULL &&
1754 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
1756 { af = AF_INET; times = 1; }
1758 #endif /* STAND_ALONE */
1760 { af = AF_INET6; times = 2; }
1762 /* No IPv6 support */
1764 #else /* HAVE_IPV6 */
1766 #endif /* HAVE_IPV6 */
1768 /* Initialize the flag that gets set for DNS syntax check errors, so that the
1769 interface to this function can be similar to host_find_bydns. */
1771 host_find_failed_syntax = FALSE;
1773 /* Loop to look up both kinds of address in an IPv6 world */
1775 for (i = 1; i <= times;
1777 af = AF_INET, /* If 2 passes, IPv4 on the second */
1783 struct hostent *hostdata;
1786 #if HAVE_GETIPNODEBYNAME
1787 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
1789 hostdata = gethostbyname2(CS host->name, af);
1790 error_num = h_errno;
1793 hostdata = gethostbyname(CS host->name);
1794 error_num = h_errno;
1797 if (hostdata == NULL)
1802 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
1803 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
1804 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
1805 case NO_DATA: error = US"NO_DATA"; break;
1806 #if NO_DATA != NO_ADDRESS
1807 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
1809 default: error = US"?"; break;
1812 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
1814 #if HAVE_GETIPNODEBYNAME
1815 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
1817 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
1824 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
1827 if ((hostdata->h_addr_list)[0] == NULL) continue;
1829 /* Replace the name with the fully qualified one if necessary, and fill in
1830 the fully_qualified_name pointer. */
1832 if (hostdata->h_name[0] != 0 &&
1833 Ustrcmp(host->name, hostdata->h_name) != 0)
1834 host->name = string_copy_dnsdomain((uschar *)hostdata->h_name);
1835 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
1837 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
1838 by their different lengths. Scan the list, ignoring any that are to be
1839 ignored, and build a chain from the rest. */
1841 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
1843 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
1845 uschar *text_address =
1846 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
1849 if (ignore_target_hosts != NULL &&
1850 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
1851 text_address, NULL) == OK)
1853 DEBUG(D_host_lookup)
1854 debug_printf("ignored host %s [%s]\n", host->name, text_address);
1859 /* If this is the first address, last == NULL and we put the data in the
1864 host->address = text_address;
1865 host->port = PORT_NONE;
1866 host->status = hstatus_unknown;
1867 host->why = hwhy_unknown;
1871 /* Else add further host item blocks for any other addresses, keeping
1876 host_item *next = store_get(sizeof(host_item));
1877 next->name = host->name;
1878 next->mx = host->mx;
1879 next->address = text_address;
1880 next->port = PORT_NONE;
1881 next->status = hstatus_unknown;
1882 next->why = hwhy_unknown;
1884 next->next = last->next;
1891 /* If no hosts were found, the address field in the original host block will be
1892 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
1893 so we pass that back. */
1895 if (host->address == NULL)
1899 (message_id[0] == 0 && smtp_in != NULL)?
1900 string_sprintf("no IP address found for host %s (during %s)", host->name,
1901 smtp_get_connection_info()) :
1903 string_sprintf("no IP address found for host %s", host->name);
1905 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
1906 if (temp_error) return HOST_FIND_AGAIN;
1907 if (host_checking || !log_testing_mode)
1908 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
1909 return HOST_FIND_FAILED;
1912 /* Remove any duplicate IP addresses, then check to see if this is the local
1913 host if required. */
1915 host_remove_duplicates(host, &last);
1916 yield = local_host_check?
1917 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
1919 /* When running in the test harness, sort into the order of addresses so as to
1920 get repeatability. */
1922 if (running_in_test_harness) sort_addresses(host, last);
1924 HDEBUG(D_host_lookup)
1927 if (fully_qualified_name != NULL)
1928 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
1929 debug_printf("%s looked up these IP addresses:\n",
1931 #if HAVE_GETIPNODEBYNAME
1940 for (h = host; h != last->next; h = h->next)
1941 debug_printf(" name=%s address=%s\n", h->name,
1942 (h->address == NULL)? US"<null>" : h->address);
1945 /* Return the found status. */
1952 /*************************************************
1953 * Fill in a host address from the DNS *
1954 *************************************************/
1956 /* Given a host item, with its name and mx fields set, and its address field
1957 set to NULL, fill in its IP address from the DNS. If it is multi-homed, create
1958 additional host items for the additional addresses, copying all the other
1959 fields, and randomizing the order.
1961 On IPv6 systems, A6 records are sought first (but only if support for A6 is
1962 configured - they may never become mainstream), then AAAA records are sought,
1963 and finally A records are sought as well.
1965 The host name may be changed if the DNS returns a different name - e.g. fully
1966 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
1967 ensures that it points to the fully qualified name. However, this is the fully
1968 qualified version of the original name; if a CNAME is involved, the actual
1969 canonical host name may be different again, and so we get it directly from the
1970 relevant RR. Note that we do NOT change the mx field of the host item in this
1971 function as it may be called to set the addresses of hosts taken from MX
1975 host points to the host item we're filling in
1976 lastptr points to pointer to last host item in a chain of
1977 host items (may be updated if host is last and gets
1978 extended because multihomed)
1979 ignore_target_hosts list of hosts to ignore
1980 allow_ip if TRUE, recognize an IP address and return it
1981 fully_qualified_name if not NULL, return fully qualified name here if
1982 the contents are different (i.e. it must be preset
1985 Returns: HOST_FIND_FAILED couldn't find A record
1986 HOST_FIND_AGAIN try again later
1987 HOST_FOUND found AAAA and/or A record(s)
1988 HOST_IGNORED found, but all IPs ignored
1992 set_address_from_dns(host_item *host, host_item **lastptr,
1993 uschar *ignore_target_hosts, BOOL allow_ip, uschar **fully_qualified_name)
1996 host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
1997 BOOL v6_find_again = FALSE;
2000 /* If allow_ip is set, a name which is an IP address returns that value
2001 as its address. This is used for MX records when allow_mx_to_ip is set, for
2002 those sites that feel they have to flaunt the RFC rules. */
2004 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2007 if (ignore_target_hosts != NULL &&
2008 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2009 host->name, NULL) == OK)
2010 return HOST_IGNORED;
2013 host->address = host->name;
2014 host->port = PORT_NONE;
2018 /* On an IPv6 system, go round the loop up to three times, looking for A6 and
2019 AAAA records the first two times. However, unless doing standalone testing, we
2020 force an IPv4 lookup if the domain matches dns_ipv4_lookup is set. Since A6
2021 records look like being abandoned, support them only if explicitly configured
2022 to do so. On an IPv4 system, go round the loop once only, looking only for A
2028 if (dns_ipv4_lookup != NULL &&
2029 match_isinlist(host->name, &dns_ipv4_lookup, 0, NULL, NULL, MCL_DOMAIN,
2031 i = 0; /* look up A records only */
2033 #endif /* STAND_ALONE */
2036 i = 2; /* look up A6 and AAAA and A records */
2038 i = 1; /* look up AAAA and A records */
2039 #endif /* SUPPORT_A6 */
2041 /* The IPv4 world */
2043 #else /* HAVE_IPV6 */
2044 i = 0; /* look up A records only */
2045 #endif /* HAVE_IPV6 */
2049 static int types[] = { T_A, T_AAAA, T_A6 };
2050 int type = types[i];
2051 int randoffset = (i == 0)? 500 : 0; /* Ensures v6 sorts before v4 */
2055 int rc = dns_lookup(&dnsa, host->name, type, fully_qualified_name);
2057 /* We want to return HOST_FIND_AGAIN if one of the A, A6, or AAAA lookups
2058 fails or times out, but not if another one succeeds. (In the early
2059 IPv6 days there are name servers that always fail on AAAA, but are happy
2060 to give out an A record. We want to proceed with that A record.) */
2062 if (rc != DNS_SUCCEED)
2064 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2066 if (host->address != NULL) return HOST_FOUND; /* A6 or AAAA was found */
2067 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2068 return HOST_FIND_AGAIN;
2069 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2072 /* Tried for an A6 or AAAA record: remember if this was a temporary
2073 error, and look for the next record type. */
2075 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2079 /* Lookup succeeded: fill in the given host item with the first non-ignored
2080 address found; create additional items for any others. A single A6 record
2081 may generate more than one address. */
2083 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2085 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2087 if (rr->type == type)
2089 /* dns_address *da = dns_address_from_rr(&dnsa, rr); */
2092 da = dns_address_from_rr(&dnsa, rr);
2094 DEBUG(D_host_lookup)
2097 debug_printf("no addresses extracted from A6 RR for %s\n",
2101 /* This loop runs only once for A and AAAA records, but may run
2102 several times for an A6 record that generated multiple addresses. */
2104 for (; da != NULL; da = da->next)
2107 if (ignore_target_hosts != NULL &&
2108 verify_check_this_host(&ignore_target_hosts, NULL,
2109 host->name, da->address, NULL) == OK)
2111 DEBUG(D_host_lookup)
2112 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2117 /* If this is the first address, stick it in the given host block,
2118 and change the name if the returned RR has a different name. */
2120 if (thishostlast == NULL)
2122 if (strcmpic(host->name, rr->name) != 0)
2123 host->name = string_copy_dnsdomain(rr->name);
2124 host->address = da->address;
2125 host->port = PORT_NONE;
2126 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2127 host->status = hstatus_unknown;
2128 host->why = hwhy_unknown;
2129 thishostlast = host;
2132 /* Not the first address. Check for, and ignore, duplicates. Then
2133 insert in the chain at a random point. */
2140 /* End of our local chain is specified by "thishostlast". */
2142 for (next = host;; next = next->next)
2144 if (Ustrcmp(CS da->address, next->address) == 0) break;
2145 if (next == thishostlast) { next = NULL; break; }
2147 if (next != NULL) continue; /* With loop for next address */
2149 /* Not a duplicate */
2151 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2152 next = store_get(sizeof(host_item));
2154 /* New address goes first: insert the new block after the first one
2155 (so as not to disturb the original pointer) but put the new address
2156 in the original block. */
2158 if (new_sort_key < host->sort_key)
2162 host->address = da->address;
2163 host->port = PORT_NONE;
2164 host->sort_key = new_sort_key;
2165 if (thishostlast == host) thishostlast = next; /* Local last */
2166 if (*lastptr == host) *lastptr = next; /* Global last */
2169 /* Otherwise scan down the addresses for this host to find the
2170 one to insert after. */
2174 host_item *h = host;
2175 while (h != thishostlast)
2177 if (new_sort_key < h->next->sort_key) break;
2182 next->address = da->address;
2183 next->port = PORT_NONE;
2184 next->sort_key = new_sort_key;
2185 if (h == thishostlast) thishostlast = next; /* Local last */
2186 if (h == *lastptr) *lastptr = next; /* Global last */
2194 /* Control gets here only if the third lookup (the A record) succeeded.
2195 However, the address may not be filled in if it was ignored. */
2197 return (host->address == NULL)? HOST_IGNORED : HOST_FOUND;
2203 /*************************************************
2204 * Find IP addresses and names for host via DNS *
2205 *************************************************/
2207 /* The input is a host_item structure with the name filled in and the address
2208 field set to NULL. This may be in a chain of other host items. The lookup may
2209 result in more than one IP address, in which case we must created new host
2210 blocks for the additional addresses, and insert them into the chain. The
2211 original name may not be fully qualified. Use the fully_qualified_name argument
2212 to return the official name, as returned by the resolver.
2215 host point to initial host item
2216 ignore_target_hosts a list of hosts to ignore
2217 whichrrs flags indicating which RRs to look for:
2218 HOST_FIND_BY_SRV => look for SRV
2219 HOST_FIND_BY_MX => look for MX
2220 HOST_FIND_BY_A => look for A or AAAA
2221 also flags indicating how the lookup is done
2222 HOST_FIND_QUALIFY_SINGLE ) passed to the
2223 HOST_FIND_SEARCH_PARENTS ) resolver
2224 srv_service when SRV used, the service name
2225 srv_fail_domains DNS errors for these domains => assume nonexist
2226 mx_fail_domains DNS errors for these domains => assume nonexist
2227 fully_qualified_name if not NULL, return fully-qualified name
2228 removed set TRUE if local host was removed from the list
2230 Returns: HOST_FIND_FAILED Failed to find the host or domain;
2231 if there was a syntax error,
2232 host_find_failed_syntax is set.
2233 HOST_FIND_AGAIN Could not resolve at this time
2234 HOST_FOUND Host found
2235 HOST_FOUND_LOCAL The lowest MX record points to this
2236 machine, if MX records were found, or
2237 an A record that was found contains
2238 an address of the local host
2242 host_find_bydns(host_item *host, uschar *ignore_target_hosts, int whichrrs,
2243 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2244 uschar **fully_qualified_name, BOOL *removed)
2246 host_item *h, *last;
2254 /* Set the default fully qualified name to the incoming name, initialize the
2255 resolver if necessary, set up the relevant options, and initialize the flag
2256 that gets set for DNS syntax check errors. */
2258 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2259 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2260 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0);
2261 host_find_failed_syntax = FALSE;
2263 /* First, if requested, look for SRV records. The service name is given; we
2264 assume TCP progocol. DNS domain names are constrained to a maximum of 256
2265 characters, so the code below should be safe. */
2267 if ((whichrrs & HOST_FIND_BY_SRV) != 0)
2270 uschar *temp_fully_qualified_name = buffer;
2273 (void)sprintf(CS buffer, "_%s._tcp.%n%.256s", srv_service, &prefix_length,
2277 /* Search for SRV records. If the fully qualified name is different to
2278 the input name, pass back the new original domain, without the prepended
2281 rc = dns_lookup(&dnsa, buffer, ind_type, &temp_fully_qualified_name);
2282 if (temp_fully_qualified_name != buffer && fully_qualified_name != NULL)
2283 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2285 /* On DNS failures, we give the "try again" error unless the domain is
2286 listed as one for which we continue. */
2288 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2290 if (match_isinlist(host->name, &srv_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2292 return HOST_FIND_AGAIN;
2293 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2294 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2298 /* If we did not find any SRV records, search the DNS for MX records, if
2299 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2300 domain, and there's no point in going on to look for address records with the
2301 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2302 records. On DNS failures, we give the "try again" error unless the domain is
2303 listed as one for which we continue. */
2305 if (rc != DNS_SUCCEED && (whichrrs & HOST_FIND_BY_MX) != 0)
2308 rc = dns_lookup(&dnsa, host->name, ind_type, fully_qualified_name);
2309 if (rc == DNS_NOMATCH) return HOST_FIND_FAILED;
2310 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2312 if (match_isinlist(host->name, &mx_fail_domains, 0, NULL, NULL, MCL_DOMAIN,
2314 return HOST_FIND_AGAIN;
2315 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2316 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2320 /* If we haven't found anything yet, and we are requested to do so, try for an
2321 A or AAAA record. If we find it (or them) check to see that it isn't the local
2324 if (rc != DNS_SUCCEED)
2326 if ((whichrrs & HOST_FIND_BY_A) == 0)
2328 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2329 return HOST_FIND_FAILED;
2332 last = host; /* End of local chainlet */
2334 host->port = PORT_NONE;
2335 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2336 fully_qualified_name);
2338 /* If one or more address records have been found, check that none of them
2339 are local. Since we know the host items all have their IP addresses
2340 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2341 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2342 because set_address_from_dns() removes them. */
2344 if (rc == HOST_FOUND)
2345 rc = host_scan_for_local_hosts(host, &last, removed);
2347 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2349 /* When running in the test harness, sort into the order of addresses so as
2350 to get repeatability. */
2352 if (running_in_test_harness) sort_addresses(host, last);
2354 DEBUG(D_host_lookup)
2357 if (host->address != NULL)
2359 if (fully_qualified_name != NULL)
2360 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2361 for (h = host; h != last->next; h = h->next)
2362 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2363 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2364 (h->status >= hstatus_unusable)? US"*" : US"");
2371 /* We have found one or more MX or SRV records. Sort them according to
2372 precedence. Put the data for the first one into the existing host block, and
2373 insert new host_item blocks into the chain for the remainder. For equal
2374 precedences one is supposed to randomize the order. To make this happen, the
2375 sorting is actually done on the MX value * 1000 + a random number. This is put
2376 into a host field called sort_key.
2378 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2379 IPv6 address in preference. At this stage, we don't know what kind of address
2380 the host has. We choose a random number < 500; if later we find an A record
2381 first, we add 500 to the random number. Then for any other address records, we
2382 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2385 At this point we remove any duplicates that point to the same host, retaining
2386 only the one with the lowest precedence. We cannot yet check for precedence
2387 greater than that of the local host, because that test cannot be properly done
2388 until the addresses have been found - an MX record may point to a name for this
2389 host which is not the primary hostname. */
2391 last = NULL; /* Indicates that not even the first item is filled yet */
2393 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2395 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2398 int weight = 0; /* For SRV records */
2399 int port = PORT_NONE; /* For SRV records */
2400 uschar *s; /* MUST be unsigned for GETSHORT */
2403 if (rr->type != ind_type) continue;
2405 GETSHORT(precedence, s); /* Pointer s is advanced */
2407 /* For MX records, we use a random "weight" which causes multiple records of
2408 the same precedence to sort randomly. */
2410 if (ind_type == T_MX)
2412 weight = random_number(500);
2415 /* SRV records are specified with a port and a weight. The weight is used
2416 in a special algorithm. However, to start with, we just use it to order the
2417 records of equal priority (precedence). */
2421 GETSHORT(weight, s);
2425 /* Get the name of the host pointed to. */
2427 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2428 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2430 /* Check that we haven't already got this host on the chain; if we have,
2431 keep only the lower precedence. This situation shouldn't occur, but you
2432 never know what junk might get into the DNS (and this case has been seen on
2433 more than one occasion). */
2435 if (last != NULL) /* This is not the first record */
2437 host_item *prev = NULL;
2439 for (h = host; h != last->next; prev = h, h = h->next)
2441 if (strcmpic(h->name, data) == 0)
2443 DEBUG(D_host_lookup)
2444 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2445 (precedence > h->mx)? precedence : h->mx);
2446 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2447 if (h == host) /* Override first item */
2450 host->sort_key = precedence * 1000 + weight;
2454 /* Unwanted host item is not the first in the chain, so we can get
2455 get rid of it by cutting it out. */
2457 prev->next = h->next;
2458 if (h == last) last = prev;
2464 /* If this is the first MX or SRV record, put the data into the existing host
2465 block. Otherwise, add a new block in the correct place; if it has to be
2466 before the first block, copy the first block's data to a new second block. */
2470 host->name = string_copy_dnsdomain(data);
2471 host->address = NULL;
2473 host->mx = precedence;
2474 host->sort_key = precedence * 1000 + weight;
2475 host->status = hstatus_unknown;
2476 host->why = hwhy_unknown;
2480 /* Make a new host item and seek the correct insertion place */
2484 int sort_key = precedence * 1000 + weight;
2485 host_item *next = store_get(sizeof(host_item));
2486 next->name = string_copy_dnsdomain(data);
2487 next->address = NULL;
2489 next->mx = precedence;
2490 next->sort_key = sort_key;
2491 next->status = hstatus_unknown;
2492 next->why = hwhy_unknown;
2495 /* Handle the case when we have to insert before the first item. */
2497 if (sort_key < host->sort_key)
2504 if (last == host) last = next;
2507 /* Else scan down the items we have inserted as part of this exercise;
2508 don't go further. */
2512 for (h = host; h != last; h = h->next)
2514 if (sort_key < h->next->sort_key)
2516 next->next = h->next;
2522 /* Join on after the last host item that's part of this
2523 processing if we haven't stopped sooner. */
2527 next->next = last->next;
2534 NEXT_MX_RR: continue;
2537 /* If the list of hosts was obtained from SRV records, there are two things to
2538 do. First, if there is only one host, and it's name is ".", it means there is
2539 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2540 priority according to their weights, using an algorithm that is defined in RFC
2541 2782. The hosts are currently sorted by priority and weight. For each priority
2542 group we have to pick off one host and put it first, and then repeat for any
2543 remaining in the same priority group. */
2545 if (ind_type == T_SRV)
2549 if (host == last && host->name[0] == 0)
2551 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2552 return HOST_FIND_FAILED;
2555 DEBUG(D_host_lookup)
2557 debug_printf("original ordering of hosts from SRV records:\n");
2558 for (h = host; h != last->next; h = h->next)
2559 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2562 for (pptr = &host, h = host; h != last; pptr = &(h->next), h = h->next)
2567 /* Find the last following host that has the same precedence. At the same
2568 time, compute the sum of the weights and the running totals. These can be
2569 stored in the sort_key field. */
2571 for (hh = h; hh != last; hh = hh->next)
2573 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2576 if (hh->mx != hh->next->mx) break;
2579 /* If there's more than one host at this precedence (priority), we need to
2580 pick one to go first. */
2586 int randomizer = random_number(sum + 1);
2588 for (ppptr = pptr, hhh = h;
2590 ppptr = &(hhh->next), hhh = hhh->next)
2592 if (hhh->sort_key >= randomizer) break;
2595 /* hhh now points to the host that should go first; ppptr points to the
2596 place that points to it. Unfortunately, if the start of the minilist is
2597 the start of the entire list, we can't just swap the items over, because
2598 we must not change the value of host, since it is passed in from outside.
2599 One day, this could perhaps be changed.
2601 The special case is fudged by putting the new item *second* in the chain,
2602 and then transferring the data between the first and second items. We
2603 can't just swap the first and the chosen item, because that would mean
2604 that an item with zero weight might no longer be first. */
2608 *ppptr = hhh->next; /* Cuts it out of the chain */
2612 host_item temp = *h;
2615 hhh->next = temp.next;
2621 hhh->next = h; /* The rest of the chain follows it */
2622 *pptr = hhh; /* It takes the place of h */
2623 h = hhh; /* It's now the start of this minilist */
2628 /* A host has been chosen to be first at this priority and h now points
2629 to this host. There may be others at the same priority, or others at a
2630 different priority. Before we leave this host, we need to put back a sort
2631 key of the traditional MX kind, in case this host is multihomed, because
2632 the sort key is used for ordering the multiple IP addresses. We do not need
2633 to ensure that these new sort keys actually reflect the order of the hosts,
2636 h->sort_key = h->mx * 1000 + random_number(500);
2637 } /* Move on to the next host */
2640 /* Now we have to ensure addresses exist for all the hosts. We have ensured
2641 above that the names in the host items are all unique. The addresses may have
2642 been returned in the additional data section of the DNS query. Because it is
2643 more expensive to scan the returned DNS records (because you have to expand the
2644 names) we do a single scan over them, and multiple scans of the chain of host
2645 items (which is typically only 3 or 4 long anyway.) Add extra host items for
2646 multi-homed hosts. */
2648 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ADDITIONAL);
2650 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2653 int status = hstatus_unknown;
2654 int why = hwhy_unknown;
2659 && rr->type != T_AAAA
2666 /* Find the first host that matches this record's name. If there isn't
2667 one, move on to the next RR. */
2669 for (h = host; h != last->next; h = h->next)
2670 { if (strcmpic(h->name, rr->name) == 0) break; }
2671 if (h == last->next) continue;
2673 /* For IPv4 addresses, add 500 to the random part of the sort key, to ensure
2674 they sort after IPv6 addresses. */
2676 randoffset = (rr->type == T_A)? 500 : 0;
2678 /* Get the list of textual addresses for this RR. There may be more than one
2679 if it is an A6 RR. Then loop to handle multiple addresses from an A6 record.
2680 If there are none, nothing will get done - the record is ignored. */
2682 for (da = dns_address_from_rr(&dnsa, rr); da != NULL; da = da->next)
2684 /* Set status for an ignorable host. */
2687 if (ignore_target_hosts != NULL &&
2688 verify_check_this_host(&ignore_target_hosts, NULL, h->name,
2689 da->address, NULL) == OK)
2691 DEBUG(D_host_lookup)
2692 debug_printf("ignored host %s [%s]\n", h->name, da->address);
2693 status = hstatus_unusable;
2698 /* If the address is already set for this host, it may be that
2699 we just have a duplicate DNS record. Alternatively, this may be
2700 a multi-homed host. Search all items with the same host name
2701 (they will all be together) and if this address is found, skip
2704 if (h->address != NULL)
2707 host_item *thishostlast;
2712 if (hh->address != NULL && Ustrcmp(CS da->address, hh->address) == 0)
2713 goto DNS_NEXT_RR; /* Need goto to escape from inner loop */
2717 while (hh != last->next && strcmpic(hh->name, rr->name) == 0);
2719 /* We have a multi-homed host, since we have a new address for
2720 an existing name. Create a copy of the current item, and give it
2721 the new address. RRs can be in arbitrary order, but one is supposed
2722 to randomize the addresses of multi-homed hosts, so compute a new
2723 sorting key and do that. [Latest SMTP RFC says not to randomize multi-
2724 homed hosts, but to rely on the resolver. I'm not happy about that -
2725 caching in the resolver will not rotate as often as the name server
2728 new_sort_key = h->mx * 1000 + random_number(500) + randoffset;
2729 hh = store_get(sizeof(host_item));
2731 /* New address goes first: insert the new block after the first one
2732 (so as not to disturb the original pointer) but put the new address
2733 in the original block. */
2735 if (new_sort_key < h->sort_key)
2737 *hh = *h; /* Note: copies the port */
2739 h->address = da->address;
2740 h->sort_key = new_sort_key;
2745 /* Otherwise scan down the addresses for this host to find the
2746 one to insert after. */
2750 while (h != thishostlast)
2752 if (new_sort_key < h->next->sort_key) break;
2755 *hh = *h; /* Note: copies the port */
2757 hh->address = da->address;
2758 hh->sort_key = new_sort_key;
2759 hh->status = status;
2763 if (h == last) last = hh; /* Inserted after last */
2766 /* The existing item doesn't have its address set yet, so just set it.
2767 Ensure that an IPv4 address gets its sort key incremented in case an IPv6
2768 address is found later. */
2772 h->address = da->address; /* Port should be set already */
2775 h->sort_key += randoffset;
2777 } /* Loop for addresses extracted from one RR */
2779 /* Carry on to the next RR. It would be nice to be able to be able to stop
2780 when every host on the list has an address, but we can't be sure there won't
2781 be an additional address for a multi-homed host further down the list, so
2782 we have to continue to the end. */
2784 DNS_NEXT_RR: continue;
2787 /* Set the default yield to failure */
2789 yield = HOST_FIND_FAILED;
2791 /* If we haven't found all the addresses in the additional section, we
2792 need to search for A or AAAA records explicitly. The names shouldn't point to
2793 CNAMES, but we use the general lookup function that handles them, just
2794 in case. If any lookup gives a soft error, change the default yield.
2796 For these DNS lookups, we must disable qualify_single and search_parents;
2797 otherwise invalid host names obtained from MX or SRV records can cause trouble
2798 if they happen to match something local. */
2800 dns_init(FALSE, FALSE);
2802 for (h = host; h != last->next; h = h->next)
2804 if (h->address != NULL || h->status == hstatus_unusable) continue;
2805 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip, NULL);
2806 if (rc != HOST_FOUND)
2808 h->status = hstatus_unusable;
2809 if (rc == HOST_FIND_AGAIN)
2812 h->why = hwhy_deferred;
2815 h->why = (rc == HOST_IGNORED)? hwhy_ignored : hwhy_failed;
2819 /* Scan the list for any hosts that are marked unusable because they have
2820 been explicitly ignored, and remove them from the list, as if they did not
2821 exist. If we end up with just a single, ignored host, flatten its fields as if
2822 nothing was found. */
2824 if (ignore_target_hosts != NULL)
2826 host_item *prev = NULL;
2827 for (h = host; h != last->next; h = h->next)
2830 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
2832 else if (prev == NULL) /* First host is ignored */
2834 if (h != last) /* First is not last */
2836 if (h->next == last) last = h; /* Overwrite it with next */
2837 *h = *(h->next); /* and reprocess it. */
2838 goto REDO; /* C should have redo, like Perl */
2841 else /* Ignored host is not first - */
2843 prev->next = h->next;
2844 if (h == last) last = prev;
2848 if (host->why == hwhy_ignored) host->address = NULL;
2851 /* There is still one complication in the case of IPv6. Although the code above
2852 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
2853 hosts, it doesn't do this for addresses that apply to different hosts with the
2854 same MX precedence, because the sorting on MX precedence happens first. So we
2855 have to make another pass to check for this case. We ensure that, within a
2856 single MX preference value, IPv6 addresses come first. This can separate the
2857 addresses of a multihomed host, but that should not matter. */
2862 for (h = host; h != last; h = h->next)
2865 host_item *next = h->next;
2866 if (h->mx != next->mx || /* If next is different MX value */
2867 (h->sort_key % 1000) < 500 || /* OR this one is IPv6 */
2868 (next->sort_key % 1000) >= 500) /* OR next is IPv4 */
2869 continue; /* move on to next */
2871 temp.next = next->next;
2879 /* When running in the test harness, we want the hosts always to be in the same
2880 order so that the debugging output is the same and can be compared. Having a
2881 fixed set of "random" numbers doesn't actually achieve this, because the RRs
2882 come back from the resolver in a random order, so the non-random random numbers
2883 get used in a different order. We therefore have to sort the hosts that have
2884 the same MX values. We chose do to this by their name and then by IP address.
2885 The fact that the sort is slow matters not - this is testing only! */
2887 if (running_in_test_harness)
2893 for (h = host; h != last; h = h->next)
2895 int c = Ustrcmp(h->name, h->next->name);
2896 if (c == 0) c = Ustrcmp(h->address, h->next->address);
2897 if (h->mx == h->next->mx && c > 0)
2899 host_item *next = h->next;
2900 host_item temp = *h;
2901 temp.next = next->next;
2912 /* Remove any duplicate IP addresses and then scan the list of hosts for any
2913 whose IP addresses are on the local host. If any are found, all hosts with the
2914 same or higher MX values are removed. However, if the local host has the lowest
2915 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
2916 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
2917 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
2918 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
2919 be HOST_FIND_FAILED. */
2921 host_remove_duplicates(host, &last);
2922 rc = host_scan_for_local_hosts(host, &last, removed);
2923 if (rc != HOST_FIND_FAILED) yield = rc;
2925 DEBUG(D_host_lookup)
2927 if (fully_qualified_name != NULL)
2928 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2929 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
2930 (yield == HOST_FOUND)? "HOST_FOUND" :
2931 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
2932 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
2933 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
2935 for (h = host; h != last->next; h = h->next)
2937 debug_printf(" %s %s MX=%d ", h->name,
2938 (h->address == NULL)? US"<null>" : h->address, h->mx);
2939 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
2940 if (h->status >= hstatus_unusable) debug_printf("*");
2951 /*************************************************
2952 **************************************************
2953 * Stand-alone test program *
2954 **************************************************
2955 *************************************************/
2959 BOOL alldigits(uschar *buffer)
2961 if (!isdigit(*buffer)) return FALSE;
2962 if (*buffer == '0' && buffer[1] == 'x')
2965 while (isxdigit(*(++buffer)));
2967 else while (isdigit(*(++buffer)));
2968 return (*buffer == 0);
2971 int main(int argc, char **cargv)
2974 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A;
2975 BOOL byname = FALSE;
2976 BOOL qualify_single = TRUE;
2977 BOOL search_parents = FALSE;
2978 uschar **argv = USS cargv;
2981 primary_hostname = US"";
2982 store_pool = POOL_MAIN;
2983 debug_selector = D_host_lookup|D_interface;
2984 debug_file = stdout;
2985 debug_fd = fileno(debug_file);
2987 printf("Exim stand-alone host functions test\n");
2989 host_find_interfaces();
2990 debug_selector = D_host_lookup | D_dns;
2992 if (argc > 1) primary_hostname = argv[1];
2994 /* So that debug level changes can be done first */
2996 dns_init(qualify_single, search_parents);
2998 printf("Testing host lookup\n");
3000 while (Ufgets(buffer, 256, stdin) != NULL)
3003 int len = Ustrlen(buffer);
3004 uschar *fully_qualified_name;
3006 while (len > 0 && isspace(buffer[len-1])) len--;
3009 if (Ustrcmp(buffer, "q") == 0) break;
3011 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3012 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3013 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A;
3014 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3015 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3016 else if (Ustrcmp(buffer, "srv+a") == 0)
3017 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A;
3018 else if (Ustrcmp(buffer, "srv+mx") == 0)
3019 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3020 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3021 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A;
3022 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3023 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3024 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3025 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3026 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3028 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3029 _res.retrans = dns_retrans;
3031 else if (Ustrncmp(buffer, "retry", 5) == 0)
3033 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3034 _res.retry = dns_retry;
3036 else if (alldigits(buffer))
3038 debug_selector = Ustrtol(buffer, NULL, 0);
3039 _res.options &= ~RES_DEBUG;
3040 DEBUG(D_resolver) _res.options |= RES_DEBUG;
3044 int flags = whichrrs;
3050 h.status = hstatus_unknown;
3051 h.why = hwhy_unknown;
3054 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3055 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3058 host_find_byname(&h, NULL, &fully_qualified_name, TRUE)
3060 host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3061 &fully_qualified_name, NULL);
3063 if (rc == HOST_FIND_FAILED) printf("Failed\n");
3064 else if (rc == HOST_FIND_AGAIN) printf("Again\n");
3065 else if (rc == HOST_FOUND_LOCAL) printf("Local\n");
3071 printf("Testing host_aton\n");
3073 while (Ufgets(buffer, 256, stdin) != NULL)
3077 int len = Ustrlen(buffer);
3079 while (len > 0 && isspace(buffer[len-1])) len--;
3082 if (Ustrcmp(buffer, "q") == 0) break;
3084 len = host_aton(buffer, x);
3085 printf("length = %d ", len);
3086 for (i = 0; i < len; i++)
3088 printf("%04x ", (x[i] >> 16) & 0xffff);
3089 printf("%04x ", x[i] & 0xffff);
3096 printf("Testing host_name_lookup\n");
3098 while (Ufgets(buffer, 256, stdin) != NULL)
3100 int len = Ustrlen(buffer);
3101 while (len > 0 && isspace(buffer[len-1])) len--;
3103 if (Ustrcmp(buffer, "q") == 0) break;
3104 sender_host_address = buffer;
3105 sender_host_name = NULL;
3106 sender_host_aliases = NULL;
3107 host_lookup_msg = US"";
3108 host_lookup_failed = FALSE;
3109 if (host_name_lookup() == FAIL) /* Debug causes printing */
3110 printf("Lookup failed:%s\n", host_lookup_msg);
3118 #endif /* STAND_ALONE */