summaryrefslogtreecommitdiffstats
path: root/src/host.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/host.c3419
1 files changed, 3419 insertions, 0 deletions
diff --git a/src/host.c b/src/host.c
new file mode 100644
index 0000000..dbc7ce2
--- /dev/null
+++ b/src/host.c
@@ -0,0 +1,3419 @@
+/*************************************************
+* Exim - an Internet mail transport agent *
+*************************************************/
+
+/* Copyright (c) University of Cambridge 1995 - 2018 */
+/* Copyright (c) The Exim Maintainers 2020 */
+/* See the file NOTICE for conditions of use and distribution. */
+
+/* Functions for finding hosts, either by gethostbyname(), gethostbyaddr(), or
+directly via the DNS. When IPv6 is supported, getipnodebyname() and
+getipnodebyaddr() may be used instead of gethostbyname() and gethostbyaddr(),
+if the newer functions are available. This module also contains various other
+functions concerned with hosts and addresses, and a random number function,
+used for randomizing hosts with equal MXs but available for use in other parts
+of Exim. */
+
+
+#include "exim.h"
+
+
+/* Static variable for preserving the list of interface addresses in case it is
+used more than once. */
+
+static ip_address_item *local_interface_data = NULL;
+
+
+#ifdef USE_INET_NTOA_FIX
+/*************************************************
+* Replacement for broken inet_ntoa() *
+*************************************************/
+
+/* On IRIX systems, gcc uses a different structure passing convention to the
+native libraries. This causes inet_ntoa() to always yield 0.0.0.0 or
+255.255.255.255. To get round this, we provide a private version of the
+function here. It is used only if USE_INET_NTOA_FIX is set, which should happen
+only when gcc is in use on an IRIX system. Code send to me by J.T. Breitner,
+with these comments:
+
+ code by Stuart Levy
+ as seen in comp.sys.sgi.admin
+
+August 2005: Apparently this is also needed for AIX systems; USE_INET_NTOA_FIX
+should now be set for them as well.
+
+Arguments: sa an in_addr structure
+Returns: pointer to static text string
+*/
+
+char *
+inet_ntoa(struct in_addr sa)
+{
+static uschar addr[20];
+sprintf(addr, "%d.%d.%d.%d",
+ (US &sa.s_addr)[0],
+ (US &sa.s_addr)[1],
+ (US &sa.s_addr)[2],
+ (US &sa.s_addr)[3]);
+ return addr;
+}
+#endif
+
+
+
+/*************************************************
+* Random number generator *
+*************************************************/
+
+/* This is a simple pseudo-random number generator. It does not have to be
+very good for the uses to which it is put. When running the regression tests,
+start with a fixed seed.
+
+If you need better, see vaguely_random_number() which is potentially stronger,
+if a crypto library is available, but might end up just calling this instead.
+
+Arguments:
+ limit: one more than the largest number required
+
+Returns: a pseudo-random number in the range 0 to limit-1
+*/
+
+int
+random_number(int limit)
+{
+if (limit < 1)
+ return 0;
+if (random_seed == 0)
+ {
+ if (f.running_in_test_harness) random_seed = 42; else
+ {
+ int p = (int)getpid();
+ random_seed = (int)time(NULL) ^ ((p << 16) | p);
+ }
+ }
+random_seed = 1103515245 * random_seed + 12345;
+return (unsigned int)(random_seed >> 16) % limit;
+}
+
+/*************************************************
+* Wrappers for logging lookup times *
+*************************************************/
+
+/* When the 'slow_lookup_log' variable is enabled, these wrappers will
+write to the log file all (potential) dns lookups that take more than
+slow_lookup_log milliseconds
+*/
+
+static void
+log_long_lookup(const uschar * type, const uschar * data, unsigned long msec)
+{
+log_write(0, LOG_MAIN, "Long %s lookup for '%s': %lu msec",
+ type, data, msec);
+}
+
+
+/* returns the current system epoch time in milliseconds. */
+static unsigned long
+get_time_in_ms()
+{
+struct timeval tmp_time;
+unsigned long seconds, microseconds;
+
+gettimeofday(&tmp_time, NULL);
+seconds = (unsigned long) tmp_time.tv_sec;
+microseconds = (unsigned long) tmp_time.tv_usec;
+return seconds*1000 + microseconds/1000;
+}
+
+
+static int
+dns_lookup_timerwrap(dns_answer *dnsa, const uschar *name, int type,
+ const uschar **fully_qualified_name)
+{
+int retval;
+unsigned long time_msec;
+
+if (!slow_lookup_log)
+ return dns_lookup(dnsa, name, type, fully_qualified_name);
+
+time_msec = get_time_in_ms();
+retval = dns_lookup(dnsa, name, type, fully_qualified_name);
+if ((time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
+ log_long_lookup(dns_text_type(type), name, time_msec);
+return retval;
+}
+
+
+/*************************************************
+* Replace gethostbyname() when testing *
+*************************************************/
+
+/* This function is called instead of gethostbyname(), gethostbyname2(), or
+getipnodebyname() when running in the test harness. . It also
+recognizes an unqualified "localhost" and forces it to the appropriate loopback
+address. IP addresses are treated as literals. For other names, it uses the DNS
+to find the host name. In the test harness, this means it will access only the
+fake DNS resolver.
+
+Arguments:
+ name the host name or a textual IP address
+ af AF_INET or AF_INET6
+ error_num where to put an error code:
+ HOST_NOT_FOUND/TRY_AGAIN/NO_RECOVERY/NO_DATA
+
+Returns: a hostent structure or NULL for an error
+*/
+
+static struct hostent *
+host_fake_gethostbyname(const uschar *name, int af, int *error_num)
+{
+#if HAVE_IPV6
+int alen = (af == AF_INET)? sizeof(struct in_addr):sizeof(struct in6_addr);
+#else
+int alen = sizeof(struct in_addr);
+#endif
+
+int ipa;
+const uschar *lname = name;
+uschar *adds;
+uschar **alist;
+struct hostent *yield;
+dns_answer * dnsa = store_get_dns_answer();
+dns_scan dnss;
+
+DEBUG(D_host_lookup)
+ debug_printf("using host_fake_gethostbyname for %s (%s)\n", name,
+ af == AF_INET ? "IPv4" : "IPv6");
+
+/* Handle unqualified "localhost" */
+
+if (Ustrcmp(name, "localhost") == 0)
+ lname = af == AF_INET ? US"127.0.0.1" : US"::1";
+
+/* Handle a literal IP address */
+
+if ((ipa = string_is_ip_address(lname, NULL)) != 0)
+ if ( ipa == 4 && af == AF_INET
+ || ipa == 6 && af == AF_INET6)
+ {
+ int x[4];
+ yield = store_get(sizeof(struct hostent), FALSE);
+ alist = store_get(2 * sizeof(char *), FALSE);
+ adds = store_get(alen, FALSE);
+ yield->h_name = CS name;
+ yield->h_aliases = NULL;
+ yield->h_addrtype = af;
+ yield->h_length = alen;
+ yield->h_addr_list = CSS alist;
+ *alist++ = adds;
+ for (int n = host_aton(lname, x), i = 0; i < n; i++)
+ {
+ int y = x[i];
+ *adds++ = (y >> 24) & 255;
+ *adds++ = (y >> 16) & 255;
+ *adds++ = (y >> 8) & 255;
+ *adds++ = y & 255;
+ }
+ *alist = NULL;
+ }
+
+ /* Wrong kind of literal address */
+
+ else
+ {
+ *error_num = HOST_NOT_FOUND;
+ return NULL;
+ }
+
+/* Handle a host name */
+
+else
+ {
+ int type = af == AF_INET ? T_A:T_AAAA;
+ int rc = dns_lookup_timerwrap(dnsa, lname, type, NULL);
+ int count = 0;
+
+ lookup_dnssec_authenticated = NULL;
+
+ switch(rc)
+ {
+ case DNS_SUCCEED: break;
+ case DNS_NOMATCH: *error_num = HOST_NOT_FOUND; return NULL;
+ case DNS_NODATA: *error_num = NO_DATA; return NULL;
+ case DNS_AGAIN: *error_num = TRY_AGAIN; return NULL;
+ default:
+ case DNS_FAIL: *error_num = NO_RECOVERY; return NULL;
+ }
+
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
+ count++;
+
+ yield = store_get(sizeof(struct hostent), FALSE);
+ alist = store_get((count + 1) * sizeof(char *), FALSE);
+ adds = store_get(count *alen, FALSE);
+
+ yield->h_name = CS name;
+ yield->h_aliases = NULL;
+ yield->h_addrtype = af;
+ yield->h_length = alen;
+ yield->h_addr_list = CSS alist;
+
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
+ {
+ int x[4];
+ dns_address *da;
+ if (!(da = dns_address_from_rr(dnsa, rr))) break;
+ *alist++ = adds;
+ for (int n = host_aton(da->address, x), i = 0; i < n; i++)
+ {
+ int y = x[i];
+ *adds++ = (y >> 24) & 255;
+ *adds++ = (y >> 16) & 255;
+ *adds++ = (y >> 8) & 255;
+ *adds++ = y & 255;
+ }
+ }
+ *alist = NULL;
+ }
+
+return yield;
+}
+
+
+
+/*************************************************
+* Build chain of host items from list *
+*************************************************/
+
+/* This function builds a chain of host items from a textual list of host
+names. It does not do any lookups. If randomize is true, the chain is build in
+a randomized order. There may be multiple groups of independently randomized
+hosts; they are delimited by a host name consisting of just "+".
+
+Arguments:
+ anchor anchor for the chain
+ list text list
+ randomize TRUE for randomizing
+
+Returns: nothing
+*/
+
+void
+host_build_hostlist(host_item **anchor, const uschar *list, BOOL randomize)
+{
+int sep = 0;
+int fake_mx = MX_NONE; /* This value is actually -1 */
+uschar *name;
+
+if (!list) return;
+if (randomize) fake_mx--; /* Start at -2 for randomizing */
+
+*anchor = NULL;
+
+while ((name = string_nextinlist(&list, &sep, NULL, 0)))
+ {
+ host_item *h;
+
+ if (name[0] == '+' && name[1] == 0) /* "+" delimits a randomized group */
+ { /* ignore if not randomizing */
+ if (randomize) fake_mx--;
+ continue;
+ }
+
+ h = store_get(sizeof(host_item), FALSE);
+ h->name = name;
+ h->address = NULL;
+ h->port = PORT_NONE;
+ h->mx = fake_mx;
+ h->sort_key = randomize? (-fake_mx)*1000 + random_number(1000) : 0;
+ h->status = hstatus_unknown;
+ h->why = hwhy_unknown;
+ h->last_try = 0;
+
+ if (!*anchor)
+ {
+ h->next = NULL;
+ *anchor = h;
+ }
+ else
+ {
+ host_item *hh = *anchor;
+ if (h->sort_key < hh->sort_key)
+ {
+ h->next = hh;
+ *anchor = h;
+ }
+ else
+ {
+ while (hh->next && h->sort_key >= hh->next->sort_key)
+ hh = hh->next;
+ h->next = hh->next;
+ hh->next = h;
+ }
+ }
+ }
+}
+
+
+
+
+
+/*************************************************
+* Extract port from address string *
+*************************************************/
+
+/* In the spool file, and in the -oMa and -oMi options, a host plus port is
+given as an IP address followed by a dot and a port number. This function
+decodes this.
+
+An alternative format for the -oMa and -oMi options is [ip address]:port which
+is what Exim 4 uses for output, because it seems to becoming commonly used,
+whereas the dot form confuses some programs/people. So we recognize that form
+too.
+
+Argument:
+ address points to the string; if there is a port, the '.' in the string
+ is overwritten with zero to terminate the address; if the string
+ is in the [xxx]:ppp format, the address is shifted left and the
+ brackets are removed
+
+Returns: 0 if there is no port, else the port number. If there's a syntax
+ error, leave the incoming address alone, and return 0.
+*/
+
+int
+host_address_extract_port(uschar *address)
+{
+int port = 0;
+uschar *endptr;
+
+/* Handle the "bracketed with colon on the end" format */
+
+if (*address == '[')
+ {
+ uschar *rb = address + 1;
+ while (*rb != 0 && *rb != ']') rb++;
+ if (*rb++ == 0) return 0; /* Missing ]; leave invalid address */
+ if (*rb == ':')
+ {
+ port = Ustrtol(rb + 1, &endptr, 10);
+ if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
+ }
+ else if (*rb != 0) return 0; /* Bad syntax; leave invalid address */
+ memmove(address, address + 1, rb - address - 2);
+ rb[-2] = 0;
+ }
+
+/* Handle the "dot on the end" format */
+
+else
+ {
+ int skip = -3; /* Skip 3 dots in IPv4 addresses */
+ address--;
+ while (*(++address) != 0)
+ {
+ int ch = *address;
+ if (ch == ':') skip = 0; /* Skip 0 dots in IPv6 addresses */
+ else if (ch == '.' && skip++ >= 0) break;
+ }
+ if (*address == 0) return 0;
+ port = Ustrtol(address + 1, &endptr, 10);
+ if (*endptr != 0) return 0; /* Invalid port; leave invalid address */
+ *address = 0;
+ }
+
+return port;
+}
+
+
+/*************************************************
+* Get port from a host item's name *
+*************************************************/
+
+/* This function is called when finding the IP address for a host that is in a
+list of hosts explicitly configured, such as in the manualroute router, or in a
+fallback hosts list. We see if there is a port specification at the end of the
+host name, and if so, remove it. A minimum length of 3 is required for the
+original name; nothing shorter is recognized as having a port.
+
+We test for a name ending with a sequence of digits; if preceded by colon we
+have a port if the character before the colon is ] and the name starts with [
+or if there are no other colons in the name (i.e. it's not an IPv6 address).
+
+Arguments: pointer to the host item
+Returns: a port number or PORT_NONE
+*/
+
+int
+host_item_get_port(host_item *h)
+{
+const uschar *p;
+int port, x;
+int len = Ustrlen(h->name);
+
+if (len < 3 || (p = h->name + len - 1, !isdigit(*p))) return PORT_NONE;
+
+/* Extract potential port number */
+
+port = *p-- - '0';
+x = 10;
+
+while (p > h->name + 1 && isdigit(*p))
+ {
+ port += (*p-- - '0') * x;
+ x *= 10;
+ }
+
+/* The smallest value of p at this point is h->name + 1. */
+
+if (*p != ':') return PORT_NONE;
+
+if (p[-1] == ']' && h->name[0] == '[')
+ h->name = string_copyn(h->name + 1, p - h->name - 2);
+else if (Ustrchr(h->name, ':') == p)
+ h->name = string_copyn(h->name, p - h->name);
+else return PORT_NONE;
+
+DEBUG(D_route|D_host_lookup) debug_printf("host=%s port=%d\n", h->name, port);
+return port;
+}
+
+
+
+#ifndef STAND_ALONE /* Omit when standalone testing */
+
+/*************************************************
+* Build sender_fullhost and sender_rcvhost *
+*************************************************/
+
+/* This function is called when sender_host_name and/or sender_helo_name
+have been set. Or might have been set - for a local message read off the spool
+they won't be. In that case, do nothing. Otherwise, set up the fullhost string
+as follows:
+
+(a) No sender_host_name or sender_helo_name: "[ip address]"
+(b) Just sender_host_name: "host_name [ip address]"
+(c) Just sender_helo_name: "(helo_name) [ip address]" unless helo is IP
+ in which case: "[ip address}"
+(d) The two are identical: "host_name [ip address]" includes helo = IP
+(e) The two are different: "host_name (helo_name) [ip address]"
+
+If log_incoming_port is set, the sending host's port number is added to the IP
+address.
+
+This function also builds sender_rcvhost for use in Received: lines, whose
+syntax is a bit different. This value also includes the RFC 1413 identity.
+There wouldn't be two different variables if I had got all this right in the
+first place.
+
+Because this data may survive over more than one incoming SMTP message, it has
+to be in permanent store. However, STARTTLS has to be forgotten and redone
+on a multi-message conn, so this will be called once per message then. Hence
+we use malloc, so we can free.
+
+Arguments: none
+Returns: nothing
+*/
+
+void
+host_build_sender_fullhost(void)
+{
+BOOL show_helo = TRUE;
+uschar * address, * fullhost, * rcvhost;
+rmark reset_point;
+int len;
+
+if (!sender_host_address) return;
+
+reset_point = store_mark();
+
+/* Set up address, with or without the port. After discussion, it seems that
+the only format that doesn't cause trouble is [aaaa]:pppp. However, we can't
+use this directly as the first item for Received: because it ain't an RFC 2822
+domain. Sigh. */
+
+address = string_sprintf("[%s]:%d", sender_host_address, sender_host_port);
+if (!LOGGING(incoming_port) || sender_host_port <= 0)
+ *(Ustrrchr(address, ':')) = 0;
+
+/* If there's no EHLO/HELO data, we can't show it. */
+
+if (!sender_helo_name) show_helo = FALSE;
+
+/* If HELO/EHLO was followed by an IP literal, it's messy because of two
+features of IPv6. Firstly, there's the "IPv6:" prefix (Exim is liberal and
+doesn't require this, for historical reasons). Secondly, IPv6 addresses may not
+be given in canonical form, so we have to canonicalize them before comparing. As
+it happens, the code works for both IPv4 and IPv6. */
+
+else if (sender_helo_name[0] == '[' &&
+ sender_helo_name[(len=Ustrlen(sender_helo_name))-1] == ']')
+ {
+ int offset = 1;
+ uschar *helo_ip;
+
+ if (strncmpic(sender_helo_name + 1, US"IPv6:", 5) == 0) offset += 5;
+ if (strncmpic(sender_helo_name + 1, US"IPv4:", 5) == 0) offset += 5;
+
+ helo_ip = string_copyn(sender_helo_name + offset, len - offset - 1);
+
+ if (string_is_ip_address(helo_ip, NULL) != 0)
+ {
+ int x[4], y[4];
+ int sizex, sizey;
+ uschar ipx[48], ipy[48]; /* large enough for full IPv6 */
+
+ sizex = host_aton(helo_ip, x);
+ sizey = host_aton(sender_host_address, y);
+
+ (void)host_nmtoa(sizex, x, -1, ipx, ':');
+ (void)host_nmtoa(sizey, y, -1, ipy, ':');
+
+ if (strcmpic(ipx, ipy) == 0) show_helo = FALSE;
+ }
+ }
+
+/* Host name is not verified */
+
+if (!sender_host_name)
+ {
+ uschar *portptr = Ustrstr(address, "]:");
+ gstring * g;
+ int adlen; /* Sun compiler doesn't like ++ in initializers */
+
+ adlen = portptr ? (++portptr - address) : Ustrlen(address);
+ fullhost = sender_helo_name
+ ? string_sprintf("(%s) %s", sender_helo_name, address)
+ : address;
+
+ g = string_catn(NULL, address, adlen);
+
+ if (sender_ident || show_helo || portptr)
+ {
+ int firstptr;
+ g = string_catn(g, US" (", 2);
+ firstptr = g->ptr;
+
+ if (portptr)
+ g = string_append(g, 2, US"port=", portptr + 1);
+
+ if (show_helo)
+ g = string_append(g, 2,
+ firstptr == g->ptr ? US"helo=" : US" helo=", sender_helo_name);
+
+ if (sender_ident)
+ g = string_append(g, 2,
+ firstptr == g->ptr ? US"ident=" : US" ident=", sender_ident);
+
+ g = string_catn(g, US")", 1);
+ }
+
+ rcvhost = string_from_gstring(g);
+ }
+
+/* Host name is known and verified. Unless we've already found that the HELO
+data matches the IP address, compare it with the name. */
+
+else
+ {
+ if (show_helo && strcmpic(sender_host_name, sender_helo_name) == 0)
+ show_helo = FALSE;
+
+ if (show_helo)
+ {
+ fullhost = string_sprintf("%s (%s) %s", sender_host_name,
+ sender_helo_name, address);
+ rcvhost = sender_ident
+ ? string_sprintf("%s\n\t(%s helo=%s ident=%s)", sender_host_name,
+ address, sender_helo_name, sender_ident)
+ : string_sprintf("%s (%s helo=%s)", sender_host_name,
+ address, sender_helo_name);
+ }
+ else
+ {
+ fullhost = string_sprintf("%s %s", sender_host_name, address);
+ rcvhost = sender_ident
+ ? string_sprintf("%s (%s ident=%s)", sender_host_name, address,
+ sender_ident)
+ : string_sprintf("%s (%s)", sender_host_name, address);
+ }
+ }
+
+sender_fullhost = string_copy_perm(fullhost, TRUE);
+sender_rcvhost = string_copy_perm(rcvhost, TRUE);
+
+store_reset(reset_point);
+
+DEBUG(D_host_lookup) debug_printf("sender_fullhost = %s\n", sender_fullhost);
+DEBUG(D_host_lookup) debug_printf("sender_rcvhost = %s\n", sender_rcvhost);
+}
+
+
+
+/*************************************************
+* Build host+ident message *
+*************************************************/
+
+/* Used when logging rejections and various ACL and SMTP incidents. The text
+return depends on whether sender_fullhost and sender_ident are set or not:
+
+ no ident, no host => U=unknown
+ no ident, host set => H=sender_fullhost
+ ident set, no host => U=ident
+ ident set, host set => H=sender_fullhost U=ident
+
+Use taint-unchecked routines on the assumption we'll never expand the results.
+
+Arguments:
+ useflag TRUE if first item to be flagged (H= or U=); if there are two
+ items, the second is always flagged
+
+Returns: pointer to a string in big_buffer
+*/
+
+uschar *
+host_and_ident(BOOL useflag)
+{
+if (!sender_fullhost)
+ string_format_nt(big_buffer, big_buffer_size, "%s%s", useflag ? "U=" : "",
+ sender_ident ? sender_ident : US"unknown");
+else
+ {
+ uschar * flag = useflag ? US"H=" : US"";
+ uschar * iface = US"";
+ if (LOGGING(incoming_interface) && interface_address)
+ iface = string_sprintf(" I=[%s]:%d", interface_address, interface_port);
+ if (sender_ident)
+ string_format_nt(big_buffer, big_buffer_size, "%s%s%s U=%s",
+ flag, sender_fullhost, iface, sender_ident);
+ else
+ string_format_nt(big_buffer, big_buffer_size, "%s%s%s",
+ flag, sender_fullhost, iface);
+ }
+return big_buffer;
+}
+
+#endif /* STAND_ALONE */
+
+
+
+
+/*************************************************
+* Build list of local interfaces *
+*************************************************/
+
+/* This function interprets the contents of the local_interfaces or
+extra_local_interfaces options, and creates an ip_address_item block for each
+item on the list. There is no special interpretation of any IP addresses; in
+particular, 0.0.0.0 and ::0 are returned without modification. If any address
+includes a port, it is set in the block. Otherwise the port value is set to
+zero.
+
+Arguments:
+ list the list
+ name the name of the option being expanded
+
+Returns: a chain of ip_address_items, each containing to a textual
+ version of an IP address, and a port number (host order) or
+ zero if no port was given with the address
+*/
+
+ip_address_item *
+host_build_ifacelist(const uschar *list, uschar *name)
+{
+int sep = 0;
+uschar *s;
+ip_address_item * yield = NULL, * last = NULL, * next;
+BOOL taint = is_tainted(list);
+
+while ((s = string_nextinlist(&list, &sep, NULL, 0)))
+ {
+ int ipv;
+ int port = host_address_extract_port(s); /* Leaves just the IP address */
+
+ if (!(ipv = string_is_ip_address(s, NULL)))
+ log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Malformed IP address \"%s\" in %s",
+ s, name);
+
+ /* Skip IPv6 addresses if IPv6 is disabled. */
+
+ if (disable_ipv6 && ipv == 6) continue;
+
+ /* This use of strcpy() is OK because we have checked that s is a valid IP
+ address above. The field in the ip_address_item is large enough to hold an
+ IPv6 address. */
+
+ next = store_get(sizeof(ip_address_item), taint);
+ next->next = NULL;
+ Ustrcpy(next->address, s);
+ next->port = port;
+ next->v6_include_v4 = FALSE;
+ next->log = NULL;
+
+ if (!yield)
+ yield = last = next;
+ else
+ {
+ last->next = next;
+ last = next;
+ }
+ }
+
+return yield;
+}
+
+
+
+
+
+/*************************************************
+* Find addresses on local interfaces *
+*************************************************/
+
+/* This function finds the addresses of local IP interfaces. These are used
+when testing for routing to the local host. As the function may be called more
+than once, the list is preserved in permanent store, pointed to by a static
+variable, to save doing the work more than once per process.
+
+The generic list of interfaces is obtained by calling host_build_ifacelist()
+for local_interfaces and extra_local_interfaces. This list scanned to remove
+duplicates (which may exist with different ports - not relevant here). If
+either of the wildcard IP addresses (0.0.0.0 and ::0) are encountered, they are
+replaced by the appropriate (IPv4 or IPv6) list of actual local interfaces,
+obtained from os_find_running_interfaces().
+
+Arguments: none
+Returns: a chain of ip_address_items, each containing to a textual
+ version of an IP address; the port numbers are not relevant
+*/
+
+
+/* First, a local subfunction to add an interface to a list in permanent store,
+but only if there isn't a previous copy of that address on the list. */
+
+static ip_address_item *
+add_unique_interface(ip_address_item *list, ip_address_item *ipa)
+{
+ip_address_item *ipa2;
+for (ipa2 = list; ipa2; ipa2 = ipa2->next)
+ if (Ustrcmp(ipa2->address, ipa->address) == 0) return list;
+ipa2 = store_get_perm(sizeof(ip_address_item), FALSE);
+*ipa2 = *ipa;
+ipa2->next = list;
+return ipa2;
+}
+
+
+/* This is the globally visible function */
+
+ip_address_item *
+host_find_interfaces(void)
+{
+ip_address_item *running_interfaces = NULL;
+
+if (local_interface_data == NULL)
+ {
+ void *reset_item = store_mark();
+ ip_address_item *dlist = host_build_ifacelist(CUS local_interfaces,
+ US"local_interfaces");
+ ip_address_item *xlist = host_build_ifacelist(CUS extra_local_interfaces,
+ US"extra_local_interfaces");
+ ip_address_item *ipa;
+
+ if (!dlist) dlist = xlist;
+ else
+ {
+ for (ipa = dlist; ipa->next; ipa = ipa->next) ;
+ ipa->next = xlist;
+ }
+
+ for (ipa = dlist; ipa; ipa = ipa->next)
+ {
+ if (Ustrcmp(ipa->address, "0.0.0.0") == 0 ||
+ Ustrcmp(ipa->address, "::0") == 0)
+ {
+ BOOL ipv6 = ipa->address[0] == ':';
+ if (!running_interfaces)
+ running_interfaces = os_find_running_interfaces();
+ for (ip_address_item * ipa2 = running_interfaces; ipa2; ipa2 = ipa2->next)
+ if ((Ustrchr(ipa2->address, ':') != NULL) == ipv6)
+ local_interface_data = add_unique_interface(local_interface_data,
+ ipa2);
+ }
+ else
+ {
+ local_interface_data = add_unique_interface(local_interface_data, ipa);
+ DEBUG(D_interface)
+ {
+ debug_printf("Configured local interface: address=%s", ipa->address);
+ if (ipa->port != 0) debug_printf(" port=%d", ipa->port);
+ debug_printf("\n");
+ }
+ }
+ }
+ store_reset(reset_item);
+ }
+
+return local_interface_data;
+}
+
+
+
+
+
+/*************************************************
+* Convert network IP address to text *
+*************************************************/
+
+/* Given an IPv4 or IPv6 address in binary, convert it to a text
+string and return the result in a piece of new store. The address can
+either be given directly, or passed over in a sockaddr structure. Note
+that this isn't the converse of host_aton() because of byte ordering
+differences. See host_nmtoa() below.
+
+Arguments:
+ type if < 0 then arg points to a sockaddr, else
+ either AF_INET or AF_INET6
+ arg points to a sockaddr if type is < 0, or
+ points to an IPv4 address (32 bits), or
+ points to an IPv6 address (128 bits),
+ in both cases, in network byte order
+ buffer if NULL, the result is returned in gotten store;
+ else points to a buffer to hold the answer
+ portptr points to where to put the port number, if non NULL; only
+ used when type < 0
+
+Returns: pointer to character string
+*/
+
+uschar *
+host_ntoa(int type, const void *arg, uschar *buffer, int *portptr)
+{
+uschar *yield;
+
+/* The new world. It is annoying that we have to fish out the address from
+different places in the block, depending on what kind of address it is. It
+is also a pain that inet_ntop() returns a const uschar *, whereas the IPv4
+function inet_ntoa() returns just uschar *, and some picky compilers insist
+on warning if one assigns a const uschar * to a uschar *. Hence the casts. */
+
+#if HAVE_IPV6
+uschar addr_buffer[46];
+if (type < 0)
+ {
+ int family = ((struct sockaddr *)arg)->sa_family;
+ if (family == AF_INET6)
+ {
+ struct sockaddr_in6 *sk = (struct sockaddr_in6 *)arg;
+ yield = US inet_ntop(family, &(sk->sin6_addr), CS addr_buffer,
+ sizeof(addr_buffer));
+ if (portptr != NULL) *portptr = ntohs(sk->sin6_port);
+ }
+ else
+ {
+ struct sockaddr_in *sk = (struct sockaddr_in *)arg;
+ yield = US inet_ntop(family, &(sk->sin_addr), CS addr_buffer,
+ sizeof(addr_buffer));
+ if (portptr != NULL) *portptr = ntohs(sk->sin_port);
+ }
+ }
+else
+ {
+ yield = US inet_ntop(type, arg, CS addr_buffer, sizeof(addr_buffer));
+ }
+
+/* If the result is a mapped IPv4 address, show it in V4 format. */
+
+if (Ustrncmp(yield, "::ffff:", 7) == 0) yield += 7;
+
+#else /* HAVE_IPV6 */
+
+/* The old world */
+
+if (type < 0)
+ {
+ yield = US inet_ntoa(((struct sockaddr_in *)arg)->sin_addr);
+ if (portptr != NULL) *portptr = ntohs(((struct sockaddr_in *)arg)->sin_port);
+ }
+else
+ yield = US inet_ntoa(*((struct in_addr *)arg));
+#endif
+
+/* If there is no buffer, put the string into some new store. */
+
+if (!buffer) buffer = store_get(46, FALSE);
+
+/* Callers of this function with a non-NULL buffer must ensure that it is
+large enough to hold an IPv6 address, namely, at least 46 bytes. That's what
+makes this use of strcpy() OK.
+If the library returned apparently an apparently tainted string, clean it;
+we trust IP addresses. */
+
+string_format_nt(buffer, 46, "%s", yield);
+return buffer;
+}
+
+
+
+
+/*************************************************
+* Convert address text to binary *
+*************************************************/
+
+/* Given the textual form of an IP address, convert it to binary in an
+array of ints. IPv4 addresses occupy one int; IPv6 addresses occupy 4 ints.
+The result has the first byte in the most significant byte of the first int. In
+other words, the result is not in network byte order, but in host byte order.
+As a result, this is not the converse of host_ntoa(), which expects network
+byte order. See host_nmtoa() below.
+
+Arguments:
+ address points to the textual address, checked for syntax
+ bin points to an array of 4 ints
+
+Returns: the number of ints used
+*/
+
+int
+host_aton(const uschar *address, int *bin)
+{
+int x[4];
+int v4offset = 0;
+
+/* Handle IPv6 address, which may end with an IPv4 address. It may also end
+with a "scope", introduced by a percent sign. This code is NOT enclosed in #if
+HAVE_IPV6 in order that IPv6 addresses are recognized even if IPv6 is not
+supported. */
+
+if (Ustrchr(address, ':') != NULL)
+ {
+ const uschar *p = address;
+ const uschar *component[8];
+ BOOL ipv4_ends = FALSE;
+ int ci = 0;
+ int nulloffset = 0;
+ int v6count = 8;
+ int i;
+
+ /* If the address starts with a colon, it will start with two colons.
+ Just lose the first one, which will leave a null first component. */
+
+ if (*p == ':') p++;
+
+ /* Split the address into components separated by colons. The input address
+ is supposed to be checked for syntax. There was a case where this was
+ overlooked; to guard against that happening again, check here and crash if
+ there are too many components. */
+
+ while (*p != 0 && *p != '%')
+ {
+ int len = Ustrcspn(p, ":%");
+ if (len == 0) nulloffset = ci;
+ if (ci > 7) log_write(0, LOG_MAIN|LOG_PANIC_DIE,
+ "Internal error: invalid IPv6 address \"%s\" passed to host_aton()",
+ address);
+ component[ci++] = p;
+ p += len;
+ if (*p == ':') p++;
+ }
+
+ /* If the final component contains a dot, it is a trailing v4 address.
+ As the syntax is known to be checked, just set up for a trailing
+ v4 address and restrict the v6 part to 6 components. */
+
+ if (Ustrchr(component[ci-1], '.') != NULL)
+ {
+ address = component[--ci];
+ ipv4_ends = TRUE;
+ v4offset = 3;
+ v6count = 6;
+ }
+
+ /* If there are fewer than 6 or 8 components, we have to insert some
+ more empty ones in the middle. */
+
+ if (ci < v6count)
+ {
+ int insert_count = v6count - ci;
+ for (i = v6count-1; i > nulloffset + insert_count; i--)
+ component[i] = component[i - insert_count];
+ while (i > nulloffset) component[i--] = US"";
+ }
+
+ /* Now turn the components into binary in pairs and bung them
+ into the vector of ints. */
+
+ for (i = 0; i < v6count; i += 2)
+ bin[i/2] = (Ustrtol(component[i], NULL, 16) << 16) +
+ Ustrtol(component[i+1], NULL, 16);
+
+ /* If there was no terminating v4 component, we are done. */
+
+ if (!ipv4_ends) return 4;
+ }
+
+/* Handle IPv4 address */
+
+(void)sscanf(CS address, "%d.%d.%d.%d", x, x+1, x+2, x+3);
+bin[v4offset] = ((uint)x[0] << 24) + (x[1] << 16) + (x[2] << 8) + x[3];
+return v4offset+1;
+}
+
+
+/*************************************************
+* Apply mask to an IP address *
+*************************************************/
+
+/* Mask an address held in 1 or 4 ints, with the ms bit in the ms bit of the
+first int, etc.
+
+Arguments:
+ count the number of ints
+ binary points to the ints to be masked
+ mask the count of ms bits to leave, or -1 if no masking
+
+Returns: nothing
+*/
+
+void
+host_mask(int count, int *binary, int mask)
+{
+if (mask < 0) mask = 99999;
+for (int i = 0; i < count; i++)
+ {
+ int wordmask;
+ if (mask == 0) wordmask = 0;
+ else if (mask < 32)
+ {
+ wordmask = (uint)(-1) << (32 - mask);
+ mask = 0;
+ }
+ else
+ {
+ wordmask = -1;
+ mask -= 32;
+ }
+ binary[i] &= wordmask;
+ }
+}
+
+
+
+
+/*************************************************
+* Convert masked IP address in ints to text *
+*************************************************/
+
+/* We can't use host_ntoa() because it assumes the binary values are in network
+byte order, and these are the result of host_aton(), which puts them in ints in
+host byte order. Also, we really want IPv6 addresses to be in a canonical
+format, so we output them with no abbreviation. In a number of cases we can't
+use the normal colon separator in them because it terminates keys in lsearch
+files, so we want to use dot instead. There's an argument that specifies what
+to use for IPv6 addresses.
+
+Arguments:
+ count 1 or 4 (number of ints)
+ binary points to the ints
+ mask mask value; if < 0 don't add to result
+ buffer big enough to hold the result
+ sep component separator character for IPv6 addresses
+
+Returns: the number of characters placed in buffer, not counting
+ the final nul.
+*/
+
+int
+host_nmtoa(int count, int *binary, int mask, uschar *buffer, int sep)
+{
+int j;
+uschar *tt = buffer;
+
+if (count == 1)
+ {
+ j = binary[0];
+ for (int i = 24; i >= 0; i -= 8)
+ tt += sprintf(CS tt, "%d.", (j >> i) & 255);
+ }
+else
+ for (int i = 0; i < 4; i++)
+ {
+ j = binary[i];
+ tt += sprintf(CS tt, "%04x%c%04x%c", (j >> 16) & 0xffff, sep, j & 0xffff, sep);
+ }
+
+tt--; /* lose final separator */
+
+if (mask < 0)
+ *tt = 0;
+else
+ tt += sprintf(CS tt, "/%d", mask);
+
+return tt - buffer;
+}
+
+
+/* Like host_nmtoa() but: ipv6-only, canonical output, no mask
+
+Arguments:
+ binary points to the ints
+ buffer big enough to hold the result
+
+Returns: the number of characters placed in buffer, not counting
+ the final nul.
+*/
+
+int
+ipv6_nmtoa(int * binary, uschar * buffer)
+{
+int i, j, k;
+uschar * c = buffer;
+uschar * d = NULL; /* shut insufficiently "clever" compiler up */
+
+for (i = 0; i < 4; i++)
+ { /* expand to text */
+ j = binary[i];
+ c += sprintf(CS c, "%x:%x:", (j >> 16) & 0xffff, j & 0xffff);
+ }
+
+for (c = buffer, k = -1, i = 0; i < 8; i++)
+ { /* find longest 0-group sequence */
+ if (*c == '0') /* must be "0:" */
+ {
+ uschar * s = c;
+ j = i;
+ while (c[2] == '0') i++, c += 2;
+ if (i-j > k)
+ {
+ k = i-j; /* length of sequence */
+ d = s; /* start of sequence */
+ }
+ }
+ while (*++c != ':') ;
+ c++;
+ }
+
+c[-1] = '\0'; /* drop trailing colon */
+
+/* debug_printf("%s: D k %d <%s> <%s>\n", __FUNCTION__, k, d, d + 2*(k+1)); */
+if (k >= 0)
+ { /* collapse */
+ c = d + 2*(k+1);
+ if (d == buffer) c--; /* need extra colon */
+ *d++ = ':'; /* 1st 0 */
+ while ((*d++ = *c++)) ;
+ }
+else
+ d = c;
+
+return d - buffer;
+}
+
+
+
+/*************************************************
+* Check port for tls_on_connect *
+*************************************************/
+
+/* This function checks whether a given incoming port is configured for tls-
+on-connect. It is called from the daemon and from inetd handling. If the global
+option tls_on_connect is already set, all ports operate this way. Otherwise, we
+check the tls_on_connect_ports option for a list of ports.
+
+Argument: a port number
+Returns: TRUE or FALSE
+*/
+
+BOOL
+host_is_tls_on_connect_port(int port)
+{
+int sep = 0;
+uschar buffer[32];
+const uschar *list = tls_in.on_connect_ports;
+uschar *s;
+uschar *end;
+
+if (tls_in.on_connect) return TRUE;
+
+while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
+ if (Ustrtol(s, &end, 10) == port)
+ return TRUE;
+
+return FALSE;
+}
+
+
+
+/*************************************************
+* Check whether host is in a network *
+*************************************************/
+
+/* This function checks whether a given IP address matches a pattern that
+represents either a single host, or a network (using CIDR notation). The caller
+of this function must check the syntax of the arguments before calling it.
+
+Arguments:
+ host string representation of the ip-address to check
+ net string representation of the network, with optional CIDR mask
+ maskoffset offset to the / that introduces the mask in the key
+ zero if there is no mask
+
+Returns:
+ TRUE the host is inside the network
+ FALSE the host is NOT inside the network
+*/
+
+BOOL
+host_is_in_net(const uschar *host, const uschar *net, int maskoffset)
+{
+int address[4];
+int incoming[4];
+int mlen;
+int size = host_aton(net, address);
+int insize;
+
+/* No mask => all bits to be checked */
+
+if (maskoffset == 0) mlen = 99999; /* Big number */
+ else mlen = Uatoi(net + maskoffset + 1);
+
+/* Convert the incoming address to binary. */
+
+insize = host_aton(host, incoming);
+
+/* Convert IPv4 addresses given in IPv6 compatible mode, which represent
+ connections from IPv4 hosts to IPv6 hosts, that is, addresses of the form
+ ::ffff:<v4address>, to IPv4 format. */
+
+if (insize == 4 && incoming[0] == 0 && incoming[1] == 0 &&
+ incoming[2] == 0xffff)
+ {
+ insize = 1;
+ incoming[0] = incoming[3];
+ }
+
+/* No match if the sizes don't agree. */
+
+if (insize != size) return FALSE;
+
+/* Else do the masked comparison. */
+
+for (int i = 0; i < size; i++)
+ {
+ int mask;
+ if (mlen == 0) mask = 0;
+ else if (mlen < 32)
+ {
+ mask = (uint)(-1) << (32 - mlen);
+ mlen = 0;
+ }
+ else
+ {
+ mask = -1;
+ mlen -= 32;
+ }
+ if ((incoming[i] & mask) != (address[i] & mask)) return FALSE;
+ }
+
+return TRUE;
+}
+
+
+
+/*************************************************
+* Scan host list for local hosts *
+*************************************************/
+
+/* Scan through a chain of addresses and check whether any of them is the
+address of an interface on the local machine. If so, remove that address and
+any previous ones with the same MX value, and all subsequent ones (which will
+have greater or equal MX values) from the chain. Note: marking them as unusable
+is NOT the right thing to do because it causes the hosts not to be used for
+other domains, for which they may well be correct.
+
+The hosts may be part of a longer chain; we only process those between the
+initial pointer and the "last" pointer.
+
+There is also a list of "pseudo-local" host names which are checked against the
+host names. Any match causes that host item to be treated the same as one which
+matches a local IP address.
+
+If the very first host is a local host, then all MX records had a precedence
+greater than or equal to that of the local host. Either there's a problem in
+the DNS, or an apparently remote name turned out to be an abbreviation for the
+local host. Give a specific return code, and let the caller decide what to do.
+Otherwise, give a success code if at least one host address has been found.
+
+Arguments:
+ host pointer to the first host in the chain
+ lastptr pointer to pointer to the last host in the chain (may be updated)
+ removed if not NULL, set TRUE if some local addresses were removed
+ from the list
+
+Returns:
+ HOST_FOUND if there is at least one host with an IP address on the chain
+ and an MX value less than any MX value associated with the
+ local host
+ HOST_FOUND_LOCAL if a local host is among the lowest-numbered MX hosts; when
+ the host addresses were obtained from A records or
+ gethostbyname(), the MX values are set to -1.
+ HOST_FIND_FAILED if no valid hosts with set IP addresses were found
+*/
+
+int
+host_scan_for_local_hosts(host_item *host, host_item **lastptr, BOOL *removed)
+{
+int yield = HOST_FIND_FAILED;
+host_item *last = *lastptr;
+host_item *prev = NULL;
+host_item *h;
+
+if (removed != NULL) *removed = FALSE;
+
+if (local_interface_data == NULL) local_interface_data = host_find_interfaces();
+
+for (h = host; h != last->next; h = h->next)
+ {
+ #ifndef STAND_ALONE
+ if (hosts_treat_as_local != NULL)
+ {
+ int rc;
+ const uschar *save = deliver_domain;
+ deliver_domain = h->name; /* set $domain */
+ rc = match_isinlist(string_copylc(h->name), CUSS &hosts_treat_as_local, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
+ deliver_domain = save;
+ if (rc == OK) goto FOUND_LOCAL;
+ }
+ #endif
+
+ /* It seems that on many operating systems, 0.0.0.0 is treated as a synonym
+ for 127.0.0.1 and refers to the local host. We therefore force it always to
+ be treated as local. */
+
+ if (h->address != NULL)
+ {
+ if (Ustrcmp(h->address, "0.0.0.0") == 0) goto FOUND_LOCAL;
+ for (ip_address_item * ip = local_interface_data; ip; ip = ip->next)
+ if (Ustrcmp(h->address, ip->address) == 0) goto FOUND_LOCAL;
+ yield = HOST_FOUND; /* At least one remote address has been found */
+ }
+
+ /* Update prev to point to the last host item before any that have
+ the same MX value as the one we have just considered. */
+
+ if (h->next == NULL || h->next->mx != h->mx) prev = h;
+ }
+
+return yield; /* No local hosts found: return HOST_FOUND or HOST_FIND_FAILED */
+
+/* A host whose IP address matches a local IP address, or whose name matches
+something in hosts_treat_as_local has been found. */
+
+FOUND_LOCAL:
+
+if (prev == NULL)
+ {
+ HDEBUG(D_host_lookup) debug_printf((h->mx >= 0)?
+ "local host has lowest MX\n" :
+ "local host found for non-MX address\n");
+ return HOST_FOUND_LOCAL;
+ }
+
+HDEBUG(D_host_lookup)
+ {
+ debug_printf("local host in host list - removed hosts:\n");
+ for (h = prev->next; h != last->next; h = h->next)
+ debug_printf(" %s %s %d\n", h->name, h->address, h->mx);
+ }
+
+if (removed != NULL) *removed = TRUE;
+prev->next = last->next;
+*lastptr = prev;
+return yield;
+}
+
+
+
+
+/*************************************************
+* Remove duplicate IPs in host list *
+*************************************************/
+
+/* You would think that administrators could set up their DNS records so that
+one ended up with a list of unique IP addresses after looking up A or MX
+records, but apparently duplication is common. So we scan such lists and
+remove the later duplicates. Note that we may get lists in which some host
+addresses are not set.
+
+Arguments:
+ host pointer to the first host in the chain
+ lastptr pointer to pointer to the last host in the chain (may be updated)
+
+Returns: nothing
+*/
+
+static void
+host_remove_duplicates(host_item *host, host_item **lastptr)
+{
+while (host != *lastptr)
+ {
+ if (host->address != NULL)
+ {
+ host_item *h = host;
+ while (h != *lastptr)
+ {
+ if (h->next->address != NULL &&
+ Ustrcmp(h->next->address, host->address) == 0)
+ {
+ DEBUG(D_host_lookup) debug_printf("duplicate IP address %s (MX=%d) "
+ "removed\n", host->address, h->next->mx);
+ if (h->next == *lastptr) *lastptr = h;
+ h->next = h->next->next;
+ }
+ else h = h->next;
+ }
+ }
+ /* If the last item was removed, host may have become == *lastptr */
+ if (host != *lastptr) host = host->next;
+ }
+}
+
+
+
+
+/*************************************************
+* Find sender host name by gethostbyaddr() *
+*************************************************/
+
+/* This used to be the only way it was done, but it turns out that not all
+systems give aliases for calls to gethostbyaddr() - or one of the modern
+equivalents like getipnodebyaddr(). Fortunately, multiple PTR records are rare,
+but they can still exist. This function is now used only when a DNS lookup of
+the IP address fails, in order to give access to /etc/hosts.
+
+Arguments: none
+Returns: OK, DEFER, FAIL
+*/
+
+static int
+host_name_lookup_byaddr(void)
+{
+struct hostent * hosts;
+struct in_addr addr;
+unsigned long time_msec = 0; /* init to quieten dumb static analysis */
+
+if (slow_lookup_log) time_msec = get_time_in_ms();
+
+/* Lookup on IPv6 system */
+
+#if HAVE_IPV6
+if (Ustrchr(sender_host_address, ':') != NULL)
+ {
+ struct in6_addr addr6;
+ if (inet_pton(AF_INET6, CS sender_host_address, &addr6) != 1)
+ log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
+ "IPv6 address", sender_host_address);
+ #if HAVE_GETIPNODEBYADDR
+ hosts = getipnodebyaddr(CS &addr6, sizeof(addr6), AF_INET6, &h_errno);
+ #else
+ hosts = gethostbyaddr(CS &addr6, sizeof(addr6), AF_INET6);
+ #endif
+ }
+else
+ {
+ if (inet_pton(AF_INET, CS sender_host_address, &addr) != 1)
+ log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to parse \"%s\" as an "
+ "IPv4 address", sender_host_address);
+ #if HAVE_GETIPNODEBYADDR
+ hosts = getipnodebyaddr(CS &addr, sizeof(addr), AF_INET, &h_errno);
+ #else
+ hosts = gethostbyaddr(CS &addr, sizeof(addr), AF_INET);
+ #endif
+ }
+
+/* Do lookup on IPv4 system */
+
+#else
+addr.s_addr = (S_ADDR_TYPE)inet_addr(CS sender_host_address);
+hosts = gethostbyaddr(CS(&addr), sizeof(addr), AF_INET);
+#endif
+
+if ( slow_lookup_log
+ && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log
+ )
+ log_long_lookup(US"gethostbyaddr", sender_host_address, time_msec);
+
+/* Failed to look up the host. */
+
+if (!hosts)
+ {
+ HDEBUG(D_host_lookup) debug_printf("IP address lookup failed: h_errno=%d\n",
+ h_errno);
+ return (h_errno == TRY_AGAIN || h_errno == NO_RECOVERY) ? DEFER : FAIL;
+ }
+
+/* It seems there are some records in the DNS that yield an empty name. We
+treat this as non-existent. In some operating systems, this is returned as an
+empty string; in others as a single dot. */
+
+if (!hosts->h_name || !hosts->h_name[0] || hosts->h_name[0] == '.')
+ {
+ HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an empty name: "
+ "treated as non-existent host name\n");
+ return FAIL;
+ }
+
+/* Copy and lowercase the name, which is in static storage in many systems.
+Put it in permanent memory. */
+
+ {
+ int old_pool = store_pool;
+ store_pool = POOL_TAINT_PERM; /* names are tainted */
+
+ sender_host_name = string_copylc(US hosts->h_name);
+
+ /* If the host has aliases, build a copy of the alias list */
+
+ if (hosts->h_aliases)
+ {
+ int count = 1;
+ uschar **ptr;
+
+ for (uschar ** aliases = USS hosts->h_aliases; *aliases; aliases++) count++;
+ store_pool = POOL_PERM;
+ ptr = sender_host_aliases = store_get(count * sizeof(uschar *), FALSE);
+ store_pool = POOL_TAINT_PERM;
+
+ for (uschar ** aliases = USS hosts->h_aliases; *aliases; aliases++)
+ *ptr++ = string_copylc(*aliases);
+ *ptr = NULL;
+ }
+ store_pool = old_pool;
+ }
+
+return OK;
+}
+
+
+
+/*************************************************
+* Find host name for incoming call *
+*************************************************/
+
+/* Put the name in permanent store, pointed to by sender_host_name. We also set
+up a list of alias names, pointed to by sender_host_alias. The list is
+NULL-terminated. The incoming address is in sender_host_address, either in
+dotted-quad form for IPv4 or in colon-separated form for IPv6.
+
+This function does a thorough check that the names it finds point back to the
+incoming IP address. Any that do not are discarded. Note that this is relied on
+by the ACL reverse_host_lookup check.
+
+On some systems, get{host,ipnode}byaddr() appears to do this internally, but
+this it not universally true. Also, for release 4.30, this function was changed
+to do a direct DNS lookup first, by default[1], because it turns out that that
+is the only guaranteed way to find all the aliases on some systems. My
+experiments indicate that Solaris gethostbyaddr() gives the aliases for but
+Linux does not.
+
+[1] The actual order is controlled by the host_lookup_order option.
+
+Arguments: none
+Returns: OK on success, the answer being placed in the global variable
+ sender_host_name, with any aliases in a list hung off
+ sender_host_aliases
+ FAIL if no host name can be found
+ DEFER if a temporary error was encountered
+
+The variable host_lookup_msg is set to an empty string on success, or to a
+reason for the failure otherwise, in a form suitable for tagging onto an error
+message, and also host_lookup_failed is set TRUE if the lookup failed. If there
+was a defer, host_lookup_deferred is set TRUE.
+
+Any dynamically constructed string for host_lookup_msg must be in permanent
+store, because it might be used for several incoming messages on the same SMTP
+connection. */
+
+int
+host_name_lookup(void)
+{
+int old_pool, rc;
+int sep = 0;
+uschar *save_hostname;
+uschar **aliases;
+uschar *ordername;
+const uschar *list = host_lookup_order;
+dns_answer * dnsa = store_get_dns_answer();
+dns_scan dnss;
+
+sender_host_dnssec = host_lookup_deferred = host_lookup_failed = FALSE;
+
+HDEBUG(D_host_lookup)
+ debug_printf("looking up host name for %s\n", sender_host_address);
+
+/* For testing the case when a lookup does not complete, we have a special
+reserved IP address. */
+
+if (f.running_in_test_harness &&
+ Ustrcmp(sender_host_address, "99.99.99.99") == 0)
+ {
+ HDEBUG(D_host_lookup)
+ debug_printf("Test harness: host name lookup returns DEFER\n");
+ host_lookup_deferred = TRUE;
+ return DEFER;
+ }
+
+/* Do lookups directly in the DNS or via gethostbyaddr() (or equivalent), in
+the order specified by the host_lookup_order option. */
+
+while ((ordername = string_nextinlist(&list, &sep, NULL, 0)))
+ {
+ if (strcmpic(ordername, US"bydns") == 0)
+ {
+ uschar * name = dns_build_reverse(sender_host_address);
+
+ dns_init(FALSE, FALSE, FALSE); /* dnssec ctrl by dns_dnssec_ok glbl */
+ rc = dns_lookup_timerwrap(dnsa, name, T_PTR, NULL);
+
+ /* The first record we come across is used for the name; others are
+ considered to be aliases. We have to scan twice, in order to find out the
+ number of aliases. However, if all the names are empty, we will behave as
+ if failure. (PTR records that yield empty names have been encountered in
+ the DNS.) */
+
+ if (rc == DNS_SUCCEED)
+ {
+ uschar **aptr = NULL;
+ int ssize = 264;
+ int count = 0;
+ int old_pool = store_pool;
+
+ sender_host_dnssec = dns_is_secure(dnsa);
+ DEBUG(D_dns)
+ debug_printf("Reverse DNS security status: %s\n",
+ sender_host_dnssec ? "DNSSEC verified (AD)" : "unverified");
+
+ store_pool = POOL_PERM; /* Save names in permanent storage */
+
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_PTR)
+ count++;
+
+ /* Get store for the list of aliases. For compatibility with
+ gethostbyaddr, we make an empty list if there are none. */
+
+ aptr = sender_host_aliases = store_get(count * sizeof(uschar *), FALSE);
+
+ /* Re-scan and extract the names */
+
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == T_PTR)
+ {
+ uschar * s = store_get(ssize, TRUE); /* names are tainted */
+
+ /* If an overlong response was received, the data will have been
+ truncated and dn_expand may fail. */
+
+ if (dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen,
+ US (rr->data), (DN_EXPAND_ARG4_TYPE)(s), ssize) < 0)
+ {
+ log_write(0, LOG_MAIN, "host name alias list truncated for %s",
+ sender_host_address);
+ break;
+ }
+
+ store_release_above(s + Ustrlen(s) + 1);
+ if (!s[0])
+ {
+ HDEBUG(D_host_lookup) debug_printf("IP address lookup yielded an "
+ "empty name: treated as non-existent host name\n");
+ continue;
+ }
+ if (!sender_host_name) sender_host_name = s;
+ else *aptr++ = s;
+ while (*s) { *s = tolower(*s); s++; }
+ }
+
+ *aptr = NULL; /* End of alias list */
+ store_pool = old_pool; /* Reset store pool */
+
+ /* If we've found a name, break out of the "order" loop */
+
+ if (sender_host_name) break;
+ }
+
+ /* If the DNS lookup deferred, we must also defer. */
+
+ if (rc == DNS_AGAIN)
+ {
+ HDEBUG(D_host_lookup)
+ debug_printf("IP address PTR lookup gave temporary error\n");
+ host_lookup_deferred = TRUE;
+ return DEFER;
+ }
+ }
+
+ /* Do a lookup using gethostbyaddr() - or equivalent */
+
+ else if (strcmpic(ordername, US"byaddr") == 0)
+ {
+ HDEBUG(D_host_lookup)
+ debug_printf("IP address lookup using gethostbyaddr()\n");
+ rc = host_name_lookup_byaddr();
+ if (rc == DEFER)
+ {
+ host_lookup_deferred = TRUE;
+ return rc; /* Can't carry on */
+ }
+ if (rc == OK) break; /* Found a name */
+ }
+ } /* Loop for bydns/byaddr scanning */
+
+/* If we have failed to find a name, return FAIL and log when required.
+NB host_lookup_msg must be in permanent store. */
+
+if (!sender_host_name)
+ {
+ if (host_checking || !f.log_testing_mode)
+ log_write(L_host_lookup_failed, LOG_MAIN, "no host name found for IP "
+ "address %s", sender_host_address);
+ host_lookup_msg = US" (failed to find host name from IP address)";
+ host_lookup_failed = TRUE;
+ return FAIL;
+ }
+
+HDEBUG(D_host_lookup)
+ {
+ uschar **aliases = sender_host_aliases;
+ debug_printf("IP address lookup yielded \"%s\"\n", sender_host_name);
+ while (*aliases != NULL) debug_printf(" alias \"%s\"\n", *aliases++);
+ }
+
+/* We need to verify that a forward lookup on the name we found does indeed
+correspond to the address. This is for security: in principle a malefactor who
+happened to own a reverse zone could set it to point to any names at all.
+
+This code was present in versions of Exim before 3.20. At that point I took it
+out because I thought that gethostbyaddr() did the check anyway. It turns out
+that this isn't always the case, so it's coming back in at 4.01. This version
+is actually better, because it also checks aliases.
+
+The code was made more robust at release 4.21. Prior to that, it accepted all
+the names if any of them had the correct IP address. Now the code checks all
+the names, and accepts only those that have the correct IP address. */
+
+save_hostname = sender_host_name; /* Save for error messages */
+aliases = sender_host_aliases;
+for (uschar * hname = sender_host_name; hname; hname = *aliases++)
+ {
+ int rc;
+ BOOL ok = FALSE;
+ host_item h = { .next = NULL, .name = hname, .mx = MX_NONE, .address = NULL };
+ dnssec_domains d =
+ { .request = sender_host_dnssec ? US"*" : NULL, .require = NULL };
+
+ if ( (rc = host_find_bydns(&h, NULL, HOST_FIND_BY_A | HOST_FIND_BY_AAAA,
+ NULL, NULL, NULL, &d, NULL, NULL)) == HOST_FOUND
+ || rc == HOST_FOUND_LOCAL
+ )
+ {
+ HDEBUG(D_host_lookup) debug_printf("checking addresses for %s\n", hname);
+
+ /* If the forward lookup was not secure we cancel the is-secure variable */
+
+ DEBUG(D_dns) debug_printf("Forward DNS security status: %s\n",
+ h.dnssec == DS_YES ? "DNSSEC verified (AD)" : "unverified");
+ if (h.dnssec != DS_YES) sender_host_dnssec = FALSE;
+
+ for (host_item * hh = &h; hh; hh = hh->next)
+ if (host_is_in_net(hh->address, sender_host_address, 0))
+ {
+ HDEBUG(D_host_lookup) debug_printf(" %s OK\n", hh->address);
+ ok = TRUE;
+ break;
+ }
+ else
+ HDEBUG(D_host_lookup) debug_printf(" %s\n", hh->address);
+
+ if (!ok) HDEBUG(D_host_lookup)
+ debug_printf("no IP address for %s matched %s\n", hname,
+ sender_host_address);
+ }
+ else if (rc == HOST_FIND_AGAIN)
+ {
+ HDEBUG(D_host_lookup) debug_printf("temporary error for host name lookup\n");
+ host_lookup_deferred = TRUE;
+ sender_host_name = NULL;
+ return DEFER;
+ }
+ else
+ HDEBUG(D_host_lookup) debug_printf("no IP addresses found for %s\n", hname);
+
+ /* If this name is no good, and it's the sender name, set it null pro tem;
+ if it's an alias, just remove it from the list. */
+
+ if (!ok)
+ {
+ if (hname == sender_host_name) sender_host_name = NULL; else
+ {
+ uschar **a; /* Don't amalgamate - some */
+ a = --aliases; /* compilers grumble */
+ while (*a != NULL) { *a = a[1]; a++; }
+ }
+ }
+ }
+
+/* If sender_host_name == NULL, it means we didn't like the name. Replace
+it with the first alias, if there is one. */
+
+if (sender_host_name == NULL && *sender_host_aliases != NULL)
+ sender_host_name = *sender_host_aliases++;
+
+/* If we now have a main name, all is well. */
+
+if (sender_host_name != NULL) return OK;
+
+/* We have failed to find an address that matches. */
+
+HDEBUG(D_host_lookup)
+ debug_printf("%s does not match any IP address for %s\n",
+ sender_host_address, save_hostname);
+
+/* This message must be in permanent store */
+
+old_pool = store_pool;
+store_pool = POOL_PERM;
+host_lookup_msg = string_sprintf(" (%s does not match any IP address for %s)",
+ sender_host_address, save_hostname);
+store_pool = old_pool;
+host_lookup_failed = TRUE;
+return FAIL;
+}
+
+
+
+
+/*************************************************
+* Find IP address(es) for host by name *
+*************************************************/
+
+/* The input is a host_item structure with the name filled in and the address
+field set to NULL. We use gethostbyname() or getipnodebyname() or
+gethostbyname2(), as appropriate. Of course, these functions may use the DNS,
+but they do not do MX processing. It appears, however, that in some systems the
+current setting of resolver options is used when one of these functions calls
+the resolver. For this reason, we call dns_init() at the start, with arguments
+influenced by bits in "flags", just as we do for host_find_bydns().
+
+The second argument provides a host list (usually an IP list) of hosts to
+ignore. This makes it possible to ignore IPv6 link-local addresses or loopback
+addresses in unreasonable places.
+
+The lookup may result in a change of name. For compatibility with the dns
+lookup, return this via fully_qualified_name as well as updating the host item.
+The lookup may also yield more than one IP address, in which case chain on
+subsequent host_item structures.
+
+Arguments:
+ host a host item with the name and MX filled in;
+ the address is to be filled in;
+ multiple IP addresses cause other host items to be
+ chained on.
+ ignore_target_hosts a list of hosts to ignore
+ flags HOST_FIND_QUALIFY_SINGLE ) passed to
+ HOST_FIND_SEARCH_PARENTS ) dns_init()
+ fully_qualified_name if not NULL, set to point to host name for
+ compatibility with host_find_bydns
+ local_host_check TRUE if a check for the local host is wanted
+
+Returns: HOST_FIND_FAILED Failed to find the host or domain
+ HOST_FIND_AGAIN Try again later
+ HOST_FOUND Host found - data filled in
+ HOST_FOUND_LOCAL Host found and is the local host
+*/
+
+int
+host_find_byname(host_item *host, const uschar *ignore_target_hosts, int flags,
+ const uschar **fully_qualified_name, BOOL local_host_check)
+{
+int yield, times;
+host_item *last = NULL;
+BOOL temp_error = FALSE;
+int af;
+
+#ifndef DISABLE_TLS
+/* Copy the host name at this point to the value which is used for
+TLS certificate name checking, before anything modifies it. */
+
+host->certname = host->name;
+#endif
+
+/* Make sure DNS options are set as required. This appears to be necessary in
+some circumstances when the get..byname() function actually calls the DNS. */
+
+dns_init((flags & HOST_FIND_QUALIFY_SINGLE) != 0,
+ (flags & HOST_FIND_SEARCH_PARENTS) != 0,
+ FALSE); /* Cannot retrieve dnssec status so do not request */
+
+/* In an IPv6 world, unless IPv6 has been disabled, we need to scan for both
+kinds of address, so go round the loop twice. Note that we have ensured that
+AF_INET6 is defined even in an IPv4 world, which makes for slightly tidier
+code. However, if dns_ipv4_lookup matches the domain, we also just do IPv4
+lookups here (except when testing standalone). */
+
+#if HAVE_IPV6
+ #ifdef STAND_ALONE
+ if (disable_ipv6)
+ #else
+ if ( disable_ipv6
+ || dns_ipv4_lookup
+ && match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK)
+ #endif
+
+ { af = AF_INET; times = 1; }
+ else
+ { af = AF_INET6; times = 2; }
+
+/* No IPv6 support */
+
+#else /* HAVE_IPV6 */
+ af = AF_INET; times = 1;
+#endif /* HAVE_IPV6 */
+
+/* Initialize the flag that gets set for DNS syntax check errors, so that the
+interface to this function can be similar to host_find_bydns. */
+
+f.host_find_failed_syntax = FALSE;
+
+/* Loop to look up both kinds of address in an IPv6 world */
+
+for (int i = 1; i <= times;
+ #if HAVE_IPV6
+ af = AF_INET, /* If 2 passes, IPv4 on the second */
+ #endif
+ i++)
+ {
+ BOOL ipv4_addr;
+ int error_num = 0;
+ struct hostent *hostdata;
+ unsigned long time_msec = 0; /* compiler quietening */
+
+ #ifdef STAND_ALONE
+ printf("Looking up: %s\n", host->name);
+ #endif
+
+ if (slow_lookup_log) time_msec = get_time_in_ms();
+
+ #if HAVE_IPV6
+ if (f.running_in_test_harness)
+ hostdata = host_fake_gethostbyname(host->name, af, &error_num);
+ else
+ {
+ #if HAVE_GETIPNODEBYNAME
+ hostdata = getipnodebyname(CS host->name, af, 0, &error_num);
+ #else
+ hostdata = gethostbyname2(CS host->name, af);
+ error_num = h_errno;
+ #endif
+ }
+
+ #else /* not HAVE_IPV6 */
+ if (f.running_in_test_harness)
+ hostdata = host_fake_gethostbyname(host->name, af, &error_num);
+ else
+ {
+ hostdata = gethostbyname(CS host->name);
+ error_num = h_errno;
+ }
+ #endif /* HAVE_IPV6 */
+
+ if ( slow_lookup_log
+ && (time_msec = get_time_in_ms() - time_msec) > slow_lookup_log)
+ log_long_lookup(US"gethostbyname", host->name, time_msec);
+
+ if (!hostdata)
+ {
+ uschar *error;
+ switch (error_num)
+ {
+ case HOST_NOT_FOUND: error = US"HOST_NOT_FOUND"; break;
+ case TRY_AGAIN: error = US"TRY_AGAIN"; break;
+ case NO_RECOVERY: error = US"NO_RECOVERY"; break;
+ case NO_DATA: error = US"NO_DATA"; break;
+ #if NO_DATA != NO_ADDRESS
+ case NO_ADDRESS: error = US"NO_ADDRESS"; break;
+ #endif
+ default: error = US"?"; break;
+ }
+
+ DEBUG(D_host_lookup) debug_printf("%s returned %d (%s)\n",
+ f.running_in_test_harness ? "host_fake_gethostbyname" :
+ #if HAVE_IPV6
+ #if HAVE_GETIPNODEBYNAME
+ af == AF_INET6 ? "getipnodebyname(af=inet6)" : "getipnodebyname(af=inet)",
+ #else
+ af == AF_INET6 ? "gethostbyname2(af=inet6)" : "gethostbyname2(af=inet)",
+ #endif
+ #else
+ "gethostbyname",
+ #endif
+ error_num, error);
+
+ if (error_num == TRY_AGAIN || error_num == NO_RECOVERY) temp_error = TRUE;
+ continue;
+ }
+ if ((hostdata->h_addr_list)[0] == NULL) continue;
+
+ /* Replace the name with the fully qualified one if necessary, and fill in
+ the fully_qualified_name pointer. */
+
+ if (hostdata->h_name[0] != 0 &&
+ Ustrcmp(host->name, hostdata->h_name) != 0)
+ host->name = string_copy_dnsdomain(US hostdata->h_name);
+ if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
+
+ /* Get the list of addresses. IPv4 and IPv6 addresses can be distinguished
+ by their different lengths. Scan the list, ignoring any that are to be
+ ignored, and build a chain from the rest. */
+
+ ipv4_addr = hostdata->h_length == sizeof(struct in_addr);
+
+ for (uschar ** addrlist = USS hostdata->h_addr_list; *addrlist; addrlist++)
+ {
+ uschar *text_address =
+ host_ntoa(ipv4_addr? AF_INET:AF_INET6, *addrlist, NULL, NULL);
+
+ #ifndef STAND_ALONE
+ if (ignore_target_hosts != NULL &&
+ verify_check_this_host(&ignore_target_hosts, NULL, host->name,
+ text_address, NULL) == OK)
+ {
+ DEBUG(D_host_lookup)
+ debug_printf("ignored host %s [%s]\n", host->name, text_address);
+ continue;
+ }
+ #endif
+
+ /* If this is the first address, last == NULL and we put the data in the
+ original block. */
+
+ if (last == NULL)
+ {
+ host->address = text_address;
+ host->port = PORT_NONE;
+ host->status = hstatus_unknown;
+ host->why = hwhy_unknown;
+ host->dnssec = DS_UNK;
+ last = host;
+ }
+
+ /* Else add further host item blocks for any other addresses, keeping
+ the order. */
+
+ else
+ {
+ host_item *next = store_get(sizeof(host_item), FALSE);
+ next->name = host->name;
+#ifndef DISABLE_TLS
+ next->certname = host->certname;
+#endif
+ next->mx = host->mx;
+ next->address = text_address;
+ next->port = PORT_NONE;
+ next->status = hstatus_unknown;
+ next->why = hwhy_unknown;
+ next->dnssec = DS_UNK;
+ next->last_try = 0;
+ next->next = last->next;
+ last->next = next;
+ last = next;
+ }
+ }
+ }
+
+/* If no hosts were found, the address field in the original host block will be
+NULL. If temp_error is set, at least one of the lookups gave a temporary error,
+so we pass that back. */
+
+if (host->address == NULL)
+ {
+ uschar *msg =
+ #ifndef STAND_ALONE
+ (message_id[0] == 0 && smtp_in != NULL)?
+ string_sprintf("no IP address found for host %s (during %s)", host->name,
+ smtp_get_connection_info()) :
+ #endif
+ string_sprintf("no IP address found for host %s", host->name);
+
+ HDEBUG(D_host_lookup) debug_printf("%s\n", msg);
+ if (temp_error) goto RETURN_AGAIN;
+ if (host_checking || !f.log_testing_mode)
+ log_write(L_host_lookup_failed, LOG_MAIN, "%s", msg);
+ return HOST_FIND_FAILED;
+ }
+
+/* Remove any duplicate IP addresses, then check to see if this is the local
+host if required. */
+
+host_remove_duplicates(host, &last);
+yield = local_host_check?
+ host_scan_for_local_hosts(host, &last, NULL) : HOST_FOUND;
+
+HDEBUG(D_host_lookup)
+ {
+ if (fully_qualified_name)
+ debug_printf("fully qualified name = %s\n", *fully_qualified_name);
+ debug_printf("%s looked up these IP addresses:\n",
+ #if HAVE_IPV6
+ #if HAVE_GETIPNODEBYNAME
+ "getipnodebyname"
+ #else
+ "gethostbyname2"
+ #endif
+ #else
+ "gethostbyname"
+ #endif
+ );
+ for (const host_item * h = host; h != last->next; h = h->next)
+ debug_printf(" name=%s address=%s\n", h->name,
+ h->address ? h->address : US"<null>");
+ }
+
+/* Return the found status. */
+
+return yield;
+
+/* Handle the case when there is a temporary error. If the name matches
+dns_again_means_nonexist, return permanent rather than temporary failure. */
+
+RETURN_AGAIN:
+ {
+ #ifndef STAND_ALONE
+ int rc;
+ const uschar *save = deliver_domain;
+ deliver_domain = host->name; /* set $domain */
+ rc = match_isinlist(host->name, CUSS &dns_again_means_nonexist, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL);
+ deliver_domain = save;
+ if (rc == OK)
+ {
+ DEBUG(D_host_lookup) debug_printf("%s is in dns_again_means_nonexist: "
+ "returning HOST_FIND_FAILED\n", host->name);
+ return HOST_FIND_FAILED;
+ }
+ #endif
+ return HOST_FIND_AGAIN;
+ }
+}
+
+
+
+/*************************************************
+* Fill in a host address from the DNS *
+*************************************************/
+
+/* Given a host item, with its name, port and mx fields set, and its address
+field set to NULL, fill in its IP address from the DNS. If it is multi-homed,
+create additional host items for the additional addresses, copying all the
+other fields, and randomizing the order.
+
+On IPv6 systems, AAAA records are sought first, then A records.
+
+The host name may be changed if the DNS returns a different name - e.g. fully
+qualified or changed via CNAME. If fully_qualified_name is not NULL, dns_lookup
+ensures that it points to the fully qualified name. However, this is the fully
+qualified version of the original name; if a CNAME is involved, the actual
+canonical host name may be different again, and so we get it directly from the
+relevant RR. Note that we do NOT change the mx field of the host item in this
+function as it may be called to set the addresses of hosts taken from MX
+records.
+
+Arguments:
+ host points to the host item we're filling in
+ lastptr points to pointer to last host item in a chain of
+ host items (may be updated if host is last and gets
+ extended because multihomed)
+ ignore_target_hosts list of hosts to ignore
+ allow_ip if TRUE, recognize an IP address and return it
+ fully_qualified_name if not NULL, return fully qualified name here if
+ the contents are different (i.e. it must be preset
+ to something)
+ dnssec_request if TRUE request the AD bit
+ dnssec_require if TRUE require the AD bit
+ whichrrs select ipv4, ipv6 results
+
+Returns: HOST_FIND_FAILED couldn't find A record
+ HOST_FIND_AGAIN try again later
+ HOST_FIND_SECURITY dnssec required but not acheived
+ HOST_FOUND found AAAA and/or A record(s)
+ HOST_IGNORED found, but all IPs ignored
+*/
+
+static int
+set_address_from_dns(host_item *host, host_item **lastptr,
+ const uschar *ignore_target_hosts, BOOL allow_ip,
+ const uschar **fully_qualified_name,
+ BOOL dnssec_request, BOOL dnssec_require, int whichrrs)
+{
+host_item *thishostlast = NULL; /* Indicates not yet filled in anything */
+BOOL v6_find_again = FALSE;
+BOOL dnssec_fail = FALSE;
+int i;
+
+#ifndef DISABLE_TLS
+/* Copy the host name at this point to the value which is used for
+TLS certificate name checking, before any CNAME-following modifies it. */
+
+host->certname = host->name;
+#endif
+
+/* If allow_ip is set, a name which is an IP address returns that value
+as its address. This is used for MX records when allow_mx_to_ip is set, for
+those sites that feel they have to flaunt the RFC rules. */
+
+if (allow_ip && string_is_ip_address(host->name, NULL) != 0)
+ {
+ #ifndef STAND_ALONE
+ if ( ignore_target_hosts
+ && verify_check_this_host(&ignore_target_hosts, NULL, host->name,
+ host->name, NULL) == OK)
+ return HOST_IGNORED;
+ #endif
+
+ host->address = host->name;
+ return HOST_FOUND;
+ }
+
+/* On an IPv6 system, unless IPv6 is disabled, go round the loop up to twice,
+looking for AAAA records the first time. However, unless doing standalone
+testing, we force an IPv4 lookup if the domain matches dns_ipv4_lookup global.
+On an IPv4 system, go round the loop once only, looking only for A records. */
+
+#if HAVE_IPV6
+ #ifndef STAND_ALONE
+ if ( disable_ipv6
+ || !(whichrrs & HOST_FIND_BY_AAAA)
+ || dns_ipv4_lookup
+ && match_isinlist(host->name, CUSS &dns_ipv4_lookup, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK
+ )
+ i = 0; /* look up A records only */
+ else
+ #endif /* STAND_ALONE */
+
+ i = 1; /* look up AAAA and A records */
+
+/* The IPv4 world */
+
+#else /* HAVE_IPV6 */
+ i = 0; /* look up A records only */
+#endif /* HAVE_IPV6 */
+
+for (; i >= 0; i--)
+ {
+ static int types[] = { T_A, T_AAAA };
+ int type = types[i];
+ int randoffset = i == (whichrrs & HOST_FIND_IPV4_FIRST ? 1 : 0)
+ ? 500 : 0; /* Ensures v6/4 sort order */
+ dns_answer * dnsa = store_get_dns_answer();
+ dns_scan dnss;
+
+ int rc = dns_lookup_timerwrap(dnsa, host->name, type, fully_qualified_name);
+ lookup_dnssec_authenticated = !dnssec_request ? NULL
+ : dns_is_secure(dnsa) ? US"yes" : US"no";
+
+ DEBUG(D_dns)
+ if ( (dnssec_request || dnssec_require)
+ && !dns_is_secure(dnsa)
+ && dns_is_aa(dnsa)
+ )
+ debug_printf("DNS lookup of %.256s (A/AAAA) requested AD, but got AA\n", host->name);
+
+ /* We want to return HOST_FIND_AGAIN if one of the A or AAAA lookups
+ fails or times out, but not if another one succeeds. (In the early
+ IPv6 days there are name servers that always fail on AAAA, but are happy
+ to give out an A record. We want to proceed with that A record.) */
+
+ if (rc != DNS_SUCCEED)
+ {
+ if (i == 0) /* Just tried for an A record, i.e. end of loop */
+ {
+ if (host->address != NULL) return HOST_FOUND; /* AAAA was found */
+ if (rc == DNS_AGAIN || rc == DNS_FAIL || v6_find_again)
+ return HOST_FIND_AGAIN;
+ return HOST_FIND_FAILED; /* DNS_NOMATCH or DNS_NODATA */
+ }
+
+ /* Tried for an AAAA record: remember if this was a temporary
+ error, and look for the next record type. */
+
+ if (rc != DNS_NOMATCH && rc != DNS_NODATA) v6_find_again = TRUE;
+ continue;
+ }
+
+ if (dnssec_request)
+ {
+ if (dns_is_secure(dnsa))
+ {
+ DEBUG(D_host_lookup) debug_printf("%s A DNSSEC\n", host->name);
+ if (host->dnssec == DS_UNK) /* set in host_find_bydns() */
+ host->dnssec = DS_YES;
+ }
+ else
+ {
+ if (dnssec_require)
+ {
+ dnssec_fail = TRUE;
+ DEBUG(D_host_lookup) debug_printf("dnssec fail on %s for %.256s",
+ i>0 ? "AAAA" : "A", host->name);
+ continue;
+ }
+ if (host->dnssec == DS_YES) /* set in host_find_bydns() */
+ {
+ DEBUG(D_host_lookup) debug_printf("%s A cancel DNSSEC\n", host->name);
+ host->dnssec = DS_NO;
+ lookup_dnssec_authenticated = US"no";
+ }
+ }
+ }
+
+ /* Lookup succeeded: fill in the given host item with the first non-ignored
+ address found; create additional items for any others. A single A6 record
+ may generate more than one address. The lookup had a chance to update the
+ fqdn; we do not want any later times round the loop to do so. */
+
+ fully_qualified_name = NULL;
+
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == type)
+ {
+ dns_address * da = dns_address_from_rr(dnsa, rr);
+
+ DEBUG(D_host_lookup)
+ if (!da) debug_printf("no addresses extracted from A6 RR for %s\n",
+ host->name);
+
+ /* This loop runs only once for A and AAAA records, but may run
+ several times for an A6 record that generated multiple addresses. */
+
+ for (; da; da = da->next)
+ {
+ #ifndef STAND_ALONE
+ if (ignore_target_hosts != NULL &&
+ verify_check_this_host(&ignore_target_hosts, NULL,
+ host->name, da->address, NULL) == OK)
+ {
+ DEBUG(D_host_lookup)
+ debug_printf("ignored host %s [%s]\n", host->name, da->address);
+ continue;
+ }
+ #endif
+
+ /* If this is the first address, stick it in the given host block,
+ and change the name if the returned RR has a different name. */
+
+ if (thishostlast == NULL)
+ {
+ if (strcmpic(host->name, rr->name) != 0)
+ host->name = string_copy_dnsdomain(rr->name);
+ host->address = da->address;
+ host->sort_key = host->mx * 1000 + random_number(500) + randoffset;
+ host->status = hstatus_unknown;
+ host->why = hwhy_unknown;
+ thishostlast = host;
+ }
+
+ /* Not the first address. Check for, and ignore, duplicates. Then
+ insert in the chain at a random point. */
+
+ else
+ {
+ int new_sort_key;
+ host_item *next;
+
+ /* End of our local chain is specified by "thishostlast". */
+
+ for (next = host;; next = next->next)
+ {
+ if (Ustrcmp(CS da->address, next->address) == 0) break;
+ if (next == thishostlast) { next = NULL; break; }
+ }
+ if (next != NULL) continue; /* With loop for next address */
+
+ /* Not a duplicate */
+
+ new_sort_key = host->mx * 1000 + random_number(500) + randoffset;
+ next = store_get(sizeof(host_item), FALSE);
+
+ /* New address goes first: insert the new block after the first one
+ (so as not to disturb the original pointer) but put the new address
+ in the original block. */
+
+ if (new_sort_key < host->sort_key)
+ {
+ *next = *host; /* Copies port */
+ host->next = next;
+ host->address = da->address;
+ host->sort_key = new_sort_key;
+ if (thishostlast == host) thishostlast = next; /* Local last */
+ if (*lastptr == host) *lastptr = next; /* Global last */
+ }
+
+ /* Otherwise scan down the addresses for this host to find the
+ one to insert after. */
+
+ else
+ {
+ host_item *h = host;
+ while (h != thishostlast)
+ {
+ if (new_sort_key < h->next->sort_key) break;
+ h = h->next;
+ }
+ *next = *h; /* Copies port */
+ h->next = next;
+ next->address = da->address;
+ next->sort_key = new_sort_key;
+ if (h == thishostlast) thishostlast = next; /* Local last */
+ if (h == *lastptr) *lastptr = next; /* Global last */
+ }
+ }
+ }
+ }
+ }
+
+/* Control gets here only if the second lookup (the A record) succeeded.
+However, the address may not be filled in if it was ignored. */
+
+return host->address
+ ? HOST_FOUND
+ : dnssec_fail
+ ? HOST_FIND_SECURITY
+ : HOST_IGNORED;
+}
+
+
+
+
+/*************************************************
+* Find IP addresses and host names via DNS *
+*************************************************/
+
+/* The input is a host_item structure with the name field filled in and the
+address field set to NULL. This may be in a chain of other host items. The
+lookup may result in more than one IP address, in which case we must created
+new host blocks for the additional addresses, and insert them into the chain.
+The original name may not be fully qualified. Use the fully_qualified_name
+argument to return the official name, as returned by the resolver.
+
+Arguments:
+ host point to initial host item
+ ignore_target_hosts a list of hosts to ignore
+ whichrrs flags indicating which RRs to look for:
+ HOST_FIND_BY_SRV => look for SRV
+ HOST_FIND_BY_MX => look for MX
+ HOST_FIND_BY_A => look for A
+ HOST_FIND_BY_AAAA => look for AAAA
+ also flags indicating how the lookup is done
+ HOST_FIND_QUALIFY_SINGLE ) passed to the
+ HOST_FIND_SEARCH_PARENTS ) resolver
+ HOST_FIND_IPV4_FIRST => reverse usual result ordering
+ HOST_FIND_IPV4_ONLY => MX results elide ipv6
+ srv_service when SRV used, the service name
+ srv_fail_domains DNS errors for these domains => assume nonexist
+ mx_fail_domains DNS errors for these domains => assume nonexist
+ dnssec_d.request => make dnssec request: domainlist
+ dnssec_d.require => ditto and nonexist failures
+ fully_qualified_name if not NULL, return fully-qualified name
+ removed set TRUE if local host was removed from the list
+
+Returns: HOST_FIND_FAILED Failed to find the host or domain;
+ if there was a syntax error,
+ host_find_failed_syntax is set.
+ HOST_FIND_AGAIN Could not resolve at this time
+ HOST_FIND_SECURITY dnsssec required but not acheived
+ HOST_FOUND Host found
+ HOST_FOUND_LOCAL The lowest MX record points to this
+ machine, if MX records were found, or
+ an A record that was found contains
+ an address of the local host
+*/
+
+int
+host_find_bydns(host_item *host, const uschar *ignore_target_hosts, int whichrrs,
+ uschar *srv_service, uschar *srv_fail_domains, uschar *mx_fail_domains,
+ const dnssec_domains *dnssec_d,
+ const uschar **fully_qualified_name, BOOL *removed)
+{
+host_item *h, *last;
+int rc = DNS_FAIL;
+int ind_type = 0;
+int yield;
+dns_answer * dnsa = store_get_dns_answer();
+dns_scan dnss;
+BOOL dnssec_require = dnssec_d
+ && match_isinlist(host->name, CUSS &dnssec_d->require,
+ 0, &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK;
+BOOL dnssec_request = dnssec_require
+ || ( dnssec_d
+ && match_isinlist(host->name, CUSS &dnssec_d->request,
+ 0, &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) == OK);
+dnssec_status_t dnssec;
+
+/* Set the default fully qualified name to the incoming name, initialize the
+resolver if necessary, set up the relevant options, and initialize the flag
+that gets set for DNS syntax check errors. */
+
+if (fully_qualified_name != NULL) *fully_qualified_name = host->name;
+dns_init((whichrrs & HOST_FIND_QUALIFY_SINGLE) != 0,
+ (whichrrs & HOST_FIND_SEARCH_PARENTS) != 0,
+ dnssec_request);
+f.host_find_failed_syntax = FALSE;
+
+/* First, if requested, look for SRV records. The service name is given; we
+assume TCP protocol. DNS domain names are constrained to a maximum of 256
+characters, so the code below should be safe. */
+
+if (whichrrs & HOST_FIND_BY_SRV)
+ {
+ gstring * g;
+ uschar * temp_fully_qualified_name;
+ int prefix_length;
+
+ g = string_fmt_append(NULL, "_%s._tcp.%n%.256s",
+ srv_service, &prefix_length, host->name);
+ temp_fully_qualified_name = string_from_gstring(g);
+ ind_type = T_SRV;
+
+ /* Search for SRV records. If the fully qualified name is different to
+ the input name, pass back the new original domain, without the prepended
+ magic. */
+
+ dnssec = DS_UNK;
+ lookup_dnssec_authenticated = NULL;
+ rc = dns_lookup_timerwrap(dnsa, temp_fully_qualified_name, ind_type,
+ CUSS &temp_fully_qualified_name);
+
+ DEBUG(D_dns)
+ if ((dnssec_request || dnssec_require)
+ && !dns_is_secure(dnsa)
+ && dns_is_aa(dnsa))
+ debug_printf("DNS lookup of %.256s (SRV) requested AD, but got AA\n", host->name);
+
+ if (dnssec_request)
+ {
+ if (dns_is_secure(dnsa))
+ { dnssec = DS_YES; lookup_dnssec_authenticated = US"yes"; }
+ else
+ { dnssec = DS_NO; lookup_dnssec_authenticated = US"no"; }
+ }
+
+ if (temp_fully_qualified_name != g->s && fully_qualified_name != NULL)
+ *fully_qualified_name = temp_fully_qualified_name + prefix_length;
+
+ /* On DNS failures, we give the "try again" error unless the domain is
+ listed as one for which we continue. */
+
+ if (rc == DNS_SUCCEED && dnssec_require && !dns_is_secure(dnsa))
+ {
+ log_write(L_host_lookup_failed, LOG_MAIN,
+ "dnssec fail on SRV for %.256s", host->name);
+ rc = DNS_FAIL;
+ }
+ if (rc == DNS_FAIL || rc == DNS_AGAIN)
+ {
+#ifndef STAND_ALONE
+ if (match_isinlist(host->name, CUSS &srv_fail_domains, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
+#endif
+ { yield = HOST_FIND_AGAIN; goto out; }
+ DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
+ "(domain in srv_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
+ }
+ }
+
+/* If we did not find any SRV records, search the DNS for MX records, if
+requested to do so. If the result is DNS_NOMATCH, it means there is no such
+domain, and there's no point in going on to look for address records with the
+same domain. The result will be DNS_NODATA if the domain exists but has no MX
+records. On DNS failures, we give the "try again" error unless the domain is
+listed as one for which we continue. */
+
+if (rc != DNS_SUCCEED && whichrrs & HOST_FIND_BY_MX)
+ {
+ ind_type = T_MX;
+ dnssec = DS_UNK;
+ lookup_dnssec_authenticated = NULL;
+ rc = dns_lookup_timerwrap(dnsa, host->name, ind_type, fully_qualified_name);
+
+ DEBUG(D_dns)
+ if ( (dnssec_request || dnssec_require)
+ && !dns_is_secure(dnsa)
+ && dns_is_aa(dnsa))
+ debug_printf("DNS lookup of %.256s (MX) requested AD, but got AA\n", host->name);
+
+ if (dnssec_request)
+ if (dns_is_secure(dnsa))
+ {
+ DEBUG(D_host_lookup) debug_printf("%s (MX resp) DNSSEC\n", host->name);
+ dnssec = DS_YES; lookup_dnssec_authenticated = US"yes";
+ }
+ else
+ {
+ dnssec = DS_NO; lookup_dnssec_authenticated = US"no";
+ }
+
+ switch (rc)
+ {
+ case DNS_NOMATCH:
+ yield = HOST_FIND_FAILED; goto out;
+
+ case DNS_SUCCEED:
+ if (!dnssec_require || dns_is_secure(dnsa))
+ break;
+ DEBUG(D_host_lookup)
+ debug_printf("dnssec fail on MX for %.256s", host->name);
+#ifndef STAND_ALONE
+ if (match_isinlist(host->name, CUSS &mx_fail_domains, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
+ { yield = HOST_FIND_SECURITY; goto out; }
+#endif
+ rc = DNS_FAIL;
+ /*FALLTHROUGH*/
+
+ case DNS_FAIL:
+ case DNS_AGAIN:
+#ifndef STAND_ALONE
+ if (match_isinlist(host->name, CUSS &mx_fail_domains, 0,
+ &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, NULL) != OK)
+#endif
+ { yield = HOST_FIND_AGAIN; goto out; }
+ DEBUG(D_host_lookup) debug_printf("DNS_%s treated as DNS_NODATA "
+ "(domain in mx_fail_domains)\n", (rc == DNS_FAIL)? "FAIL":"AGAIN");
+ break;
+ }
+ }
+
+/* If we haven't found anything yet, and we are requested to do so, try for an
+A or AAAA record. If we find it (or them) check to see that it isn't the local
+host. */
+
+if (rc != DNS_SUCCEED)
+ {
+ if (!(whichrrs & (HOST_FIND_BY_A | HOST_FIND_BY_AAAA)))
+ {
+ DEBUG(D_host_lookup) debug_printf("Address records are not being sought\n");
+ yield = HOST_FIND_FAILED;
+ goto out;
+ }
+
+ last = host; /* End of local chainlet */
+ host->mx = MX_NONE;
+ host->port = PORT_NONE;
+ host->dnssec = DS_UNK;
+ lookup_dnssec_authenticated = NULL;
+ rc = set_address_from_dns(host, &last, ignore_target_hosts, FALSE,
+ fully_qualified_name, dnssec_request, dnssec_require, whichrrs);
+
+ /* If one or more address records have been found, check that none of them
+ are local. Since we know the host items all have their IP addresses
+ inserted, host_scan_for_local_hosts() can only return HOST_FOUND or
+ HOST_FOUND_LOCAL. We do not need to scan for duplicate IP addresses here,
+ because set_address_from_dns() removes them. */
+
+ if (rc == HOST_FOUND)
+ rc = host_scan_for_local_hosts(host, &last, removed);
+ else
+ if (rc == HOST_IGNORED) rc = HOST_FIND_FAILED; /* No special action */
+
+ DEBUG(D_host_lookup)
+ if (host->address)
+ {
+ if (fully_qualified_name)
+ debug_printf("fully qualified name = %s\n", *fully_qualified_name);
+ for (host_item * h = host; h != last->next; h = h->next)
+ debug_printf("%s %s mx=%d sort=%d %s\n", h->name,
+ h->address ? h->address : US"<null>", h->mx, h->sort_key,
+ h->status >= hstatus_unusable ? US"*" : US"");
+ }
+
+ yield = rc;
+ goto out;
+ }
+
+/* We have found one or more MX or SRV records. Sort them according to
+precedence. Put the data for the first one into the existing host block, and
+insert new host_item blocks into the chain for the remainder. For equal
+precedences one is supposed to randomize the order. To make this happen, the
+sorting is actually done on the MX value * 1000 + a random number. This is put
+into a host field called sort_key.
+
+In the case of hosts with both IPv6 and IPv4 addresses, we want to choose the
+IPv6 address in preference. At this stage, we don't know what kind of address
+the host has. We choose a random number < 500; if later we find an A record
+first, we add 500 to the random number. Then for any other address records, we
+use random numbers in the range 0-499 for AAAA records and 500-999 for A
+records.
+
+At this point we remove any duplicates that point to the same host, retaining
+only the one with the lowest precedence. We cannot yet check for precedence
+greater than that of the local host, because that test cannot be properly done
+until the addresses have been found - an MX record may point to a name for this
+host which is not the primary hostname. */
+
+last = NULL; /* Indicates that not even the first item is filled yet */
+
+for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
+ rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)) if (rr->type == ind_type)
+ {
+ int precedence, weight;
+ int port = PORT_NONE;
+ const uschar * s = rr->data; /* MUST be unsigned for GETSHORT */
+ uschar data[256];
+
+ GETSHORT(precedence, s); /* Pointer s is advanced */
+
+ /* For MX records, we use a random "weight" which causes multiple records of
+ the same precedence to sort randomly. */
+
+ if (ind_type == T_MX)
+ weight = random_number(500);
+ else
+ {
+ /* SRV records are specified with a port and a weight. The weight is used
+ in a special algorithm. However, to start with, we just use it to order the
+ records of equal priority (precedence). */
+ GETSHORT(weight, s);
+ GETSHORT(port, s);
+ }
+
+ /* Get the name of the host pointed to. */
+
+ (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, s,
+ (DN_EXPAND_ARG4_TYPE)data, sizeof(data));
+
+ /* Check that we haven't already got this host on the chain; if we have,
+ keep only the lower precedence. This situation shouldn't occur, but you
+ never know what junk might get into the DNS (and this case has been seen on
+ more than one occasion). */
+
+ if (last) /* This is not the first record */
+ {
+ host_item *prev = NULL;
+
+ for (h = host; h != last->next; prev = h, h = h->next)
+ if (strcmpic(h->name, data) == 0)
+ {
+ DEBUG(D_host_lookup)
+ debug_printf("discarded duplicate host %s (MX=%d)\n", data,
+ precedence > h->mx ? precedence : h->mx);
+ if (precedence >= h->mx) goto NEXT_MX_RR; /* Skip greater precedence */
+ if (h == host) /* Override first item */
+ {
+ h->mx = precedence;
+ host->sort_key = precedence * 1000 + weight;
+ goto NEXT_MX_RR;
+ }
+
+ /* Unwanted host item is not the first in the chain, so we can get
+ get rid of it by cutting it out. */
+
+ prev->next = h->next;
+ if (h == last) last = prev;
+ break;
+ }
+ }
+
+ /* If this is the first MX or SRV record, put the data into the existing host
+ block. Otherwise, add a new block in the correct place; if it has to be
+ before the first block, copy the first block's data to a new second block. */
+
+ if (!last)
+ {
+ host->name = string_copy_dnsdomain(data);
+ host->address = NULL;
+ host->port = port;
+ host->mx = precedence;
+ host->sort_key = precedence * 1000 + weight;
+ host->status = hstatus_unknown;
+ host->why = hwhy_unknown;
+ host->dnssec = dnssec;
+ last = host;
+ }
+ else
+
+ /* Make a new host item and seek the correct insertion place */
+ {
+ int sort_key = precedence * 1000 + weight;
+ host_item *next = store_get(sizeof(host_item), FALSE);
+ next->name = string_copy_dnsdomain(data);
+ next->address = NULL;
+ next->port = port;
+ next->mx = precedence;
+ next->sort_key = sort_key;
+ next->status = hstatus_unknown;
+ next->why = hwhy_unknown;
+ next->dnssec = dnssec;
+ next->last_try = 0;
+
+ /* Handle the case when we have to insert before the first item. */
+
+ if (sort_key < host->sort_key)
+ {
+ host_item htemp;
+ htemp = *host;
+ *host = *next;
+ *next = htemp;
+ host->next = next;
+ if (last == host) last = next;
+ }
+ else
+
+ /* Else scan down the items we have inserted as part of this exercise;
+ don't go further. */
+ {
+ for (h = host; h != last; h = h->next)
+ if (sort_key < h->next->sort_key)
+ {
+ next->next = h->next;
+ h->next = next;
+ break;
+ }
+
+ /* Join on after the last host item that's part of this
+ processing if we haven't stopped sooner. */
+
+ if (h == last)
+ {
+ next->next = last->next;
+ last->next = next;
+ last = next;
+ }
+ }
+ }
+
+ NEXT_MX_RR: continue;
+ }
+
+if (!last) /* No rr of correct type; give up */
+ {
+ yield = HOST_FIND_FAILED;
+ goto out;
+ }
+
+/* If the list of hosts was obtained from SRV records, there are two things to
+do. First, if there is only one host, and it's name is ".", it means there is
+no SMTP service at this domain. Otherwise, we have to sort the hosts of equal
+priority according to their weights, using an algorithm that is defined in RFC
+2782. The hosts are currently sorted by priority and weight. For each priority
+group we have to pick off one host and put it first, and then repeat for any
+remaining in the same priority group. */
+
+if (ind_type == T_SRV)
+ {
+ host_item ** pptr;
+
+ if (host == last && host->name[0] == 0)
+ {
+ DEBUG(D_host_lookup) debug_printf("the single SRV record is \".\"\n");
+ yield = HOST_FIND_FAILED;
+ goto out;
+ }
+
+ DEBUG(D_host_lookup)
+ {
+ debug_printf("original ordering of hosts from SRV records:\n");
+ for (h = host; h != last->next; h = h->next)
+ debug_printf(" %s P=%d W=%d\n", h->name, h->mx, h->sort_key % 1000);
+ }
+
+ for (pptr = &host, h = host; h != last; pptr = &h->next, h = h->next)
+ {
+ int sum = 0;
+ host_item *hh;
+
+ /* Find the last following host that has the same precedence. At the same
+ time, compute the sum of the weights and the running totals. These can be
+ stored in the sort_key field. */
+
+ for (hh = h; hh != last; hh = hh->next)
+ {
+ int weight = hh->sort_key % 1000; /* was precedence * 1000 + weight */
+ sum += weight;
+ hh->sort_key = sum;
+ if (hh->mx != hh->next->mx) break;
+ }
+
+ /* If there's more than one host at this precedence (priority), we need to
+ pick one to go first. */
+
+ if (hh != h)
+ {
+ host_item *hhh;
+ host_item **ppptr;
+ int randomizer = random_number(sum + 1);
+
+ for (ppptr = pptr, hhh = h;
+ hhh != hh;
+ ppptr = &hhh->next, hhh = hhh->next)
+ if (hhh->sort_key >= randomizer)
+ break;
+
+ /* hhh now points to the host that should go first; ppptr points to the
+ place that points to it. Unfortunately, if the start of the minilist is
+ the start of the entire list, we can't just swap the items over, because
+ we must not change the value of host, since it is passed in from outside.
+ One day, this could perhaps be changed.
+
+ The special case is fudged by putting the new item *second* in the chain,
+ and then transferring the data between the first and second items. We
+ can't just swap the first and the chosen item, because that would mean
+ that an item with zero weight might no longer be first. */
+
+ if (hhh != h)
+ {
+ *ppptr = hhh->next; /* Cuts it out of the chain */
+
+ if (h == host)
+ {
+ host_item temp = *h;
+ *h = *hhh;
+ *hhh = temp;
+ hhh->next = temp.next;
+ h->next = hhh;
+ }
+ else
+ {
+ hhh->next = h; /* The rest of the chain follows it */
+ *pptr = hhh; /* It takes the place of h */
+ h = hhh; /* It's now the start of this minilist */
+ }
+ }
+ }
+
+ /* A host has been chosen to be first at this priority and h now points
+ to this host. There may be others at the same priority, or others at a
+ different priority. Before we leave this host, we need to put back a sort
+ key of the traditional MX kind, in case this host is multihomed, because
+ the sort key is used for ordering the multiple IP addresses. We do not need
+ to ensure that these new sort keys actually reflect the order of the hosts,
+ however. */
+
+ h->sort_key = h->mx * 1000 + random_number(500);
+ } /* Move on to the next host */
+ }
+
+/* Now we have to find IP addresses for all the hosts. We have ensured above
+that the names in all the host items are unique. Before release 4.61 we used to
+process records from the additional section in the DNS packet that returned the
+MX or SRV records. However, a DNS name server is free to drop any resource
+records from the additional section. In theory, this has always been a
+potential problem, but it is exacerbated by the advent of IPv6. If a host had
+several IPv4 addresses and some were not in the additional section, at least
+Exim would try the others. However, if a host had both IPv4 and IPv6 addresses
+and all the IPv4 (say) addresses were absent, Exim would try only for a IPv6
+connection, and never try an IPv4 address. When there was only IPv4
+connectivity, this was a disaster that did in practice occur.
+
+So, from release 4.61 onwards, we always search for A and AAAA records
+explicitly. The names shouldn't point to CNAMES, but we use the general lookup
+function that handles them, just in case. If any lookup gives a soft error,
+change the default yield.
+
+For these DNS lookups, we must disable qualify_single and search_parents;
+otherwise invalid host names obtained from MX or SRV records can cause trouble
+if they happen to match something local. */
+
+yield = HOST_FIND_FAILED; /* Default yield */
+dns_init(FALSE, FALSE, /* Disable qualify_single and search_parents */
+ dnssec_request || dnssec_require);
+
+for (h = host; h != last->next; h = h->next)
+ {
+ if (h->address) continue; /* Inserted by a multihomed host */
+
+ rc = set_address_from_dns(h, &last, ignore_target_hosts, allow_mx_to_ip,
+ NULL, dnssec_request, dnssec_require,
+ whichrrs & HOST_FIND_IPV4_ONLY
+ ? HOST_FIND_BY_A : HOST_FIND_BY_A | HOST_FIND_BY_AAAA);
+ if (rc != HOST_FOUND)
+ {
+ h->status = hstatus_unusable;
+ switch (rc)
+ {
+ case HOST_FIND_AGAIN: yield = rc; h->why = hwhy_deferred; break;
+ case HOST_FIND_SECURITY: yield = rc; h->why = hwhy_insecure; break;
+ case HOST_IGNORED: h->why = hwhy_ignored; break;
+ default: h->why = hwhy_failed; break;
+ }
+ }
+ }
+
+/* Scan the list for any hosts that are marked unusable because they have
+been explicitly ignored, and remove them from the list, as if they did not
+exist. If we end up with just a single, ignored host, flatten its fields as if
+nothing was found. */
+
+if (ignore_target_hosts)
+ {
+ host_item *prev = NULL;
+ for (h = host; h != last->next; h = h->next)
+ {
+ REDO:
+ if (h->why != hwhy_ignored) /* Non ignored host, just continue */
+ prev = h;
+ else if (prev == NULL) /* First host is ignored */
+ {
+ if (h != last) /* First is not last */
+ {
+ if (h->next == last) last = h; /* Overwrite it with next */
+ *h = *(h->next); /* and reprocess it. */
+ goto REDO; /* C should have redo, like Perl */
+ }
+ }
+ else /* Ignored host is not first - */
+ { /* cut it out */
+ prev->next = h->next;
+ if (h == last) last = prev;
+ }
+ }
+
+ if (host->why == hwhy_ignored) host->address = NULL;
+ }
+
+/* There is still one complication in the case of IPv6. Although the code above
+arranges that IPv6 addresses take precedence over IPv4 addresses for multihomed
+hosts, it doesn't do this for addresses that apply to different hosts with the
+same MX precedence, because the sorting on MX precedence happens first. So we
+have to make another pass to check for this case. We ensure that, within a
+single MX preference value, IPv6 addresses come first. This can separate the
+addresses of a multihomed host, but that should not matter. */
+
+#if HAVE_IPV6
+if (h != last && !disable_ipv6) for (h = host; h != last; h = h->next)
+ {
+ host_item temp;
+ host_item *next = h->next;
+
+ if ( h->mx != next->mx /* If next is different MX */
+ || !h->address /* OR this one is unset */
+ )
+ continue; /* move on to next */
+
+ if ( whichrrs & HOST_FIND_IPV4_FIRST
+ ? !Ustrchr(h->address, ':') /* OR this one is IPv4 */
+ || next->address
+ && Ustrchr(next->address, ':') /* OR next is IPv6 */
+
+ : Ustrchr(h->address, ':') /* OR this one is IPv6 */
+ || next->address
+ && !Ustrchr(next->address, ':') /* OR next is IPv4 */
+ )
+ continue; /* move on to next */
+
+ temp = *h; /* otherwise, swap */
+ temp.next = next->next;
+ *h = *next;
+ h->next = next;
+ *next = temp;
+ }
+#endif
+
+/* Remove any duplicate IP addresses and then scan the list of hosts for any
+whose IP addresses are on the local host. If any are found, all hosts with the
+same or higher MX values are removed. However, if the local host has the lowest
+numbered MX, then HOST_FOUND_LOCAL is returned. Otherwise, if at least one host
+with an IP address is on the list, HOST_FOUND is returned. Otherwise,
+HOST_FIND_FAILED is returned, but in this case do not update the yield, as it
+might have been set to HOST_FIND_AGAIN just above here. If not, it will already
+be HOST_FIND_FAILED. */
+
+host_remove_duplicates(host, &last);
+rc = host_scan_for_local_hosts(host, &last, removed);
+if (rc != HOST_FIND_FAILED) yield = rc;
+
+DEBUG(D_host_lookup)
+ {
+ if (fully_qualified_name)
+ debug_printf("fully qualified name = %s\n", *fully_qualified_name);
+ debug_printf("host_find_bydns yield = %s (%d); returned hosts:\n",
+ yield == HOST_FOUND ? "HOST_FOUND" :
+ yield == HOST_FOUND_LOCAL ? "HOST_FOUND_LOCAL" :
+ yield == HOST_FIND_SECURITY ? "HOST_FIND_SECURITY" :
+ yield == HOST_FIND_AGAIN ? "HOST_FIND_AGAIN" :
+ yield == HOST_FIND_FAILED ? "HOST_FIND_FAILED" : "?",
+ yield);
+ for (h = host; h != last->next; h = h->next)
+ {
+ debug_printf(" %s %s MX=%d %s", h->name,
+ !h->address ? US"<null>" : h->address, h->mx,
+ h->dnssec == DS_YES ? US"DNSSEC " : US"");
+ if (h->port != PORT_NONE) debug_printf("port=%d ", h->port);
+ if (h->status >= hstatus_unusable) debug_printf("*");
+ debug_printf("\n");
+ }
+ }
+
+out:
+
+dns_init(FALSE, FALSE, FALSE); /* clear the dnssec bit for getaddrbyname */
+return yield;
+}
+
+
+
+
+#ifdef SUPPORT_DANE
+/* Lookup TLSA record for host/port.
+Return: OK success with dnssec; DANE mode
+ DEFER Do not use this host now, may retry later
+ FAIL_FORCED No TLSA record; DANE not usable
+ FAIL Do not use this connection
+*/
+
+int
+tlsa_lookup(const host_item * host, dns_answer * dnsa, BOOL dane_required)
+{
+uschar buffer[300];
+const uschar * fullname = buffer;
+int rc;
+BOOL sec;
+
+/* TLSA lookup string */
+(void)sprintf(CS buffer, "_%d._tcp.%.256s", host->port, host->name);
+
+rc = dns_lookup_timerwrap(dnsa, buffer, T_TLSA, &fullname);
+sec = dns_is_secure(dnsa);
+DEBUG(D_transport)
+ debug_printf("TLSA lookup ret %d %sDNSSEC\n", rc, sec ? "" : "not ");
+
+switch (rc)
+ {
+ case DNS_AGAIN:
+ return DEFER; /* just defer this TLS'd conn */
+
+ case DNS_SUCCEED:
+ if (sec)
+ {
+ DEBUG(D_transport)
+ {
+ dns_scan dnss;
+ for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
+ rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
+ if (rr->type == T_TLSA && rr->size > 3)
+ {
+ uint16_t payload_length = rr->size - 3;
+ uschar s[MAX_TLSA_EXPANDED_SIZE], * sp = s, * p = US rr->data;
+
+ sp += sprintf(CS sp, "%d ", *p++); /* usage */
+ sp += sprintf(CS sp, "%d ", *p++); /* selector */
+ sp += sprintf(CS sp, "%d ", *p++); /* matchtype */
+ while (payload_length-- > 0 && sp-s < (MAX_TLSA_EXPANDED_SIZE - 4))
+ sp += sprintf(CS sp, "%02x", *p++);
+
+ debug_printf(" %s\n", s);
+ }
+ }
+ return OK;
+ }
+ log_write(0, LOG_MAIN,
+ "DANE error: TLSA lookup for %s not DNSSEC", host->name);
+ /*FALLTRHOUGH*/
+
+ case DNS_NODATA: /* no TLSA RR for this lookup */
+ case DNS_NOMATCH: /* no records at all for this lookup */
+ return dane_required ? FAIL : FAIL_FORCED;
+
+ default:
+ case DNS_FAIL:
+ return dane_required ? FAIL : DEFER;
+ }
+}
+#endif /*SUPPORT_DANE*/
+
+
+
+/*************************************************
+**************************************************
+* Stand-alone test program *
+**************************************************
+*************************************************/
+
+#ifdef STAND_ALONE
+
+int main(int argc, char **cargv)
+{
+host_item h;
+int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
+BOOL byname = FALSE;
+BOOL qualify_single = TRUE;
+BOOL search_parents = FALSE;
+BOOL request_dnssec = FALSE;
+BOOL require_dnssec = FALSE;
+uschar **argv = USS cargv;
+uschar buffer[256];
+
+disable_ipv6 = FALSE;
+primary_hostname = US"";
+store_pool = POOL_MAIN;
+debug_selector = D_host_lookup|D_interface;
+debug_file = stdout;
+debug_fd = fileno(debug_file);
+
+printf("Exim stand-alone host functions test\n");
+
+host_find_interfaces();
+debug_selector = D_host_lookup | D_dns;
+
+if (argc > 1) primary_hostname = argv[1];
+
+/* So that debug level changes can be done first */
+
+dns_init(qualify_single, search_parents, FALSE);
+
+printf("Testing host lookup\n");
+printf("> ");
+while (Ufgets(buffer, 256, stdin) != NULL)
+ {
+ int rc;
+ int len = Ustrlen(buffer);
+ uschar *fully_qualified_name;
+
+ while (len > 0 && isspace(buffer[len-1])) len--;
+ buffer[len] = 0;
+
+ if (Ustrcmp(buffer, "q") == 0) break;
+
+ if (Ustrcmp(buffer, "byname") == 0) byname = TRUE;
+ else if (Ustrcmp(buffer, "no_byname") == 0) byname = FALSE;
+ else if (Ustrcmp(buffer, "a_only") == 0) whichrrs = HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
+ else if (Ustrcmp(buffer, "mx_only") == 0) whichrrs = HOST_FIND_BY_MX;
+ else if (Ustrcmp(buffer, "srv_only") == 0) whichrrs = HOST_FIND_BY_SRV;
+ else if (Ustrcmp(buffer, "srv+a") == 0)
+ whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
+ else if (Ustrcmp(buffer, "srv+mx") == 0)
+ whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX;
+ else if (Ustrcmp(buffer, "srv+mx+a") == 0)
+ whichrrs = HOST_FIND_BY_SRV | HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
+ else if (Ustrcmp(buffer, "qualify_single") == 0) qualify_single = TRUE;
+ else if (Ustrcmp(buffer, "no_qualify_single") == 0) qualify_single = FALSE;
+ else if (Ustrcmp(buffer, "search_parents") == 0) search_parents = TRUE;
+ else if (Ustrcmp(buffer, "no_search_parents") == 0) search_parents = FALSE;
+ else if (Ustrcmp(buffer, "request_dnssec") == 0) request_dnssec = TRUE;
+ else if (Ustrcmp(buffer, "no_request_dnssec") == 0) request_dnssec = FALSE;
+ else if (Ustrcmp(buffer, "require_dnssec") == 0) require_dnssec = TRUE;
+ else if (Ustrcmp(buffer, "no_require_dnssec") == 0) require_dnssec = FALSE;
+ else if (Ustrcmp(buffer, "test_harness") == 0)
+ f.running_in_test_harness = !f.running_in_test_harness;
+ else if (Ustrcmp(buffer, "ipv6") == 0) disable_ipv6 = !disable_ipv6;
+ else if (Ustrcmp(buffer, "res_debug") == 0)
+ {
+ _res.options ^= RES_DEBUG;
+ }
+ else if (Ustrncmp(buffer, "retrans", 7) == 0)
+ {
+ (void)sscanf(CS(buffer+8), "%d", &dns_retrans);
+ _res.retrans = dns_retrans;
+ }
+ else if (Ustrncmp(buffer, "retry", 5) == 0)
+ {
+ (void)sscanf(CS(buffer+6), "%d", &dns_retry);
+ _res.retry = dns_retry;
+ }
+ else
+ {
+ int flags = whichrrs;
+ dnssec_domains d;
+
+ h.name = buffer;
+ h.next = NULL;
+ h.mx = MX_NONE;
+ h.port = PORT_NONE;
+ h.status = hstatus_unknown;
+ h.why = hwhy_unknown;
+ h.address = NULL;
+
+ if (qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
+ if (search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
+
+ d.request = request_dnssec ? &h.name : NULL;
+ d.require = require_dnssec ? &h.name : NULL;
+
+ rc = byname
+ ? host_find_byname(&h, NULL, flags, &fully_qualified_name, TRUE)
+ : host_find_bydns(&h, NULL, flags, US"smtp", NULL, NULL,
+ &d, &fully_qualified_name, NULL);
+
+ switch (rc)
+ {
+ case HOST_FIND_FAILED: printf("Failed\n"); break;
+ case HOST_FIND_AGAIN: printf("Again\n"); break;
+ case HOST_FIND_SECURITY: printf("Security\n"); break;
+ case HOST_FOUND_LOCAL: printf("Local\n"); break;
+ }
+ }
+
+ printf("\n> ");
+ }
+
+printf("Testing host_aton\n");
+printf("> ");
+while (Ufgets(buffer, 256, stdin) != NULL)
+ {
+ int x[4];
+ int len = Ustrlen(buffer);
+
+ while (len > 0 && isspace(buffer[len-1])) len--;
+ buffer[len] = 0;
+
+ if (Ustrcmp(buffer, "q") == 0) break;
+
+ len = host_aton(buffer, x);
+ printf("length = %d ", len);
+ for (int i = 0; i < len; i++)
+ {
+ printf("%04x ", (x[i] >> 16) & 0xffff);
+ printf("%04x ", x[i] & 0xffff);
+ }
+ printf("\n> ");
+ }
+
+printf("\n");
+
+printf("Testing host_name_lookup\n");
+printf("> ");
+while (Ufgets(buffer, 256, stdin) != NULL)
+ {
+ int len = Ustrlen(buffer);
+ while (len > 0 && isspace(buffer[len-1])) len--;
+ buffer[len] = 0;
+ if (Ustrcmp(buffer, "q") == 0) break;
+ sender_host_address = buffer;
+ sender_host_name = NULL;
+ sender_host_aliases = NULL;
+ host_lookup_msg = US"";
+ host_lookup_failed = FALSE;
+ if (host_name_lookup() == FAIL) /* Debug causes printing */
+ printf("Lookup failed:%s\n", host_lookup_msg);
+ printf("\n> ");
+ }
+
+printf("\n");
+
+return 0;
+}
+#endif /* STAND_ALONE */
+
+/* vi: aw ai sw=2
+*/
+/* End of host.c */