src/src/routers/dnslookup.c

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