da49307b1c6cd25e7783a2f7a8bb8c2476fca31a
[exim.git] / src / src / transports / pipe.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 "pipe.h"
12
13 #ifdef HAVE_SETCLASSRESOURCES
14 #include <login_cap.h>
15 #endif
16
17
18
19 /* Options specific to the pipe transport. They must be in alphabetic
20 order (note that "_" comes before the lower case letters). Those starting
21 with "*" are not settable by the user but are used by the option-reading
22 software for alternative value types. Some options are stored in the transport
23 instance block so as to be publicly visible; these are flagged with opt_public.
24 */
25 #define LOFF(field) OPT_OFF(pipe_transport_options_block, field)
26
27 optionlist pipe_transport_options[] = {
28   { "allow_commands",    opt_stringptr, LOFF(allow_commands) },
29   { "batch_id",          opt_stringptr | opt_public,
30       OPT_OFF(transport_instance, batch_id) },
31   { "batch_max",         opt_int | opt_public,
32       OPT_OFF(transport_instance, batch_max) },
33   { "check_string",      opt_stringptr, LOFF(check_string) },
34   { "command",           opt_stringptr, LOFF(cmd) },
35   { "environment",       opt_stringptr, LOFF(environment) },
36   { "escape_string",     opt_stringptr, LOFF(escape_string) },
37   { "force_command",         opt_bool,  LOFF(force_command) },
38   { "freeze_exec_fail",  opt_bool,      LOFF(freeze_exec_fail) },
39   { "freeze_signal",     opt_bool,      LOFF(freeze_signal) },
40   { "ignore_status",     opt_bool,      LOFF(ignore_status) },
41   { "log_defer_output",  opt_bool | opt_public,
42       OPT_OFF(transport_instance, log_defer_output) },
43   { "log_fail_output",   opt_bool | opt_public,
44       OPT_OFF(transport_instance, log_fail_output) },
45   { "log_output",        opt_bool | opt_public,
46       OPT_OFF(transport_instance, log_output) },
47   { "max_output",        opt_mkint,     LOFF(max_output) },
48   { "message_prefix",    opt_stringptr, LOFF(message_prefix) },
49   { "message_suffix",    opt_stringptr, LOFF(message_suffix) },
50   { "path",              opt_stringptr, LOFF(path) },
51   { "permit_coredump",   opt_bool,      LOFF(permit_coredump) },
52   { "pipe_as_creator",   opt_bool | opt_public,
53       OPT_OFF(transport_instance, deliver_as_creator) },
54   { "restrict_to_path",  opt_bool,      LOFF(restrict_to_path) },
55   { "return_fail_output",opt_bool | opt_public,
56       OPT_OFF(transport_instance, return_fail_output) },
57   { "return_output",     opt_bool | opt_public,
58       OPT_OFF(transport_instance, return_output) },
59   { "temp_errors",       opt_stringptr, LOFF(temp_errors) },
60   { "timeout",           opt_time,      LOFF(timeout) },
61   { "timeout_defer",     opt_bool,      LOFF(timeout_defer) },
62   { "umask",             opt_octint,    LOFF(umask) },
63   { "use_bsmtp",         opt_bool,      LOFF(use_bsmtp) },
64   #ifdef HAVE_SETCLASSRESOURCES
65   { "use_classresources", opt_bool,     LOFF(use_classresources) },
66   #endif
67   { "use_crlf",          opt_bool,      LOFF(use_crlf) },
68   { "use_shell",         opt_bool,      LOFF(use_shell) },
69 };
70
71 /* Size of the options list. An extern variable has to be used so that its
72 address can appear in the tables drtables.c. */
73
74 int pipe_transport_options_count =
75   sizeof(pipe_transport_options)/sizeof(optionlist);
76
77
78 #ifdef MACRO_PREDEF
79
80 /* Dummy values */
81 pipe_transport_options_block pipe_transport_option_defaults = {0};
82 void pipe_transport_init(transport_instance *tblock) {}
83 BOOL pipe_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
84
85 #else   /*!MACRO_PREDEF*/
86
87
88 /* Default private options block for the pipe transport. */
89
90 pipe_transport_options_block pipe_transport_option_defaults = {
91   NULL,           /* cmd */
92   NULL,           /* allow_commands */
93   NULL,           /* environment */
94   US"/bin:/usr/bin",  /* path */
95   NULL,           /* message_prefix (reset in init if not bsmtp) */
96   NULL,           /* message_suffix (ditto) */
97   US mac_expanded_string(EX_TEMPFAIL) ":"    /* temp_errors */
98      mac_expanded_string(EX_CANTCREAT),
99   NULL,           /* check_string */
100   NULL,           /* escape_string */
101   022,            /* umask */
102   20480,          /* max_output */
103   60*60,          /* timeout */
104   0,              /* options */
105   FALSE,          /* force_command */
106   FALSE,          /* freeze_exec_fail */
107   FALSE,          /* freeze_signal */
108   FALSE,          /* ignore_status */
109   FALSE,          /* permit_coredump */
110   FALSE,          /* restrict_to_path */
111   FALSE,          /* timeout_defer */
112   FALSE,          /* use_shell */
113   FALSE,          /* use_bsmtp */
114   FALSE,          /* use_classresources */
115   FALSE           /* use_crlf */
116 };
117
118
119
120 /*************************************************
121 *              Setup entry point                 *
122 *************************************************/
123
124 /* Called for each delivery in the privileged state, just before the uid/gid
125 are changed and the main entry point is called. In a system that supports the
126 login_cap facilities, this function is used to set the class resource limits
127 for the user.  It may also re-enable coredumps.
128
129 Arguments:
130   tblock     points to the transport instance
131   addrlist   addresses about to be delivered (not used)
132   dummy      not used (doesn't pass back data)
133   uid        the uid that will be set (not used)
134   gid        the gid that will be set (not used)
135   errmsg     where to put an error message
136
137 Returns:     OK, FAIL, or DEFER
138 */
139
140 static int
141 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
142   transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
143 {
144 pipe_transport_options_block *ob =
145   (pipe_transport_options_block *)(tblock->options_block);
146
147 #ifdef HAVE_SETCLASSRESOURCES
148 if (ob->use_classresources)
149   {
150   struct passwd *pw = getpwuid(uid);
151   if (pw != NULL)
152     {
153     login_cap_t *lc = login_getpwclass(pw);
154     if (lc != NULL)
155       {
156       setclassresources(lc);
157       login_close(lc);
158       }
159     }
160   }
161 #endif
162
163 #ifdef RLIMIT_CORE
164 if (ob->permit_coredump)
165   {
166   struct rlimit rl;
167   rl.rlim_cur = RLIM_INFINITY;
168   rl.rlim_max = RLIM_INFINITY;
169   if (setrlimit(RLIMIT_CORE, &rl) < 0)
170     {
171 #ifdef SETRLIMIT_NOT_SUPPORTED
172     if (errno != ENOSYS && errno != ENOTSUP)
173 #endif
174       log_write(0, LOG_MAIN,
175           "delivery setrlimit(RLIMIT_CORE, RLIM_INFINITY) failed: %s",
176           strerror(errno));
177     }
178   }
179 #endif
180
181 return OK;
182 }
183
184
185
186 /*************************************************
187 *          Initialization entry point            *
188 *************************************************/
189
190 /* Called for each instance, after its options have been read, to
191 enable consistency checks to be done, or anything else that needs
192 to be set up. */
193
194 void
195 pipe_transport_init(transport_instance *tblock)
196 {
197 pipe_transport_options_block *ob =
198   (pipe_transport_options_block *)(tblock->options_block);
199
200 /* Set up the setup entry point, to be called in the privileged state */
201
202 tblock->setup = pipe_transport_setup;
203
204 /* If pipe_as_creator is set, then uid/gid should not be set. */
205
206 if (tblock->deliver_as_creator && (tblock->uid_set || tblock->gid_set ||
207   tblock->expand_uid != NULL || tblock->expand_gid != NULL))
208     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
209       "both pipe_as_creator and an explicit uid/gid are set for the %s "
210         "transport", tblock->name);
211
212 /* If a fixed uid field is set, then a gid field must also be set. */
213
214 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
215   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
216     "user set without group for the %s transport", tblock->name);
217
218 /* Temp_errors must consist only of digits and colons, but there can be
219 spaces round the colons, so allow them too. */
220
221 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
222   {
223   size_t p = Ustrspn(ob->temp_errors, "0123456789: ");
224   if (ob->temp_errors[p] != 0)
225     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
226       "temp_errors must be a list of numbers or an asterisk for the %s "
227       "transport", tblock->name);
228   }
229
230 /* Only one of return_output/return_fail_output or log_output/log_fail_output
231 should be set. */
232
233 if (tblock->return_output && tblock->return_fail_output)
234   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
235     "both return_output and return_fail_output set for %s transport",
236     tblock->name);
237
238 if (tblock->log_output && tblock->log_fail_output)
239   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
240     "both log_output and log_fail_output set for the %s transport",
241     tblock->name);
242
243 /* If batch SMTP is set, force the check and escape strings, and arrange that
244 headers are also escaped. */
245
246 if (ob->use_bsmtp)
247   {
248   ob->check_string = US".";
249   ob->escape_string = US"..";
250   ob->options |= topt_escape_headers;
251   }
252
253 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
254 default values for them. */
255
256 else
257   {
258   if (ob->message_prefix == NULL) ob->message_prefix =
259     US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
260   if (ob->message_suffix == NULL) ob->message_suffix = US"\n";
261   }
262
263 /* The restrict_to_path  and use_shell options are incompatible */
264
265 if (ob->restrict_to_path && ob->use_shell)
266   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
267     "both restrict_to_path and use_shell set for %s transport",
268     tblock->name);
269
270 /* The allow_commands and use_shell options are incompatible */
271
272 if (ob->allow_commands && ob->use_shell)
273   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
274     "both allow_commands and use_shell set for %s transport",
275     tblock->name);
276
277 /* Set up the bitwise options for transport_write_message from the various
278 driver options. Only one of body_only and headers_only can be set. */
279
280 ob->options |=
281   (tblock->body_only? topt_no_headers : 0) |
282   (tblock->headers_only? topt_no_body : 0) |
283   (tblock->return_path_add? topt_add_return_path : 0) |
284   (tblock->delivery_date_add? topt_add_delivery_date : 0) |
285   (tblock->envelope_to_add? topt_add_envelope_to : 0) |
286   (ob->use_crlf? topt_use_crlf : 0);
287 }
288
289
290
291 /*************************************************
292 *          Set up direct (non-shell) command     *
293 *************************************************/
294
295 /* This function is called when a command line is to be parsed by the transport
296 and executed directly, without the use of /bin/sh.
297
298 Arguments:
299   argvptr            pointer to anchor for argv vector
300   cmd                points to the command string
301   expand_arguments   true if expansion is to occur
302   expand_fail        error if expansion fails
303   addr               chain of addresses
304   tname              the transport name
305   ob                 the transport options block
306
307 Returns:             TRUE if all went well; otherwise an error will be
308                      set in the first address and FALSE returned
309 */
310
311 static BOOL
312 set_up_direct_command(const uschar ***argvptr, uschar *cmd,
313   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname,
314   pipe_transport_options_block *ob)
315 {
316 BOOL permitted = FALSE;
317 const uschar **argv;
318
319 /* Set up "transport <name>" to be put in any error messages, and then
320 call the common function for creating an argument list and expanding
321 the items if necessary. If it fails, this function fails (error information
322 is in the addresses). */
323
324 if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
325       addr, string_sprintf("%.50s transport", tname), NULL))
326   return FALSE;
327
328 /* Point to the set-up arguments. */
329
330 argv = *argvptr;
331
332 /* If allow_commands is set, see if the command is in the permitted list. */
333
334 if (ob->allow_commands)
335   {
336   int sep = 0;
337   const uschar *s;
338   uschar *p;
339
340   if (!(s = expand_string(ob->allow_commands)))
341     {
342     addr->transport_return = DEFER;
343     addr->message = string_sprintf("failed to expand string \"%s\" "
344       "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
345     return FALSE;
346     }
347
348   while ((p = string_nextinlist(&s, &sep, NULL, 0)))
349     if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
350   }
351
352 /* If permitted is TRUE it means the command was found in the allowed list, and
353 no further checks are done. If permitted = FALSE, it either means
354 allow_commands wasn't set, or that the command didn't match anything in the
355 list. In both cases, if restrict_to_path is set, we fail if the command
356 contains any slashes, but if restrict_to_path is not set, we must fail the
357 command only if allow_commands is set. */
358
359 if (!permitted)
360   {
361   if (ob->restrict_to_path)
362     {
363     if (Ustrchr(argv[0], '/') != NULL)
364       {
365       addr->transport_return = FAIL;
366       addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
367         "transport) - failed for security reasons", cmd, tname);
368       return FALSE;
369       }
370     }
371
372   else if (ob->allow_commands)
373     {
374     addr->transport_return = FAIL;
375     addr->message = string_sprintf("\"%s\" command not permitted by %s "
376       "transport", argv[0], tname);
377     return FALSE;
378     }
379   }
380
381 /* If the command is not an absolute path, search the PATH directories
382 for it. */
383
384 if (argv[0][0] != '/')
385   {
386   int sep = 0;
387   uschar *p;
388   const uschar *listptr = expand_string(ob->path);
389
390   while ((p = string_nextinlist(&listptr, &sep, NULL, 0)))
391     {
392     struct stat statbuf;
393     sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
394     if (Ustat(big_buffer, &statbuf) == 0)
395       {
396       argv[0] = string_copy(big_buffer);
397       break;
398       }
399     }
400   if (!p)
401     {
402     addr->transport_return = FAIL;
403     addr->message = string_sprintf("\"%s\" command not found for %s transport",
404       argv[0], tname);
405     return FALSE;
406     }
407   }
408
409 return TRUE;
410 }
411
412
413 /*************************************************
414 *               Set up shell command             *
415 *************************************************/
416
417 /* This function is called when a command line is to be passed to /bin/sh
418 without parsing inside the transport.
419
420 Arguments:
421   argvptr            pointer to anchor for argv vector
422   cmd                points to the command string
423   expand_arguments   true if expansion is to occur
424   expand_fail        error if expansion fails
425   addr               chain of addresses
426   tname              the transport name
427
428 Returns:             TRUE if all went well; otherwise an error will be
429                      set in the first address and FALSE returned
430 */
431
432 static BOOL
433 set_up_shell_command(const uschar ***argvptr, uschar *cmd,
434   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname)
435 {
436 const uschar **argv;
437
438 *argvptr = argv = store_get((4)*sizeof(uschar *), FALSE);
439
440 argv[0] = US"/bin/sh";
441 argv[1] = US"-c";
442
443 /* We have to take special action to handle the special "variable" called
444 $pipe_addresses, which is not recognized by the normal expansion function. */
445
446 if (expand_arguments)
447   {
448   uschar * p = Ustrstr(cmd, "pipe_addresses");
449   gstring * g = NULL;
450
451   DEBUG(D_transport)
452     debug_printf("shell pipe command before expansion:\n  %s\n", cmd);
453
454   /* Allow $recipients in the expansion iff it comes from a system filter */
455
456   f.enable_dollar_recipients = addr && addr->parent &&
457     Ustrcmp(addr->parent->address, "system-filter") == 0;
458
459   if (p != NULL && (
460          (p > cmd && p[-1] == '$') ||
461          (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
462     {
463     uschar *q = p + 14;
464
465     if (p[-1] == '{') { q++; p--; }
466
467     g = string_get(Ustrlen(cmd) + 64);
468     g = string_catn(g, cmd, p - cmd - 1);
469
470     for (address_item * ad = addr; ad; ad = ad->next)
471       {
472       /*XXX string_append_listele() ? */
473       if (ad != addr) g = string_catn(g, US" ", 1);
474       g = string_cat(g, ad->address);
475       }
476
477     g = string_cat(g, q);
478     argv[2] = (cmd = string_from_gstring(g)) ? expand_string(cmd) : NULL;
479     }
480   else
481     argv[2] = expand_string(cmd);
482
483   f.enable_dollar_recipients = FALSE;
484
485   if (!argv[2])
486     {
487     addr->transport_return = f.search_find_defer ? DEFER : expand_fail;
488     addr->message = string_sprintf("Expansion of command \"%s\" "
489       "in %s transport failed: %s",
490       cmd, tname, expand_string_message);
491     return FALSE;
492     }
493
494   DEBUG(D_transport)
495     debug_printf("shell pipe command after expansion:\n  %s\n", argv[2]);
496   }
497 else
498   {
499   DEBUG(D_transport)
500     debug_printf("shell pipe command (no expansion):\n  %s\n", cmd);
501   argv[2] = cmd;
502   }
503
504 argv[3] = US 0;
505 return TRUE;
506 }
507
508
509
510
511 /*************************************************
512 *              Main entry point                  *
513 *************************************************/
514
515 /* See local README for interface details. This transport always returns FALSE,
516 indicating that the status in the first address is the status for all addresses
517 in a batch. */
518
519 BOOL
520 pipe_transport_entry(
521   transport_instance *tblock,      /* data for this instantiation */
522   address_item *addr)              /* address(es) we are working on */
523 {
524 pid_t pid, outpid;
525 int fd_in, fd_out, rc;
526 int envcount = 0;
527 int envsep = 0;
528 int expand_fail;
529 pipe_transport_options_block *ob =
530   (pipe_transport_options_block *)(tblock->options_block);
531 int timeout = ob->timeout;
532 BOOL written_ok = FALSE;
533 BOOL expand_arguments;
534 const uschar **argv;
535 uschar *envp[50];
536 const uschar *envlist = ob->environment;
537 uschar *cmd, *ss;
538 uschar *eol = ob->use_crlf ? US"\r\n" : US"\n";
539 transport_ctx tctx = {
540   .tblock = tblock,
541   .addr = addr,
542   .check_string = ob->check_string,
543   .escape_string = ob->escape_string,
544   ob->options | topt_not_socket /* set at initialization time */
545 };
546
547 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
548
549 /* Set up for the good case */
550
551 addr->transport_return = OK;
552 addr->basic_errno = 0;
553
554 /* Pipes are not accepted as general addresses, but they can be generated from
555 .forward files or alias files. In those cases, the pfr flag is set, and the
556 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
557 symbol. In other cases, the command is supplied as one of the pipe transport's
558 options. */
559
560 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
561   if (ob->force_command)
562     {
563     /* Enables expansion of $address_pipe into separate arguments */
564     setflag(addr, af_force_command);
565     cmd = ob->cmd;
566     expand_arguments = TRUE;
567     expand_fail = PANIC;
568     }
569   else
570     {
571     cmd = addr->local_part + 1;
572     while (isspace(*cmd)) cmd++;
573     expand_arguments = testflag(addr, af_expand_pipe);
574     expand_fail = FAIL;
575     }
576 else
577   {
578   cmd = ob->cmd;
579   expand_arguments = TRUE;
580   expand_fail = PANIC;
581   }
582
583 /* If no command has been supplied, we are in trouble.
584  * We also check for an empty string since it may be
585  * coming from addr->local_part[0] == '|'
586  */
587
588 if (!cmd || !*cmd)
589   {
590   addr->transport_return = DEFER;
591   addr->message = string_sprintf("no command specified for %s transport",
592     tblock->name);
593   return FALSE;
594   }
595
596 { uschar *m;
597 if ((m = is_tainted2(cmd, 0, "Tainted '%s' (command "
598     "for %s transport) not permitted", cmd, tblock->name)))
599   {
600   addr->transport_return = PANIC;
601   addr->message = m;
602   return FALSE;
603   }
604 }
605
606 /* When a pipe is set up by a filter file, there may be values for $thisaddress
607 and numerical the variables in existence. These are passed in
608 addr->pipe_expandn for use here. */
609
610 if (expand_arguments && addr->pipe_expandn)
611   {
612   uschar **ss = addr->pipe_expandn;
613   expand_nmax = -1;
614   if (*ss) filter_thisaddress = *ss++;
615   while (*ss)
616     {
617     expand_nstring[++expand_nmax] = *ss;
618     expand_nlength[expand_nmax] = Ustrlen(*ss++);
619     }
620   }
621
622 /* The default way of processing the command is to split it up into arguments
623 here, and run it directly. This offers some security advantages. However, there
624 are installations that want by default to run commands under /bin/sh always, so
625 there is an option to do that. */
626
627 if (ob->use_shell)
628   {
629   if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
630     tblock->name)) return FALSE;
631   }
632 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
633   tblock->name, ob)) return FALSE;
634
635 expand_nmax = -1;           /* Reset */
636 filter_thisaddress = NULL;
637
638 /* Set up the environment for the command. */
639
640 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
641 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
642 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
643 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
644   deliver_localpart_prefix);
645 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
646   deliver_localpart_suffix);
647 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
648 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
649 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
650 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
651 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
652   deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
653   deliver_domain);
654 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
655 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
656 envp[envcount++] = US"SHELL=/bin/sh";
657
658 if (addr->host_list != NULL)
659   envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
660
661 if (f.timestamps_utc) envp[envcount++] = US"TZ=UTC";
662 else if (timezone_string != NULL && timezone_string[0] != 0)
663   envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
664
665 /* Add any requested items */
666
667 if (envlist)
668   if (!(envlist = expand_cstring(envlist)))
669     {
670     addr->transport_return = DEFER;
671     addr->message = string_sprintf("failed to expand string \"%s\" "
672       "for %s transport: %s", ob->environment, tblock->name,
673       expand_string_message);
674     return FALSE;
675     }
676
677 while ((ss = string_nextinlist(&envlist, &envsep, NULL, 0)))
678    {
679    if (envcount > nelem(envp) - 2)
680      {
681      addr->transport_return = DEFER;
682      addr->basic_errno = E2BIG;
683      addr->message = string_sprintf("too many environment settings for "
684        "%s transport", tblock->name);
685      return FALSE;
686      }
687    envp[envcount++] = string_copy(ss);
688    }
689
690 envp[envcount] = NULL;
691
692 /* If the -N option is set, can't do any more. */
693
694 if (f.dont_deliver)
695   {
696   DEBUG(D_transport)
697     debug_printf("*** delivery by %s transport bypassed by -N option",
698       tblock->name);
699   return FALSE;
700   }
701
702
703 /* Handling the output from the pipe is tricky. If a file for catching this
704 output is provided, we could in theory just hand that fd over to the process,
705 but this isn't very safe because it might loop and carry on writing for
706 ever (which is exactly what happened in early versions of Exim). Therefore we
707 use the standard child_open() function, which creates pipes. We can then read
708 our end of the output pipe and count the number of bytes that come through,
709 chopping the sub-process if it exceeds some limit.
710
711 However, this means we want to run a sub-process with both its input and output
712 attached to pipes. We can't handle that easily from a single parent process
713 using straightforward code such as the transport_write_message() function
714 because the subprocess might not be reading its input because it is trying to
715 write to a full output pipe. The complication of redesigning the world to
716 handle this is too great - simpler just to run another process to do the
717 reading of the output pipe. */
718
719
720 /* As this is a local transport, we are already running with the required
721 uid/gid and current directory. Request that the new process be a process group
722 leader, so we can kill it and all its children on a timeout. */
723
724 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE,
725                         US"pipe-tpt-cmd")) < 0)
726   {
727   addr->transport_return = DEFER;
728   addr->message = string_sprintf(
729     "Failed to create child process for %s transport: %s", tblock->name,
730       strerror(errno));
731   return FALSE;
732   }
733 tctx.u.fd = fd_in;
734
735 /* Now fork a process to handle the output that comes down the pipe. */
736
737 if ((outpid = exim_fork(US"pipe-tpt-output")) < 0)
738   {
739   addr->basic_errno = errno;
740   addr->transport_return = DEFER;
741   addr->message = string_sprintf(
742     "Failed to create process for handling output in %s transport",
743       tblock->name);
744   (void)close(fd_in);
745   (void)close(fd_out);
746   return FALSE;
747   }
748
749 /* This is the code for the output-handling subprocess. Read from the pipe
750 in chunks, and write to the return file if one is provided. Keep track of
751 the number of bytes handled. If the limit is exceeded, try to kill the
752 subprocess group, and in any case close the pipe and exit, which should cause
753 the subprocess to fail. */
754
755 if (outpid == 0)
756   {
757   int count = 0;
758   (void)close(fd_in);
759   set_process_info("reading output from |%s", cmd);
760   while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
761     {
762     if (addr->return_file >= 0)
763       if(write(addr->return_file, big_buffer, rc) != rc)
764         DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
765     count += rc;
766     if (count > ob->max_output)
767       {
768       DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
769       if (addr->return_file >= 0)
770         {
771         uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
772         rc = Ustrlen(message);
773         if(write(addr->return_file, message, rc) != rc)
774           DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
775         }
776       killpg(pid, SIGKILL);
777       break;
778       }
779     }
780   (void)close(fd_out);
781   _exit(0);
782   }
783
784 (void)close(fd_out);  /* Not used in this process */
785
786
787 /* Carrying on now with the main parent process. Attempt to write the message
788 to it down the pipe. It is a fallacy to think that you can detect write errors
789 when the sub-process fails to read the pipe. The parent process may complete
790 writing and close the pipe before the sub-process completes. We could sleep a
791 bit here to let the sub-process get going, but it may still not complete. So we
792 ignore all writing errors. (When in the test harness, we do do a short sleep so
793 any debugging output is likely to be in the same order.) */
794
795 testharness_pause_ms(500);
796
797 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
798
799 /* Arrange to time out writes if there is a timeout set. */
800
801 if (timeout > 0)
802   {
803   sigalrm_seen = FALSE;
804   transport_write_timeout = timeout;
805   }
806
807 /* Reset the counter of bytes written */
808
809 transport_count = 0;
810
811 /* First write any configured prefix information */
812
813 if (ob->message_prefix)
814   {
815   uschar *prefix = expand_string(ob->message_prefix);
816   if (!prefix)
817     {
818     addr->transport_return = f.search_find_defer? DEFER : PANIC;
819     addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
820       "transport) failed: %s", ob->message_prefix, tblock->name,
821       expand_string_message);
822     return FALSE;
823     }
824   if (!transport_write_block(&tctx, prefix, Ustrlen(prefix), FALSE))
825     goto END_WRITE;
826   }
827
828 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
829 The various different values for batching are handled outside; if there is more
830 than one address available here, all must be included. Force SMTP dot-handling.
831 */
832
833 if (ob->use_bsmtp)
834   {
835   if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
836     goto END_WRITE;
837
838   for (address_item * a = addr; a; a = a->next)
839     if (!transport_write_string(fd_in,
840         "RCPT TO:<%s>%s",
841         transport_rcpt_address(a, tblock->rcpt_include_affixes),
842         eol))
843       goto END_WRITE;
844
845   if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
846   }
847
848 /* Now the actual message */
849
850 if (!transport_write_message(&tctx, 0))
851     goto END_WRITE;
852
853 /* Now any configured suffix */
854
855 if (ob->message_suffix)
856   {
857   uschar *suffix = expand_string(ob->message_suffix);
858   if (!suffix)
859     {
860     addr->transport_return = f.search_find_defer? DEFER : PANIC;
861     addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
862       "transport) failed: %s", ob->message_suffix, tblock->name,
863       expand_string_message);
864     return FALSE;
865     }
866   if (!transport_write_block(&tctx, suffix, Ustrlen(suffix), FALSE))
867     goto END_WRITE;
868   }
869
870 /* If local_smtp, write the terminating dot. */
871
872 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
873   goto END_WRITE;
874
875 /* Flag all writing completed successfully. */
876
877 written_ok = TRUE;
878
879 /* Come here if there are errors during writing. */
880
881 END_WRITE:
882
883 /* OK, the writing is now all done. Close the pipe. */
884
885 (void) close(fd_in);
886
887 /* Handle errors during writing. For timeouts, set the timeout for waiting for
888 the child process to 1 second. If the process at the far end of the pipe died
889 without reading all of it, we expect an EPIPE error, which should be ignored.
890 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
891 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
892 comments therein. */
893
894 if (!written_ok)
895   {
896   if (errno == ETIMEDOUT)
897     {
898     addr->message = string_sprintf("%stimeout while writing to pipe",
899       f.transport_filter_timed_out ? "transport filter " : "");
900     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
901     timeout = 1;
902     }
903   else if (errno == EPIPE)
904     {
905     debug_printf("transport error EPIPE ignored\n");
906     }
907   else
908     {
909     addr->transport_return = PANIC;
910     addr->basic_errno = errno;
911     if (errno == ERRNO_CHHEADER_FAIL)
912       addr->message =
913         string_sprintf("Failed to expand headers_add or headers_remove: %s",
914           expand_string_message);
915     else if (errno == ERRNO_FILTER_FAIL)
916       addr->message = string_sprintf("Transport filter process failed (%d)%s",
917       addr->more_errno,
918       (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
919     else if (errno == ERRNO_WRITEINCOMPLETE)
920       addr->message = US"Failed repeatedly to write data";
921     else
922       addr->message = string_sprintf("Error %d", errno);
923     return FALSE;
924     }
925   }
926
927 /* Wait for the child process to complete and take action if the returned
928 status is nonzero. The timeout will be just 1 second if any of the writes
929 above timed out. */
930
931 if ((rc = child_close(pid, timeout)) != 0)
932   {
933   uschar * tmsg = addr->message
934     ? string_sprintf(" (preceded by %s)", addr->message) : US"";
935
936   /* The process did not complete in time; kill its process group and fail
937   the delivery. It appears to be necessary to kill the output process too, as
938   otherwise it hangs on for some time if the actual pipe process is sleeping.
939   (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
940   the delivery, that shouldn't cause any problem. */
941
942   if (rc == -256)
943     {
944     killpg(pid, SIGKILL);
945     kill(outpid, SIGKILL);
946     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
947     addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
948     }
949
950   /* Wait() failed. */
951
952   else if (rc == -257)
953     {
954     addr->transport_return = PANIC;
955     addr->message = string_sprintf("Wait() failed for child process of %s "
956       "transport: %s%s", tblock->name, strerror(errno), tmsg);
957     }
958
959   /* Since the transport_filter timed out we assume it has sent the child process
960   a malformed or incomplete data stream.  Kill off the child process
961   and prevent checking its exit status as it will has probably exited in error.
962   This prevents the transport_filter timeout message from getting overwritten
963   by the exit error which is not the cause of the problem. */
964
965   else if (f.transport_filter_timed_out)
966     {
967     killpg(pid, SIGKILL);
968     kill(outpid, SIGKILL);
969     }
970
971   /* Either the process completed, but yielded a non-zero (necessarily
972   positive) status, or the process was terminated by a signal (rc will contain
973   the negation of the signal number). Treat killing by signal as failure unless
974   status is being ignored. By default, the message is bounced back, unless
975   freeze_signal is set, in which case it is frozen instead. */
976
977   else if (rc < 0)
978     {
979     if (ob->freeze_signal)
980       {
981       addr->transport_return = DEFER;
982       addr->special_action = SPECIAL_FREEZE;
983       addr->message = string_sprintf("Child process of %s transport (running "
984         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
985         -rc, os_strsignal(-rc), tmsg);
986       }
987     else if (!ob->ignore_status)
988       {
989       addr->transport_return = FAIL;
990       addr->message = string_sprintf("Child process of %s transport (running "
991         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
992         -rc, os_strsignal(-rc), tmsg);
993       }
994     }
995
996   /* For positive values (process terminated with non-zero status), we need a
997   status code to request deferral. A number of systems contain the following
998   line in sysexits.h:
999
1000       #define EX_TEMPFAIL 75
1001
1002   with the description
1003
1004       EX_TEMPFAIL -- temporary failure, indicating something that
1005          is not really an error.  In sendmail, this means
1006          that a mailer (e.g.) could not create a connection,
1007          and the request should be reattempted later.
1008
1009   Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1010   not ignoring the returned status. However, there is now an option that
1011   contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1012
1013   Another case that needs special treatment is if execve() failed (typically
1014   the command that was given is a non-existent path). By default this is
1015   treated as just another failure, but if freeze_exec_fail is set, the reaction
1016   is to freeze the message rather than bounce the address. Exim used to signal
1017   this failure with EX_UNAVAILABLE, which is defined in many systems as
1018
1019       #define EX_UNAVAILABLE  69
1020
1021   with the description
1022
1023       EX_UNAVAILABLE -- A service is unavailable.  This can occur
1024             if a support program or file does not exist.  This
1025             can also be used as a catchall message when something
1026             you wanted to do doesn't work, but you don't know why.
1027
1028   However, this can be confused with a command that actually returns 69 because
1029   something *it* wanted is unavailable. At release 4.21, Exim was changed to
1030   use return code 127 instead, because this is what the shell returns when it
1031   is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1032   child.c to signal execve() failure and other unexpected failures such as
1033   setuid() not working - though that won't be the case here because we aren't
1034   changing uid. */
1035
1036   else
1037     {
1038     /* Always handle execve() failure specially if requested to */
1039
1040     if (ob->freeze_exec_fail  &&  rc == EX_EXECFAILED)
1041       {
1042       addr->transport_return = DEFER;
1043       addr->special_action = SPECIAL_FREEZE;
1044       addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1045         cmd, tmsg);
1046       }
1047
1048     /* Otherwise take action only if not ignoring status */
1049
1050     else if (!ob->ignore_status)
1051       {
1052       uschar *ss;
1053       gstring * g;
1054
1055       /* If temp_errors is "*" all codes are temporary. Initialization checks
1056       that it's either "*" or a list of numbers. If not "*", scan the list of
1057       temporary failure codes; if any match, the result is DEFER. */
1058
1059       if (ob->temp_errors[0] == '*')
1060         addr->transport_return = DEFER;
1061
1062       else
1063         {
1064         const uschar *s = ob->temp_errors;
1065         uschar *p;
1066         int sep = 0;
1067
1068         addr->transport_return = FAIL;
1069         while ((p = string_nextinlist(&s,&sep,NULL,0)))
1070           if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1071         }
1072
1073       /* Ensure the message contains the expanded command and arguments. This
1074       doesn't have to be brilliantly efficient - it is an error situation. */
1075
1076       addr->message = string_sprintf("Child process of %s transport returned "
1077         "%d", tblock->name, rc);
1078       g = string_cat(NULL, addr->message);
1079
1080       /* If the return code is > 128, it often means that a shell command
1081       was terminated by a signal. */
1082
1083       ss = (rc > 128)?
1084         string_sprintf("(could mean shell command ended by signal %d (%s))",
1085           rc-128, os_strsignal(rc-128)) :
1086         US os_strexit(rc);
1087
1088       if (*ss)
1089         {
1090         g = string_catn(g, US" ", 1);
1091         g = string_cat (g, ss);
1092         }
1093
1094       /* Now add the command and arguments */
1095
1096       g = string_catn(g, US" from command:", 14);
1097
1098       for (int i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1099         {
1100         BOOL quote = FALSE;
1101         g = string_catn(g, US" ", 1);
1102         if (Ustrpbrk(argv[i], " \t") != NULL)
1103           {
1104           quote = TRUE;
1105           g = string_catn(g, US"\"", 1);
1106           }
1107         g = string_cat(g, argv[i]);
1108         if (quote)
1109           g = string_catn(g, US"\"", 1);
1110         }
1111
1112       /* Add previous filter timeout message, if present. */
1113
1114       if (*tmsg)
1115         g = string_cat(g, tmsg);
1116
1117       addr->message = string_from_gstring(g);
1118       }
1119     }
1120   }
1121
1122 /* Ensure all subprocesses (in particular, the output handling process)
1123 are complete before we pass this point. */
1124
1125 while (wait(&rc) >= 0);
1126
1127 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1128   addr->transport_return);
1129
1130 /* If there has been a problem, the message in addr->message contains details
1131 of the pipe command. We don't want to expose these to the world, so we set up
1132 something bland to return to the sender. */
1133
1134 if (addr->transport_return != OK)
1135   addr->user_message = US"local delivery failed";
1136
1137 return FALSE;
1138 }
1139
1140 #endif  /*!MACRO_PREDEF*/
1141 /* End of transport/pipe.c */