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