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