1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
12 #ifdef HAVE_SETCLASSRESOURCES
13 #include <login_cap.h>
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.
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) },
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) },
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. */
95 int pipe_transport_options_count =
96 sizeof(pipe_transport_options)/sizeof(optionlist);
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;}
106 #else /*!MACRO_PREDEF*/
109 /* Default private options block for the pipe transport. */
111 pipe_transport_options_block pipe_transport_option_defaults = {
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 */
123 20480, /* max_output */
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 */
141 /*************************************************
142 * Setup entry point *
143 *************************************************/
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.
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
158 Returns: OK, FAIL, or DEFER
162 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
163 transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
165 pipe_transport_options_block *ob =
166 (pipe_transport_options_block *)(tblock->options_block);
168 addrlist = addrlist; /* Keep compiler happy */
175 #ifdef HAVE_SETCLASSRESOURCES
176 if (ob->use_classresources)
178 struct passwd *pw = getpwuid(uid);
181 login_cap_t *lc = login_getpwclass(pw);
184 setclassresources(lc);
192 if (ob->permit_coredump)
195 rl.rlim_cur = RLIM_INFINITY;
196 rl.rlim_max = RLIM_INFINITY;
197 if (setrlimit(RLIMIT_CORE, &rl) < 0)
199 #ifdef SETRLIMIT_NOT_SUPPORTED
200 if (errno != ENOSYS && errno != ENOTSUP)
202 log_write(0, LOG_MAIN,
203 "delivery setrlimit(RLIMIT_CORE, RLIM_INFINITY) failed: %s",
214 /*************************************************
215 * Initialization entry point *
216 *************************************************/
218 /* Called for each instance, after its options have been read, to
219 enable consistency checks to be done, or anything else that needs
223 pipe_transport_init(transport_instance *tblock)
225 pipe_transport_options_block *ob =
226 (pipe_transport_options_block *)(tblock->options_block);
228 /* Set up the setup entry point, to be called in the privileged state */
230 tblock->setup = pipe_transport_setup;
232 /* If pipe_as_creator is set, then uid/gid should not be set. */
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);
240 /* If a fixed uid field is set, then a gid field must also be set. */
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);
246 /* Temp_errors must consist only of digits and colons, but there can be
247 spaces round the colons, so allow them too. */
249 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
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);
258 /* Only one of return_output/return_fail_output or log_output/log_fail_output
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",
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",
271 /* If batch SMTP is set, force the check and escape strings, and arrange that
272 headers are also escaped. */
276 ob->check_string = US".";
277 ob->escape_string = US"..";
278 ob->options |= topt_escape_headers;
281 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
282 default values for them. */
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";
291 /* The restrict_to_path and use_shell options are incompatible */
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",
298 /* The allow_commands and use_shell options are incompatible */
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",
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. */
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);
319 /*************************************************
320 * Set up direct (non-shell) command *
321 *************************************************/
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.
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
335 Returns: TRUE if all went well; otherwise an error will be
336 set in the first address and FALSE returned
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)
344 BOOL permitted = FALSE;
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). */
352 if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
353 addr, string_sprintf("%.50s transport", tname), NULL))
356 /* Point to the set-up arguments. */
360 /* If allow_commands is set, see if the command is in the permitted list. */
362 if (ob->allow_commands)
368 if (!(s = expand_string(ob->allow_commands)))
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);
376 while ((p = string_nextinlist(&s, &sep, NULL, 0)))
377 if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
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. */
389 if (ob->restrict_to_path)
391 if (Ustrchr(argv[0], '/') != NULL)
393 addr->transport_return = FAIL;
394 addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
395 "transport) - failed for security reasons", cmd, tname);
400 else if (ob->allow_commands)
402 addr->transport_return = FAIL;
403 addr->message = string_sprintf("\"%s\" command not permitted by %s "
404 "transport", argv[0], tname);
409 /* If the command is not an absolute path, search the PATH directories
412 if (argv[0][0] != '/')
416 const uschar *listptr = expand_string(ob->path);
418 while ((p = string_nextinlist(&listptr, &sep, NULL, 0)))
421 sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
422 if (Ustat(big_buffer, &statbuf) == 0)
424 argv[0] = string_copy(big_buffer);
430 addr->transport_return = FAIL;
431 addr->message = string_sprintf("\"%s\" command not found for %s transport",
441 /*************************************************
442 * Set up shell command *
443 *************************************************/
445 /* This function is called when a command line is to be passed to /bin/sh
446 without parsing inside the transport.
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
456 Returns: TRUE if all went well; otherwise an error will be
457 set in the first address and FALSE returned
461 set_up_shell_command(const uschar ***argvptr, uschar *cmd,
462 BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname)
466 *argvptr = argv = store_get((4)*sizeof(uschar *));
468 argv[0] = US"/bin/sh";
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. */
475 debug_printf("shell pipe command before expansion:\n %s\n", cmd);
477 if (expand_arguments)
480 uschar *p = Ustrstr(cmd, "pipe_addresses");
483 (p > cmd && p[-1] == '$') ||
484 (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
488 int size = Ustrlen(cmd) + 64;
491 if (p[-1] == '{') { q++; p--; }
494 offset = p - cmd - 1;
495 Ustrncpy(s, cmd, offset);
497 for (ad = addr; ad != NULL; ad = ad->next)
499 /*XXX string_append_listele() ? */
500 if (ad != addr) s = string_catn(s, &size, &offset, US" ", 1);
501 s = string_cat(s, &size, &offset, ad->address);
504 s = string_cat(s, &size, &offset, q);
508 /* Allow $recipients in the expansion iff it comes from a system filter */
510 enable_dollar_recipients = addr != NULL &&
511 addr->parent != NULL &&
512 Ustrcmp(addr->parent->address, "system-filter") == 0;
513 argv[2] = expand_string(s);
514 enable_dollar_recipients = FALSE;
518 addr->transport_return = search_find_defer? DEFER : expand_fail;
519 addr->message = string_sprintf("Expansion of command \"%s\" "
520 "in %s transport failed: %s",
521 cmd, tname, expand_string_message);
526 debug_printf("shell pipe command after expansion:\n %s\n", argv[2]);
530 argv[3] = (uschar *)0;
537 /*************************************************
539 *************************************************/
541 /* See local README for interface details. This transport always returns FALSE,
542 indicating that the status in the first address is the status for all addresses
546 pipe_transport_entry(
547 transport_instance *tblock, /* data for this instantiation */
548 address_item *addr) /* address(es) we are working on */
551 int fd_in, fd_out, rc;
555 pipe_transport_options_block *ob =
556 (pipe_transport_options_block *)(tblock->options_block);
557 int timeout = ob->timeout;
558 BOOL written_ok = FALSE;
559 BOOL expand_arguments;
562 const uschar *envlist = ob->environment;
564 uschar *eol = ob->use_crlf ? US"\r\n" : US"\n";
565 transport_ctx tctx = {
571 ob->options /* set at initialization time */
574 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
576 /* Set up for the good case */
578 addr->transport_return = OK;
579 addr->basic_errno = 0;
581 /* Pipes are not accepted as general addresses, but they can be generated from
582 .forward files or alias files. In those cases, the pfr flag is set, and the
583 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
584 symbol. In other cases, the command is supplied as one of the pipe transport's
587 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
589 if (ob->force_command)
591 /* Enables expansion of $address_pipe into separate arguments */
592 setflag(addr, af_force_command);
594 expand_arguments = TRUE;
599 cmd = addr->local_part + 1;
600 while (isspace(*cmd)) cmd++;
601 expand_arguments = testflag(addr, af_expand_pipe);
608 expand_arguments = TRUE;
612 /* If no command has been supplied, we are in trouble.
613 * We also check for an empty string since it may be
614 * coming from addr->local_part[0] == '|'
617 if (cmd == NULL || *cmd == '\0')
619 addr->transport_return = DEFER;
620 addr->message = string_sprintf("no command specified for %s transport",
625 /* When a pipe is set up by a filter file, there may be values for $thisaddress
626 and numerical the variables in existence. These are passed in
627 addr->pipe_expandn for use here. */
629 if (expand_arguments && addr->pipe_expandn)
631 uschar **ss = addr->pipe_expandn;
633 if (*ss != NULL) filter_thisaddress = *ss++;
636 expand_nstring[++expand_nmax] = *ss;
637 expand_nlength[expand_nmax] = Ustrlen(*ss++);
641 /* The default way of processing the command is to split it up into arguments
642 here, and run it directly. This offers some security advantages. However, there
643 are installations that want by default to run commands under /bin/sh always, so
644 there is an option to do that. */
648 if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
649 tblock->name)) return FALSE;
651 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
652 tblock->name, ob)) return FALSE;
654 expand_nmax = -1; /* Reset */
655 filter_thisaddress = NULL;
657 /* Set up the environment for the command. */
659 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
660 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
661 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
662 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
663 deliver_localpart_prefix);
664 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
665 deliver_localpart_suffix);
666 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
667 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
668 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
669 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
670 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
671 deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
673 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
674 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
675 envp[envcount++] = US"SHELL=/bin/sh";
677 if (addr->host_list != NULL)
678 envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
680 if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
681 else if (timezone_string != NULL && timezone_string[0] != 0)
682 envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
684 /* Add any requested items */
688 envlist = expand_cstring(envlist);
691 addr->transport_return = DEFER;
692 addr->message = string_sprintf("failed to expand string \"%s\" "
693 "for %s transport: %s", ob->environment, tblock->name,
694 expand_string_message);
699 while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
702 if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
704 addr->transport_return = DEFER;
705 addr->message = string_sprintf("too many environment settings for "
706 "%s transport", tblock->name);
709 envp[envcount++] = string_copy(ss);
712 envp[envcount] = NULL;
714 /* If the -N option is set, can't do any more. */
719 debug_printf("*** delivery by %s transport bypassed by -N option",
725 /* Handling the output from the pipe is tricky. If a file for catching this
726 output is provided, we could in theory just hand that fd over to the process,
727 but this isn't very safe because it might loop and carry on writing for
728 ever (which is exactly what happened in early versions of Exim). Therefore we
729 use the standard child_open() function, which creates pipes. We can then read
730 our end of the output pipe and count the number of bytes that come through,
731 chopping the sub-process if it exceeds some limit.
733 However, this means we want to run a sub-process with both its input and output
734 attached to pipes. We can't handle that easily from a single parent process
735 using straightforward code such as the transport_write_message() function
736 because the subprocess might not be reading its input because it is trying to
737 write to a full output pipe. The complication of redesigning the world to
738 handle this is too great - simpler just to run another process to do the
739 reading of the output pipe. */
742 /* As this is a local transport, we are already running with the required
743 uid/gid and current directory. Request that the new process be a process group
744 leader, so we can kill it and all its children on a timeout. */
746 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
748 addr->transport_return = DEFER;
749 addr->message = string_sprintf(
750 "Failed to create child process for %s transport: %s", tblock->name,
756 /* Now fork a process to handle the output that comes down the pipe. */
758 if ((outpid = fork()) < 0)
760 addr->basic_errno = errno;
761 addr->transport_return = DEFER;
762 addr->message = string_sprintf(
763 "Failed to create process for handling output in %s transport",
770 /* This is the code for the output-handling subprocess. Read from the pipe
771 in chunks, and write to the return file if one is provided. Keep track of
772 the number of bytes handled. If the limit is exceeded, try to kill the
773 subprocess group, and in any case close the pipe and exit, which should cause
774 the subprocess to fail. */
780 set_process_info("reading output from |%s", cmd);
781 while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
783 if (addr->return_file >= 0)
784 if(write(addr->return_file, big_buffer, rc) != rc)
785 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
787 if (count > ob->max_output)
789 DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
790 if (addr->return_file >= 0)
792 uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
793 rc = Ustrlen(message);
794 if(write(addr->return_file, message, rc) != rc)
795 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
797 killpg(pid, SIGKILL);
805 (void)close(fd_out); /* Not used in this process */
808 /* Carrying on now with the main parent process. Attempt to write the message
809 to it down the pipe. It is a fallacy to think that you can detect write errors
810 when the sub-process fails to read the pipe. The parent process may complete
811 writing and close the pipe before the sub-process completes. We could sleep a
812 bit here to let the sub-process get going, but it may still not complete. So we
813 ignore all writing errors. (When in the test harness, we do do a short sleep so
814 any debugging output is likely to be in the same order.) */
816 if (running_in_test_harness) millisleep(500);
818 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
820 /* Arrange to time out writes if there is a timeout set. */
824 sigalrm_seen = FALSE;
825 transport_write_timeout = timeout;
828 /* Reset the counter of bytes written */
832 /* First write any configured prefix information */
834 if (ob->message_prefix != NULL)
836 uschar *prefix = expand_string(ob->message_prefix);
839 addr->transport_return = search_find_defer? DEFER : PANIC;
840 addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
841 "transport) failed: %s", ob->message_prefix, tblock->name,
842 expand_string_message);
845 if (!transport_write_block(&tctx, prefix, Ustrlen(prefix), FALSE))
849 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
850 The various different values for batching are handled outside; if there is more
851 than one address available here, all must be included. Force SMTP dot-handling.
858 if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
861 for (a = addr; a; a = a->next)
862 if (!transport_write_string(fd_in,
864 transport_rcpt_address(a, tblock->rcpt_include_affixes),
868 if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
871 /* Now the actual message */
873 if (!transport_write_message(&tctx, 0))
876 /* Now any configured suffix */
878 if (ob->message_suffix)
880 uschar *suffix = expand_string(ob->message_suffix);
883 addr->transport_return = search_find_defer? DEFER : PANIC;
884 addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
885 "transport) failed: %s", ob->message_suffix, tblock->name,
886 expand_string_message);
889 if (!transport_write_block(&tctx, suffix, Ustrlen(suffix), FALSE))
893 /* If local_smtp, write the terminating dot. */
895 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
898 /* Flag all writing completed successfully. */
902 /* Come here if there are errors during writing. */
906 /* OK, the writing is now all done. Close the pipe. */
910 /* Handle errors during writing. For timeouts, set the timeout for waiting for
911 the child process to 1 second. If the process at the far end of the pipe died
912 without reading all of it, we expect an EPIPE error, which should be ignored.
913 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
914 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
919 if (errno == ETIMEDOUT)
921 addr->message = string_sprintf("%stimeout while writing to pipe",
922 transport_filter_timed_out? "transport filter " : "");
923 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
926 else if (errno == EPIPE)
928 debug_printf("transport error EPIPE ignored\n");
932 addr->transport_return = PANIC;
933 addr->basic_errno = errno;
934 if (errno == ERRNO_CHHEADER_FAIL)
936 string_sprintf("Failed to expand headers_add or headers_remove: %s",
937 expand_string_message);
938 else if (errno == ERRNO_FILTER_FAIL)
939 addr->message = string_sprintf("Transport filter process failed (%d)%s",
941 (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
942 else if (errno == ERRNO_WRITEINCOMPLETE)
943 addr->message = string_sprintf("Failed repeatedly to write data");
945 addr->message = string_sprintf("Error %d", errno);
950 /* Wait for the child process to complete and take action if the returned
951 status is nonzero. The timeout will be just 1 second if any of the writes
954 if ((rc = child_close(pid, timeout)) != 0)
956 uschar *tmsg = (addr->message == NULL)? US"" :
957 string_sprintf(" (preceded by %s)", addr->message);
959 /* The process did not complete in time; kill its process group and fail
960 the delivery. It appears to be necessary to kill the output process too, as
961 otherwise it hangs on for some time if the actual pipe process is sleeping.
962 (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
963 the delivery, that shouldn't cause any problem. */
967 killpg(pid, SIGKILL);
968 kill(outpid, SIGKILL);
969 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
970 addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
977 addr->transport_return = PANIC;
978 addr->message = string_sprintf("Wait() failed for child process of %s "
979 "transport: %s%s", tblock->name, strerror(errno), tmsg);
982 /* Since the transport_filter timed out we assume it has sent the child process
983 a malformed or incomplete data stream. Kill off the child process
984 and prevent checking its exit status as it will has probably exited in error.
985 This prevents the transport_filter timeout message from getting overwritten
986 by the exit error which is not the cause of the problem. */
988 else if (transport_filter_timed_out)
990 killpg(pid, SIGKILL);
991 kill(outpid, SIGKILL);
994 /* Either the process completed, but yielded a non-zero (necessarily
995 positive) status, or the process was terminated by a signal (rc will contain
996 the negation of the signal number). Treat killing by signal as failure unless
997 status is being ignored. By default, the message is bounced back, unless
998 freeze_signal is set, in which case it is frozen instead. */
1002 if (ob->freeze_signal)
1004 addr->transport_return = DEFER;
1005 addr->special_action = SPECIAL_FREEZE;
1006 addr->message = string_sprintf("Child process of %s transport (running "
1007 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
1008 -rc, os_strsignal(-rc), tmsg);
1010 else if (!ob->ignore_status)
1012 addr->transport_return = FAIL;
1013 addr->message = string_sprintf("Child process of %s transport (running "
1014 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
1015 -rc, os_strsignal(-rc), tmsg);
1019 /* For positive values (process terminated with non-zero status), we need a
1020 status code to request deferral. A number of systems contain the following
1023 #define EX_TEMPFAIL 75
1025 with the description
1027 EX_TEMPFAIL -- temporary failure, indicating something that
1028 is not really an error. In sendmail, this means
1029 that a mailer (e.g.) could not create a connection,
1030 and the request should be reattempted later.
1032 Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1033 not ignoring the returned status. However, there is now an option that
1034 contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1036 Another case that needs special treatment is if execve() failed (typically
1037 the command that was given is a non-existent path). By default this is
1038 treated as just another failure, but if freeze_exec_fail is set, the reaction
1039 is to freeze the message rather than bounce the address. Exim used to signal
1040 this failure with EX_UNAVAILABLE, which is defined in many systems as
1042 #define EX_UNAVAILABLE 69
1044 with the description
1046 EX_UNAVAILABLE -- A service is unavailable. This can occur
1047 if a support program or file does not exist. This
1048 can also be used as a catchall message when something
1049 you wanted to do doesn't work, but you don't know why.
1051 However, this can be confused with a command that actually returns 69 because
1052 something *it* wanted is unavailable. At release 4.21, Exim was changed to
1053 use return code 127 instead, because this is what the shell returns when it
1054 is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1055 child.c to signal execve() failure and other unexpected failures such as
1056 setuid() not working - though that won't be the case here because we aren't
1061 /* Always handle execve() failure specially if requested to */
1063 if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
1065 addr->transport_return = DEFER;
1066 addr->special_action = SPECIAL_FREEZE;
1067 addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1071 /* Otherwise take action only if not ignoring status */
1073 else if (!ob->ignore_status)
1078 /* If temp_errors is "*" all codes are temporary. Initialization checks
1079 that it's either "*" or a list of numbers. If not "*", scan the list of
1080 temporary failure codes; if any match, the result is DEFER. */
1082 if (ob->temp_errors[0] == '*')
1083 addr->transport_return = DEFER;
1087 const uschar *s = ob->temp_errors;
1091 addr->transport_return = FAIL;
1092 while ((p = string_nextinlist(&s,&sep,NULL,0)))
1093 if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1096 /* Ensure the message contains the expanded command and arguments. This
1097 doesn't have to be brilliantly efficient - it is an error situation. */
1099 addr->message = string_sprintf("Child process of %s transport returned "
1100 "%d", tblock->name, rc);
1102 ptr = Ustrlen(addr->message);
1105 /* If the return code is > 128, it often means that a shell command
1106 was terminated by a signal. */
1109 string_sprintf("(could mean shell command ended by signal %d (%s))",
1110 rc-128, os_strsignal(rc-128)) :
1115 addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1116 addr->message = string_cat (addr->message, &size, &ptr, ss);
1119 /* Now add the command and arguments */
1121 addr->message = string_catn(addr->message, &size, &ptr,
1122 US" from command:", 14);
1124 for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1127 addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1128 if (Ustrpbrk(argv[i], " \t") != NULL)
1131 addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1133 addr->message = string_cat(addr->message, &size, &ptr, argv[i]);
1135 addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1138 /* Add previous filter timeout message, if present. */
1141 addr->message = string_cat(addr->message, &size, &ptr, tmsg);
1143 addr->message[ptr] = 0; /* Ensure concatenated string terminated */
1148 /* Ensure all subprocesses (in particular, the output handling process)
1149 are complete before we pass this point. */
1151 while (wait(&rc) >= 0);
1153 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1154 addr->transport_return);
1156 /* If there has been a problem, the message in addr->message contains details
1157 of the pipe command. We don't want to expose these to the world, so we set up
1158 something bland to return to the sender. */
1160 if (addr->transport_return != OK)
1161 addr->user_message = US"local delivery failed";
1166 #endif /*!MACRO_PREDEF*/
1167 /* End of transport/pipe.c */