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