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