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