d222adce868e8d240e59cb742a4f1dead4f63d21
[users/jgh/exim.git] / src / src / transport.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2014 */
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 /* Add/remove/rewwrite headers, and send them plus the empty-line sparator.
604
605 Globals:
606   header_list
607
608 Arguments:
609   addr                  (chain of) addresses (for extra headers), or NULL;
610                           only the first address is used
611   fd                    file descriptor to write the message to
612   sendfn                function for output
613   use_crlf              turn NL into CR LF
614   rewrite_rules         chain of header rewriting rules
615   rewrite_existflags    flags for the rewriting rules
616
617 Returns:                TRUE on success; FALSE on failure.
618 */
619 BOOL
620 transport_headers_send(address_item *addr, int fd, uschar *add_headers, uschar *remove_headers,
621   BOOL (*sendfn)(int fd, uschar * s, int len, BOOL use_crlf),
622   BOOL use_crlf, rewrite_rule *rewrite_rules, int rewrite_existflags)
623 {
624 header_line *h;
625
626 /* Then the message's headers. Don't write any that are flagged as "old";
627 that means they were rewritten, or are a record of envelope rewriting, or
628 were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
629 match any entries therein.  It is a colon-sep list; expand the items
630 separately and squash any empty ones.
631 Then check addr->p.remove_headers too, provided that addr is not NULL. */
632
633 for (h = header_list; h != NULL; h = h->next) if (h->type != htype_old)
634   {
635   int i;
636   uschar *list = remove_headers;
637
638   BOOL include_header = TRUE;
639
640   for (i = 0; i < 2; i++)    /* For remove_headers && addr->p.remove_headers */
641     {
642     if (list)
643       {
644       int sep = ':';         /* This is specified as a colon-separated list */
645       uschar *s, *ss;
646       uschar buffer[128];
647       while ((s = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
648         {
649         int len;
650
651         if (i == 0)
652           if (!(s = expand_string(s)) && !expand_string_forcedfail)
653             {
654             errno = ERRNO_CHHEADER_FAIL;
655             return FALSE;
656             }
657         len = Ustrlen(s);
658         if (strncmpic(h->text, s, len) != 0) continue;
659         ss = h->text + len;
660         while (*ss == ' ' || *ss == '\t') ss++;
661         if (*ss == ':') break;
662         }
663       if (s != NULL) { include_header = FALSE; break; }
664       }
665     if (addr != NULL) list = addr->p.remove_headers;
666     }
667
668   /* If this header is to be output, try to rewrite it if there are rewriting
669   rules. */
670
671   if (include_header)
672     {
673     if (rewrite_rules)
674       {
675       void *reset_point = store_get(0);
676       header_line *hh;
677
678       if ((hh = rewrite_header(h, NULL, NULL, rewrite_rules, rewrite_existflags, FALSE)))
679         {
680         if (!sendfn(fd, hh->text, hh->slen, use_crlf)) return FALSE;
681         store_reset(reset_point);
682         continue;     /* With the next header line */
683         }
684       }
685
686     /* Either no rewriting rules, or it didn't get rewritten */
687
688     if (!sendfn(fd, h->text, h->slen, use_crlf)) return FALSE;
689     }
690
691   /* Header removed */
692
693   else
694     {
695     DEBUG(D_transport) debug_printf("removed header line:\n%s---\n", h->text);
696     }
697   }
698
699 /* Add on any address-specific headers. If there are multiple addresses,
700 they will all have the same headers in order to be batched. The headers
701 are chained in reverse order of adding (so several addresses from the
702 same alias might share some of them) but we want to output them in the
703 opposite order. This is a bit tedious, but there shouldn't be very many
704 of them. We just walk the list twice, reversing the pointers each time,
705 but on the second time, write out the items.
706
707 Headers added to an address by a router are guaranteed to end with a newline.
708 */
709
710 if (addr)
711   {
712   int i;
713   header_line *hprev = addr->p.extra_headers;
714   header_line *hnext;
715   for (i = 0; i < 2; i++)
716     {
717     for (h = hprev, hprev = NULL; h != NULL; h = hnext)
718       {
719       hnext = h->next;
720       h->next = hprev;
721       hprev = h;
722       if (i == 1)
723         {
724         if (!sendfn(fd, h->text, h->slen, use_crlf)) return FALSE;
725         DEBUG(D_transport)
726           debug_printf("added header line(s):\n%s---\n", h->text);
727         }
728       }
729     }
730   }
731
732 /* If a string containing additional headers exists it is a newline-sep
733 list.  Expand each item and write out the result.  This is done last so that
734 if it (deliberately or accidentally) isn't in header format, it won't mess
735 up any other headers. An empty string or a forced expansion failure are
736 noops. An added header string from a transport may not end with a newline;
737 add one if it does not. */
738
739 if (add_headers)
740   {
741   int sep = '\n';
742   uschar * s;
743
744   while ((s = string_nextinlist(&add_headers, &sep, NULL, 0)))
745     if (!(s = expand_string(s)))
746       {
747       if (!expand_string_forcedfail)
748         { errno = ERRNO_CHHEADER_FAIL; return FALSE; }
749       }
750     else
751       {
752       int len = Ustrlen(s);
753       if (len > 0)
754         {
755         if (!sendfn(fd, s, len, use_crlf)) return FALSE;
756         if (s[len-1] != '\n' && !sendfn(fd, US"\n", 1, use_crlf))
757           return FALSE;
758         DEBUG(D_transport)
759           {
760           debug_printf("added header line:\n%s", s);
761           if (s[len-1] != '\n') debug_printf("\n");
762           debug_printf("---\n");
763           }
764         }
765       }
766   }
767
768 /* Separate headers from body with a blank line */
769
770 return sendfn(fd, US"\n", 1, use_crlf);
771 }
772
773
774 /*************************************************
775 *                Write the message               *
776 *************************************************/
777
778 /* This function writes the message to the given file descriptor. The headers
779 are in the in-store data structure, and the rest of the message is in the open
780 file descriptor deliver_datafile. Make sure we start it at the beginning.
781
782 . If add_return_path is TRUE, a "return-path:" header is added to the message,
783   containing the envelope sender's address.
784
785 . If add_envelope_to is TRUE, a "envelope-to:" header is added to the message,
786   giving the top-level envelope address that caused this delivery to happen.
787
788 . If add_delivery_date is TRUE, a "delivery-date:" header is added to the
789   message. It gives the time and date that delivery took place.
790
791 . If check_string is not null, the start of each line is checked for that
792   string. If it is found, it is replaced by escape_string. This used to be
793   the "from hack" for files, and "smtp_dots" for escaping SMTP dots.
794
795 . If use_crlf is true, newlines are turned into CRLF (SMTP output).
796
797 The yield is TRUE if all went well, and FALSE if not. Exit *immediately* after
798 any writing or reading error, leaving the code in errno intact. Error exits
799 can include timeouts for certain transports, which are requested by setting
800 transport_write_timeout non-zero.
801
802 Arguments:
803   addr                  (chain of) addresses (for extra headers), or NULL;
804                           only the first address is used
805   fd                    file descriptor to write the message to
806   options               bit-wise options:
807     add_return_path       if TRUE, add a "return-path" header
808     add_envelope_to       if TRUE, add a "envelope-to" header
809     add_delivery_date     if TRUE, add a "delivery-date" header
810     use_crlf              if TRUE, turn NL into CR LF
811     end_dot               if TRUE, send a terminating "." line at the end
812     no_headers            if TRUE, omit the headers
813     no_body               if TRUE, omit the body
814   size_limit            if > 0, this is a limit to the size of message written;
815                           it is used when returning messages to their senders,
816                           and is approximate rather than exact, owing to chunk
817                           buffering
818   add_headers           a string containing one or more headers to add; it is
819                           expanded, and must be in correct RFC 822 format as
820                           it is transmitted verbatim; NULL => no additions,
821                           and so does empty string or forced expansion fail
822   remove_headers        a colon-separated list of headers to remove, or NULL
823   check_string          a string to check for at the start of lines, or NULL
824   escape_string         a string to insert in front of any check string
825   rewrite_rules         chain of header rewriting rules
826   rewrite_existflags    flags for the rewriting rules
827
828 Returns:                TRUE on success; FALSE (with errno) on failure.
829                         In addition, the global variable transport_count
830                         is incremented by the number of bytes written.
831 */
832
833 static BOOL
834 internal_transport_write_message(address_item *addr, int fd, int options,
835   int size_limit, uschar *add_headers, uschar *remove_headers, uschar *check_string,
836   uschar *escape_string, rewrite_rule *rewrite_rules, int rewrite_existflags)
837 {
838 int written = 0;
839 int len;
840 BOOL use_crlf  = (options & topt_use_crlf)  != 0;
841
842 /* Initialize pointer in output buffer. */
843
844 chunk_ptr = deliver_out_buffer;
845
846 /* Set up the data for start-of-line data checking and escaping */
847
848 nl_partial_match = -1;
849 if (check_string != NULL && escape_string != NULL)
850   {
851   nl_check = check_string;
852   nl_check_length = Ustrlen(nl_check);
853   nl_escape = escape_string;
854   nl_escape_length = Ustrlen(nl_escape);
855   }
856 else nl_check_length = nl_escape_length = 0;
857
858 /* Whether the escaping mechanism is applied to headers or not is controlled by
859 an option (set for SMTP, not otherwise). Negate the length if not wanted till
860 after the headers. */
861
862 if ((options & topt_escape_headers) == 0) nl_check_length = -nl_check_length;
863
864 /* Write the headers if required, including any that have to be added. If there
865 are header rewriting rules, apply them. */
866
867 if ((options & topt_no_headers) == 0)
868   {
869   /* Add return-path: if requested. */
870
871   if ((options & topt_add_return_path) != 0)
872     {
873     uschar buffer[ADDRESS_MAXLENGTH + 20];
874     sprintf(CS buffer, "Return-path: <%.*s>\n", ADDRESS_MAXLENGTH,
875       return_path);
876     if (!write_chunk(fd, buffer, Ustrlen(buffer), use_crlf)) return FALSE;
877     }
878
879   /* Add envelope-to: if requested */
880
881   if ((options & topt_add_envelope_to) != 0)
882     {
883     BOOL first = TRUE;
884     address_item *p;
885     struct aci *plist = NULL;
886     struct aci *dlist = NULL;
887     void *reset_point = store_get(0);
888
889     if (!write_chunk(fd, US"Envelope-to: ", 13, use_crlf)) return FALSE;
890
891     /* Pick up from all the addresses. The plist and dlist variables are
892     anchors for lists of addresses already handled; they have to be defined at
893     this level becuase write_env_to() calls itself recursively. */
894
895     for (p = addr; p != NULL; p = p->next)
896       {
897       if (!write_env_to(p, &plist, &dlist, &first, fd, use_crlf)) return FALSE;
898       }
899
900     /* Add a final newline and reset the store used for tracking duplicates */
901
902     if (!write_chunk(fd, US"\n", 1, use_crlf)) return FALSE;
903     store_reset(reset_point);
904     }
905
906   /* Add delivery-date: if requested. */
907
908   if ((options & topt_add_delivery_date) != 0)
909     {
910     uschar buffer[100];
911     sprintf(CS buffer, "Delivery-date: %s\n", tod_stamp(tod_full));
912     if (!write_chunk(fd, buffer, Ustrlen(buffer), use_crlf)) return FALSE;
913     }
914
915   /* Then the message's headers. Don't write any that are flagged as "old";
916   that means they were rewritten, or are a record of envelope rewriting, or
917   were removed (e.g. Bcc). If remove_headers is not null, skip any headers that
918   match any entries therein. Then check addr->p.remove_headers too, provided that
919   addr is not NULL. */
920   if (!transport_headers_send(addr, fd, add_headers, remove_headers, &write_chunk,
921         use_crlf, rewrite_rules, rewrite_existflags))
922     return FALSE;
923   }
924
925 /* If the body is required, ensure that the data for check strings (formerly
926 the "from hack") is enabled by negating the length if necessary. (It will be
927 negative in cases where it isn't to apply to the headers). Then ensure the body
928 is positioned at the start of its file (following the message id), then write
929 it, applying the size limit if required. */
930
931 if ((options & topt_no_body) == 0)
932   {
933   nl_check_length = abs(nl_check_length);
934   nl_partial_match = 0;
935   lseek(deliver_datafile, SPOOL_DATA_START_OFFSET, SEEK_SET);
936   while ((len = read(deliver_datafile, deliver_in_buffer,
937            DELIVER_IN_BUFFER_SIZE)) > 0)
938     {
939     if (!write_chunk(fd, deliver_in_buffer, len, use_crlf)) return FALSE;
940     if (size_limit > 0)
941       {
942       written += len;
943       if (written > size_limit)
944         {
945         len = 0;    /* Pretend EOF */
946         break;
947         }
948       }
949     }
950
951   /* A read error on the body will have left len == -1 and errno set. */
952
953   if (len != 0) return FALSE;
954   }
955
956 /* Finished with the check string */
957
958 nl_check_length = nl_escape_length = 0;
959
960 /* If requested, add a terminating "." line (SMTP output). */
961
962 if ((options & topt_end_dot) != 0 && !write_chunk(fd, US".\n", 2, use_crlf))
963   return FALSE;
964
965 /* Write out any remaining data in the buffer before returning. */
966
967 return (len = chunk_ptr - deliver_out_buffer) <= 0 ||
968   transport_write_block(fd, deliver_out_buffer, len);
969 }
970
971
972 #ifndef DISABLE_DKIM
973
974 /***************************************************************************************************
975 *    External interface to write the message, while signing it with DKIM and/or Domainkeys         *
976 ***************************************************************************************************/
977
978 /* This function is a wrapper around transport_write_message().
979    It is only called from the smtp transport if DKIM or Domainkeys support
980    is compiled in.  The function sets up a replacement fd into a -K file,
981    then calls the normal function. This way, the exact bits that exim would
982    have put "on the wire" will end up in the file (except for TLS
983    encapsulation, which is the very very last thing). When we are done
984    signing the file, send the signed message down the original fd (or TLS fd).
985
986 Arguments:
987   as for internal_transport_write_message() above, with additional arguments:
988    uschar *dkim_private_key  DKIM: The private key to use (filename or
989                                     plain data)
990    uschar *dkim_domain       DKIM: The domain to use
991    uschar *dkim_selector     DKIM: The selector to use.
992    uschar *dkim_canon        DKIM: The canonalization scheme to use,
993                                     "simple" or "relaxed"
994    uschar *dkim_strict       DKIM: What to do if signing fails:
995                                   1/true  => throw error
996                                   0/false => send anyway
997    uschar *dkim_sign_headers DKIM: List of headers that should be included
998                                     in signature generation
999
1000 Returns:       TRUE on success; FALSE (with errno) for any failure
1001 */
1002
1003 BOOL
1004 dkim_transport_write_message(address_item *addr, int fd, int options,
1005   int size_limit, uschar *add_headers, uschar *remove_headers,
1006   uschar *check_string, uschar *escape_string, rewrite_rule *rewrite_rules,
1007   int rewrite_existflags, uschar *dkim_private_key, uschar *dkim_domain,
1008   uschar *dkim_selector, uschar *dkim_canon, uschar *dkim_strict, uschar *dkim_sign_headers
1009   )
1010 {
1011 int dkim_fd;
1012 int save_errno = 0;
1013 BOOL rc;
1014 uschar dkim_spool_name[256];
1015 char sbuf[2048];
1016 int sread = 0;
1017 int wwritten = 0;
1018 uschar *dkim_signature = NULL;
1019 off_t size = 0;
1020
1021 /* If we can't sign, just call the original function. */
1022
1023 if (!(dkim_private_key && dkim_domain && dkim_selector))
1024   return transport_write_message(addr, fd, options,
1025             size_limit, add_headers, remove_headers,
1026             check_string, escape_string, rewrite_rules,
1027             rewrite_existflags);
1028
1029 (void)string_format(dkim_spool_name, 256, "%s/input/%s/%s-%d-K",
1030         spool_directory, message_subdir, message_id, (int)getpid());
1031
1032 if ((dkim_fd = Uopen(dkim_spool_name, O_RDWR|O_CREAT|O_TRUNC, SPOOL_MODE)) < 0)
1033   {
1034   /* Can't create spool file. Ugh. */
1035   rc = FALSE;
1036   save_errno = errno;
1037   goto CLEANUP;
1038   }
1039
1040 /* Call original function to write the -K file */
1041
1042 rc = transport_write_message(addr, dkim_fd, options,
1043   size_limit, add_headers, remove_headers,
1044   check_string, escape_string, rewrite_rules,
1045   rewrite_existflags);
1046
1047 /* Save error state. We must clean up before returning. */
1048 if (!rc)
1049   {
1050   save_errno = errno;
1051   goto CLEANUP;
1052   }
1053
1054 if (dkim_private_key && dkim_domain && dkim_selector)
1055   {
1056   /* Rewind file and feed it to the goats^W DKIM lib */
1057   lseek(dkim_fd, 0, SEEK_SET);
1058   dkim_signature = dkim_exim_sign(dkim_fd,
1059                                   dkim_private_key,
1060                                   dkim_domain,
1061                                   dkim_selector,
1062                                   dkim_canon,
1063                                   dkim_sign_headers);
1064   if (!dkim_signature)
1065     {
1066     if (dkim_strict)
1067       {
1068       uschar *dkim_strict_result = expand_string(dkim_strict);
1069       if (dkim_strict_result)
1070         if ( (strcmpic(dkim_strict,US"1") == 0) ||
1071              (strcmpic(dkim_strict,US"true") == 0) )
1072           {
1073           /* Set errno to something halfway meaningful */
1074           save_errno = EACCES;
1075           log_write(0, LOG_MAIN, "DKIM: message could not be signed,"
1076             " and dkim_strict is set. Deferring message delivery.");
1077           rc = FALSE;
1078           goto CLEANUP;
1079           }
1080       }
1081     }
1082   else
1083     {
1084     int siglen = Ustrlen(dkim_signature);
1085     while(siglen > 0)
1086       {
1087 #ifdef SUPPORT_TLS
1088       wwritten = tls_out.active == fd
1089         ? tls_write(FALSE, dkim_signature, siglen)
1090         : write(fd, dkim_signature, siglen);
1091 #else
1092       wwritten = write(fd, dkim_signature, siglen);
1093 #endif
1094       if (wwritten == -1)
1095         {
1096         /* error, bail out */
1097         save_errno = errno;
1098         rc = FALSE;
1099         goto CLEANUP;
1100         }
1101       siglen -= wwritten;
1102       dkim_signature += wwritten;
1103       }
1104     }
1105   }
1106
1107   /* Fetch file positition (the size) */
1108   size = lseek(dkim_fd,0,SEEK_CUR);
1109
1110 /* Rewind file */
1111 lseek(dkim_fd, 0, SEEK_SET);
1112
1113 #ifdef HAVE_LINUX_SENDFILE
1114 /* We can use sendfile() to shove the file contents
1115    to the socket. However only if we don't use TLS,
1116    as then there's another layer of indirection
1117    before the data finally hits the socket. */
1118 if (tls_out.active != fd)
1119   {
1120   ssize_t copied = 0;
1121   off_t offset = 0;
1122   while(copied >= 0 && offset < size)
1123     copied = sendfile(fd, dkim_fd, &offset, size - offset);
1124   if (copied < 0)
1125     {
1126     save_errno = errno;
1127     rc = FALSE;
1128     }
1129   goto CLEANUP;
1130   }
1131 #endif
1132
1133 /* Send file down the original fd */
1134 while((sread = read(dkim_fd, sbuf, 2048)) > 0)
1135   {
1136   char *p = sbuf;
1137   /* write the chunk */
1138
1139   while (sread)
1140     {
1141 #ifdef SUPPORT_TLS
1142     wwritten = tls_out.active == fd
1143       ? tls_write(FALSE, US p, sread)
1144       : write(fd, p, sread);
1145 #else
1146     wwritten = write(fd, p, sread);
1147 #endif
1148     if (wwritten == -1)
1149       {
1150       /* error, bail out */
1151       save_errno = errno;
1152       rc = FALSE;
1153       goto CLEANUP;
1154       }
1155     p += wwritten;
1156     sread -= wwritten;
1157     }
1158   }
1159
1160 if (sread == -1)
1161   {
1162   save_errno = errno;
1163   rc = FALSE;
1164   goto CLEANUP;
1165   }
1166
1167 CLEANUP:
1168 /* unlink -K file */
1169 (void)close(dkim_fd);
1170 Uunlink(dkim_spool_name);
1171 errno = save_errno;
1172 return rc;
1173 }
1174
1175 #endif
1176
1177
1178
1179 /*************************************************
1180 *    External interface to write the message     *
1181 *************************************************/
1182
1183 /* If there is no filtering required, call the internal function above to do
1184 the real work, passing over all the arguments from this function. Otherwise,
1185 set up a filtering process, fork another process to call the internal function
1186 to write to the filter, and in this process just suck from the filter and write
1187 down the given fd. At the end, tidy up the pipes and the processes.
1188
1189 Arguments:     as for internal_transport_write_message() above
1190
1191 Returns:       TRUE on success; FALSE (with errno) for any failure
1192                transport_count is incremented by the number of bytes written
1193 */
1194
1195 BOOL
1196 transport_write_message(address_item *addr, int fd, int options,
1197   int size_limit, uschar *add_headers, uschar *remove_headers,
1198   uschar *check_string, uschar *escape_string, rewrite_rule *rewrite_rules,
1199   int rewrite_existflags)
1200 {
1201 BOOL use_crlf;
1202 BOOL last_filter_was_NL = TRUE;
1203 int rc, len, yield, fd_read, fd_write, save_errno;
1204 int pfd[2];
1205 pid_t filter_pid, write_pid;
1206
1207 transport_filter_timed_out = FALSE;
1208
1209 /* If there is no filter command set up, call the internal function that does
1210 the actual work, passing it the incoming fd, and return its result. */
1211
1212 if (transport_filter_argv == NULL)
1213   return internal_transport_write_message(addr, fd, options, size_limit,
1214     add_headers, remove_headers, check_string, escape_string,
1215     rewrite_rules, rewrite_existflags);
1216
1217 /* Otherwise the message must be written to a filter process and read back
1218 before being written to the incoming fd. First set up the special processing to
1219 be done during the copying. */
1220
1221 use_crlf  = (options & topt_use_crlf) != 0;
1222 nl_partial_match = -1;
1223
1224 if (check_string != NULL && escape_string != NULL)
1225   {
1226   nl_check = check_string;
1227   nl_check_length = Ustrlen(nl_check);
1228   nl_escape = escape_string;
1229   nl_escape_length = Ustrlen(nl_escape);
1230   }
1231 else nl_check_length = nl_escape_length = 0;
1232
1233 /* Start up a subprocess to run the command. Ensure that our main fd will
1234 be closed when the subprocess execs, but remove the flag afterwards.
1235 (Otherwise, if this is a TCP/IP socket, it can't get passed on to another
1236 process to deliver another message.) We get back stdin/stdout file descriptors.
1237 If the process creation failed, give an error return. */
1238
1239 fd_read = -1;
1240 fd_write = -1;
1241 save_errno = 0;
1242 yield = FALSE;
1243 write_pid = (pid_t)(-1);
1244
1245 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
1246 filter_pid = child_open(transport_filter_argv, NULL, 077, &fd_write, &fd_read,
1247   FALSE);
1248 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) & ~FD_CLOEXEC);
1249 if (filter_pid < 0) goto TIDY_UP;      /* errno set */
1250
1251 DEBUG(D_transport)
1252   debug_printf("process %d running as transport filter: write=%d read=%d\n",
1253     (int)filter_pid, fd_write, fd_read);
1254
1255 /* Fork subprocess to write the message to the filter, and return the result
1256 via a(nother) pipe. While writing to the filter, we do not do the CRLF,
1257 smtp dots, or check string processing. */
1258
1259 if (pipe(pfd) != 0) goto TIDY_UP;      /* errno set */
1260 if ((write_pid = fork()) == 0)
1261   {
1262   BOOL rc;
1263   (void)close(fd_read);
1264   (void)close(pfd[pipe_read]);
1265   nl_check_length = nl_escape_length = 0;
1266   rc = internal_transport_write_message(addr, fd_write,
1267     (options & ~(topt_use_crlf | topt_end_dot)),
1268     size_limit, add_headers, remove_headers, NULL, NULL,
1269     rewrite_rules, rewrite_existflags);
1270   save_errno = errno;
1271   if (  write(pfd[pipe_write], (void *)&rc, sizeof(BOOL))
1272         != sizeof(BOOL)
1273      || write(pfd[pipe_write], (void *)&save_errno, sizeof(int))
1274         != sizeof(int)
1275      || write(pfd[pipe_write], (void *)&(addr->more_errno), sizeof(int))
1276         != sizeof(int)
1277      )
1278     rc = FALSE; /* compiler quietening */
1279   _exit(0);
1280   }
1281 save_errno = errno;
1282
1283 /* Parent process: close our copy of the writing subprocess' pipes. */
1284
1285 (void)close(pfd[pipe_write]);
1286 (void)close(fd_write);
1287 fd_write = -1;
1288
1289 /* Writing process creation failed */
1290
1291 if (write_pid < 0)
1292   {
1293   errno = save_errno;    /* restore */
1294   goto TIDY_UP;
1295   }
1296
1297 /* When testing, let the subprocess get going */
1298
1299 if (running_in_test_harness) millisleep(250);
1300
1301 DEBUG(D_transport)
1302   debug_printf("process %d writing to transport filter\n", (int)write_pid);
1303
1304 /* Copy the message from the filter to the output fd. A read error leaves len
1305 == -1 and errno set. We need to apply a timeout to the read, to cope with
1306 the case when the filter gets stuck, but it can be quite a long one. The
1307 default is 5m, but this is now configurable. */
1308
1309 DEBUG(D_transport) debug_printf("copying from the filter\n");
1310
1311 /* Copy the output of the filter, remembering if the last character was NL. If
1312 no data is returned, that counts as "ended with NL" (default setting of the
1313 variable is TRUE). */
1314
1315 chunk_ptr = deliver_out_buffer;
1316
1317 for (;;)
1318   {
1319   sigalrm_seen = FALSE;
1320   alarm(transport_filter_timeout);
1321   len = read(fd_read, deliver_in_buffer, DELIVER_IN_BUFFER_SIZE);
1322   alarm(0);
1323   if (sigalrm_seen)
1324     {
1325     errno = ETIMEDOUT;
1326     transport_filter_timed_out = TRUE;
1327     goto TIDY_UP;
1328     }
1329
1330   /* If the read was successful, write the block down the original fd,
1331   remembering whether it ends in \n or not. */
1332
1333   if (len > 0)
1334     {
1335     if (!write_chunk(fd, deliver_in_buffer, len, use_crlf)) goto TIDY_UP;
1336     last_filter_was_NL = (deliver_in_buffer[len-1] == '\n');
1337     }
1338
1339   /* Otherwise, break the loop. If we have hit EOF, set yield = TRUE. */
1340
1341   else
1342     {
1343     if (len == 0) yield = TRUE;
1344     break;
1345     }
1346   }
1347
1348 /* Tidying up code. If yield = FALSE there has been an error and errno is set
1349 to something. Ensure the pipes are all closed and the processes are removed. If
1350 there has been an error, kill the processes before waiting for them, just to be
1351 sure. Also apply a paranoia timeout. */
1352
1353 TIDY_UP:
1354 save_errno = errno;
1355
1356 (void)close(fd_read);
1357 if (fd_write > 0) (void)close(fd_write);
1358
1359 if (!yield)
1360   {
1361   if (filter_pid > 0) kill(filter_pid, SIGKILL);
1362   if (write_pid > 0)  kill(write_pid, SIGKILL);
1363   }
1364
1365 /* Wait for the filter process to complete. */
1366
1367 DEBUG(D_transport) debug_printf("waiting for filter process\n");
1368 if (filter_pid > 0 && (rc = child_close(filter_pid, 30)) != 0 && yield)
1369   {
1370   yield = FALSE;
1371   save_errno = ERRNO_FILTER_FAIL;
1372   addr->more_errno = rc;
1373   DEBUG(D_transport) debug_printf("filter process returned %d\n", rc);
1374   }
1375
1376 /* Wait for the writing process to complete. If it ends successfully,
1377 read the results from its pipe, provided we haven't already had a filter
1378 process failure. */
1379
1380 DEBUG(D_transport) debug_printf("waiting for writing process\n");
1381 if (write_pid > 0)
1382   {
1383   rc = child_close(write_pid, 30);
1384   if (yield)
1385     {
1386     if (rc == 0)
1387       {
1388       BOOL ok;
1389       int dummy = read(pfd[pipe_read], (void *)&ok, sizeof(BOOL));
1390       if (!ok)
1391         {
1392         dummy = read(pfd[pipe_read], (void *)&save_errno, sizeof(int));
1393         dummy = read(pfd[pipe_read], (void *)&(addr->more_errno), sizeof(int));
1394         yield = FALSE;
1395         }
1396       }
1397     else
1398       {
1399       yield = FALSE;
1400       save_errno = ERRNO_FILTER_FAIL;
1401       addr->more_errno = rc;
1402       DEBUG(D_transport) debug_printf("writing process returned %d\n", rc);
1403       }
1404     }
1405   }
1406 (void)close(pfd[pipe_read]);
1407
1408 /* If there have been no problems we can now add the terminating "." if this is
1409 SMTP output, turning off escaping beforehand. If the last character from the
1410 filter was not NL, insert a NL to make the SMTP protocol work. */
1411
1412 if (yield)
1413   {
1414   nl_check_length = nl_escape_length = 0;
1415   if ((options & topt_end_dot) != 0 && (last_filter_was_NL?
1416         !write_chunk(fd, US".\n", 2, use_crlf) :
1417         !write_chunk(fd, US"\n.\n", 3, use_crlf)))
1418     {
1419     yield = FALSE;
1420     }
1421
1422   /* Write out any remaining data in the buffer. */
1423
1424   else
1425     {
1426     yield = (len = chunk_ptr - deliver_out_buffer) <= 0 ||
1427       transport_write_block(fd, deliver_out_buffer, len);
1428     }
1429   }
1430 else errno = save_errno;      /* From some earlier error */
1431
1432 DEBUG(D_transport)
1433   {
1434   debug_printf("end of filtering transport writing: yield=%d\n", yield);
1435   if (!yield)
1436     debug_printf("errno=%d more_errno=%d\n", errno, addr->more_errno);
1437   }
1438
1439 return yield;
1440 }
1441
1442
1443
1444
1445
1446 /*************************************************
1447 *            Update waiting database             *
1448 *************************************************/
1449
1450 /* This is called when an address is deferred by remote transports that are
1451 capable of sending more than one message over one connection. A database is
1452 maintained for each transport, keeping track of which messages are waiting for
1453 which hosts. The transport can then consult this when eventually a successful
1454 delivery happens, and if it finds that another message is waiting for the same
1455 host, it can fire up a new process to deal with it using the same connection.
1456
1457 The database records are keyed by host name. They can get full if there are
1458 lots of messages waiting, and so there is a continuation mechanism for them.
1459
1460 Each record contains a list of message ids, packed end to end without any
1461 zeros. Each one is MESSAGE_ID_LENGTH bytes long. The count field says how many
1462 in this record, and the sequence field says if there are any other records for
1463 this host. If the sequence field is 0, there are none. If it is 1, then another
1464 record with the name <hostname>:0 exists; if it is 2, then two other records
1465 with sequence numbers 0 and 1 exist, and so on.
1466
1467 Currently, an exhaustive search of all continuation records has to be done to
1468 determine whether to add a message id to a given record. This shouldn't be
1469 too bad except in extreme cases. I can't figure out a *simple* way of doing
1470 better.
1471
1472 Old records should eventually get swept up by the exim_tidydb utility.
1473
1474 Arguments:
1475   hostlist  list of hosts that this message could be sent to
1476   tpname    name of the transport
1477
1478 Returns:    nothing
1479 */
1480
1481 void
1482 transport_update_waiting(host_item *hostlist, uschar *tpname)
1483 {
1484 uschar buffer[256];
1485 uschar *prevname = US"";
1486 host_item *host;
1487 open_db dbblock;
1488 open_db *dbm_file;
1489
1490 DEBUG(D_transport) debug_printf("updating wait-%s database\n", tpname);
1491
1492 /* Open the database for this transport */
1493
1494 sprintf(CS buffer, "wait-%.200s", tpname);
1495 dbm_file = dbfn_open(buffer, O_RDWR, &dbblock, TRUE);
1496 if (dbm_file == NULL) return;
1497
1498 /* Scan the list of hosts for which this message is waiting, and ensure
1499 that the message id is in each host record. */
1500
1501 for (host = hostlist; host!= NULL; host = host->next)
1502   {
1503   BOOL already = FALSE;
1504   dbdata_wait *host_record;
1505   uschar *s;
1506   int i, host_length;
1507
1508   /* Skip if this is the same host as we just processed; otherwise remember
1509   the name for next time. */
1510
1511   if (Ustrcmp(prevname, host->name) == 0) continue;
1512   prevname = host->name;
1513
1514   /* Look up the host record; if there isn't one, make an empty one. */
1515
1516   host_record = dbfn_read(dbm_file, host->name);
1517   if (host_record == NULL)
1518     {
1519     host_record = store_get(sizeof(dbdata_wait) + MESSAGE_ID_LENGTH);
1520     host_record->count = host_record->sequence = 0;
1521     }
1522
1523   /* Compute the current length */
1524
1525   host_length = host_record->count * MESSAGE_ID_LENGTH;
1526
1527   /* Search the record to see if the current message is already in it. */
1528
1529   for (s = host_record->text; s < host_record->text + host_length;
1530        s += MESSAGE_ID_LENGTH)
1531     {
1532     if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1533       { already = TRUE; break; }
1534     }
1535
1536   /* If we haven't found this message in the main record, search any
1537   continuation records that exist. */
1538
1539   for (i = host_record->sequence - 1; i >= 0 && !already; i--)
1540     {
1541     dbdata_wait *cont;
1542     sprintf(CS buffer, "%.200s:%d", host->name, i);
1543     cont = dbfn_read(dbm_file, buffer);
1544     if (cont != NULL)
1545       {
1546       int clen = cont->count * MESSAGE_ID_LENGTH;
1547       for (s = cont->text; s < cont->text + clen; s += MESSAGE_ID_LENGTH)
1548         {
1549         if (Ustrncmp(s, message_id, MESSAGE_ID_LENGTH) == 0)
1550           { already = TRUE; break; }
1551         }
1552       }
1553     }
1554
1555   /* If this message is already in a record, no need to update. */
1556
1557   if (already)
1558     {
1559     DEBUG(D_transport) debug_printf("already listed for %s\n", host->name);
1560     continue;
1561     }
1562
1563
1564   /* If this record is full, write it out with a new name constructed
1565   from the sequence number, increase the sequence number, and empty
1566   the record. */
1567
1568   if (host_record->count >= WAIT_NAME_MAX)
1569     {
1570     sprintf(CS buffer, "%.200s:%d", host->name, host_record->sequence);
1571     dbfn_write(dbm_file, buffer, host_record, sizeof(dbdata_wait) + host_length);
1572     host_record->sequence++;
1573     host_record->count = 0;
1574     host_length = 0;
1575     }
1576
1577   /* If this record is not full, increase the size of the record to
1578   allow for one new message id. */
1579
1580   else
1581     {
1582     dbdata_wait *newr =
1583       store_get(sizeof(dbdata_wait) + host_length + MESSAGE_ID_LENGTH);
1584     memcpy(newr, host_record, sizeof(dbdata_wait) + host_length);
1585     host_record = newr;
1586     }
1587
1588   /* Now add the new name on the end */
1589
1590   memcpy(host_record->text + host_length, message_id, MESSAGE_ID_LENGTH);
1591   host_record->count++;
1592   host_length += MESSAGE_ID_LENGTH;
1593
1594   /* Update the database */
1595
1596   dbfn_write(dbm_file, host->name, host_record, sizeof(dbdata_wait) + host_length);
1597   DEBUG(D_transport) debug_printf("added to list for %s\n", host->name);
1598   }
1599
1600 /* All now done */
1601
1602 dbfn_close(dbm_file);
1603 }
1604
1605
1606
1607
1608 /*************************************************
1609 *         Test for waiting messages              *
1610 *************************************************/
1611
1612 /* This function is called by a remote transport which uses the previous
1613 function to remember which messages are waiting for which remote hosts. It's
1614 called after a successful delivery and its job is to check whether there is
1615 another message waiting for the same host. However, it doesn't do this if the
1616 current continue sequence is greater than the maximum supplied as an argument,
1617 or greater than the global connection_max_messages, which, if set, overrides.
1618
1619 Arguments:
1620   transport_name     name of the transport
1621   hostname           name of the host
1622   local_message_max  maximum number of messages down one connection
1623                        as set by the caller transport
1624   new_message_id     set to the message id of a waiting message
1625   more               set TRUE if there are yet more messages waiting
1626
1627 Returns:             TRUE if new_message_id set; FALSE otherwise
1628 */
1629
1630 BOOL
1631 transport_check_waiting(uschar *transport_name, uschar *hostname,
1632   int local_message_max, uschar *new_message_id, BOOL *more)
1633 {
1634 dbdata_wait *host_record;
1635 int host_length, path_len;
1636 open_db dbblock;
1637 open_db *dbm_file;
1638 uschar buffer[256];
1639
1640 *more = FALSE;
1641
1642 DEBUG(D_transport)
1643   {
1644   debug_printf("transport_check_waiting entered\n");
1645   debug_printf("  sequence=%d local_max=%d global_max=%d\n",
1646     continue_sequence, local_message_max, connection_max_messages);
1647   }
1648
1649 /* Do nothing if we have hit the maximum number that can be send down one
1650 connection. */
1651
1652 if (connection_max_messages >= 0) local_message_max = connection_max_messages;
1653 if (local_message_max > 0 && continue_sequence >= local_message_max)
1654   {
1655   DEBUG(D_transport)
1656     debug_printf("max messages for one connection reached: returning\n");
1657   return FALSE;
1658   }
1659
1660 /* Open the waiting information database. */
1661
1662 sprintf(CS buffer, "wait-%.200s", transport_name);
1663 dbm_file = dbfn_open(buffer, O_RDWR, &dbblock, TRUE);
1664 if (dbm_file == NULL) return FALSE;
1665
1666 /* See if there is a record for this host; if not, there's nothing to do. */
1667
1668 host_record = dbfn_read(dbm_file, hostname);
1669 if (host_record == NULL)
1670   {
1671   dbfn_close(dbm_file);
1672   DEBUG(D_transport) debug_printf("no messages waiting for %s\n", hostname);
1673   return FALSE;
1674   }
1675
1676 /* If the data in the record looks corrupt, just log something and
1677 don't try to use it. */
1678
1679 if (host_record->count > WAIT_NAME_MAX)
1680   {
1681   dbfn_close(dbm_file);
1682   log_write(0, LOG_MAIN|LOG_PANIC, "smtp-wait database entry for %s has bad "
1683     "count=%d (max=%d)", hostname, host_record->count, WAIT_NAME_MAX);
1684   return FALSE;
1685   }
1686
1687 /* Scan the message ids in the record from the end towards the beginning,
1688 until one is found for which a spool file actually exists. If the record gets
1689 emptied, delete it and continue with any continuation records that may exist.
1690 */
1691
1692 host_length = host_record->count * MESSAGE_ID_LENGTH;
1693
1694 /* Loop to handle continuation host records in the database */
1695
1696 for (;;)
1697   {
1698   BOOL found = FALSE;
1699
1700   sprintf(CS buffer, "%s/input/", spool_directory);
1701   path_len = Ustrlen(buffer);
1702
1703   for (host_length -= MESSAGE_ID_LENGTH; host_length >= 0;
1704        host_length -= MESSAGE_ID_LENGTH)
1705     {
1706     struct stat statbuf;
1707     Ustrncpy(new_message_id, host_record->text + host_length,
1708       MESSAGE_ID_LENGTH);
1709     new_message_id[MESSAGE_ID_LENGTH] = 0;
1710
1711     if (split_spool_directory)
1712       sprintf(CS(buffer + path_len), "%c/%s-D", new_message_id[5], new_message_id);
1713     else
1714       sprintf(CS(buffer + path_len), "%s-D", new_message_id);
1715
1716     /* The listed message may be the one we are currently processing. If
1717     so, we want to remove it from the list without doing anything else.
1718     If not, do a stat to see if it is an existing message. If it is, break
1719     the loop to handle it. No need to bother about locks; as this is all
1720     "hint" processing, it won't matter if it doesn't exist by the time exim
1721     actually tries to deliver it. */
1722
1723     if (Ustrcmp(new_message_id, message_id) != 0 &&
1724         Ustat(buffer, &statbuf) == 0)
1725       {
1726       found = TRUE;
1727       break;
1728       }
1729     }
1730
1731   /* If we have removed all the message ids from the record delete the record.
1732   If there is a continuation record, fetch it and remove it from the file,
1733   as it will be rewritten as the main record. Repeat in the case of an
1734   empty continuation. */
1735
1736   while (host_length <= 0)
1737     {
1738     int i;
1739     dbdata_wait *newr = NULL;
1740
1741     /* Search for a continuation */
1742
1743     for (i = host_record->sequence - 1; i >= 0 && newr == NULL; i--)
1744       {
1745       sprintf(CS buffer, "%.200s:%d", hostname, i);
1746       newr = dbfn_read(dbm_file, buffer);
1747       }
1748
1749     /* If no continuation, delete the current and break the loop */
1750
1751     if (newr == NULL)
1752       {
1753       dbfn_delete(dbm_file, hostname);
1754       break;
1755       }
1756
1757     /* Else replace the current with the continuation */
1758
1759     dbfn_delete(dbm_file, buffer);
1760     host_record = newr;
1761     host_length = host_record->count * MESSAGE_ID_LENGTH;
1762     }
1763
1764   /* If we found an existing message, break the continuation loop. */
1765
1766   if (found) break;
1767
1768   /* If host_length <= 0 we have emptied a record and not found a good message,
1769   and there are no continuation records. Otherwise there is a continuation
1770   record to process. */
1771
1772   if (host_length <= 0)
1773     {
1774     dbfn_close(dbm_file);
1775     DEBUG(D_transport) debug_printf("waiting messages already delivered\n");
1776     return FALSE;
1777     }
1778   }
1779
1780 /* Control gets here when an existing message has been encountered; its
1781 id is in new_message_id, and host_length is the revised length of the
1782 host record. If it is zero, the record has been removed. Update the
1783 record if required, close the database, and return TRUE. */
1784
1785 if (host_length > 0)
1786   {
1787   host_record->count = host_length/MESSAGE_ID_LENGTH;
1788   dbfn_write(dbm_file, hostname, host_record, (int)sizeof(dbdata_wait) + host_length);
1789   *more = TRUE;
1790   }
1791
1792 dbfn_close(dbm_file);
1793 return TRUE;
1794 }
1795
1796
1797
1798 /*************************************************
1799 *    Deliver waiting message down same socket    *
1800 *************************************************/
1801
1802 /* Fork a new exim process to deliver the message, and do a re-exec, both to
1803 get a clean delivery process, and to regain root privilege in cases where it
1804 has been given away.
1805
1806 Arguments:
1807   transport_name  to pass to the new process
1808   hostname        ditto
1809   hostaddress     ditto
1810   id              the new message to process
1811   socket_fd       the connected socket
1812
1813 Returns:          FALSE if fork fails; TRUE otherwise
1814 */
1815
1816 BOOL
1817 transport_pass_socket(uschar *transport_name, uschar *hostname,
1818   uschar *hostaddress, uschar *id, int socket_fd)
1819 {
1820 pid_t pid;
1821 int status;
1822
1823 DEBUG(D_transport) debug_printf("transport_pass_socket entered\n");
1824
1825 if ((pid = fork()) == 0)
1826   {
1827   int i = 16;
1828   uschar **argv;
1829
1830   /* Disconnect entirely from the parent process. If we are running in the
1831   test harness, wait for a bit to allow the previous process time to finish,
1832   write the log, etc., so that the output is always in the same order for
1833   automatic comparison. */
1834
1835   if ((pid = fork()) != 0) _exit(EXIT_SUCCESS);
1836   if (running_in_test_harness) sleep(1);
1837
1838   /* Set up the calling arguments; use the standard function for the basics,
1839   but we have a number of extras that may be added. */
1840
1841   argv = child_exec_exim(CEE_RETURN_ARGV, TRUE, &i, FALSE, 0);
1842
1843   #ifdef EXPERIMENTAL_DSN
1844   /* Call with the dsn flag */
1845   if (smtp_use_dsn) argv[i++] = US"-MCD";
1846   #endif
1847
1848   if (smtp_authenticated) argv[i++] = US"-MCA";
1849
1850   #ifdef SUPPORT_TLS
1851   if (tls_offered) argv[i++] = US"-MCT";
1852   #endif
1853
1854   if (smtp_use_size) argv[i++] = US"-MCS";
1855   if (smtp_use_pipelining) argv[i++] = US"-MCP";
1856
1857   if (queue_run_pid != (pid_t)0)
1858     {
1859     argv[i++] = US"-MCQ";
1860     argv[i++] = string_sprintf("%d", queue_run_pid);
1861     argv[i++] = string_sprintf("%d", queue_run_pipe);
1862     }
1863
1864   argv[i++] = US"-MC";
1865   argv[i++] = transport_name;
1866   argv[i++] = hostname;
1867   argv[i++] = hostaddress;
1868   argv[i++] = string_sprintf("%d", continue_sequence + 1);
1869   argv[i++] = id;
1870   argv[i++] = NULL;
1871
1872   /* Arrange for the channel to be on stdin. */
1873
1874   if (socket_fd != 0)
1875     {
1876     (void)dup2(socket_fd, 0);
1877     (void)close(socket_fd);
1878     }
1879
1880   DEBUG(D_exec) debug_print_argv(argv);
1881   exim_nullstd();                          /* Ensure std{out,err} exist */
1882   execv(CS argv[0], (char *const *)argv);
1883
1884   DEBUG(D_any) debug_printf("execv failed: %s\n", strerror(errno));
1885   _exit(errno);         /* Note: must be _exit(), NOT exit() */
1886   }
1887
1888 /* If the process creation succeeded, wait for the first-level child, which
1889 immediately exits, leaving the second level process entirely disconnected from
1890 this one. */
1891
1892 if (pid > 0)
1893   {
1894   int rc;
1895   while ((rc = wait(&status)) != pid && (rc >= 0 || errno != ECHILD));
1896   DEBUG(D_transport) debug_printf("transport_pass_socket succeeded\n");
1897   return TRUE;
1898   }
1899 else
1900   {
1901   DEBUG(D_transport) debug_printf("transport_pass_socket failed to fork: %s\n",
1902     strerror(errno));
1903   return FALSE;
1904   }
1905 }
1906
1907
1908
1909 /*************************************************
1910 *          Set up direct (non-shell) command     *
1911 *************************************************/
1912
1913 /* This function is called when a command line is to be parsed and executed
1914 directly, without the use of /bin/sh. It is called by the pipe transport,
1915 the queryprogram router, and also from the main delivery code when setting up a
1916 transport filter process. The code for ETRN also makes use of this; in that
1917 case, no addresses are passed.
1918
1919 Arguments:
1920   argvptr            pointer to anchor for argv vector
1921   cmd                points to the command string
1922   expand_arguments   true if expansion is to occur
1923   expand_failed      error value to set if expansion fails; not relevant if
1924                      addr == NULL
1925   addr               chain of addresses, or NULL
1926   etext              text for use in error messages
1927   errptr             where to put error message if addr is NULL;
1928                      otherwise it is put in the first address
1929
1930 Returns:             TRUE if all went well; otherwise an error will be
1931                      set in the first address and FALSE returned
1932 */
1933
1934 BOOL
1935 transport_set_up_command(uschar ***argvptr, uschar *cmd, BOOL expand_arguments,
1936   int expand_failed, address_item *addr, uschar *etext, uschar **errptr)
1937 {
1938 address_item *ad;
1939 uschar **argv;
1940 uschar *s, *ss;
1941 int address_count = 0;
1942 int argcount = 0;
1943 int i, max_args;
1944
1945 /* Get store in which to build an argument list. Count the number of addresses
1946 supplied, and allow for that many arguments, plus an additional 60, which
1947 should be enough for anybody. Multiple addresses happen only when the local
1948 delivery batch option is set. */
1949
1950 for (ad = addr; ad != NULL; ad = ad->next) address_count++;
1951 max_args = address_count + 60;
1952 *argvptr = argv = store_get((max_args+1)*sizeof(uschar *));
1953
1954 /* Split the command up into arguments terminated by white space. Lose
1955 trailing space at the start and end. Double-quoted arguments can contain \\ and
1956 \" escapes and so can be handled by the standard function; single-quoted
1957 arguments are verbatim. Copy each argument into a new string. */
1958
1959 s = cmd;
1960 while (isspace(*s)) s++;
1961
1962 while (*s != 0 && argcount < max_args)
1963   {
1964   if (*s == '\'')
1965     {
1966     ss = s + 1;
1967     while (*ss != 0 && *ss != '\'') ss++;
1968     argv[argcount++] = ss = store_get(ss - s++);
1969     while (*s != 0 && *s != '\'') *ss++ = *s++;
1970     if (*s != 0) s++;
1971     *ss++ = 0;
1972     }
1973   else argv[argcount++] = string_dequote(&s);
1974   while (isspace(*s)) s++;
1975   }
1976
1977 argv[argcount] = (uschar *)0;
1978
1979 /* If *s != 0 we have run out of argument slots. */
1980
1981 if (*s != 0)
1982   {
1983   uschar *msg = string_sprintf("Too many arguments in command \"%s\" in "
1984     "%s", cmd, etext);
1985   if (addr != NULL)
1986     {
1987     addr->transport_return = FAIL;
1988     addr->message = msg;
1989     }
1990   else *errptr = msg;
1991   return FALSE;
1992   }
1993
1994 /* Expand each individual argument if required. Expansion happens for pipes set
1995 up in filter files and with directly-supplied commands. It does not happen if
1996 the pipe comes from a traditional .forward file. A failing expansion is a big
1997 disaster if the command came from Exim's configuration; if it came from a user
1998 it is just a normal failure. The expand_failed value is used as the error value
1999 to cater for these two cases.
2000
2001 An argument consisting just of the text "$pipe_addresses" is treated specially.
2002 It is not passed to the general expansion function. Instead, it is replaced by
2003 a number of arguments, one for each address. This avoids problems with shell
2004 metacharacters and spaces in addresses.
2005
2006 If the parent of the top address has an original part of "system-filter", this
2007 pipe was set up by the system filter, and we can permit the expansion of
2008 $recipients. */
2009
2010 DEBUG(D_transport)
2011   {
2012   debug_printf("direct command:\n");
2013   for (i = 0; argv[i] != (uschar *)0; i++)
2014     debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2015   }
2016
2017 if (expand_arguments)
2018   {
2019   BOOL allow_dollar_recipients = addr != NULL &&
2020     addr->parent != NULL &&
2021     Ustrcmp(addr->parent->address, "system-filter") == 0;
2022
2023   for (i = 0; argv[i] != (uschar *)0; i++)
2024     {
2025
2026     /* Handle special fudge for passing an address list */
2027
2028     if (addr != NULL &&
2029         (Ustrcmp(argv[i], "$pipe_addresses") == 0 ||
2030          Ustrcmp(argv[i], "${pipe_addresses}") == 0))
2031       {
2032       int additional;
2033
2034       if (argcount + address_count - 1 > max_args)
2035         {
2036         addr->transport_return = FAIL;
2037         addr->message = string_sprintf("Too many arguments to command \"%s\" "
2038           "in %s", cmd, etext);
2039         return FALSE;
2040         }
2041
2042       additional = address_count - 1;
2043       if (additional > 0)
2044         memmove(argv + i + 1 + additional, argv + i + 1,
2045           (argcount - i)*sizeof(uschar *));
2046
2047       for (ad = addr; ad != NULL; ad = ad->next) {
2048           argv[i++] = ad->address;
2049           argcount++;
2050       }
2051
2052       /* Subtract one since we replace $pipe_addresses */
2053       argcount--;
2054       i--;
2055       }
2056
2057       /* Handle special case of $address_pipe when af_force_command is set */
2058
2059     else if (addr != NULL && testflag(addr,af_force_command) &&
2060         (Ustrcmp(argv[i], "$address_pipe") == 0 ||
2061          Ustrcmp(argv[i], "${address_pipe}") == 0))
2062       {
2063       int address_pipe_i;
2064       int address_pipe_argcount = 0;
2065       int address_pipe_max_args;
2066       uschar **address_pipe_argv;
2067
2068       /* We can never have more then the argv we will be loading into */
2069       address_pipe_max_args = max_args - argcount + 1;
2070
2071       DEBUG(D_transport)
2072         debug_printf("address_pipe_max_args=%d\n", address_pipe_max_args);
2073
2074       /* We allocate an additional for (uschar *)0 */
2075       address_pipe_argv = store_get((address_pipe_max_args+1)*sizeof(uschar *));
2076
2077       /* +1 because addr->local_part[0] == '|' since af_force_command is set */
2078       s = expand_string(addr->local_part + 1);
2079
2080       if (s == NULL || *s == '\0')
2081         {
2082         addr->transport_return = FAIL;
2083         addr->message = string_sprintf("Expansion of \"%s\" "
2084            "from command \"%s\" in %s failed: %s",
2085            (addr->local_part + 1), cmd, etext, expand_string_message);
2086         return FALSE;
2087         }
2088
2089       while (isspace(*s)) s++; /* strip leading space */
2090
2091       while (*s != 0 && address_pipe_argcount < address_pipe_max_args)
2092         {
2093         if (*s == '\'')
2094           {
2095           ss = s + 1;
2096           while (*ss != 0 && *ss != '\'') ss++;
2097           address_pipe_argv[address_pipe_argcount++] = ss = store_get(ss - s++);
2098           while (*s != 0 && *s != '\'') *ss++ = *s++;
2099           if (*s != 0) s++;
2100           *ss++ = 0;
2101           }
2102         else address_pipe_argv[address_pipe_argcount++] = string_dequote(&s);
2103         while (isspace(*s)) s++; /* strip space after arg */
2104         }
2105
2106       address_pipe_argv[address_pipe_argcount] = (uschar *)0;
2107
2108       /* If *s != 0 we have run out of argument slots. */
2109       if (*s != 0)
2110         {
2111         uschar *msg = string_sprintf("Too many arguments in $address_pipe "
2112           "\"%s\" in %s", addr->local_part + 1, etext);
2113         if (addr != NULL)
2114           {
2115           addr->transport_return = FAIL;
2116           addr->message = msg;
2117           }
2118         else *errptr = msg;
2119         return FALSE;
2120         }
2121
2122       /* address_pipe_argcount - 1
2123        * because we are replacing $address_pipe in the argument list
2124        * with the first thing it expands to */
2125       if (argcount + address_pipe_argcount - 1 > max_args)
2126         {
2127         addr->transport_return = FAIL;
2128         addr->message = string_sprintf("Too many arguments to command "
2129           "\"%s\" after expanding $address_pipe in %s", cmd, etext);
2130         return FALSE;
2131         }
2132
2133       /* If we are not just able to replace the slot that contained
2134        * $address_pipe (address_pipe_argcount == 1)
2135        * We have to move the existing argv by address_pipe_argcount - 1
2136        * Visually if address_pipe_argcount == 2:
2137        * [argv 0][argv 1][argv 2($address_pipe)][argv 3][0]
2138        * [argv 0][argv 1][ap_arg0][ap_arg1][old argv 3][0]
2139        */
2140       if (address_pipe_argcount > 1)
2141         memmove(
2142           /* current position + additonal args */
2143           argv + i + address_pipe_argcount,
2144           /* current position + 1 (for the (uschar *)0 at the end) */
2145           argv + i + 1,
2146           /* -1 for the (uschar *)0 at the end)*/
2147           (argcount - i)*sizeof(uschar *)
2148         );
2149
2150       /* Now we fill in the slots we just moved argv out of
2151        * [argv 0][argv 1][argv 2=pipeargv[0]][argv 3=pipeargv[1]][old argv 3][0]
2152        */
2153       for (address_pipe_i = 0;
2154            address_pipe_argv[address_pipe_i] != (uschar *)0;
2155            address_pipe_i++)
2156         {
2157         argv[i++] = address_pipe_argv[address_pipe_i];
2158         argcount++;
2159         }
2160
2161       /* Subtract one since we replace $address_pipe */
2162       argcount--;
2163       i--;
2164       }
2165
2166     /* Handle normal expansion string */
2167
2168     else
2169       {
2170       uschar *expanded_arg;
2171       enable_dollar_recipients = allow_dollar_recipients;
2172       expanded_arg = expand_string(argv[i]);
2173       enable_dollar_recipients = FALSE;
2174
2175       if (expanded_arg == NULL)
2176         {
2177         uschar *msg = string_sprintf("Expansion of \"%s\" "
2178           "from command \"%s\" in %s failed: %s",
2179           argv[i], cmd, etext, expand_string_message);
2180         if (addr != NULL)
2181           {
2182           addr->transport_return = expand_failed;
2183           addr->message = msg;
2184           }
2185         else *errptr = msg;
2186         return FALSE;
2187         }
2188       argv[i] = expanded_arg;
2189       }
2190     }
2191
2192   DEBUG(D_transport)
2193     {
2194     debug_printf("direct command after expansion:\n");
2195     for (i = 0; argv[i] != (uschar *)0; i++)
2196       debug_printf("  argv[%d] = %s\n", i, string_printing(argv[i]));
2197     }
2198   }
2199
2200 return TRUE;
2201 }
2202
2203 /* vi: aw ai sw=2
2204 */
2205 /* End of transport.c */