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