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);
98 /* Default private options block for the pipe transport. */
100 pipe_transport_options_block pipe_transport_option_defaults = {
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 */
112 20480, /* max_output */
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 */
130 /*************************************************
131 * Setup entry point *
132 *************************************************/
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.
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
147 Returns: OK, FAIL, or DEFER
151 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
152 transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
154 pipe_transport_options_block *ob =
155 (pipe_transport_options_block *)(tblock->options_block);
157 addrlist = addrlist; /* Keep compiler happy */
164 #ifdef HAVE_SETCLASSRESOURCES
165 if (ob->use_classresources)
167 struct passwd *pw = getpwuid(uid);
170 login_cap_t *lc = login_getpwclass(pw);
173 setclassresources(lc);
181 if (ob->permit_coredump)
184 rl.rlim_cur = RLIM_INFINITY;
185 rl.rlim_max = RLIM_INFINITY;
186 if (setrlimit(RLIMIT_CORE, &rl) < 0)
188 #ifdef SETRLIMIT_NOT_SUPPORTED
189 if (errno != ENOSYS && errno != ENOTSUP)
191 log_write(0, LOG_MAIN,
192 "delivery setrlimit(RLIMIT_CORE, RLIM_INFINITY) failed: %s",
203 /*************************************************
204 * Initialization entry point *
205 *************************************************/
207 /* Called for each instance, after its options have been read, to
208 enable consistency checks to be done, or anything else that needs
212 pipe_transport_init(transport_instance *tblock)
214 pipe_transport_options_block *ob =
215 (pipe_transport_options_block *)(tblock->options_block);
217 /* Set up the setup entry point, to be called in the privileged state */
219 tblock->setup = pipe_transport_setup;
221 /* If pipe_as_creator is set, then uid/gid should not be set. */
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);
229 /* If a fixed uid field is set, then a gid field must also be set. */
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);
235 /* Temp_errors must consist only of digits and colons, but there can be
236 spaces round the colons, so allow them too. */
238 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
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);
247 /* Only one of return_output/return_fail_output or log_output/log_fail_output
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",
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",
260 /* If batch SMTP is set, force the check and escape strings, and arrange that
261 headers are also escaped. */
265 ob->check_string = US".";
266 ob->escape_string = US"..";
267 ob->options |= topt_escape_headers;
270 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
271 default values for them. */
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";
280 /* The restrict_to_path and use_shell options are incompatible */
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",
287 /* The allow_commands and use_shell options are incompatible */
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",
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. */
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);
308 /*************************************************
309 * Set up direct (non-shell) command *
310 *************************************************/
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.
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
324 Returns: TRUE if all went well; otherwise an error will be
325 set in the first address and FALSE returned
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)
333 BOOL permitted = FALSE;
336 /* Set up "transport <name>" to be put in any error messages, and then
337 call the common function for creating an argument list and expanding
338 the items if necessary. If it fails, this function fails (error information
339 is in the addresses). */
341 if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
342 addr, string_sprintf("%.50s transport", tname), NULL))
345 /* Point to the set-up arguments. */
349 /* If allow_commands is set, see if the command is in the permitted list. */
351 if (ob->allow_commands)
357 if (!(s = expand_string(ob->allow_commands)))
359 addr->transport_return = DEFER;
360 addr->message = string_sprintf("failed to expand string \"%s\" "
361 "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
365 while ((p = string_nextinlist(&s, &sep, NULL, 0)))
366 if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
369 /* If permitted is TRUE it means the command was found in the allowed list, and
370 no further checks are done. If permitted = FALSE, it either means
371 allow_commands wasn't set, or that the command didn't match anything in the
372 list. In both cases, if restrict_to_path is set, we fail if the command
373 contains any slashes, but if restrict_to_path is not set, we must fail the
374 command only if allow_commands is set. */
378 if (ob->restrict_to_path)
380 if (Ustrchr(argv[0], '/') != NULL)
382 addr->transport_return = FAIL;
383 addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
384 "transport) - failed for security reasons", cmd, tname);
389 else if (ob->allow_commands)
391 addr->transport_return = FAIL;
392 addr->message = string_sprintf("\"%s\" command not permitted by %s "
393 "transport", argv[0], tname);
398 /* If the command is not an absolute path, search the PATH directories
401 if (argv[0][0] != '/')
405 const uschar *listptr = expand_string(ob->path);
407 while ((p = string_nextinlist(&listptr, &sep, NULL, 0)))
410 sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
411 if (Ustat(big_buffer, &statbuf) == 0)
413 argv[0] = string_copy(big_buffer);
419 addr->transport_return = FAIL;
420 addr->message = string_sprintf("\"%s\" command not found for %s transport",
430 /*************************************************
431 * Set up shell command *
432 *************************************************/
434 /* This function is called when a command line is to be passed to /bin/sh
435 without parsing inside the transport.
438 argvptr pointer to anchor for argv vector
439 cmd points to the command string
440 expand_arguments true if expansion is to occur
441 expand_fail error if expansion fails
442 addr chain of addresses
443 tname the transport name
445 Returns: TRUE if all went well; otherwise an error will be
446 set in the first address and FALSE returned
450 set_up_shell_command(const uschar ***argvptr, uschar *cmd,
451 BOOL expand_arguments, int expand_fail, address_item *addr, uschar *tname)
455 *argvptr = argv = store_get((4)*sizeof(uschar *));
457 argv[0] = US"/bin/sh";
460 /* We have to take special action to handle the special "variable" called
461 $pipe_addresses, which is not recognized by the normal expansion function. */
464 debug_printf("shell pipe command before expansion:\n %s\n", cmd);
466 if (expand_arguments)
469 uschar *p = Ustrstr(cmd, "pipe_addresses");
472 (p > cmd && p[-1] == '$') ||
473 (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
477 int size = Ustrlen(cmd) + 64;
480 if (p[-1] == '{') { q++; p--; }
483 offset = p - cmd - 1;
484 Ustrncpy(s, cmd, offset);
486 for (ad = addr; ad != NULL; ad = ad->next)
488 /*XXX string_append_listele() ? */
489 if (ad != addr) s = string_catn(s, &size, &offset, US" ", 1);
490 s = string_cat(s, &size, &offset, ad->address);
493 s = string_cat(s, &size, &offset, q);
497 /* Allow $recipients in the expansion iff it comes from a system filter */
499 enable_dollar_recipients = addr != NULL &&
500 addr->parent != NULL &&
501 Ustrcmp(addr->parent->address, "system-filter") == 0;
502 argv[2] = expand_string(s);
503 enable_dollar_recipients = FALSE;
507 addr->transport_return = search_find_defer? DEFER : expand_fail;
508 addr->message = string_sprintf("Expansion of command \"%s\" "
509 "in %s transport failed: %s",
510 cmd, tname, expand_string_message);
515 debug_printf("shell pipe command after expansion:\n %s\n", argv[2]);
519 argv[3] = (uschar *)0;
526 /*************************************************
528 *************************************************/
530 /* See local README for interface details. This transport always returns FALSE,
531 indicating that the status in the first address is the status for all addresses
535 pipe_transport_entry(
536 transport_instance *tblock, /* data for this instantiation */
537 address_item *addr) /* address(es) we are working on */
540 int fd_in, fd_out, rc;
544 pipe_transport_options_block *ob =
545 (pipe_transport_options_block *)(tblock->options_block);
546 int timeout = ob->timeout;
547 BOOL written_ok = FALSE;
548 BOOL expand_arguments;
551 const uschar *envlist = ob->environment;
553 uschar *eol = ob->use_crlf ? US"\r\n" : US"\n";
554 transport_ctx tctx = {
560 ob->options /* set at initialization time */
563 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
565 /* Set up for the good case */
567 addr->transport_return = OK;
568 addr->basic_errno = 0;
570 /* Pipes are not accepted as general addresses, but they can be generated from
571 .forward files or alias files. In those cases, the pfr flag is set, and the
572 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
573 symbol. In other cases, the command is supplied as one of the pipe transport's
576 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
578 if (ob->force_command)
580 /* Enables expansion of $address_pipe into separate arguments */
581 setflag(addr, af_force_command);
583 expand_arguments = TRUE;
588 cmd = addr->local_part + 1;
589 while (isspace(*cmd)) cmd++;
590 expand_arguments = testflag(addr, af_expand_pipe);
597 expand_arguments = TRUE;
601 /* If no command has been supplied, we are in trouble.
602 * We also check for an empty string since it may be
603 * coming from addr->local_part[0] == '|'
606 if (cmd == NULL || *cmd == '\0')
608 addr->transport_return = DEFER;
609 addr->message = string_sprintf("no command specified for %s transport",
614 /* When a pipe is set up by a filter file, there may be values for $thisaddress
615 and numerical the variables in existence. These are passed in
616 addr->pipe_expandn for use here. */
618 if (expand_arguments && addr->pipe_expandn)
620 uschar **ss = addr->pipe_expandn;
622 if (*ss != NULL) filter_thisaddress = *ss++;
625 expand_nstring[++expand_nmax] = *ss;
626 expand_nlength[expand_nmax] = Ustrlen(*ss++);
630 /* The default way of processing the command is to split it up into arguments
631 here, and run it directly. This offers some security advantages. However, there
632 are installations that want by default to run commands under /bin/sh always, so
633 there is an option to do that. */
637 if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
638 tblock->name)) return FALSE;
640 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
641 tblock->name, ob)) return FALSE;
643 expand_nmax = -1; /* Reset */
644 filter_thisaddress = NULL;
646 /* Set up the environment for the command. */
648 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
649 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
650 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
651 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
652 deliver_localpart_prefix);
653 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
654 deliver_localpart_suffix);
655 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
656 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
657 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
658 envp[envcount++] = string_sprintf("PATH=%s", expand_string(ob->path));
659 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
660 deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
662 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
663 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
664 envp[envcount++] = US"SHELL=/bin/sh";
666 if (addr->host_list != NULL)
667 envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
669 if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
670 else if (timezone_string != NULL && timezone_string[0] != 0)
671 envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
673 /* Add any requested items */
677 envlist = expand_cstring(envlist);
680 addr->transport_return = DEFER;
681 addr->message = string_sprintf("failed to expand string \"%s\" "
682 "for %s transport: %s", ob->environment, tblock->name,
683 expand_string_message);
688 while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
691 if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
693 addr->transport_return = DEFER;
694 addr->message = string_sprintf("too many environment settings for "
695 "%s transport", tblock->name);
698 envp[envcount++] = string_copy(ss);
701 envp[envcount] = NULL;
703 /* If the -N option is set, can't do any more. */
708 debug_printf("*** delivery by %s transport bypassed by -N option",
714 /* Handling the output from the pipe is tricky. If a file for catching this
715 output is provided, we could in theory just hand that fd over to the process,
716 but this isn't very safe because it might loop and carry on writing for
717 ever (which is exactly what happened in early versions of Exim). Therefore we
718 use the standard child_open() function, which creates pipes. We can then read
719 our end of the output pipe and count the number of bytes that come through,
720 chopping the sub-process if it exceeds some limit.
722 However, this means we want to run a sub-process with both its input and output
723 attached to pipes. We can't handle that easily from a single parent process
724 using straightforward code such as the transport_write_message() function
725 because the subprocess might not be reading its input because it is trying to
726 write to a full output pipe. The complication of redesigning the world to
727 handle this is too great - simpler just to run another process to do the
728 reading of the output pipe. */
731 /* As this is a local transport, we are already running with the required
732 uid/gid and current directory. Request that the new process be a process group
733 leader, so we can kill it and all its children on a timeout. */
735 if ((pid = child_open(USS argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
737 addr->transport_return = DEFER;
738 addr->message = string_sprintf(
739 "Failed to create child process for %s transport: %s", tblock->name,
745 /* Now fork a process to handle the output that comes down the pipe. */
747 if ((outpid = fork()) < 0)
749 addr->basic_errno = errno;
750 addr->transport_return = DEFER;
751 addr->message = string_sprintf(
752 "Failed to create process for handling output in %s transport",
759 /* This is the code for the output-handling subprocess. Read from the pipe
760 in chunks, and write to the return file if one is provided. Keep track of
761 the number of bytes handled. If the limit is exceeded, try to kill the
762 subprocess group, and in any case close the pipe and exit, which should cause
763 the subprocess to fail. */
769 set_process_info("reading output from |%s", cmd);
770 while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
772 if (addr->return_file >= 0)
773 if(write(addr->return_file, big_buffer, rc) != rc)
774 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
776 if (count > ob->max_output)
778 DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
779 if (addr->return_file >= 0)
781 uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
782 rc = Ustrlen(message);
783 if(write(addr->return_file, message, rc) != rc)
784 DEBUG(D_transport) debug_printf("Problem writing to return_file\n");
786 killpg(pid, SIGKILL);
794 (void)close(fd_out); /* Not used in this process */
797 /* Carrying on now with the main parent process. Attempt to write the message
798 to it down the pipe. It is a fallacy to think that you can detect write errors
799 when the sub-process fails to read the pipe. The parent process may complete
800 writing and close the pipe before the sub-process completes. We could sleep a
801 bit here to let the sub-process get going, but it may still not complete. So we
802 ignore all writing errors. (When in the test harness, we do do a short sleep so
803 any debugging output is likely to be in the same order.) */
805 if (running_in_test_harness) millisleep(500);
807 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
809 /* Arrange to time out writes if there is a timeout set. */
813 sigalrm_seen = FALSE;
814 transport_write_timeout = timeout;
817 /* Reset the counter of bytes written */
821 /* First write any configured prefix information */
823 if (ob->message_prefix != NULL)
825 uschar *prefix = expand_string(ob->message_prefix);
828 addr->transport_return = search_find_defer? DEFER : PANIC;
829 addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
830 "transport) failed: %s", ob->message_prefix, tblock->name,
831 expand_string_message);
834 if (!transport_write_block(&tctx, prefix, Ustrlen(prefix), FALSE))
838 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
839 The various different values for batching are handled outside; if there is more
840 than one address available here, all must be included. Force SMTP dot-handling.
847 if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
850 for (a = addr; a; a = a->next)
851 if (!transport_write_string(fd_in,
853 transport_rcpt_address(a, tblock->rcpt_include_affixes),
857 if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
860 /* Now the actual message */
862 if (!transport_write_message(&tctx, 0))
865 /* Now any configured suffix */
867 if (ob->message_suffix)
869 uschar *suffix = expand_string(ob->message_suffix);
872 addr->transport_return = search_find_defer? DEFER : PANIC;
873 addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
874 "transport) failed: %s", ob->message_suffix, tblock->name,
875 expand_string_message);
878 if (!transport_write_block(&tctx, suffix, Ustrlen(suffix), FALSE))
882 /* If local_smtp, write the terminating dot. */
884 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
887 /* Flag all writing completed successfully. */
891 /* Come here if there are errors during writing. */
895 /* OK, the writing is now all done. Close the pipe. */
899 /* Handle errors during writing. For timeouts, set the timeout for waiting for
900 the child process to 1 second. If the process at the far end of the pipe died
901 without reading all of it, we expect an EPIPE error, which should be ignored.
902 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
903 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
908 if (errno == ETIMEDOUT)
910 addr->message = string_sprintf("%stimeout while writing to pipe",
911 transport_filter_timed_out? "transport filter " : "");
912 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
915 else if (errno == EPIPE)
917 debug_printf("transport error EPIPE ignored\n");
921 addr->transport_return = PANIC;
922 addr->basic_errno = errno;
923 if (errno == ERRNO_CHHEADER_FAIL)
925 string_sprintf("Failed to expand headers_add or headers_remove: %s",
926 expand_string_message);
927 else if (errno == ERRNO_FILTER_FAIL)
928 addr->message = string_sprintf("Transport filter process failed (%d)%s",
930 (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
931 else if (errno == ERRNO_WRITEINCOMPLETE)
932 addr->message = string_sprintf("Failed repeatedly to write data");
934 addr->message = string_sprintf("Error %d", errno);
939 /* Wait for the child process to complete and take action if the returned
940 status is nonzero. The timeout will be just 1 second if any of the writes
943 if ((rc = child_close(pid, timeout)) != 0)
945 uschar *tmsg = (addr->message == NULL)? US"" :
946 string_sprintf(" (preceded by %s)", addr->message);
948 /* The process did not complete in time; kill its process group and fail
949 the delivery. It appears to be necessary to kill the output process too, as
950 otherwise it hangs on for some time if the actual pipe process is sleeping.
951 (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
952 the delivery, that shouldn't cause any problem. */
956 killpg(pid, SIGKILL);
957 kill(outpid, SIGKILL);
958 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
959 addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
966 addr->transport_return = PANIC;
967 addr->message = string_sprintf("Wait() failed for child process of %s "
968 "transport: %s%s", tblock->name, strerror(errno), tmsg);
971 /* Since the transport_filter timed out we assume it has sent the child process
972 a malformed or incomplete data stream. Kill off the child process
973 and prevent checking its exit status as it will has probably exited in error.
974 This prevents the transport_filter timeout message from getting overwritten
975 by the exit error which is not the cause of the problem. */
977 else if (transport_filter_timed_out)
979 killpg(pid, SIGKILL);
980 kill(outpid, SIGKILL);
983 /* Either the process completed, but yielded a non-zero (necessarily
984 positive) status, or the process was terminated by a signal (rc will contain
985 the negation of the signal number). Treat killing by signal as failure unless
986 status is being ignored. By default, the message is bounced back, unless
987 freeze_signal is set, in which case it is frozen instead. */
991 if (ob->freeze_signal)
993 addr->transport_return = DEFER;
994 addr->special_action = SPECIAL_FREEZE;
995 addr->message = string_sprintf("Child process of %s transport (running "
996 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
997 -rc, os_strsignal(-rc), tmsg);
999 else if (!ob->ignore_status)
1001 addr->transport_return = FAIL;
1002 addr->message = string_sprintf("Child process of %s transport (running "
1003 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
1004 -rc, os_strsignal(-rc), tmsg);
1008 /* For positive values (process terminated with non-zero status), we need a
1009 status code to request deferral. A number of systems contain the following
1012 #define EX_TEMPFAIL 75
1014 with the description
1016 EX_TEMPFAIL -- temporary failure, indicating something that
1017 is not really an error. In sendmail, this means
1018 that a mailer (e.g.) could not create a connection,
1019 and the request should be reattempted later.
1021 Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1022 not ignoring the returned status. However, there is now an option that
1023 contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1025 Another case that needs special treatment is if execve() failed (typically
1026 the command that was given is a non-existent path). By default this is
1027 treated as just another failure, but if freeze_exec_fail is set, the reaction
1028 is to freeze the message rather than bounce the address. Exim used to signal
1029 this failure with EX_UNAVAILABLE, which is defined in many systems as
1031 #define EX_UNAVAILABLE 69
1033 with the description
1035 EX_UNAVAILABLE -- A service is unavailable. This can occur
1036 if a support program or file does not exist. This
1037 can also be used as a catchall message when something
1038 you wanted to do doesn't work, but you don't know why.
1040 However, this can be confused with a command that actually returns 69 because
1041 something *it* wanted is unavailable. At release 4.21, Exim was changed to
1042 use return code 127 instead, because this is what the shell returns when it
1043 is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1044 child.c to signal execve() failure and other unexpected failures such as
1045 setuid() not working - though that won't be the case here because we aren't
1050 /* Always handle execve() failure specially if requested to */
1052 if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
1054 addr->transport_return = DEFER;
1055 addr->special_action = SPECIAL_FREEZE;
1056 addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1060 /* Otherwise take action only if not ignoring status */
1062 else if (!ob->ignore_status)
1067 /* If temp_errors is "*" all codes are temporary. Initialization checks
1068 that it's either "*" or a list of numbers. If not "*", scan the list of
1069 temporary failure codes; if any match, the result is DEFER. */
1071 if (ob->temp_errors[0] == '*')
1072 addr->transport_return = DEFER;
1076 const uschar *s = ob->temp_errors;
1080 addr->transport_return = FAIL;
1081 while ((p = string_nextinlist(&s,&sep,NULL,0)))
1082 if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1085 /* Ensure the message contains the expanded command and arguments. This
1086 doesn't have to be brilliantly efficient - it is an error situation. */
1088 addr->message = string_sprintf("Child process of %s transport returned "
1089 "%d", tblock->name, rc);
1091 ptr = Ustrlen(addr->message);
1094 /* If the return code is > 128, it often means that a shell command
1095 was terminated by a signal. */
1098 string_sprintf("(could mean shell command ended by signal %d (%s))",
1099 rc-128, os_strsignal(rc-128)) :
1104 addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1105 addr->message = string_cat (addr->message, &size, &ptr, ss);
1108 /* Now add the command and arguments */
1110 addr->message = string_catn(addr->message, &size, &ptr,
1111 US" from command:", 14);
1113 for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1116 addr->message = string_catn(addr->message, &size, &ptr, US" ", 1);
1117 if (Ustrpbrk(argv[i], " \t") != NULL)
1120 addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1122 addr->message = string_cat(addr->message, &size, &ptr, argv[i]);
1124 addr->message = string_catn(addr->message, &size, &ptr, US"\"", 1);
1127 /* Add previous filter timeout message, if present. */
1130 addr->message = string_cat(addr->message, &size, &ptr, tmsg);
1132 addr->message[ptr] = 0; /* Ensure concatenated string terminated */
1137 /* Ensure all subprocesses (in particular, the output handling process)
1138 are complete before we pass this point. */
1140 while (wait(&rc) >= 0);
1142 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1143 addr->transport_return);
1145 /* If there has been a problem, the message in addr->message contains details
1146 of the pipe command. We don't want to expose these to the world, so we set up
1147 something bland to return to the sender. */
1149 if (addr->transport_return != OK)
1150 addr->user_message = US"local delivery failed";
1155 /* End of transport/pipe.c */