1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for finding hosts, either by gethostbyname(), gethostbyaddr(), or
9 directly via the DNS. When IPv6 is supported, getipnodebyname() and
10 getipnodebyaddr() may be used instead of gethostbyname() and gethostbyaddr(),
11 if the newer functions are available. This module also contains various other
12 functions concerned with hosts and addresses, and a random number function,
13 used for randomizing hosts with equal MXs but available for use in other parts
20 /* Static variable for preserving the list of interface addresses in case it is
21 used more than once. */
23 static ip_address_item *local_interface_data = NULL;
26 #ifdef USE_INET_NTOA_FIX
27 /*************************************************
28 * Replacement for broken inet_ntoa() *
29 *************************************************/
31 /* On IRIX systems, gcc uses a different structure passing convention to the
32 native libraries. This causes inet_ntoa() to always yield 0.0.0.0 or
33 255.255.255.255. To get round this, we provide a private version of the
34 function here. It is used only if USE_INET_NTOA_FIX is set, which should happen
35 only when gcc is in use on an IRIX system. Code send to me by J.T. Breitner,
39 as seen in comp.sys.sgi.admin
41 August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
42 should now be set for them as well.
44 Arguments: sa an in_addr structure
45 Returns: pointer to static text string
49 inet_ntoa(struct in_addr sa)
51 static uschar addr[20];
52 sprintf(addr, "%d.%d.%d.%d",
63 /*************************************************
64 * Random number generator *
65 *************************************************/
67 /* This is a simple pseudo-random number generator. It does not have to be
68 very good for the uses to which it is put. When running the regression tests,
69 start with a fixed seed.
71 If you need better, see vaguely_random_number() which is potentially stronger,
72 if a crypto library is available, but might end up just calling this instead.
75 limit: one more than the largest number required
77 Returns: a pseudo-random number in the range 0 to limit-1
81 random_number(int limit)
87 if (f.running_in_test_harness) random_seed = 42; else
89 int p = (int)getpid();
90 random_seed = (int)time(NULL) ^ ((p << 16) | p);
93 random_seed = 1103515245 * random_seed + 12345;
94 return (unsigned int)(random_seed >> 16) % limit;
97 /*************************************************
98 * Wrappers for logging lookup times *
99 *************************************************/
101 /* When the 'slow_lookup_log' variable is enabled, these wrappers will
102 write to the log file all (potential) dns lookups that take more than
103 slow_lookup_log milliseconds
107 log_long_lookup(const uschar * type, const uschar * data, unsigned long msec)
109 log_write(0, LOG_MAIN, "Long %s lookup for '%s': %lu msec",
114 /* returns the current system epoch time in milliseconds. */
118 struct timeval tmp_time;
119 unsigned long seconds, microseconds;
121 gettimeofday(&tmp_time, NULL);
122 seconds = (unsigned long) tmp_time.tv_sec;
123 microseconds = (unsigned long) tmp_time.tv_usec;
124 return seconds*1000 + microseconds/1000;
129 dns_lookup_timerwrap(dns_answer *dnsa, const uschar *name, int type,
130 const uschar **fully_qualified_name)
133 unsigned long time_msec;
135 if (!slow_lookup_log)
136 return dns_lookup(dnsa, name, type, fully_qualified_name);
138 time_msec = get_time_in_ms();
139 retval = dns_lookup(dnsa, name, type, fully_qualified_name);
140 if ((time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
141 log_long_lookup(US"name", name, time_msec);
146 /*************************************************
147 * Replace gethostbyname() when testing *
148 *************************************************/
150 /* This function is called instead of gethostbyname(), gethostbyname2(), or
151 getipnodebyname() when running in the test harness. . It also
152 recognizes an unqualified "localhost" and forces it to the appropriate loopback
153 address. IP addresses are treated as literals. For other names, it uses the DNS
154 to find the host name. In the test harness, this means it will access only the
158 name the host name or a textual IP address
159 af AF_INET or AF_INET6
160 error_num where to put an error code:
161 HOST_NOT_FOUND/TRY_AGAIN/NO_RECOVERY/NO_DATA
163 Returns: a hostent structure or NULL for an error
166 static struct hostent *
167 host_fake_gethostbyname(const uschar *name, int af, int *error_num)
170 int alen = (af == AF_INET)? sizeof(struct in_addr):sizeof(struct in6_addr);
172 int alen = sizeof(struct in_addr);
176 const uschar *lname = name;
179 struct hostent *yield;
185 debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
186 (af == AF_INET)? "IPv4" : "IPv6");
188 /* Handle unqualified "localhost" */
190 if (Ustrcmp(name, "localhost") == 0)
191 lname = (af == AF_INET)? US"127.0.0.1" : US"::1";
193 /* Handle a literal IP address */
195 ipa = string_is_ip_address(lname, NULL);
198 if ((ipa == 4 && af == AF_INET) ||
199 (ipa == 6 && af == AF_INET6))
203 yield = store_get(sizeof(struct hostent));
204 alist = store_get(2 * sizeof(char *));
205 adds = store_get(alen);
206 yield->h_name = CS name;
207 yield->h_aliases = NULL;
208 yield->h_addrtype = af;
209 yield->h_length = alen;
210 yield->h_addr_list = CSS alist;
212 n = host_aton(lname, x);
213 for (i = 0; i < n; i++)
216 *adds++ = (y >> 24) & 255;
217 *adds++ = (y >> 16) & 255;
218 *adds++ = (y >> 8) & 255;
224 /* Wrong kind of literal address */
228 *error_num = HOST_NOT_FOUND;
233 /* Handle a host name */
237 int type = (af == AF_INET)? T_A:T_AAAA;
238 int rc = dns_lookup_timerwrap(&dnsa, lname, type, NULL);
241 lookup_dnssec_authenticated = NULL;
245 case DNS_SUCCEED: break;
246 case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
247 case DNS_NODATA: *error_num = NO_DATA; return NULL;
248 case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
250 case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
253 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
255 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
256 if (rr->type == type)
259 yield = store_get(sizeof(struct hostent));
260 alist = store_get((count + 1) * sizeof(char *));
261 adds = store_get(count *alen);
263 yield->h_name = CS name;
264 yield->h_aliases = NULL;
265 yield->h_addrtype = af;
266 yield->h_length = alen;
267 yield->h_addr_list = CSS alist;
269 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
271 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
276 if (rr->type != type) continue;
277 if (!(da = dns_address_from_rr(&dnsa, rr))) break;
279 n = host_aton(da->address, x);
280 for (i = 0; i < n; i++)
283 *adds++ = (y >> 24) & 255;
284 *adds++ = (y >> 16) & 255;
285 *adds++ = (y >> 8) & 255;
297 /*************************************************
298 * Build chain of host items from list *
299 *************************************************/
301 /* This function builds a chain of host items from a textual list of host
302 names. It does not do any lookups. If randomize is true, the chain is build in
303 a randomized order. There may be multiple groups of independently randomized
304 hosts; they are delimited by a host name consisting of just "+".
307 anchor anchor for the chain
309 randomize TRUE for randomizing
315 host_build_hostlist(host_item **anchor, const uschar *list, BOOL randomize)
318 int fake_mx = MX_NONE; /* This value is actually -1 */
322 if (randomize) fake_mx--; /* Start at -2 for randomizing */
326 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
330 if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
331 { /* ignore if not randomizing */
332 if (randomize) fake_mx--;
336 h = store_get(sizeof(host_item));
341 h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
342 h->status = hstatus_unknown;
343 h->why = hwhy_unknown;
353 host_item *hh = *anchor;
354 if (h->sort_key < hh->sort_key)
361 while (hh->next && h->sort_key >= hh->next->sort_key)
374 /*************************************************
375 * Extract port from address string *
376 *************************************************/
378 /* In the spool file, and in the -oMa and -oMi options, a host plus port is
379 given as an IP address followed by a dot and a port number. This function
382 An alternative format for the -oMa and -oMi options is [ip address]:port which
383 is what Exim 4 uses for output, because it seems to becoming commonly used,
384 whereas the dot form confuses some programs/people. So we recognize that form
388 address points to the string; if there is a port, the '.' in the string
389 is overwritten with zero to terminate the address; if the string
390 is in the [xxx]:ppp format, the address is shifted left and the
393 Returns: 0 if there is no port, else the port number. If there's a syntax
394 error, leave the incoming address alone, and return 0.
398 host_address_extract_port(uschar *address)
403 /* Handle the "bracketed with colon on the end" format */
407 uschar *rb = address + 1;
408 while (*rb != 0 && *rb != ']') rb++;
409 if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
412 port = Ustrtol(rb + 1, &endptr, 10);
413 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
415 else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
416 memmove(address, address + 1, rb - address - 2);
420 /* Handle the "dot on the end" format */
424 int skip = -3; /* Skip 3 dots in IPv4 addresses */
426 while (*(++address) != 0)
429 if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
430 else if (ch == '.' && skip++ >= 0) break;
432 if (*address == 0) return 0;
433 port = Ustrtol(address + 1, &endptr, 10);
434 if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
442 /*************************************************
443 * Get port from a host item's name *
444 *************************************************/
446 /* This function is called when finding the IP address for a host that is in a
447 list of hosts explicitly configured, such as in the manualroute router, or in a
448 fallback hosts list. We see if there is a port specification at the end of the
449 host name, and if so, remove it. A minimum length of 3 is required for the
450 original name; nothing shorter is recognized as having a port.
452 We test for a name ending with a sequence of digits; if preceded by colon we
453 have a port if the character before the colon is ] and the name starts with [
454 or if there are no other colons in the name (i.e. it's not an IPv6 address).
456 Arguments: pointer to the host item
457 Returns: a port number or PORT_NONE
461 host_item_get_port(host_item *h)
465 int len = Ustrlen(h->name);
467 if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
469 /* Extract potential port number */
474 while (p > h->name + 1 && isdigit(*p))
476 port += (*p-- - '0') * x;
480 /* The smallest value of p at this point is h->name + 1. */
482 if (*p != ':') return PORT_NONE;
484 if (p[-1] == ']' && h->name[0] == '[')
485 h->name = string_copyn(h->name + 1, p - h->name - 2);
486 else if (Ustrchr(h->name, ':') == p)
487 h->name = string_copyn(h->name, p - h->name);
488 else return PORT_NONE;
490 DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
496 #ifndef STAND_ALONE /* Omit when standalone testing */
498 /*************************************************
499 * Build sender_fullhost and sender_rcvhost *
500 *************************************************/
502 /* This function is called when sender_host_name and/or sender_helo_name
503 have been set. Or might have been set - for a local message read off the spool
504 they won't be. In that case, do nothing. Otherwise, set up the fullhost string
507 (a) No sender_host_name or sender_helo_name: "[ip address]"
508 (b) Just sender_host_name: "host_name [ip address]"
509 (c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
510 in which case: "[ip address}"
511 (d) The two are identical: "host_name [ip address]" includes helo = IP
512 (e) The two are different: "host_name (helo_name) [ip address]"
514 If log_incoming_port is set, the sending host's port number is added to the IP
517 This function also builds sender_rcvhost for use in Received: lines, whose
518 syntax is a bit different. This value also includes the RFC 1413 identity.
519 There wouldn't be two different variables if I had got all this right in the
522 Because this data may survive over more than one incoming SMTP message, it has
523 to be in permanent store. However, STARTTLS has to be forgotten and redone
524 on a multi-message conn, so this will be called once per message then. Hence
525 we use malloc, so we can free.
532 host_build_sender_fullhost(void)
534 BOOL show_helo = TRUE;
535 uschar * address, * fullhost, * rcvhost, * reset_point;
538 if (!sender_host_address) return;
540 reset_point = store_get(0);
542 /* Set up address, with or without the port. After discussion, it seems that
543 the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
544 use this directly as the first item for Received: because it ain't an RFC 2822
547 address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
548 if (!LOGGING(incoming_port) || sender_host_port <= 0)
549 *(Ustrrchr(address, ':')) = 0;
551 /* If there's no EHLO/HELO data, we can't show it. */
553 if (!sender_helo_name) show_helo = FALSE;
555 /* If HELO/EHLO was followed by an IP literal, it's messy because of two
556 features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
557 doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
558 be given in canonical form, so we have to canonicalize them before comparing. As
559 it happens, the code works for both IPv4 and IPv6. */
561 else if (sender_helo_name[0] == '[' &&
562 sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
567 if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
568 if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
570 helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
572 if (string_is_ip_address(helo_ip, NULL) != 0)
576 uschar ipx[48], ipy[48]; /* large enough for full IPv6 */
578 sizex = host_aton(helo_ip, x);
579 sizey = host_aton(sender_host_address, y);
581 (void)host_nmtoa(sizex, x, -1, ipx, ':');
582 (void)host_nmtoa(sizey, y, -1, ipy, ':');
584 if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
588 /* Host name is not verified */
590 if (!sender_host_name)
592 uschar *portptr = Ustrstr(address, "]:");
594 int adlen; /* Sun compiler doesn't like ++ in initializers */
596 adlen = portptr ? (++portptr - address) : Ustrlen(address);
597 fullhost = sender_helo_name
598 ? string_sprintf("(%s) %s", sender_helo_name, address)
601 g = string_catn(NULL, address, adlen);
603 if (sender_ident || show_helo || portptr)
606 g = string_catn(g, US" (", 2);
610 g = string_append(g, 2, US"port=", portptr + 1);
613 g = string_append(g, 2,
614 firstptr == g->ptr ? US"helo=" : US" helo=", sender_helo_name);
617 g = string_append(g, 2,
618 firstptr == g->ptr ? US"ident=" : US" ident=", sender_ident);
620 g = string_catn(g, US")", 1);
623 rcvhost = string_from_gstring(g);
626 /* Host name is known and verified. Unless we've already found that the HELO
627 data matches the IP address, compare it with the name. */
631 if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
636 fullhost = string_sprintf("%s (%s) %s", sender_host_name,
637 sender_helo_name, address);
638 rcvhost = sender_ident
639 ? string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
640 address, sender_helo_name, sender_ident)
641 : string_sprintf("%s (%s helo=%s)", sender_host_name,
642 address, sender_helo_name);
646 fullhost = string_sprintf("%s %s", sender_host_name, address);
647 rcvhost = sender_ident
648 ? string_sprintf("%s (%s ident=%s)", sender_host_name, address,
650 : string_sprintf("%s (%s)", sender_host_name, address);
654 if (sender_fullhost) store_free(sender_fullhost);
655 sender_fullhost = string_copy_malloc(fullhost);
656 if (sender_rcvhost) store_free(sender_rcvhost);
657 sender_rcvhost = string_copy_malloc(rcvhost);
659 store_reset(reset_point);
661 DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
662 DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
667 /*************************************************
668 * Build host+ident message *
669 *************************************************/
671 /* Used when logging rejections and various ACL and SMTP incidents. The text
672 return depends on whether sender_fullhost and sender_ident are set or not:
674 no ident, no host => U=unknown
675 no ident, host set => H=sender_fullhost
676 ident set, no host => U=ident
677 ident set, host set => H=sender_fullhost U=ident
680 useflag TRUE if first item to be flagged (H= or U=); if there are two
681 items, the second is always flagged
683 Returns: pointer to a string in big_buffer
687 host_and_ident(BOOL useflag)
689 if (!sender_fullhost)
690 (void)string_format(big_buffer, big_buffer_size, "%s%s", useflag ? "U=" : "",
691 sender_ident ? sender_ident : US"unknown");
694 uschar * flag = useflag ? US"H=" : US"";
695 uschar * iface = US"";
696 if (LOGGING(incoming_interface) && interface_address)
697 iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
699 (void)string_format(big_buffer, big_buffer_size, "%s%s%s U=%s",
700 flag, sender_fullhost, iface, sender_ident);
702 (void)string_format(big_buffer, big_buffer_size, "%s%s%s",
703 flag, sender_fullhost, iface);
708 #endif /* STAND_ALONE */
713 /*************************************************
714 * Build list of local interfaces *
715 *************************************************/
717 /* This function interprets the contents of the local_interfaces or
718 extra_local_interfaces options, and creates an ip_address_item block for each
719 item on the list. There is no special interpretation of any IP addresses; in
720 particular, 0.0.0.0 and ::0 are returned without modification. If any address
721 includes a port, it is set in the block. Otherwise the port value is set to
726 name the name of the option being expanded
728 Returns: a chain of ip_address_items, each containing to a textual
729 version of an IP address, and a port number (host order) or
730 zero if no port was given with the address
734 host_build_ifacelist(const uschar *list, uschar *name)
738 ip_address_item * yield = NULL, * last = NULL, * next;
740 while ((s = string_nextinlist(&list, &sep, NULL, 0)))
743 int port = host_address_extract_port(s); /* Leaves just the IP address */
745 if (!(ipv = string_is_ip_address(s, NULL)))
746 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
749 /* Skip IPv6 addresses if IPv6 is disabled. */
751 if (disable_ipv6 && ipv == 6) continue;
753 /* This use of strcpy() is OK because we have checked that s is a valid IP
754 address above. The field in the ip_address_item is large enough to hold an
757 next = store_get(sizeof(ip_address_item));
759 Ustrcpy(next->address, s);
761 next->v6_include_v4 = FALSE;
780 /*************************************************
781 * Find addresses on local interfaces *
782 *************************************************/
784 /* This function finds the addresses of local IP interfaces. These are used
785 when testing for routing to the local host. As the function may be called more
786 than once, the list is preserved in permanent store, pointed to by a static
787 variable, to save doing the work more than once per process.
789 The generic list of interfaces is obtained by calling host_build_ifacelist()
790 for local_interfaces and extra_local_interfaces. This list scanned to remove
791 duplicates (which may exist with different ports - not relevant here). If
792 either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
793 replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
794 obtained from os_find_running_interfaces().
797 Returns: a chain of ip_address_items, each containing to a textual
798 version of an IP address; the port numbers are not relevant
802 /* First, a local subfunction to add an interface to a list in permanent store,
803 but only if there isn't a previous copy of that address on the list. */
805 static ip_address_item *
806 add_unique_interface(ip_address_item *list, ip_address_item *ipa)
808 ip_address_item *ipa2;
809 for (ipa2 = list; ipa2 != NULL; ipa2 = ipa2->next)
810 if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
811 ipa2 = store_get_perm(sizeof(ip_address_item));
818 /* This is the globally visible function */
821 host_find_interfaces(void)
823 ip_address_item *running_interfaces = NULL;
825 if (local_interface_data == NULL)
827 void *reset_item = store_get(0);
828 ip_address_item *dlist = host_build_ifacelist(CUS local_interfaces,
829 US"local_interfaces");
830 ip_address_item *xlist = host_build_ifacelist(CUS extra_local_interfaces,
831 US"extra_local_interfaces");
832 ip_address_item *ipa;
834 if (dlist == NULL) dlist = xlist; else
836 for (ipa = dlist; ipa->next != NULL; ipa = ipa->next);
840 for (ipa = dlist; ipa != NULL; ipa = ipa->next)
842 if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
843 Ustrcmp(ipa->address, "::0") == 0)
845 ip_address_item *ipa2;
846 BOOL ipv6 = ipa->address[0] == ':';
847 if (running_interfaces == NULL)
848 running_interfaces = os_find_running_interfaces();
849 for (ipa2 = running_interfaces; ipa2 != NULL; ipa2 = ipa2->next)
851 if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
852 local_interface_data = add_unique_interface(local_interface_data,
858 local_interface_data = add_unique_interface(local_interface_data, ipa);
861 debug_printf("Configured local interface: address=%s", ipa->address);
862 if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
867 store_reset(reset_item);
870 return local_interface_data;
877 /*************************************************
878 * Convert network IP address to text *
879 *************************************************/
881 /* Given an IPv4 or IPv6 address in binary, convert it to a text
882 string and return the result in a piece of new store. The address can
883 either be given directly, or passed over in a sockaddr structure. Note
884 that this isn't the converse of host_aton() because of byte ordering
885 differences. See host_nmtoa() below.
888 type if < 0 then arg points to a sockaddr, else
889 either AF_INET or AF_INET6
890 arg points to a sockaddr if type is < 0, or
891 points to an IPv4 address (32 bits), or
892 points to an IPv6 address (128 bits),
893 in both cases, in network byte order
894 buffer if NULL, the result is returned in gotten store;
895 else points to a buffer to hold the answer
896 portptr points to where to put the port number, if non NULL; only
899 Returns: pointer to character string
903 host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
907 /* The new world. It is annoying that we have to fish out the address from
908 different places in the block, depending on what kind of address it is. It
909 is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
910 function inet_ntoa() returns just uschar *, and some picky compilers insist
911 on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
914 uschar addr_buffer[46];
917 int family = ((struct sockaddr *)arg)->sa_family;
918 if (family == AF_INET6)
920 struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
921 yield = US inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
922 sizeof(addr_buffer));
923 if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
927 struct sockaddr_in *sk = (struct sockaddr_in *)arg;
928 yield = US inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
929 sizeof(addr_buffer));
930 if (portptr != NULL) *portptr = ntohs(sk->sin_port);
935 yield = US inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
938 /* If the result is a mapped IPv4 address, show it in V4 format. */
940 if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
942 #else /* HAVE_IPV6 */
948 yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
949 if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
952 yield = US inet_ntoa(*((struct in_addr *)arg));
955 /* If there is no buffer, put the string into some new store. */
957 if (buffer == NULL) return string_copy(yield);
959 /* Callers of this function with a non-NULL buffer must ensure that it is
960 large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
961 makes this use of strcpy() OK. */
963 Ustrcpy(buffer, yield);
970 /*************************************************
971 * Convert address text to binary *
972 *************************************************/
974 /* Given the textual form of an IP address, convert it to binary in an
975 array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
976 The result has the first byte in the most significant byte of the first int. In
977 other words, the result is not in network byte order, but in host byte order.
978 As a result, this is not the converse of host_ntoa(), which expects network
979 byte order. See host_nmtoa() below.
982 address points to the textual address, checked for syntax
983 bin points to an array of 4 ints
985 Returns: the number of ints used
989 host_aton(const uschar *address, int *bin)
994 /* Handle IPv6 address, which may end with an IPv4 address. It may also end
995 with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
996 HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
999 if (Ustrchr(address, ':') != NULL)
1001 const uschar *p = address;
1002 const uschar *component[8];
1003 BOOL ipv4_ends = FALSE;
1009 /* If the address starts with a colon, it will start with two colons.
1010 Just lose the first one, which will leave a null first component. */
1014 /* Split the address into components separated by colons. The input address
1015 is supposed to be checked for syntax. There was a case where this was
1016 overlooked; to guard against that happening again, check here and crash if
1017 there are too many components. */
1019 while (*p != 0 && *p != '%')
1021 int len = Ustrcspn(p, ":%");
1022 if (len == 0) nulloffset = ci;
1023 if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1024 "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
1026 component[ci++] = p;
1031 /* If the final component contains a dot, it is a trailing v4 address.
1032 As the syntax is known to be checked, just set up for a trailing
1033 v4 address and restrict the v6 part to 6 components. */
1035 if (Ustrchr(component[ci-1], '.') != NULL)
1037 address = component[--ci];
1043 /* If there are fewer than 6 or 8 components, we have to insert some
1044 more empty ones in the middle. */
1048 int insert_count = v6count - ci;
1049 for (i = v6count-1; i > nulloffset + insert_count; i--)
1050 component[i] = component[i - insert_count];
1051 while (i > nulloffset) component[i--] = US"";
1054 /* Now turn the components into binary in pairs and bung them
1055 into the vector of ints. */
1057 for (i = 0; i < v6count; i += 2)
1058 bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
1059 Ustrtol(component[i+1], NULL, 16);
1061 /* If there was no terminating v4 component, we are done. */
1063 if (!ipv4_ends) return 4;
1066 /* Handle IPv4 address */
1068 (void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
1069 bin[v4offset] = ((uint)x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
1074 /*************************************************
1075 * Apply mask to an IP address *
1076 *************************************************/
1078 /* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
1082 count the number of ints
1083 binary points to the ints to be masked
1084 mask the count of ms bits to leave, or -1 if no masking
1090 host_mask(int count, int *binary, int mask)
1093 if (mask < 0) mask = 99999;
1094 for (i = 0; i < count; i++)
1097 if (mask == 0) wordmask = 0;
1100 wordmask = (uint)(-1) << (32 - mask);
1108 binary[i] &= wordmask;
1115 /*************************************************
1116 * Convert masked IP address in ints to text *
1117 *************************************************/
1119 /* We can't use host_ntoa() because it assumes the binary values are in network
1120 byte order, and these are the result of host_aton(), which puts them in ints in
1121 host byte order. Also, we really want IPv6 addresses to be in a canonical
1122 format, so we output them with no abbreviation. In a number of cases we can't
1123 use the normal colon separator in them because it terminates keys in lsearch
1124 files, so we want to use dot instead. There's an argument that specifies what
1125 to use for IPv6 addresses.
1128 count 1 or 4 (number of ints)
1129 binary points to the ints
1130 mask mask value; if < 0 don't add to result
1131 buffer big enough to hold the result
1132 sep component separator character for IPv6 addresses
1134 Returns: the number of characters placed in buffer, not counting
1139 host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
1142 uschar *tt = buffer;
1147 for (i = 24; i >= 0; i -= 8)
1148 tt += sprintf(CS tt, "%d.", (j >> i) & 255);
1151 for (i = 0; i < 4; i++)
1154 tt += sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
1157 tt--; /* lose final separator */
1162 tt += sprintf(CS tt, "/%d", mask);
1168 /* Like host_nmtoa() but: ipv6-only, canonical output, no mask
1171 binary points to the ints
1172 buffer big enough to hold the result
1174 Returns: the number of characters placed in buffer, not counting
1179 ipv6_nmtoa(int * binary, uschar * buffer)
1182 uschar * c = buffer;
1183 uschar * d = NULL; /* shut insufficiently "clever" compiler up */
1185 for (i = 0; i < 4; i++)
1186 { /* expand to text */
1188 c += sprintf(CS c, "%x:%x:", (j >> 16) & 0xffff, j & 0xffff);
1191 for (c = buffer, k = -1, i = 0; i < 8; i++)
1192 { /* find longest 0-group sequence */
1193 if (*c == '0') /* must be "0:" */
1197 while (c[2] == '0') i++, c += 2;
1200 k = i-j; /* length of sequence */
1201 d = s; /* start of sequence */
1204 while (*++c != ':') ;
1208 c[-1] = '\0'; /* drop trailing colon */
1210 /* debug_printf("%s: D k %d <%s> <%s>\n", __FUNCTION__, k, d, d + 2*(k+1)); */
1214 if (d == buffer) c--; /* need extra colon */
1215 *d++ = ':'; /* 1st 0 */
1216 while ((*d++ = *c++)) ;
1226 /*************************************************
1227 * Check port for tls_on_connect *
1228 *************************************************/
1230 /* This function checks whether a given incoming port is configured for tls-
1231 on-connect. It is called from the daemon and from inetd handling. If the global
1232 option tls_on_connect is already set, all ports operate this way. Otherwise, we
1233 check the tls_on_connect_ports option for a list of ports.
1235 Argument: a port number
1236 Returns: TRUE or FALSE
1240 host_is_tls_on_connect_port(int port)
1244 const uschar *list = tls_in.on_connect_ports;
1248 if (tls_in.on_connect) return TRUE;
1250 while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
1251 if (Ustrtol(s, &end, 10) == port)
1259 /*************************************************
1260 * Check whether host is in a network *
1261 *************************************************/
1263 /* This function checks whether a given IP address matches a pattern that
1264 represents either a single host, or a network (using CIDR notation). The caller
1265 of this function must check the syntax of the arguments before calling it.
1268 host string representation of the ip-address to check
1269 net string representation of the network, with optional CIDR mask
1270 maskoffset offset to the / that introduces the mask in the key
1271 zero if there is no mask
1274 TRUE the host is inside the network
1275 FALSE the host is NOT inside the network
1279 host_is_in_net(const uschar *host, const uschar *net, int maskoffset)
1285 int size = host_aton(net, address);
1288 /* No mask => all bits to be checked */
1290 if (maskoffset == 0) mlen = 99999; /* Big number */
1291 else mlen = Uatoi(net + maskoffset + 1);
1293 /* Convert the incoming address to binary. */
1295 insize = host_aton(host, incoming);
1297 /* Convert IPv4 addresses given in IPv6 compatible mode, which represent
1298 connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
1299 ::ffff:<v4address>, to IPv4 format. */
1301 if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
1302 incoming[2] == 0xffff)
1305 incoming[0] = incoming[3];
1308 /* No match if the sizes don't agree. */
1310 if (insize != size) return FALSE;
1312 /* Else do the masked comparison. */
1314 for (i = 0; i < size; i++)
1317 if (mlen == 0) mask = 0;
1320 mask = (uint)(-1) << (32 - mlen);
1328 if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
1336 /*************************************************
1337 * Scan host list for local hosts *
1338 *************************************************/
1340 /* Scan through a chain of addresses and check whether any of them is the
1341 address of an interface on the local machine. If so, remove that address and
1342 any previous ones with the same MX value, and all subsequent ones (which will
1343 have greater or equal MX values) from the chain. Note: marking them as unusable
1344 is NOT the right thing to do because it causes the hosts not to be used for
1345 other domains, for which they may well be correct.
1347 The hosts may be part of a longer chain; we only process those between the
1348 initial pointer and the "last" pointer.
1350 There is also a list of "pseudo-local" host names which are checked against the
1351 host names. Any match causes that host item to be treated the same as one which
1352 matches a local IP address.
1354 If the very first host is a local host, then all MX records had a precedence
1355 greater than or equal to that of the local host. Either there's a problem in
1356 the DNS, or an apparently remote name turned out to be an abbreviation for the
1357 local host. Give a specific return code, and let the caller decide what to do.
1358 Otherwise, give a success code if at least one host address has been found.
1361 host pointer to the first host in the chain
1362 lastptr pointer to pointer to the last host in the chain (may be updated)
1363 removed if not NULL, set TRUE if some local addresses were removed
1367 HOST_FOUND if there is at least one host with an IP address on the chain
1368 and an MX value less than any MX value associated with the
1370 HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
1371 the host addresses were obtained from A records or
1372 gethostbyname(), the MX values are set to -1.
1373 HOST_FIND_FAILED if no valid hosts with set IP addresses were found
1377 host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
1379 int yield = HOST_FIND_FAILED;
1380 host_item *last = *lastptr;
1381 host_item *prev = NULL;
1384 if (removed != NULL) *removed = FALSE;
1386 if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
1388 for (h = host; h != last->next; h = h->next)
1391 if (hosts_treat_as_local != NULL)
1394 const uschar *save = deliver_domain;
1395 deliver_domain = h->name; /* set $domain */
1396 rc = match_isinlist(string_copylc(h->name), CUSS &hosts_treat_as_local, 0,
1397 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
1398 deliver_domain = save;
1399 if (rc == OK) goto FOUND_LOCAL;
1403 /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
1404 for 127.0.0.1 and refers to the local host. We therefore force it always to
1405 be treated as local. */
1407 if (h->address != NULL)
1409 ip_address_item *ip;
1410 if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
1411 for (ip = local_interface_data; ip != NULL; ip = ip->next)
1412 if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
1413 yield = HOST_FOUND; /* At least one remote address has been found */
1416 /* Update prev to point to the last host item before any that have
1417 the same MX value as the one we have just considered. */
1419 if (h->next == NULL || h->next->mx != h->mx) prev = h;
1422 return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
1424 /* A host whose IP address matches a local IP address, or whose name matches
1425 something in hosts_treat_as_local has been found. */
1431 HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
1432 "local host has lowest MX\n" :
1433 "local host found for non-MX address\n");
1434 return HOST_FOUND_LOCAL;
1437 HDEBUG(D_host_lookup)
1439 debug_printf("local host in host list - removed hosts:\n");
1440 for (h = prev->next; h != last->next; h = h->next)
1441 debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
1444 if (removed != NULL) *removed = TRUE;
1445 prev->next = last->next;
1453 /*************************************************
1454 * Remove duplicate IPs in host list *
1455 *************************************************/
1457 /* You would think that administrators could set up their DNS records so that
1458 one ended up with a list of unique IP addresses after looking up A or MX
1459 records, but apparently duplication is common. So we scan such lists and
1460 remove the later duplicates. Note that we may get lists in which some host
1461 addresses are not set.
1464 host pointer to the first host in the chain
1465 lastptr pointer to pointer to the last host in the chain (may be updated)
1471 host_remove_duplicates(host_item *host, host_item **lastptr)
1473 while (host != *lastptr)
1475 if (host->address != NULL)
1477 host_item *h = host;
1478 while (h != *lastptr)
1480 if (h->next->address != NULL &&
1481 Ustrcmp(h->next->address, host->address) == 0)
1483 DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
1484 "removed\n", host->address, h->next->mx);
1485 if (h->next == *lastptr) *lastptr = h;
1486 h->next = h->next->next;
1491 /* If the last item was removed, host may have become == *lastptr */
1492 if (host != *lastptr) host = host->next;
1499 /*************************************************
1500 * Find sender host name by gethostbyaddr() *
1501 *************************************************/
1503 /* This used to be the only way it was done, but it turns out that not all
1504 systems give aliases for calls to gethostbyaddr() - or one of the modern
1505 equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
1506 but they can still exist. This function is now used only when a DNS lookup of
1507 the IP address fails, in order to give access to /etc/hosts.
1510 Returns: OK, DEFER, FAIL
1514 host_name_lookup_byaddr(void)
1518 struct hostent *hosts;
1519 struct in_addr addr;
1520 unsigned long time_msec = 0; /* init to quieten dumb static analysis */
1522 if (slow_lookup_log) time_msec = get_time_in_ms();
1524 /* Lookup on IPv6 system */
1527 if (Ustrchr(sender_host_address, ':') != NULL)
1529 struct in6_addr addr6;
1530 if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
1531 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1532 "IPv6 address", sender_host_address);
1533 #if HAVE_GETIPNODEBYADDR
1534 hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
1536 hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
1541 if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
1542 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
1543 "IPv4 address", sender_host_address);
1544 #if HAVE_GETIPNODEBYADDR
1545 hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
1547 hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
1551 /* Do lookup on IPv4 system */
1554 addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
1555 hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
1558 if ( slow_lookup_log
1559 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
1561 log_long_lookup(US"name", sender_host_address, time_msec);
1563 /* Failed to look up the host. */
1567 HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
1569 return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
1572 /* It seems there are some records in the DNS that yield an empty name. We
1573 treat this as non-existent. In some operating systems, this is returned as an
1574 empty string; in others as a single dot. */
1576 if (hosts->h_name == NULL || hosts->h_name[0] == 0 || hosts->h_name[0] == '.')
1578 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
1579 "treated as non-existent host name\n");
1583 /* Copy and lowercase the name, which is in static storage in many systems.
1584 Put it in permanent memory. */
1586 s = US hosts->h_name;
1587 len = Ustrlen(s) + 1;
1588 t = sender_host_name = store_get_perm(len);
1589 while (*s != 0) *t++ = tolower(*s++);
1592 /* If the host has aliases, build a copy of the alias list */
1594 if (hosts->h_aliases != NULL)
1597 uschar **aliases, **ptr;
1598 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++) count++;
1599 ptr = sender_host_aliases = store_get_perm(count * sizeof(uschar *));
1600 for (aliases = USS hosts->h_aliases; *aliases != NULL; aliases++)
1602 uschar *s = *aliases;
1603 int len = Ustrlen(s) + 1;
1604 uschar *t = *ptr++ = store_get_perm(len);
1605 while (*s != 0) *t++ = tolower(*s++);
1616 /*************************************************
1617 * Find host name for incoming call *
1618 *************************************************/
1620 /* Put the name in permanent store, pointed to by sender_host_name. We also set
1621 up a list of alias names, pointed to by sender_host_alias. The list is
1622 NULL-terminated. The incoming address is in sender_host_address, either in
1623 dotted-quad form for IPv4 or in colon-separated form for IPv6.
1625 This function does a thorough check that the names it finds point back to the
1626 incoming IP address. Any that do not are discarded. Note that this is relied on
1627 by the ACL reverse_host_lookup check.
1629 On some systems, get{host,ipnode}byaddr() appears to do this internally, but
1630 this it not universally true. Also, for release 4.30, this function was changed
1631 to do a direct DNS lookup first, by default[1], because it turns out that that
1632 is the only guaranteed way to find all the aliases on some systems. My
1633 experiments indicate that Solaris gethostbyaddr() gives the aliases for but
1636 [1] The actual order is controlled by the host_lookup_order option.
1639 Returns: OK on success, the answer being placed in the global variable
1640 sender_host_name, with any aliases in a list hung off
1642 FAIL if no host name can be found
1643 DEFER if a temporary error was encountered
1645 The variable host_lookup_msg is set to an empty string on success, or to a
1646 reason for the failure otherwise, in a form suitable for tagging onto an error
1647 message, and also host_lookup_failed is set TRUE if the lookup failed. If there
1648 was a defer, host_lookup_deferred is set TRUE.
1650 Any dynamically constructed string for host_lookup_msg must be in permanent
1651 store, because it might be used for several incoming messages on the same SMTP
1655 host_name_lookup(void)
1659 uschar *hname, *save_hostname;
1663 const uschar *list = host_lookup_order;
1668 sender_host_dnssec = host_lookup_deferred = host_lookup_failed = FALSE;
1670 HDEBUG(D_host_lookup)
1671 debug_printf("looking up host name for %s\n", sender_host_address);
1673 /* For testing the case when a lookup does not complete, we have a special
1674 reserved IP address. */
1676 if (f.running_in_test_harness &&
1677 Ustrcmp(sender_host_address, "99.99.99.99") == 0)
1679 HDEBUG(D_host_lookup)
1680 debug_printf("Test harness: host name lookup returns DEFER\n");
1681 host_lookup_deferred = TRUE;
1685 /* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
1686 the order specified by the host_lookup_order option. */
1688 while ((ordername = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
1690 if (strcmpic(ordername, US"bydns") == 0)
1692 dns_init(FALSE, FALSE, FALSE); /* dnssec ctrl by dns_dnssec_ok glbl */
1693 dns_build_reverse(sender_host_address, buffer);
1694 rc = dns_lookup_timerwrap(&dnsa, buffer, T_PTR, NULL);
1696 /* The first record we come across is used for the name; others are
1697 considered to be aliases. We have to scan twice, in order to find out the
1698 number of aliases. However, if all the names are empty, we will behave as
1699 if failure. (PTR records that yield empty names have been encountered in
1702 if (rc == DNS_SUCCEED)
1704 uschar **aptr = NULL;
1707 int old_pool = store_pool;
1709 sender_host_dnssec = dns_is_secure(&dnsa);
1711 debug_printf("Reverse DNS security status: %s\n",
1712 sender_host_dnssec ? "DNSSEC verified (AD)" : "unverified");
1714 store_pool = POOL_PERM; /* Save names in permanent storage */
1716 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1718 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1719 if (rr->type == T_PTR)
1722 /* Get store for the list of aliases. For compatibility with
1723 gethostbyaddr, we make an empty list if there are none. */
1725 aptr = sender_host_aliases = store_get(count * sizeof(uschar *));
1727 /* Re-scan and extract the names */
1729 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1731 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1734 if (rr->type != T_PTR) continue;
1735 s = store_get(ssize);
1737 /* If an overlong response was received, the data will have been
1738 truncated and dn_expand may fail. */
1740 if (dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen,
1741 US (rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
1743 log_write(0, LOG_MAIN, "host name alias list truncated for %s",
1744 sender_host_address);
1748 store_reset(s + Ustrlen(s) + 1);
1751 HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
1752 "empty name: treated as non-existent host name\n");
1755 if (!sender_host_name) sender_host_name = s;
1757 while (*s != 0) { *s = tolower(*s); s++; }
1760 *aptr = NULL; /* End of alias list */
1761 store_pool = old_pool; /* Reset store pool */
1763 /* If we've found a names, break out of the "order" loop */
1765 if (sender_host_name != NULL) break;
1768 /* If the DNS lookup deferred, we must also defer. */
1770 if (rc == DNS_AGAIN)
1772 HDEBUG(D_host_lookup)
1773 debug_printf("IP address PTR lookup gave temporary error\n");
1774 host_lookup_deferred = TRUE;
1779 /* Do a lookup using gethostbyaddr() - or equivalent */
1781 else if (strcmpic(ordername, US"byaddr") == 0)
1783 HDEBUG(D_host_lookup)
1784 debug_printf("IP address lookup using gethostbyaddr()\n");
1785 rc = host_name_lookup_byaddr();
1788 host_lookup_deferred = TRUE;
1789 return rc; /* Can't carry on */
1791 if (rc == OK) break; /* Found a name */
1793 } /* Loop for bydns/byaddr scanning */
1795 /* If we have failed to find a name, return FAIL and log when required.
1796 NB host_lookup_msg must be in permanent store. */
1798 if (!sender_host_name)
1800 if (host_checking || !f.log_testing_mode)
1801 log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
1802 "address %s", sender_host_address);
1803 host_lookup_msg = US" (failed to find host name from IP address)";
1804 host_lookup_failed = TRUE;
1808 HDEBUG(D_host_lookup)
1810 uschar **aliases = sender_host_aliases;
1811 debug_printf("IP address lookup yielded \"%s\"\n", sender_host_name);
1812 while (*aliases != NULL) debug_printf(" alias \"%s\"\n", *aliases++);
1815 /* We need to verify that a forward lookup on the name we found does indeed
1816 correspond to the address. This is for security: in principle a malefactor who
1817 happened to own a reverse zone could set it to point to any names at all.
1819 This code was present in versions of Exim before 3.20. At that point I took it
1820 out because I thought that gethostbyaddr() did the check anyway. It turns out
1821 that this isn't always the case, so it's coming back in at 4.01. This version
1822 is actually better, because it also checks aliases.
1824 The code was made more robust at release 4.21. Prior to that, it accepted all
1825 the names if any of them had the correct IP address. Now the code checks all
1826 the names, and accepts only those that have the correct IP address. */
1828 save_hostname = sender_host_name; /* Save for error messages */
1829 aliases = sender_host_aliases;
1830 for (hname = sender_host_name; hname; hname = *aliases++)
1834 host_item h = { .next = NULL, .name = hname, .mx = MX_NONE, .address = NULL };
1836 { .request = sender_host_dnssec ? US"*" : NULL, .require = NULL };
1838 if ( (rc = host_find_bydns(&h, NULL, HOST_FIND_BY_A | HOST_FIND_BY_AAAA,
1839 NULL, NULL, NULL, &d, NULL, NULL)) == HOST_FOUND
1840 || rc == HOST_FOUND_LOCAL
1844 HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
1846 /* If the forward lookup was not secure we cancel the is-secure variable */
1848 DEBUG(D_dns) debug_printf("Forward DNS security status: %s\n",
1849 h.dnssec == DS_YES ? "DNSSEC verified (AD)" : "unverified");
1850 if (h.dnssec != DS_YES) sender_host_dnssec = FALSE;
1852 for (hh = &h; hh; hh = hh->next)
1853 if (host_is_in_net(hh->address, sender_host_address, 0))
1855 HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
1860 HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
1862 if (!ok) HDEBUG(D_host_lookup)
1863 debug_printf("no IP address for %s matched %s\n", hname,
1864 sender_host_address);
1866 else if (rc == HOST_FIND_AGAIN)
1868 HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
1869 host_lookup_deferred = TRUE;
1870 sender_host_name = NULL;
1874 HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
1876 /* If this name is no good, and it's the sender name, set it null pro tem;
1877 if it's an alias, just remove it from the list. */
1881 if (hname == sender_host_name) sender_host_name = NULL; else
1883 uschar **a; /* Don't amalgamate - some */
1884 a = --aliases; /* compilers grumble */
1885 while (*a != NULL) { *a = a[1]; a++; }
1890 /* If sender_host_name == NULL, it means we didn't like the name. Replace
1891 it with the first alias, if there is one. */
1893 if (sender_host_name == NULL && *sender_host_aliases != NULL)
1894 sender_host_name = *sender_host_aliases++;
1896 /* If we now have a main name, all is well. */
1898 if (sender_host_name != NULL) return OK;
1900 /* We have failed to find an address that matches. */
1902 HDEBUG(D_host_lookup)
1903 debug_printf("%s does not match any IP address for %s\n",
1904 sender_host_address, save_hostname);
1906 /* This message must be in permanent store */
1908 old_pool = store_pool;
1909 store_pool = POOL_PERM;
1910 host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
1911 sender_host_address, save_hostname);
1912 store_pool = old_pool;
1913 host_lookup_failed = TRUE;
1920 /*************************************************
1921 * Find IP address(es) for host by name *
1922 *************************************************/
1924 /* The input is a host_item structure with the name filled in and the address
1925 field set to NULL. We use gethostbyname() or getipnodebyname() or
1926 gethostbyname2(), as appropriate. Of course, these functions may use the DNS,
1927 but they do not do MX processing. It appears, however, that in some systems the
1928 current setting of resolver options is used when one of these functions calls
1929 the resolver. For this reason, we call dns_init() at the start, with arguments
1930 influenced by bits in "flags", just as we do for host_find_bydns().
1932 The second argument provides a host list (usually an IP list) of hosts to
1933 ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
1934 addresses in unreasonable places.
1936 The lookup may result in a change of name. For compatibility with the dns
1937 lookup, return this via fully_qualified_name as well as updating the host item.
1938 The lookup may also yield more than one IP address, in which case chain on
1939 subsequent host_item structures.
1942 host a host item with the name and MX filled in;
1943 the address is to be filled in;
1944 multiple IP addresses cause other host items to be
1946 ignore_target_hosts a list of hosts to ignore
1947 flags HOST_FIND_QUALIFY_SINGLE ) passed to
1948 HOST_FIND_SEARCH_PARENTS ) dns_init()
1949 fully_qualified_name if not NULL, set to point to host name for
1950 compatibility with host_find_bydns
1951 local_host_check TRUE if a check for the local host is wanted
1953 Returns: HOST_FIND_FAILED Failed to find the host or domain
1954 HOST_FIND_AGAIN Try again later
1955 HOST_FOUND Host found - data filled in
1956 HOST_FOUND_LOCAL Host found and is the local host
1960 host_find_byname(host_item *host, const uschar *ignore_target_hosts, int flags,
1961 const uschar **fully_qualified_name, BOOL local_host_check)
1963 int i, yield, times;
1965 host_item *last = NULL;
1966 BOOL temp_error = FALSE;
1971 /* Make sure DNS options are set as required. This appears to be necessary in
1972 some circumstances when the get..byname() function actually calls the DNS. */
1974 dns_init((flags & HOST_FIND_QUALIFY_SINGLE) != 0,
1975 (flags & HOST_FIND_SEARCH_PARENTS) != 0,
1976 FALSE); /* Cannot retrieve dnssec status so do not request */
1978 /* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
1979 kinds of address, so go round the loop twice. Note that we have ensured that
1980 AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
1981 code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
1982 lookups here (except when testing standalone). */
1989 (dns_ipv4_lookup != NULL &&
1990 match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
1991 MCL_DOMAIN, TRUE, NULL) == OK))
1994 { af = AF_INET; times = 1; }
1996 { af = AF_INET6; times = 2; }
1998 /* No IPv6 support */
2000 #else /* HAVE_IPV6 */
2002 #endif /* HAVE_IPV6 */
2004 /* Initialize the flag that gets set for DNS syntax check errors, so that the
2005 interface to this function can be similar to host_find_bydns. */
2007 f.host_find_failed_syntax = FALSE;
2009 /* Loop to look up both kinds of address in an IPv6 world */
2011 for (i = 1; i <= times;
2013 af = AF_INET, /* If 2 passes, IPv4 on the second */
2019 struct hostent *hostdata;
2020 unsigned long time_msec = 0; /* compiler quietening */
2023 printf("Looking up: %s\n", host->name);
2026 if (slow_lookup_log) time_msec = get_time_in_ms();
2029 if (f.running_in_test_harness)
2030 hostdata = host_fake_gethostbyname(host->name, af, &error_num);
2033 #if HAVE_GETIPNODEBYNAME
2034 hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
2036 hostdata = gethostbyname2(CS host->name, af);
2037 error_num = h_errno;
2041 #else /* not HAVE_IPV6 */
2042 if (f.running_in_test_harness)
2043 hostdata = host_fake_gethostbyname(host->name, AF_INET, &error_num);
2046 hostdata = gethostbyname(CS host->name);
2047 error_num = h_errno;
2049 #endif /* HAVE_IPV6 */
2051 if ( slow_lookup_log
2052 && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
2053 log_long_lookup(US"name", host->name, time_msec);
2055 if (hostdata == NULL)
2060 case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
2061 case TRY_AGAIN: error = US"TRY_AGAIN"; break;
2062 case NO_RECOVERY: error = US"NO_RECOVERY"; break;
2063 case NO_DATA: error = US"NO_DATA"; break;
2064 #if NO_DATA != NO_ADDRESS
2065 case NO_ADDRESS: error = US"NO_ADDRESS"; break;
2067 default: error = US"?"; break;
2070 DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
2072 #if HAVE_GETIPNODEBYNAME
2073 (af == AF_INET6)? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
2075 (af == AF_INET6)? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
2082 if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
2085 if ((hostdata->h_addr_list)[0] == NULL) continue;
2087 /* Replace the name with the fully qualified one if necessary, and fill in
2088 the fully_qualified_name pointer. */
2090 if (hostdata->h_name[0] != 0 &&
2091 Ustrcmp(host->name, hostdata->h_name) != 0)
2092 host->name = string_copy_dnsdomain(US hostdata->h_name);
2093 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2095 /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
2096 by their different lengths. Scan the list, ignoring any that are to be
2097 ignored, and build a chain from the rest. */
2099 ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
2101 for (addrlist = USS hostdata->h_addr_list; *addrlist != NULL; addrlist++)
2103 uschar *text_address =
2104 host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
2107 if (ignore_target_hosts != NULL &&
2108 verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2109 text_address, NULL) == OK)
2111 DEBUG(D_host_lookup)
2112 debug_printf("ignored host %s [%s]\n", host->name, text_address);
2117 /* If this is the first address, last == NULL and we put the data in the
2122 host->address = text_address;
2123 host->port = PORT_NONE;
2124 host->status = hstatus_unknown;
2125 host->why = hwhy_unknown;
2126 host->dnssec = DS_UNK;
2130 /* Else add further host item blocks for any other addresses, keeping
2135 host_item *next = store_get(sizeof(host_item));
2136 next->name = host->name;
2137 next->mx = host->mx;
2138 next->address = text_address;
2139 next->port = PORT_NONE;
2140 next->status = hstatus_unknown;
2141 next->why = hwhy_unknown;
2142 next->dnssec = DS_UNK;
2144 next->next = last->next;
2151 /* If no hosts were found, the address field in the original host block will be
2152 NULL. If temp_error is set, at least one of the lookups gave a temporary error,
2153 so we pass that back. */
2155 if (host->address == NULL)
2159 (message_id[0] == 0 && smtp_in != NULL)?
2160 string_sprintf("no IP address found for host %s (during %s)", host->name,
2161 smtp_get_connection_info()) :
2163 string_sprintf("no IP address found for host %s", host->name);
2165 HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
2166 if (temp_error) goto RETURN_AGAIN;
2167 if (host_checking || !f.log_testing_mode)
2168 log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
2169 return HOST_FIND_FAILED;
2172 /* Remove any duplicate IP addresses, then check to see if this is the local
2173 host if required. */
2175 host_remove_duplicates(host, &last);
2176 yield = local_host_check?
2177 host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
2179 HDEBUG(D_host_lookup)
2182 if (fully_qualified_name != NULL)
2183 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2184 debug_printf("%s looked up these IP addresses:\n",
2186 #if HAVE_GETIPNODEBYNAME
2195 for (h = host; h != last->next; h = h->next)
2196 debug_printf(" name=%s address=%s\n", h->name,
2197 (h->address == NULL)? US"<null>" : h->address);
2200 /* Return the found status. */
2204 /* Handle the case when there is a temporary error. If the name matches
2205 dns_again_means_nonexist, return permanent rather than temporary failure. */
2211 const uschar *save = deliver_domain;
2212 deliver_domain = host->name; /* set $domain */
2213 rc = match_isinlist(host->name, CUSS &dns_again_means_nonexist, 0, NULL, NULL,
2214 MCL_DOMAIN, TRUE, NULL);
2215 deliver_domain = save;
2218 DEBUG(D_host_lookup) debug_printf("%s is in dns_again_means_nonexist: "
2219 "returning HOST_FIND_FAILED\n", host->name);
2220 return HOST_FIND_FAILED;
2223 return HOST_FIND_AGAIN;
2229 /*************************************************
2230 * Fill in a host address from the DNS *
2231 *************************************************/
2233 /* Given a host item, with its name, port and mx fields set, and its address
2234 field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
2235 create additional host items for the additional addresses, copying all the
2236 other fields, and randomizing the order.
2238 On IPv6 systems, AAAA records are sought first, then A records.
2240 The host name may be changed if the DNS returns a different name - e.g. fully
2241 qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
2242 ensures that it points to the fully qualified name. However, this is the fully
2243 qualified version of the original name; if a CNAME is involved, the actual
2244 canonical host name may be different again, and so we get it directly from the
2245 relevant RR. Note that we do NOT change the mx field of the host item in this
2246 function as it may be called to set the addresses of hosts taken from MX
2250 host points to the host item we're filling in
2251 lastptr points to pointer to last host item in a chain of
2252 host items (may be updated if host is last and gets
2253 extended because multihomed)
2254 ignore_target_hosts list of hosts to ignore
2255 allow_ip if TRUE, recognize an IP address and return it
2256 fully_qualified_name if not NULL, return fully qualified name here if
2257 the contents are different (i.e. it must be preset
2259 dnssec_request if TRUE request the AD bit
2260 dnssec_require if TRUE require the AD bit
2261 whichrrs select ipv4, ipv6 results
2263 Returns: HOST_FIND_FAILED couldn't find A record
2264 HOST_FIND_AGAIN try again later
2265 HOST_FIND_SECURITY dnssec required but not acheived
2266 HOST_FOUND found AAAA and/or A record(s)
2267 HOST_IGNORED found, but all IPs ignored
2271 set_address_from_dns(host_item *host, host_item **lastptr,
2272 const uschar *ignore_target_hosts, BOOL allow_ip,
2273 const uschar **fully_qualified_name,
2274 BOOL dnssec_request, BOOL dnssec_require, int whichrrs)
2277 host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
2278 BOOL v6_find_again = FALSE;
2279 BOOL dnssec_fail = FALSE;
2282 /* If allow_ip is set, a name which is an IP address returns that value
2283 as its address. This is used for MX records when allow_mx_to_ip is set, for
2284 those sites that feel they have to flaunt the RFC rules. */
2286 if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
2289 if ( ignore_target_hosts
2290 && verify_check_this_host(&ignore_target_hosts, NULL, host->name,
2291 host->name, NULL) == OK)
2292 return HOST_IGNORED;
2295 host->address = host->name;
2299 /* On an IPv6 system, unless IPv6 is disabled, go round the loop up to twice,
2300 looking for AAAA records the first time. However, unless doing standalone
2301 testing, we force an IPv4 lookup if the domain matches dns_ipv4_lookup global.
2302 On an IPv4 system, go round the loop once only, looking only for A records. */
2307 || !(whichrrs & HOST_FIND_BY_AAAA)
2309 && match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0, NULL, NULL,
2310 MCL_DOMAIN, TRUE, NULL) == OK)
2312 i = 0; /* look up A records only */
2314 #endif /* STAND_ALONE */
2316 i = 1; /* look up AAAA and A records */
2318 /* The IPv4 world */
2320 #else /* HAVE_IPV6 */
2321 i = 0; /* look up A records only */
2322 #endif /* HAVE_IPV6 */
2326 static int types[] = { T_A, T_AAAA };
2327 int type = types[i];
2328 int randoffset = i == (whichrrs & HOST_FIND_IPV4_FIRST ? 1 : 0)
2329 ? 500 : 0; /* Ensures v6/4 sort order */
2333 int rc = dns_lookup_timerwrap(&dnsa, host->name, type, fully_qualified_name);
2334 lookup_dnssec_authenticated = !dnssec_request ? NULL
2335 : dns_is_secure(&dnsa) ? US"yes" : US"no";
2338 if ( (dnssec_request || dnssec_require)
2339 && !dns_is_secure(&dnsa)
2342 debug_printf("DNS lookup of %.256s (A/AAAA) requested AD, but got AA\n", host->name);
2344 /* We want to return HOST_FIND_AGAIN if one of the A or AAAA lookups
2345 fails or times out, but not if another one succeeds. (In the early
2346 IPv6 days there are name servers that always fail on AAAA, but are happy
2347 to give out an A record. We want to proceed with that A record.) */
2349 if (rc != DNS_SUCCEED)
2351 if (i == 0) /* Just tried for an A record, i.e. end of loop */
2353 if (host->address != NULL) return HOST_FOUND; /* AAAA was found */
2354 if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
2355 return HOST_FIND_AGAIN;
2356 return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
2359 /* Tried for an AAAA record: remember if this was a temporary
2360 error, and look for the next record type. */
2362 if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
2368 if (dns_is_secure(&dnsa))
2370 DEBUG(D_host_lookup) debug_printf("%s A DNSSEC\n", host->name);
2371 if (host->dnssec == DS_UNK) /* set in host_find_bydns() */
2372 host->dnssec = DS_YES;
2379 DEBUG(D_host_lookup) debug_printf("dnssec fail on %s for %.256s",
2380 i>0 ? "AAAA" : "A", host->name);
2383 if (host->dnssec == DS_YES) /* set in host_find_bydns() */
2385 DEBUG(D_host_lookup) debug_printf("%s A cancel DNSSEC\n", host->name);
2386 host->dnssec = DS_NO;
2387 lookup_dnssec_authenticated = US"no";
2392 /* Lookup succeeded: fill in the given host item with the first non-ignored
2393 address found; create additional items for any others. A single A6 record
2394 may generate more than one address. The lookup had a chance to update the
2395 fqdn; we do not want any later times round the loop to do so. */
2397 fully_qualified_name = NULL;
2399 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2401 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
2403 if (rr->type == type)
2405 dns_address *da = dns_address_from_rr(&dnsa, rr);
2407 DEBUG(D_host_lookup)
2408 if (!da) debug_printf("no addresses extracted from A6 RR for %s\n",
2411 /* This loop runs only once for A and AAAA records, but may run
2412 several times for an A6 record that generated multiple addresses. */
2414 for (; da; da = da->next)
2417 if (ignore_target_hosts != NULL &&
2418 verify_check_this_host(&ignore_target_hosts, NULL,
2419 host->name, da->address, NULL) == OK)
2421 DEBUG(D_host_lookup)
2422 debug_printf("ignored host %s [%s]\n", host->name, da->address);
2427 /* If this is the first address, stick it in the given host block,
2428 and change the name if the returned RR has a different name. */
2430 if (thishostlast == NULL)
2432 if (strcmpic(host->name, rr->name) != 0)
2433 host->name = string_copy_dnsdomain(rr->name);
2434 host->address = da->address;
2435 host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
2436 host->status = hstatus_unknown;
2437 host->why = hwhy_unknown;
2438 thishostlast = host;
2441 /* Not the first address. Check for, and ignore, duplicates. Then
2442 insert in the chain at a random point. */
2449 /* End of our local chain is specified by "thishostlast". */
2451 for (next = host;; next = next->next)
2453 if (Ustrcmp(CS da->address, next->address) == 0) break;
2454 if (next == thishostlast) { next = NULL; break; }
2456 if (next != NULL) continue; /* With loop for next address */
2458 /* Not a duplicate */
2460 new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
2461 next = store_get(sizeof(host_item));
2463 /* New address goes first: insert the new block after the first one
2464 (so as not to disturb the original pointer) but put the new address
2465 in the original block. */
2467 if (new_sort_key < host->sort_key)
2469 *next = *host; /* Copies port */
2471 host->address = da->address;
2472 host->sort_key = new_sort_key;
2473 if (thishostlast == host) thishostlast = next; /* Local last */
2474 if (*lastptr == host) *lastptr = next; /* Global last */
2477 /* Otherwise scan down the addresses for this host to find the
2478 one to insert after. */
2482 host_item *h = host;
2483 while (h != thishostlast)
2485 if (new_sort_key < h->next->sort_key) break;
2488 *next = *h; /* Copies port */
2490 next->address = da->address;
2491 next->sort_key = new_sort_key;
2492 if (h == thishostlast) thishostlast = next; /* Local last */
2493 if (h == *lastptr) *lastptr = next; /* Global last */
2501 /* Control gets here only if the second lookup (the A record) succeeded.
2502 However, the address may not be filled in if it was ignored. */
2504 return host->address
2507 ? HOST_FIND_SECURITY
2514 /*************************************************
2515 * Find IP addresses and host names via DNS *
2516 *************************************************/
2518 /* The input is a host_item structure with the name field filled in and the
2519 address field set to NULL. This may be in a chain of other host items. The
2520 lookup may result in more than one IP address, in which case we must created
2521 new host blocks for the additional addresses, and insert them into the chain.
2522 The original name may not be fully qualified. Use the fully_qualified_name
2523 argument to return the official name, as returned by the resolver.
2526 host point to initial host item
2527 ignore_target_hosts a list of hosts to ignore
2528 whichrrs flags indicating which RRs to look for:
2529 HOST_FIND_BY_SRV => look for SRV
2530 HOST_FIND_BY_MX => look for MX
2531 HOST_FIND_BY_A => look for A
2532 HOST_FIND_BY_AAAA => look for AAAA
2533 also flags indicating how the lookup is done
2534 HOST_FIND_QUALIFY_SINGLE ) passed to the
2535 HOST_FIND_SEARCH_PARENTS ) resolver
2536 HOST_FIND_IPV4_FIRST => reverse usual result ordering
2537 HOST_FIND_IPV4_ONLY => MX results elide ipv6
2538 srv_service when SRV used, the service name
2539 srv_fail_domains DNS errors for these domains => assume nonexist
2540 mx_fail_domains DNS errors for these domains => assume nonexist
2541 dnssec_d.request => make dnssec request: domainlist
2542 dnssec_d.require => ditto and nonexist failures
2543 fully_qualified_name if not NULL, return fully-qualified name
2544 removed set TRUE if local host was removed from the list
2546 Returns: HOST_FIND_FAILED Failed to find the host or domain;
2547 if there was a syntax error,
2548 host_find_failed_syntax is set.
2549 HOST_FIND_AGAIN Could not resolve at this time
2550 HOST_FIND_SECURITY dnsssec required but not acheived
2551 HOST_FOUND Host found
2552 HOST_FOUND_LOCAL The lowest MX record points to this
2553 machine, if MX records were found, or
2554 an A record that was found contains
2555 an address of the local host
2559 host_find_bydns(host_item *host, const uschar *ignore_target_hosts, int whichrrs,
2560 uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
2561 const dnssec_domains *dnssec_d,
2562 const uschar **fully_qualified_name, BOOL *removed)
2564 host_item *h, *last;
2571 BOOL dnssec_require = dnssec_d
2572 && match_isinlist(host->name, CUSS &dnssec_d->require,
2573 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
2574 BOOL dnssec_request = dnssec_require
2576 && match_isinlist(host->name, CUSS &dnssec_d->request,
2577 0, NULL, NULL, MCL_DOMAIN, TRUE, NULL) == OK);
2578 dnssec_status_t dnssec;
2580 /* Set the default fully qualified name to the incoming name, initialize the
2581 resolver if necessary, set up the relevant options, and initialize the flag
2582 that gets set for DNS syntax check errors. */
2584 if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
2585 dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
2586 (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0,
2588 f.host_find_failed_syntax = FALSE;
2590 /* First, if requested, look for SRV records. The service name is given; we
2591 assume TCP protocol. DNS domain names are constrained to a maximum of 256
2592 characters, so the code below should be safe. */
2594 if (whichrrs & HOST_FIND_BY_SRV)
2597 uschar * temp_fully_qualified_name;
2600 g = string_fmt_append(NULL, "_%s._tcp.%n%.256s",
2601 srv_service, &prefix_length, host->name);
2602 temp_fully_qualified_name = string_from_gstring(g);
2605 /* Search for SRV records. If the fully qualified name is different to
2606 the input name, pass back the new original domain, without the prepended
2610 lookup_dnssec_authenticated = NULL;
2611 rc = dns_lookup_timerwrap(&dnsa, temp_fully_qualified_name, ind_type,
2612 CUSS &temp_fully_qualified_name);
2615 if ((dnssec_request || dnssec_require)
2616 && !dns_is_secure(&dnsa)
2617 && dns_is_aa(&dnsa))
2618 debug_printf("DNS lookup of %.256s (SRV) requested AD, but got AA\n", host->name);
2622 if (dns_is_secure(&dnsa))
2623 { dnssec = DS_YES; lookup_dnssec_authenticated = US"yes"; }
2625 { dnssec = DS_NO; lookup_dnssec_authenticated = US"no"; }
2628 if (temp_fully_qualified_name != g->s && fully_qualified_name != NULL)
2629 *fully_qualified_name = temp_fully_qualified_name + prefix_length;
2631 /* On DNS failures, we give the "try again" error unless the domain is
2632 listed as one for which we continue. */
2634 if (rc == DNS_SUCCEED && dnssec_require && !dns_is_secure(&dnsa))
2636 log_write(L_host_lookup_failed, LOG_MAIN,
2637 "dnssec fail on SRV for %.256s", host->name);
2640 if (rc == DNS_FAIL || rc == DNS_AGAIN)
2643 if (match_isinlist(host->name, CUSS &srv_fail_domains, 0, NULL, NULL,
2644 MCL_DOMAIN, TRUE, NULL) != OK)
2646 { yield = HOST_FIND_AGAIN; goto out; }
2647 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2648 "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2652 /* If we did not find any SRV records, search the DNS for MX records, if
2653 requested to do so. If the result is DNS_NOMATCH, it means there is no such
2654 domain, and there's no point in going on to look for address records with the
2655 same domain. The result will be DNS_NODATA if the domain exists but has no MX
2656 records. On DNS failures, we give the "try again" error unless the domain is
2657 listed as one for which we continue. */
2659 if (rc != DNS_SUCCEED && whichrrs & HOST_FIND_BY_MX)
2663 lookup_dnssec_authenticated = NULL;
2664 rc = dns_lookup_timerwrap(&dnsa, host->name, ind_type, fully_qualified_name);
2667 if ( (dnssec_request || dnssec_require)
2668 && !dns_is_secure(&dnsa)
2669 && dns_is_aa(&dnsa))
2670 debug_printf("DNS lookup of %.256s (MX) requested AD, but got AA\n", host->name);
2673 if (dns_is_secure(&dnsa))
2675 DEBUG(D_host_lookup) debug_printf("%s MX DNSSEC\n", host->name);
2676 dnssec = DS_YES; lookup_dnssec_authenticated = US"yes";
2680 dnssec = DS_NO; lookup_dnssec_authenticated = US"no";
2686 yield = HOST_FIND_FAILED; goto out;
2689 if (!dnssec_require || dns_is_secure(&dnsa))
2691 DEBUG(D_host_lookup)
2692 debug_printf("dnssec fail on MX for %.256s", host->name);
2694 if (match_isinlist(host->name, CUSS &mx_fail_domains, 0, NULL, NULL,
2695 MCL_DOMAIN, TRUE, NULL) != OK)
2696 { yield = HOST_FIND_SECURITY; goto out; }
2704 if (match_isinlist(host->name, CUSS &mx_fail_domains, 0, NULL, NULL,
2705 MCL_DOMAIN, TRUE, NULL) != OK)
2707 { yield = HOST_FIND_AGAIN; goto out; }
2708 DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
2709 "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
2714 /* If we haven't found anything yet, and we are requested to do so, try for an
2715 A or AAAA record. If we find it (or them) check to see that it isn't the local
2718 if (rc != DNS_SUCCEED)
2720 if (!(whichrrs & (HOST_FIND_BY_A | HOST_FIND_BY_AAAA)))
2722 DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
2723 yield = HOST_FIND_FAILED;
2727 last = host; /* End of local chainlet */
2729 host->port = PORT_NONE;
2730 host->dnssec = DS_UNK;
2731 lookup_dnssec_authenticated = NULL;
2732 rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
2733 fully_qualified_name, dnssec_request, dnssec_require, whichrrs);
2735 /* If one or more address records have been found, check that none of them
2736 are local. Since we know the host items all have their IP addresses
2737 inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
2738 HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
2739 because set_address_from_dns() removes them. */
2741 if (rc == HOST_FOUND)
2742 rc = host_scan_for_local_hosts(host, &last, removed);
2744 if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
2746 DEBUG(D_host_lookup)
2749 if (host->address != NULL)
2751 if (fully_qualified_name != NULL)
2752 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
2753 for (h = host; h != last->next; h = h->next)
2754 debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
2755 (h->address == NULL)? US"<null>" : h->address, h->mx, h->sort_key,
2756 (h->status >= hstatus_unusable)? US"*" : US"");
2764 /* We have found one or more MX or SRV records. Sort them according to
2765 precedence. Put the data for the first one into the existing host block, and
2766 insert new host_item blocks into the chain for the remainder. For equal
2767 precedences one is supposed to randomize the order. To make this happen, the
2768 sorting is actually done on the MX value * 1000 + a random number. This is put
2769 into a host field called sort_key.
2771 In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
2772 IPv6 address in preference. At this stage, we don't know what kind of address
2773 the host has. We choose a random number < 500; if later we find an A record
2774 first, we add 500 to the random number. Then for any other address records, we
2775 use random numbers in the range 0-499 for AAAA records and 500-999 for A
2778 At this point we remove any duplicates that point to the same host, retaining
2779 only the one with the lowest precedence. We cannot yet check for precedence
2780 greater than that of the local host, because that test cannot be properly done
2781 until the addresses have been found - an MX record may point to a name for this
2782 host which is not the primary hostname. */
2784 last = NULL; /* Indicates that not even the first item is filled yet */
2786 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
2788 rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT)) if (rr->type == ind_type)
2790 int precedence, weight;
2791 int port = PORT_NONE;
2792 const uschar * s = rr->data; /* MUST be unsigned for GETSHORT */
2795 GETSHORT(precedence, s); /* Pointer s is advanced */
2797 /* For MX records, we use a random "weight" which causes multiple records of
2798 the same precedence to sort randomly. */
2800 if (ind_type == T_MX)
2801 weight = random_number(500);
2804 /* SRV records are specified with a port and a weight. The weight is used
2805 in a special algorithm. However, to start with, we just use it to order the
2806 records of equal priority (precedence). */
2807 GETSHORT(weight, s);
2811 /* Get the name of the host pointed to. */
2813 (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, s,
2814 (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
2816 /* Check that we haven't already got this host on the chain; if we have,
2817 keep only the lower precedence. This situation shouldn't occur, but you
2818 never know what junk might get into the DNS (and this case has been seen on
2819 more than one occasion). */
2821 if (last) /* This is not the first record */
2823 host_item *prev = NULL;
2825 for (h = host; h != last->next; prev = h, h = h->next)
2826 if (strcmpic(h->name, data) == 0)
2828 DEBUG(D_host_lookup)
2829 debug_printf("discarded duplicate host %s (MX=%d)\n", data,
2830 precedence > h->mx ? precedence : h->mx);
2831 if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
2832 if (h == host) /* Override first item */
2835 host->sort_key = precedence * 1000 + weight;
2839 /* Unwanted host item is not the first in the chain, so we can get
2840 get rid of it by cutting it out. */
2842 prev->next = h->next;
2843 if (h == last) last = prev;
2848 /* If this is the first MX or SRV record, put the data into the existing host
2849 block. Otherwise, add a new block in the correct place; if it has to be
2850 before the first block, copy the first block's data to a new second block. */
2854 host->name = string_copy_dnsdomain(data);
2855 host->address = NULL;
2857 host->mx = precedence;
2858 host->sort_key = precedence * 1000 + weight;
2859 host->status = hstatus_unknown;
2860 host->why = hwhy_unknown;
2861 host->dnssec = dnssec;
2866 /* Make a new host item and seek the correct insertion place */
2868 int sort_key = precedence * 1000 + weight;
2869 host_item *next = store_get(sizeof(host_item));
2870 next->name = string_copy_dnsdomain(data);
2871 next->address = NULL;
2873 next->mx = precedence;
2874 next->sort_key = sort_key;
2875 next->status = hstatus_unknown;
2876 next->why = hwhy_unknown;
2877 next->dnssec = dnssec;
2880 /* Handle the case when we have to insert before the first item. */
2882 if (sort_key < host->sort_key)
2889 if (last == host) last = next;
2893 /* Else scan down the items we have inserted as part of this exercise;
2894 don't go further. */
2896 for (h = host; h != last; h = h->next)
2897 if (sort_key < h->next->sort_key)
2899 next->next = h->next;
2904 /* Join on after the last host item that's part of this
2905 processing if we haven't stopped sooner. */
2909 next->next = last->next;
2916 NEXT_MX_RR: continue;
2919 if (!last) /* No rr of correct type; give up */
2921 yield = HOST_FIND_FAILED;
2925 /* If the list of hosts was obtained from SRV records, there are two things to
2926 do. First, if there is only one host, and it's name is ".", it means there is
2927 no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
2928 priority according to their weights, using an algorithm that is defined in RFC
2929 2782. The hosts are currently sorted by priority and weight. For each priority
2930 group we have to pick off one host and put it first, and then repeat for any
2931 remaining in the same priority group. */
2933 if (ind_type == T_SRV)
2937 if (host == last && host->name[0] == 0)
2939 DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
2940 yield = HOST_FIND_FAILED;
2944 DEBUG(D_host_lookup)
2946 debug_printf("original ordering of hosts from SRV records:\n");
2947 for (h = host; h != last->next; h = h->next)
2948 debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
2951 for (pptr = &host, h = host; h != last; pptr = &h->next, h = h->next)
2956 /* Find the last following host that has the same precedence. At the same
2957 time, compute the sum of the weights and the running totals. These can be
2958 stored in the sort_key field. */
2960 for (hh = h; hh != last; hh = hh->next)
2962 int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
2965 if (hh->mx != hh->next->mx) break;
2968 /* If there's more than one host at this precedence (priority), we need to
2969 pick one to go first. */
2975 int randomizer = random_number(sum + 1);
2977 for (ppptr = pptr, hhh = h;
2979 ppptr = &hhh->next, hhh = hhh->next)
2980 if (hhh->sort_key >= randomizer)
2983 /* hhh now points to the host that should go first; ppptr points to the
2984 place that points to it. Unfortunately, if the start of the minilist is
2985 the start of the entire list, we can't just swap the items over, because
2986 we must not change the value of host, since it is passed in from outside.
2987 One day, this could perhaps be changed.
2989 The special case is fudged by putting the new item *second* in the chain,
2990 and then transferring the data between the first and second items. We
2991 can't just swap the first and the chosen item, because that would mean
2992 that an item with zero weight might no longer be first. */
2996 *ppptr = hhh->next; /* Cuts it out of the chain */
3000 host_item temp = *h;
3003 hhh->next = temp.next;
3008 hhh->next = h; /* The rest of the chain follows it */
3009 *pptr = hhh; /* It takes the place of h */
3010 h = hhh; /* It's now the start of this minilist */
3015 /* A host has been chosen to be first at this priority and h now points
3016 to this host. There may be others at the same priority, or others at a
3017 different priority. Before we leave this host, we need to put back a sort
3018 key of the traditional MX kind, in case this host is multihomed, because
3019 the sort key is used for ordering the multiple IP addresses. We do not need
3020 to ensure that these new sort keys actually reflect the order of the hosts,
3023 h->sort_key = h->mx * 1000 + random_number(500);
3024 } /* Move on to the next host */
3027 /* Now we have to find IP addresses for all the hosts. We have ensured above
3028 that the names in all the host items are unique. Before release 4.61 we used to
3029 process records from the additional section in the DNS packet that returned the
3030 MX or SRV records. However, a DNS name server is free to drop any resource
3031 records from the additional section. In theory, this has always been a
3032 potential problem, but it is exacerbated by the advent of IPv6. If a host had
3033 several IPv4 addresses and some were not in the additional section, at least
3034 Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
3035 and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
3036 connection, and never try an IPv4 address. When there was only IPv4
3037 connectivity, this was a disaster that did in practice occur.
3039 So, from release 4.61 onwards, we always search for A and AAAA records
3040 explicitly. The names shouldn't point to CNAMES, but we use the general lookup
3041 function that handles them, just in case. If any lookup gives a soft error,
3042 change the default yield.
3044 For these DNS lookups, we must disable qualify_single and search_parents;
3045 otherwise invalid host names obtained from MX or SRV records can cause trouble
3046 if they happen to match something local. */
3048 yield = HOST_FIND_FAILED; /* Default yield */
3049 dns_init(FALSE, FALSE, /* Disable qualify_single and search_parents */
3050 dnssec_request || dnssec_require);
3052 for (h = host; h != last->next; h = h->next)
3054 if (h->address) continue; /* Inserted by a multihomed host */
3056 rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip,
3057 NULL, dnssec_request, dnssec_require,
3058 whichrrs & HOST_FIND_IPV4_ONLY
3059 ? HOST_FIND_BY_A : HOST_FIND_BY_A | HOST_FIND_BY_AAAA);
3060 if (rc != HOST_FOUND)
3062 h->status = hstatus_unusable;
3065 case HOST_FIND_AGAIN: yield = rc; h->why = hwhy_deferred; break;
3066 case HOST_FIND_SECURITY: yield = rc; h->why = hwhy_insecure; break;
3067 case HOST_IGNORED: h->why = hwhy_ignored; break;
3068 default: h->why = hwhy_failed; break;
3073 /* Scan the list for any hosts that are marked unusable because they have
3074 been explicitly ignored, and remove them from the list, as if they did not
3075 exist. If we end up with just a single, ignored host, flatten its fields as if
3076 nothing was found. */
3078 if (ignore_target_hosts)
3080 host_item *prev = NULL;
3081 for (h = host; h != last->next; h = h->next)
3084 if (h->why != hwhy_ignored) /* Non ignored host, just continue */
3086 else if (prev == NULL) /* First host is ignored */
3088 if (h != last) /* First is not last */
3090 if (h->next == last) last = h; /* Overwrite it with next */
3091 *h = *(h->next); /* and reprocess it. */
3092 goto REDO; /* C should have redo, like Perl */
3095 else /* Ignored host is not first - */
3097 prev->next = h->next;
3098 if (h == last) last = prev;
3102 if (host->why == hwhy_ignored) host->address = NULL;
3105 /* There is still one complication in the case of IPv6. Although the code above
3106 arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
3107 hosts, it doesn't do this for addresses that apply to different hosts with the
3108 same MX precedence, because the sorting on MX precedence happens first. So we
3109 have to make another pass to check for this case. We ensure that, within a
3110 single MX preference value, IPv6 addresses come first. This can separate the
3111 addresses of a multihomed host, but that should not matter. */
3114 if (h != last && !disable_ipv6) for (h = host; h != last; h = h->next)
3117 host_item *next = h->next;
3119 if ( h->mx != next->mx /* If next is different MX */
3120 || !h->address /* OR this one is unset */
3122 continue; /* move on to next */
3124 if ( whichrrs & HOST_FIND_IPV4_FIRST
3125 ? !Ustrchr(h->address, ':') /* OR this one is IPv4 */
3127 && Ustrchr(next->address, ':') /* OR next is IPv6 */
3129 : Ustrchr(h->address, ':') /* OR this one is IPv6 */
3131 && !Ustrchr(next->address, ':') /* OR next is IPv4 */
3133 continue; /* move on to next */
3135 temp = *h; /* otherwise, swap */
3136 temp.next = next->next;
3143 /* Remove any duplicate IP addresses and then scan the list of hosts for any
3144 whose IP addresses are on the local host. If any are found, all hosts with the
3145 same or higher MX values are removed. However, if the local host has the lowest
3146 numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
3147 with an IP address is on the list, HOST_FOUND is returned. Otherwise,
3148 HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
3149 might have been set to HOST_FIND_AGAIN just above here. If not, it will already
3150 be HOST_FIND_FAILED. */
3152 host_remove_duplicates(host, &last);
3153 rc = host_scan_for_local_hosts(host, &last, removed);
3154 if (rc != HOST_FIND_FAILED) yield = rc;
3156 DEBUG(D_host_lookup)
3158 if (fully_qualified_name != NULL)
3159 debug_printf("fully qualified name = %s\n", *fully_qualified_name);
3160 debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
3161 (yield == HOST_FOUND)? "HOST_FOUND" :
3162 (yield == HOST_FOUND_LOCAL)? "HOST_FOUND_LOCAL" :
3163 (yield == HOST_FIND_SECURITY)? "HOST_FIND_SECURITY" :
3164 (yield == HOST_FIND_AGAIN)? "HOST_FIND_AGAIN" :
3165 (yield == HOST_FIND_FAILED)? "HOST_FIND_FAILED" : "?",
3167 for (h = host; h != last->next; h = h->next)
3169 debug_printf(" %s %s MX=%d %s", h->name,
3170 !h->address ? US"<null>" : h->address, h->mx,
3171 h->dnssec == DS_YES ? US"DNSSEC " : US"");
3172 if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
3173 if (h->status >= hstatus_unusable) debug_printf("*");
3180 dns_init(FALSE, FALSE, FALSE); /* clear the dnssec bit for getaddrbyname */
3184 /*************************************************
3185 **************************************************
3186 * Stand-alone test program *
3187 **************************************************
3188 *************************************************/
3192 int main(int argc, char **cargv)
3195 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3196 BOOL byname = FALSE;
3197 BOOL qualify_single = TRUE;
3198 BOOL search_parents = FALSE;
3199 BOOL request_dnssec = FALSE;
3200 BOOL require_dnssec = FALSE;
3201 uschar **argv = USS cargv;
3204 disable_ipv6 = FALSE;
3205 primary_hostname = US"";
3206 store_pool = POOL_MAIN;
3207 debug_selector = D_host_lookup|D_interface;
3208 debug_file = stdout;
3209 debug_fd = fileno(debug_file);
3211 printf("Exim stand-alone host functions test\n");
3213 host_find_interfaces();
3214 debug_selector = D_host_lookup | D_dns;
3216 if (argc > 1) primary_hostname = argv[1];
3218 /* So that debug level changes can be done first */
3220 dns_init(qualify_single, search_parents, FALSE);
3222 printf("Testing host lookup\n");
3224 while (Ufgets(buffer, 256, stdin) != NULL)
3227 int len = Ustrlen(buffer);
3228 uschar *fully_qualified_name;
3230 while (len > 0 && isspace(buffer[len-1])) len--;
3233 if (Ustrcmp(buffer, "q") == 0) break;
3235 if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
3236 else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
3237 else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3238 else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
3239 else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
3240 else if (Ustrcmp(buffer, "srv+a") == 0)
3241 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3242 else if (Ustrcmp(buffer, "srv+mx") == 0)
3243 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
3244 else if (Ustrcmp(buffer, "srv+mx+a") == 0)
3245 whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
3246 else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
3247 else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
3248 else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
3249 else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
3250 else if (Ustrcmp(buffer, "request_dnssec") == 0) request_dnssec = TRUE;
3251 else if (Ustrcmp(buffer, "no_request_dnssec") == 0) request_dnssec = FALSE;
3252 else if (Ustrcmp(buffer, "require_dnssec") == 0) require_dnssec = TRUE;
3253 else if (Ustrcmp(buffer, "no_require_dnssec") == 0) require_dnssec = FALSE;
3254 else if (Ustrcmp(buffer, "test_harness") == 0)
3255 f.running_in_test_harness = !f.running_in_test_harness;
3256 else if (Ustrcmp(buffer, "ipv6") == 0) disable_ipv6 = !disable_ipv6;
3257 else if (Ustrcmp(buffer, "res_debug") == 0)
3259 _res.options ^= RES_DEBUG;
3261 else if (Ustrncmp(buffer, "retrans", 7) == 0)
3263 (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
3264 _res.retrans = dns_retrans;
3266 else if (Ustrncmp(buffer, "retry", 5) == 0)
3268 (void)sscanf(CS(buffer+6), "%d", &dns_retry);
3269 _res.retry = dns_retry;
3273 int flags = whichrrs;
3280 h.status = hstatus_unknown;
3281 h.why = hwhy_unknown;
3284 if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
3285 if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
3287 d.request = request_dnssec ? &h.name : NULL;
3288 d.require = require_dnssec ? &h.name : NULL;
3291 ? host_find_byname(&h, NULL, flags, &fully_qualified_name, TRUE)
3292 : host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
3293 &d, &fully_qualified_name, NULL);
3297 case HOST_FIND_FAILED: printf("Failed\n"); break;
3298 case HOST_FIND_AGAIN: printf("Again\n"); break;
3299 case HOST_FIND_SECURITY: printf("Security\n"); break;
3300 case HOST_FOUND_LOCAL: printf("Local\n"); break;
3307 printf("Testing host_aton\n");
3309 while (Ufgets(buffer, 256, stdin) != NULL)
3313 int len = Ustrlen(buffer);
3315 while (len > 0 && isspace(buffer[len-1])) len--;
3318 if (Ustrcmp(buffer, "q") == 0) break;
3320 len = host_aton(buffer, x);
3321 printf("length = %d ", len);
3322 for (i = 0; i < len; i++)
3324 printf("%04x ", (x[i] >> 16) & 0xffff);
3325 printf("%04x ", x[i] & 0xffff);
3332 printf("Testing host_name_lookup\n");
3334 while (Ufgets(buffer, 256, stdin) != NULL)
3336 int len = Ustrlen(buffer);
3337 while (len > 0 && isspace(buffer[len-1])) len--;
3339 if (Ustrcmp(buffer, "q") == 0) break;
3340 sender_host_address = buffer;
3341 sender_host_name = NULL;
3342 sender_host_aliases = NULL;
3343 host_lookup_msg = US"";
3344 host_lookup_failed = FALSE;
3345 if (host_name_lookup() == FAIL) /* Debug causes printing */
3346 printf("Lookup failed:%s\n", host_lookup_msg);
3354 #endif /* STAND_ALONE */