1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 - 2021 */
7 /* See the file NOTICE for conditions of use and distribution. */
11 #include "autoreply.h"
15 /* Options specific to the autoreply transport. They must be in alphabetic
16 order (note that "_" comes before the lower case letters). Those starting
17 with "*" are not settable by the user but are used by the option-reading
18 software for alternative value types. Some options are publicly visible and so
19 are stored in the driver instance block. These are flagged with opt_public. */
20 #define LOFF(field) OPT_OFF(autoreply_transport_options_block, field)
22 optionlist autoreply_transport_options[] = {
23 { "bcc", opt_stringptr, LOFF(bcc) },
24 { "cc", opt_stringptr, LOFF(cc) },
25 { "file", opt_stringptr, LOFF(file) },
26 { "file_expand", opt_bool, LOFF(file_expand) },
27 { "file_optional", opt_bool, LOFF(file_optional) },
28 { "from", opt_stringptr, LOFF(from) },
29 { "headers", opt_stringptr, LOFF(headers) },
30 { "log", opt_stringptr, LOFF(logfile) },
31 { "mode", opt_octint, LOFF(mode) },
32 { "never_mail", opt_stringptr, LOFF(never_mail) },
33 { "once", opt_stringptr, LOFF(oncelog) },
34 { "once_file_size", opt_int, LOFF(once_file_size) },
35 { "once_repeat", opt_stringptr, LOFF(once_repeat) },
36 { "reply_to", opt_stringptr, LOFF(reply_to) },
37 { "return_message", opt_bool, LOFF(return_message) },
38 { "subject", opt_stringptr, LOFF(subject) },
39 { "text", opt_stringptr, LOFF(text) },
40 { "to", opt_stringptr, LOFF(to) },
43 /* Size of the options list. An extern variable has to be used so that its
44 address can appear in the tables drtables.c. */
46 int autoreply_transport_options_count =
47 sizeof(autoreply_transport_options)/sizeof(optionlist);
53 autoreply_transport_options_block autoreply_transport_option_defaults = {0};
54 void autoreply_transport_init(transport_instance *tblock) {}
55 BOOL autoreply_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
57 #else /*!MACRO_PREDEF*/
60 /* Default private options block for the autoreply transport.
61 All non-mentioned lements zero/null/false. */
63 autoreply_transport_options_block autoreply_transport_option_defaults = {
69 /* Type of text for the checkexpand() function */
71 enum { cke_text, cke_hdr, cke_file };
75 /*************************************************
76 * Initialization entry point *
77 *************************************************/
79 /* Called for each instance, after its options have been read, to
80 enable consistency checks to be done, or anything else that needs
84 autoreply_transport_init(transport_instance *tblock)
87 autoreply_transport_options_block *ob =
88 (autoreply_transport_options_block *)(tblock->options_block);
91 /* If a fixed uid field is set, then a gid field must also be set. */
93 if (tblock->uid_set && !tblock->gid_set && tblock->expand_gid == NULL)
94 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
95 "user set without group for the %s transport", tblock->name);
101 /*************************************************
102 * Expand string and check *
103 *************************************************/
105 /* If the expansion fails, the error is set up in the address. Expanded
106 strings must be checked to ensure they contain only printing characters
107 and white space. If not, the function fails.
111 addr address that is being worked on
112 name transport name, for error text
113 type type, for checking content:
115 cke_hdr => header, allow \n + whitespace
116 cke_file => file name, no non-printers allowed
118 Returns: expanded string if expansion succeeds;
123 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
125 uschar *ss = expand_string(s);
129 addr->transport_return = FAIL;
130 addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
131 "%s", s, name, expand_string_message);
135 if (type != cke_text) for (uschar * t = ss; *t != 0; t++)
139 if (mac_isprint(c)) continue;
140 if (type == cke_hdr && c == '\n' && (t[1] == ' ' || t[1] == '\t')) continue;
141 sp = string_printing(s);
142 addr->transport_return = FAIL;
143 addr->message = string_sprintf("Expansion of \"%s\" in %s transport "
144 "contains non-printing character %d", sp, name, c);
154 /*************************************************
155 * Check a header line for never_mail *
156 *************************************************/
158 /* This is called to check to, cc, and bcc for addresses in the never_mail
159 list. Any that are found are removed.
162 list list of addresses to be checked
163 never_mail an address list, already expanded
165 Returns: edited replacement address list, or NULL, or original
169 check_never_mail(uschar * list, const uschar * never_mail)
171 rmark reset_point = store_mark();
172 uschar * newlist = string_copy(list);
173 uschar * s = newlist;
178 uschar *error, *next;
179 uschar *e = parse_find_address_end(s, FALSE);
181 int start, end, domain, rc;
183 /* Temporarily terminate the string at the address end while extracting
184 the operative address within. */
187 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
190 /* If there is some kind of syntax error, just give up on this header
195 /* See if the address is on the never_mail list */
197 rc = match_address_list(next, /* address to check */
198 TRUE, /* start caseless */
199 FALSE, /* don't expand the list */
200 &never_mail, /* the list */
201 NULL, /* no caching */
202 -1, /* no expand setup */
203 0, /* separator from list */
204 NULL); /* no lookup value return */
206 if (rc == OK) /* Remove this address */
209 debug_printf("discarding recipient %s (matched never_mail)\n", next);
211 if (terminator == ',') e++;
212 memmove(s, e, Ustrlen(e) + 1);
214 else /* Skip over this address */
217 if (terminator == ',') s++;
221 /* If no addresses were removed, retrieve the memory used and return
226 store_reset(reset_point);
230 /* Check to see if we removed the last address, leaving a terminating comma
231 that needs to be removed */
233 s = newlist + Ustrlen(newlist);
234 while (s > newlist && (isspace(s[-1]) || s[-1] == ',')) s--;
237 /* Check to see if there any addresses left; if not, return NULL */
240 while (s && isspace(*s)) s++;
244 store_reset(reset_point);
250 /*************************************************
252 *************************************************/
254 /* See local README for interface details. This transport always returns
255 FALSE, indicating that the top address has the status for all - though in fact
256 this transport can handle only one address at at time anyway. */
259 autoreply_transport_entry(
260 transport_instance *tblock, /* data for this instantiation */
261 address_item *addr) /* address we are working on */
267 EXIM_DB *dbm_file = NULL;
268 BOOL file_expand, return_message;
269 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
270 uschar *logfile, *oncelog;
271 uschar *cache_buff = NULL;
272 uschar *cache_time = NULL;
273 uschar *message_id = NULL;
275 time_t now = time(NULL);
276 time_t once_repeat_sec = 0;
280 autoreply_transport_options_block *ob =
281 (autoreply_transport_options_block *)(tblock->options_block);
283 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
285 /* Set up for the good case */
287 addr->transport_return = OK;
288 addr->basic_errno = 0;
290 /* If the address is pointing to a reply block, then take all the data
291 from that block. It has typically been set up by a mail filter processing
292 router. Otherwise, the data must be supplied by this transport, and
293 it has to be expanded here. */
297 DEBUG(D_transport) debug_printf("taking data from address\n");
298 from = addr->reply->from;
299 reply_to = addr->reply->reply_to;
300 to = addr->reply->to;
301 cc = addr->reply->cc;
302 bcc = addr->reply->bcc;
303 subject = addr->reply->subject;
304 headers = addr->reply->headers;
305 text = addr->reply->text;
306 file = addr->reply->file;
307 logfile = addr->reply->logfile;
308 oncelog = addr->reply->oncelog;
309 once_repeat_sec = addr->reply->once_repeat;
310 file_expand = addr->reply->file_expand;
311 expand_forbid = addr->reply->expand_forbid;
312 return_message = addr->reply->return_message;
316 uschar *oncerepeat = ob->once_repeat;
318 DEBUG(D_transport) debug_printf("taking data from transport\n");
320 reply_to = ob->reply_to;
324 subject = ob->subject;
325 headers = ob->headers;
328 logfile = ob->logfile;
329 oncelog = ob->oncelog;
330 file_expand = ob->file_expand;
331 return_message = ob->return_message;
333 if ( from && !(from = checkexpand(from, addr, tblock->name, cke_hdr))
334 || reply_to && !(reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr))
335 || to && !(to = checkexpand(to, addr, tblock->name, cke_hdr))
336 || cc && !(cc = checkexpand(cc, addr, tblock->name, cke_hdr))
337 || bcc && !(bcc = checkexpand(bcc, addr, tblock->name, cke_hdr))
338 || subject && !(subject = checkexpand(subject, addr, tblock->name, cke_hdr))
339 || headers && !(headers = checkexpand(headers, addr, tblock->name, cke_text))
340 || text && !(text = checkexpand(text, addr, tblock->name, cke_text))
341 || file && !(file = checkexpand(file, addr, tblock->name, cke_file))
342 || logfile && !(logfile = checkexpand(logfile, addr, tblock->name, cke_file))
343 || oncelog && !(oncelog = checkexpand(oncelog, addr, tblock->name, cke_file))
344 || oncerepeat && !(oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file))
349 if ((once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE)) < 0)
351 addr->transport_return = FAIL;
352 addr->message = string_sprintf("Invalid time value \"%s\" for "
353 "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
358 /* If the never_mail option is set, we have to scan all the recipients and
359 remove those that match. */
363 const uschar *never_mail = expand_string(ob->never_mail);
367 addr->transport_return = FAIL;
368 addr->message = string_sprintf("Failed to expand \"%s\" for "
369 "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
373 if (to) to = check_never_mail(to, never_mail);
374 if (cc) cc = check_never_mail(cc, never_mail);
375 if (bcc) bcc = check_never_mail(bcc, never_mail);
377 if (!to && !cc && !bcc)
380 debug_printf("*** all recipients removed by never_mail\n");
385 /* If the -N option is set, can't do any more. */
390 debug_printf("*** delivery by %s transport bypassed by -N option\n",
396 /* If the oncelog field is set, we send want to send only one message to the
397 given recipient(s). This works only on the "To" field. If there is no "To"
398 field, the message is always sent. If the To: field contains more than one
399 recipient, the effect might not be quite as envisaged. If once_file_size is
400 set, instead of a dbm file, we use a regular file containing a circular buffer
403 if (oncelog && *oncelog && to)
408 if ((m = is_tainted2(oncelog, 0, "Tainted '%s' (once file for %s transport)"
409 " not permitted", oncelog, tblock->name)))
411 addr->transport_return = DEFER;
412 addr->basic_errno = EACCES;
417 /* Handle fixed-size cache file. */
419 if (ob->once_file_size > 0)
424 cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
425 if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
427 addr->transport_return = DEFER;
428 addr->basic_errno = errno;
429 addr->message = string_sprintf("Failed to %s \"once\" file %s when "
430 "sending message from %s transport: %s",
431 cache_fd < 0 ? "open" : "stat", oncelog, tblock->name, strerror(errno));
435 /* Get store in the temporary pool and read the entire file into it. We get
436 an amount of store that is big enough to add the new entry on the end if we
439 cache_size = statbuf.st_size;
440 add_size = sizeof(time_t) + Ustrlen(to) + 1;
441 cache_buff = store_get(cache_size + add_size, is_tainted(oncelog));
443 if (read(cache_fd, cache_buff, cache_size) != cache_size)
445 addr->transport_return = DEFER;
446 addr->basic_errno = errno;
447 addr->message = US"error while reading \"once\" file";
451 DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
453 /* Scan the data for this recipient. Each entry in the file starts with
454 a time_t sized time value, followed by the address, followed by a binary
455 zero. If we find a match, put the time into "then", and the place where it
456 was found into "cache_time". Otherwise, "then" is left at zero. */
458 for (uschar * p = cache_buff; p < cache_buff + cache_size; p = nextp)
460 uschar *s = p + sizeof(time_t);
461 nextp = s + Ustrlen(s) + 1;
462 if (Ustrcmp(to, s) == 0)
464 memcpy(&then, p, sizeof(time_t));
471 /* Use a DBM file for the list of previous recipients. */
475 EXIM_DATUM key_datum, result_datum;
476 uschar * dirname, * s;
478 dirname = (s = Ustrrchr(oncelog, '/'))
479 ? string_copyn(oncelog, s - oncelog) : NULL;
480 EXIM_DBOPEN(oncelog, dirname, O_RDWR|O_CREAT, ob->mode, &dbm_file);
483 addr->transport_return = DEFER;
484 addr->basic_errno = errno;
485 addr->message = string_sprintf("Failed to open %s file %s when sending "
486 "message from %s transport: %s", EXIM_DBTYPE, oncelog, tblock->name,
491 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need datums */
492 EXIM_DATUM_INIT(result_datum); /* to be cleared */
493 EXIM_DATUM_DATA(key_datum) = CS to;
494 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
496 if (EXIM_DBGET(dbm_file, key_datum, result_datum))
498 /* If the datum size is that of a binary time, we are in the new world
499 where messages are sent periodically. Otherwise the file is an old one,
500 where the datum was filled with a tod_log time, which is assumed to be
501 different in size. For that, only one message is ever sent. This change
502 introduced at Exim 3.00. In a couple of years' time the test on the size
505 if (EXIM_DATUM_SIZE(result_datum) == sizeof(time_t))
506 memcpy(&then, EXIM_DATUM_DATA(result_datum), sizeof(time_t));
512 /* Either "then" is set zero, if no message has yet been sent, or it
513 is set to the time of the last sending. */
515 if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
519 if ((m = is_tainted2(logfile, 0, "Tainted '%s' (logfile for %s transport)"
520 " not permitted", logfile, tblock->name)))
522 addr->transport_return = DEFER;
523 addr->basic_errno = EACCES;
528 DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
529 (once_repeat_sec > 0)? " and repeat time not reached" : "");
530 log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
533 uschar *ptr = log_buffer;
534 sprintf(CS ptr, "%s\n previously sent to %.200s\n", tod_stamp(tod_log), to);
536 if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
538 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
539 "transport\n", logfile, tblock->name);
544 DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
545 "no previous message sent to" : "repeat time reached for", to);
548 /* We are going to send a message. Ensure any requested file is available. */
552 if ((m = is_tainted2(file, 0, "Tainted '%s' (file for %s transport)"
553 " not permitted", file, tblock->name)))
555 addr->transport_return = DEFER;
556 addr->basic_errno = EACCES;
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 debug_printf("%s %d: ff\n", __FUNCTION__, __LINE__);
631 while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
635 uschar *s = expand_string(big_buffer);
639 debug_printf("error while expanding line from file:\n %s\n %s\n",
640 big_buffer, expand_string_message);
642 fprintf(fp, "%s", s ? CS s : CS big_buffer);
644 else fprintf(fp, "%s", CS big_buffer);
649 /* Copy the original message if required, observing the return size
650 limit if we are returning the body. */
654 debug_printf("%s %d: ret msg\n", __FUNCTION__, __LINE__);
655 uschar *rubric = tblock->headers_only
656 ? US"------ This is a copy of the message's header lines.\n"
658 ? US"------ This is a copy of the body of the message, without the headers.\n"
659 : US"------ This is a copy of the message, including all the headers.\n";
660 transport_ctx tctx = {
661 .u = {.fd = fileno(fp)},
664 .check_string = NULL,
665 .escape_string = NULL,
666 .options = (tblock->body_only ? topt_no_headers : 0)
667 | (tblock->headers_only ? topt_no_body : 0)
668 | (tblock->return_path_add ? topt_add_return_path : 0)
669 | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
670 | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
674 if (bounce_return_size_limit > 0 && !tblock->headers_only)
677 int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
678 DELIVER_IN_BUFFER_SIZE;
679 if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
682 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
683 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
686 else fprintf(fp, "\n%s\n", rubric);
688 else fprintf(fp, "\n%s\n", rubric);
692 transport_write_message(&tctx, bounce_return_size_limit);
695 /* End the message and wait for the child process to end; no timeout. */
698 rc = child_close(pid, 0);
700 /* Update the "sent to" log whatever the yield. This errs on the side of
701 missing out a message rather than risking sending more than one. We either have
702 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
703 DBM file (or neither, if "once" is not set). */
705 /* Update fixed-size cache file. If cache_time is set, we found a previous
706 entry; that is the spot into which to put the current time. Otherwise we have
707 to add a new record; remove the first one in the file if the file is too big.
708 We always rewrite the entire file in a single write operation. This is
709 (hopefully) going to be the safest thing because there is no interlocking
710 between multiple simultaneous deliveries. */
714 uschar *from = cache_buff;
715 int size = cache_size;
717 if (lseek(cache_fd, 0, SEEK_SET) == 0)
721 cache_time = from + size;
722 memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
725 if (cache_size > 0 && size > ob->once_file_size)
727 from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
728 size -= (from - cache_buff);
732 memcpy(cache_time, &now, sizeof(time_t));
733 if(write(cache_fd, from, size) != size)
734 DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
735 "transport\n", oncelog, tblock->name);
739 /* Update DBM file */
743 EXIM_DATUM key_datum, value_datum;
744 EXIM_DATUM_INIT(key_datum); /* Some DBM libraries need to have */
745 EXIM_DATUM_INIT(value_datum); /* cleared datums. */
746 EXIM_DATUM_DATA(key_datum) = CS to;
747 EXIM_DATUM_SIZE(key_datum) = Ustrlen(to) + 1;
749 /* Many OS define the datum value, sensibly, as a void *. However, there
750 are some which still have char *. By casting this address to a char * we
751 can avoid warning messages from the char * systems. */
753 EXIM_DATUM_DATA(value_datum) = CS (&now);
754 EXIM_DATUM_SIZE(value_datum) = (int)sizeof(time_t);
755 EXIM_DBPUT(dbm_file, key_datum, value_datum);
758 /* If sending failed, defer to try again - but if once is set the next
759 try will skip, of course. However, if there were no recipients in the
760 message, we do not fail. */
763 if (rc == EXIT_NORECIPIENTS)
765 DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
770 addr->transport_return = DEFER;
771 addr->message = string_sprintf("Failed to send message from %s "
772 "transport (%d)", tblock->name, rc);
776 /* Log the sending of the message if successful and required. If the file
777 fails to open, it's hard to know what to do. We cannot write to the Exim
778 log from here, since we may be running under an unprivileged uid. We don't
779 want to fail the delivery, since the message has been successfully sent. For
780 the moment, ignore open failures. Write the log entry as a single write() to a
781 file opened for appending, in order to avoid interleaving of output from
782 different processes. The log_buffer can be used exactly as for main log
787 int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
790 gstring gs = { .size = LOG_BUFFER_SIZE, .ptr = 0, .s = log_buffer }, *g = &gs;
792 /* Use taint-unchecked routines for writing into log_buffer, trusting
793 that we'll never expand it. */
795 DEBUG(D_transport) debug_printf("logging message details\n");
796 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "%s\n", tod_stamp(tod_log));
798 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " From: %s\n", from);
800 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " To: %s\n", to);
802 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Cc: %s\n", cc);
804 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Bcc: %s\n", bcc);
806 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " Subject: %s\n", subject);
808 g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " %s\n", headers);
809 if(write(log_fd, g->s, g->ptr) != g->ptr || close(log_fd))
810 DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
811 "transport\n", logfile, tblock->name);
813 else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
814 "transport: %s\n", logfile, tblock->name, strerror(errno));
818 if (dbm_file) EXIM_DBCLOSE(dbm_file);
819 if (cache_fd > 0) (void)close(cache_fd);
821 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
826 #endif /*!MACRO_PREDEF*/
827 /* End of transport/autoreply.c */