c4f3745096205ab29b300667b0bc14e6e53a1ac1
[users/jgh/exim.git] / src / src / transport.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* General functions concerned with transportation, and generic options for all
9 transports. */
10
11
12 #include "exim.h"
13
14 /* Generic options for transports, all of which live inside transport_instance
15 data blocks and which therefore have the opt_public flag set. Note that there
16 are other options living inside this structure which can be set only from
17 certain transports. */
18
19 optionlist optionlist_transports[] = {
20   /*    name            type                                    value */
21   { "*expand_group",    opt_stringptr|opt_hidden|opt_public,
22                  (void *)offsetof(transport_instance, expand_gid) },
23   { "*expand_user",     opt_stringptr|opt_hidden|opt_public,
24                  (void *)offsetof(transport_instance, expand_uid) },
25   { "*headers_rewrite_flags", opt_int|opt_public|opt_hidden,
26                  (void *)offsetof(transport_instance, rewrite_existflags) },
27   { "*headers_rewrite_rules", opt_void|opt_public|opt_hidden,
28                  (void *)offsetof(transport_instance, rewrite_rules) },
29   { "*set_group",       opt_bool|opt_hidden|opt_public,
30                  (void *)offsetof(transport_instance, gid_set) },
31   { "*set_user",        opt_bool|opt_hidden|opt_public,
32                  (void *)offsetof(transport_instance, uid_set) },
33   { "body_only",        opt_bool|opt_public,
34                  (void *)offsetof(transport_instance, body_only) },
35   { "current_directory", opt_stringptr|opt_public,
36                  (void *)offsetof(transport_instance, current_dir) },
37   { "debug_print",      opt_stringptr | opt_public,
38                  (void *)offsetof(transport_instance, debug_string) },
39   { "delivery_date_add", opt_bool|opt_public,
40                  (void *)(offsetof(transport_instance, delivery_date_add)) },
41   { "disable_logging",  opt_bool|opt_public,
42                  (void *)(offsetof(transport_instance, disable_logging)) },
43   { "driver",           opt_stringptr|opt_public,
44                  (void *)offsetof(transport_instance, driver_name) },
45   { "envelope_to_add",   opt_bool|opt_public,
46                  (void *)(offsetof(transport_instance, envelope_to_add)) },
47 #ifndef DISABLE_EVENT
48   { "event_action",     opt_stringptr | opt_public,
49                  (void *)offsetof(transport_instance, event_action) },
50 #endif
51   { "group",             opt_expand_gid|opt_public,
52                  (void *)offsetof(transport_instance, gid) },
53   { "headers_add",      opt_stringptr|opt_public|opt_rep_str,
54                  (void *)offsetof(transport_instance, add_headers) },
55   { "headers_only",     opt_bool|opt_public,
56                  (void *)offsetof(transport_instance, headers_only) },
57   { "headers_remove",   opt_stringptr|opt_public|opt_rep_str,
58                  (void *)offsetof(transport_instance, remove_headers) },
59   { "headers_rewrite",  opt_rewrite|opt_public,
60                  (void *)offsetof(transport_instance, headers_rewrite) },
61   { "home_directory",   opt_stringptr|opt_public,
62                  (void *)offsetof(transport_instance, home_dir) },
63   { "initgroups",       opt_bool|opt_public,
64                  (void *)offsetof(transport_instance, initgroups) },
65   { "max_parallel",     opt_stringptr|opt_public,
66                  (void *)offsetof(transport_instance, max_parallel) },
67   { "message_size_limit", opt_stringptr|opt_public,
68                  (void *)offsetof(transport_instance, message_size_limit) },
69   { "rcpt_include_affixes", opt_bool|opt_public,
70                  (void *)offsetof(transport_instance, rcpt_include_affixes) },
71   { "retry_use_local_part", opt_bool|opt_public,
72                  (void *)offsetof(transport_instance, retry_use_local_part) },
73   { "return_path",      opt_stringptr|opt_public,
74                  (void *)(offsetof(transport_instance, return_path)) },
75   { "return_path_add",   opt_bool|opt_public,
76                  (void *)(offsetof(transport_instance, return_path_add)) },
77   { "shadow_condition", opt_stringptr|opt_public,
78                  (void *)offsetof(transport_instance, shadow_condition) },
79   { "shadow_transport", opt_stringptr|opt_public,
80                  (void *)offsetof(transport_instance, shadow) },
81   { "transport_filter", opt_stringptr|opt_public,
82                  (void *)offsetof(transport_instance, filter_command) },
83   { "transport_filter_timeout", opt_time|opt_public,
84                  (void *)offsetof(transport_instance, filter_timeout) },
85   { "user",             opt_expand_uid|opt_public,
86                  (void *)offsetof(transport_instance, uid) }
87 };
88
89 int optionlist_transports_size = nelem(optionlist_transports);
90
91 #ifdef MACRO_PREDEF
92
93 # include "macro_predef.h"
94
95 void
96 options_transports(void)
97 {
98 uschar buf[64];
99
100 options_from_list(optionlist_transports, nelem(optionlist_transports), US"TRANSPORTS", NULL);
101
102 for (transport_info * ti = transports_available; ti->driver_name[0]; ti++)
103   {
104   spf(buf, sizeof(buf), US"_DRIVER_TRANSPORT_%T", ti->driver_name);
105   builtin_macro_create(buf);
106   options_from_list(ti->options, (unsigned)*ti->options_count, US"TRANSPORT", ti->driver_name);
107   }
108 }
109
110 #else   /*!MACRO_PREDEF*/
111
112 /* Structure for keeping list of addresses that have been added to
113 Envelope-To:, in order to avoid duplication. */
114
115 struct aci {
116   struct aci *next;
117   address_item *ptr;
118   };
119
120
121 /* Static data for write_chunk() */
122
123 static uschar *chunk_ptr;           /* chunk pointer */
124 static uschar *nl_check;            /* string to look for at line start */
125 static int     nl_check_length;     /* length of same */
126 static uschar *nl_escape;           /* string to insert */
127 static int     nl_escape_length;    /* length of same */
128 static int     nl_partial_match;    /* length matched at chunk end */
129
130
131 /*************************************************
132 *             Initialize transport list           *
133 *************************************************/
134
135 /* Read the transports section of the configuration file, and set up a chain of
136 transport instances according to its contents. Each transport has generic
137 options and may also have its own private options. This function is only ever
138 called when transports == NULL. We use generic code in readconf to do most of
139 the work. */
140
141 void
142 transport_init(void)
143 {
144 readconf_driver_init(US"transport",
145   (driver_instance **)(&transports),     /* chain anchor */
146   (driver_info *)transports_available,   /* available drivers */
147   sizeof(transport_info),                /* size of info block */
148   &transport_defaults,                   /* default values for generic options */
149   sizeof(transport_instance),            /* size of instance block */
150   optionlist_transports,                 /* generic options */
151   optionlist_transports_size);
152
153 /* Now scan the configured transports and check inconsistencies. A shadow
154 transport is permitted only for local transports. */
155
156 for (transport_instance * t = transports; t; t = t->next)
157   {
158   if (!t->info->local && t->shadow)
159     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
160       "shadow transport not allowed on non-local transport %s", t->name);
161
162   if (t->body_only && t->headers_only)
163     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
164       "%s transport: body_only and headers_only are mutually exclusive",
165       t->name);
166   }
167 }
168
169
170
171 /*************************************************
172 *             Write block of data                *
173 *************************************************/
174
175 static int
176 tpt_write(int fd, uschar * block, int len, BOOL more, int options)
177 {
178 return
179 #ifndef DISABLE_TLS
180   tls_out.active.sock == fd
181     ? tls_write(tls_out.active.tls_ctx, block, len, more) :
182 #endif
183 #ifdef MSG_MORE
184   more && !(options & topt_not_socket) ? send(fd, block, len, MSG_MORE) :
185 #endif
186   write(fd, block, len);
187 }
188
189 /* Subroutine called by write_chunk() and at the end of the message actually
190 to write a data block. Also called directly by some transports to write
191 additional data to the file descriptor (e.g. prefix, suffix).
192
193 If a transport wants data transfers to be timed, it sets a non-zero value in
194 transport_write_timeout. A non-zero transport_write_timeout causes a timer to
195 be set for each block of data written from here. If time runs out, then write()
196 fails and provokes an error return. The caller can then inspect sigalrm_seen to
197 check for a timeout.
198
199 On some systems, if a quota is exceeded during the write, the yield is the
200 number of bytes written rather than an immediate error code. This also happens
201 on some systems in other cases, for example a pipe that goes away because the
202 other end's process terminates (Linux). On other systems, (e.g. Solaris 2) you
203 get the error codes the first time.
204
205 The write() function is also interruptible; the Solaris 2.6 man page says:
206
207      If write() is interrupted by a signal before it writes any
208      data, it will return -1 with errno set to EINTR.
209
210      If write() is interrupted by a signal after it successfully
211      writes some data, it will return the number of bytes written.
212
213 To handle these cases, we want to restart the write() to output the remainder
214 of the data after a non-negative return from write(), except after a timeout.
215 In the error cases (EDQUOT, EPIPE) no bytes get written the second time, and a
216 proper error then occurs. In principle, after an interruption, the second
217 write() could suffer the same fate, but we do not want to continue for
218 evermore, so stick a maximum repetition count on the loop to act as a
219 longstop.
220
221 Arguments:
222   tctx      transport context: file descriptor or string to write to
223   block     block of bytes to write
224   len       number of bytes to write
225   more      further data expected soon
226
227 Returns:    TRUE on success, FALSE on failure (with errno preserved);
228               transport_count is incremented by the number of bytes written
229 */
230
231 static BOOL
232 transport_write_block_fd(transport_ctx * tctx, uschar * block, int len, BOOL more)
233 {
234 int rc, save_errno;
235 int local_timeout = transport_write_timeout;
236 int connretry = 1;
237 int fd = tctx->u.fd;
238
239 /* This loop is for handling incomplete writes and other retries. In most
240 normal cases, it is only ever executed once. */
241
242 for (int i = 0; i < 100; i++)
243   {
244   DEBUG(D_transport)
245     debug_printf("writing data block fd=%d size=%d timeout=%d%s\n",
246       fd, len, local_timeout, more ? " (more expected)" : "");
247
248   /* When doing TCP Fast Open we may get this far before the 3-way handshake
249   is complete, and write returns ENOTCONN.  Detect that, wait for the socket
250   to become writable, and retry once only. */
251
252   for(;;)
253     {
254     fd_set fds;
255     /* This code makes use of alarm() in order to implement the timeout. This
256     isn't a very tidy way of doing things. Using non-blocking I/O with select()
257     provides a neater approach. However, I don't know how to do this when TLS is
258     in use. */
259
260     if (transport_write_timeout <= 0)   /* No timeout wanted */
261       {
262       rc = tpt_write(fd, block, len, more, tctx->options);
263       save_errno = errno;
264       }
265     else                                /* Timeout wanted. */
266       {
267       ALARM(local_timeout);
268         rc = tpt_write(fd, block, len, more, tctx->options);
269         save_errno = errno;
270       local_timeout = ALARM_CLR(0);
271       if (sigalrm_seen)
272         {
273         errno = ETIMEDOUT;
274         return FALSE;
275         }
276       }
277
278     if (rc >= 0 || errno != ENOTCONN || connretry <= 0)
279       break;
280
281     FD_ZERO(&fds); FD_SET(fd, &fds);
282     select(fd+1, NULL, &fds, NULL, NULL);       /* could set timout? */
283     connretry--;
284     }
285
286   /* Hopefully, the most common case is success, so test that first. */
287
288   if (rc == len) { transport_count += len; return TRUE; }
289
290   /* A non-negative return code is an incomplete write. Try again for the rest
291   of the block. If we have exactly hit the timeout, give up. */
292
293   if (rc >= 0)
294     {
295     len -= rc;
296     block += rc;
297     transport_count += rc;
298     DEBUG(D_transport) debug_printf("write incomplete (%d)\n", rc);
299     goto CHECK_TIMEOUT;   /* A few lines below */
300     }
301
302   /* A negative return code with an EINTR error is another form of
303   incomplete write, zero bytes having been written */
304
305   if (save_errno == EINTR)
306     {
307     DEBUG(D_transport)
308       debug_printf("write interrupted before anything written\n");
309     goto CHECK_TIMEOUT;   /* A few lines below */
310     }
311
312   /* A response of EAGAIN from write() is likely only in the case of writing
313   to a FIFO that is not swallowing the data as fast as Exim is writing it. */
314
315   if (save_errno == EAGAIN)
316     {
317     DEBUG(D_transport)
318       debug_printf("write temporarily locked out, waiting 1 sec\n");
319     sleep(1);
320
321     /* Before continuing to try another write, check that we haven't run out of
322     time. */
323
324     CHECK_TIMEOUT:
325     if (transport_write_timeout > 0 && local_timeout <= 0)
326       {
327       errno = ETIMEDOUT;
328       return FALSE;
329       }
330     continue;
331     }
332
333   /* Otherwise there's been an error */
334
335   DEBUG(D_transport) debug_printf("writing error %d: %s\n", save_errno,
336     strerror(save_errno));
337   errno = save_errno;
338   return FALSE;
339   }
340
341 /* We've tried and tried and tried but still failed */
342
343 errno = ERRNO_WRITEINCOMPLETE;
344 return FALSE;
345 }
346
347
348 BOOL
349 transport_write_block(transport_ctx * tctx, uschar *block, int len, BOOL more)
350 {
351 if (!(tctx->options & topt_output_string))
352   return transport_write_block_fd(tctx, block, len, more);
353
354 /* Write to expanding-string.  NOTE: not NUL-terminated */
355
356 if (!tctx->u.msg)
357   tctx->u.msg = string_get(1024);
358
359 tctx->u.msg = string_catn(tctx->u.msg, block, len);
360 return TRUE;
361 }
362
363
364
365
366 /*************************************************
367 *             Write formatted string             *
368 *************************************************/
369
370 /* This is called by various transports. It is a convenience function.
371
372 Arguments:
373   fd          file descriptor
374   format      string format
375   ...         arguments for format
376
377 Returns:      the yield of transport_write_block()
378 */
379
380 BOOL
381 transport_write_string(int fd, const char *format, ...)
382 {
383 transport_ctx tctx = {{0}};
384 gstring gs = { .size = big_buffer_size, .ptr = 0, .s = big_buffer };
385 va_list ap;
386
387 /* Use taint-unchecked routines for writing into big_buffer, trusting
388 that the result will never be expanded. */
389
390 va_start(ap, format);
391 if (!string_vformat(&gs, SVFMT_TAINT_NOCHK, format, ap))
392   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "overlong formatted string in transport");
393 va_end(ap);
394 tctx.u.fd = fd;
395 return transport_write_block(&tctx, gs.s, gs.ptr, FALSE);
396 }
397
398
399
400
401 void
402 transport_write_reset(int options)
403 {
404 if (!(options & topt_continuation)) chunk_ptr = deliver_out_buffer;
405 nl_partial_match = -1;
406 nl_check_length = nl_escape_length = 0;
407 }
408
409
410
411 /*************************************************
412 *              Write character chunk             *
413 *************************************************/
414
415 /* Subroutine used by transport_write_message() to scan character chunks for
416 newlines and act appropriately. The object is to minimise the number of writes.
417 The output byte stream is buffered up in deliver_out_buffer, which is written
418 only when it gets full, thus minimizing write operations and TCP packets.
419
420 Static data is used to handle the case when the last character of the previous
421 chunk was NL, or matched part of the data that has to be escaped.
422
423 Arguments:
424   tctx       transport context - processing to be done during output,
425                 and file descriptor to write to
426   chunk      pointer to data to write
427   len        length of data to write
428
429 In addition, the static nl_xxx variables must be set as required.
430
431 Returns:     TRUE on success, FALSE on failure (with errno preserved)
432 */
433
434 BOOL
435 write_chunk(transport_ctx * tctx, uschar *chunk, int len)
436 {
437 uschar *start = chunk;
438 uschar *end = chunk + len;
439 int mlen = DELIVER_OUT_BUFFER_SIZE - nl_escape_length - 2;
440
441 /* The assumption is made that the check string will never stretch over move
442 than one chunk since the only time there are partial matches is when copying
443 the body in large buffers. There is always enough room in the buffer for an
444 escape string, since the loop below ensures this for each character it
445 processes, and it won't have stuck in the escape string if it left a partial
446 match. */
447
448 if (nl_partial_match >= 0)
449   {
450   if (nl_check_length > 0 && len >= nl_check_length &&
451       Ustrncmp(start, nl_check + nl_partial_match,
452         nl_check_length - nl_partial_match) == 0)
453     {
454     Ustrncpy(chunk_ptr, nl_escape, nl_escape_length);
455     chunk_ptr += nl_escape_length;
456     start += nl_check_length - nl_partial_match;
457     }
458
459   /* The partial match was a false one. Insert the characters carried over
460   from the previous chunk. */
461
462   else if (nl_partial_match > 0)
463     {
464     Ustrncpy(chunk_ptr, nl_check, nl_partial_match);
465     chunk_ptr += nl_partial_match;
466     }
467
468   nl_partial_match = -1;
469   }
470
471 /* Now process the characters in the chunk. Whenever we hit a newline we check
472 for possible escaping. The code for the non-NL route should be as fast as
473 possible. */
474
475 for (uschar * ptr = start; ptr < end; ptr++)
476   {
477   int ch, len;
478
479   /* Flush the buffer if it has reached the threshold - we want to leave enough
480   room for the next uschar, plus a possible extra CR for an LF, plus the escape
481   string. */
482
483   if ((len = chunk_ptr - deliver_out_buffer) > mlen)
484     {
485     DEBUG(D_transport) debug_printf("flushing headers buffer\n");
486
487     /* If CHUNKING, prefix with BDAT (size) NON-LAST.  Also, reap responses
488     from previous SMTP commands. */
489
490     if (tctx->options & topt_use_bdat  &&  tctx->chunk_cb)
491       {
492       if (  tctx->chunk_cb(tctx, (unsigned)len, 0) != OK
493          || !transport_write_block(tctx, deliver_out_buffer, len, FALSE)
494          || tctx->chunk_cb(tctx, 0, tc_reap_prev) != OK
495          )
496         return FALSE;
497       }
498     else
499       if (!transport_write_block(tctx, deliver_out_buffer, len, FALSE))
500         return FALSE;
501     chunk_ptr = deliver_out_buffer;
502     }
503
504   /* Remove CR before NL if required */
505
506   if (  *ptr == '\r' && ptr[1] == '\n'
507      && !(tctx->options & topt_use_crlf)
508      && f.spool_file_wireformat
509      )
510     ptr++;
511
512   if ((ch = *ptr) == '\n')
513     {
514     int left = end - ptr - 1;  /* count of chars left after NL */
515
516     /* Insert CR before NL if required */
517
518     if (tctx->options & topt_use_crlf && !f.spool_file_wireformat)
519       *chunk_ptr++ = '\r';
520     *chunk_ptr++ = '\n';
521     transport_newlines++;
522
523     /* The check_string test (formerly "from hack") replaces the specific
524     string at the start of a line with an escape string (e.g. "From " becomes
525     ">From " or "." becomes "..". It is a case-sensitive test. The length
526     check above ensures there is always enough room to insert this string. */
527
528     if (nl_check_length > 0)
529       {
530       if (left >= nl_check_length &&
531           Ustrncmp(ptr+1, nl_check, nl_check_length) == 0)
532         {
533         Ustrncpy(chunk_ptr, nl_escape, nl_escape_length);
534         chunk_ptr += nl_escape_length;
535         ptr += nl_check_length;
536         }
537
538       /* Handle the case when there isn't enough left to match the whole
539       check string, but there may be a partial match. We remember how many
540       characters matched, and finish processing this chunk. */
541
542       else if (left <= 0) nl_partial_match = 0;
543
544       else if (Ustrncmp(ptr+1, nl_check, left) == 0)
545         {
546         nl_partial_match = left;
547         ptr = end;
548         }
549       }
550     }
551
552   /* Not a NL character */
553
554   else *chunk_ptr++ = ch;
555   }
556
557 return TRUE;
558 }
559
560
561
562
563 /*************************************************
564 *        Generate address for RCPT TO            *
565 *************************************************/
566
567 /* This function puts together an address for RCPT to, using the caseful
568 version of the local part and the caseful version of the domain. If there is no
569 prefix or suffix, or if affixes are to be retained, we can just use the
570 original address. Otherwise, if there is a prefix but no suffix we can use a
571 pointer into the original address. If there is a suffix, however, we have to
572 build a new string.
573
574 Arguments:
575   addr              the address item
576   include_affixes   TRUE if affixes are to be included
577
578 Returns:            a string
579 */
580
581 uschar *
582 transport_rcpt_address(address_item *addr, BOOL include_affixes)
583 {
584 uschar *at;
585 int plen, slen;
586
587 if (include_affixes)
588   {
589   setflag(addr, af_include_affixes);  /* Affects logged => line */
590   return addr->address;
591   }
592
593 if (addr->suffix == NULL)
594   {
595   if (addr->prefix == NULL) return addr->address;
596   return addr->address + Ustrlen(addr->prefix);
597   }
598
599 at = Ustrrchr(addr->address, '@');
600 plen = (addr->prefix == NULL)? 0 : Ustrlen(addr->prefix);
601 slen = Ustrlen(addr->suffix);
602
603 return string_sprintf("%.*s@%s", (int)(at - addr->address - plen - slen),
604    addr->address + plen, at + 1);
605 }
606
607
608 /*************************************************
609 *  Output Envelope-To: address & scan duplicates *
610 *************************************************/
611
612 /* This function is called from internal_transport_write_message() below, when
613 generating an Envelope-To: header line. It checks for duplicates of the given
614 address and its ancestors. When one is found, this function calls itself
615 recursively, to output the envelope address of the duplicate.
616
617 We want to avoid duplication in the list, which can arise for example when
618 A->B,C and then both B and C alias to D. This can also happen when there are
619 unseen drivers in use. So a list of addresses that have been output is kept in
620 the plist variable.
621
622 It is also possible to have loops in the address ancestry/duplication graph,
623 for example if there are two top level addresses A and B and we have A->B,C and
624 B->A. To break the loop, we use a list of processed addresses in the dlist
625 variable.
626
627 After handling duplication, this function outputs the progenitor of the given
628 address.
629
630 Arguments:
631   p         the address we are interested in
632   pplist    address of anchor of the list of addresses not to output
633   pdlist    address of anchor of the list of processed addresses
634   first     TRUE if this is the first address; set it FALSE afterwards
635   tctx      transport context - processing to be done during output
636               and the file descriptor to write to
637
638 Returns:    FALSE if writing failed
639 */
640
641 static BOOL
642 write_env_to(address_item *p, struct aci **pplist, struct aci **pdlist,
643   BOOL *first, transport_ctx * tctx)
644 {
645 address_item *pp;
646 struct aci *ppp;
647
648 /* Do nothing if we have already handled this address. If not, remember it
649 so that we don't handle it again. */
650
651 for (ppp = *pdlist; ppp; ppp = ppp->next) if (p == ppp->ptr) return TRUE;
652
653 ppp = store_get(sizeof(struct aci), FALSE);
654 ppp->next = *pdlist;
655 *pdlist = ppp;
656 ppp->ptr = p;
657
658 /* Now scan up the ancestry, checking for duplicates at each generation. */
659
660 for (pp = p;; pp = pp->parent)
661   {
662   address_item *dup;
663   for (dup = addr_duplicate; dup; dup = dup->next)
664     if (dup->dupof == pp)   /* a dup of our address */
665       if (!write_env_to(dup, pplist, pdlist, first, tctx))
666         return FALSE;
667   if (!pp->parent) break;
668   }
669
670 /* Check to see if we have already output the progenitor. */
671
672 for (ppp = *pplist; ppp; ppp = ppp->next) if (pp == ppp->ptr) break;
673 if (ppp) return TRUE;
674
675 /* Remember what we have output, and output it. */
676
677 ppp = store_get(sizeof(struct aci), FALSE);
678 ppp->next = *pplist;
679 *pplist = ppp;
680 ppp->ptr = pp;
681
682 if (!*first && !write_chunk(tctx, US",\n ", 3)) return FALSE;
683 *first = FALSE;
684 return write_chunk(tctx, pp->address, Ustrlen(pp->address));
685 }
686
687
688
689
690 /* Add/remove/rewrite headers, and send them plus the empty-line separator.
691
692 Globals:
693   header_list
694
695 Arguments:
696   addr                  (chain of) addresses (for extra headers), or NULL;
697                           only the first address is used
698   tctx                  transport context
699   sendfn                function for output (transport or verify)
700
701 Returns:                TRUE on success; FALSE on failure.
702 */
703 BOOL
704 transport_headers_send(transport_ctx * tctx,
705   BOOL (*sendfn)(transport_ctx * tctx, uschar * s, int len))
706 {
707 const uschar *list;
708 transport_instance * tblock = tctx ? tctx->tblock : NULL;
709 address_item * addr = tctx ? tctx->addr : NULL;
710
711 /* Then the message's headers. Don't write any that are flagged as "old";
712 that means they were rewritten, or are a record of envelope rewriting, or
713 were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
714 match any entries therein.  It is a colon-sep list; expand the items
715 separately and squash any empty ones.
716 Then check addr->prop.remove_headers too, provided that addr is not NULL. */
717
718 for (header_line * h = header_list; h; h = h->next) if (h->type != htype_old)
719   {
720   BOOL include_header = TRUE;
721
722   list = tblock ? tblock->remove_headers : NULL;
723   for (int i = 0; i < 2; i++)    /* For remove_headers && addr->prop.remove_headers */
724     {
725     if (list)
726       {
727       int sep = ':';         /* This is specified as a colon-separated list */
728       uschar *s, *ss;
729       while ((s = string_nextinlist(&list, &sep, NULL, 0)))
730         {
731         int len;
732
733         if (i == 0)
734           if (!(s = expand_string(s)) && !f.expand_string_forcedfail)
735             {
736             errno = ERRNO_CHHEADER_FAIL;
737             return FALSE;
738             }
739         len = s ? Ustrlen(s) : 0;
740         if (strncmpic(h->text, s, len) != 0) continue;
741         ss = h->text + len;
742         while (*ss == ' ' || *ss == '\t') ss++;
743         if (*ss == ':') break;
744         }
745       if (s) { include_header = FALSE; break; }
746       }
747     if (addr) list = addr->prop.remove_headers;
748     }
749
750   /* If this header is to be output, try to rewrite it if there are rewriting
751   rules. */
752
753   if (include_header)
754     {
755     if (tblock && tblock->rewrite_rules)
756       {
757       rmark reset_point = store_mark();
758       header_line *hh;
759
760       if ((hh = rewrite_header(h, NULL, NULL, tblock->rewrite_rules,
761                   tblock->rewrite_existflags, FALSE)))
762         {
763         if (!sendfn(tctx, hh->text, hh->slen)) return FALSE;
764         store_reset(reset_point);
765         continue;     /* With the next header line */
766         }
767       }
768
769     /* Either no rewriting rules, or it didn't get rewritten */
770
771     if (!sendfn(tctx, h->text, h->slen)) return FALSE;
772     }
773
774   /* Header removed */
775
776   else
777     DEBUG(D_transport) debug_printf("removed header line:\n%s---\n", h->text);
778   }
779
780 /* Add on any address-specific headers. If there are multiple addresses,
781 they will all have the same headers in order to be batched. The headers
782 are chained in reverse order of adding (so several addresses from the
783 same alias might share some of them) but we want to output them in the
784 opposite order. This is a bit tedious, but there shouldn't be very many
785 of them. We just walk the list twice, reversing the pointers each time,
786 but on the second time, write out the items.
787
788 Headers added to an address by a router are guaranteed to end with a newline.
789 */
790
791 if (addr)
792   {
793   header_line *hprev = addr->prop.extra_headers;
794   header_line *hnext, * h;
795   for (int i = 0; i < 2; i++)
796     for (h = hprev, hprev = NULL; h; h = hnext)
797       {
798       hnext = h->next;
799       h->next = hprev;
800       hprev = h;
801       if (i == 1)
802         {
803         if (!sendfn(tctx, h->text, h->slen)) return FALSE;
804         DEBUG(D_transport)
805           debug_printf("added header line(s):\n%s---\n", h->text);
806         }
807       }
808   }
809
810 /* If a string containing additional headers exists it is a newline-sep
811 list.  Expand each item and write out the result.  This is done last so that
812 if it (deliberately or accidentally) isn't in header format, it won't mess
813 up any other headers. An empty string or a forced expansion failure are
814 noops. An added header string from a transport may not end with a newline;
815 add one if it does not. */
816
817 if (tblock && (list = CUS tblock->add_headers))
818   {
819   int sep = '\n';
820   uschar * s;
821
822   while ((s = string_nextinlist(&list, &sep, NULL, 0)))
823     if ((s = expand_string(s)))
824       {
825       int len = Ustrlen(s);
826       if (len > 0)
827         {
828         if (!sendfn(tctx, s, len)) return FALSE;
829         if (s[len-1] != '\n' && !sendfn(tctx, US"\n", 1))
830           return FALSE;
831         DEBUG(D_transport)
832           {
833           debug_printf("added header line:\n%s", s);
834           if (s[len-1] != '\n') debug_printf("\n");
835           debug_printf("---\n");
836           }
837         }
838       }
839     else if (!f.expand_string_forcedfail)
840       { errno = ERRNO_CHHEADER_FAIL; return FALSE; }
841   }
842
843 /* Separate headers from body with a blank line */
844
845 return sendfn(tctx, US"\n", 1);
846 }
847
848
849 /*************************************************
850 *                Write the message               *
851 *************************************************/
852
853 /* This function writes the message to the given file descriptor. The headers
854 are in the in-store data structure, and the rest of the message is in the open
855 file descriptor deliver_datafile. Make sure we start it at the beginning.
856
857 . If add_return_path is TRUE, a "return-path:" header is added to the message,
858   containing the envelope sender's address.
859
860 . If add_envelope_to is TRUE, a "envelope-to:" header is added to the message,
861   giving the top-level envelope address that caused this delivery to happen.
862
863 . If add_delivery_date is TRUE, a "delivery-date:" header is added to the
864   message. It gives the time and date that delivery took place.
865
866 . If check_string is not null, the start of each line is checked for that
867   string. If it is found, it is replaced by escape_string. This used to be
868   the "from hack" for files, and "smtp_dots" for escaping SMTP dots.
869
870 . If use_crlf is true, newlines are turned into CRLF (SMTP output).
871
872 The yield is TRUE if all went well, and FALSE if not. Exit *immediately* after
873 any writing or reading error, leaving the code in errno intact. Error exits
874 can include timeouts for certain transports, which are requested by setting
875 transport_write_timeout non-zero.
876
877 Arguments:
878   tctx
879     (fd, msg)           Either and fd, to write the message to,
880                         or a string: if null write message to allocated space
881                         otherwire take content as headers.
882     addr                (chain of) addresses (for extra headers), or NULL;
883                           only the first address is used
884     tblock              optional transport instance block (NULL signifies NULL/0):
885       add_headers           a string containing one or more headers to add; it is
886                             expanded, and must be in correct RFC 822 format as
887                             it is transmitted verbatim; NULL => no additions,
888                             and so does empty string or forced expansion fail
889       remove_headers        a colon-separated list of headers to remove, or NULL
890       rewrite_rules         chain of header rewriting rules
891       rewrite_existflags    flags for the rewriting rules
892     options               bit-wise options:
893       add_return_path       if TRUE, add a "return-path" header
894       add_envelope_to       if TRUE, add a "envelope-to" header
895       add_delivery_date     if TRUE, add a "delivery-date" header
896       use_crlf              if TRUE, turn NL into CR LF
897       end_dot               if TRUE, send a terminating "." line at the end
898       no_headers            if TRUE, omit the headers
899       no_body               if TRUE, omit the body
900     check_string          a string to check for at the start of lines, or NULL
901     escape_string         a string to insert in front of any check string
902   size_limit              if > 0, this is a limit to the size of message written;
903                             it is used when returning messages to their senders,
904                             and is approximate rather than exact, owing to chunk
905                             buffering
906
907 Returns:                TRUE on success; FALSE (with errno) on failure.
908                         In addition, the global variable transport_count
909                         is incremented by the number of bytes written.
910 */
911
912 static BOOL
913 internal_transport_write_message(transport_ctx * tctx, int size_limit)
914 {
915 int len, size = 0;
916
917 /* Initialize pointer in output buffer. */
918
919 transport_write_reset(tctx->options);
920
921 /* Set up the data for start-of-line data checking and escaping */
922
923 if (tctx->check_string && tctx->escape_string)
924   {
925   nl_check = tctx->check_string;
926   nl_check_length = Ustrlen(nl_check);
927   nl_escape = tctx->escape_string;
928   nl_escape_length = Ustrlen(nl_escape);
929   }
930
931 /* Whether the escaping mechanism is applied to headers or not is controlled by
932 an option (set for SMTP, not otherwise). Negate the length if not wanted till
933 after the headers. */
934
935 if (!(tctx->options & topt_escape_headers))
936   nl_check_length = -nl_check_length;
937
938 /* Write the headers if required, including any that have to be added. If there
939 are header rewriting rules, apply them.  The datasource is not the -D spoolfile
940 so temporarily hide the global that adjusts for its format. */
941
942 if (!(tctx->options & topt_no_headers))
943   {
944   BOOL save_wireformat = f.spool_file_wireformat;
945   f.spool_file_wireformat = FALSE;
946
947   /* Add return-path: if requested. */
948
949   if (tctx->options & topt_add_return_path)
950     {
951     uschar buffer[ADDRESS_MAXLENGTH + 20];
952     int n = sprintf(CS buffer, "Return-path: <%.*s>\n", ADDRESS_MAXLENGTH,
953       return_path);
954     if (!write_chunk(tctx, buffer, n)) goto bad;
955     }
956
957   /* Add envelope-to: if requested */
958
959   if (tctx->options & topt_add_envelope_to)
960     {
961     BOOL first = TRUE;
962     struct aci *plist = NULL;
963     struct aci *dlist = NULL;
964     rmark reset_point = store_mark();
965
966     if (!write_chunk(tctx, US"Envelope-to: ", 13)) goto bad;
967
968     /* Pick up from all the addresses. The plist and dlist variables are
969     anchors for lists of addresses already handled; they have to be defined at
970     this level because write_env_to() calls itself recursively. */
971
972     for (address_item * p = tctx->addr; p; p = p->next)
973       if (!write_env_to(p, &plist, &dlist, &first, tctx))
974         goto bad;
975
976     /* Add a final newline and reset the store used for tracking duplicates */
977
978     if (!write_chunk(tctx, US"\n", 1)) goto bad;
979     store_reset(reset_point);
980     }
981
982   /* Add delivery-date: if requested. */
983
984   if (tctx->options & topt_add_delivery_date)
985     {
986     uschar * s = tod_stamp(tod_full);
987
988     if (  !write_chunk(tctx, US"Delivery-date: ", 15)
989        || !write_chunk(tctx, s, Ustrlen(s))
990        || !write_chunk(tctx, US"\n", 1)) goto bad;
991     }
992
993   /* Then the message's headers. Don't write any that are flagged as "old";
994   that means they were rewritten, or are a record of envelope rewriting, or
995   were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
996   match any entries therein. Then check addr->prop.remove_headers too, provided that
997   addr is not NULL. */
998
999   if (!transport_headers_send(tctx, &write_chunk))
1000     {
1001 bad:
1002     f.spool_file_wireformat = save_wireformat;
1003     return FALSE;
1004     }
1005
1006   f.spool_file_wireformat = save_wireformat;
1007   }
1008
1009 /* When doing RFC3030 CHUNKING output, work out how much data would be in a
1010 last-BDAT, consisting of the current write_chunk() output buffer fill
1011 (optimally, all of the headers - but it does not matter if we already had to
1012 flush that buffer with non-last BDAT prependix) plus the amount of body data
1013 (as expanded for CRLF lines).  Then create and write BDAT(s), and ensure
1014 that further use of write_chunk() will not prepend BDATs.
1015 The first BDAT written will also first flush any outstanding MAIL and RCPT
1016 commands which were buffered thans to PIPELINING.
1017 Commands go out (using a send()) from a different buffer to data (using a
1018 write()).  They might not end up in the same TCP segment, which is
1019 suboptimal. */
1020
1021 if (tctx->options & topt_use_bdat)
1022   {
1023   off_t fsize;
1024   int hsize;
1025
1026   if ((hsize = chunk_ptr - deliver_out_buffer) < 0)
1027     hsize = 0;
1028   if (!(tctx->options & topt_no_body))
1029     {
1030     if ((fsize = lseek(deliver_datafile, 0, SEEK_END)) < 0) return FALSE;
1031     fsize -= SPOOL_DATA_START_OFFSET;
1032     if (size_limit > 0  &&  fsize > size_limit)
1033       fsize = size_limit;
1034     size = hsize + fsize;
1035     if (tctx->options & topt_use_crlf  &&  !f.spool_file_wireformat)
1036       size += body_linecount;   /* account for CRLF-expansion */
1037
1038     /* With topt_use_bdat we never do dot-stuffing; no need to
1039     account for any expansion due to that. */
1040     }
1041
1042   /* If the message is large, emit first a non-LAST chunk with just the
1043   headers, and reap the command responses.  This lets us error out early
1044   on RCPT rejects rather than sending megabytes of data.  Include headers
1045   on the assumption they are cheap enough and some clever implementations
1046   might errorcheck them too, on-the-fly, and reject that chunk. */
1047
1048   if (size > DELIVER_OUT_BUFFER_SIZE && hsize > 0)
1049     {
1050     DEBUG(D_transport)
1051       debug_printf("sending small initial BDAT; hsize=%d\n", hsize);
1052     if (  tctx->chunk_cb(tctx, hsize, 0) != OK
1053        || !transport_write_block(tctx, deliver_out_buffer, hsize, FALSE)
1054        || tctx->chunk_cb(tctx, 0, tc_reap_prev) != OK
1055        )
1056       return FALSE;
1057     chunk_ptr = deliver_out_buffer;
1058     size -= hsize;
1059     }
1060
1061   /* Emit a LAST datachunk command, and unmark the context for further
1062   BDAT commands. */
1063
1064   if (tctx->chunk_cb(tctx, size, tc_chunk_last) != OK)
1065     return FALSE;
1066   tctx->options &= ~topt_use_bdat;
1067   }
1068
1069 /* If the body is required, ensure that the data for check strings (formerly
1070 the "from hack") is enabled by negating the length if necessary. (It will be
1071 negative in cases where it isn't to apply to the headers). Then ensure the body
1072 is positioned at the start of its file (following the message id), then write
1073 it, applying the size limit if required. */
1074
1075 /* If we have a wireformat -D file (CRNL lines, non-dotstuffed, no ending dot)
1076 and we want to send a body without dotstuffing or ending-dot, in-clear,
1077 then we can just dump it using sendfile.
1078 This should get used for CHUNKING output and also for writing the -K file for
1079 dkim signing,  when we had CHUNKING input.  */
1080
1081 #ifdef OS_SENDFILE
1082 if (  f.spool_file_wireformat
1083    && !(tctx->options & (topt_no_body | topt_end_dot))
1084    && !nl_check_length
1085    && tls_out.active.sock != tctx->u.fd
1086    )
1087   {
1088   ssize_t copied = 0;
1089   off_t offset = SPOOL_DATA_START_OFFSET;
1090
1091   /* Write out any header data in the buffer */
1092
1093   if ((len = chunk_ptr - deliver_out_buffer) > 0)
1094     {
1095     if (!transport_write_block(tctx, deliver_out_buffer, len, TRUE))
1096       return FALSE;
1097     size -= len;
1098     }
1099
1100   DEBUG(D_transport) debug_printf("using sendfile for body\n");
1101
1102   while(size > 0)
1103     {
1104     if ((copied = os_sendfile(tctx->u.fd, deliver_datafile, &offset, size)) <= 0) break;
1105     size -= copied;
1106     }
1107   return copied >= 0;
1108   }
1109 #else
1110 DEBUG(D_transport) debug_printf("cannot use sendfile for body: no support\n");
1111 #endif
1112
1113 DEBUG(D_transport)
1114   if (!(tctx->options & topt_no_body))
1115     debug_printf("cannot use sendfile for body: %s\n",
1116       !f.spool_file_wireformat ? "spoolfile not wireformat"
1117       : tctx->options & topt_end_dot ? "terminating dot wanted"
1118       : nl_check_length ? "dot- or From-stuffing wanted"
1119       : "TLS output wanted");
1120
1121 if (!(tctx->options & topt_no_body))
1122   {
1123   unsigned long size = size_limit > 0 ? size_limit : ULONG_MAX;
1124
1125   nl_check_length = abs(nl_check_length);
1126   nl_partial_match = 0;
1127   if (lseek(deliver_datafile, SPOOL_DATA_START_OFFSET, SEEK_SET) < 0)
1128     return FALSE;
1129   while (  (len = MIN(DELIVER_IN_BUFFER_SIZE, size)) > 0
1130         && (len = read(deliver_datafile, deliver_in_buffer, len)) > 0)
1131     {
1132     if (!write_chunk(tctx, deliver_in_buffer, len))
1133       return FALSE;
1134     size -= len;
1135     }
1136
1137   /* A read error on the body will have left len == -1 and errno set. */
1138
1139   if (len != 0) return FALSE;
1140   }
1141
1142 /* Finished with the check string, and spool-format consideration */
1143
1144 nl_check_length = nl_escape_length = 0;
1145 f.spool_file_wireformat = FALSE;
1146
1147 /* If requested, add a terminating "." line (SMTP output). */
1148
1149 if (tctx->options & topt_end_dot && !write_chunk(tctx, US".\n", 2))
1150   return FALSE;
1151
1152 /* Write out any remaining data in the buffer before returning. */
1153
1154 return (len = chunk_ptr - deliver_out_buffer) <= 0 ||
1155   transport_write_block(tctx, deliver_out_buffer, len, FALSE);
1156 }
1157
1158
1159
1160
1161 /*************************************************
1162 *    External interface to write the message     *
1163 *************************************************/
1164
1165 /* If there is no filtering required, call the internal function above to do
1166 the real work, passing over all the arguments from this function. Otherwise,
1167 set up a filtering process, fork another process to call the internal function
1168 to write to the filter, and in this process just suck from the filter and write
1169 down the fd in the transport context. At the end, tidy up the pipes and the
1170 processes.
1171
1172 Arguments:     as for internal_transport_write_message() above
1173
1174 Returns:       TRUE on success; FALSE (with errno) for any failure
1175                transport_count is incremented by the number of bytes written
1176 */
1177
1178 BOOL
1179 transport_write_message(transport_ctx * tctx, int size_limit)
1180 {
1181 BOOL last_filter_was_NL = TRUE;
1182 BOOL save_spool_file_wireformat = f.spool_file_wireformat;
1183 int rc, len, yield, fd_read, fd_write, save_errno;
1184 int pfd[2] = {-1, -1};
1185 pid_t filter_pid, write_pid;
1186
1187 f.transport_filter_timed_out = FALSE;
1188
1189 /* If there is no filter command set up, call the internal function that does
1190 the actual work, passing it the incoming fd, and return its result. */
1191
1192 if (  !transport_filter_argv
1193    || !*transport_filter_argv
1194    || !**transport_filter_argv
1195    )
1196   return internal_transport_write_message(tctx, size_limit);
1197
1198 /* Otherwise the message must be written to a filter process and read back
1199 before being written to the incoming fd. First set up the special processing to
1200 be done during the copying. */
1201
1202 nl_partial_match = -1;
1203
1204 if (tctx->check_string && tctx->escape_string)
1205   {
1206   nl_check = tctx->check_string;
1207   nl_check_length = Ustrlen(nl_check);
1208   nl_escape = tctx->escape_string;
1209   nl_escape_length = Ustrlen(nl_escape);
1210   }
1211 else nl_check_length = nl_escape_length = 0;
1212
1213 /* Start up a subprocess to run the command. Ensure that our main fd will
1214 be closed when the subprocess execs, but remove the flag afterwards.
1215 (Otherwise, if this is a TCP/IP socket, it can't get passed on to another
1216 process to deliver another message.) We get back stdin/stdout file descriptors.
1217 If the process creation failed, give an error return. */
1218
1219 fd_read = -1;
1220 fd_write = -1;
1221 save_errno = 0;
1222 yield = FALSE;
1223 write_pid = (pid_t)(-1);
1224
1225   {
1226   int bits = fcntl(tctx->u.fd, F_GETFD);
1227   (void)fcntl(tctx->u.fd, F_SETFD, bits | FD_CLOEXEC);
1228   filter_pid = child_open(USS transport_filter_argv, NULL, 077,
1229    &fd_write, &fd_read, FALSE);
1230   (void)fcntl(tctx->u.fd, F_SETFD, bits & ~FD_CLOEXEC);
1231   }
1232 if (filter_pid < 0) goto TIDY_UP;      /* errno set */
1233
1234 DEBUG(D_transport)
1235   debug_printf("process %d running as transport filter: fd_write=%d fd_read=%d\n",
1236     (int)filter_pid, fd_write, fd_read);
1237
1238 /* Fork subprocess to write the message to the filter, and return the result
1239 via a(nother) pipe. While writing to the filter, we do not do the CRLF,
1240 smtp dots, or check string processing. */
1241
1242 if (pipe(pfd) != 0) goto TIDY_UP;      /* errno set */
1243 if ((write_pid = fork()) == 0)
1244   {
1245   BOOL rc;
1246   (void)close(fd_read);
1247   (void)close(pfd[pipe_read]);
1248   nl_check_length = nl_escape_length = 0;
1249
1250   tctx->u.fd = fd_write;
1251   tctx->check_string = tctx->escape_string = NULL;
1252   tctx->options &= ~(topt_use_crlf | topt_end_dot | topt_use_bdat);
1253
1254   rc = internal_transport_write_message(tctx, size_limit);
1255
1256   save_errno = errno;
1257   errno = 0;
1258   for (int retries = 10;;)
1259     {
1260     if (  os_pipe_write(pfd[pipe_write], (void *)&rc, sizeof(BOOL))
1261           != sizeof(BOOL)
1262        || os_pipe_write(pfd[pipe_write], (void *)&save_errno, sizeof(int))
1263           != sizeof(int)
1264        || os_pipe_write(pfd[pipe_write], (void *)&tctx->addr->more_errno, sizeof(int))
1265           != sizeof(int)
1266        || os_pipe_write(pfd[pipe_write], (void *)&tctx->addr->delivery_usec, sizeof(int))
1267           != sizeof(int)
1268        )
1269       if (errno == EINTR && --retries > 0)
1270         continue;
1271       else
1272         rc = FALSE;     /* compiler quietening */
1273     break;
1274     }
1275   exim_underbar_exit(0);
1276   }
1277 save_errno = errno;
1278
1279 /* Parent process: close our copy of the writing subprocess' pipes. */
1280
1281 (void)close(pfd[pipe_write]);
1282 (void)close(fd_write);
1283 fd_write = -1;
1284
1285 /* Writing process creation failed */
1286
1287 if (write_pid < 0)
1288   {
1289   errno = save_errno;    /* restore */
1290   goto TIDY_UP;
1291   }
1292
1293 /* When testing, let the subprocess get going */
1294
1295 testharness_pause_ms(250);
1296
1297 DEBUG(D_transport)
1298   debug_printf("process %d writing to transport filter\n", (int)write_pid);
1299
1300 /* Copy the message from the filter to the output fd. A read error leaves len
1301 == -1 and errno set. We need to apply a timeout to the read, to cope with
1302 the case when the filter gets stuck, but it can be quite a long one. The
1303 default is 5m, but this is now configurable. */
1304
1305 DEBUG(D_transport) debug_printf("copying from the filter\n");
1306
1307 /* Copy the output of the filter, remembering if the last character was NL. If
1308 no data is returned, that counts as "ended with NL" (default setting of the
1309 variable is TRUE).  The output should always be unix-format as we converted
1310 any wireformat source on writing input to the filter. */
1311
1312 f.spool_file_wireformat = FALSE;
1313 chunk_ptr = deliver_out_buffer;
1314
1315 for (;;)
1316   {
1317   sigalrm_seen = FALSE;
1318   ALARM(transport_filter_timeout);
1319   len = read(fd_read, deliver_in_buffer, DELIVER_IN_BUFFER_SIZE);
1320   ALARM_CLR(0);
1321   if (sigalrm_seen)
1322     {
1323     errno = ETIMEDOUT;
1324     f.transport_filter_timed_out = TRUE;
1325     goto TIDY_UP;
1326     }
1327
1328   /* If the read was successful, write the block down the original fd,
1329   remembering whether it ends in \n or not. */
1330
1331   if (len > 0)
1332     {
1333     if (!write_chunk(tctx, deliver_in_buffer, len)) goto TIDY_UP;
1334     last_filter_was_NL = (deliver_in_buffer[len-1] == '\n');
1335     }
1336
1337   /* Otherwise, break the loop. If we have hit EOF, set yield = TRUE. */
1338
1339   else
1340     {
1341     if (len == 0) yield = TRUE;
1342     break;
1343     }
1344   }
1345
1346 /* Tidying up code. If yield = FALSE there has been an error and errno is set
1347 to something. Ensure the pipes are all closed and the processes are removed. If
1348 there has been an error, kill the processes before waiting for them, just to be
1349 sure. Also apply a paranoia timeout. */
1350
1351 TIDY_UP:
1352 f.spool_file_wireformat = save_spool_file_wireformat;
1353 save_errno = errno;
1354
1355 (void)close(fd_read);
1356 if (fd_write > 0) (void)close(fd_write);
1357
1358 if (!yield)
1359   {
1360   if (filter_pid > 0) kill(filter_pid, SIGKILL);
1361   if (write_pid > 0)  kill(write_pid, SIGKILL);
1362   }
1363
1364 /* Wait for the filter process to complete. */
1365
1366 DEBUG(D_transport) debug_printf("waiting for filter process\n");
1367 if (filter_pid > 0 && (rc = child_close(filter_pid, 30)) != 0 && yield)
1368   {
1369   yield = FALSE;
1370   save_errno = ERRNO_FILTER_FAIL;
1371   tctx->addr->more_errno = rc;
1372   DEBUG(D_transport) debug_printf("filter process returned %d\n", rc);
1373   }
1374
1375 /* Wait for the writing process to complete. If it ends successfully,
1376 read the results from its pipe, provided we haven't already had a filter
1377 process failure. */
1378
1379 DEBUG(D_transport) debug_printf("waiting for writing process\n");
1380 if (write_pid > 0)
1381   {
1382   rc = child_close(write_pid, 30);
1383   if (yield)
1384     if (rc == 0)
1385       {
1386       BOOL ok;
1387       if (os_pipe_read(pfd[pipe_read], (void *)&ok, sizeof(BOOL)) != sizeof(BOOL))
1388         {
1389         DEBUG(D_transport)
1390           debug_printf("pipe read from writing process: %s\n", strerror(errno));
1391         save_errno = ERRNO_FILTER_FAIL;
1392         yield = FALSE;
1393         }
1394       else if (!ok)
1395         {
1396         int dummy = os_pipe_read(pfd[pipe_read], (void *)&save_errno, sizeof(int));
1397         dummy = os_pipe_read(pfd[pipe_read], (void *)&tctx->addr->more_errno, sizeof(int));
1398         dummy = os_pipe_read(pfd[pipe_read], (void *)&tctx->addr->delivery_usec, sizeof(int));
1399         dummy = dummy;          /* compiler quietening */
1400         yield = FALSE;
1401         }
1402       }
1403     else
1404       {
1405       yield = FALSE;
1406       save_errno = ERRNO_FILTER_FAIL;
1407       tctx->addr->more_errno = rc;
1408       DEBUG(D_transport) debug_printf("writing process returned %d\n", rc);
1409       }
1410   }
1411 (void)close(pfd[pipe_read]);
1412
1413 /* If there have been no problems we can now add the terminating "." if this is
1414 SMTP output, turning off escaping beforehand. If the last character from the
1415 filter was not NL, insert a NL to make the SMTP protocol work. */
1416
1417 if (yield)
1418   {
1419   nl_check_length = nl_escape_length = 0;
1420   f.spool_file_wireformat = FALSE;
1421   if (  tctx->options & topt_end_dot
1422      && ( last_filter_was_NL
1423         ? !write_chunk(tctx, US".\n", 2)
1424         : !write_chunk(tctx, US"\n.\n", 3)
1425      )  )
1426     yield = FALSE;
1427
1428   /* Write out any remaining data in the buffer. */
1429
1430   else
1431     yield = (len = chunk_ptr - deliver_out_buffer) <= 0
1432           || transport_write_block(tctx, deliver_out_buffer, len, FALSE);
1433   }
1434 else
1435   errno = save_errno;      /* From some earlier error */
1436
1437 DEBUG(D_transport)
1438   {
1439   debug_printf("end of filtering transport writing: yield=%d\n", yield);
1440   if (!yield)
1441     debug_printf("errno=%d more_errno=%d\n", errno, tctx->addr->more_errno);
1442   }
1443
1444 return yield;
1445 }
1446
1447
1448
1449
1450
1451 /*************************************************
1452 *            Update waiting database             *
1453 *************************************************/
1454
1455 /* This is called when an address is deferred by remote transports that are
1456 capable of sending more than one message over one connection. A database is
1457 maintained for each transport, keeping track of which messages are waiting for
1458 which hosts. The transport can then consult this when eventually a successful
1459 delivery happens, and if it finds that another message is waiting for the same
1460 host, it can fire up a new process to deal with it using the same connection.
1461
1462 The database records are keyed by host name. They can get full if there are
1463 lots of messages waiting, and so there is a continuation mechanism for them.
1464
1465 Each record contains a list of message ids, packed end to end without any
1466 zeros. Each one is MESSAGE_ID_LENGTH bytes long. The count field says how many
1467 in this record, and the sequence field says if there are any other records for
1468 this host. If the sequence field is 0, there are none. If it is 1, then another
1469 record with the name <hostname>:0 exists; if it is 2, then two other records
1470 with sequence numbers 0 and 1 exist, and so on.
1471
1472 Currently, an exhaustive search of all continuation records has to be done to
1473 determine whether to add a message id to a given record. This shouldn't be
1474 too bad except in extreme cases. I can't figure out a *simple* way of doing
1475 better.
1476
1477 Old records should eventually get swept up by the exim_tidydb utility.
1478
1479 Arguments:
1480   hostlist  list of hosts that this message could be sent to
1481   tpname    name of the transport
1482
1483 Returns:    nothing
1484 */
1485
1486 void
1487 transport_update_waiting(host_item *hostlist, uschar *tpname)
1488 {
1489 const uschar *prevname = US"";
1490 open_db dbblock;
1491 open_db *dbm_file;
1492
1493 DEBUG(D_transport) debug_printf("updating wait-%s database\n", tpname);
1494
1495 /* Open the database for this transport */
1496
1497 if (!(dbm_file = dbfn_open(string_sprintf("wait-%.200s", tpname),
1498                       O_RDWR, &dbblock, TRUE, TRUE)))
1499   return;
1500
1501 /* Scan the list of hosts for which this message is waiting, and ensure
1502 that the message id is in each host record. */
1503
1504 for (host_item * host = hostlist; host; host = host->next)
1505   {
1506   BOOL already = FALSE;
1507   dbdata_wait *host_record;
1508   int host_length;
1509   uschar buffer[256];
1510
1511   /* Skip if this is the same host as we just processed; otherwise remember
1512   the name for next time. */
1513
1514   if (Ustrcmp(prevname, host->name) == 0) continue;
1515   prevname = host->name;
1516
1517   /* Look up the host record; if there isn't one, make an empty one. */
1518
1519   if (!(host_record = dbfn_read(dbm_file, host->name)))
1520     {
1521     host_record = store_get(sizeof(dbdata_wait) + MESSAGE_ID_LENGTH, FALSE);
1522     host_record->count = host_record->sequence = 0;
1523     }
1524
1525   /* Compute the current length */
1526
1527   host_length = host_record->count * MESSAGE_ID_LENGTH;
1528
1529   /* Search the record to see if the current message is already in it. */
1530
1531   for (uschar * s = host_record->text; s < host_record->text + host_length;
1532        s += MESSAGE_ID_LENGTH)
1533     if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1534       { already = TRUE; break; }
1535
1536   /* If we haven't found this message in the main record, search any
1537   continuation records that exist. */
1538
1539   for (int i = host_record->sequence - 1; i >= 0 && !already; i--)
1540     {
1541     dbdata_wait *cont;
1542     sprintf(CS buffer, "%.200s:%d", host->name, i);
1543     if ((cont = dbfn_read(dbm_file, buffer)))
1544       {
1545       int clen = cont->count * MESSAGE_ID_LENGTH;
1546       for (uschar * s = cont->text; s < cont->text + clen; s += MESSAGE_ID_LENGTH)
1547         if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1548           { already = TRUE; break; }
1549       }
1550     }
1551
1552   /* If this message is already in a record, no need to update. */
1553
1554   if (already)
1555     {
1556     DEBUG(D_transport) debug_printf("already listed for %s\n", host->name);
1557     continue;
1558     }
1559
1560
1561   /* If this record is full, write it out with a new name constructed
1562   from the sequence number, increase the sequence number, and empty
1563   the record. */
1564
1565   if (host_record->count >= WAIT_NAME_MAX)
1566     {
1567     sprintf(CS buffer, "%.200s:%d", host->name, host_record->sequence);
1568     dbfn_write(dbm_file, buffer, host_record, sizeof(dbdata_wait) + host_length);
1569     host_record->sequence++;
1570     host_record->count = 0;
1571     host_length = 0;
1572     }
1573
1574   /* If this record is not full, increase the size of the record to
1575   allow for one new message id. */
1576
1577   else
1578     {
1579     dbdata_wait *newr =
1580       store_get(sizeof(dbdata_wait) + host_length + MESSAGE_ID_LENGTH, FALSE);
1581     memcpy(newr, host_record, sizeof(dbdata_wait) + host_length);
1582     host_record = newr;
1583     }
1584
1585   /* Now add the new name on the end */
1586
1587   memcpy(host_record->text + host_length, message_id, MESSAGE_ID_LENGTH);
1588   host_record->count++;
1589   host_length += MESSAGE_ID_LENGTH;
1590
1591   /* Update the database */
1592
1593   dbfn_write(dbm_file, host->name, host_record, sizeof(dbdata_wait) + host_length);
1594   DEBUG(D_transport) debug_printf("added to list for %s\n", host->name);
1595   }
1596
1597 /* All now done */
1598
1599 dbfn_close(dbm_file);
1600 }
1601
1602
1603
1604
1605 /*************************************************
1606 *         Test for waiting messages              *
1607 *************************************************/
1608
1609 /* This function is called by a remote transport which uses the previous
1610 function to remember which messages are waiting for which remote hosts. It's
1611 called after a successful delivery and its job is to check whether there is
1612 another message waiting for the same host. However, it doesn't do this if the
1613 current continue sequence is greater than the maximum supplied as an argument,
1614 or greater than the global connection_max_messages, which, if set, overrides.
1615
1616 Arguments:
1617   transport_name     name of the transport
1618   hostname           name of the host
1619   local_message_max  maximum number of messages down one connection
1620                        as set by the caller transport
1621   new_message_id     set to the message id of a waiting message
1622   more               set TRUE if there are yet more messages waiting
1623   oicf_func          function to call to validate if it is ok to send
1624                      to this message_id from the current instance.
1625   oicf_data          opaque data for oicf_func
1626
1627 Returns:             TRUE if new_message_id set; FALSE otherwise
1628 */
1629
1630 typedef struct msgq_s
1631 {
1632     uschar  message_id [MESSAGE_ID_LENGTH + 1];
1633     BOOL    bKeep;
1634 } msgq_t;
1635
1636 BOOL
1637 transport_check_waiting(const uschar *transport_name, const uschar *hostname,
1638   int local_message_max, uschar *new_message_id, BOOL *more, oicf oicf_func, void *oicf_data)
1639 {
1640 dbdata_wait *host_record;
1641 int host_length;
1642 open_db dbblock;
1643 open_db *dbm_file;
1644
1645 int         i;
1646 struct stat statbuf;
1647
1648 *more = FALSE;
1649
1650 DEBUG(D_transport)
1651   {
1652   debug_printf("transport_check_waiting entered\n");
1653   debug_printf("  sequence=%d local_max=%d global_max=%d\n",
1654     continue_sequence, local_message_max, connection_max_messages);
1655   }
1656
1657 /* Do nothing if we have hit the maximum number that can be send down one
1658 connection. */
1659
1660 if (connection_max_messages >= 0) local_message_max = connection_max_messages;
1661 if (local_message_max > 0 && continue_sequence >= local_message_max)
1662   {
1663   DEBUG(D_transport)
1664     debug_printf("max messages for one connection reached: returning\n");
1665   return FALSE;
1666   }
1667
1668 /* Open the waiting information database. */
1669
1670 if (!(dbm_file = dbfn_open(string_sprintf("wait-%.200s", transport_name),
1671                           O_RDWR, &dbblock, TRUE, TRUE)))
1672   return FALSE;
1673
1674 /* See if there is a record for this host; if not, there's nothing to do. */
1675
1676 if (!(host_record = dbfn_read(dbm_file, hostname)))
1677   {
1678   dbfn_close(dbm_file);
1679   DEBUG(D_transport) debug_printf("no messages waiting for %s\n", hostname);
1680   return FALSE;
1681   }
1682
1683 /* If the data in the record looks corrupt, just log something and
1684 don't try to use it. */
1685
1686 if (host_record->count > WAIT_NAME_MAX)
1687   {
1688   dbfn_close(dbm_file);
1689   log_write(0, LOG_MAIN|LOG_PANIC, "smtp-wait database entry for %s has bad "
1690     "count=%d (max=%d)", hostname, host_record->count, WAIT_NAME_MAX);
1691   return FALSE;
1692   }
1693
1694 /* Scan the message ids in the record from the end towards the beginning,
1695 until one is found for which a spool file actually exists. If the record gets
1696 emptied, delete it and continue with any continuation records that may exist.
1697 */
1698
1699 /* For Bug 1141, I refactored this major portion of the routine, it is risky
1700 but the 1 off will remain without it.  This code now allows me to SKIP over
1701 a message I do not want to send out on this run.  */
1702
1703 host_length = host_record->count * MESSAGE_ID_LENGTH;
1704
1705 while (1)
1706   {
1707   msgq_t      *msgq;
1708   int         msgq_count = 0;
1709   int         msgq_actual = 0;
1710   BOOL        bFound = FALSE;
1711   BOOL        bContinuation = FALSE;
1712
1713   /* create an array to read entire message queue into memory for processing  */
1714
1715   msgq = store_get(sizeof(msgq_t) * host_record->count, FALSE);
1716   msgq_count = host_record->count;
1717   msgq_actual = msgq_count;
1718
1719   for (i = 0; i < host_record->count; ++i)
1720     {
1721     msgq[i].bKeep = TRUE;
1722
1723     Ustrncpy_nt(msgq[i].message_id, host_record->text + (i * MESSAGE_ID_LENGTH), 
1724       MESSAGE_ID_LENGTH);
1725     msgq[i].message_id[MESSAGE_ID_LENGTH] = 0;
1726     }
1727
1728   /* first thing remove current message id if it exists */
1729
1730   for (i = 0; i < msgq_count; ++i)
1731     if (Ustrcmp(msgq[i].message_id, message_id) == 0)
1732       {
1733       msgq[i].bKeep = FALSE;
1734       break;
1735       }
1736
1737   /* now find the next acceptable message_id */
1738
1739   for (i = msgq_count - 1; i >= 0; --i) if (msgq[i].bKeep)
1740     {
1741     uschar subdir[2];
1742     uschar * mid = msgq[i].message_id;
1743
1744     set_subdir_str(subdir, mid, 0);
1745     if (Ustat(spool_fname(US"input", subdir, mid, US"-D"), &statbuf) != 0)
1746       msgq[i].bKeep = FALSE;
1747     else if (!oicf_func || oicf_func(mid, oicf_data))
1748       {
1749       Ustrcpy_nt(new_message_id, mid);
1750       msgq[i].bKeep = FALSE;
1751       bFound = TRUE;
1752       break;
1753       }
1754     }
1755
1756   /* re-count */
1757   for (msgq_actual = 0, i = 0; i < msgq_count; ++i)
1758     if (msgq[i].bKeep)
1759       msgq_actual++;
1760
1761   /* reassemble the host record, based on removed message ids, from in
1762   memory queue  */
1763
1764   if (msgq_actual <= 0)
1765     {
1766     host_length = 0;
1767     host_record->count = 0;
1768     }
1769   else
1770     {
1771     host_length = msgq_actual * MESSAGE_ID_LENGTH;
1772     host_record->count = msgq_actual;
1773
1774     if (msgq_actual < msgq_count)
1775       {
1776       int new_count;
1777       for (new_count = 0, i = 0; i < msgq_count; ++i)
1778         if (msgq[i].bKeep)
1779           Ustrncpy(&host_record->text[new_count++ * MESSAGE_ID_LENGTH],
1780             msgq[i].message_id, MESSAGE_ID_LENGTH);
1781
1782       host_record->text[new_count * MESSAGE_ID_LENGTH] = 0;
1783       }
1784     }
1785
1786   /* Check for a continuation record. */
1787
1788   while (host_length <= 0)
1789     {
1790     dbdata_wait * newr = NULL;
1791     uschar buffer[256];
1792
1793     /* Search for a continuation */
1794
1795     for (int i = host_record->sequence - 1; i >= 0 && !newr; i--)
1796       {
1797       sprintf(CS buffer, "%.200s:%d", hostname, i);
1798       newr = dbfn_read(dbm_file, buffer);
1799       }
1800
1801     /* If no continuation, delete the current and break the loop */
1802
1803     if (!newr)
1804       {
1805       dbfn_delete(dbm_file, hostname);
1806       break;
1807       }
1808
1809     /* Else replace the current with the continuation */
1810
1811     dbfn_delete(dbm_file, buffer);
1812     host_record = newr;
1813     host_length = host_record->count * MESSAGE_ID_LENGTH;
1814
1815     bContinuation = TRUE;
1816     }
1817
1818   if (bFound)           /* Usual exit from main loop */
1819     break;
1820
1821   /* If host_length <= 0 we have emptied a record and not found a good message,
1822   and there are no continuation records. Otherwise there is a continuation
1823   record to process. */
1824
1825   if (host_length <= 0)
1826     {
1827     dbfn_close(dbm_file);
1828     DEBUG(D_transport) debug_printf("waiting messages already delivered\n");
1829     return FALSE;
1830     }
1831
1832   /* we were not able to find an acceptable message, nor was there a
1833    * continuation record.  So bug out, outer logic will clean this up.
1834    */
1835
1836   if (!bContinuation)
1837     {
1838     Ustrcpy(new_message_id, message_id);
1839     dbfn_close(dbm_file);
1840     return FALSE;
1841     }
1842   }             /* we need to process a continuation record */
1843
1844 /* Control gets here when an existing message has been encountered; its
1845 id is in new_message_id, and host_length is the revised length of the
1846 host record. If it is zero, the record has been removed. Update the
1847 record if required, close the database, and return TRUE. */
1848
1849 if (host_length > 0)
1850   {
1851   host_record->count = host_length/MESSAGE_ID_LENGTH;
1852
1853   dbfn_write(dbm_file, hostname, host_record, (int)sizeof(dbdata_wait) + host_length);
1854   *more = TRUE;
1855   }
1856
1857 dbfn_close(dbm_file);
1858 return TRUE;
1859 }
1860
1861 /*************************************************
1862 *    Deliver waiting message down same socket    *
1863 *************************************************/
1864
1865 /* Just the regain-root-privilege exec portion */
1866 void
1867 transport_do_pass_socket(const uschar *transport_name, const uschar *hostname,
1868   const uschar *hostaddress, uschar *id, int socket_fd)
1869 {
1870 int i = 20;
1871 const uschar **argv;
1872
1873 /* Set up the calling arguments; use the standard function for the basics,
1874 but we have a number of extras that may be added. */
1875
1876 argv = CUSS child_exec_exim(CEE_RETURN_ARGV, TRUE, &i, FALSE, 0);
1877
1878 if (f.smtp_authenticated)                       argv[i++] = US"-MCA";
1879 if (smtp_peer_options & OPTION_CHUNKING)        argv[i++] = US"-MCK";
1880 if (smtp_peer_options & OPTION_DSN)             argv[i++] = US"-MCD";
1881 if (smtp_peer_options & OPTION_PIPE)            argv[i++] = US"-MCP";
1882 if (smtp_peer_options & OPTION_SIZE)            argv[i++] = US"-MCS";
1883 #ifndef DISABLE_TLS
1884 if (smtp_peer_options & OPTION_TLS)
1885   if (tls_out.active.sock >= 0 || continue_proxy_cipher)
1886     {
1887     argv[i++] = US"-MCt";
1888     argv[i++] = sending_ip_address;
1889     argv[i++] = string_sprintf("%d", sending_port);
1890     argv[i++] = tls_out.active.sock >= 0 ? tls_out.cipher : continue_proxy_cipher;
1891     }
1892   else
1893     argv[i++] = US"-MCT";
1894 #endif
1895
1896 if (queue_run_pid != (pid_t)0)
1897   {
1898   argv[i++] = US"-MCQ";
1899   argv[i++] = string_sprintf("%d", queue_run_pid);
1900   argv[i++] = string_sprintf("%d", queue_run_pipe);
1901   }
1902
1903 argv[i++] = US"-MC";
1904 argv[i++] = US transport_name;
1905 argv[i++] = US hostname;
1906 argv[i++] = US hostaddress;
1907 argv[i++] = string_sprintf("%d", continue_sequence + 1);
1908 argv[i++] = id;
1909 argv[i++] = NULL;
1910
1911 /* Arrange for the channel to be on stdin. */
1912
1913 if (socket_fd != 0)
1914   {
1915   (void)dup2(socket_fd, 0);
1916   (void)close(socket_fd);
1917   }
1918
1919 DEBUG(D_exec) debug_print_argv(argv);
1920 exim_nullstd();                          /* Ensure std{out,err} exist */
1921 execv(CS argv[0], (char *const *)argv);
1922
1923 DEBUG(D_any) debug_printf("execv failed: %s\n", strerror(errno));
1924 _exit(errno);         /* Note: must be _exit(), NOT exit() */
1925 }
1926
1927
1928
1929 /* Fork a new exim process to deliver the message, and do a re-exec, both to
1930 get a clean delivery process, and to regain root privilege in cases where it
1931 has been given away.
1932
1933 Arguments:
1934   transport_name  to pass to the new process
1935   hostname        ditto
1936   hostaddress     ditto
1937   id              the new message to process
1938   socket_fd       the connected socket
1939
1940 Returns:          FALSE if fork fails; TRUE otherwise
1941 */
1942
1943 BOOL
1944 transport_pass_socket(const uschar *transport_name, const uschar *hostname,
1945   const uschar *hostaddress, uschar *id, int socket_fd)
1946 {
1947 pid_t pid;
1948 int status;
1949
1950 DEBUG(D_transport) debug_printf("transport_pass_socket entered\n");
1951
1952 if ((pid = fork()) == 0)
1953   {
1954   /* Disconnect entirely from the parent process. If we are running in the
1955   test harness, wait for a bit to allow the previous process time to finish,
1956   write the log, etc., so that the output is always in the same order for
1957   automatic comparison. */
1958
1959   if ((pid = fork()) != 0)
1960     {
1961     DEBUG(D_transport) debug_printf("transport_pass_socket succeeded (final-pid %d)\n", pid);
1962     _exit(EXIT_SUCCESS);
1963     }
1964   testharness_pause_ms(1000);
1965
1966   transport_do_pass_socket(transport_name, hostname, hostaddress,
1967     id, socket_fd);
1968   }
1969
1970 /* If the process creation succeeded, wait for the first-level child, which
1971 immediately exits, leaving the second level process entirely disconnected from
1972 this one. */
1973
1974 if (pid > 0)
1975   {
1976   int rc;
1977   while ((rc = wait(&status)) != pid && (rc >= 0 || errno != ECHILD));
1978   DEBUG(D_transport) debug_printf("transport_pass_socket succeeded (inter-pid %d)\n", pid);
1979   return TRUE;
1980   }
1981 else
1982   {
1983   DEBUG(D_transport) debug_printf("transport_pass_socket failed to fork: %s\n",
1984     strerror(errno));
1985   return FALSE;
1986   }
1987 }
1988
1989
1990
1991 /*************************************************
1992 *          Set up direct (non-shell) command     *
1993 *************************************************/
1994
1995 /* This function is called when a command line is to be parsed and executed
1996 directly, without the use of /bin/sh. It is called by the pipe transport,
1997 the queryprogram router, and also from the main delivery code when setting up a
1998 transport filter process. The code for ETRN also makes use of this; in that
1999 case, no addresses are passed.
2000
2001 Arguments:
2002   argvptr            pointer to anchor for argv vector
2003   cmd                points to the command string (modified IN PLACE)
2004   expand_arguments   true if expansion is to occur
2005   expand_failed      error value to set if expansion fails; not relevant if
2006                      addr == NULL
2007   addr               chain of addresses, or NULL
2008   etext              text for use in error messages
2009   errptr             where to put error message if addr is NULL;
2010                      otherwise it is put in the first address
2011
2012 Returns:             TRUE if all went well; otherwise an error will be
2013                      set in the first address and FALSE returned
2014 */
2015
2016 BOOL
2017 transport_set_up_command(const uschar ***argvptr, uschar *cmd,
2018   BOOL expand_arguments, int expand_failed, address_item *addr,
2019   uschar *etext, uschar **errptr)
2020 {
2021 const uschar **argv;
2022 uschar *s, *ss;
2023 int address_count = 0;
2024 int argcount = 0;
2025 int max_args;
2026
2027 /* Get store in which to build an argument list. Count the number of addresses
2028 supplied, and allow for that many arguments, plus an additional 60, which
2029 should be enough for anybody. Multiple addresses happen only when the local
2030 delivery batch option is set. */
2031
2032 for (address_item * ad = addr; ad; ad = ad->next) address_count++;
2033 max_args = address_count + 60;
2034 *argvptr = argv = store_get((max_args+1)*sizeof(uschar *), FALSE);
2035
2036 /* Split the command up into arguments terminated by white space. Lose
2037 trailing space at the start and end. Double-quoted arguments can contain \\ and
2038 \" escapes and so can be handled by the standard function; single-quoted
2039 arguments are verbatim. Copy each argument into a new string. */
2040
2041 s = cmd;
2042 while (isspace(*s)) s++;
2043
2044 for (; *s != 0 && argcount < max_args; argcount++)
2045   {
2046   if (*s == '\'')
2047     {
2048     ss = s + 1;
2049     while (*ss != 0 && *ss != '\'') ss++;
2050     argv[argcount] = ss = store_get(ss - s++, is_tainted(cmd));
2051     while (*s != 0 && *s != '\'') *ss++ = *s++;
2052     if (*s != 0) s++;
2053     *ss++ = 0;
2054     }
2055   else
2056     argv[argcount] = string_dequote(CUSS &s);
2057   while (isspace(*s)) s++;
2058   }
2059
2060 argv[argcount] = US 0;
2061
2062 /* If *s != 0 we have run out of argument slots. */
2063
2064 if (*s != 0)
2065   {
2066   uschar *msg = string_sprintf("Too many arguments in command \"%s\" in "
2067     "%s", cmd, etext);
2068   if (addr != NULL)
2069     {
2070     addr->transport_return = FAIL;
2071     addr->message = msg;
2072     }
2073   else *errptr = msg;
2074   return FALSE;
2075   }
2076
2077 /* Expand each individual argument if required. Expansion happens for pipes set
2078 up in filter files and with directly-supplied commands. It does not happen if
2079 the pipe comes from a traditional .forward file. A failing expansion is a big
2080 disaster if the command came from Exim's configuration; if it came from a user
2081 it is just a normal failure. The expand_failed value is used as the error value
2082 to cater for these two cases.
2083
2084 An argument consisting just of the text "$pipe_addresses" is treated specially.
2085 It is not passed to the general expansion function. Instead, it is replaced by
2086 a number of arguments, one for each address. This avoids problems with shell
2087 metacharacters and spaces in addresses.
2088
2089 If the parent of the top address has an original part of "system-filter", this
2090 pipe was set up by the system filter, and we can permit the expansion of
2091 $recipients. */
2092
2093 DEBUG(D_transport)
2094   {
2095   debug_printf("direct command:\n");
2096   for (int i = 0; argv[i]; i++)
2097     debug_printf("  argv[%d] = '%s'\n", i, string_printing(argv[i]));
2098   }
2099
2100 if (expand_arguments)
2101   {
2102   BOOL allow_dollar_recipients = addr != NULL &&
2103     addr->parent != NULL &&
2104     Ustrcmp(addr->parent->address, "system-filter") == 0;
2105
2106   for (int i = 0; argv[i] != US 0; i++)
2107     {
2108
2109     /* Handle special fudge for passing an address list */
2110
2111     if (addr != NULL &&
2112         (Ustrcmp(argv[i], "$pipe_addresses") == 0 ||
2113          Ustrcmp(argv[i], "${pipe_addresses}") == 0))
2114       {
2115       int additional;
2116
2117       if (argcount + address_count - 1 > max_args)
2118         {
2119         addr->transport_return = FAIL;
2120         addr->message = string_sprintf("Too many arguments to command \"%s\" "
2121           "in %s", cmd, etext);
2122         return FALSE;
2123         }
2124
2125       additional = address_count - 1;
2126       if (additional > 0)
2127         memmove(argv + i + 1 + additional, argv + i + 1,
2128           (argcount - i)*sizeof(uschar *));
2129
2130       for (address_item * ad = addr; ad; ad = ad->next)
2131         {
2132         argv[i++] = ad->address;
2133         argcount++;
2134         }
2135
2136       /* Subtract one since we replace $pipe_addresses */
2137       argcount--;
2138       i--;
2139       }
2140
2141       /* Handle special case of $address_pipe when af_force_command is set */
2142
2143     else if (addr != NULL && testflag(addr,af_force_command) &&
2144         (Ustrcmp(argv[i], "$address_pipe") == 0 ||
2145          Ustrcmp(argv[i], "${address_pipe}") == 0))
2146       {
2147       int address_pipe_argcount = 0;
2148       int address_pipe_max_args;
2149       uschar **address_pipe_argv;
2150       BOOL tainted;
2151
2152       /* We can never have more then the argv we will be loading into */
2153       address_pipe_max_args = max_args - argcount + 1;
2154
2155       DEBUG(D_transport)
2156         debug_printf("address_pipe_max_args=%d\n", address_pipe_max_args);
2157
2158       /* We allocate an additional for (uschar *)0 */
2159       address_pipe_argv = store_get((address_pipe_max_args+1)*sizeof(uschar *), FALSE);
2160
2161       /* +1 because addr->local_part[0] == '|' since af_force_command is set */
2162       s = expand_string(addr->local_part + 1);
2163       tainted = is_tainted(s);
2164
2165       if (s == NULL || *s == '\0')
2166         {
2167         addr->transport_return = FAIL;
2168         addr->message = string_sprintf("Expansion of \"%s\" "
2169            "from command \"%s\" in %s failed: %s",
2170            (addr->local_part + 1), cmd, etext, expand_string_message);
2171         return FALSE;
2172         }
2173
2174       while (isspace(*s)) s++; /* strip leading space */
2175
2176       while (*s != 0 && address_pipe_argcount < address_pipe_max_args)
2177         {
2178         if (*s == '\'')
2179           {
2180           ss = s + 1;
2181           while (*ss != 0 && *ss != '\'') ss++;
2182           address_pipe_argv[address_pipe_argcount++] = ss = store_get(ss - s++, tainted);
2183           while (*s != 0 && *s != '\'') *ss++ = *s++;
2184           if (*s != 0) s++;
2185           *ss++ = 0;
2186           }
2187         else address_pipe_argv[address_pipe_argcount++] =
2188               string_copy(string_dequote(CUSS &s));
2189         while (isspace(*s)) s++; /* strip space after arg */
2190         }
2191
2192       address_pipe_argv[address_pipe_argcount] = US 0;
2193
2194       /* If *s != 0 we have run out of argument slots. */
2195       if (*s != 0)
2196         {
2197         uschar *msg = string_sprintf("Too many arguments in $address_pipe "
2198           "\"%s\" in %s", addr->local_part + 1, etext);
2199         if (addr != NULL)
2200           {
2201           addr->transport_return = FAIL;
2202           addr->message = msg;
2203           }
2204         else *errptr = msg;
2205         return FALSE;
2206         }
2207
2208       /* address_pipe_argcount - 1
2209        * because we are replacing $address_pipe in the argument list
2210        * with the first thing it expands to */
2211       if (argcount + address_pipe_argcount - 1 > max_args)
2212         {
2213         addr->transport_return = FAIL;
2214         addr->message = string_sprintf("Too many arguments to command "
2215           "\"%s\" after expanding $address_pipe in %s", cmd, etext);
2216         return FALSE;
2217         }
2218
2219       /* If we are not just able to replace the slot that contained
2220        * $address_pipe (address_pipe_argcount == 1)
2221        * We have to move the existing argv by address_pipe_argcount - 1
2222        * Visually if address_pipe_argcount == 2:
2223        * [argv 0][argv 1][argv 2($address_pipe)][argv 3][0]
2224        * [argv 0][argv 1][ap_arg0][ap_arg1][old argv 3][0]
2225        */
2226       if (address_pipe_argcount > 1)
2227         memmove(
2228           /* current position + additional args */
2229           argv + i + address_pipe_argcount,
2230           /* current position + 1 (for the (uschar *)0 at the end) */
2231           argv + i + 1,
2232           /* -1 for the (uschar *)0 at the end)*/
2233           (argcount - i)*sizeof(uschar *)
2234         );
2235
2236       /* Now we fill in the slots we just moved argv out of
2237        * [argv 0][argv 1][argv 2=pipeargv[0]][argv 3=pipeargv[1]][old argv 3][0]
2238        */
2239       for (int address_pipe_i = 0;
2240            address_pipe_argv[address_pipe_i] != US 0;
2241            address_pipe_i++)
2242         {
2243         argv[i++] = address_pipe_argv[address_pipe_i];
2244         argcount++;
2245         }
2246
2247       /* Subtract one since we replace $address_pipe */
2248       argcount--;
2249       i--;
2250       }
2251
2252     /* Handle normal expansion string */
2253
2254     else
2255       {
2256       const uschar *expanded_arg;
2257       f.enable_dollar_recipients = allow_dollar_recipients;
2258       expanded_arg = expand_cstring(argv[i]);
2259       f.enable_dollar_recipients = FALSE;
2260
2261       if (!expanded_arg)
2262         {
2263         uschar *msg = string_sprintf("Expansion of \"%s\" "
2264           "from command \"%s\" in %s failed: %s",
2265           argv[i], cmd, etext, expand_string_message);
2266         if (addr)
2267           {
2268           addr->transport_return = expand_failed;
2269           addr->message = msg;
2270           }
2271         else *errptr = msg;
2272         return FALSE;
2273         }
2274       argv[i] = expanded_arg;
2275       }
2276     }
2277
2278   DEBUG(D_transport)
2279     {
2280     debug_printf("direct command after expansion:\n");
2281     for (int i = 0; argv[i] != US 0; i++)
2282       debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2283     }
2284   }
2285
2286 return TRUE;
2287 }
2288
2289 #endif  /*!MACRO_PREDEF*/
2290 /* vi: aw ai sw=2
2291 */
2292 /* End of transport.c */