src/src/routers/dnslookup.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 #include "../exim.h"
  11
  12 #ifdef ROUTER_DNSLOOKUP         /* Remainder of file */
  13 #include "rf_functions.h"
  14 #include "dnslookup.h"
  15
  16
  17
  18 /* Options specific to the dnslookup router. */
  19 #define LOFF(field) OPT_OFF(dnslookup_router_options_block, field)
  20
  21 optionlist dnslookup_router_options[] = {
  22   { "check_secondary_mx", opt_bool,             LOFF(check_secondary_mx) },
  23   { "check_srv",          opt_stringptr,        LOFF(check_srv) },
  24   { "fail_defer_domains", opt_stringptr,        LOFF(fail_defer_domains) },
  25   { "ipv4_only",          opt_stringptr,        LOFF(ipv4_only) },
  26   { "ipv4_prefer",        opt_stringptr,        LOFF(ipv4_prefer) },
  27   { "mx_domains",         opt_stringptr,        LOFF(mx_domains) },
  28   { "mx_fail_domains",    opt_stringptr,        LOFF(mx_fail_domains) },
  29   { "qualify_single",     opt_bool,             LOFF(qualify_single) },
  30   { "rewrite_headers",    opt_bool,             LOFF(rewrite_headers) },
  31   { "same_domain_copy_routing", opt_bool|opt_public, OPT_OFF(router_instance, same_domain_copy_routing) },
  32   { "search_parents",     opt_bool,             LOFF(search_parents) },
  33   { "srv_fail_domains",   opt_stringptr,        LOFF(srv_fail_domains) },
  34   { "widen_domains",      opt_stringptr,        LOFF(widen_domains) }
  35 };
  36
  37 /* Size of the options list. An extern variable has to be used so that its
  38 address can appear in the tables drtables.c. */
  39
  40 int dnslookup_router_options_count =
  41   sizeof(dnslookup_router_options)/sizeof(optionlist);
  42
  43
  44 #ifdef MACRO_PREDEF
  45
  46 /* Dummy entries */
  47 dnslookup_router_options_block dnslookup_router_option_defaults = {0};
  48 void dnslookup_router_init(router_instance *rblock) {}
  49 int dnslookup_router_entry(router_instance *rblock, address_item *addr,
  50   struct passwd *pw, int verify, address_item **addr_local,
  51   address_item **addr_remote, address_item **addr_new,
  52   address_item **addr_succeed) {return 0;}
  53
  54 #else   /*!MACRO_PREDEF*/
  55
  56
  57
  58
  59 /* Default private options block for the dnslookup router. */
  60
  61 dnslookup_router_options_block dnslookup_router_option_defaults = {
  62   .check_secondary_mx = FALSE,
  63   .qualify_single =     TRUE,
  64   .search_parents =     FALSE,
  65   .rewrite_headers =    TRUE,
  66   .widen_domains =      NULL,
  67   .mx_domains =         NULL,
  68   .mx_fail_domains =    NULL,
  69   .srv_fail_domains =   NULL,
  70   .check_srv =          NULL,
  71   .fail_defer_domains = NULL,
  72   .ipv4_only =          NULL,
  73   .ipv4_prefer =        NULL,
  74 };
  75
  76
  77
  78 /*************************************************
  79 *          Initialization entry point            *
  80 *************************************************/
  81
  82 /* Called for each instance, after its options have been read, to enable
  83 consistency checks to be done, or anything else that needs to be set up. */
  84
  85 void
  86 dnslookup_router_init(router_instance *rblock)
  87 {
  88 /*
  89 dnslookup_router_options_block *ob =
  90   (dnslookup_router_options_block *)(rblock->options_block);
  91 */
  92 rblock = rblock;
  93 }
  94
  95
  96
  97 /*************************************************
  98 *              Main entry point                  *
  99 *************************************************/
 100
 101 /* See local README for interface details. This router returns:
 102
 103 DECLINE
 104   . the domain does not exist in the DNS
 105   . MX records point to non-existent hosts (including RHS = IP address)
 106   . a single SRV record has a host name of "." (=> no service)
 107   . syntactically invalid mail domain
 108   . check_secondary_mx set, and local host not in host list
 109
 110 DEFER
 111   . lookup defer for mx_domains
 112   . timeout etc on DNS lookup
 113   . verifying the errors address caused a deferment or a big disaster such
 114       as an expansion failure (rf_get_errors_address)
 115   . expanding a headers_{add,remove} string caused a deferment or another
 116       expansion error (rf_get_munge_headers)
 117   . a problem in rf_get_transport: no transport when one is needed;
 118       failed to expand dynamic transport; failed to find dynamic transport
 119   . failure to expand or find a uid/gid (rf_get_ugid via rf_queue_add)
 120   . self = "freeze", self = "defer"
 121
 122 PASS
 123   . timeout etc on DNS lookup and pass_on_timeout set
 124   . self = "pass"
 125
 126 REROUTED
 127   . routed to local host, but name was expanded by DNS lookup, so a
 128       re-routing should take place
 129   . self = "reroute"
 130
 131   In both cases the new address will have been set up as a child
 132
 133 FAIL
 134   . self = "fail"
 135
 136 OK
 137   added address to addr_local or addr_remote, as appropriate for the
 138   type of transport; this includes the self="send" case.
 139 */
 140
 141 int
 142 dnslookup_router_entry(
 143   router_instance *rblock,        /* data for this instantiation */
 144   address_item *addr,             /* address we are working on */
 145   struct passwd *pw,              /* passwd entry after check_local_user */
 146   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
 147   address_item **addr_local,      /* add it to this if it's local */
 148   address_item **addr_remote,     /* add it to this if it's remote */
 149   address_item **addr_new,        /* put new addresses on here */
 150   address_item **addr_succeed)    /* put old address here on success */
 151 {
 152 host_item h;
 153 int rc;
 154 int widen_sep = 0;
 155 int whichrrs = HOST_FIND_BY_MX | HOST_FIND_BY_A | HOST_FIND_BY_AAAA;
 156 dnslookup_router_options_block * ob =
 157   (dnslookup_router_options_block *)(rblock->options_block);
 158 uschar * srv_service = NULL, * widen = NULL;
 159 const uschar * pre_widen = addr->domain, * post_widen = NULL;
 160 const uschar * fully_qualified_name, * listptr;
 161 uschar widen_buffer[256];
 162
 163 DEBUG(D_route)
 164   debug_printf("%s router called for %s\n  domain = %s\n",
 165     rblock->name, addr->address, addr->domain);
 166
 167 /* If an SRV check is required, expand the service name */
 168
 169 GET_OPTION("check_srv");
 170 if (ob->check_srv)
 171   if (  !(srv_service = expand_string(ob->check_srv))
 172      && !f.expand_string_forcedfail)
 173     {
 174     addr->message = string_sprintf("%s router: failed to expand \"%s\": %s",
 175       rblock->name, ob->check_srv, expand_string_message);
 176     return DEFER;
 177     }
 178   else
 179     whichrrs |= HOST_FIND_BY_SRV;
 180
 181 /* Set up the first of any widening domains. The code further down copes with
 182 either pre- or post-widening, but at present there is no way to turn on
 183 pre-widening, as actually doing so seems like a rather bad idea, and nobody has
 184 requested it. Pre-widening would cause local abbreviated names to take
 185 precedence over global names. For example, if the domain is "xxx.ch" it might
 186 be something in the "ch" toplevel domain, but it also might be xxx.ch.xyz.com.
 187 The choice of pre- or post-widening affects which takes precedence. If ever
 188 somebody comes up with some kind of requirement for pre-widening, presumably
 189 with some conditions under which it is done, it can be selected here.
 190
 191 The rewrite_headers option works only when routing an address at transport
 192 time, because the alterations to the headers are not persistent so must be
 193 worked out immediately before they are used. Sender addresses are routed for
 194 verification purposes, but never at transport time, so any header changes that
 195 you might expect as a result of sender domain widening do not occur. Therefore
 196 we do not perform widening when verifying sender addresses; however, widening
 197 sender addresses is OK if we do not have to rewrite the headers. A corollary
 198 of this is that if the current address is not the original address, then it
 199 does not appear in the message header so it is also OK to widen. The
 200 suppression of widening for sender addresses is silent because it is the
 201 normal desirable behaviour. */
 202
 203 if (  ob->widen_domains
 204    && (verify != v_sender || !ob->rewrite_headers || addr->parent))
 205   {
 206   listptr = ob->widen_domains;
 207   /* not expanded so should never be tainted */
 208   widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
 209     sizeof(widen_buffer));
 210
 211 /****
 212   if (some condition requiring pre-widening)
 213     {
 214     post_widen = pre_widen;
 215     pre_widen = NULL;
 216     }
 217 ****/
 218   }
 219
 220 /* Loop to cope with explicit widening of domains as configured. This code
 221 copes with widening that may happen before or after the original name. The
 222 decision as to which is taken above. */
 223
 224 for (;;)
 225   {
 226   int flags = whichrrs;
 227   BOOL removed = FALSE;
 228
 229   if (pre_widen)
 230     {
 231     h.name = pre_widen;
 232     pre_widen = NULL;
 233     }
 234   else if (widen)
 235     {
 236     h.name = string_sprintf("%s.%s", addr->domain, widen);
 237     /* not expanded so should never be tainted */
 238     widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
 239       sizeof(widen_buffer));
 240     DEBUG(D_route) debug_printf("%s router widened %s to %s\n", rblock->name,
 241       addr->domain, h.name);
 242     }
 243   else if (post_widen)
 244     {
 245     h.name = post_widen;
 246     post_widen = NULL;
 247     DEBUG(D_route) debug_printf("%s router trying %s after widening failed\n",
 248       rblock->name, h.name);
 249     }
 250   else return DECLINE;
 251
 252   /* Check if we must request only. or prefer, ipv4 */
 253
 254   if (  ob->ipv4_only
 255      && expand_check_condition(ob->ipv4_only, rblock->name, US"router"))
 256     flags = flags & ~HOST_FIND_BY_AAAA | HOST_FIND_IPV4_ONLY;
 257   else if (f.search_find_defer)
 258     return DEFER;
 259   if (  ob->ipv4_prefer
 260      && expand_check_condition(ob->ipv4_prefer, rblock->name, US"router"))
 261     flags |= HOST_FIND_IPV4_FIRST;
 262   else if (f.search_find_defer)
 263     return DEFER;
 264
 265   /* Set up the rest of the initial host item. Others may get chained on if
 266   there is more than one IP address. We set it up here instead of outside the
 267   loop so as to re-initialize if a previous try succeeded but was rejected
 268   because of not having an MX record. */
 269
 270   h.next = NULL;
 271   h.address = NULL;
 272   h.port = PORT_NONE;
 273   h.mx = MX_NONE;
 274   h.status = hstatus_unknown;
 275   h.why = hwhy_unknown;
 276   h.last_try = 0;
 277
 278   /* Unfortunately, we cannot set the mx_only option in advance, because the
 279   DNS lookup may extend an unqualified name. Therefore, we must do the test
 280   subsequently. We use the same logic as that for widen_domains above to avoid
 281   requesting a header rewrite that cannot work. */
 282
 283   if (verify != v_sender || !ob->rewrite_headers || addr->parent)
 284     {
 285     if (ob->qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
 286     if (ob->search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
 287     }
 288
 289   DEBUG(D_route) debug_printf_indent("main lookup for domain\n");
 290    {
 291     expand_level++;
 292     rc = host_find_bydns(&h, CUS rblock->ignore_target_hosts, flags,
 293       srv_service, ob->srv_fail_domains, ob->mx_fail_domains,
 294       &rblock->dnssec,
 295       &fully_qualified_name, &removed);
 296     expand_level--;
 297    }
 298
 299   if (removed) setflag(addr, af_local_host_removed);
 300
 301   /* If host found with only address records, test for the domain's being in
 302   the mx_domains list. Note that this applies also to SRV records; the name of
 303   the option is historical. */
 304
 305   if ((rc == HOST_FOUND || rc == HOST_FOUND_LOCAL) && h.mx < 0 &&
 306        ob->mx_domains)
 307     switch(match_isinlist(fully_qualified_name,
 308           CUSS &(ob->mx_domains), 0,
 309           &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
 310       {
 311       case DEFER:
 312       addr->message = US"lookup defer for mx_domains";
 313       return DEFER;
 314
 315       case OK:
 316       DEBUG(D_route) debug_printf("%s router rejected %s: no MX record(s)\n",
 317         rblock->name, fully_qualified_name);
 318       continue;
 319       }
 320
 321   /* Deferral returns forthwith, and anything other than failure breaks the
 322   loop. */
 323
 324   if (rc == HOST_FIND_SECURITY)
 325     {
 326     addr->message = US"host lookup done insecurely";
 327     return DEFER;
 328     }
 329   if (rc == HOST_FIND_AGAIN)
 330     {
 331     if (rblock->pass_on_timeout)
 332       {
 333       DEBUG(D_route) debug_printf("%s router timed out, and pass_on_timeout is set\n",
 334         rblock->name);
 335       return PASS;
 336       }
 337     addr->message = US"host lookup did not complete";
 338     return DEFER;
 339     }
 340
 341   if (rc != HOST_FIND_FAILED) break;
 342
 343   if (ob->fail_defer_domains)
 344     switch(match_isinlist(fully_qualified_name,
 345           CUSS &ob->fail_defer_domains, 0,
 346           &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
 347       {
 348       case DEFER:
 349         addr->message = US"lookup defer for fail_defer_domains option";
 350         return DEFER;
 351
 352       case OK:
 353         DEBUG(D_route) debug_printf("%s router: matched fail_defer_domains\n",
 354           rblock->name);
 355         addr->message = US"missing MX, or all MXs point to missing A records,"
 356           " and defer requested";
 357         return DEFER;
 358       }
 359   /* Check to see if the failure is the result of MX records pointing to
 360   non-existent domains, and if so, set an appropriate error message; the case
 361   of an MX or SRV record pointing to "." is another special case that we can
 362   detect. Otherwise "unknown mail domain" is used, which is confusing. Also, in
 363   this case don't do the widening. We need check only the first host to see if
 364   its MX has been filled in, but there is no address, because if there were any
 365   usable addresses returned, we would not have had HOST_FIND_FAILED.
 366
 367   As a common cause of this problem is MX records with IP addresses on the
 368   RHS, give a special message in this case. */
 369
 370   if (h.mx >= 0 && !h.address)
 371     {
 372     setflag(addr, af_pass_message);   /* This is not a security risk */
 373     if (h.name[0] == 0)
 374       addr->message = US"an MX or SRV record indicated no SMTP service";
 375     else
 376       {
 377       addr->basic_errno = ERRNO_UNKNOWNHOST;
 378       addr->message = US"all relevant MX records point to non-existent hosts";
 379       if (!allow_mx_to_ip && string_is_ip_address(h.name, NULL) != 0)
 380         {
 381         addr->user_message =
 382           string_sprintf("It appears that the DNS operator for %s\n"
 383             "has installed an invalid MX record with an IP address\n"
 384             "instead of a domain name on the right hand side.", addr->domain);
 385         addr->message = string_sprintf("%s or (invalidly) to IP addresses",
 386           addr->message);
 387         }
 388       }
 389     return DECLINE;
 390     }
 391
 392   /* If there's a syntax error, do not continue with any widening, and note
 393   the error. */
 394
 395   if (f.host_find_failed_syntax)
 396     {
 397     addr->message = string_sprintf("mail domain \"%s\" is syntactically "
 398       "invalid", h.name);
 399     return DECLINE;
 400     }
 401   }
 402
 403 /* If the original domain name has been changed as a result of the host lookup,
 404 set up a child address for rerouting and request header rewrites if so
 405 configured. Then yield REROUTED. However, if the only change is a change of
 406 case in the domain name, which some resolvers yield (others don't), just change
 407 the domain name in the original address so that the official version is used in
 408 RCPT commands. */
 409
 410 if (Ustrcmp(addr->domain, fully_qualified_name) != 0)
 411   {
 412   if (strcmpic(addr->domain, fully_qualified_name) == 0)
 413     {
 414     uschar *at = Ustrrchr(addr->address, '@');
 415     memcpy(at+1, fully_qualified_name, Ustrlen(at+1));
 416     }
 417   else
 418     {
 419     rf_change_domain(addr, fully_qualified_name, ob->rewrite_headers, addr_new);
 420     return REROUTED;
 421     }
 422   }
 423
 424 /* If the yield is HOST_FOUND_LOCAL, the remote domain name either found MX
 425 records with the lowest numbered one pointing to a host with an IP address that
 426 is set on one of the interfaces of this machine, or found A records or got
 427 addresses from gethostbyname() that contain one for this machine. This can
 428 happen quite legitimately if the original name was a shortened form of a
 429 domain, but we will have picked that up already via the name change test above.
 430
 431 Otherwise, the action to be taken can be configured by the self option, the
 432 handling of which is in a separate function, as it is also required for other
 433 routers. */
 434
 435 if (rc == HOST_FOUND_LOCAL)
 436   {
 437   rc = rf_self_action(addr, &h, rblock->self_code, rblock->self_rewrite,
 438     rblock->self, addr_new);
 439   if (rc != OK) return rc;
 440   }
 441
 442 /* Otherwise, insist on being a secondary MX if so configured */
 443
 444 else if (ob->check_secondary_mx && !testflag(addr, af_local_host_removed))
 445   {
 446   DEBUG(D_route) debug_printf("check_secondary_mx set and local host not secondary\n");
 447   return DECLINE;
 448   }
 449
 450 /* Set up the errors address, if any. */
 451
 452 rc = rf_get_errors_address(addr, rblock, verify, &addr->prop.errors_address);
 453 if (rc != OK) return rc;
 454
 455 /* Set up the additional and removable headers for this address. */
 456
 457 rc = rf_get_munge_headers(addr, rblock, &addr->prop.extra_headers,
 458   &addr->prop.remove_headers);
 459 if (rc != OK) return rc;
 460
 461 /* Get store in which to preserve the original host item, chained on
 462 to the address. */
 463
 464 addr->host_list = store_get(sizeof(host_item), GET_UNTAINTED);
 465 addr->host_list[0] = h;
 466
 467 /* Fill in the transport and queue the address for delivery. */
 468
 469 if (!rf_get_transport(rblock->transport_name, &(rblock->transport),
 470       addr, rblock->name, NULL))
 471   return DEFER;
 472
 473 addr->transport = rblock->transport;
 474
 475 return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
 476   OK : DEFER;
 477 }
 478
 479 #endif  /*!MACRO_PREDEF*/
 480 #endif  /*ROUTER_DNSLOOKUP*/
 481 /* End of routers/dnslookup.c */
 482 /* vi: aw ai sw=2
 483 */