src/routers/manualroute.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
   9 #include "../exim.h"
  10 #include "rf_functions.h"
  11 #include "manualroute.h"
  12
  13
  14 /* Options specific to the manualroute router. */
  15
  16 optionlist manualroute_router_options[] = {
  17   { "host_all_ignored", opt_stringptr,
  18       (void *)(offsetof(manualroute_router_options_block, host_all_ignored)) },
  19   { "host_find_failed", opt_stringptr,
  20       (void *)(offsetof(manualroute_router_options_block, host_find_failed)) },
  21   { "hosts_randomize",  opt_bool,
  22       (void *)(offsetof(manualroute_router_options_block, hosts_randomize)) },
  23   { "route_data",       opt_stringptr,
  24       (void *)(offsetof(manualroute_router_options_block, route_data)) },
  25   { "route_list",       opt_stringptr,
  26       (void *)(offsetof(manualroute_router_options_block, route_list)) },
  27   { "same_domain_copy_routing", opt_bool|opt_public,
  28       (void *)(offsetof(router_instance, same_domain_copy_routing)) }
  29 };
  30
  31 /* Size of the options list. An extern variable has to be used so that its
  32 address can appear in the tables drtables.c. */
  33
  34 int manualroute_router_options_count =
  35   sizeof(manualroute_router_options)/sizeof(optionlist);
  36
  37 /* Default private options block for the manualroute router. */
  38
  39 manualroute_router_options_block manualroute_router_option_defaults = {
  40   -1,           /* host_all_ignored code (unset) */
  41   -1,           /* host_find_failed code (unset) */
  42   FALSE,        /* hosts_randomize */
  43   US"defer",    /* host_all_ignored */
  44   US"freeze",   /* host_find_failed */
  45   NULL,         /* route_data */
  46   NULL          /* route_list */
  47 };
  48
  49
  50 /* Names and values for host_find_failed and host_all_ignored.  */
  51
  52 static uschar *hff_names[] = {
  53   US"ignore",  /* MUST be first - not valid for host_all_ignored */
  54   US"decline",
  55   US"defer",
  56   US"fail",
  57   US"freeze",
  58   US"pass" };
  59
  60 static int hff_codes[] = { hff_ignore, hff_decline, hff_defer, hff_fail,
  61   hff_freeze, hff_pass };
  62
  63 static int hff_count= sizeof(hff_codes)/sizeof(int);
  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 manualroute_router_init(router_instance *rblock)
  76 {
  77 manualroute_router_options_block *ob =
  78   (manualroute_router_options_block *)(rblock->options_block);
  79 int i;
  80
  81 /* Host_find_failed must be a recognized word */
  82
  83 for (i = 0; i < hff_count; i++)
  84   {
  85   if (Ustrcmp(ob->host_find_failed, hff_names[i]) == 0)
  86     {
  87     ob->hff_code = hff_codes[i];
  88     break;
  89     }
  90   }
  91 if (ob->hff_code < 0)
  92   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
  93     "unrecognized setting for host_find_failed option", rblock->name);
  94
  95 for (i = 1; i < hff_count; i++)   /* NB starts at 1 to skip "ignore" */
  96   {
  97   if (Ustrcmp(ob->host_all_ignored, hff_names[i]) == 0)
  98     {
  99     ob->hai_code = hff_codes[i];
 100     break;
 101     }
 102   }
 103 if (ob->hai_code < 0)
 104   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
 105     "unrecognized setting for host_all_ignored option", rblock->name);
 106
 107 /* One of route_list or route_data must be specified */
 108
 109 if ((ob->route_list == NULL && ob->route_data == NULL) ||
 110     (ob->route_list != NULL && ob->route_data != NULL))
 111   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
 112     "route_list or route_data (but not both) must be specified",
 113     rblock->name);
 114 }
 115
 116
 117
 118
 119 /*************************************************
 120 *               Parse a route item               *
 121 *************************************************/
 122
 123 /* The format of a route list item is:
 124
 125   <domain> [<host[list]> [<options>]]
 126
 127 if obtained from route_list. The domain is absent if the string came from
 128 route_data, in which case domain==NULL. The domain and the host list may be
 129 enclosed in quotes.
 130
 131 Arguments:
 132   s         pointer to route list item
 133   domain    if not NULL, where to put the domain pointer
 134   hostlist  where to put the host[list] pointer
 135   options   where to put the options pointer
 136
 137 Returns:    FALSE if domain expected and string is empty;
 138             TRUE otherwise
 139 */
 140
 141 static BOOL
 142 parse_route_item(uschar *s, uschar **domain, uschar **hostlist,
 143   uschar **options)
 144 {
 145 while (*s != 0 && isspace(*s)) s++;
 146
 147 if (domain != NULL)
 148   {
 149   if (*s == 0) return FALSE;            /* missing data */
 150   *domain = string_dequote(&s);
 151   while (*s != 0 && isspace(*s)) s++;
 152   }
 153
 154 *hostlist = string_dequote(&s);
 155 while (*s != 0 && isspace(*s)) s++;
 156 *options = s;
 157 return TRUE;
 158 }
 159
 160
 161
 162 /*************************************************
 163 *              Main entry point                  *
 164 *************************************************/
 165
 166 /* The manualroute router provides a manual routing facility (surprise,
 167 surprise). The data that defines the routing can either be set in route_data
 168 (which means it can be found by, for example, looking up the domain in a file),
 169 or a list of domain patterns and their corresponding data can be provided in
 170 route_list. */
 171
 172 /* See local README for interface details. This router returns:
 173
 174 DECLINE
 175   . no pattern in route_list matched (route_data not set)
 176   . route_data was an empty string (route_list not set)
 177   . forced expansion failure in route_data (rf_expand_data)
 178   . forced expansion of host list
 179   . host_find_failed = decline
 180
 181 DEFER
 182   . transport not defined when needed
 183   . lookup defer in route_list when matching domain pattern
 184   . non-forced expansion failure in route_data
 185   . non-forced expansion failure in host list
 186   . unknown routing option
 187   . host list missing for remote transport (not verifying)
 188   . timeout etc on host lookup (pass_on_timeout not set)
 189   . verifying the errors address caused a deferment or a big disaster such
 190       as an expansion failure (rf_get_errors_address)
 191   . expanding a headers_{add,remove} string caused a deferment or another
 192       expansion error (rf_get_munge_headers)
 193   . a problem in rf_get_transport: no transport when one is needed;
 194       failed to expand dynamic transport; failed to find dynamic transport
 195   . failure to expand or find a uid/gid (rf_get_ugid via rf_queue_add)
 196   . host_find_failed = freeze or defer
 197   . self = freeze or defer
 198
 199 PASS
 200   . timeout etc on host lookup (pass_on_timeout set)
 201   . host_find_failed = pass
 202   . self = pass
 203
 204 REROUTED
 205   . self = reroute
 206
 207 FAIL
 208   . host_find_failed = fail
 209   . self = fail
 210
 211 OK
 212   . added address to addr_local or addr_remote, as appropriate for the
 213     type of transport; this includes the self="send" case.
 214 */
 215
 216 int
 217 manualroute_router_entry(
 218   router_instance *rblock,        /* data for this instantiation */
 219   address_item *addr,             /* address we are working on */
 220   struct passwd *pw,              /* passwd entry after check_local_user */
 221   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
 222   address_item **addr_local,      /* add it to this if it's local */
 223   address_item **addr_remote,     /* add it to this if it's remote */
 224   address_item **addr_new,        /* put new addresses on here */
 225   address_item **addr_succeed)    /* put old address here on success */
 226 {
 227 int rc, lookup_type;
 228 uschar *route_item = NULL;
 229 uschar *options = NULL;
 230 uschar *hostlist = NULL;
 231 uschar *domain, *newhostlist, *listptr;
 232 manualroute_router_options_block *ob =
 233   (manualroute_router_options_block *)(rblock->options_block);
 234 transport_instance *transport = NULL;
 235 BOOL individual_transport_set = FALSE;
 236 BOOL randomize = ob->hosts_randomize;
 237
 238 addr_new = addr_new;           /* Keep picky compilers happy */
 239 addr_succeed = addr_succeed;
 240
 241 DEBUG(D_route) debug_printf("%s router called for %s\n  domain = %s\n",
 242   rblock->name, addr->address, addr->domain);
 243
 244 /* The initialization check ensures that either route_list or route_data is
 245 set. */
 246
 247 if (ob->route_list != NULL)
 248   {
 249   int sep = -(';');             /* Default is semicolon */
 250   listptr = ob->route_list;
 251
 252   while ((route_item = string_nextinlist(&listptr, &sep, NULL, 0)) != NULL)
 253     {
 254     int rc;
 255
 256     DEBUG(D_route) debug_printf("route_item = %s\n", route_item);
 257     if (!parse_route_item(route_item, &domain, &hostlist, &options))
 258       continue;     /* Ignore blank items */
 259
 260     /* Check the current domain; if it matches, break the loop */
 261
 262     if ((rc = match_isinlist(addr->domain, &domain, UCHAR_MAX+1,
 263            &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, &lookup_value)) == OK)
 264       break;
 265
 266     /* If there was a problem doing the check, defer */
 267
 268     if (rc == DEFER)
 269       {
 270       addr->message = US"lookup defer in route_list";
 271       return DEFER;
 272       }
 273     }
 274
 275   if (route_item == NULL) return DECLINE;  /* No pattern in the list matched */
 276   }
 277
 278 /* Handle a single routing item in route_data. If it expands to an empty
 279 string, decline. */
 280
 281 else
 282   {
 283   route_item = rf_expand_data(addr, ob->route_data, &rc);
 284   if (route_item == NULL) return rc;
 285   (void) parse_route_item(route_item, NULL, &hostlist, &options);
 286   if (hostlist[0] == 0) return DECLINE;
 287   }
 288
 289 /* Expand the hostlist item. It may then pointing to an empty string, or to a
 290 single host or a list of hosts; options is pointing to the rest of the
 291 routelist item, which is either empty or contains various option words. */
 292
 293 DEBUG(D_route) debug_printf("original list of hosts = \"%s\" options = %s\n",
 294   hostlist, options);
 295
 296 newhostlist = expand_string_copy(hostlist);
 297 lookup_value = NULL;                        /* Finished with */
 298 expand_nmax = -1;
 299
 300 /* If the expansion was forced to fail, just decline. Otherwise there is a
 301 configuration problem. */
 302
 303 if (newhostlist == NULL)
 304   {
 305   if (expand_string_forcedfail) return DECLINE;
 306   addr->message = string_sprintf("%s router: failed to expand \"%s\": %s",
 307     rblock->name, hostlist, expand_string_message);
 308   return DEFER;
 309   }
 310 else hostlist = newhostlist;
 311
 312 DEBUG(D_route) debug_printf("expanded list of hosts = \"%s\" options = %s\n",
 313   hostlist, options);
 314
 315 /* Set default lookup type and scan the options */
 316
 317 lookup_type = lk_default;
 318
 319 while (*options != 0)
 320   {
 321   int term;
 322   uschar *s = options;
 323   while (*options != 0 && !isspace(*options)) options++;
 324   term = *options;
 325   *options = 0;
 326
 327   if (Ustrcmp(s, "randomize") == 0) randomize = TRUE;
 328   else if (Ustrcmp(s, "no_randomize") == 0) randomize = FALSE;
 329   else if (Ustrcmp(s, "byname") == 0) lookup_type = lk_byname;
 330   else if (Ustrcmp(s, "bydns") == 0) lookup_type = lk_bydns;
 331   else
 332     {
 333     transport_instance *t;
 334     for (t = transports; t != NULL; t = t->next)
 335       {
 336       if (Ustrcmp(t->name, s) == 0)
 337         {
 338         transport = t;
 339         individual_transport_set = TRUE;
 340         break;
 341         }
 342       }
 343     if (t == NULL)
 344       {
 345       s = string_sprintf("unknown routing option or transport name \"%s\"", s);
 346       log_write(0, LOG_MAIN, "Error in %s router: %s", rblock->name, s);
 347       addr->message = string_sprintf("error in router: %s", s);
 348       return DEFER;
 349       }
 350     }
 351
 352   if (term != 0)
 353     {
 354     options++;
 355     while (*options != 0 && isspace(*options)) options++;
 356     }
 357   }
 358
 359 /* Set up the errors address, if any. */
 360
 361 rc = rf_get_errors_address(addr, rblock, verify, &(addr->p.errors_address));
 362 if (rc != OK) return rc;
 363
 364 /* Set up the additional and removeable headers for this address. */
 365
 366 rc = rf_get_munge_headers(addr, rblock, &(addr->p.extra_headers),
 367   &(addr->p.remove_headers));
 368 if (rc != OK) return rc;
 369
 370 /* If an individual transport is not set, get the transport for this router, if
 371 any. It might be expanded, or it might be unset if this router has verify_only
 372 set. */
 373
 374 if (!individual_transport_set)
 375   {
 376   if (!rf_get_transport(rblock->transport_name, &(rblock->transport), addr,
 377       rblock->name, NULL))
 378     return DEFER;
 379   transport = rblock->transport;
 380   }
 381
 382 /* Deal with the case of a local transport. The host list is passed over as a
 383 single text string that ends up in $host. */
 384
 385 if (transport != NULL && transport->info->local)
 386   {
 387   if (hostlist[0] != 0)
 388     {
 389     host_item *h;
 390     addr->host_list = h = store_get(sizeof(host_item));
 391     h->name = string_copy(hostlist);
 392     h->address = NULL;
 393     h->port = PORT_NONE;
 394     h->mx = MX_NONE;
 395     h->status = hstatus_unknown;
 396     h->why = hwhy_unknown;
 397     h->last_try = 0;
 398     h->next = NULL;
 399     }
 400
 401   /* There is nothing more to do other than to queue the address for the
 402   local transport, filling in any uid/gid. This can be done by the common
 403   rf_queue_add() function. */
 404
 405   addr->transport = transport;
 406   return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
 407     OK : DEFER;
 408   }
 409
 410 /* There is either no transport (verify_only) or a remote transport. A host
 411 list is mandatory in either case, except when verifying, in which case the
 412 address is just accepted. */
 413
 414 if (hostlist[0] == 0)
 415   {
 416   if (verify != v_none) goto ROUTED;
 417   addr->message = string_sprintf("error in %s router: no host(s) specified "
 418     "for domain %s", rblock->name, domain);
 419   log_write(0, LOG_MAIN, "%s", addr->message);
 420   return DEFER;
 421   }
 422
 423 /* Otherwise we finish the routing here by building a chain of host items
 424 for the list of configured hosts, and then finding their addresses. */
 425
 426 host_build_hostlist(&(addr->host_list), hostlist, randomize);
 427 rc = rf_lookup_hostlist(rblock, addr, rblock->ignore_target_hosts, lookup_type,
 428   ob->hff_code, addr_new);
 429 if (rc != OK) return rc;
 430
 431 /* If host_find_failed is set to "ignore", it is possible for all the hosts to
 432 be ignored, in which case we will end up with an empty host list. What happens
 433 is controlled by host_all_ignored. */
 434
 435 if (addr->host_list == NULL)
 436   {
 437   int i;
 438   DEBUG(D_route) debug_printf("host_find_failed ignored every host\n");
 439   if (ob->hai_code == hff_decline) return DECLINE;
 440   if (ob->hai_code == hff_pass) return PASS;
 441
 442   for (i = 0; i < hff_count; i++)
 443     if (ob->hai_code == hff_codes[i]) break;
 444
 445   addr->message = string_sprintf("lookup failed for all hosts in %s router: "
 446     "host_find_failed=ignore host_all_ignored=%s", rblock->name, hff_names[i]);
 447
 448   if (ob->hai_code == hff_defer) return DEFER;
 449   if (ob->hai_code == hff_fail) return FAIL;
 450
 451   addr->special_action = SPECIAL_FREEZE;
 452   return DEFER;
 453   }
 454
 455 /* Finally, since we have done all the routing here, there must be a transport
 456 defined for these hosts. It will be a remote one, as a local transport is
 457 dealt with above. However, we don't need one if verifying only. */
 458
 459 if (transport == NULL && verify == v_none)
 460     {
 461     log_write(0, LOG_MAIN, "Error in %s router: no transport defined",
 462       rblock->name);
 463     addr->message = US"error in router: transport missing";
 464     return DEFER;
 465     }
 466
 467 /* Fill in the transport, queue for remote delivery. The yield of
 468 rf_queue_add() is always TRUE for a remote transport. */
 469
 470 ROUTED:
 471
 472 addr->transport = transport;
 473 (void)rf_queue_add(addr, addr_local, addr_remote, rblock, NULL);
 474 return OK;
 475 }
 476
 477 /* End of routers/manualroute.c */