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