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-only */
   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;
 157 uschar *widen = NULL;
 158 const uschar *pre_widen = addr->domain;
 159 const uschar *post_widen = NULL;
 160 const uschar *fully_qualified_name;
 161 const uschar *listptr;
 162 uschar widen_buffer[256];
 163
 164 DEBUG(D_route)
 165   debug_printf("%s router called for %s\n  domain = %s\n",
 166     rblock->name, addr->address, addr->domain);
 167
 168 /* If an SRV check is required, expand the service name */
 169
 170 if (ob->check_srv)
 171   {
 172   if (  !(srv_service = expand_string(ob->check_srv))
 173      && !f.expand_string_forcedfail)
 174     {
 175     addr->message = string_sprintf("%s router: failed to expand \"%s\": %s",
 176       rblock->name, ob->check_srv, expand_string_message);
 177     return DEFER;
 178     }
 179   else whichrrs |= HOST_FIND_BY_SRV;
 180   }
 181
 182 /* Set up the first of any widening domains. The code further down copes with
 183 either pre- or post-widening, but at present there is no way to turn on
 184 pre-widening, as actually doing so seems like a rather bad idea, and nobody has
 185 requested it. Pre-widening would cause local abbreviated names to take
 186 precedence over global names. For example, if the domain is "xxx.ch" it might
 187 be something in the "ch" toplevel domain, but it also might be xxx.ch.xyz.com.
 188 The choice of pre- or post-widening affects which takes precedence. If ever
 189 somebody comes up with some kind of requirement for pre-widening, presumably
 190 with some conditions under which it is done, it can be selected here.
 191
 192 The rewrite_headers option works only when routing an address at transport
 193 time, because the alterations to the headers are not persistent so must be
 194 worked out immediately before they are used. Sender addresses are routed for
 195 verification purposes, but never at transport time, so any header changes that
 196 you might expect as a result of sender domain widening do not occur. Therefore
 197 we do not perform widening when verifying sender addresses; however, widening
 198 sender addresses is OK if we do not have to rewrite the headers. A corollary
 199 of this is that if the current address is not the original address, then it
 200 does not appear in the message header so it is also OK to widen. The
 201 suppression of widening for sender addresses is silent because it is the
 202 normal desirable behaviour. */
 203
 204 if (  ob->widen_domains
 205    && (verify != v_sender || !ob->rewrite_headers || addr->parent))
 206   {
 207   listptr = ob->widen_domains;
 208   /* not expanded so should never be tainted */
 209   widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
 210     sizeof(widen_buffer));
 211
 212 /****
 213   if (some condition requiring pre-widening)
 214     {
 215     post_widen = pre_widen;
 216     pre_widen = NULL;
 217     }
 218 ****/
 219   }
 220
 221 /* Loop to cope with explicit widening of domains as configured. This code
 222 copes with widening that may happen before or after the original name. The
 223 decision as to which is taken above. */
 224
 225 for (;;)
 226   {
 227   int flags = whichrrs;
 228   BOOL removed = FALSE;
 229
 230   if (pre_widen)
 231     {
 232     h.name = pre_widen;
 233     pre_widen = NULL;
 234     }
 235   else if (widen)
 236     {
 237     h.name = string_sprintf("%s.%s", addr->domain, widen);
 238     /* not expanded so should never be tainted */
 239     widen = string_nextinlist(&listptr, &widen_sep, widen_buffer,
 240       sizeof(widen_buffer));
 241     DEBUG(D_route) debug_printf("%s router widened %s to %s\n", rblock->name,
 242       addr->domain, h.name);
 243     }
 244   else if (post_widen)
 245     {
 246     h.name = post_widen;
 247     post_widen = NULL;
 248     DEBUG(D_route) debug_printf("%s router trying %s after widening failed\n",
 249       rblock->name, h.name);
 250     }
 251   else return DECLINE;
 252
 253   /* Check if we must request only. or prefer, ipv4 */
 254
 255   if (  ob->ipv4_only
 256      && expand_check_condition(ob->ipv4_only, rblock->name, US"router"))
 257     flags = flags & ~HOST_FIND_BY_AAAA | HOST_FIND_IPV4_ONLY;
 258   else if (f.search_find_defer)
 259     return DEFER;
 260   if (  ob->ipv4_prefer
 261      && expand_check_condition(ob->ipv4_prefer, rblock->name, US"router"))
 262     flags |= HOST_FIND_IPV4_FIRST;
 263   else if (f.search_find_defer)
 264     return DEFER;
 265
 266   /* Set up the rest of the initial host item. Others may get chained on if
 267   there is more than one IP address. We set it up here instead of outside the
 268   loop so as to re-initialize if a previous try succeeded but was rejected
 269   because of not having an MX record. */
 270
 271   h.next = NULL;
 272   h.address = NULL;
 273   h.port = PORT_NONE;
 274   h.mx = MX_NONE;
 275   h.status = hstatus_unknown;
 276   h.why = hwhy_unknown;
 277   h.last_try = 0;
 278
 279   /* Unfortunately, we cannot set the mx_only option in advance, because the
 280   DNS lookup may extend an unqualified name. Therefore, we must do the test
 281   subsequently. We use the same logic as that for widen_domains above to avoid
 282   requesting a header rewrite that cannot work. */
 283
 284   if (verify != v_sender || !ob->rewrite_headers || addr->parent)
 285     {
 286     if (ob->qualify_single) flags |= HOST_FIND_QUALIFY_SINGLE;
 287     if (ob->search_parents) flags |= HOST_FIND_SEARCH_PARENTS;
 288     }
 289
 290   rc = host_find_bydns(&h, CUS rblock->ignore_target_hosts, flags,
 291     srv_service, ob->srv_fail_domains, ob->mx_fail_domains,
 292     &rblock->dnssec,
 293     &fully_qualified_name, &removed);
 294
 295   if (removed) setflag(addr, af_local_host_removed);
 296
 297   /* If host found with only address records, test for the domain's being in
 298   the mx_domains list. Note that this applies also to SRV records; the name of
 299   the option is historical. */
 300
 301   if ((rc == HOST_FOUND || rc == HOST_FOUND_LOCAL) && h.mx < 0 &&
 302        ob->mx_domains)
 303     switch(match_isinlist(fully_qualified_name,
 304           CUSS &(ob->mx_domains), 0,
 305           &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
 306       {
 307       case DEFER:
 308       addr->message = US"lookup defer for mx_domains";
 309       return DEFER;
 310
 311       case OK:
 312       DEBUG(D_route) debug_printf("%s router rejected %s: no MX record(s)\n",
 313         rblock->name, fully_qualified_name);
 314       continue;
 315       }
 316
 317   /* Deferral returns forthwith, and anything other than failure breaks the
 318   loop. */
 319
 320   if (rc == HOST_FIND_SECURITY)
 321     {
 322     addr->message = US"host lookup done insecurely";
 323     return DEFER;
 324     }
 325   if (rc == HOST_FIND_AGAIN)
 326     {
 327     if (rblock->pass_on_timeout)
 328       {
 329       DEBUG(D_route) debug_printf("%s router timed out, and pass_on_timeout is set\n",
 330         rblock->name);
 331       return PASS;
 332       }
 333     addr->message = US"host lookup did not complete";
 334     return DEFER;
 335     }
 336
 337   if (rc != HOST_FIND_FAILED) break;
 338
 339   if (ob->fail_defer_domains)
 340     switch(match_isinlist(fully_qualified_name,
 341           CUSS &ob->fail_defer_domains, 0,
 342           &domainlist_anchor, addr->domain_cache, MCL_DOMAIN, TRUE, NULL))
 343       {
 344       case DEFER:
 345         addr->message = US"lookup defer for fail_defer_domains option";
 346         return DEFER;
 347
 348       case OK:
 349         DEBUG(D_route) debug_printf("%s router: matched fail_defer_domains\n",
 350           rblock->name);
 351         addr->message = US"missing MX, or all MXs point to missing A records,"
 352           " and defer requested";
 353         return DEFER;
 354       }
 355   /* Check to see if the failure is the result of MX records pointing to
 356   non-existent domains, and if so, set an appropriate error message; the case
 357   of an MX or SRV record pointing to "." is another special case that we can
 358   detect. Otherwise "unknown mail domain" is used, which is confusing. Also, in
 359   this case don't do the widening. We need check only the first host to see if
 360   its MX has been filled in, but there is no address, because if there were any
 361   usable addresses returned, we would not have had HOST_FIND_FAILED.
 362
 363   As a common cause of this problem is MX records with IP addresses on the
 364   RHS, give a special message in this case. */
 365
 366   if (h.mx >= 0 && h.address == NULL)
 367     {
 368     setflag(addr, af_pass_message);   /* This is not a security risk */
 369     if (h.name[0] == 0)
 370       addr->message = US"an MX or SRV record indicated no SMTP service";
 371     else
 372       {
 373       addr->basic_errno = ERRNO_UNKNOWNHOST;
 374       addr->message = US"all relevant MX records point to non-existent hosts";
 375       if (!allow_mx_to_ip && string_is_ip_address(h.name, NULL) != 0)
 376         {
 377         addr->user_message =
 378           string_sprintf("It appears that the DNS operator for %s\n"
 379             "has installed an invalid MX record with an IP address\n"
 380             "instead of a domain name on the right hand side.", addr->domain);
 381         addr->message = string_sprintf("%s or (invalidly) to IP addresses",
 382           addr->message);
 383         }
 384       }
 385     return DECLINE;
 386     }
 387
 388   /* If there's a syntax error, do not continue with any widening, and note
 389   the error. */
 390
 391   if (f.host_find_failed_syntax)
 392     {
 393     addr->message = string_sprintf("mail domain \"%s\" is syntactically "
 394       "invalid", h.name);
 395     return DECLINE;
 396     }
 397   }
 398
 399 /* If the original domain name has been changed as a result of the host lookup,
 400 set up a child address for rerouting and request header rewrites if so
 401 configured. Then yield REROUTED. However, if the only change is a change of
 402 case in the domain name, which some resolvers yield (others don't), just change
 403 the domain name in the original address so that the official version is used in
 404 RCPT commands. */
 405
 406 if (Ustrcmp(addr->domain, fully_qualified_name) != 0)
 407   {
 408   if (strcmpic(addr->domain, fully_qualified_name) == 0)
 409     {
 410     uschar *at = Ustrrchr(addr->address, '@');
 411     memcpy(at+1, fully_qualified_name, Ustrlen(at+1));
 412     }
 413   else
 414     {
 415     rf_change_domain(addr, fully_qualified_name, ob->rewrite_headers, addr_new);
 416     return REROUTED;
 417     }
 418   }
 419
 420 /* If the yield is HOST_FOUND_LOCAL, the remote domain name either found MX
 421 records with the lowest numbered one pointing to a host with an IP address that
 422 is set on one of the interfaces of this machine, or found A records or got
 423 addresses from gethostbyname() that contain one for this machine. This can
 424 happen quite legitimately if the original name was a shortened form of a
 425 domain, but we will have picked that up already via the name change test above.
 426
 427 Otherwise, the action to be taken can be configured by the self option, the
 428 handling of which is in a separate function, as it is also required for other
 429 routers. */
 430
 431 if (rc == HOST_FOUND_LOCAL)
 432   {
 433   rc = rf_self_action(addr, &h, rblock->self_code, rblock->self_rewrite,
 434     rblock->self, addr_new);
 435   if (rc != OK) return rc;
 436   }
 437
 438 /* Otherwise, insist on being a secondary MX if so configured */
 439
 440 else if (ob->check_secondary_mx && !testflag(addr, af_local_host_removed))
 441   {
 442   DEBUG(D_route) debug_printf("check_secondary_mx set and local host not secondary\n");
 443   return DECLINE;
 444   }
 445
 446 /* Set up the errors address, if any. */
 447
 448 rc = rf_get_errors_address(addr, rblock, verify, &addr->prop.errors_address);
 449 if (rc != OK) return rc;
 450
 451 /* Set up the additional and removable headers for this address. */
 452
 453 rc = rf_get_munge_headers(addr, rblock, &addr->prop.extra_headers,
 454   &addr->prop.remove_headers);
 455 if (rc != OK) return rc;
 456
 457 /* Get store in which to preserve the original host item, chained on
 458 to the address. */
 459
 460 addr->host_list = store_get(sizeof(host_item), GET_UNTAINTED);
 461 addr->host_list[0] = h;
 462
 463 /* Fill in the transport and queue the address for delivery. */
 464
 465 if (!rf_get_transport(rblock->transport_name, &(rblock->transport),
 466       addr, rblock->name, NULL))
 467   return DEFER;
 468
 469 addr->transport = rblock->transport;
 470
 471 return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
 472   OK : DEFER;
 473 }
 474
 475 #endif   /*!MACRO_PREDEF*/
 476 /* End of routers/dnslookup.c */
 477 /* vi: aw ai sw=2
 478 */