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