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