Routers: named variables
[exim.git] / src / src / routers / queryprogram.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 "queryprogram.h"
11
12
13
14 /* Options specific to the queryprogram router. */
15
16 optionlist queryprogram_router_options[] = {
17   { "*expand_command_group", opt_bool | opt_hidden,
18       (void *)(offsetof(queryprogram_router_options_block, expand_cmd_gid)) },
19   { "*expand_command_user", opt_bool | opt_hidden,
20       (void *)(offsetof(queryprogram_router_options_block, expand_cmd_uid)) },
21   { "*set_command_group",   opt_bool | opt_hidden,
22       (void *)(offsetof(queryprogram_router_options_block, cmd_gid_set)) },
23   { "*set_command_user",    opt_bool | opt_hidden,
24       (void *)(offsetof(queryprogram_router_options_block, cmd_uid_set)) },
25   { "command",      opt_stringptr,
26       (void *)(offsetof(queryprogram_router_options_block, command)) },
27   { "command_group",opt_expand_gid,
28       (void *)(offsetof(queryprogram_router_options_block, cmd_gid)) },
29   { "command_user", opt_expand_uid,
30       (void *)(offsetof(queryprogram_router_options_block, cmd_uid)) },
31   { "current_directory", opt_stringptr,
32       (void *)(offsetof(queryprogram_router_options_block, current_directory)) },
33   { "timeout",      opt_time,
34       (void *)(offsetof(queryprogram_router_options_block, timeout)) }
35 };
36
37 /* Size of the options list. An extern variable has to be used so that its
38 address can appear in the tables drtables.c. */
39
40 int queryprogram_router_options_count =
41   sizeof(queryprogram_router_options)/sizeof(optionlist);
42
43
44 #ifdef MACRO_PREDEF
45
46 /* Dummy entries */
47 queryprogram_router_options_block queryprogram_router_option_defaults = {0};
48 void queryprogram_router_init(router_instance *rblock) {}
49 int queryprogram_router_entry(router_instance *rblock, address_item *addr,
50   struct passwd *pw, int verify, address_item **addr_local,
51   address_item **addr_remote, address_item **addr_new,
52   address_item **addr_succeed) {return 0;}
53
54 #else   /*!MACRO_PREDEF*/
55
56
57 /* Default private options block for the queryprogram router. */
58
59 queryprogram_router_options_block queryprogram_router_option_defaults = {
60   NULL,         /* command */
61   60*60,        /* timeout */
62   (uid_t)(-1),  /* cmd_uid */
63   (gid_t)(-1),  /* cmd_gid */
64   FALSE,        /* cmd_uid_set */
65   FALSE,        /* cmd_gid_set */
66   US"/",        /* current_directory */
67   NULL,         /* expand_cmd_gid */
68   NULL          /* expand_cmd_uid */
69 };
70
71
72
73 /*************************************************
74 *          Initialization entry point            *
75 *************************************************/
76
77 /* Called for each instance, after its options have been read, to enable
78 consistency checks to be done, or anything else that needs to be set up. */
79
80 void
81 queryprogram_router_init(router_instance *rblock)
82 {
83 queryprogram_router_options_block *ob =
84   (queryprogram_router_options_block *)(rblock->options_block);
85
86 /* A command must be given */
87
88 if (ob->command == NULL)
89   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
90     "a command specification is required", rblock->name);
91
92 /* A uid/gid must be supplied */
93
94 if (!ob->cmd_uid_set && ob->expand_cmd_uid == NULL)
95   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
96     "command_user must be specified", rblock->name);
97 }
98
99
100
101 /*************************************************
102 *    Process a set of generated new addresses    *
103 *************************************************/
104
105 /* This function sets up a set of newly generated child addresses and puts them
106 on the new address chain.
107
108 Arguments:
109   rblock                  router block
110   addr_new                new address chain
111   addr                    original address
112   generated               list of generated addresses
113   addr_prop               the propagated data block, containing errors_to,
114                             header change stuff, and address_data
115
116 Returns:         nothing
117 */
118
119 static void
120 add_generated(router_instance *rblock, address_item **addr_new,
121   address_item *addr, address_item *generated,
122   address_item_propagated *addr_prop)
123 {
124 while (generated != NULL)
125   {
126   BOOL ignore_error = addr->prop.ignore_error;
127   address_item *next = generated;
128
129   generated = next->next;
130
131   next->parent = addr;
132   next->prop = *addr_prop;
133   next->prop.ignore_error = next->prop.ignore_error || ignore_error;
134   next->start_router = rblock->redirect_router;
135
136   next->next = *addr_new;
137   *addr_new = next;
138
139   if (addr->child_count == USHRT_MAX)
140     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
141       "child addresses for <%s>", rblock->name, USHRT_MAX, addr->address);
142   addr->child_count++;
143
144   DEBUG(D_route)
145     debug_printf("%s router generated %s\n", rblock->name, next->address);
146   }
147 }
148
149
150
151
152 /*************************************************
153 *              Main entry point                  *
154 *************************************************/
155
156 /* See local README for interface details. This router returns:
157
158 DECLINE
159   . DECLINE returned
160   . self = DECLINE
161
162 PASS
163   . PASS returned
164   . timeout of host lookup and pass_on_timeout set
165   . self = PASS
166
167 DEFER
168   . verifying the errors address caused a deferment or a big disaster such
169       as an expansion failure (rf_get_errors_address)
170   . expanding a headers_{add,remove} string caused a deferment or another
171       expansion error (rf_get_munge_headers)
172   . a problem in rf_get_transport: no transport when one is needed;
173       failed to expand dynamic transport; failed to find dynamic transport
174   . bad lookup type
175   . problem looking up host (rf_lookup_hostlist)
176   . self = DEFER or FREEZE
177   . failure to set up uid/gid for running the command
178   . failure of transport_set_up_command: too many arguments, expansion fail
179   . failure to create child process
180   . child process crashed or timed out or didn't return data
181   . :defer: in data
182   . DEFER or FREEZE returned
183   . problem in redirection data
184   . unknown transport name or trouble expanding router transport
185
186 FAIL
187   . :fail: in data
188   . FAIL returned
189   . self = FAIL
190
191 OK
192   . address added to addr_local or addr_remote for delivery
193   . new addresses added to addr_new
194 */
195
196 int
197 queryprogram_router_entry(
198   router_instance *rblock,        /* data for this instantiation */
199   address_item *addr,             /* address we are working on */
200   struct passwd *pw,              /* passwd entry after check_local_user */
201   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
202   address_item **addr_local,      /* add it to this if it's local */
203   address_item **addr_remote,     /* add it to this if it's remote */
204   address_item **addr_new,        /* put new addresses on here */
205   address_item **addr_succeed)    /* put old address here on success */
206 {
207 int fd_in, fd_out, len, rc;
208 pid_t pid;
209 struct passwd *upw = NULL;
210 uschar buffer[1024];
211 const uschar **argvptr;
212 uschar *rword, *rdata, *s;
213 address_item_propagated addr_prop;
214 queryprogram_router_options_block *ob =
215   (queryprogram_router_options_block *)(rblock->options_block);
216 uschar *current_directory = ob->current_directory;
217 ugid_block ugid;
218 uid_t curr_uid = getuid();
219 gid_t curr_gid = getgid();
220 uid_t uid = ob->cmd_uid;
221 gid_t gid = ob->cmd_gid;
222 uid_t *puid = &uid;
223 gid_t *pgid = &gid;
224
225 DEBUG(D_route) debug_printf("%s router called for %s: domain = %s\n",
226   rblock->name, addr->address, addr->domain);
227
228 ugid.uid_set = ugid.gid_set = FALSE;
229
230 /* Set up the propagated data block with the current address_data and the
231 errors address and extra header stuff. */
232
233 bzero(&addr_prop, sizeof(addr_prop));
234 addr_prop.address_data = deliver_address_data;
235 addr_prop.set = addr->prop.set;
236
237 rc = rf_get_errors_address(addr, rblock, verify, &addr_prop.errors_address);
238 if (rc != OK) return rc;
239
240 rc = rf_get_munge_headers(addr, rblock, &addr_prop.extra_headers,
241   &addr_prop.remove_headers);
242 if (rc != OK) return rc;
243
244 #ifdef EXPERIMENTAL_SRS
245 addr_prop.srs_sender = NULL;
246 #endif
247
248 /* Get the fixed or expanded uid under which the command is to run
249 (initialization ensures that one or the other is set). */
250
251 if (!ob->cmd_uid_set)
252   {
253   if (!route_find_expanded_user(ob->expand_cmd_uid, rblock->name, US"router",
254       &upw, &uid, &(addr->message)))
255     return DEFER;
256   }
257
258 /* Get the fixed or expanded gid, or take the gid from the passwd entry. */
259
260 if (!ob->cmd_gid_set)
261   {
262   if (ob->expand_cmd_gid != NULL)
263     {
264     if (route_find_expanded_group(ob->expand_cmd_gid, rblock->name,
265         US"router", &gid, &(addr->message)))
266       return DEFER;
267     }
268   else if (upw != NULL)
269     {
270     gid = upw->pw_gid;
271     }
272   else
273     {
274     addr->message = string_sprintf("command_user set without command_group "
275       "for %s router", rblock->name);
276     return DEFER;
277     }
278   }
279
280 DEBUG(D_route) debug_printf("requires uid=%ld gid=%ld current_directory=%s\n",
281   (long int)uid, (long int)gid, current_directory);
282
283 /* If we are not running as root, we will not be able to change uid/gid. */
284
285 if (curr_uid != root_uid && (uid != curr_uid || gid != curr_gid))
286   {
287   DEBUG(D_route)
288     {
289     debug_printf("not running as root: cannot change uid/gid\n");
290     debug_printf("subprocess will run with uid=%ld gid=%ld\n",
291       (long int)curr_uid, (long int)curr_gid);
292     }
293   puid = pgid = NULL;
294   }
295
296 /* Set up the command to run */
297
298 if (!transport_set_up_command(&argvptr, /* anchor for arg list */
299     ob->command,                        /* raw command */
300     TRUE,                               /* expand the arguments */
301     0,                                  /* not relevant when... */
302     NULL,                               /* no transporting address */
303     US"queryprogram router",            /* for error messages */
304     &(addr->message)))                  /* where to put error message */
305   {
306   return DEFER;
307   }
308
309 /* Create the child process, making it a group leader. */
310
311 pid = child_open_uid(argvptr, NULL, 0077, puid, pgid, &fd_in, &fd_out,
312   current_directory, TRUE);
313
314 if (pid < 0)
315   {
316   addr->message = string_sprintf("%s router couldn't create child process: %s",
317     rblock->name, strerror(errno));
318   return DEFER;
319   }
320
321 /* Nothing is written to the standard input. */
322
323 (void)close(fd_in);
324
325 /* Wait for the process to finish, applying the timeout, and inspect its return
326 code. */
327
328 if ((rc = child_close(pid, ob->timeout)) != 0)
329   {
330   if (rc > 0)
331     addr->message = string_sprintf("%s router: command returned non-zero "
332       "code %d", rblock->name, rc);
333
334   else if (rc == -256)
335     {
336     addr->message = string_sprintf("%s router: command timed out",
337       rblock->name);
338     killpg(pid, SIGKILL);       /* Kill the whole process group */
339     }
340
341   else if (rc == -257)
342     addr->message = string_sprintf("%s router: wait() failed: %s",
343       rblock->name, strerror(errno));
344
345   else
346     addr->message = string_sprintf("%s router: command killed by signal %d",
347       rblock->name, -rc);
348
349   return DEFER;
350   }
351
352 /* Read the pipe to get the command's output, and then close it. */
353
354 len = read(fd_out, buffer, sizeof(buffer) - 1);
355 (void)close(fd_out);
356
357 /* Failure to return any data is an error. */
358
359 if (len <= 0)
360   {
361   addr->message = string_sprintf("%s router: command failed to return data",
362     rblock->name);
363   return DEFER;
364   }
365
366 /* Get rid of leading and trailing white space, and pick off the first word of
367 the result. */
368
369 while (len > 0 && isspace(buffer[len-1])) len--;
370 buffer[len] = 0;
371
372 DEBUG(D_route) debug_printf("command wrote: %s\n", buffer);
373
374 rword = buffer;
375 while (isspace(*rword)) rword++;
376 rdata = rword;
377 while (*rdata != 0 && !isspace(*rdata)) rdata++;
378 if (*rdata != 0) *rdata++ = 0;
379
380 /* The word must be a known yield name. If it is "REDIRECT", the rest of the
381 line is redirection data, as for a .forward file. It may not contain filter
382 data, and it may not contain anything other than addresses (no files, no pipes,
383 no specials). */
384
385 if (strcmpic(rword, US"REDIRECT") == 0)
386   {
387   int filtertype;
388   redirect_block redirect;
389   address_item *generated = NULL;
390
391   redirect.string = rdata;
392   redirect.isfile = FALSE;
393
394   rc = rda_interpret(&redirect,  /* redirection data */
395     RDO_BLACKHOLE |              /* forbid :blackhole: */
396       RDO_FAIL    |              /* forbid :fail: */
397       RDO_INCLUDE |              /* forbid :include: */
398       RDO_REWRITE,               /* rewrite generated addresses */
399     NULL,                        /* :include: directory not relevant */
400     NULL,                        /* sieve vacation directory not relevant */
401     NULL,                        /* sieve enotify mailto owner not relevant */
402     NULL,                        /* sieve useraddress not relevant */
403     NULL,                        /* sieve subaddress not relevant */
404     &ugid,                       /* uid/gid (but not set) */
405     &generated,                  /* where to hang the results */
406     &(addr->message),            /* where to put messages */
407     NULL,                        /* don't skip syntax errors */
408     &filtertype,                 /* not used; will always be FILTER_FORWARD */
409     string_sprintf("%s router", rblock->name));
410
411   switch (rc)
412     {
413     /* FF_DEFER and FF_FAIL can arise only as a result of explicit commands.
414     If a configured message was supplied, allow it to be  included in an SMTP
415     response after verifying. */
416
417     case FF_DEFER:
418     if (addr->message == NULL) addr->message = US"forced defer";
419       else addr->user_message = addr->message;
420     return DEFER;
421
422     case FF_FAIL:
423     add_generated(rblock, addr_new, addr, generated, &addr_prop);
424     if (addr->message == NULL) addr->message = US"forced rejection";
425       else addr->user_message = addr->message;
426     return FAIL;
427
428     case FF_DELIVERED:
429     break;
430
431     case FF_NOTDELIVERED:    /* an empty redirection list is bad */
432     addr->message = US"no addresses supplied";
433     /* Fall through */
434
435     case FF_ERROR:
436     default:
437     addr->basic_errno = ERRNO_BADREDIRECT;
438     addr->message = string_sprintf("error in redirect data: %s", addr->message);
439     return DEFER;
440     }
441
442   /* Handle the generated addresses, if any. */
443
444   add_generated(rblock, addr_new, addr, generated, &addr_prop);
445
446   /* Put the original address onto the succeed queue so that any retry items
447   that get attached to it get processed. */
448
449   addr->next = *addr_succeed;
450   *addr_succeed = addr;
451
452   return OK;
453   }
454
455 /* Handle other returns that are not ACCEPT */
456
457 if (strcmpic(rword, US"accept") != 0)
458   {
459   if (strcmpic(rword, US"decline") == 0) return DECLINE;
460   if (strcmpic(rword, US"pass") == 0) return PASS;
461   addr->message = string_copy(rdata);                /* data is a message */
462   if (strcmpic(rword, US"fail") == 0)
463     {
464     setflag(addr, af_pass_message);
465     return FAIL;
466     }
467   if (strcmpic(rword, US"freeze") == 0) addr->special_action = SPECIAL_FREEZE;
468   else if (strcmpic(rword, US"defer") != 0)
469     {
470     addr->message = string_sprintf("bad command yield: %s %s", rword, rdata);
471     log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
472     }
473   return DEFER;
474   }
475
476 /* The command yielded "ACCEPT". The rest of the string is a number of keyed
477 fields from which we can fish out values using the "extract" expansion
478 function. To use this feature, we must put the string into the $value variable,
479 i.e. set lookup_value. */
480
481 lookup_value = rdata;
482 s = expand_string(US"${extract{data}{$value}}");
483 if (*s != 0) addr_prop.address_data = string_copy(s);
484
485 s = expand_string(US"${extract{transport}{$value}}");
486 lookup_value = NULL;
487
488 /* If we found a transport name, find the actual transport */
489
490 if (*s != 0)
491   {
492   transport_instance *transport;
493   for (transport = transports; transport; transport = transport->next)
494     if (Ustrcmp(transport->name, s) == 0) break;
495   if (!transport)
496     {
497     addr->message = string_sprintf("unknown transport name %s yielded by "
498       "command", s);
499     log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
500     return DEFER;
501     }
502   addr->transport = transport;
503   }
504
505 /* No transport given; get the transport from the router configuration. It may
506 be fixed or expanded, but there will be an error if it is unset, requested by
507 the last argument not being NULL. */
508
509 else
510   {
511   if (!rf_get_transport(rblock->transport_name, &(rblock->transport), addr,
512        rblock->name, US"transport"))
513     return DEFER;
514   addr->transport = rblock->transport;
515   }
516
517 /* See if a host list is given, and if so, look up the addresses. */
518
519 lookup_value = rdata;
520 s = expand_string(US"${extract{hosts}{$value}}");
521
522 if (*s != 0)
523   {
524   int lookup_type = LK_DEFAULT;
525   uschar *ss = expand_string(US"${extract{lookup}{$value}}");
526   lookup_value = NULL;
527
528   if (*ss != 0)
529     {
530     if (Ustrcmp(ss, "byname") == 0) lookup_type = LK_BYNAME;
531     else if (Ustrcmp(ss, "bydns") == 0) lookup_type = LK_BYDNS;
532     else
533       {
534       addr->message = string_sprintf("bad lookup type \"%s\" yielded by "
535         "command", ss);
536       log_write(0, LOG_PANIC, "%s router: %s", rblock->name, addr->message);
537       return DEFER;
538       }
539     }
540
541   host_build_hostlist(&(addr->host_list), s, FALSE);  /* pro tem no randomize */
542
543   rc = rf_lookup_hostlist(rblock, addr, rblock->ignore_target_hosts,
544     lookup_type, hff_defer, addr_new);
545   if (rc != OK) return rc;
546   }
547 lookup_value = NULL;
548
549 /* Put the errors address, extra headers, and address_data into this address */
550
551 addr->prop = addr_prop;
552
553 /* Queue the address for local or remote delivery. */
554
555 return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
556   OK : DEFER;
557 }
558
559 #endif   /*!MACRO_PREDEF*/
560 /* End of routers/queryprogram.c */