1. Preserve underlying transport filter timeout message if a pipe
[exim.git] / src / src / transports / pipe.c
CommitLineData
22c3b60b 1/* $Cambridge: exim/src/src/transports/pipe.c,v 1.6 2005/05/10 11:13:09 ph10 Exp $ */
0756eb3c
PH
2
3/*************************************************
4* Exim - an Internet mail transport agent *
5*************************************************/
6
c988f1f4 7/* Copyright (c) University of Cambridge 1995 - 2005 */
0756eb3c
PH
8/* See the file NOTICE for conditions of use and distribution. */
9
10
11#include "../exim.h"
12#include "pipe.h"
13
14
15
16/* Options specific to the pipe transport. They must be in alphabetic
17order (note that "_" comes before the lower case letters). Those starting
18with "*" are not settable by the user but are used by the option-reading
19software for alternative value types. Some options are stored in the transport
20instance block so as to be publicly visible; these are flagged with opt_public.
21*/
22
23optionlist pipe_transport_options[] = {
24 { "allow_commands", opt_stringptr,
25 (void *)offsetof(pipe_transport_options_block, allow_commands) },
26 { "batch_id", opt_stringptr | opt_public,
27 (void *)offsetof(transport_instance, batch_id) },
28 { "batch_max", opt_int | opt_public,
29 (void *)offsetof(transport_instance, batch_max) },
30 { "check_string", opt_stringptr,
31 (void *)offsetof(pipe_transport_options_block, check_string) },
32 { "command", opt_stringptr,
33 (void *)offsetof(pipe_transport_options_block, cmd) },
34 { "environment", opt_stringptr,
35 (void *)offsetof(pipe_transport_options_block, environment) },
36 { "escape_string", opt_stringptr,
37 (void *)offsetof(pipe_transport_options_block, escape_string) },
38 { "freeze_exec_fail", opt_bool,
39 (void *)offsetof(pipe_transport_options_block, freeze_exec_fail) },
40 { "ignore_status", opt_bool,
41 (void *)offsetof(pipe_transport_options_block, ignore_status) },
42 { "log_defer_output", opt_bool | opt_public,
43 (void *)offsetof(transport_instance, log_defer_output) },
44 { "log_fail_output", opt_bool | opt_public,
45 (void *)offsetof(transport_instance, log_fail_output) },
46 { "log_output", opt_bool | opt_public,
47 (void *)offsetof(transport_instance, log_output) },
48 { "max_output", opt_mkint,
49 (void *)offsetof(pipe_transport_options_block, max_output) },
50 { "message_prefix", opt_stringptr,
51 (void *)offsetof(pipe_transport_options_block, message_prefix) },
52 { "message_suffix", opt_stringptr,
53 (void *)offsetof(pipe_transport_options_block, message_suffix) },
54 { "path", opt_stringptr,
55 (void *)offsetof(pipe_transport_options_block, path) },
56 { "pipe_as_creator", opt_bool | opt_public,
57 (void *)offsetof(transport_instance, deliver_as_creator) },
58 { "restrict_to_path", opt_bool,
59 (void *)offsetof(pipe_transport_options_block, restrict_to_path) },
60 { "return_fail_output",opt_bool | opt_public,
61 (void *)offsetof(transport_instance, return_fail_output) },
62 { "return_output", opt_bool | opt_public,
63 (void *)offsetof(transport_instance, return_output) },
64 { "temp_errors", opt_stringptr,
65 (void *)offsetof(pipe_transport_options_block, temp_errors) },
66 { "timeout", opt_time,
67 (void *)offsetof(pipe_transport_options_block, timeout) },
2e2a30b4
PH
68 { "timeout_defer", opt_bool,
69 (void *)offsetof(pipe_transport_options_block, timeout_defer) },
0756eb3c
PH
70 { "umask", opt_octint,
71 (void *)offsetof(pipe_transport_options_block, umask) },
72 { "use_bsmtp", opt_bool,
73 (void *)offsetof(pipe_transport_options_block, use_bsmtp) },
74 { "use_crlf", opt_bool,
75 (void *)offsetof(pipe_transport_options_block, use_crlf) },
76 { "use_shell", opt_bool,
77 (void *)offsetof(pipe_transport_options_block, use_shell) },
78};
79
80/* Size of the options list. An extern variable has to be used so that its
81address can appear in the tables drtables.c. */
82
83int pipe_transport_options_count =
84 sizeof(pipe_transport_options)/sizeof(optionlist);
85
86/* Default private options block for the pipe transport. */
87
88pipe_transport_options_block pipe_transport_option_defaults = {
89 NULL, /* cmd */
90 NULL, /* allow_commands */
91 NULL, /* environment */
92 US"/usr/bin", /* path */
93 NULL, /* message_prefix (reset in init if not bsmtp) */
94 NULL, /* message_suffix (ditto) */
95 US mac_expanded_string(EX_TEMPFAIL) ":" /* temp_errors */
96 mac_expanded_string(EX_CANTCREAT),
97 NULL, /* check_string */
98 NULL, /* escape_string */
99 022, /* umask */
100 20480, /* max_output */
101 60*60, /* timeout */
102 0, /* options */
103 FALSE, /* freeze_exec_fail */
104 FALSE, /* ignore_status */
105 FALSE, /* restrict_to_path */
2e2a30b4 106 FALSE, /* timeout_defer */
0756eb3c
PH
107 FALSE, /* use_shell */
108 FALSE, /* use_bsmtp */
109 FALSE /* use_crlf */
110};
111
112
113
114/*************************************************
115* Initialization entry point *
116*************************************************/
117
118/* Called for each instance, after its options have been read, to
119enable consistency checks to be done, or anything else that needs
120to be set up. */
121
122void
123pipe_transport_init(transport_instance *tblock)
124{
125pipe_transport_options_block *ob =
126 (pipe_transport_options_block *)(tblock->options_block);
127
128/* If pipe_as_creator is set, then uid/gid should not be set. */
129
130if (tblock->deliver_as_creator && (tblock->uid_set || tblock->gid_set ||
131 tblock->expand_uid != NULL || tblock->expand_gid != NULL))
132 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
133 "both pipe_as_creator and an explicit uid/gid are set for the %s "
134 "transport", tblock->name);
135
136/* If a fixed uid field is set, then a gid field must also be set. */
137
138if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
139 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
140 "user set without group for the %s transport", tblock->name);
141
142/* Temp_errors must consist only of digits and colons, but there can be
143spaces round the colons, so allow them too. */
144
145if (ob->temp_errors != NULL && Ustrcmp(ob->temp_errors, "*") != 0)
146 {
147 size_t p = Ustrspn(ob->temp_errors, "0123456789: ");
148 if (ob->temp_errors[p] != 0)
149 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
150 "temp_errors must be a list of numbers or an asterisk for the %s "
151 "transport", tblock->name);
152 }
153
154/* Only one of return_output/return_fail_output or log_output/log_fail_output
155should be set. */
156
157if (tblock->return_output && tblock->return_fail_output)
158 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
159 "both return_output and return_fail_output set for %s transport",
160 tblock->name);
161
162if (tblock->log_output && tblock->log_fail_output)
163 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
164 "both log_output and log_fail_output set for the %s transport",
165 tblock->name);
166
167/* If batch SMTP is set, force the check and escape strings, and arrange that
168headers are also escaped. */
169
170if (ob->use_bsmtp)
171 {
172 ob->check_string = US".";
173 ob->escape_string = US"..";
174 ob->options |= topt_escape_headers;
175 }
176
177/* If not batch SMTP, and message_prefix or message_suffix are unset, insert
178default values for them. */
179
180else
181 {
182 if (ob->message_prefix == NULL) ob->message_prefix =
183 US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
184 if (ob->message_suffix == NULL) ob->message_suffix = US"\n";
185 }
186
187/* The restrict_to_path and use_shell options are incompatible */
188
189if (ob->restrict_to_path && ob->use_shell)
190 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
191 "both restrict_to_path and use_shell set for %s transport",
192 tblock->name);
193
194/* The allow_commands and use_shell options are incompatible */
195
196if (ob->allow_commands && ob->use_shell)
197 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
198 "both allow_commands and use_shell set for %s transport",
199 tblock->name);
200
201/* Set up the bitwise options for transport_write_message from the various
202driver options. Only one of body_only and headers_only can be set. */
203
204ob->options |=
205 (tblock->body_only? topt_no_headers : 0) |
206 (tblock->headers_only? topt_no_body : 0) |
207 (tblock->return_path_add? topt_add_return_path : 0) |
208 (tblock->delivery_date_add? topt_add_delivery_date : 0) |
209 (tblock->envelope_to_add? topt_add_envelope_to : 0) |
210 (ob->use_crlf? topt_use_crlf : 0);
211}
212
213
214
215/*************************************************
216* Set up direct (non-shell) command *
217*************************************************/
218
219/* This function is called when a command line is to be parsed by the transport
220and executed directly, without the use of /bin/sh.
221
222Arguments:
223 argvptr pointer to anchor for argv vector
224 cmd points to the command string
225 expand_arguments true if expansion is to occur
226 expand_fail error if expansion fails
227 addr chain of addresses
228 tname the transport name
229 ob the transport options block
230
231Returns: TRUE if all went well; otherwise an error will be
232 set in the first address and FALSE returned
233*/
234
235static BOOL
236set_up_direct_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
237 int expand_fail, address_item *addr, uschar *tname,
238 pipe_transport_options_block *ob)
239{
240BOOL permitted = FALSE;
241uschar **argv;
242uschar buffer[64];
243
244/* Set up "transport <name>" to be put in any error messages, and then
245call the common function for creating an argument list and expanding
246the items if necessary. If it fails, this function fails (error information
247is in the addresses). */
248
249sprintf(CS buffer, "%.50s transport", tname);
250if (!transport_set_up_command(argvptr, cmd, expand_arguments, expand_fail,
251 addr, buffer, NULL))
252 return FALSE;
253
254/* Point to the set-up arguments. */
255
256argv = *argvptr;
257
258/* If allow_commands is set, see if the command is in the permitted list. */
259
260if (ob->allow_commands != NULL)
261 {
262 int sep = 0;
263 uschar *s, *p;
264 uschar buffer[256];
265
266 s = expand_string(ob->allow_commands);
267 if (s == NULL)
268 {
269 addr->transport_return = DEFER;
270 addr->message = string_sprintf("failed to expand string \"%s\" "
271 "for %s transport: %s", ob->allow_commands, tname, expand_string_message);
272 return FALSE;
273 }
274
275 while ((p = string_nextinlist(&s, &sep, buffer, sizeof(buffer))) != NULL)
276 {
277 if (Ustrcmp(p, argv[0]) == 0) { permitted = TRUE; break; }
278 }
279 }
280
281/* If permitted is TRUE it means the command was found in the allowed list, and
282no further checks are done. If permitted = FALSE, it either means
283allow_commands wasn't set, or that the command didn't match anything in the
284list. In both cases, if restrict_to_path is set, we fail if the command
285contains any slashes, but if restrict_to_path is not set, we must fail the
286command only if allow_commands is set. */
287
288if (!permitted)
289 {
290 if (ob->restrict_to_path)
291 {
292 if (Ustrchr(argv[0], '/') != NULL)
293 {
294 addr->transport_return = FAIL;
295 addr->message = string_sprintf("\"/\" found in \"%s\" (command for %s "
296 "transport) - failed for security reasons", cmd, tname);
297 return FALSE;
298 }
299 }
300
301 else if (ob->allow_commands != NULL)
302 {
303 addr->transport_return = FAIL;
304 addr->message = string_sprintf("\"%s\" command not permitted by %s "
305 "transport", argv[0], tname);
306 return FALSE;
307 }
308 }
309
310/* If the command is not an absolute path, search the PATH directories
311for it. */
312
313if (argv[0][0] != '/')
314 {
315 int sep = 0;
316 uschar *p;
317 uschar *listptr = ob->path;
318 uschar buffer[1024];
319
320 while ((p = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer))) != NULL)
321 {
322 struct stat statbuf;
323 sprintf(CS big_buffer, "%.256s/%.256s", p, argv[0]);
324 if (Ustat(big_buffer, &statbuf) == 0)
325 {
326 argv[0] = string_copy(big_buffer);
327 break;
328 }
329 }
330 if (p == NULL)
331 {
332 addr->transport_return = FAIL;
333 addr->message = string_sprintf("\"%s\" command not found for %s transport",
334 argv[0], tname);
335 return FALSE;
336 }
337 }
338
339return TRUE;
340}
341
342
343/*************************************************
344* Set up shell command *
345*************************************************/
346
347/* This function is called when a command line is to be passed to /bin/sh
348without parsing inside the transport.
349
350Arguments:
351 argvptr pointer to anchor for argv vector
352 cmd points to the command string
353 expand_arguments true if expansion is to occur
354 expand_fail error if expansion fails
355 addr chain of addresses
356 tname the transport name
357
358Returns: TRUE if all went well; otherwise an error will be
359 set in the first address and FALSE returned
360*/
361
362static BOOL
363set_up_shell_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
364 int expand_fail, address_item *addr, uschar *tname)
365{
366uschar **argv;
367
368*argvptr = argv = store_get((4)*sizeof(uschar *));
369
370argv[0] = US"/bin/sh";
371argv[1] = US"-c";
372
373/* We have to take special action to handle the special "variable" called
374$pipe_addresses, which is not recognized by the normal expansion function. */
375
376DEBUG(D_transport)
377 debug_printf("shell pipe command before expansion:\n %s\n", cmd);
378
379if (expand_arguments)
380 {
381 uschar *s = cmd;
382 uschar *p = Ustrstr(cmd, "pipe_addresses");
383
384 if (p != NULL && (
385 (p > cmd && p[-1] == '$') ||
386 (p > cmd + 1 && p[-2] == '$' && p[-1] == '{' && p[14] == '}')))
387 {
388 address_item *ad;
389 uschar *q = p + 14;
390 int size = Ustrlen(cmd) + 64;
391 int offset;
392
393 if (p[-1] == '{') { q++; p--; }
394
395 s = store_get(size);
396 offset = p - cmd - 1;
397 Ustrncpy(s, cmd, offset);
398
399 for (ad = addr; ad != NULL; ad = ad->next)
400 {
401 if (ad != addr) string_cat(s, &size, &offset, US" ", 1);
402 string_cat(s, &size, &offset, ad->address, Ustrlen(ad->address));
403 }
404
405 string_cat(s, &size, &offset, q, Ustrlen(q));
406 s[offset] = 0;
407 }
408
409 /* Allow $recipients in the expansion iff it comes from a system filter */
410
411 enable_dollar_recipients = addr != NULL &&
412 addr->parent != NULL &&
413 Ustrcmp(addr->parent->address, "system-filter") == 0;
414 argv[2] = expand_string(s);
415 enable_dollar_recipients = FALSE;
416
417 if (argv[2] == NULL)
418 {
419 addr->transport_return = search_find_defer? DEFER : expand_fail;
420 addr->message = string_sprintf("Expansion of command \"%s\" "
421 "in %s transport failed: %s",
422 cmd, tname, expand_string_message);
423 return FALSE;
424 }
425
426 DEBUG(D_transport)
427 debug_printf("shell pipe command after expansion:\n %s\n", argv[2]);
428 }
429else argv[2] = cmd;
430
431argv[3] = (uschar *)0;
432return TRUE;
433}
434
435
436
437
438/*************************************************
439* Main entry point *
440*************************************************/
441
442/* See local README for interface details. This transport always returns FALSE,
443indicating that the status in the first address is the status for all addresses
444in a batch. */
445
446BOOL
447pipe_transport_entry(
448 transport_instance *tblock, /* data for this instantiation */
449 address_item *addr) /* address(es) we are working on */
450{
451pid_t pid, outpid;
452int fd_in, fd_out, rc;
453int envcount = 0;
454int envsep = 0;
455int expand_fail;
456pipe_transport_options_block *ob =
457 (pipe_transport_options_block *)(tblock->options_block);
458int timeout = ob->timeout;
459BOOL written_ok = FALSE;
460BOOL expand_arguments;
461uschar **argv;
462uschar *envp[50];
463uschar *envlist = ob->environment;
464uschar *cmd, *ss;
465uschar *eol = (ob->use_crlf)? US"\r\n" : US"\n";
466
467DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
468
469/* Set up for the good case */
470
471addr->transport_return = OK;
472addr->basic_errno = 0;
473
474/* Pipes are not accepted as general addresses, but they can be generated from
475.forward files or alias files. In those cases, the pfr flag is set, and the
476command to be obeyed is pointed to by addr->local_part; it starts with the pipe
477symbol. In other cases, the command is supplied as one of the pipe transport's
478options. */
479
480if (testflag(addr, af_pfr) && addr->local_part[0] == '|')
481 {
482 cmd = addr->local_part + 1;
483 while (isspace(*cmd)) cmd++;
484 expand_arguments = testflag(addr, af_expand_pipe);
485 expand_fail = FAIL;
486 }
487else
488 {
489 cmd = ob->cmd;
490 expand_arguments = TRUE;
491 expand_fail = PANIC;
492 }
493
494/* If no command has been supplied, we are in trouble. */
495
496if (cmd == NULL)
497 {
498 addr->transport_return = DEFER;
499 addr->message = string_sprintf("no command specified for %s transport",
500 tblock->name);
501 return FALSE;
502 }
503
504/* When a pipe is set up by a filter file, there may be values for $thisaddress
505and numerical the variables in existence. These are passed in
506addr->pipe_expandn for use here. */
507
508if (expand_arguments && addr->pipe_expandn != NULL)
509 {
510 uschar **ss = addr->pipe_expandn;
511 expand_nmax = -1;
512 if (*ss != NULL) filter_thisaddress = *ss++;
513 while (*ss != NULL)
514 {
515 expand_nstring[++expand_nmax] = *ss;
516 expand_nlength[expand_nmax] = Ustrlen(*ss++);
517 }
518 }
519
520/* The default way of processing the command is to split it up into arguments
521here, and run it directly. This offers some security advantages. However, there
522are installations that want by default to run commands under /bin/sh always, so
523there is an option to do that. */
524
525if (ob->use_shell)
526 {
527 if (!set_up_shell_command(&argv, cmd, expand_arguments, expand_fail, addr,
528 tblock->name)) return FALSE;
529 }
530else if (!set_up_direct_command(&argv, cmd, expand_arguments, expand_fail, addr,
531 tblock->name, ob)) return FALSE;
532
533expand_nmax = -1; /* Reset */
534filter_thisaddress = NULL;
535
536/* Set up the environment for the command. */
537
538envp[envcount++] = string_sprintf("LOCAL_PART=%s", deliver_localpart);
539envp[envcount++] = string_sprintf("LOGNAME=%s", deliver_localpart);
540envp[envcount++] = string_sprintf("USER=%s", deliver_localpart);
541envp[envcount++] = string_sprintf("LOCAL_PART_PREFIX=%#s",
542 deliver_localpart_prefix);
543envp[envcount++] = string_sprintf("LOCAL_PART_SUFFIX=%#s",
544 deliver_localpart_suffix);
545envp[envcount++] = string_sprintf("DOMAIN=%s", deliver_domain);
546envp[envcount++] = string_sprintf("HOME=%#s", deliver_home);
547envp[envcount++] = string_sprintf("MESSAGE_ID=%s", message_id);
548envp[envcount++] = string_sprintf("PATH=%s", ob->path);
549envp[envcount++] = string_sprintf("RECIPIENT=%#s%#s%#s@%#s",
550 deliver_localpart_prefix, deliver_localpart, deliver_localpart_suffix,
551 deliver_domain);
552envp[envcount++] = string_sprintf("QUALIFY_DOMAIN=%s", qualify_domain_sender);
553envp[envcount++] = string_sprintf("SENDER=%s", sender_address);
554envp[envcount++] = US"SHELL=/bin/sh";
555
556if (addr->host_list != NULL)
557 envp[envcount++] = string_sprintf("HOST=%s", addr->host_list->name);
558
559if (timestamps_utc) envp[envcount++] = US"TZ=UTC";
560else if (timezone_string != NULL && timezone_string[0] != 0)
561 envp[envcount++] = string_sprintf("TZ=%s", timezone_string);
562
563/* Add any requested items */
564
565if (envlist != NULL)
566 {
567 envlist = expand_string(envlist);
568 if (envlist == NULL)
569 {
570 addr->transport_return = DEFER;
571 addr->message = string_sprintf("failed to expand string \"%s\" "
572 "for %s transport: %s", ob->environment, tblock->name,
573 expand_string_message);
574 return FALSE;
575 }
576 }
577
578while ((ss = string_nextinlist(&envlist, &envsep, big_buffer, big_buffer_size))
579 != NULL)
580 {
581 if (envcount > sizeof(envp)/sizeof(uschar *) - 2)
582 {
583 addr->transport_return = DEFER;
584 addr->message = string_sprintf("too many environment settings for "
585 "%s transport", tblock->name);
586 return FALSE;
587 }
588 envp[envcount++] = string_copy(ss);
589 }
590
591envp[envcount] = NULL;
592
593/* If the -N option is set, can't do any more. */
594
595if (dont_deliver)
596 {
597 DEBUG(D_transport)
598 debug_printf("*** delivery by %s transport bypassed by -N option",
599 tblock->name);
600 return FALSE;
601 }
602
603
604/* Handling the output from the pipe is tricky. If a file for catching this
605output is provided, we could in theory just hand that fd over to the process,
606but this isn't very safe because it might loop and carry on writing for
607ever (which is exactly what happened in early versions of Exim). Therefore we
608use the standard child_open() function, which creates pipes. We can then read
609our end of the output pipe and count the number of bytes that come through,
610chopping the sub-process if it exceeds some limit.
611
612However, this means we want to run a sub-process with both its input and output
613attached to pipes. We can't handle that easily from a single parent process
614using straightforward code such as the transport_write_message() function
615because the subprocess might not be reading its input because it is trying to
616write to a full output pipe. The complication of redesigning the world to
617handle this is too great - simpler just to run another process to do the
618reading of the output pipe. */
619
620
621/* As this is a local transport, we are already running with the required
622uid/gid and current directory. Request that the new process be a process group
623leader, so we can kill it and all its children on a timeout. */
624
625if ((pid = child_open(argv, envp, ob->umask, &fd_in, &fd_out, TRUE)) < 0)
626 {
627 addr->transport_return = DEFER;
628 addr->message = string_sprintf(
629 "Failed to create child process for %s transport: %s", tblock->name,
630 strerror(errno));
631 return FALSE;
632 }
633
634/* Now fork a process to handle the output that comes down the pipe. */
635
636if ((outpid = fork()) < 0)
637 {
638 addr->basic_errno = errno;
639 addr->transport_return = DEFER;
640 addr->message = string_sprintf(
641 "Failed to create process for handling output in %s transport",
642 tblock->name);
643 close(fd_in);
644 close(fd_out);
645 return FALSE;
646 }
647
648/* This is the code for the output-handling subprocess. Read from the pipe
649in chunks, and write to the return file if one is provided. Keep track of
650the number of bytes handled. If the limit is exceeded, try to kill the
651subprocess group, and in any case close the pipe and exit, which should cause
652the subprocess to fail. */
653
654if (outpid == 0)
655 {
656 int count = 0;
657 close(fd_in);
658 set_process_info("reading output from |%s", cmd);
659 while ((rc = read(fd_out, big_buffer, big_buffer_size)) > 0)
660 {
661 if (addr->return_file >= 0)
662 write(addr->return_file, big_buffer, rc);
663 count += rc;
664 if (count > ob->max_output)
665 {
666 uschar *message = US"\n\n*** Too much output - remainder discarded ***\n";
667 DEBUG(D_transport) debug_printf("Too much output from pipe - killed\n");
668 if (addr->return_file >= 0)
669 write(addr->return_file, message, Ustrlen(message));
670 killpg(pid, SIGKILL);
671 break;
672 }
673 }
674 close(fd_out);
675 _exit(0);
676 }
677
678close(fd_out); /* Not used in this process */
679
680
681/* Carrying on now with the main parent process. Attempt to write the message
682to it down the pipe. It is a fallacy to think that you can detect write errors
683when the sub-process fails to read the pipe. The parent process may complete
684writing and close the pipe before the sub-process completes. We could sleep a
685bit here to let the sub-process get going, but it may still not complete. So we
686ignore all writing errors. (When in the test harness, we do do a short sleep so
687any debugging output is likely to be in the same order.) */
688
689if (running_in_test_harness) millisleep(500);
690
691DEBUG(D_transport) debug_printf("Writing message to pipe\n");
692
693/* Arrange to time out writes if there is a timeout set. */
694
695if (timeout > 0)
696 {
697 sigalrm_seen = FALSE;
698 transport_write_timeout = timeout;
699 }
700
701/* Reset the counter of bytes written */
702
703transport_count = 0;
704
705/* First write any configured prefix information */
706
707if (ob->message_prefix != NULL)
708 {
709 uschar *prefix = expand_string(ob->message_prefix);
710 if (prefix == NULL)
711 {
712 addr->transport_return = search_find_defer? DEFER : PANIC;
713 addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
714 "transport) failed: %s", ob->message_prefix, tblock->name,
715 expand_string_message);
716 return FALSE;
717 }
718 if (!transport_write_block(fd_in, prefix, Ustrlen(prefix)))
719 goto END_WRITE;
720 }
721
722/* If the use_bsmtp option is set, we need to write SMTP prefix information.
723The various different values for batching are handled outside; if there is more
724than one address available here, all must be included. Force SMTP dot-handling.
725*/
726
727if (ob->use_bsmtp)
728 {
729 address_item *a;
730
731 if (!transport_write_string(fd_in, "MAIL FROM:<%s>%s", return_path, eol))
732 goto END_WRITE;
733
734 for (a = addr; a != NULL; a = a->next)
735 {
736 if (!transport_write_string(fd_in,
737 "RCPT TO:<%s>%s",
738 transport_rcpt_address(a, tblock->rcpt_include_affixes),
739 eol))
740 goto END_WRITE;
741 }
742
743 if (!transport_write_string(fd_in, "DATA%s", eol)) goto END_WRITE;
744 }
745
746/* Now the actual message - the options were set at initialization time */
747
748if (!transport_write_message(addr, fd_in, ob->options, 0, tblock->add_headers,
749 tblock->remove_headers, ob->check_string, ob->escape_string,
750 tblock->rewrite_rules, tblock->rewrite_existflags))
751 goto END_WRITE;
752
753/* Now any configured suffix */
754
755if (ob->message_suffix != NULL)
756 {
757 uschar *suffix = expand_string(ob->message_suffix);
758 if (suffix == NULL)
759 {
760 addr->transport_return = search_find_defer? DEFER : PANIC;
761 addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
762 "transport) failed: %s", ob->message_suffix, tblock->name,
763 expand_string_message);
764 return FALSE;
765 }
766 if (!transport_write_block(fd_in, suffix, Ustrlen(suffix)))
767 goto END_WRITE;
768 }
769
770/* If local_smtp, write the terminating dot. */
771
772if (ob->use_bsmtp && !transport_write_string(fd_in, ".%s", eol))
773 goto END_WRITE;
774
775/* Flag all writing completed successfully. */
776
777written_ok = TRUE;
778
779/* Come here if there are errors during writing. */
780
781END_WRITE:
782
783/* OK, the writing is now all done. Close the pipe. */
784
785(void) close(fd_in);
786
787/* Handle errors during writing. For timeouts, set the timeout for waiting for
788the child process to 1 second. If the process at the far end of the pipe died
789without reading all of it, we expect an EPIPE error, which should be ignored.
790We used also to ignore WRITEINCOMPLETE but the writing function is now cleverer
791at handling OS where the death of a pipe doesn't give EPIPE immediately. See
2e2a30b4 792comments therein. */
0756eb3c
PH
793
794if (!written_ok)
795 {
796 if (errno == ETIMEDOUT)
2e2a30b4
PH
797 {
798 addr->message = string_sprintf("%stimeout while writing to pipe",
799 transport_filter_timed_out? "transport filter " : "");
800 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
0756eb3c 801 timeout = 1;
2e2a30b4
PH
802 }
803 else if (errno == EPIPE)
0756eb3c 804 {
2e2a30b4 805 debug_printf("transport error EPIPE ignored\n");
0756eb3c
PH
806 }
807 else
808 {
8e669ac1 809 addr->transport_return = PANIC;
0756eb3c
PH
810 addr->basic_errno = errno;
811 if (errno == ERRNO_CHHEADER_FAIL)
812 addr->message =
813 string_sprintf("Failed to expand headers_add or headers_remove: %s",
814 expand_string_message);
815 else if (errno == ERRNO_FILTER_FAIL)
35af9f61
PH
816 addr->message = string_sprintf("Transport filter process failed (%d)%s",
817 addr->more_errno,
818 (addr->more_errno == EX_EXECFAILED)? ": unable to execute command" : "");
0756eb3c
PH
819 else if (errno == ERRNO_WRITEINCOMPLETE)
820 addr->message = string_sprintf("Failed repeatedly to write data");
821 else
822 addr->message = string_sprintf("Error %d", errno);
823 return FALSE;
824 }
825 }
826
827/* Wait for the child process to complete and take action if the returned
828status is nonzero. The timeout will be just 1 second if any of the writes
829above timed out. */
830
831if ((rc = child_close(pid, timeout)) != 0)
832 {
22c3b60b
PH
833 uschar *tmsg = (addr->message == NULL)? US"" :
834 string_sprintf(" (preceded by %s)", addr->message);
835
0756eb3c
PH
836 /* The process did not complete in time; kill its process group and fail
837 the delivery. It appears to be necessary to kill the output process too, as
838 otherwise it hangs on for some time if the actual pipe process is sleeping.
839 (At least, that's what I observed on Solaris 2.5.1.) Since we are failing
840 the delivery, that shouldn't cause any problem. */
841
842 if (rc == -256)
843 {
844 killpg(pid, SIGKILL);
845 kill(outpid, SIGKILL);
2e2a30b4 846 addr->transport_return = ob->timeout_defer? DEFER : FAIL;
22c3b60b 847 addr->message = string_sprintf("pipe delivery process timed out%s", tmsg);
0756eb3c
PH
848 }
849
850 /* Wait() failed. */
851
852 else if (rc == -257)
853 {
854 addr->transport_return = PANIC;
855 addr->message = string_sprintf("Wait() failed for child process of %s "
22c3b60b 856 "transport: %s%s", tblock->name, strerror(errno), tmsg);
0756eb3c
PH
857 }
858
859 /* Either the process completed, but yielded a non-zero (necessarily
860 positive) status, or the process was terminated by a signal (rc will contain
861 the negation of the signal number). Treat killing by signal as failure unless
862 status is being ignored. */
863
864 else if (rc < 0)
865 {
866 if (!ob->ignore_status)
867 {
868 addr->transport_return = FAIL;
869 addr->message = string_sprintf("Child process of %s transport (running "
22c3b60b
PH
870 "command \"%s\") was terminated by signal %d (%s)%s", tblock->name, cmd,
871 -rc, os_strsignal(-rc), tmsg);
0756eb3c
PH
872 }
873 }
874
875 /* For positive values (process terminated with non-zero status), we need a
876 status code to request deferral. A number of systems contain the following
877 line in sysexits.h:
878
879 #define EX_TEMPFAIL 75
880
881 with the description
882
883 EX_TEMPFAIL -- temporary failure, indicating something that
884 is not really an error. In sendmail, this means
885 that a mailer (e.g.) could not create a connection,
886 and the request should be reattempted later.
887
888 Based on this, we use exit code EX_TEMPFAIL as a default to mean "defer" when
889 not ignoring the returned status. However, there is now an option that
890 contains a list of temporary codes, with TEMPFAIL and CANTCREAT as defaults.
891
892 Another case that needs special treatment is if execve() failed (typically
893 the command that was given is a non-existent path). By default this is
894 treated as just another failure, but if freeze_exec_fail is set, the reaction
895 is to freeze the message rather than bounce the address. Exim used to signal
896 this failure with EX_UNAVAILABLE, which is definined in many systems as
897
898 #define EX_UNAVAILABLE 69
899
900 with the description
901
902 EX_UNAVAILABLE -- A service is unavailable. This can occur
903 if a support program or file does not exist. This
904 can also be used as a catchall message when something
905 you wanted to do doesn't work, but you don't know why.
906
907 However, this can be confused with a command that actually returns 69 because
908 something *it* wanted is unavailable. At release 4.21, Exim was changed to
909 use return code 127 instead, because this is what the shell returns when it
910 is unable to exec a command. We define it as EX_EXECFAILED, and use it in
911 child.c to signal execve() failure and other unexpected failures such as
912 setuid() not working - though that won't be the case here because we aren't
913 changing uid. */
914
915 else
916 {
917 /* Always handle execve() failure specially if requested to */
918
919 if (ob->freeze_exec_fail && (rc == EX_EXECFAILED))
920 {
921 addr->transport_return = DEFER;
922 addr->special_action = SPECIAL_FREEZE;
22c3b60b
PH
923 addr->message = string_sprintf("pipe process failed to exec \"%s\"%s",
924 cmd, tmsg);
0756eb3c
PH
925 }
926
927 /* Otherwise take action only if not ignoring status */
928
929 else if (!ob->ignore_status)
930 {
931 uschar *ss;
932 int size, ptr, i;
933
934 /* If temp_errors is "*" all codes are temporary. Initializion checks
935 that it's either "*" or a list of numbers. If not "*", scan the list of
936 temporary failure codes; if any match, the result is DEFER. */
937
938 if (ob->temp_errors[0] == '*')
939 addr->transport_return = DEFER;
940
941 else
942 {
943 uschar *s = ob->temp_errors;
944 uschar *p;
945 uschar buffer[64];
946 int sep = 0;
947
948 addr->transport_return = FAIL;
949 while ((p = string_nextinlist(&s,&sep,buffer,sizeof(buffer))) != NULL)
950 {
951 if (rc == Uatoi(p)) { addr->transport_return = DEFER; break; }
952 }
953 }
954
955 /* Ensure the message contains the expanded command and arguments. This
956 doesn't have to be brilliantly efficient - it is an error situation. */
957
958 addr->message = string_sprintf("Child process of %s transport returned "
959 "%d", tblock->name, rc);
960
961 ptr = Ustrlen(addr->message);
962 size = ptr + 1;
963
964 /* If the return code is > 128, it often means that a shell command
965 was terminated by a signal. */
966
967 ss = (rc > 128)?
968 string_sprintf("(could mean shell command ended by signal %d (%s))",
969 rc-128, os_strsignal(rc-128)) :
970 US os_strexit(rc);
971
972 if (*ss != 0)
973 {
974 addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
975 addr->message = string_cat(addr->message, &size, &ptr,
976 ss, Ustrlen(ss));
977 }
978
979 /* Now add the command and arguments */
980
981 addr->message = string_cat(addr->message, &size, &ptr,
982 US" from command:", 14);
983
984 for (i = 0; i < sizeof(argv)/sizeof(int *) && argv[i] != NULL; i++)
985 {
986 BOOL quote = FALSE;
987 addr->message = string_cat(addr->message, &size, &ptr, US" ", 1);
988 if (Ustrpbrk(argv[i], " \t") != NULL)
989 {
990 quote = TRUE;
991 addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
992 }
993 addr->message = string_cat(addr->message, &size, &ptr, argv[i],
994 Ustrlen(argv[i]));
995 if (quote)
996 addr->message = string_cat(addr->message, &size, &ptr, US"\"", 1);
997 }
22c3b60b
PH
998
999 /* Add previous filter timeout message, if present. */
1000
1001 if (*tmsg != 0)
1002 addr->message = string_cat(addr->message, &size, &ptr, tmsg,
1003 Ustrlen(tmsg));
1004
0756eb3c
PH
1005 addr->message[ptr] = 0; /* Ensure concatenated string terminated */
1006 }
1007 }
1008 }
1009
1010/* Ensure all subprocesses (in particular, the output handling process)
1011are complete before we pass this point. */
1012
1013while (wait(&rc) >= 0);
1014
1015DEBUG(D_transport) debug_printf("%s transport yielded %d\n", tblock->name,
1016 addr->transport_return);
1017
1018/* If there has been a problem, the message in addr->message contains details
1019of the pipe command. We don't want to expose these to the world, so we set up
1020something bland to return to the sender. */
1021
1022if (addr->transport_return != OK)
1023 addr->user_message = US"local delivery failed";
1024
1025return FALSE;
1026}
1027
1028/* End of transport/pipe.c */