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