Adding upstream version 4.94.2.upstream/4.94.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 478 insertions, 0 deletions

diff --git a/src/routers/dnslookup.c b/src/routers/dnslookup.c
new file mode 100644
index 0000000..abc41a3
--- /dev/null
+++ b/src/routers/dnslookup.c
@@ -0,0 +1,478 @@
+/*************************************************
+*     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. */
+
+#include "../exim.h"
+#include "rf_functions.h"
+#include "dnslookup.h"
+
+
+
+/* Options specific to the dnslookup router. */
+#define LOFF(field) OPT_OFF(dnslookup_router_options_block, field)
+
+optionlist dnslookup_router_options[] = {
+  { "check_secondary_mx", opt_bool,		LOFF(check_secondary_mx) },
+  { "check_srv",          opt_stringptr,	LOFF(check_srv) },
+  { "fail_defer_domains", opt_stringptr,	LOFF(fail_defer_domains) },
+  { "ipv4_only",          opt_stringptr,	LOFF(ipv4_only) },
+  { "ipv4_prefer",        opt_stringptr,	LOFF(ipv4_prefer) },
+  { "mx_domains",         opt_stringptr,	LOFF(mx_domains) },
+  { "mx_fail_domains",    opt_stringptr,	LOFF(mx_fail_domains) },
+  { "qualify_single",     opt_bool,		LOFF(qualify_single) },
+  { "rewrite_headers",    opt_bool,		LOFF(rewrite_headers) },
+  { "same_domain_copy_routing", opt_bool|opt_public, OPT_OFF(router_instance, same_domain_copy_routing) },
+  { "search_parents",     opt_bool,		LOFF(search_parents) },
+  { "srv_fail_domains",   opt_stringptr,	LOFF(srv_fail_domains) },
+  { "widen_domains",      opt_stringptr,	LOFF(widen_domains) }
+};
+
+/* Size of the options list. An extern variable has to be used so that its
+address can appear in the tables drtables.c. */
+
+int dnslookup_router_options_count =
+  sizeof(dnslookup_router_options)/sizeof(optionlist);
+
+
+#ifdef MACRO_PREDEF
+
+/* Dummy entries */
+dnslookup_router_options_block dnslookup_router_option_defaults = {0};
+void dnslookup_router_init(router_instance *rblock) {}
+int dnslookup_router_entry(router_instance *rblock, address_item *addr,
+  struct passwd *pw, int verify, address_item **addr_local,
+  address_item **addr_remote, address_item **addr_new,
+  address_item **addr_succeed) {return 0;}
+
+#else   /*!MACRO_PREDEF*/
+
+
+
+
+/* Default private options block for the dnslookup router. */
+
+dnslookup_router_options_block dnslookup_router_option_defaults = {
+  .check_secondary_mx =	FALSE,
+  .qualify_single =	TRUE,
+  .search_parents =	FALSE,
+  .rewrite_headers =	TRUE,
+  .widen_domains =	NULL,
+  .mx_domains =		NULL,
+  .mx_fail_domains =	NULL,
+  .srv_fail_domains =	NULL,
+  .check_srv =		NULL,
+  .fail_defer_domains =	NULL,
+  .ipv4_only =		NULL,
+  .ipv4_prefer =	NULL,
+};
+
+
+
+/*************************************************
+*          Initialization entry point            *
+*************************************************/
+
+/* Called for each instance, after its options have been read, to enable
+consistency checks to be done, or anything else that needs to be set up. */
+
+void
+dnslookup_router_init(router_instance *rblock)
+{
+/*
+dnslookup_router_options_block *ob =
+  (dnslookup_router_options_block *)(rblock->options_block);
+*/
+rblock = rblock;
+}
+
+
+
+/*************************************************
+*              Main entry point                  *
+*************************************************/
+
+/* See local README for interface details. This router returns:
+
+DECLINE
+  . the domain does not exist in the DNS
+  . MX records point to non-existent hosts (including RHS = IP address)
+  . a single SRV record has a host name of "." (=> no service)
+  . syntactically invalid mail domain
+  . check_secondary_mx set, and local host not in host list
+
+DEFER
+  . lookup defer for mx_domains
+  . timeout etc on DNS lookup
+  . verifying the errors address caused a deferment or a big disaster such
+      as an expansion failure (rf_get_errors_address)
+  . expanding a headers_{add,remove} string caused a deferment or another
+      expansion error (rf_get_munge_headers)
+  . a problem in rf_get_transport: no transport when one is needed;
+      failed to expand dynamic transport; failed to find dynamic transport
+  . failure to expand or find a uid/gid (rf_get_ugid via rf_queue_add)
+  . self = "freeze", self = "defer"
+
+PASS
+  . timeout etc on DNS lookup and pass_on_timeout set
+  . self = "pass"
+
+REROUTED
+  . routed to local host, but name was expanded by DNS lookup, so a
+      re-routing should take place
+  . self = "reroute"
+
+  In both cases the new address will have been set up as a child
+
+FAIL
+  . self = "fail"
+
+OK
+  added address to addr_local or addr_remote, as appropriate for the
+  type of transport; this includes the self="send" case.
+*/
+
+int
+dnslookup_router_entry(
+  router_instance *rblock,        /* data for this instantiation */
+  address_item *addr,             /* address we are working on */
+  struct passwd *pw,              /* passwd entry after check_local_user */
+  int verify,                     /* v_none/v_recipient/v_sender/v_expn */
+  address_item **addr_local,      /* add it to this if it's local */
+  address_item **addr_remote,     /* add it to this if it's remote */
+  address_item **addr_new,        /* put new addresses on here */
+  address_item **addr_succeed)    /* put old address here on success */
+{
+host_item h;
+int rc;
+int widen_sep = 0;
+int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
+dnslookup_router_options_block *ob =
+  (dnslookup_router_options_block *)(rblock->options_block);
+uschar *srv_service = NULL;
+uschar *widen = NULL;
+const uschar *pre_widen = addr->domain;
+const uschar *post_widen = NULL;
+const uschar *fully_qualified_name;
+const uschar *listptr;
+uschar widen_buffer[256];
+
+addr_new = addr_new;          /* Keep picky compilers happy */
+addr_succeed = addr_succeed;
+
+DEBUG(D_route)
+  debug_printf("%s router called for %s\n  domain = %s\n",
+    rblock->name, addr->address, addr->domain);
+
+/* If an SRV check is required, expand the service name */
+
+if (ob->check_srv)
+  {
+  if (  !(srv_service = expand_string(ob->check_srv))
+     && !f.expand_string_forcedfail)
+    {
+    addr->message = string_sprintf("%s router: failed to expand \"%s\": %s",
+      rblock->name, ob->check_srv, expand_string_message);
+    return DEFER;
+    }
+  else whichrrs |= HOST_FIND_BY_SRV;
+  }
+
+/* Set up the first of any widening domains. The code further down copes with
+either pre- or post-widening, but at present there is no way to turn on
+pre-widening, as actually doing so seems like a rather bad idea, and nobody has
+requested it. Pre-widening would cause local abbreviated names to take
+precedence over global names. For example, if the domain is "xxx.ch" it might
+be something in the "ch" toplevel domain, but it also might be xxx.ch.xyz.com.
+The choice of pre- or post-widening affects which takes precedence. If ever
+somebody comes up with some kind of requirement for pre-widening, presumably
+with some conditions under which it is done, it can be selected here.
+
+The rewrite_headers option works only when routing an address at transport
+time, because the alterations to the headers are not persistent so must be
+worked out immediately before they are used. Sender addresses are routed for
+verification purposes, but never at transport time, so any header changes that
+you might expect as a result of sender domain widening do not occur. Therefore
+we do not perform widening when verifying sender addresses; however, widening
+sender addresses is OK if we do not have to rewrite the headers. A corollary
+of this is that if the current address is not the original address, then it
+does not appear in the message header so it is also OK to widen. The
+suppression of widening for sender addresses is silent because it is the
+normal desirable behaviour. */
+
+if (  ob->widen_domains
+   && (verify != v_sender || !ob->rewrite_headers || addr->parent))
+  {
+  listptr = ob->widen_domains;
+  widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
+    sizeof(widen_buffer));
+
+/****
+  if (some condition requiring pre-widening)
+    {
+    post_widen = pre_widen;
+    pre_widen = NULL;
+    }
+****/
+  }
+
+/* Loop to cope with explicit widening of domains as configured. This code
+copes with widening that may happen before or after the original name. The
+decision as to which is taken above. */
+
+for (;;)
+  {
+  int flags = whichrrs;
+  BOOL removed = FALSE;
+
+  if (pre_widen)
+    {
+    h.name = pre_widen;
+    pre_widen = NULL;
+    }
+  else if (widen)
+    {
+    h.name = string_sprintf("%s.%s", addr->domain, widen);
+    widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
+      sizeof(widen_buffer));
+    DEBUG(D_route) debug_printf("%s router widened %s to %s\n", rblock->name,
+      addr->domain, h.name);
+    }
+  else if (post_widen)
+    {
+    h.name = post_widen;
+    post_widen = NULL;
+    DEBUG(D_route) debug_printf("%s router trying %s after widening failed\n",
+      rblock->name, h.name);
+    }
+  else return DECLINE;
+
+  /* Check if we must request only. or prefer, ipv4 */
+
+  if (  ob->ipv4_only
+     && expand_check_condition(ob->ipv4_only, rblock->name, US"router"))
+    flags = flags & ~HOST_FIND_BY_AAAA | HOST_FIND_IPV4_ONLY;
+  else if (f.search_find_defer)
+    return DEFER;
+  if (  ob->ipv4_prefer
+     && expand_check_condition(ob->ipv4_prefer, rblock->name, US"router"))
+    flags |= HOST_FIND_IPV4_FIRST;
+  else if (f.search_find_defer)
+    return DEFER;
+
+  /* Set up the rest of the initial host item. Others may get chained on if
+  there is more than one IP address. We set it up here instead of outside the
+  loop so as to re-initialize if a previous try succeeded but was rejected
+  because of not having an MX record. */
+
+  h.next = NULL;
+  h.address = NULL;
+  h.port = PORT_NONE;
+  h.mx = MX_NONE;
+  h.status = hstatus_unknown;
+  h.why = hwhy_unknown;
+  h.last_try = 0;
+
+  /* Unfortunately, we cannot set the mx_only option in advance, because the
+  DNS lookup may extend an unqualified name. Therefore, we must do the test
+  subsequently. We use the same logic as that for widen_domains above to avoid
+  requesting a header rewrite that cannot work. */
+
+  if (verify != v_sender || !ob->rewrite_headers || addr->parent)
+    {
+    if (ob->qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
+    if (ob->search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
+    }
+
+  rc = host_find_bydns(&h, CUS rblock->ignore_target_hosts, flags,
+    srv_service, ob->srv_fail_domains, ob->mx_fail_domains,
+    &rblock->dnssec,
+    &fully_qualified_name, &removed);
+
+  if (removed) setflag(addr, af_local_host_removed);
+
+  /* If host found with only address records, test for the domain's being in
+  the mx_domains list. Note that this applies also to SRV records; the name of
+  the option is historical. */
+
+  if ((rc == HOST_FOUND || rc == HOST_FOUND_LOCAL) && h.mx < 0 &&
+       ob->mx_domains)
+    switch(match_isinlist(fully_qualified_name,
+          CUSS &(ob->mx_domains), 0,
+          &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
+      {
+      case DEFER:
+      addr->message = US"lookup defer for mx_domains";
+      return DEFER;
+
+      case OK:
+      DEBUG(D_route) debug_printf("%s router rejected %s: no MX record(s)\n",
+        rblock->name, fully_qualified_name);
+      continue;
+      }
+
+  /* Deferral returns forthwith, and anything other than failure breaks the
+  loop. */
+
+  if (rc == HOST_FIND_SECURITY)
+    {
+    addr->message = US"host lookup done insecurely";
+    return DEFER;
+    }
+  if (rc == HOST_FIND_AGAIN)
+    {
+    if (rblock->pass_on_timeout)
+      {
+      DEBUG(D_route) debug_printf("%s router timed out, and pass_on_timeout is set\n",
+        rblock->name);
+      return PASS;
+      }
+    addr->message = US"host lookup did not complete";
+    return DEFER;
+    }
+
+  if (rc != HOST_FIND_FAILED) break;
+
+  if (ob->fail_defer_domains)
+    switch(match_isinlist(fully_qualified_name,
+	  CUSS &ob->fail_defer_domains, 0,
+	  &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
+      {
+      case DEFER:
+	addr->message = US"lookup defer for fail_defer_domains option";
+	return DEFER;
+
+      case OK:
+	DEBUG(D_route) debug_printf("%s router: matched fail_defer_domains\n",
+	  rblock->name);
+	addr->message = US"missing MX, or all MXs point to missing A records,"
+	  " and defer requested";
+	return DEFER;
+      }
+  /* Check to see if the failure is the result of MX records pointing to
+  non-existent domains, and if so, set an appropriate error message; the case
+  of an MX or SRV record pointing to "." is another special case that we can
+  detect. Otherwise "unknown mail domain" is used, which is confusing. Also, in
+  this case don't do the widening. We need check only the first host to see if
+  its MX has been filled in, but there is no address, because if there were any
+  usable addresses returned, we would not have had HOST_FIND_FAILED.
+
+  As a common cause of this problem is MX records with IP addresses on the
+  RHS, give a special message in this case. */
+
+  if (h.mx >= 0 && h.address == NULL)
+    {
+    setflag(addr, af_pass_message);   /* This is not a security risk */
+    if (h.name[0] == 0)
+      addr->message = US"an MX or SRV record indicated no SMTP service";
+    else
+      {
+      addr->basic_errno = ERRNO_UNKNOWNHOST;
+      addr->message = US"all relevant MX records point to non-existent hosts";
+      if (!allow_mx_to_ip && string_is_ip_address(h.name, NULL) != 0)
+        {
+        addr->user_message =
+          string_sprintf("It appears that the DNS operator for %s\n"
+            "has installed an invalid MX record with an IP address\n"
+            "instead of a domain name on the right hand side.", addr->domain);
+        addr->message = string_sprintf("%s or (invalidly) to IP addresses",
+          addr->message);
+        }
+      }
+    return DECLINE;
+    }
+
+  /* If there's a syntax error, do not continue with any widening, and note
+  the error. */
+
+  if (f.host_find_failed_syntax)
+    {
+    addr->message = string_sprintf("mail domain \"%s\" is syntactically "
+      "invalid", h.name);
+    return DECLINE;
+    }
+  }
+
+/* If the original domain name has been changed as a result of the host lookup,
+set up a child address for rerouting and request header rewrites if so
+configured. Then yield REROUTED. However, if the only change is a change of
+case in the domain name, which some resolvers yield (others don't), just change
+the domain name in the original address so that the official version is used in
+RCPT commands. */
+
+if (Ustrcmp(addr->domain, fully_qualified_name) != 0)
+  {
+  if (strcmpic(addr->domain, fully_qualified_name) == 0)
+    {
+    uschar *at = Ustrrchr(addr->address, '@');
+    memcpy(at+1, fully_qualified_name, Ustrlen(at+1));
+    }
+  else
+    {
+    rf_change_domain(addr, fully_qualified_name, ob->rewrite_headers, addr_new);
+    return REROUTED;
+    }
+  }
+
+/* If the yield is HOST_FOUND_LOCAL, the remote domain name either found MX
+records with the lowest numbered one pointing to a host with an IP address that
+is set on one of the interfaces of this machine, or found A records or got
+addresses from gethostbyname() that contain one for this machine. This can
+happen quite legitimately if the original name was a shortened form of a
+domain, but we will have picked that up already via the name change test above.
+
+Otherwise, the action to be taken can be configured by the self option, the
+handling of which is in a separate function, as it is also required for other
+routers. */
+
+if (rc == HOST_FOUND_LOCAL)
+  {
+  rc = rf_self_action(addr, &h, rblock->self_code, rblock->self_rewrite,
+    rblock->self, addr_new);
+  if (rc != OK) return rc;
+  }
+
+/* Otherwise, insist on being a secondary MX if so configured */
+
+else if (ob->check_secondary_mx && !testflag(addr, af_local_host_removed))
+  {
+  DEBUG(D_route) debug_printf("check_secondary_mx set and local host not secondary\n");
+  return DECLINE;
+  }
+
+/* Set up the errors address, if any. */
+
+rc = rf_get_errors_address(addr, rblock, verify, &addr->prop.errors_address);
+if (rc != OK) return rc;
+
+/* Set up the additional and removable headers for this address. */
+
+rc = rf_get_munge_headers(addr, rblock, &addr->prop.extra_headers,
+  &addr->prop.remove_headers);
+if (rc != OK) return rc;
+
+/* Get store in which to preserve the original host item, chained on
+to the address. */
+
+addr->host_list = store_get(sizeof(host_item), FALSE);
+addr->host_list[0] = h;
+
+/* Fill in the transport and queue the address for delivery. */
+
+if (!rf_get_transport(rblock->transport_name, &(rblock->transport),
+      addr, rblock->name, NULL))
+  return DEFER;
+
+addr->transport = rblock->transport;
+
+return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
+  OK : DEFER;
+}
+
+#endif   /*!MACRO_PREDEF*/
+/* End of routers/dnslookup.c */
+/* vi: aw ai sw=2
+*/