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