1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
13 #ifdef TRANSPORT_AUTOREPLY /* Remainder of file */
14 #include "autoreply.h"
18 /* Options specific to the autoreply transport. They must be in alphabetic
19 order (note that "_" comes before the lower case letters). Those starting
20 with "*" are not settable by the user but are used by the option-reading
21 software for alternative value types. Some options are publicly visible and so
22 are stored in the driver instance block. These are flagged with opt_public. */
23 #define LOFF(field) OPT_OFF(autoreply_transport_options_block, field)
25 optionlist autoreply_transport_options[] = {
26 { "bcc", opt_stringptr, LOFF(bcc) },
27 { "cc", opt_stringptr, LOFF(cc) },
28 { "file", opt_stringptr, LOFF(file) },
29 { "file_expand", opt_bool, LOFF(file_expand) },
30 { "file_optional", opt_bool, LOFF(file_optional) },
31 { "from", opt_stringptr, LOFF(from) },
32 { "headers", opt_stringptr, LOFF(headers) },
33 { "log", opt_stringptr, LOFF(logfile) },
34 { "mode", opt_octint, LOFF(mode) },
35 { "never_mail", opt_stringptr, LOFF(never_mail) },
36 { "once", opt_stringptr, LOFF(oncelog) },
37 { "once_file_size", opt_int, LOFF(once_file_size) },
38 { "once_repeat", opt_stringptr, LOFF(once_repeat) },
39 { "reply_to", opt_stringptr, LOFF(reply_to) },
40 { "return_message", opt_bool, LOFF(return_message) },
41 { "subject", opt_stringptr, LOFF(subject) },
42 { "text", opt_stringptr, LOFF(text) },
43 { "to", opt_stringptr, LOFF(to) },
46 /* Size of the options list. An extern variable has to be used so that its
47 address can appear in the tables drtables.c. */
49 int autoreply_transport_options_count =
50 sizeof(autoreply_transport_options)/sizeof(optionlist);
56 autoreply_transport_options_block autoreply_transport_option_defaults = {0};
57 void autoreply_transport_init(transport_instance *tblock) {}
58 BOOL autoreply_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
60 #else /*!MACRO_PREDEF*/
63 /* Default private options block for the autoreply transport.
64 All non-mentioned lements zero/null/false. */
66 autoreply_transport_options_block autoreply_transport_option_defaults = {
72 /* Type of text for the checkexpand() function */
74 enum { cke_text, cke_hdr, cke_file };
78 /*************************************************
79 * Initialization entry point *
80 *************************************************/
82 /* Called for each instance, after its options have been read, to
83 enable consistency checks to be done, or anything else that needs
87 autoreply_transport_init(transport_instance *tblock)
90 autoreply_transport_options_block *ob =
91 (autoreply_transport_options_block *)(tblock->options_block);
94 /* If a fixed uid field is set, then a gid field must also be set. */
96 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
97 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
98 "user set without group for the %s transport", tblock->name);
104 /*************************************************
105 * Expand string and check *
106 *************************************************/
108 /* If the expansion fails, the error is set up in the address. Expanded
109 strings must be checked to ensure they contain only printing characters
110 and white space. If not, the function fails.
114 addr address that is being worked on
115 name transport name, for error text
116 type type, for checking content:
118 cke_hdr => header, allow \n + whitespace
119 cke_file => file name, no non-printers allowed
121 Returns: expanded string if expansion succeeds;
126 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
128 uschar *ss = expand_string(s);
132 addr->transport_return = FAIL;
133 addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
134 "%s", s, name, expand_string_message);
138 if (type != cke_text) for (uschar * t = ss; *t != 0; t++)
142 if (mac_isprint(c)) continue;
143 if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
144 sp = string_printing(s);
145 addr->transport_return = FAIL;
146 addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
147 "contains non-printing character %d", sp, name, c);
157 /*************************************************
158 * Check a header line for never_mail *
159 *************************************************/
161 /* This is called to check to, cc, and bcc for addresses in the never_mail
162 list. Any that are found are removed.
165 list list of addresses to be checked
166 never_mail an address list, already expanded
168 Returns: edited replacement address list, or NULL, or original
172 check_never_mail(uschar * list, const uschar * never_mail)
174 rmark reset_point = store_mark();
175 uschar * newlist = string_copy(list);
176 uschar * s = newlist;
181 uschar *error, *next;
182 uschar *e = parse_find_address_end(s, FALSE);
184 int start, end, domain, rc;
186 /* Temporarily terminate the string at the address end while extracting
187 the operative address within. */
190 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
193 /* If there is some kind of syntax error, just give up on this header
198 /* See if the address is on the never_mail list */
200 rc = match_address_list(next, /* address to check */
201 TRUE, /* start caseless */
202 FALSE, /* don't expand the list */
203 &never_mail, /* the list */
204 NULL, /* no caching */
205 -1, /* no expand setup */
206 0, /* separator from list */
207 NULL); /* no lookup value return */
209 if (rc == OK) /* Remove this address */
212 debug_printf("discarding recipient %s (matched never_mail)\n", next);
214 if (terminator == ',') e++;
215 memmove(s, e, Ustrlen(e) + 1);
217 else /* Skip over this address */
220 if (terminator == ',') s++;
224 /* If no addresses were removed, retrieve the memory used and return
229 store_reset(reset_point);
233 /* Check to see if we removed the last address, leaving a terminating comma
234 that needs to be removed */
236 s = newlist + Ustrlen(newlist);
237 while (s > newlist && (isspace(s[-1]) || s[-1] == ',')) s--;
240 /* Check to see if there any addresses left; if not, return NULL */
243 while (s && isspace(*s)) s++;
247 store_reset(reset_point);
253 /*************************************************
255 *************************************************/
257 /* See local README for interface details. This transport always returns
258 FALSE, indicating that the top address has the status for all - though in fact
259 this transport can handle only one address at at time anyway. */
262 autoreply_transport_entry(
263 transport_instance *tblock, /* data for this instantiation */
264 address_item *addr) /* address we are working on */
270 EXIM_DB * dbm_file = NULL;
271 BOOL file_expand, return_message;
272 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
273 uschar *logfile, *oncelog;
274 uschar *cache_buff = NULL;
275 uschar *cache_time = NULL;
276 uschar *message_id = NULL;
278 time_t now = time(NULL);
279 time_t once_repeat_sec = 0;
283 autoreply_transport_options_block *ob =
284 (autoreply_transport_options_block *)(tblock->options_block);
286 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
288 /* Set up for the good case */
290 addr->transport_return = OK;
291 addr->basic_errno = 0;
293 /* If the address is pointing to a reply block, then take all the data
294 from that block. It has typically been set up by a mail filter processing
295 router. Otherwise, the data must be supplied by this transport, and
296 it has to be expanded here. */
300 DEBUG(D_transport) debug_printf("taking data from address\n");
301 from = addr->reply->from;
302 reply_to = addr->reply->reply_to;
303 to = addr->reply->to;
304 cc = addr->reply->cc;
305 bcc = addr->reply->bcc;
306 subject = addr->reply->subject;
307 headers = addr->reply->headers;
308 text = addr->reply->text;
309 file = addr->reply->file;
310 logfile = addr->reply->logfile;
311 oncelog = addr->reply->oncelog;
312 once_repeat_sec = addr->reply->once_repeat;
313 file_expand = addr->reply->file_expand;
314 expand_forbid = addr->reply->expand_forbid;
315 return_message = addr->reply->return_message;
321 DEBUG(D_transport) debug_printf("taking data from transport\n");
322 GET_OPTION("once_repeat"); oncerepeat = ob->once_repeat;
323 GET_OPTION("from"); from = ob->from;
324 GET_OPTION("reply_to"); reply_to = ob->reply_to;
325 GET_OPTION("to"); to = ob->to;
326 GET_OPTION("cc"); cc = ob->cc;
327 GET_OPTION("bcc"); bcc = ob->bcc;
328 GET_OPTION("subject"); subject = ob->subject;
329 GET_OPTION("headers"); headers = ob->headers;
330 GET_OPTION("text"); text = ob->text;
331 GET_OPTION("file"); file = ob->file;
332 GET_OPTION("log"); logfile = ob->logfile;
333 GET_OPTION("once"); oncelog = ob->oncelog;
334 file_expand = ob->file_expand;
335 return_message = ob->return_message;
337 if ( from && !(from = checkexpand(from, addr, tblock->name, cke_hdr))
338 || reply_to && !(reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr))
339 || to && !(to = checkexpand(to, addr, tblock->name, cke_hdr))
340 || cc && !(cc = checkexpand(cc, addr, tblock->name, cke_hdr))
341 || bcc && !(bcc = checkexpand(bcc, addr, tblock->name, cke_hdr))
342 || subject && !(subject = checkexpand(subject, addr, tblock->name, cke_hdr))
343 || headers && !(headers = checkexpand(headers, addr, tblock->name, cke_text))
344 || text && !(text = checkexpand(text, addr, tblock->name, cke_text))
345 || file && !(file = checkexpand(file, addr, tblock->name, cke_file))
346 || logfile && !(logfile = checkexpand(logfile, addr, tblock->name, cke_file))
347 || oncelog && !(oncelog = checkexpand(oncelog, addr, tblock->name, cke_file))
348 || oncerepeat && !(oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file))
353 if ((once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE)) < 0)
355 addr->transport_return = FAIL;
356 addr->message = string_sprintf("Invalid time value \"%s\" for "
357 "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
362 /* If the never_mail option is set, we have to scan all the recipients and
363 remove those that match. */
367 const uschar *never_mail = expand_string(ob->never_mail);
371 addr->transport_return = FAIL;
372 addr->message = string_sprintf("Failed to expand \"%s\" for "
373 "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
377 if (to) to = check_never_mail(to, never_mail);
378 if (cc) cc = check_never_mail(cc, never_mail);
379 if (bcc) bcc = check_never_mail(bcc, never_mail);
381 if (!to && !cc && !bcc)
384 debug_printf("*** all recipients removed by never_mail\n");
389 /* If the -N option is set, can't do any more. */
394 debug_printf("*** delivery by %s transport bypassed by -N option\n",
400 /* If the oncelog field is set, we send want to send only one message to the
401 given recipient(s). This works only on the "To" field. If there is no "To"
402 field, the message is always sent. If the To: field contains more than one
403 recipient, the effect might not be quite as envisaged. If once_file_size is
404 set, instead of a dbm file, we use a regular file containing a circular buffer
407 if (oncelog && *oncelog && to)
411 if (is_tainted(oncelog))
413 addr->transport_return = DEFER;
414 addr->basic_errno = EACCES;
415 addr->message = string_sprintf("Tainted '%s' (once file for %s transport)"
416 " not permitted", oncelog, tblock->name);
420 /* Handle fixed-size cache file. */
422 if (ob->once_file_size > 0)
427 cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
428 if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
430 addr->transport_return = DEFER;
431 addr->basic_errno = errno;
432 addr->message = string_sprintf("Failed to %s \"once\" file %s when "
433 "sending message from %s transport: %s",
434 cache_fd < 0 ? "open" : "stat", oncelog, tblock->name, strerror(errno));
438 /* Get store in the temporary pool and read the entire file into it. We get
439 an amount of store that is big enough to add the new entry on the end if we
442 cache_size = statbuf.st_size;
443 add_size = sizeof(time_t) + Ustrlen(to) + 1;
444 cache_buff = store_get(cache_size + add_size, oncelog);
446 if (read(cache_fd, cache_buff, cache_size) != cache_size)
448 addr->transport_return = DEFER;
449 addr->basic_errno = errno;
450 addr->message = US"error while reading \"once\" file";
454 DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
456 /* Scan the data for this recipient. Each entry in the file starts with
457 a time_t sized time value, followed by the address, followed by a binary
458 zero. If we find a match, put the time into "then", and the place where it
459 was found into "cache_time". Otherwise, "then" is left at zero. */
461 for (uschar * p = cache_buff; p < cache_buff + cache_size; p = nextp)
463 uschar *s = p + sizeof(time_t);
464 nextp = s + Ustrlen(s) + 1;
465 if (Ustrcmp(to, s) == 0)
467 memcpy(&then, p, sizeof(time_t));
474 /* Use a DBM file for the list of previous recipients. */
478 EXIM_DATUM key_datum, result_datum;
479 uschar * dirname, * s;
481 dirname = (s = Ustrrchr(oncelog, '/'))
482 ? string_copyn(oncelog, s - oncelog) : NULL;
483 if (!(dbm_file = exim_dbopen(oncelog, dirname, O_RDWR|O_CREAT, ob->mode)))
485 addr->transport_return = DEFER;
486 addr->basic_errno = errno;
487 addr->message = string_sprintf("Failed to open %s file %s when sending "
488 "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
493 exim_datum_init(&key_datum); /* Some DBM libraries need datums */
494 exim_datum_init(&result_datum); /* to be cleared */
495 exim_datum_data_set(&key_datum, (void *) to);
496 exim_datum_size_set(&key_datum, Ustrlen(to) + 1);
498 if (exim_dbget(dbm_file, &key_datum, &result_datum))
500 /* If the datum size is that of a binary time, we are in the new world
501 where messages are sent periodically. Otherwise the file is an old one,
502 where the datum was filled with a tod_log time, which is assumed to be
503 different in size. For that, only one message is ever sent. This change
504 introduced at Exim 3.00. In a couple of years' time the test on the size
507 if (exim_datum_size_get(&result_datum) == sizeof(time_t))
508 memcpy(&then, exim_datum_data_get(&result_datum), sizeof(time_t));
514 /* Either "then" is set zero, if no message has yet been sent, or it
515 is set to the time of the last sending. */
517 if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
520 if (is_tainted(logfile))
522 addr->transport_return = DEFER;
523 addr->basic_errno = EACCES;
524 addr->message = string_sprintf("Tainted '%s' (logfile for %s transport)"
525 " not permitted", logfile, tblock->name);
529 DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
530 (once_repeat_sec > 0)? " and repeat time not reached" : "");
531 log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
534 uschar *ptr = log_buffer;
535 sprintf(CS ptr, "%s\n previously sent to %.200s\n", tod_stamp(tod_log), to);
537 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
539 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
540 "transport\n", logfile, tblock->name);
545 DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
546 "no previous message sent to" : "repeat time reached for", to);
549 /* We are going to send a message. Ensure any requested file is available. */
552 if (is_tainted(file))
554 addr->transport_return = DEFER;
555 addr->basic_errno = EACCES;
556 addr->message = string_sprintf("Tainted '%s' (file for %s transport)"
557 " not permitted", file, tblock->name);
560 if (!(ff = Ufopen(file, "rb")) && !ob->file_optional)
562 addr->transport_return = DEFER;
563 addr->basic_errno = errno;
564 addr->message = string_sprintf("Failed to open file %s when sending "
565 "message from %s transport: %s", file, tblock->name, strerror(errno));
570 /* Make a subprocess to send the message */
572 if ((pid = child_open_exim(&fd, US"autoreply")) < 0)
574 /* Creation of child failed; defer this delivery. */
576 addr->transport_return = DEFER;
577 addr->basic_errno = errno;
578 addr->message = string_sprintf("Failed to create child process to send "
579 "message from %s transport: %s", tblock->name, strerror(errno));
580 DEBUG(D_transport) debug_printf("%s\n", addr->message);
581 if (dbm_file) exim_dbclose(dbm_file);
585 /* Create the message to be sent - recipients are taken from the headers,
586 as the -t option is used. The "headers" stuff *must* be last in case there
587 are newlines in it which might, if placed earlier, screw up other headers. */
589 fp = fdopen(fd, "wb");
591 if (from) fprintf(fp, "From: %s\n", from);
592 if (reply_to) fprintf(fp, "Reply-To: %s\n", reply_to);
593 if (to) fprintf(fp, "To: %s\n", to);
594 if (cc) fprintf(fp, "Cc: %s\n", cc);
595 if (bcc) fprintf(fp, "Bcc: %s\n", bcc);
596 if (subject) fprintf(fp, "Subject: %s\n", subject);
598 /* Generate In-Reply-To from the message_id header; there should
599 always be one, but code defensively. */
601 for (h = header_list; h; h = h->next)
602 if (h->type == htype_id) break;
606 message_id = Ustrchr(h->text, ':') + 1;
607 while (isspace(*message_id)) message_id++;
608 fprintf(fp, "In-Reply-To: %s", message_id);
611 moan_write_references(fp, message_id);
613 /* Add an Auto-Submitted: header */
615 fprintf(fp, "Auto-Submitted: auto-replied\n");
617 /* Add any specially requested headers */
619 if (headers) fprintf(fp, "%s\n", headers);
624 fprintf(fp, "%s", CS text);
625 if (text[Ustrlen(text)-1] != '\n') fprintf(fp, "\n");
630 while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
634 uschar *s = expand_string(big_buffer);
638 debug_printf("error while expanding line from file:\n %s\n %s\n",
639 big_buffer, expand_string_message);
641 fprintf(fp, "%s", s ? CS s : CS big_buffer);
643 else fprintf(fp, "%s", CS big_buffer);
648 /* Copy the original message if required, observing the return size
649 limit if we are returning the body. */
653 uschar *rubric = tblock->headers_only
654 ? US"------ This is a copy of the message's header lines.\n"
656 ? US"------ This is a copy of the body of the message, without the headers.\n"
657 : US"------ This is a copy of the message, including all the headers.\n";
658 transport_ctx tctx = {
659 .u = {.fd = fileno(fp)},
662 .check_string = NULL,
663 .escape_string = NULL,
664 .options = (tblock->body_only ? topt_no_headers : 0)
665 | (tblock->headers_only ? topt_no_body : 0)
666 | (tblock->return_path_add ? topt_add_return_path : 0)
667 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
668 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
672 if (bounce_return_size_limit > 0 && !tblock->headers_only)
675 int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
676 DELIVER_IN_BUFFER_SIZE;
677 if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
680 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
681 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
684 else fprintf(fp, "\n%s\n", rubric);
686 else fprintf(fp, "\n%s\n", rubric);
690 transport_write_message(&tctx, bounce_return_size_limit);
693 /* End the message and wait for the child process to end; no timeout. */
696 rc = child_close(pid, 0);
698 /* Update the "sent to" log whatever the yield. This errs on the side of
699 missing out a message rather than risking sending more than one. We either have
700 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
701 DBM file (or neither, if "once" is not set). */
703 /* Update fixed-size cache file. If cache_time is set, we found a previous
704 entry; that is the spot into which to put the current time. Otherwise we have
705 to add a new record; remove the first one in the file if the file is too big.
706 We always rewrite the entire file in a single write operation. This is
707 (hopefully) going to be the safest thing because there is no interlocking
708 between multiple simultaneous deliveries. */
712 uschar *from = cache_buff;
713 int size = cache_size;
715 if (lseek(cache_fd, 0, SEEK_SET) == 0)
719 cache_time = from + size;
720 memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
723 if (cache_size > 0 && size > ob->once_file_size)
725 from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
726 size -= (from - cache_buff);
730 memcpy(cache_time, &now, sizeof(time_t));
731 if(write(cache_fd, from, size) != size)
732 DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
733 "transport\n", oncelog, tblock->name);
737 /* Update DBM file */
741 EXIM_DATUM key_datum, value_datum;
742 exim_datum_init(&key_datum); /* Some DBM libraries need to have */
743 exim_datum_init(&value_datum); /* cleared datums. */
744 exim_datum_data_set(&key_datum, to);
745 exim_datum_size_set(&key_datum, Ustrlen(to) + 1);
747 /* Many OS define the datum value, sensibly, as a void *. However, there
748 are some which still have char *. By casting this address to a char * we
749 can avoid warning messages from the char * systems. */
751 exim_datum_data_set(&value_datum, &now);
752 exim_datum_size_set(&value_datum, sizeof(time_t));
753 exim_dbput(dbm_file, &key_datum, &value_datum);
756 /* If sending failed, defer to try again - but if once is set the next
757 try will skip, of course. However, if there were no recipients in the
758 message, we do not fail. */
761 if (rc == EXIT_NORECIPIENTS)
763 DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
768 addr->transport_return = DEFER;
769 addr->message = string_sprintf("Failed to send message from %s "
770 "transport (%d)", tblock->name, rc);
774 /* Log the sending of the message if successful and required. If the file
775 fails to open, it's hard to know what to do. We cannot write to the Exim
776 log from here, since we may be running under an unprivileged uid. We don't
777 want to fail the delivery, since the message has been successfully sent. For
778 the moment, ignore open failures. Write the log entry as a single write() to a
779 file opened for appending, in order to avoid interleaving of output from
780 different processes. The log_buffer can be used exactly as for main log
785 int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
788 gstring gs = { .size = LOG_BUFFER_SIZE, .ptr = 0, .s = log_buffer }, *g = &gs;
790 /* Use taint-unchecked routines for writing into log_buffer, trusting
791 that we'll never expand it. */
793 DEBUG(D_transport) debug_printf("logging message details\n");
794 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "%s\n", tod_stamp(tod_log));
796 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " From: %s\n", from);
798 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " To: %s\n", to);
800 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Cc: %s\n", cc);
802 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Bcc: %s\n", bcc);
804 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Subject: %s\n", subject);
806 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " %s\n", headers);
807 if(write(log_fd, g->s, g->ptr) != g->ptr || close(log_fd))
808 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
809 "transport\n", logfile, tblock->name);
811 else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
812 "transport: %s\n", logfile, tblock->name, strerror(errno));
816 if (dbm_file) exim_dbclose(dbm_file);
817 if (cache_fd > 0) (void)close(cache_fd);
819 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
824 #endif /*!MACRO_PREDEF*/
825 #endif /*TRANSPORT_AUTOREPOL*/
826 /* End of transport/autoreply.c */