1 /* $Cambridge: exim/src/src/transports/pipe.c,v 1.15 2010/06/05 10:04:44 pdp Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
14 #ifdef HAVE_SETCLASSRESOURCES
15 #include <login_cap.h>
20 /* Options specific to the pipe transport. They must be in alphabetic
21 order (note that "_" comes before the lower case letters). Those starting
22 with "*" are not settable by the user but are used by the option-reading
23 software for alternative value types. Some options are stored in the transport
24 instance block so as to be publicly visible; these are flagged with opt_public.
27 optionlist pipe_transport_options[] = {
28 { "allow_commands", opt_stringptr,
29 (void *)offsetof(pipe_transport_options_block, allow_commands) },
30 { "batch_id", opt_stringptr | opt_public,
31 (void *)offsetof(transport_instance, batch_id) },
32 { "batch_max", opt_int | opt_public,
33 (void *)offsetof(transport_instance, batch_max) },
34 { "check_string", opt_stringptr,
35 (void *)offsetof(pipe_transport_options_block, check_string) },
36 { "command", opt_stringptr,
37 (void *)offsetof(pipe_transport_options_block, cmd) },
38 { "environment", opt_stringptr,
39 (void *)offsetof(pipe_transport_options_block, environment) },
40 { "escape_string", opt_stringptr,
41 (void *)offsetof(pipe_transport_options_block, escape_string) },
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, /* freeze_exec_fail */
116 FALSE, /* freeze_signal */
117 FALSE, /* ignore_status */
118 FALSE, /* permit_coredump */
119 FALSE, /* restrict_to_path */
120 FALSE, /* timeout_defer */
121 FALSE, /* use_shell */
122 FALSE, /* use_bsmtp */
123 FALSE, /* use_classresources */
129 /*************************************************
130 * Setup entry point *
131 *************************************************/
133 /* Called for each delivery in the privileged state, just before the uid/gid
134 are changed and the main entry point is called. In a system that supports the
135 login_cap facilities, this function is used to set the class resource limits
136 for the user. It may also re-enable coredumps.
139 tblock points to the transport instance
140 addrlist addresses about to be delivered (not used)
141 dummy not used (doesn't pass back data)
142 uid the uid that will be set (not used)
143 gid the gid that will be set (not used)
144 errmsg where to put an error message
146 Returns: OK, FAIL, or DEFER
150 pipe_transport_setup(transport_instance *tblock, address_item *addrlist,
151 transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
153 pipe_transport_options_block *ob =
154 (pipe_transport_options_block *)(tblock->options_block);
156 addrlist = addrlist; /* Keep compiler happy */
163 #ifdef HAVE_SETCLASSRESOURCES
164 if (ob->use_classresources)
166 struct passwd *pw = getpwuid(uid);
169 login_cap_t *lc = login_getpwclass(pw);
172 setclassresources(lc);
180 if (ob->permit_coredump)
183 rl.rlim_cur = RLIM_INFINITY;
184 rl.rlim_max = RLIM_INFINITY;
185 if (setrlimit(RLIMIT_CORE, &rl) < 0)
187 #ifdef SETRLIMIT_NOT_SUPPORTED
188 if (errno != ENOSYS && errno != ENOTSUP)
190 log_write(0, LOG_MAIN,
191 "delivery setrlimit(RLIMIT_CORE, RLIMI_INFINITY) failed: %s",
202 /*************************************************
203 * Initialization entry point *
204 *************************************************/
206 /* Called for each instance, after its options have been read, to
207 enable consistency checks to be done, or anything else that needs
211 pipe_transport_init(transport_instance *tblock)
213 pipe_transport_options_block *ob =
214 (pipe_transport_options_block *)(tblock->options_block);
216 /* Set up the setup entry point, to be called in the privileged state */
218 tblock->setup = pipe_transport_setup;
220 /* If pipe_as_creator is set, then uid/gid should not be set. */
222 if (tblock->deliver_as_creator && (tblock->uid_set || tblock->gid_set ||
223 tblock->expand_uid != NULL || tblock->expand_gid != NULL))
224 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
225 "both pipe_as_creator and an explicit uid/gid are set for the %s "
226 "transport", tblock->name);
228 /* If a fixed uid field is set, then a gid field must also be set. */
230 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
231 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
232 "user set without group for the %s transport", tblock->name);
234 /* Temp_errors must consist only of digits and colons, but there can be
235 spaces round the colons, so allow them too. */
237 if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
239 size_t p = Ustrspn(ob->temp_errors, "0123456789: ");
240 if (ob->temp_errors[p] != 0)
241 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
242 "temp_errors must be a list of numbers or an asterisk for the %s "
243 "transport", tblock->name);
246 /* Only one of return_output/return_fail_output or log_output/log_fail_output
249 if (tblock->return_output && tblock->return_fail_output)
250 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
251 "both return_output and return_fail_output set for %s transport",
254 if (tblock->log_output && tblock->log_fail_output)
255 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
256 "both log_output and log_fail_output set for the %s transport",
259 /* If batch SMTP is set, force the check and escape strings, and arrange that
260 headers are also escaped. */
264 ob->check_string = US".";
265 ob->escape_string = US"..";
266 ob->options |= topt_escape_headers;
269 /* If not batch SMTP, and message_prefix or message_suffix are unset, insert
270 default values for them. */
274 if (ob->message_prefix == NULL) ob->message_prefix =
275 US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
276 if (ob->message_suffix == NULL) ob->message_suffix = US"\n";
279 /* The restrict_to_path and use_shell options are incompatible */
281 if (ob->restrict_to_path && ob->use_shell)
282 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
283 "both restrict_to_path and use_shell set for %s transport",
286 /* The allow_commands and use_shell options are incompatible */
288 if (ob->allow_commands && ob->use_shell)
289 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
290 "both allow_commands and use_shell set for %s transport",
293 /* Set up the bitwise options for transport_write_message from the various
294 driver options. Only one of body_only and headers_only can be set. */
297 (tblock->body_only? topt_no_headers : 0) |
298 (tblock->headers_only? topt_no_body : 0) |
299 (tblock->return_path_add? topt_add_return_path : 0) |
300 (tblock->delivery_date_add? topt_add_delivery_date : 0) |
301 (tblock->envelope_to_add? topt_add_envelope_to : 0) |
302 (ob->use_crlf? topt_use_crlf : 0);
307 /*************************************************
308 * Set up direct (non-shell) command *
309 *************************************************/
311 /* This function is called when a command line is to be parsed by the transport
312 and executed directly, without the use of /bin/sh.
315 argvptr pointer to anchor for argv vector
316 cmd points to the command string
317 expand_arguments true if expansion is to occur
318 expand_fail error if expansion fails
319 addr chain of addresses
320 tname the transport name
321 ob the transport options block
323 Returns: TRUE if all went well; otherwise an error will be
324 set in the first address and FALSE returned
328 set_up_direct_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
329 int expand_fail, address_item *addr, uschar *tname,
330 pipe_transport_options_block *ob)
332 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 sprintf(CS buffer, "%.50s transport", tname);
342 if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
346 /* Point to the set-up arguments. */
350 /* If allow_commands is set, see if the command is in the permitted list. */
352 if (ob->allow_commands != NULL)
358 s = expand_string(ob->allow_commands);
361 addr->transport_return = DEFER;
362 addr->message = string_sprintf("failed to expand string \"%s\" "
363 "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
367 while ((p = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
369 if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
373 /* If permitted is TRUE it means the command was found in the allowed list, and
374 no further checks are done. If permitted = FALSE, it either means
375 allow_commands wasn't set, or that the command didn't match anything in the
376 list. In both cases, if restrict_to_path is set, we fail if the command
377 contains any slashes, but if restrict_to_path is not set, we must fail the
378 command only if allow_commands is set. */
382 if (ob->restrict_to_path)
384 if (Ustrchr(argv[0], '/') != NULL)
386 addr->transport_return = FAIL;
387 addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
388 "transport) - failed for security reasons", cmd, tname);
393 else if (ob->allow_commands != NULL)
395 addr->transport_return = FAIL;
396 addr->message = string_sprintf("\"%s\" command not permitted by %s "
397 "transport", argv[0], tname);
402 /* If the command is not an absolute path, search the PATH directories
405 if (argv[0][0] != '/')
409 uschar *listptr = ob->path;
412 while ((p = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer))) != NULL)
415 sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
416 if (Ustat(big_buffer, &statbuf) == 0)
418 argv[0] = string_copy(big_buffer);
424 addr->transport_return = FAIL;
425 addr->message = string_sprintf("\"%s\" command not found for %s transport",
435 /*************************************************
436 * Set up shell command *
437 *************************************************/
439 /* This function is called when a command line is to be passed to /bin/sh
440 without parsing inside the transport.
443 argvptr pointer to anchor for argv vector
444 cmd points to the command string
445 expand_arguments true if expansion is to occur
446 expand_fail error if expansion fails
447 addr chain of addresses
448 tname the transport name
450 Returns: TRUE if all went well; otherwise an error will be
451 set in the first address and FALSE returned
455 set_up_shell_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
456 int expand_fail, address_item *addr, uschar *tname)
460 *argvptr = argv = store_get((4)*sizeof(uschar *));
462 argv[0] = US"/bin/sh";
465 /* We have to take special action to handle the special "variable" called
466 $pipe_addresses, which is not recognized by the normal expansion function. */
469 debug_printf("shell pipe command before expansion:\n %s\n", cmd);
471 if (expand_arguments)
474 uschar *p = Ustrstr(cmd, "pipe_addresses");
477 (p > cmd && p[-1] == '$') ||
478 (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
482 int size = Ustrlen(cmd) + 64;
485 if (p[-1] == '{') { q++; p--; }
488 offset = p - cmd - 1;
489 Ustrncpy(s, cmd, offset);
491 for (ad = addr; ad != NULL; ad = ad->next)
493 if (ad != addr) string_cat(s, &size, &offset, US" ", 1);
494 string_cat(s, &size, &offset, ad->address, Ustrlen(ad->address));
497 string_cat(s, &size, &offset, q, Ustrlen(q));
501 /* Allow $recipients in the expansion iff it comes from a system filter */
503 enable_dollar_recipients = addr != NULL &&
504 addr->parent != NULL &&
505 Ustrcmp(addr->parent->address, "system-filter") == 0;
506 argv[2] = expand_string(s);
507 enable_dollar_recipients = FALSE;
511 addr->transport_return = search_find_defer? DEFER : expand_fail;
512 addr->message = string_sprintf("Expansion of command \"%s\" "
513 "in %s transport failed: %s",
514 cmd, tname, expand_string_message);
519 debug_printf("shell pipe command after expansion:\n %s\n", argv[2]);
523 argv[3] = (uschar *)0;
530 /*************************************************
532 *************************************************/
534 /* See local README for interface details. This transport always returns FALSE,
535 indicating that the status in the first address is the status for all addresses
539 pipe_transport_entry(
540 transport_instance *tblock, /* data for this instantiation */
541 address_item *addr) /* address(es) we are working on */
544 int fd_in, fd_out, rc;
548 pipe_transport_options_block *ob =
549 (pipe_transport_options_block *)(tblock->options_block);
550 int timeout = ob->timeout;
551 BOOL written_ok = FALSE;
552 BOOL expand_arguments;
555 uschar *envlist = ob->environment;
557 uschar *eol = (ob->use_crlf)? US"\r\n" : US"\n";
559 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
561 /* Set up for the good case */
563 addr->transport_return = OK;
564 addr->basic_errno = 0;
566 /* Pipes are not accepted as general addresses, but they can be generated from
567 .forward files or alias files. In those cases, the pfr flag is set, and the
568 command to be obeyed is pointed to by addr->local_part; it starts with the pipe
569 symbol. In other cases, the command is supplied as one of the pipe transport's
572 if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
574 cmd = addr->local_part + 1;
575 while (isspace(*cmd)) cmd++;
576 expand_arguments = testflag(addr, af_expand_pipe);
582 expand_arguments = TRUE;
586 /* If no command has been supplied, we are in trouble. */
590 addr->transport_return = DEFER;
591 addr->message = string_sprintf("no command specified for %s transport",
596 /* When a pipe is set up by a filter file, there may be values for $thisaddress
597 and numerical the variables in existence. These are passed in
598 addr->pipe_expandn for use here. */
600 if (expand_arguments && addr->pipe_expandn != NULL)
602 uschar **ss = addr->pipe_expandn;
604 if (*ss != NULL) filter_thisaddress = *ss++;
607 expand_nstring[++expand_nmax] = *ss;
608 expand_nlength[expand_nmax] = Ustrlen(*ss++);
612 /* The default way of processing the command is to split it up into arguments
613 here, and run it directly. This offers some security advantages. However, there
614 are installations that want by default to run commands under /bin/sh always, so
615 there is an option to do that. */
619 if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
620 tblock->name)) return FALSE;
622 else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
623 tblock->name, ob)) return FALSE;
625 expand_nmax = -1; /* Reset */
626 filter_thisaddress = NULL;
628 /* Set up the environment for the command. */
630 envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
631 envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
632 envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
633 envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
634 deliver_localpart_prefix);
635 envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
636 deliver_localpart_suffix);
637 envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
638 envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
639 envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
640 envp[envcount++] = string_sprintf("PATH=%s", ob->path);
641 envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
642 deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
644 envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
645 envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
646 envp[envcount++] = US"SHELL=/bin/sh";
648 if (addr->host_list != NULL)
649 envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
651 if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
652 else if (timezone_string != NULL && timezone_string[0] != 0)
653 envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
655 /* Add any requested items */
659 envlist = expand_string(envlist);
662 addr->transport_return = DEFER;
663 addr->message = string_sprintf("failed to expand string \"%s\" "
664 "for %s transport: %s", ob->environment, tblock->name,
665 expand_string_message);
670 while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
673 if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
675 addr->transport_return = DEFER;
676 addr->message = string_sprintf("too many environment settings for "
677 "%s transport", tblock->name);
680 envp[envcount++] = string_copy(ss);
683 envp[envcount] = NULL;
685 /* If the -N option is set, can't do any more. */
690 debug_printf("*** delivery by %s transport bypassed by -N option",
696 /* Handling the output from the pipe is tricky. If a file for catching this
697 output is provided, we could in theory just hand that fd over to the process,
698 but this isn't very safe because it might loop and carry on writing for
699 ever (which is exactly what happened in early versions of Exim). Therefore we
700 use the standard child_open() function, which creates pipes. We can then read
701 our end of the output pipe and count the number of bytes that come through,
702 chopping the sub-process if it exceeds some limit.
704 However, this means we want to run a sub-process with both its input and output
705 attached to pipes. We can't handle that easily from a single parent process
706 using straightforward code such as the transport_write_message() function
707 because the subprocess might not be reading its input because it is trying to
708 write to a full output pipe. The complication of redesigning the world to
709 handle this is too great - simpler just to run another process to do the
710 reading of the output pipe. */
713 /* As this is a local transport, we are already running with the required
714 uid/gid and current directory. Request that the new process be a process group
715 leader, so we can kill it and all its children on a timeout. */
717 if ((pid = child_open(argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
719 addr->transport_return = DEFER;
720 addr->message = string_sprintf(
721 "Failed to create child process for %s transport: %s", tblock->name,
726 /* Now fork a process to handle the output that comes down the pipe. */
728 if ((outpid = fork()) < 0)
730 addr->basic_errno = errno;
731 addr->transport_return = DEFER;
732 addr->message = string_sprintf(
733 "Failed to create process for handling output in %s transport",
740 /* This is the code for the output-handling subprocess. Read from the pipe
741 in chunks, and write to the return file if one is provided. Keep track of
742 the number of bytes handled. If the limit is exceeded, try to kill the
743 subprocess group, and in any case close the pipe and exit, which should cause
744 the subprocess to fail. */
750 set_process_info("reading output from |%s", cmd);
751 while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
753 if (addr->return_file >= 0)
754 write(addr->return_file, big_buffer, rc);
756 if (count > ob->max_output)
758 uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
759 DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
760 if (addr->return_file >= 0)
761 write(addr->return_file, message, Ustrlen(message));
762 killpg(pid, SIGKILL);
770 (void)close(fd_out); /* Not used in this process */
773 /* Carrying on now with the main parent process. Attempt to write the message
774 to it down the pipe. It is a fallacy to think that you can detect write errors
775 when the sub-process fails to read the pipe. The parent process may complete
776 writing and close the pipe before the sub-process completes. We could sleep a
777 bit here to let the sub-process get going, but it may still not complete. So we
778 ignore all writing errors. (When in the test harness, we do do a short sleep so
779 any debugging output is likely to be in the same order.) */
781 if (running_in_test_harness) millisleep(500);
783 DEBUG(D_transport) debug_printf("Writing message to pipe\n");
785 /* Arrange to time out writes if there is a timeout set. */
789 sigalrm_seen = FALSE;
790 transport_write_timeout = timeout;
793 /* Reset the counter of bytes written */
797 /* First write any configured prefix information */
799 if (ob->message_prefix != NULL)
801 uschar *prefix = expand_string(ob->message_prefix);
804 addr->transport_return = search_find_defer? DEFER : PANIC;
805 addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
806 "transport) failed: %s", ob->message_prefix, tblock->name,
807 expand_string_message);
810 if (!transport_write_block(fd_in, prefix, Ustrlen(prefix)))
814 /* If the use_bsmtp option is set, we need to write SMTP prefix information.
815 The various different values for batching are handled outside; if there is more
816 than one address available here, all must be included. Force SMTP dot-handling.
823 if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
826 for (a = addr; a != NULL; a = a->next)
828 if (!transport_write_string(fd_in,
830 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 - the options were set at initialization time */
840 if (!transport_write_message(addr, fd_in, ob->options, 0, tblock->add_headers,
841 tblock->remove_headers, ob->check_string, ob->escape_string,
842 tblock->rewrite_rules, tblock->rewrite_existflags))
845 /* Now any configured suffix */
847 if (ob->message_suffix != NULL)
849 uschar *suffix = expand_string(ob->message_suffix);
852 addr->transport_return = search_find_defer? DEFER : PANIC;
853 addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
854 "transport) failed: %s", ob->message_suffix, tblock->name,
855 expand_string_message);
858 if (!transport_write_block(fd_in, suffix, Ustrlen(suffix)))
862 /* If local_smtp, write the terminating dot. */
864 if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
867 /* Flag all writing completed successfully. */
871 /* Come here if there are errors during writing. */
875 /* OK, the writing is now all done. Close the pipe. */
879 /* Handle errors during writing. For timeouts, set the timeout for waiting for
880 the child process to 1 second. If the process at the far end of the pipe died
881 without reading all of it, we expect an EPIPE error, which should be ignored.
882 We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
883 at handling OS where the death of a pipe doesn't give EPIPE immediately. See
888 if (errno == ETIMEDOUT)
890 addr->message = string_sprintf("%stimeout while writing to pipe",
891 transport_filter_timed_out? "transport filter " : "");
892 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
895 else if (errno == EPIPE)
897 debug_printf("transport error EPIPE ignored\n");
901 addr->transport_return = PANIC;
902 addr->basic_errno = errno;
903 if (errno == ERRNO_CHHEADER_FAIL)
905 string_sprintf("Failed to expand headers_add or headers_remove: %s",
906 expand_string_message);
907 else if (errno == ERRNO_FILTER_FAIL)
908 addr->message = string_sprintf("Transport filter process failed (%d)%s",
910 (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
911 else if (errno == ERRNO_WRITEINCOMPLETE)
912 addr->message = string_sprintf("Failed repeatedly to write data");
914 addr->message = string_sprintf("Error %d", errno);
919 /* Wait for the child process to complete and take action if the returned
920 status is nonzero. The timeout will be just 1 second if any of the writes
923 if ((rc = child_close(pid, timeout)) != 0)
925 uschar *tmsg = (addr->message == NULL)? US"" :
926 string_sprintf(" (preceded by %s)", addr->message);
928 /* The process did not complete in time; kill its process group and fail
929 the delivery. It appears to be necessary to kill the output process too, as
930 otherwise it hangs on for some time if the actual pipe process is sleeping.
931 (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
932 the delivery, that shouldn't cause any problem. */
936 killpg(pid, SIGKILL);
937 kill(outpid, SIGKILL);
938 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
939 addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
946 addr->transport_return = PANIC;
947 addr->message = string_sprintf("Wait() failed for child process of %s "
948 "transport: %s%s", tblock->name, strerror(errno), tmsg);
951 /* Since the transport_filter timed out we assume it has sent the child process
952 a malformed or incomplete data stream. Kill off the child process
953 and prevent checking its exit status as it will has probably exited in error.
954 This prevents the transport_filter timeout message from getting overwritten
955 by the exit error which is not the cause of the problem. */
957 else if (transport_filter_timed_out)
959 killpg(pid, SIGKILL);
960 kill(outpid, SIGKILL);
963 /* Either the process completed, but yielded a non-zero (necessarily
964 positive) status, or the process was terminated by a signal (rc will contain
965 the negation of the signal number). Treat killing by signal as failure unless
966 status is being ignored. By default, the message is bounced back, unless
967 freeze_signal is set, in which case it is frozen instead. */
971 if (ob->freeze_signal)
973 addr->transport_return = DEFER;
974 addr->special_action = SPECIAL_FREEZE;
975 addr->message = string_sprintf("Child process of %s transport (running "
976 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
977 -rc, os_strsignal(-rc), tmsg);
979 else if (!ob->ignore_status)
981 addr->transport_return = FAIL;
982 addr->message = string_sprintf("Child process of %s transport (running "
983 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
984 -rc, os_strsignal(-rc), tmsg);
988 /* For positive values (process terminated with non-zero status), we need a
989 status code to request deferral. A number of systems contain the following
992 #define EX_TEMPFAIL 75
996 EX_TEMPFAIL -- temporary failure, indicating something that
997 is not really an error. In sendmail, this means
998 that a mailer (e.g.) could not create a connection,
999 and the request should be reattempted later.
1001 Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
1002 not ignoring the returned status. However, there is now an option that
1003 contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
1005 Another case that needs special treatment is if execve() failed (typically
1006 the command that was given is a non-existent path). By default this is
1007 treated as just another failure, but if freeze_exec_fail is set, the reaction
1008 is to freeze the message rather than bounce the address. Exim used to signal
1009 this failure with EX_UNAVAILABLE, which is definined in many systems as
1011 #define EX_UNAVAILABLE 69
1013 with the description
1015 EX_UNAVAILABLE -- A service is unavailable. This can occur
1016 if a support program or file does not exist. This
1017 can also be used as a catchall message when something
1018 you wanted to do doesn't work, but you don't know why.
1020 However, this can be confused with a command that actually returns 69 because
1021 something *it* wanted is unavailable. At release 4.21, Exim was changed to
1022 use return code 127 instead, because this is what the shell returns when it
1023 is unable to exec a command. We define it as EX_EXECFAILED, and use it in
1024 child.c to signal execve() failure and other unexpected failures such as
1025 setuid() not working - though that won't be the case here because we aren't
1030 /* Always handle execve() failure specially if requested to */
1032 if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
1034 addr->transport_return = DEFER;
1035 addr->special_action = SPECIAL_FREEZE;
1036 addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
1040 /* Otherwise take action only if not ignoring status */
1042 else if (!ob->ignore_status)
1047 /* If temp_errors is "*" all codes are temporary. Initializion checks
1048 that it's either "*" or a list of numbers. If not "*", scan the list of
1049 temporary failure codes; if any match, the result is DEFER. */
1051 if (ob->temp_errors[0] == '*')
1052 addr->transport_return = DEFER;
1056 uschar *s = ob->temp_errors;
1061 addr->transport_return = FAIL;
1062 while ((p = string_nextinlist(&s,&sep,buffer,sizeof(buffer))) != NULL)
1064 if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
1068 /* Ensure the message contains the expanded command and arguments. This
1069 doesn't have to be brilliantly efficient - it is an error situation. */
1071 addr->message = string_sprintf("Child process of %s transport returned "
1072 "%d", tblock->name, rc);
1074 ptr = Ustrlen(addr->message);
1077 /* If the return code is > 128, it often means that a shell command
1078 was terminated by a signal. */
1081 string_sprintf("(could mean shell command ended by signal %d (%s))",
1082 rc-128, os_strsignal(rc-128)) :
1087 addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
1088 addr->message = string_cat(addr->message, &size, &ptr,
1092 /* Now add the command and arguments */
1094 addr->message = string_cat(addr->message, &size, &ptr,
1095 US" from command:", 14);
1097 for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
1100 addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
1101 if (Ustrpbrk(argv[i], " \t") != NULL)
1104 addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
1106 addr->message = string_cat(addr->message, &size, &ptr, argv[i],
1109 addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
1112 /* Add previous filter timeout message, if present. */
1115 addr->message = string_cat(addr->message, &size, &ptr, tmsg,
1118 addr->message[ptr] = 0; /* Ensure concatenated string terminated */
1123 /* Ensure all subprocesses (in particular, the output handling process)
1124 are complete before we pass this point. */
1126 while (wait(&rc) >= 0);
1128 DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1129 addr->transport_return);
1131 /* If there has been a problem, the message in addr->message contains details
1132 of the pipe command. We don't want to expose these to the world, so we set up
1133 something bland to return to the sender. */
1135 if (addr->transport_return != OK)
1136 addr->user_message = US"local delivery failed";
1141 /* End of transport/pipe.c */