src/src/routers/dnslookup.c

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