1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim maintainers 2020 - 2024 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
13 #ifdef TRANSPORT_PIPE /* Remainder of file */
16 #ifdef HAVE_SETCLASSRESOURCES
17 #include <login_cap.h>
22 /* Options specific to the pipe transport. They must be in alphabetic
23 order (note that "_" comes before the lower case letters). Those starting
24 with "*" are not settable by the user but are used by the option-reading
25 software for alternative value types. Some options are stored in the transport
26 instance block so as to be publicly visible; these are flagged with opt_public.
28 #define LOFF(field) OPT_OFF(pipe_transport_options_block, field)
30 optionlist pipe_transport_options[] = {
31 { "allow_commands", opt_stringptr, LOFF(allow_commands) },
32 { "batch_id", opt_stringptr | opt_public,
33 OPT_OFF(transport_instance, batch_id) },
34 { "batch_max", opt_int | opt_public,
35 OPT_OFF(transport_instance, batch_max) },
36 { "check_string", opt_stringptr, LOFF(check_string) },
37 { "command", opt_stringptr, LOFF(cmd) },
38 { "environment", opt_stringptr, LOFF(environment) },
39 { "escape_string", opt_stringptr, LOFF(escape_string) },
40 { "force_command", opt_bool, LOFF(force_command) },
41 { "freeze_exec_fail", opt_bool, LOFF(freeze_exec_fail) },
42 { "freeze_signal", opt_bool, LOFF(freeze_signal) },
43 { "ignore_status", opt_bool, LOFF(ignore_status) },
44 { "log_defer_output", opt_bool | opt_public,
45 OPT_OFF(transport_instance, log_defer_output) },
46 { "log_fail_output", opt_bool | opt_public,
47 OPT_OFF(transport_instance, log_fail_output) },
48 { "log_output", opt_bool | opt_public,
49 OPT_OFF(transport_instance, log_output) },
50 { "max_output", opt_mkint, LOFF(max_output) },
51 { "message_prefix", opt_stringptr, LOFF(message_prefix) },
52 { "message_suffix", opt_stringptr, LOFF(message_suffix) },
53 { "path", opt_stringptr, LOFF(path) },
54 { "permit_coredump", opt_bool, LOFF(permit_coredump) },
55 { "pipe_as_creator", opt_bool | opt_public,
56 OPT_OFF(transport_instance, deliver_as_creator) },
57 { "restrict_to_path", opt_bool, LOFF(restrict_to_path) },
58 { "return_fail_output",opt_bool | opt_public,
59 OPT_OFF(transport_instance, return_fail_output) },
60 { "return_output", opt_bool | opt_public,
61 OPT_OFF(transport_instance, return_output) },
62 { "temp_errors", opt_stringptr, LOFF(temp_errors) },
63 { "timeout", opt_time, LOFF(timeout) },
64 { "timeout_defer", opt_bool, LOFF(timeout_defer) },
65 { "umask", opt_octint, LOFF(umask) },
66 { "use_bsmtp", opt_bool, LOFF(use_bsmtp) },
67 #ifdef HAVE_SETCLASSRESOURCES
68 { "use_classresources", opt_bool, LOFF(use_classresources) },
70 { "use_crlf", opt_bool, LOFF(use_crlf) },
71 { "use_shell", opt_bool, LOFF(use_shell) },
74 /* Size of the options list. An extern variable has to be used so that its
75 address can appear in the tables drtables.c. */
77 int pipe_transport_options_count =
78 sizeof(pipe_transport_options)/sizeof(optionlist);
84 pipe_transport_options_block pipe_transport_option_defaults = {0};
85 void pipe_transport_init(driver_instance *tblock) {}
86 BOOL pipe_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
88 #else /*!MACRO_PREDEF*/
91 /* Default private options block for the pipe transport. */
93 pipe_transport_options_block pipe_transport_option_defaults = {
94 .path = US"/bin:/usr/bin",
95 .temp_errors = US mac_expanded_string(EX_TEMPFAIL) ":"
96 mac_expanded_string(EX_CANTCREAT),
100 /* all others null/zero/false */
105 /*************************************************
106 * Setup entry point *
107 *************************************************/
109 /* Called for each delivery in the privileged state, just before the uid/gid
110 are changed and the main entry point is called. In a system that supports the
111 login_cap facilities, this function is used to set the class resource limits
112 for the user. It may also re-enable coredumps.
115 tblock points to the transport instance
116 addrlist addresses about to be delivered (not used)
117 dummy not used (doesn't pass back data)
118 uid the uid that will be set (not used)
119 gid the gid that will be set (not used)
120 errmsg where to put an error message
122 Returns: OK, FAIL, or DEFER
126 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
127 transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
129 pipe_transport_options_block * ob = tblock->drinst.options_block;
131 #ifdef HAVE_SETCLASSRESOURCES
132 if (ob->use_classresources)
134 struct passwd *pw = getpwuid(uid);
137 login_cap_t *lc = login_getpwclass(pw);
140 setclassresources(lc);
148 if (ob->permit_coredump)
151 rl.rlim_cur = RLIM_INFINITY;
152 rl.rlim_max = RLIM_INFINITY;
153 if (setrlimit(RLIMIT_CORE, &rl) < 0)
155 #ifdef SETRLIMIT_NOT_SUPPORTED
156 if (errno != ENOSYS && errno != ENOTSUP)
158 log_write(0, LOG_MAIN,
159 "delivery setrlimit(RLIMIT_CORE, RLIM_INFINITY) failed: %s",
170 /*************************************************
171 * Initialization entry point *
172 *************************************************/
174 /* Called for each instance, after its options have been read, to
175 enable consistency checks to be done, or anything else that needs
179 pipe_transport_init(driver_instance * t)
181 transport_instance * tblock = (transport_instance *)t;
182 const uschar * trname = t->name;
183 pipe_transport_options_block * ob = t->options_block;
185 /* Set up the setup entry point, to be called in the privileged state */
187 tblock->setup = pipe_transport_setup;
189 /* If pipe_as_creator is set, then uid/gid should not be set. */
191 if (tblock->deliver_as_creator && (tblock->uid_set || tblock->gid_set ||
192 tblock->expand_uid != NULL || tblock->expand_gid != NULL))
193 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
194 "both pipe_as_creator and an explicit uid/gid are set for the %s "
195 "transport", trname);
197 /* If a fixed uid field is set, then a gid field must also be set. */
199 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
200 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
201 "user set without group for the %s transport", trname);
203 /* Temp_errors must consist only of digits and colons, but there can be
204 spaces round the colons, so allow them too. */
206 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
208 size_t p = Ustrspn(ob->temp_errors, "0123456789: ");
209 if (ob->temp_errors[p] != 0)
210 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
211 "temp_errors must be a list of numbers or an asterisk for the %s "
212 "transport", trname);
215 /* Only one of return_output/return_fail_output or log_output/log_fail_output
218 if (tblock->return_output && tblock->return_fail_output)
219 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
220 "both return_output and return_fail_output set for %s transport",
223 if (tblock->log_output && tblock->log_fail_output)
224 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
225 "both log_output and log_fail_output set for the %s transport",
228 /* If batch SMTP is set, force the check and escape strings, and arrange that
229 headers are also escaped. */
233 ob->check_string = US".";
234 ob->escape_string = US"..";
235 ob->options |= topt_escape_headers;
238 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
239 default values for them. */
243 if (ob->message_prefix == NULL) ob->message_prefix =
244 US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
245 if (ob->message_suffix == NULL) ob->message_suffix = US"\n";
248 /* The restrict_to_path and use_shell options are incompatible */
250 if (ob->restrict_to_path && ob->use_shell)
251 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
252 "both restrict_to_path and use_shell set for %s transport",
255 /* The allow_commands and use_shell options are incompatible */
257 if (ob->allow_commands && ob->use_shell)
258 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
259 "both allow_commands and use_shell set for %s transport",
262 /* Set up the bitwise options for transport_write_message from the various
263 driver options. Only one of body_only and headers_only can be set. */
266 (tblock->body_only ? topt_no_headers : 0)
267 | (tblock->headers_only ? topt_no_body : 0)
268 | (tblock->return_path_add ? topt_add_return_path : 0)
269 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
270 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
271 | (ob->use_crlf ? topt_use_crlf : 0);
276 /*************************************************
277 * Set up direct (non-shell) command *
278 *************************************************/
280 /* This function is called when a command line is to be parsed by the transport
281 and executed directly, without the use of /bin/sh.
284 argvptr pointer to anchor for argv vector
285 cmd points to the command string
286 expand_arguments true if expansion is to occur
287 expand_fail error if expansion fails
288 addr chain of addresses
289 tname the transport name
290 ob the transport options block
292 Returns: TRUE if all went well; otherwise an error will be
293 set in the first address and FALSE returned
297 set_up_direct_command(const uschar *** argvptr, const uschar * cmd,
298 BOOL expand_arguments, int expand_fail, address_item * addr,
299 const uschar * tname, pipe_transport_options_block * ob)
301 BOOL permitted = FALSE;
304 /* Set up "transport <name>" to be put in any error messages, and then
305 call the common function for creating an argument list and expanding
306 the items if necessary. If it fails, this function fails (error information
307 is in the addresses). */
309 if (!transport_set_up_command(argvptr, cmd,
310 expand_arguments ? TSUC_EXPAND_ARGS : 0,
311 expand_fail, addr, string_sprintf("%.50s transport", tname), NULL))
314 /* Point to the set-up arguments. */
318 /* If allow_commands is set, see if the command is in the permitted list. */
320 GET_OPTION("allow_commands");
321 if (ob->allow_commands)
327 if (!(s = expand_string(ob->allow_commands)))
329 addr->transport_return = DEFER;
330 addr->message = string_sprintf("failed to expand string \"%s\" "
331 "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
335 while ((p = string_nextinlist(&s, &sep, NULL, 0)))
336 if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
339 /* If permitted is TRUE it means the command was found in the allowed list, and
340 no further checks are done. If permitted = FALSE, it either means
341 allow_commands wasn't set, or that the command didn't match anything in the
342 list. In both cases, if restrict_to_path is set, we fail if the command
343 contains any slashes, but if restrict_to_path is not set, we must fail the
344 command only if allow_commands is set. */
348 if (ob->restrict_to_path)
350 if (Ustrchr(argv[0], '/') != NULL)
352 addr->transport_return = FAIL;
353 addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
354 "transport) - failed for security reasons", cmd, tname);
359 else if (ob->allow_commands)
361 addr->transport_return = FAIL;
362 addr->message = string_sprintf("\"%s\" command not permitted by %s "
363 "transport", argv[0], tname);
368 /* If the command is not an absolute path, search the PATH directories
371 if (argv[0][0] != '/')
377 for (const uschar * listptr = expand_string(ob->path);
378 p = string_nextinlist(&listptr, &sep, NULL, 0); )
381 sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
382 if (Ustat(big_buffer, &statbuf) == 0)
384 argv[0] = string_copy(big_buffer);
390 addr->transport_return = FAIL;
391 addr->message = string_sprintf("\"%s\" command not found for %s transport",
401 /*************************************************
402 * Set up shell command *
403 *************************************************/
405 /* This function is called when a command line is to be passed to /bin/sh
406 without parsing inside the transport.
409 argvptr pointer to anchor for argv vector
410 cmd points to the command string
411 expand_arguments true if expansion is to occur
412 expand_fail error if expansion fails
413 addr chain of addresses
414 tname the transport name
416 Returns: TRUE if all went well; otherwise an error will be
417 set in the first address and FALSE returned
421 set_up_shell_command(const uschar *** argvptr, const uschar * cmd,
422 BOOL expand_arguments, int expand_fail, address_item * addr,
423 const uschar * tname)
427 *argvptr = argv = store_get((4)*sizeof(uschar *), GET_UNTAINTED);
429 argv[0] = US"/bin/sh";
432 /* We have to take special action to handle the special "variable" called
433 $pipe_addresses, which is not recognized by the normal expansion function. */
435 if (expand_arguments)
437 uschar * p = Ustrstr(cmd, "pipe_addresses");
441 debug_printf("shell pipe command before expansion:\n %s\n", cmd);
443 /* Allow $recipients in the expansion iff it comes from a system filter */
445 f.enable_dollar_recipients = addr && addr->parent &&
446 Ustrcmp(addr->parent->address, "system-filter") == 0;
449 (p > cmd && p[-1] == '$') ||
450 (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
454 if (p[-1] == '{') { q++; p--; }
456 g = string_get(Ustrlen(cmd) + 64);
457 g = string_catn(g, cmd, p - cmd - 1);
459 for (address_item * ad = addr; ad; ad = ad->next)
461 DEBUG(D_transport) if (is_tainted(ad->address))
462 debug_printf("tainted element '%s' from $pipe_addresses\n", ad->address);
464 /*XXX string_append_listele() ? */
465 if (ad != addr) g = string_catn(g, US" ", 1);
466 g = string_cat(g, ad->address);
469 g = string_cat(g, q);
470 argv[2] = (cmd = string_from_gstring(g)) ? expand_cstring(cmd) : NULL;
473 argv[2] = expand_cstring(cmd);
475 f.enable_dollar_recipients = FALSE;
479 addr->transport_return = f.search_find_defer ? DEFER : expand_fail;
480 addr->message = string_sprintf("Expansion of command \"%s\" "
481 "in %s transport failed: %s",
482 cmd, tname, expand_string_message);
487 debug_printf("shell pipe command after expansion:\n %s\n", argv[2]);
492 debug_printf("shell pipe command (no expansion):\n %s\n", cmd);
503 /*************************************************
505 *************************************************/
507 /* See local README for interface details. This transport always returns FALSE,
508 indicating that the status in the first address is the status for all addresses
512 pipe_transport_entry(
513 transport_instance *tblock, /* data for this instantiation */
514 address_item *addr) /* address(es) we are working on */
516 pipe_transport_options_block * ob = tblock->drinst.options_block;
517 const uschar * trname = tblock->drinst.name;
519 int fd_in, fd_out, rc;
520 int envcount = 0, envsep = 0, expand_fail, timeout = ob->timeout;
521 BOOL written_ok = FALSE, expand_arguments;
522 const uschar ** argv;
524 const uschar * envlist = ob->environment, * cmd;
526 uschar * eol = ob->use_crlf ? US"\r\n" : US"\n";
527 transport_ctx tctx = {
530 .check_string = ob->check_string,
531 .escape_string = ob->escape_string,
532 ob->options | topt_not_socket /* set at initialization time */
535 DEBUG(D_transport) debug_printf("%s transport entered\n", trname);
537 /* Set up for the good case */
539 addr->transport_return = OK;
540 addr->basic_errno = 0;
542 /* Pipes are not accepted as general addresses, but they can be generated from
543 .forward files or alias files. In those cases, the pfr flag is set, and the
544 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
545 symbol. In other cases, the command is supplied as one of the pipe transport's
548 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
549 if (ob->force_command)
551 /* Enables expansion of $address_pipe into separate arguments */
552 setflag(addr, af_force_command);
553 GET_OPTION("commsnd");
555 expand_arguments = TRUE;
560 cmd = addr->local_part + 1;
561 Uskip_whitespace(&cmd);
562 expand_arguments = testflag(addr, af_expand_pipe);
567 GET_OPTION("commsnd");
569 expand_arguments = TRUE;
573 /* If no command has been supplied, we are in trouble.
574 We also check for an empty string since it may be
575 coming from addr->local_part[0] == '|' */
579 addr->transport_return = DEFER;
580 addr->message = string_sprintf("no command specified for %s transport",
586 DEBUG(D_transport) debug_printf("cmd '%s' is tainted\n", cmd);
587 addr->message = string_sprintf("Tainted '%s' (command "
588 "for %s transport) not permitted", cmd, trname);
589 addr->transport_return = PANIC;
593 /* When a pipe is set up by a filter file, there may be values for $thisaddress
594 and numerical the variables in existence. These are passed in
595 addr->pipe_expandn for use here. */
597 if (expand_arguments && addr->pipe_expandn)
599 uschar **ss = addr->pipe_expandn;
601 if (*ss) filter_thisaddress = *ss++;
604 expand_nstring[++expand_nmax] = *ss;
605 expand_nlength[expand_nmax] = Ustrlen(*ss++);
609 /* The default way of processing the command is to split it up into arguments
610 here, and run it directly. This offers some security advantages. However, there
611 are installations that want by default to run commands under /bin/sh always, so
612 there is an option to do that. */
616 if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
617 trname)) return FALSE;
619 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
620 trname, ob)) return FALSE;
622 expand_nmax = -1; /* Reset */
623 filter_thisaddress = NULL;
625 /* Set up the environment for the command. */
627 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
628 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
629 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
630 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
631 deliver_localpart_prefix);
632 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
633 deliver_localpart_suffix);
634 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
635 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
636 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
637 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
638 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
639 deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
641 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
642 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
643 envp[envcount++] = US"SHELL=/bin/sh";
646 envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
648 if (f.timestamps_utc)
649 envp[envcount++] = US"TZ=UTC";
650 else if (timezone_string && timezone_string[0])
651 envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
653 /* Add any requested items */
655 GET_OPTION("environment");
657 if (!(envlist = expand_cstring(envlist)))
659 addr->transport_return = DEFER;
660 addr->message = string_sprintf("failed to expand string \"%s\" "
661 "for %s transport: %s", ob->environment, trname,
662 expand_string_message);
666 while ((ss = string_nextinlist(&envlist, &envsep, NULL, 0)))
668 if (envcount > nelem(envp) - 2)
670 addr->transport_return = DEFER;
671 addr->basic_errno = E2BIG;
672 addr->message = string_sprintf("too many environment settings for "
673 "%s transport", trname);
676 envp[envcount++] = string_copy(ss);
679 envp[envcount] = NULL;
681 /* If the -N option is set, can't do any more. */
686 debug_printf("*** delivery by %s transport bypassed by -N option",
692 /* Handling the output from the pipe is tricky. If a file for catching this
693 output is provided, we could in theory just hand that fd over to the process,
694 but this isn't very safe because it might loop and carry on writing for
695 ever (which is exactly what happened in early versions of Exim). Therefore we
696 use the standard child_open() function, which creates pipes. We can then read
697 our end of the output pipe and count the number of bytes that come through,
698 chopping the sub-process if it exceeds some limit.
700 However, this means we want to run a sub-process with both its input and output
701 attached to pipes. We can't handle that easily from a single parent process
702 using straightforward code such as the transport_write_message() function
703 because the subprocess might not be reading its input because it is trying to
704 write to a full output pipe. The complication of redesigning the world to
705 handle this is too great - simpler just to run another process to do the
706 reading of the output pipe. */
709 /* As this is a local transport, we are already running with the required
710 uid/gid and current directory. Request that the new process be a process group
711 leader, so we can kill it and all its children on a timeout. */
713 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE,
714 US"pipe-tpt-cmd")) < 0)
716 addr->transport_return = DEFER;
717 addr->message = string_sprintf(
718 "Failed to create child process for %s transport: %s", trname,
724 /* Now fork a process to handle the output that comes down the pipe. */
726 if ((outpid = exim_fork(US"pipe-tpt-output")) < 0)
728 addr->basic_errno = errno;
729 addr->transport_return = DEFER;
730 addr->message = string_sprintf(
731 "Failed to create process for handling output in %s transport",
738 /* This is the code for the output-handling subprocess. Read from the pipe
739 in chunks, and write to the return file if one is provided. Keep track of
740 the number of bytes handled. If the limit is exceeded, try to kill the
741 subprocess group, and in any case close the pipe and exit, which should cause
742 the subprocess to fail. */
748 set_process_info("reading output from |%s", cmd);
749 while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
751 if (addr->return_file >= 0)
752 if(write(addr->return_file, big_buffer, rc) != rc)
753 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
755 if (count > ob->max_output)
757 DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
758 if (addr->return_file >= 0)
760 uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
761 rc = Ustrlen(message);
762 if(write(addr->return_file, message, rc) != rc)
763 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
765 killpg(pid, SIGKILL);
773 (void)close(fd_out); /* Not used in this process */
776 /* Carrying on now with the main parent process. Attempt to write the message
777 to it down the pipe. It is a fallacy to think that you can detect write errors
778 when the sub-process fails to read the pipe. The parent process may complete
779 writing and close the pipe before the sub-process completes. We could sleep a
780 bit here to let the sub-process get going, but it may still not complete. So we
781 ignore all writing errors. (When in the test harness, we do do a short sleep so
782 any debugging output is likely to be in the same order.) */
784 testharness_pause_ms(500);
786 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
788 /* Arrange to time out writes if there is a timeout set. */
792 sigalrm_seen = FALSE;
793 transport_write_timeout = timeout;
796 /* Reset the counter of bytes written */
800 /* First write any configured prefix information */
802 GET_OPTION("message_prefix");
803 if (ob->message_prefix)
805 uschar * prefix = expand_string(ob->message_prefix);
808 addr->transport_return = f.search_find_defer? DEFER : PANIC;
809 addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
810 "transport) failed: %s", ob->message_prefix, trname,
811 expand_string_message);
814 if (!transport_write_block(&tctx, prefix, Ustrlen(prefix), FALSE))
818 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
819 The various different values for batching are handled outside; if there is more
820 than one address available here, all must be included. Force SMTP dot-handling.
825 if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
828 for (address_item * a = addr; a; a = a->next)
829 if (!transport_write_string(fd_in,
831 transport_rcpt_address(a, tblock->rcpt_include_affixes),
835 if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
838 /* Now the actual message */
840 if (!transport_write_message(&tctx, 0))
843 /* Now any configured suffix */
845 GET_OPTION("message_suffix");
846 if (ob->message_suffix)
848 uschar * suffix = expand_string(ob->message_suffix);
851 addr->transport_return = f.search_find_defer? DEFER : PANIC;
852 addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
853 "transport) failed: %s", ob->message_suffix, trname,
854 expand_string_message);
857 if (!transport_write_block(&tctx, suffix, Ustrlen(suffix), FALSE))
861 /* If local_smtp, write the terminating dot. */
863 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
866 /* Flag all writing completed successfully. */
870 /* Come here if there are errors during writing. */
874 /* OK, the writing is now all done. Close the pipe. */
878 /* Handle errors during writing. For timeouts, set the timeout for waiting for
879 the child process to 1 second. If the process at the far end of the pipe died
880 without reading all of it, we expect an EPIPE error, which should be ignored.
881 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
882 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
887 if (errno == ETIMEDOUT)
889 addr->message = string_sprintf("%stimeout while writing to pipe",
890 f.transport_filter_timed_out ? "transport filter " : "");
891 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
894 else if (errno == EPIPE)
896 debug_printf("transport error EPIPE ignored\n");
900 addr->transport_return = PANIC;
901 addr->basic_errno = errno;
902 if (errno == ERRNO_CHHEADER_FAIL)
904 string_sprintf("Failed to expand headers_add or headers_remove: %s",
905 expand_string_message);
906 else if (errno == ERRNO_FILTER_FAIL)
907 addr->message = string_sprintf("Transport filter process failed (%d)%s",
909 (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
910 else if (errno == ERRNO_WRITEINCOMPLETE)
911 addr->message = US"Failed repeatedly to write data";
913 addr->message = string_sprintf("Error %d", errno);
918 /* Wait for the child process to complete and take action if the returned
919 status is nonzero. The timeout will be just 1 second if any of the writes
922 if ((rc = child_close(pid, timeout)) != 0)
924 uschar * tmsg = addr->message
925 ? string_sprintf(" (preceded by %s)", addr->message) : US"";
927 /* The process did not complete in time; kill its process group and fail
928 the delivery. It appears to be necessary to kill the output process too, as
929 otherwise it hangs on for some time if the actual pipe process is sleeping.
930 (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
931 the delivery, that shouldn't cause any problem. */
935 killpg(pid, SIGKILL);
936 kill(outpid, SIGKILL);
937 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
938 addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
945 addr->transport_return = PANIC;
946 addr->message = string_sprintf("Wait() failed for child process of %s "
947 "transport: %s%s", trname, strerror(errno), tmsg);
950 /* Since the transport_filter timed out we assume it has sent the child process
951 a malformed or incomplete data stream. Kill off the child process
952 and prevent checking its exit status as it will has probably exited in error.
953 This prevents the transport_filter timeout message from getting overwritten
954 by the exit error which is not the cause of the problem. */
956 else if (f.transport_filter_timed_out)
958 killpg(pid, SIGKILL);
959 kill(outpid, SIGKILL);
962 /* Either the process completed, but yielded a non-zero (necessarily
963 positive) status, or the process was terminated by a signal (rc will contain
964 the negation of the signal number). Treat killing by signal as failure unless
965 status is being ignored. By default, the message is bounced back, unless
966 freeze_signal is set, in which case it is frozen instead. */
970 if (ob->freeze_signal)
972 addr->transport_return = DEFER;
973 addr->special_action = SPECIAL_FREEZE;
974 addr->message = string_sprintf("Child process of %s transport (running "
975 "command \"%s\") was terminated by signal %d (%s)%s", trname, cmd,
976 -rc, os_strsignal(-rc), tmsg);
978 else if (!ob->ignore_status)
980 addr->transport_return = FAIL;
981 addr->message = string_sprintf("Child process of %s transport (running "
982 "command \"%s\") was terminated by signal %d (%s)%s", trname, cmd,
983 -rc, os_strsignal(-rc), tmsg);
987 /* For positive values (process terminated with non-zero status), we need a
988 status code to request deferral. A number of systems contain the following
991 #define EX_TEMPFAIL 75
995 EX_TEMPFAIL -- temporary failure, indicating something that
996 is not really an error. In sendmail, this means
997 that a mailer (e.g.) could not create a connection,
998 and the request should be reattempted later.
1000 Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1001 not ignoring the returned status. However, there is now an option that
1002 contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1004 Another case that needs special treatment is if execve() failed (typically
1005 the command that was given is a non-existent path). By default this is
1006 treated as just another failure, but if freeze_exec_fail is set, the reaction
1007 is to freeze the message rather than bounce the address. Exim used to signal
1008 this failure with EX_UNAVAILABLE, which is defined in many systems as
1010 #define EX_UNAVAILABLE 69
1012 with the description
1014 EX_UNAVAILABLE -- A service is unavailable. This can occur
1015 if a support program or file does not exist. This
1016 can also be used as a catchall message when something
1017 you wanted to do doesn't work, but you don't know why.
1019 However, this can be confused with a command that actually returns 69 because
1020 something *it* wanted is unavailable. At release 4.21, Exim was changed to
1021 use return code 127 instead, because this is what the shell returns when it
1022 is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1023 child.c to signal execve() failure and other unexpected failures such as
1024 setuid() not working - though that won't be the case here because we aren't
1029 /* Always handle execve() failure specially if requested to */
1031 if (ob->freeze_exec_fail && rc == EX_EXECFAILED)
1033 addr->transport_return = DEFER;
1034 addr->special_action = SPECIAL_FREEZE;
1035 addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1039 /* Otherwise take action only if not ignoring status */
1041 else if (!ob->ignore_status)
1046 /* If temp_errors is "*" all codes are temporary. Initialization checks
1047 that it's either "*" or a list of numbers. If not "*", scan the list of
1048 temporary failure codes; if any match, the result is DEFER. */
1050 if (ob->temp_errors[0] == '*')
1051 addr->transport_return = DEFER;
1055 const uschar *s = ob->temp_errors;
1059 addr->transport_return = FAIL;
1060 while ((p = string_nextinlist(&s,&sep,NULL,0)))
1061 if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1064 /* Ensure the message contains the expanded command and arguments. This
1065 doesn't have to be brilliantly efficient - it is an error situation. */
1067 addr->message = string_sprintf("Child process of %s transport returned "
1069 g = string_cat(NULL, addr->message);
1071 /* If the return code is > 128, it often means that a shell command
1072 was terminated by a signal. */
1075 string_sprintf("(could mean shell command ended by signal %d (%s))",
1076 rc-128, os_strsignal(rc-128)) :
1081 g = string_catn(g, US" ", 1);
1082 g = string_cat (g, ss);
1085 /* Now add the command and arguments */
1087 g = string_catn(g, US" from command:", 14);
1089 for (int i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1092 g = string_catn(g, US" ", 1);
1093 if (Ustrpbrk(argv[i], " \t") != NULL)
1096 g = string_catn(g, US"\"", 1);
1098 g = string_cat(g, argv[i]);
1100 g = string_catn(g, US"\"", 1);
1103 /* Add previous filter timeout message, if present. */
1106 g = string_cat(g, tmsg);
1108 addr->message = string_from_gstring(g);
1113 /* Ensure all subprocesses (in particular, the output handling process)
1114 are complete before we pass this point. */
1116 while (wait(&rc) >= 0);
1118 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", trname,
1119 addr->transport_return);
1121 /* If there has been a problem, the message in addr->message contains details
1122 of the pipe command. We don't want to expose these to the world, so we set up
1123 something bland to return to the sender. */
1125 if (addr->transport_return != OK)
1126 addr->user_message = US"local delivery failed";
1131 #endif /*!MACRO_PREDEF*/
1132 #endif /*TRASPORT_PIPE*/
1133 /* End of transport/pipe.c */