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