src/src/routers/dnslookup.c

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