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