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