1cb574ee72c791a4e98b2699774b930e9b18fd62
[users/heiko/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 if (is_tainted(cmd))
596   {
597   addr->message = string_sprintf("Tainted '%s' (command "
598     "for %s transport) not permitted", cmd, tblock->name);
599   addr->transport_return = PANIC;
600   return FALSE;
601   }
602
603 /* When a pipe is set up by a filter file, there may be values for $thisaddress
604 and numerical the variables in existence. These are passed in
605 addr->pipe_expandn for use here. */
606
607 if (expand_arguments && addr->pipe_expandn)
608   {
609   uschar **ss = addr->pipe_expandn;
610   expand_nmax = -1;
611   if (*ss) filter_thisaddress = *ss++;
612   while (*ss)
613     {
614     expand_nstring[++expand_nmax] = *ss;
615     expand_nlength[expand_nmax] = Ustrlen(*ss++);
616     }
617   }
618
619 /* The default way of processing the command is to split it up into arguments
620 here, and run it directly. This offers some security advantages. However, there
621 are installations that want by default to run commands under /bin/sh always, so
622 there is an option to do that. */
623
624 if (ob->use_shell)
625   {
626   if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
627     tblock->name)) return FALSE;
628   }
629 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
630   tblock->name, ob)) return FALSE;
631
632 expand_nmax = -1;           /* Reset */
633 filter_thisaddress = NULL;
634
635 /* Set up the environment for the command. */
636
637 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
638 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
639 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
640 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
641   deliver_localpart_prefix);
642 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
643   deliver_localpart_suffix);
644 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
645 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
646 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
647 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
648 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
649   deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
650   deliver_domain);
651 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
652 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
653 envp[envcount++] = US"SHELL=/bin/sh";
654
655 if (addr->host_list != NULL)
656   envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
657
658 if (f.timestamps_utc) envp[envcount++] = US"TZ=UTC";
659 else if (timezone_string != NULL && timezone_string[0] != 0)
660   envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
661
662 /* Add any requested items */
663
664 if (envlist)
665   if (!(envlist = expand_cstring(envlist)))
666     {
667     addr->transport_return = DEFER;
668     addr->message = string_sprintf("failed to expand string \"%s\" "
669       "for %s transport: %s", ob->environment, tblock->name,
670       expand_string_message);
671     return FALSE;
672     }
673
674 while ((ss = string_nextinlist(&envlist, &envsep, NULL, 0)))
675    {
676    if (envcount > nelem(envp) - 2)
677      {
678      addr->transport_return = DEFER;
679      addr->basic_errno = E2BIG;
680      addr->message = string_sprintf("too many environment settings for "
681        "%s transport", tblock->name);
682      return FALSE;
683      }
684    envp[envcount++] = string_copy(ss);
685    }
686
687 envp[envcount] = NULL;
688
689 /* If the -N option is set, can't do any more. */
690
691 if (f.dont_deliver)
692   {
693   DEBUG(D_transport)
694     debug_printf("*** delivery by %s transport bypassed by -N option",
695       tblock->name);
696   return FALSE;
697   }
698
699
700 /* Handling the output from the pipe is tricky. If a file for catching this
701 output is provided, we could in theory just hand that fd over to the process,
702 but this isn't very safe because it might loop and carry on writing for
703 ever (which is exactly what happened in early versions of Exim). Therefore we
704 use the standard child_open() function, which creates pipes. We can then read
705 our end of the output pipe and count the number of bytes that come through,
706 chopping the sub-process if it exceeds some limit.
707
708 However, this means we want to run a sub-process with both its input and output
709 attached to pipes. We can't handle that easily from a single parent process
710 using straightforward code such as the transport_write_message() function
711 because the subprocess might not be reading its input because it is trying to
712 write to a full output pipe. The complication of redesigning the world to
713 handle this is too great - simpler just to run another process to do the
714 reading of the output pipe. */
715
716
717 /* As this is a local transport, we are already running with the required
718 uid/gid and current directory. Request that the new process be a process group
719 leader, so we can kill it and all its children on a timeout. */
720
721 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE,
722                         US"pipe-tpt-cmd")) < 0)
723   {
724   addr->transport_return = DEFER;
725   addr->message = string_sprintf(
726     "Failed to create child process for %s transport: %s", tblock->name,
727       strerror(errno));
728   return FALSE;
729   }
730 tctx.u.fd = fd_in;
731
732 /* Now fork a process to handle the output that comes down the pipe. */
733
734 if ((outpid = exim_fork(US"pipe-tpt-output")) < 0)
735   {
736   addr->basic_errno = errno;
737   addr->transport_return = DEFER;
738   addr->message = string_sprintf(
739     "Failed to create process for handling output in %s transport",
740       tblock->name);
741   (void)close(fd_in);
742   (void)close(fd_out);
743   return FALSE;
744   }
745
746 /* This is the code for the output-handling subprocess. Read from the pipe
747 in chunks, and write to the return file if one is provided. Keep track of
748 the number of bytes handled. If the limit is exceeded, try to kill the
749 subprocess group, and in any case close the pipe and exit, which should cause
750 the subprocess to fail. */
751
752 if (outpid == 0)
753   {
754   int count = 0;
755   (void)close(fd_in);
756   set_process_info("reading output from |%s", cmd);
757   while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
758     {
759     if (addr->return_file >= 0)
760       if(write(addr->return_file, big_buffer, rc) != rc)
761         DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
762     count += rc;
763     if (count > ob->max_output)
764       {
765       DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
766       if (addr->return_file >= 0)
767         {
768         uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
769         rc = Ustrlen(message);
770         if(write(addr->return_file, message, rc) != rc)
771           DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
772         }
773       killpg(pid, SIGKILL);
774       break;
775       }
776     }
777   (void)close(fd_out);
778   _exit(0);
779   }
780
781 (void)close(fd_out);  /* Not used in this process */
782
783
784 /* Carrying on now with the main parent process. Attempt to write the message
785 to it down the pipe. It is a fallacy to think that you can detect write errors
786 when the sub-process fails to read the pipe. The parent process may complete
787 writing and close the pipe before the sub-process completes. We could sleep a
788 bit here to let the sub-process get going, but it may still not complete. So we
789 ignore all writing errors. (When in the test harness, we do do a short sleep so
790 any debugging output is likely to be in the same order.) */
791
792 testharness_pause_ms(500);
793
794 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
795
796 /* Arrange to time out writes if there is a timeout set. */
797
798 if (timeout > 0)
799   {
800   sigalrm_seen = FALSE;
801   transport_write_timeout = timeout;
802   }
803
804 /* Reset the counter of bytes written */
805
806 transport_count = 0;
807
808 /* First write any configured prefix information */
809
810 if (ob->message_prefix)
811   {
812   uschar *prefix = expand_string(ob->message_prefix);
813   if (!prefix)
814     {
815     addr->transport_return = f.search_find_defer? DEFER : PANIC;
816     addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
817       "transport) failed: %s", ob->message_prefix, tblock->name,
818       expand_string_message);
819     return FALSE;
820     }
821   if (!transport_write_block(&tctx, prefix, Ustrlen(prefix), FALSE))
822     goto END_WRITE;
823   }
824
825 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
826 The various different values for batching are handled outside; if there is more
827 than one address available here, all must be included. Force SMTP dot-handling.
828 */
829
830 if (ob->use_bsmtp)
831   {
832   if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
833     goto END_WRITE;
834
835   for (address_item * a = addr; a; a = a->next)
836     if (!transport_write_string(fd_in,
837         "RCPT TO:<%s>%s",
838         transport_rcpt_address(a, tblock->rcpt_include_affixes),
839         eol))
840       goto END_WRITE;
841
842   if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
843   }
844
845 /* Now the actual message */
846
847 if (!transport_write_message(&tctx, 0))
848     goto END_WRITE;
849
850 /* Now any configured suffix */
851
852 if (ob->message_suffix)
853   {
854   uschar *suffix = expand_string(ob->message_suffix);
855   if (!suffix)
856     {
857     addr->transport_return = f.search_find_defer? DEFER : PANIC;
858     addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
859       "transport) failed: %s", ob->message_suffix, tblock->name,
860       expand_string_message);
861     return FALSE;
862     }
863   if (!transport_write_block(&tctx, suffix, Ustrlen(suffix), FALSE))
864     goto END_WRITE;
865   }
866
867 /* If local_smtp, write the terminating dot. */
868
869 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
870   goto END_WRITE;
871
872 /* Flag all writing completed successfully. */
873
874 written_ok = TRUE;
875
876 /* Come here if there are errors during writing. */
877
878 END_WRITE:
879
880 /* OK, the writing is now all done. Close the pipe. */
881
882 (void) close(fd_in);
883
884 /* Handle errors during writing. For timeouts, set the timeout for waiting for
885 the child process to 1 second. If the process at the far end of the pipe died
886 without reading all of it, we expect an EPIPE error, which should be ignored.
887 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
888 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
889 comments therein. */
890
891 if (!written_ok)
892   {
893   if (errno == ETIMEDOUT)
894     {
895     addr->message = string_sprintf("%stimeout while writing to pipe",
896       f.transport_filter_timed_out ? "transport filter " : "");
897     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
898     timeout = 1;
899     }
900   else if (errno == EPIPE)
901     {
902     debug_printf("transport error EPIPE ignored\n");
903     }
904   else
905     {
906     addr->transport_return = PANIC;
907     addr->basic_errno = errno;
908     if (errno == ERRNO_CHHEADER_FAIL)
909       addr->message =
910         string_sprintf("Failed to expand headers_add or headers_remove: %s",
911           expand_string_message);
912     else if (errno == ERRNO_FILTER_FAIL)
913       addr->message = string_sprintf("Transport filter process failed (%d)%s",
914       addr->more_errno,
915       (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
916     else if (errno == ERRNO_WRITEINCOMPLETE)
917       addr->message = US"Failed repeatedly to write data";
918     else
919       addr->message = string_sprintf("Error %d", errno);
920     return FALSE;
921     }
922   }
923
924 /* Wait for the child process to complete and take action if the returned
925 status is nonzero. The timeout will be just 1 second if any of the writes
926 above timed out. */
927
928 if ((rc = child_close(pid, timeout)) != 0)
929   {
930   uschar * tmsg = addr->message
931     ? string_sprintf(" (preceded by %s)", addr->message) : US"";
932
933   /* The process did not complete in time; kill its process group and fail
934   the delivery. It appears to be necessary to kill the output process too, as
935   otherwise it hangs on for some time if the actual pipe process is sleeping.
936   (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
937   the delivery, that shouldn't cause any problem. */
938
939   if (rc == -256)
940     {
941     killpg(pid, SIGKILL);
942     kill(outpid, SIGKILL);
943     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
944     addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
945     }
946
947   /* Wait() failed. */
948
949   else if (rc == -257)
950     {
951     addr->transport_return = PANIC;
952     addr->message = string_sprintf("Wait() failed for child process of %s "
953       "transport: %s%s", tblock->name, strerror(errno), tmsg);
954     }
955
956   /* Since the transport_filter timed out we assume it has sent the child process
957   a malformed or incomplete data stream.  Kill off the child process
958   and prevent checking its exit status as it will has probably exited in error.
959   This prevents the transport_filter timeout message from getting overwritten
960   by the exit error which is not the cause of the problem. */
961
962   else if (f.transport_filter_timed_out)
963     {
964     killpg(pid, SIGKILL);
965     kill(outpid, SIGKILL);
966     }
967
968   /* Either the process completed, but yielded a non-zero (necessarily
969   positive) status, or the process was terminated by a signal (rc will contain
970   the negation of the signal number). Treat killing by signal as failure unless
971   status is being ignored. By default, the message is bounced back, unless
972   freeze_signal is set, in which case it is frozen instead. */
973
974   else if (rc < 0)
975     {
976     if (ob->freeze_signal)
977       {
978       addr->transport_return = DEFER;
979       addr->special_action = SPECIAL_FREEZE;
980       addr->message = string_sprintf("Child process of %s transport (running "
981         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
982         -rc, os_strsignal(-rc), tmsg);
983       }
984     else if (!ob->ignore_status)
985       {
986       addr->transport_return = FAIL;
987       addr->message = string_sprintf("Child process of %s transport (running "
988         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
989         -rc, os_strsignal(-rc), tmsg);
990       }
991     }
992
993   /* For positive values (process terminated with non-zero status), we need a
994   status code to request deferral. A number of systems contain the following
995   line in sysexits.h:
996
997       #define EX_TEMPFAIL 75
998
999   with the description
1000
1001       EX_TEMPFAIL -- temporary failure, indicating something that
1002          is not really an error.  In sendmail, this means
1003          that a mailer (e.g.) could not create a connection,
1004          and the request should be reattempted later.
1005
1006   Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1007   not ignoring the returned status. However, there is now an option that
1008   contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1009
1010   Another case that needs special treatment is if execve() failed (typically
1011   the command that was given is a non-existent path). By default this is
1012   treated as just another failure, but if freeze_exec_fail is set, the reaction
1013   is to freeze the message rather than bounce the address. Exim used to signal
1014   this failure with EX_UNAVAILABLE, which is defined in many systems as
1015
1016       #define EX_UNAVAILABLE  69
1017
1018   with the description
1019
1020       EX_UNAVAILABLE -- A service is unavailable.  This can occur
1021             if a support program or file does not exist.  This
1022             can also be used as a catchall message when something
1023             you wanted to do doesn't work, but you don't know why.
1024
1025   However, this can be confused with a command that actually returns 69 because
1026   something *it* wanted is unavailable. At release 4.21, Exim was changed to
1027   use return code 127 instead, because this is what the shell returns when it
1028   is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1029   child.c to signal execve() failure and other unexpected failures such as
1030   setuid() not working - though that won't be the case here because we aren't
1031   changing uid. */
1032
1033   else
1034     {
1035     /* Always handle execve() failure specially if requested to */
1036
1037     if (ob->freeze_exec_fail  &&  rc == EX_EXECFAILED)
1038       {
1039       addr->transport_return = DEFER;
1040       addr->special_action = SPECIAL_FREEZE;
1041       addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1042         cmd, tmsg);
1043       }
1044
1045     /* Otherwise take action only if not ignoring status */
1046
1047     else if (!ob->ignore_status)
1048       {
1049       uschar *ss;
1050       gstring * g;
1051
1052       /* If temp_errors is "*" all codes are temporary. Initialization checks
1053       that it's either "*" or a list of numbers. If not "*", scan the list of
1054       temporary failure codes; if any match, the result is DEFER. */
1055
1056       if (ob->temp_errors[0] == '*')
1057         addr->transport_return = DEFER;
1058
1059       else
1060         {
1061         const uschar *s = ob->temp_errors;
1062         uschar *p;
1063         int sep = 0;
1064
1065         addr->transport_return = FAIL;
1066         while ((p = string_nextinlist(&s,&sep,NULL,0)))
1067           if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1068         }
1069
1070       /* Ensure the message contains the expanded command and arguments. This
1071       doesn't have to be brilliantly efficient - it is an error situation. */
1072
1073       addr->message = string_sprintf("Child process of %s transport returned "
1074         "%d", tblock->name, rc);
1075       g = string_cat(NULL, addr->message);
1076
1077       /* If the return code is > 128, it often means that a shell command
1078       was terminated by a signal. */
1079
1080       ss = (rc > 128)?
1081         string_sprintf("(could mean shell command ended by signal %d (%s))",
1082           rc-128, os_strsignal(rc-128)) :
1083         US os_strexit(rc);
1084
1085       if (*ss)
1086         {
1087         g = string_catn(g, US" ", 1);
1088         g = string_cat (g, ss);
1089         }
1090
1091       /* Now add the command and arguments */
1092
1093       g = string_catn(g, US" from command:", 14);
1094
1095       for (int i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1096         {
1097         BOOL quote = FALSE;
1098         g = string_catn(g, US" ", 1);
1099         if (Ustrpbrk(argv[i], " \t") != NULL)
1100           {
1101           quote = TRUE;
1102           g = string_catn(g, US"\"", 1);
1103           }
1104         g = string_cat(g, argv[i]);
1105         if (quote)
1106           g = string_catn(g, US"\"", 1);
1107         }
1108
1109       /* Add previous filter timeout message, if present. */
1110
1111       if (*tmsg)
1112         g = string_cat(g, tmsg);
1113
1114       addr->message = string_from_gstring(g);
1115       }
1116     }
1117   }
1118
1119 /* Ensure all subprocesses (in particular, the output handling process)
1120 are complete before we pass this point. */
1121
1122 while (wait(&rc) >= 0);
1123
1124 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1125   addr->transport_return);
1126
1127 /* If there has been a problem, the message in addr->message contains details
1128 of the pipe command. We don't want to expose these to the world, so we set up
1129 something bland to return to the sender. */
1130
1131 if (addr->transport_return != OK)
1132   addr->user_message = US"local delivery failed";
1133
1134 return FALSE;
1135 }
1136
1137 #endif  /*!MACRO_PREDEF*/
1138 /* End of transport/pipe.c */