eaf04d15061be4b78dfd06b8c9a322a240a824b2
[exim.git] / src / src / transports / pipe.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
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(const uschar ***argvptr, uschar *cmd,
330   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname,
331   pipe_transport_options_block *ob)
332 {
333 BOOL permitted = FALSE;
334 const 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   const uschar *s;
357   uschar *p;
358   uschar buffer[256];
359
360   if (!(s = expand_string(ob->allow_commands)))
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))))
369     if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
370   }
371
372 /* If permitted is TRUE it means the command was found in the allowed list, and
373 no further checks are done. If permitted = FALSE, it either means
374 allow_commands wasn't set, or that the command didn't match anything in the
375 list. In both cases, if restrict_to_path is set, we fail if the command
376 contains any slashes, but if restrict_to_path is not set, we must fail the
377 command only if allow_commands is set. */
378
379 if (!permitted)
380   {
381   if (ob->restrict_to_path)
382     {
383     if (Ustrchr(argv[0], '/') != NULL)
384       {
385       addr->transport_return = FAIL;
386       addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
387         "transport) - failed for security reasons", cmd, tname);
388       return FALSE;
389       }
390     }
391
392   else if (ob->allow_commands != NULL)
393     {
394     addr->transport_return = FAIL;
395     addr->message = string_sprintf("\"%s\" command not permitted by %s "
396       "transport", argv[0], tname);
397     return FALSE;
398     }
399   }
400
401 /* If the command is not an absolute path, search the PATH directories
402 for it. */
403
404 if (argv[0][0] != '/')
405   {
406   int sep = 0;
407   uschar *p;
408   const uschar *listptr = ob->path;
409   uschar buffer[1024];
410
411   while ((p = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer))) != NULL)
412     {
413     struct stat statbuf;
414     sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
415     if (Ustat(big_buffer, &statbuf) == 0)
416       {
417       argv[0] = string_copy(big_buffer);
418       break;
419       }
420     }
421   if (p == NULL)
422     {
423     addr->transport_return = FAIL;
424     addr->message = string_sprintf("\"%s\" command not found for %s transport",
425       argv[0], tname);
426     return FALSE;
427     }
428   }
429
430 return TRUE;
431 }
432
433
434 /*************************************************
435 *               Set up shell command             *
436 *************************************************/
437
438 /* This function is called when a command line is to be passed to /bin/sh
439 without parsing inside the transport.
440
441 Arguments:
442   argvptr            pointer to anchor for argv vector
443   cmd                points to the command string
444   expand_arguments   true if expansion is to occur
445   expand_fail        error if expansion fails
446   addr               chain of addresses
447   tname              the transport name
448
449 Returns:             TRUE if all went well; otherwise an error will be
450                      set in the first address and FALSE returned
451 */
452
453 static BOOL
454 set_up_shell_command(const uschar ***argvptr, uschar *cmd,
455   BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname)
456 {
457 const uschar **argv;
458
459 *argvptr = argv = store_get((4)*sizeof(uschar *));
460
461 argv[0] = US"/bin/sh";
462 argv[1] = US"-c";
463
464 /* We have to take special action to handle the special "variable" called
465 $pipe_addresses, which is not recognized by the normal expansion function. */
466
467 DEBUG(D_transport)
468   debug_printf("shell pipe command before expansion:\n  %s\n", cmd);
469
470 if (expand_arguments)
471   {
472   uschar *s = cmd;
473   uschar *p = Ustrstr(cmd, "pipe_addresses");
474
475   if (p != NULL && (
476          (p > cmd && p[-1] == '$') ||
477          (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
478     {
479     address_item *ad;
480     uschar *q = p + 14;
481     int size = Ustrlen(cmd) + 64;
482     int offset;
483
484     if (p[-1] == '{') { q++; p--; }
485
486     s = store_get(size);
487     offset = p - cmd - 1;
488     Ustrncpy(s, cmd, offset);
489
490     for (ad = addr; ad != NULL; ad = ad->next)
491       {
492       if (ad != addr) string_cat(s, &size, &offset, US" ", 1);
493       string_cat(s, &size, &offset, ad->address, Ustrlen(ad->address));
494       }
495
496     string_cat(s, &size, &offset, q, Ustrlen(q));
497     s[offset] = 0;
498     }
499
500   /* Allow $recipients in the expansion iff it comes from a system filter */
501
502   enable_dollar_recipients = addr != NULL &&
503     addr->parent != NULL &&
504     Ustrcmp(addr->parent->address, "system-filter") == 0;
505   argv[2] = expand_string(s);
506   enable_dollar_recipients = FALSE;
507
508   if (argv[2] == NULL)
509     {
510     addr->transport_return = search_find_defer? DEFER : expand_fail;
511     addr->message = string_sprintf("Expansion of command \"%s\" "
512       "in %s transport failed: %s",
513       cmd, tname, expand_string_message);
514     return FALSE;
515     }
516
517   DEBUG(D_transport)
518     debug_printf("shell pipe command after expansion:\n  %s\n", argv[2]);
519   }
520 else argv[2] = cmd;
521
522 argv[3] = (uschar *)0;
523 return TRUE;
524 }
525
526
527
528
529 /*************************************************
530 *              Main entry point                  *
531 *************************************************/
532
533 /* See local README for interface details. This transport always returns FALSE,
534 indicating that the status in the first address is the status for all addresses
535 in a batch. */
536
537 BOOL
538 pipe_transport_entry(
539   transport_instance *tblock,      /* data for this instantiation */
540   address_item *addr)              /* address(es) we are working on */
541 {
542 pid_t pid, outpid;
543 int fd_in, fd_out, rc;
544 int envcount = 0;
545 int envsep = 0;
546 int expand_fail;
547 pipe_transport_options_block *ob =
548   (pipe_transport_options_block *)(tblock->options_block);
549 int timeout = ob->timeout;
550 BOOL written_ok = FALSE;
551 BOOL expand_arguments;
552 const uschar **argv;
553 uschar *envp[50];
554 const uschar *envlist = ob->environment;
555 uschar *cmd, *ss;
556 uschar *eol = (ob->use_crlf)? US"\r\n" : US"\n";
557
558 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
559
560 /* Set up for the good case */
561
562 addr->transport_return = OK;
563 addr->basic_errno = 0;
564
565 /* Pipes are not accepted as general addresses, but they can be generated from
566 .forward files or alias files. In those cases, the pfr flag is set, and the
567 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
568 symbol. In other cases, the command is supplied as one of the pipe transport's
569 options. */
570
571 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
572   {
573   if (ob->force_command)
574     {
575     /* Enables expansion of $address_pipe into seperate arguments */
576     setflag(addr, af_force_command);
577     cmd = ob->cmd;
578     expand_arguments = TRUE;
579     expand_fail = PANIC;
580     }
581   else
582     {
583     cmd = addr->local_part + 1;
584     while (isspace(*cmd)) cmd++;
585     expand_arguments = testflag(addr, af_expand_pipe);
586     expand_fail = FAIL;
587     }
588   }
589 else
590   {
591   cmd = ob->cmd;
592   expand_arguments = TRUE;
593   expand_fail = PANIC;
594   }
595
596 /* If no command has been supplied, we are in trouble.
597  * We also check for an empty string since it may be
598  * coming from addr->local_part[0] == '|'
599  */
600
601 if (cmd == NULL || *cmd == '\0')
602   {
603   addr->transport_return = DEFER;
604   addr->message = string_sprintf("no command specified for %s transport",
605     tblock->name);
606   return FALSE;
607   }
608
609 /* When a pipe is set up by a filter file, there may be values for $thisaddress
610 and numerical the variables in existence. These are passed in
611 addr->pipe_expandn for use here. */
612
613 if (expand_arguments && addr->pipe_expandn != NULL)
614   {
615   uschar **ss = addr->pipe_expandn;
616   expand_nmax = -1;
617   if (*ss != NULL) filter_thisaddress = *ss++;
618   while (*ss != NULL)
619     {
620     expand_nstring[++expand_nmax] = *ss;
621     expand_nlength[expand_nmax] = Ustrlen(*ss++);
622     }
623   }
624
625 /* The default way of processing the command is to split it up into arguments
626 here, and run it directly. This offers some security advantages. However, there
627 are installations that want by default to run commands under /bin/sh always, so
628 there is an option to do that. */
629
630 if (ob->use_shell)
631   {
632   if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
633     tblock->name)) return FALSE;
634   }
635 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
636   tblock->name, ob)) return FALSE;
637
638 expand_nmax = -1;           /* Reset */
639 filter_thisaddress = NULL;
640
641 /* Set up the environment for the command. */
642
643 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
644 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
645 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
646 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
647   deliver_localpart_prefix);
648 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
649   deliver_localpart_suffix);
650 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
651 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
652 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
653 envp[envcount++] = string_sprintf("PATH=%s", ob->path);
654 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
655   deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
656   deliver_domain);
657 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
658 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
659 envp[envcount++] = US"SHELL=/bin/sh";
660
661 if (addr->host_list != NULL)
662   envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
663
664 if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
665 else if (timezone_string != NULL && timezone_string[0] != 0)
666   envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
667
668 /* Add any requested items */
669
670 if (envlist)
671   {
672   envlist = expand_cstring(envlist);
673   if (envlist == NULL)
674     {
675     addr->transport_return = DEFER;
676     addr->message = string_sprintf("failed to expand string \"%s\" "
677       "for %s transport: %s", ob->environment, tblock->name,
678       expand_string_message);
679     return FALSE;
680     }
681   }
682
683 while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
684        != NULL)
685    {
686    if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
687      {
688      addr->transport_return = DEFER;
689      addr->message = string_sprintf("too many environment settings for "
690        "%s transport", tblock->name);
691      return FALSE;
692      }
693    envp[envcount++] = string_copy(ss);
694    }
695
696 envp[envcount] = NULL;
697
698 /* If the -N option is set, can't do any more. */
699
700 if (dont_deliver)
701   {
702   DEBUG(D_transport)
703     debug_printf("*** delivery by %s transport bypassed by -N option",
704       tblock->name);
705   return FALSE;
706   }
707
708
709 /* Handling the output from the pipe is tricky. If a file for catching this
710 output is provided, we could in theory just hand that fd over to the process,
711 but this isn't very safe because it might loop and carry on writing for
712 ever (which is exactly what happened in early versions of Exim). Therefore we
713 use the standard child_open() function, which creates pipes. We can then read
714 our end of the output pipe and count the number of bytes that come through,
715 chopping the sub-process if it exceeds some limit.
716
717 However, this means we want to run a sub-process with both its input and output
718 attached to pipes. We can't handle that easily from a single parent process
719 using straightforward code such as the transport_write_message() function
720 because the subprocess might not be reading its input because it is trying to
721 write to a full output pipe. The complication of redesigning the world to
722 handle this is too great - simpler just to run another process to do the
723 reading of the output pipe. */
724
725
726 /* As this is a local transport, we are already running with the required
727 uid/gid and current directory. Request that the new process be a process group
728 leader, so we can kill it and all its children on a timeout. */
729
730 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
731   {
732   addr->transport_return = DEFER;
733   addr->message = string_sprintf(
734     "Failed to create child process for %s transport: %s", tblock->name,
735       strerror(errno));
736   return FALSE;
737   }
738
739 /* Now fork a process to handle the output that comes down the pipe. */
740
741 if ((outpid = fork()) < 0)
742   {
743   addr->basic_errno = errno;
744   addr->transport_return = DEFER;
745   addr->message = string_sprintf(
746     "Failed to create process for handling output in %s transport",
747       tblock->name);
748   (void)close(fd_in);
749   (void)close(fd_out);
750   return FALSE;
751   }
752
753 /* This is the code for the output-handling subprocess. Read from the pipe
754 in chunks, and write to the return file if one is provided. Keep track of
755 the number of bytes handled. If the limit is exceeded, try to kill the
756 subprocess group, and in any case close the pipe and exit, which should cause
757 the subprocess to fail. */
758
759 if (outpid == 0)
760   {
761   int count = 0;
762   (void)close(fd_in);
763   set_process_info("reading output from |%s", cmd);
764   while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
765     {
766     if (addr->return_file >= 0)
767       if(write(addr->return_file, big_buffer, rc) != rc)
768         DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
769     count += rc;
770     if (count > ob->max_output)
771       {
772       DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
773       if (addr->return_file >= 0)
774         {
775         uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
776         rc = Ustrlen(message);
777         if(write(addr->return_file, message, rc) != rc)
778           DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
779         }
780       killpg(pid, SIGKILL);
781       break;
782       }
783     }
784   (void)close(fd_out);
785   _exit(0);
786   }
787
788 (void)close(fd_out);  /* Not used in this process */
789
790
791 /* Carrying on now with the main parent process. Attempt to write the message
792 to it down the pipe. It is a fallacy to think that you can detect write errors
793 when the sub-process fails to read the pipe. The parent process may complete
794 writing and close the pipe before the sub-process completes. We could sleep a
795 bit here to let the sub-process get going, but it may still not complete. So we
796 ignore all writing errors. (When in the test harness, we do do a short sleep so
797 any debugging output is likely to be in the same order.) */
798
799 if (running_in_test_harness) millisleep(500);
800
801 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
802
803 /* Arrange to time out writes if there is a timeout set. */
804
805 if (timeout > 0)
806   {
807   sigalrm_seen = FALSE;
808   transport_write_timeout = timeout;
809   }
810
811 /* Reset the counter of bytes written */
812
813 transport_count = 0;
814
815 /* First write any configured prefix information */
816
817 if (ob->message_prefix != NULL)
818   {
819   uschar *prefix = expand_string(ob->message_prefix);
820   if (prefix == NULL)
821     {
822     addr->transport_return = search_find_defer? DEFER : PANIC;
823     addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
824       "transport) failed: %s", ob->message_prefix, tblock->name,
825       expand_string_message);
826     return FALSE;
827     }
828   if (!transport_write_block(fd_in, prefix, Ustrlen(prefix)))
829     goto END_WRITE;
830   }
831
832 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
833 The various different values for batching are handled outside; if there is more
834 than one address available here, all must be included. Force SMTP dot-handling.
835 */
836
837 if (ob->use_bsmtp)
838   {
839   address_item *a;
840
841   if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
842     goto END_WRITE;
843
844   for (a = addr; a != NULL; a = a->next)
845     {
846     if (!transport_write_string(fd_in,
847         "RCPT TO:<%s>%s",
848         transport_rcpt_address(a, tblock->rcpt_include_affixes),
849         eol))
850       goto END_WRITE;
851     }
852
853   if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
854   }
855
856 /* Now the actual message - the options were set at initialization time */
857
858 if (!transport_write_message(addr, fd_in, ob->options, 0, tblock->add_headers,
859   tblock->remove_headers, ob->check_string, ob->escape_string,
860   tblock->rewrite_rules, tblock->rewrite_existflags))
861     goto END_WRITE;
862
863 /* Now any configured suffix */
864
865 if (ob->message_suffix != NULL)
866   {
867   uschar *suffix = expand_string(ob->message_suffix);
868   if (suffix == NULL)
869     {
870     addr->transport_return = search_find_defer? DEFER : PANIC;
871     addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
872       "transport) failed: %s", ob->message_suffix, tblock->name,
873       expand_string_message);
874     return FALSE;
875     }
876   if (!transport_write_block(fd_in, suffix, Ustrlen(suffix)))
877     goto END_WRITE;
878   }
879
880 /* If local_smtp, write the terminating dot. */
881
882 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
883   goto END_WRITE;
884
885 /* Flag all writing completed successfully. */
886
887 written_ok = TRUE;
888
889 /* Come here if there are errors during writing. */
890
891 END_WRITE:
892
893 /* OK, the writing is now all done. Close the pipe. */
894
895 (void) close(fd_in);
896
897 /* Handle errors during writing. For timeouts, set the timeout for waiting for
898 the child process to 1 second. If the process at the far end of the pipe died
899 without reading all of it, we expect an EPIPE error, which should be ignored.
900 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
901 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
902 comments therein. */
903
904 if (!written_ok)
905   {
906   if (errno == ETIMEDOUT)
907     {
908     addr->message = string_sprintf("%stimeout while writing to pipe",
909       transport_filter_timed_out? "transport filter " : "");
910     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
911     timeout = 1;
912     }
913   else if (errno == EPIPE)
914     {
915     debug_printf("transport error EPIPE ignored\n");
916     }
917   else
918     {
919     addr->transport_return = PANIC;
920     addr->basic_errno = errno;
921     if (errno == ERRNO_CHHEADER_FAIL)
922       addr->message =
923         string_sprintf("Failed to expand headers_add or headers_remove: %s",
924           expand_string_message);
925     else if (errno == ERRNO_FILTER_FAIL)
926       addr->message = string_sprintf("Transport filter process failed (%d)%s",
927       addr->more_errno,
928       (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
929     else if (errno == ERRNO_WRITEINCOMPLETE)
930       addr->message = string_sprintf("Failed repeatedly to write data");
931     else
932       addr->message = string_sprintf("Error %d", errno);
933     return FALSE;
934     }
935   }
936
937 /* Wait for the child process to complete and take action if the returned
938 status is nonzero. The timeout will be just 1 second if any of the writes
939 above timed out. */
940
941 if ((rc = child_close(pid, timeout)) != 0)
942   {
943   uschar *tmsg = (addr->message == NULL)? US"" :
944     string_sprintf(" (preceded by %s)", addr->message);
945
946   /* The process did not complete in time; kill its process group and fail
947   the delivery. It appears to be necessary to kill the output process too, as
948   otherwise it hangs on for some time if the actual pipe process is sleeping.
949   (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
950   the delivery, that shouldn't cause any problem. */
951
952   if (rc == -256)
953     {
954     killpg(pid, SIGKILL);
955     kill(outpid, SIGKILL);
956     addr->transport_return = ob->timeout_defer? DEFER : FAIL;
957     addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
958     }
959
960   /* Wait() failed. */
961
962   else if (rc == -257)
963     {
964     addr->transport_return = PANIC;
965     addr->message = string_sprintf("Wait() failed for child process of %s "
966       "transport: %s%s", tblock->name, strerror(errno), tmsg);
967     }
968
969   /* Since the transport_filter timed out we assume it has sent the child process
970   a malformed or incomplete data stream.  Kill off the child process
971   and prevent checking its exit status as it will has probably exited in error.
972   This prevents the transport_filter timeout message from getting overwritten
973   by the exit error which is not the cause of the problem. */
974
975   else if (transport_filter_timed_out)
976     {
977     killpg(pid, SIGKILL);
978     kill(outpid, SIGKILL);
979     }
980
981   /* Either the process completed, but yielded a non-zero (necessarily
982   positive) status, or the process was terminated by a signal (rc will contain
983   the negation of the signal number). Treat killing by signal as failure unless
984   status is being ignored. By default, the message is bounced back, unless
985   freeze_signal is set, in which case it is frozen instead. */
986
987   else if (rc < 0)
988     {
989     if (ob->freeze_signal)
990       {
991       addr->transport_return = DEFER;
992       addr->special_action = SPECIAL_FREEZE;
993       addr->message = string_sprintf("Child process of %s transport (running "
994         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
995         -rc, os_strsignal(-rc), tmsg);
996       }
997     else if (!ob->ignore_status)
998       {
999       addr->transport_return = FAIL;
1000       addr->message = string_sprintf("Child process of %s transport (running "
1001         "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
1002         -rc, os_strsignal(-rc), tmsg);
1003       }
1004     }
1005
1006   /* For positive values (process terminated with non-zero status), we need a
1007   status code to request deferral. A number of systems contain the following
1008   line in sysexits.h:
1009
1010       #define EX_TEMPFAIL 75
1011
1012   with the description
1013
1014       EX_TEMPFAIL -- temporary failure, indicating something that
1015          is not really an error.  In sendmail, this means
1016          that a mailer (e.g.) could not create a connection,
1017          and the request should be reattempted later.
1018
1019   Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1020   not ignoring the returned status. However, there is now an option that
1021   contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1022
1023   Another case that needs special treatment is if execve() failed (typically
1024   the command that was given is a non-existent path). By default this is
1025   treated as just another failure, but if freeze_exec_fail is set, the reaction
1026   is to freeze the message rather than bounce the address. Exim used to signal
1027   this failure with EX_UNAVAILABLE, which is definined in many systems as
1028
1029       #define EX_UNAVAILABLE  69
1030
1031   with the description
1032
1033       EX_UNAVAILABLE -- A service is unavailable.  This can occur
1034             if a support program or file does not exist.  This
1035             can also be used as a catchall message when something
1036             you wanted to do doesn't work, but you don't know why.
1037
1038   However, this can be confused with a command that actually returns 69 because
1039   something *it* wanted is unavailable. At release 4.21, Exim was changed to
1040   use return code 127 instead, because this is what the shell returns when it
1041   is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1042   child.c to signal execve() failure and other unexpected failures such as
1043   setuid() not working - though that won't be the case here because we aren't
1044   changing uid. */
1045
1046   else
1047     {
1048     /* Always handle execve() failure specially if requested to */
1049
1050     if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
1051       {
1052       addr->transport_return = DEFER;
1053       addr->special_action = SPECIAL_FREEZE;
1054       addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1055         cmd, tmsg);
1056       }
1057
1058     /* Otherwise take action only if not ignoring status */
1059
1060     else if (!ob->ignore_status)
1061       {
1062       uschar *ss;
1063       int size, ptr, i;
1064
1065       /* If temp_errors is "*" all codes are temporary. Initializion checks
1066       that it's either "*" or a list of numbers. If not "*", scan the list of
1067       temporary failure codes; if any match, the result is DEFER. */
1068
1069       if (ob->temp_errors[0] == '*')
1070         addr->transport_return = DEFER;
1071
1072       else
1073         {
1074         const uschar *s = ob->temp_errors;
1075         uschar *p;
1076         uschar buffer[64];
1077         int sep = 0;
1078
1079         addr->transport_return = FAIL;
1080         while ((p = string_nextinlist(&s,&sep,buffer,sizeof(buffer))))
1081           if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1082         }
1083
1084       /* Ensure the message contains the expanded command and arguments. This
1085       doesn't have to be brilliantly efficient - it is an error situation. */
1086
1087       addr->message = string_sprintf("Child process of %s transport returned "
1088         "%d", tblock->name, rc);
1089
1090       ptr = Ustrlen(addr->message);
1091       size = ptr + 1;
1092
1093       /* If the return code is > 128, it often means that a shell command
1094       was terminated by a signal. */
1095
1096       ss = (rc > 128)?
1097         string_sprintf("(could mean shell command ended by signal %d (%s))",
1098           rc-128, os_strsignal(rc-128)) :
1099         US os_strexit(rc);
1100
1101       if (*ss != 0)
1102         {
1103         addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
1104         addr->message = string_cat(addr->message, &size, &ptr,
1105           ss, Ustrlen(ss));
1106         }
1107
1108       /* Now add the command and arguments */
1109
1110       addr->message = string_cat(addr->message, &size, &ptr,
1111         US" from command:", 14);
1112
1113       for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1114         {
1115         BOOL quote = FALSE;
1116         addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
1117         if (Ustrpbrk(argv[i], " \t") != NULL)
1118           {
1119           quote = TRUE;
1120           addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
1121           }
1122         addr->message = string_cat(addr->message, &size, &ptr, argv[i],
1123           Ustrlen(argv[i]));
1124         if (quote)
1125           addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
1126         }
1127
1128       /* Add previous filter timeout message, if present. */
1129
1130       if (*tmsg != 0)
1131         addr->message = string_cat(addr->message, &size, &ptr, tmsg,
1132           Ustrlen(tmsg));
1133
1134       addr->message[ptr] = 0;  /* Ensure concatenated string terminated */
1135       }
1136     }
1137   }
1138
1139 /* Ensure all subprocesses (in particular, the output handling process)
1140 are complete before we pass this point. */
1141
1142 while (wait(&rc) >= 0);
1143
1144 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1145   addr->transport_return);
1146
1147 /* If there has been a problem, the message in addr->message contains details
1148 of the pipe command. We don't want to expose these to the world, so we set up
1149 something bland to return to the sender. */
1150
1151 if (addr->transport_return != OK)
1152   addr->user_message = US"local delivery failed";
1153
1154 return FALSE;
1155 }
1156
1157 /* End of transport/pipe.c */