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