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