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