src/src/transports/autoreply.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   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 */
   9
  10
  11 #include "../exim.h"
  12
  13 #ifdef TRANSPORT_AUTOREPLY      /* Remainder of file */
  14 #include "autoreply.h"
  15
  16
  17
  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)
  24
  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) },
  44 };
  45
  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. */
  48
  49 int autoreply_transport_options_count =
  50   sizeof(autoreply_transport_options)/sizeof(optionlist);
  51
  52
  53 #ifdef MACRO_PREDEF
  54
  55 /* Dummy values */
  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;}
  59
  60 #else   /*!MACRO_PREDEF*/
  61
  62
  63 /* Default private options block for the autoreply transport.
  64 All non-mentioned lements zero/null/false. */
  65
  66 autoreply_transport_options_block autoreply_transport_option_defaults = {
  67   .mode = 0600,
  68 };
  69
  70
  71
  72 /* Type of text for the checkexpand() function */
  73
  74 enum { cke_text, cke_hdr, cke_file };
  75
  76
  77
  78 /*************************************************
  79 *          Initialization entry point            *
  80 *************************************************/
  81
  82 /* Called for each instance, after its options have been read, to
  83 enable consistency checks to be done, or anything else that needs
  84 to be set up. */
  85
  86 void
  87 autoreply_transport_init(transport_instance *tblock)
  88 {
  89 /*
  90 autoreply_transport_options_block *ob =
  91   (autoreply_transport_options_block *)(tblock->options_block);
  92 */
  93
  94 /* If a fixed uid field is set, then a gid field must also be set. */
  95
  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);
  99 }
 100
 101
 102
 103
 104 /*************************************************
 105 *          Expand string and check               *
 106 *************************************************/
 107
 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.
 111
 112 Arguments:
 113    s         string to expand
 114    addr      address that is being worked on
 115    name      transport name, for error text
 116    type      type, for checking content:
 117                cke_text => no check
 118                cke_hdr  => header, allow \n + whitespace
 119                cke_file => file name, no non-printers allowed
 120
 121 Returns:     expanded string if expansion succeeds;
 122              NULL otherwise
 123 */
 124
 125 static uschar *
 126 checkexpand(uschar *s, address_item *addr, uschar *name, int type)
 127 {
 128 uschar *ss = expand_string(s);
 129
 130 if (!ss)
 131   {
 132   addr->transport_return = FAIL;
 133   addr->message = string_sprintf("Expansion of \"%s\" failed in %s transport: "
 134     "%s", s, name, expand_string_message);
 135   return NULL;
 136   }
 137
 138 if (type != cke_text) for (uschar * t = ss; *t != 0; t++)
 139   {
 140   int c = *t;
 141   const uschar * sp;
 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);
 148   return NULL;
 149   }
 150
 151 return ss;
 152 }
 153
 154
 155
 156
 157 /*************************************************
 158 *          Check a header line for never_mail    *
 159 *************************************************/
 160
 161 /* This is called to check to, cc, and bcc for addresses in the never_mail
 162 list. Any that are found are removed.
 163
 164 Arguments:
 165   list        list of addresses to be checked
 166   never_mail  an address list, already expanded
 167
 168 Returns:      edited replacement address list, or NULL, or original
 169 */
 170
 171 static uschar *
 172 check_never_mail(uschar * list, const uschar * never_mail)
 173 {
 174 rmark reset_point = store_mark();
 175 uschar * newlist = string_copy(list);
 176 uschar * s = newlist;
 177 BOOL hit = FALSE;
 178
 179 while (*s)
 180   {
 181   uschar *error, *next;
 182   uschar *e = parse_find_address_end(s, FALSE);
 183   int terminator = *e;
 184   int start, end, domain, rc;
 185
 186   /* Temporarily terminate the string at the address end while extracting
 187   the operative address within. */
 188
 189   *e = 0;
 190   next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
 191   *e = terminator;
 192
 193   /* If there is some kind of syntax error, just give up on this header
 194   line. */
 195
 196   if (!next) break;
 197
 198   /* See if the address is on the never_mail list */
 199
 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 */
 208
 209   if (rc == OK)                         /* Remove this address */
 210     {
 211     DEBUG(D_transport)
 212       debug_printf("discarding recipient %s (matched never_mail)\n", next);
 213     hit = TRUE;
 214     if (terminator == ',') e++;
 215     memmove(s, e, Ustrlen(e) + 1);
 216     }
 217   else                                  /* Skip over this address */
 218     {
 219     s = e;
 220     if (terminator == ',') s++;
 221     }
 222   }
 223
 224 /* If no addresses were removed, retrieve the memory used and return
 225 the original. */
 226
 227 if (!hit)
 228   {
 229   store_reset(reset_point);
 230   return list;
 231   }
 232
 233 /* Check to see if we removed the last address, leaving a terminating comma
 234 that needs to be removed */
 235
 236 s = newlist + Ustrlen(newlist);
 237 while (s > newlist && (isspace(s[-1]) || s[-1] == ',')) s--;
 238 *s = '\0';
 239
 240 /* Check to see if there any addresses left; if not, return NULL */
 241
 242 s = newlist;
 243 if (Uskip_whitespace(&s))
 244   return newlist;
 245
 246 store_reset(reset_point);
 247 return NULL;
 248 }
 249
 250
 251
 252 /*************************************************
 253 *              Main entry point                  *
 254 *************************************************/
 255
 256 /* See local README for interface details. This transport always returns
 257 FALSE, indicating that the top address has the status for all - though in fact
 258 this transport can handle only one address at at time anyway. */
 259
 260 BOOL
 261 autoreply_transport_entry(
 262   transport_instance *tblock,      /* data for this instantiation */
 263   address_item *addr)              /* address we are working on */
 264 {
 265 int fd, pid, rc;
 266 int cache_fd = -1;
 267 int cache_size = 0;
 268 int add_size = 0;
 269 EXIM_DB * dbm_file = NULL;
 270 BOOL file_expand, return_message;
 271 uschar *from, *reply_to, *to, *cc, *bcc, *subject, *headers, *text, *file;
 272 uschar *logfile, *oncelog;
 273 uschar *cache_buff = NULL;
 274 uschar *cache_time = NULL;
 275 uschar *message_id = NULL;
 276 header_line *h;
 277 time_t now = time(NULL);
 278 time_t once_repeat_sec = 0;
 279 FILE *fp;
 280 FILE *ff = NULL;
 281
 282 autoreply_transport_options_block *ob =
 283   (autoreply_transport_options_block *)(tblock->options_block);
 284
 285 DEBUG(D_transport) debug_printf("%s transport entered\n", tblock->name);
 286
 287 /* Set up for the good case */
 288
 289 addr->transport_return = OK;
 290 addr->basic_errno = 0;
 291
 292 /* If the address is pointing to a reply block, then take all the data
 293 from that block. It has typically been set up by a mail filter processing
 294 router. Otherwise, the data must be supplied by this transport, and
 295 it has to be expanded here. */
 296
 297 if (addr->reply)
 298   {
 299   DEBUG(D_transport) debug_printf("taking data from address\n");
 300   from = addr->reply->from;
 301   reply_to = addr->reply->reply_to;
 302   to = addr->reply->to;
 303   cc = addr->reply->cc;
 304   bcc = addr->reply->bcc;
 305   subject = addr->reply->subject;
 306   headers = addr->reply->headers;
 307   text = addr->reply->text;
 308   file = addr->reply->file;
 309   logfile = addr->reply->logfile;
 310   oncelog = addr->reply->oncelog;
 311   once_repeat_sec = addr->reply->once_repeat;
 312   file_expand = addr->reply->file_expand;
 313   expand_forbid = addr->reply->expand_forbid;
 314   return_message = addr->reply->return_message;
 315   }
 316 else
 317   {
 318   uschar * oncerepeat;
 319
 320   DEBUG(D_transport) debug_printf("taking data from transport\n");
 321   GET_OPTION("once_repeat");    oncerepeat = ob->once_repeat;
 322   GET_OPTION("from");           from = ob->from;
 323   GET_OPTION("reply_to");       reply_to = ob->reply_to;
 324   GET_OPTION("to");             to = ob->to;
 325   GET_OPTION("cc");             cc = ob->cc;
 326   GET_OPTION("bcc");            bcc = ob->bcc;
 327   GET_OPTION("subject");        subject = ob->subject;
 328   GET_OPTION("headers");        headers = ob->headers;
 329   GET_OPTION("text");           text = ob->text;
 330   GET_OPTION("file");           file = ob->file;
 331   GET_OPTION("log");            logfile = ob->logfile;
 332   GET_OPTION("once");           oncelog = ob->oncelog;
 333   file_expand = ob->file_expand;
 334   return_message = ob->return_message;
 335
 336   if (  from && !(from = checkexpand(from, addr, tblock->name, cke_hdr))
 337      || reply_to && !(reply_to = checkexpand(reply_to, addr, tblock->name, cke_hdr))
 338      || to && !(to = checkexpand(to, addr, tblock->name, cke_hdr))
 339      || cc && !(cc = checkexpand(cc, addr, tblock->name, cke_hdr))
 340      || bcc && !(bcc = checkexpand(bcc, addr, tblock->name, cke_hdr))
 341      || subject && !(subject = checkexpand(subject, addr, tblock->name, cke_hdr))
 342      || headers && !(headers = checkexpand(headers, addr, tblock->name, cke_text))
 343      || text && !(text = checkexpand(text, addr, tblock->name, cke_text))
 344      || file && !(file = checkexpand(file, addr, tblock->name, cke_file))
 345      || logfile && !(logfile = checkexpand(logfile, addr, tblock->name, cke_file))
 346      || oncelog && !(oncelog = checkexpand(oncelog, addr, tblock->name, cke_file))
 347      || oncerepeat && !(oncerepeat = checkexpand(oncerepeat, addr, tblock->name, cke_file))
 348      )
 349     return FALSE;
 350
 351   if (oncerepeat)
 352     if ((once_repeat_sec = readconf_readtime(oncerepeat, 0, FALSE)) < 0)
 353       {
 354       addr->transport_return = FAIL;
 355       addr->message = string_sprintf("Invalid time value \"%s\" for "
 356         "\"once_repeat\" in %s transport", oncerepeat, tblock->name);
 357       return FALSE;
 358       }
 359   }
 360
 361 /* If the never_mail option is set, we have to scan all the recipients and
 362 remove those that match. */
 363
 364 if (ob->never_mail)
 365   {
 366   const uschar *never_mail = expand_string(ob->never_mail);
 367
 368   if (!never_mail)
 369     {
 370     addr->transport_return = FAIL;
 371     addr->message = string_sprintf("Failed to expand \"%s\" for "
 372       "\"never_mail\" in %s transport", ob->never_mail, tblock->name);
 373     return FALSE;
 374     }
 375
 376   if (to) to = check_never_mail(to, never_mail);
 377   if (cc) cc = check_never_mail(cc, never_mail);
 378   if (bcc) bcc = check_never_mail(bcc, never_mail);
 379
 380   if (!to && !cc && !bcc)
 381     {
 382     DEBUG(D_transport)
 383       debug_printf("*** all recipients removed by never_mail\n");
 384     return OK;
 385     }
 386   }
 387
 388 /* If the -N option is set, can't do any more. */
 389
 390 if (f.dont_deliver)
 391   {
 392   DEBUG(D_transport)
 393     debug_printf("*** delivery by %s transport bypassed by -N option\n",
 394       tblock->name);
 395   return FALSE;
 396   }
 397
 398
 399 /* If the oncelog field is set, we send want to send only one message to the
 400 given recipient(s). This works only on the "To" field. If there is no "To"
 401 field, the message is always sent. If the To: field contains more than one
 402 recipient, the effect might not be quite as envisaged. If once_file_size is
 403 set, instead of a dbm file, we use a regular file containing a circular buffer
 404 recipient cache. */
 405
 406 if (oncelog && *oncelog && to)
 407   {
 408   time_t then = 0;
 409
 410   if (is_tainted(oncelog))
 411     {
 412     addr->transport_return = DEFER;
 413     addr->basic_errno = EACCES;
 414     addr->message = string_sprintf("Tainted '%s' (once file for %s transport)"
 415       " not permitted", oncelog, tblock->name);
 416     goto END_OFF;
 417     }
 418
 419   /* Handle fixed-size cache file. */
 420
 421   if (ob->once_file_size > 0)
 422     {
 423     uschar * nextp;
 424     struct stat statbuf;
 425
 426     cache_fd = Uopen(oncelog, O_CREAT|O_RDWR, ob->mode);
 427     if (cache_fd < 0 || fstat(cache_fd, &statbuf) != 0)
 428       {
 429       addr->transport_return = DEFER;
 430       addr->basic_errno = errno;
 431       addr->message = string_sprintf("Failed to %s \"once\" file %s when "
 432         "sending message from %s transport: %s",
 433         cache_fd < 0 ? "open" : "stat", oncelog, tblock->name, strerror(errno));
 434       goto END_OFF;
 435       }
 436
 437     /* Get store in the temporary pool and read the entire file into it. We get
 438     an amount of store that is big enough to add the new entry on the end if we
 439     need to do that. */
 440
 441     cache_size = statbuf.st_size;
 442     add_size = sizeof(time_t) + Ustrlen(to) + 1;
 443     cache_buff = store_get(cache_size + add_size, oncelog);
 444
 445     if (read(cache_fd, cache_buff, cache_size) != cache_size)
 446       {
 447       addr->transport_return = DEFER;
 448       addr->basic_errno = errno;
 449       addr->message = US"error while reading \"once\" file";
 450       goto END_OFF;
 451       }
 452
 453     DEBUG(D_transport) debug_printf("%d bytes read from %s\n", cache_size, oncelog);
 454
 455     /* Scan the data for this recipient. Each entry in the file starts with
 456     a time_t sized time value, followed by the address, followed by a binary
 457     zero. If we find a match, put the time into "then", and the place where it
 458     was found into "cache_time". Otherwise, "then" is left at zero. */
 459
 460     for (uschar * p = cache_buff; p < cache_buff + cache_size; p = nextp)
 461       {
 462       uschar *s = p + sizeof(time_t);
 463       nextp = s + Ustrlen(s) + 1;
 464       if (Ustrcmp(to, s) == 0)
 465         {
 466         memcpy(&then, p, sizeof(time_t));
 467         cache_time = p;
 468         break;
 469         }
 470       }
 471     }
 472
 473   /* Use a DBM file for the list of previous recipients. */
 474
 475   else
 476     {
 477     EXIM_DATUM key_datum, result_datum;
 478     uschar * s = Ustrrchr(oncelog, '/');
 479     uschar * dirname = s ? string_copyn(oncelog, s - oncelog) : NULL;
 480
 481     if (!(dbm_file = exim_dbopen(oncelog, dirname, O_RDWR|O_CREAT, ob->mode)))
 482       {
 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,
 487         strerror(errno));
 488       goto END_OFF;
 489       }
 490
 491     exim_datum_init(&key_datum);        /* Some DBM libraries need datums */
 492     exim_datum_init(&result_datum);     /* to be cleared */
 493     exim_datum_data_set(&key_datum, (void *) to);
 494     exim_datum_size_set(&key_datum, Ustrlen(to) + 1);
 495
 496     if (exim_dbget(dbm_file, &key_datum, &result_datum))
 497       memcpy(&then, exim_datum_data_get(&result_datum), sizeof(time_t));
 498     }
 499
 500   /* Either "then" is set zero, if no message has yet been sent, or it
 501   is set to the time of the last sending. */
 502
 503   if (then != 0 && (once_repeat_sec <= 0 || now - then < once_repeat_sec))
 504     {
 505     int log_fd;
 506     if (is_tainted(logfile))
 507       {
 508       addr->transport_return = DEFER;
 509       addr->basic_errno = EACCES;
 510       addr->message = string_sprintf("Tainted '%s' (logfile for %s transport)"
 511         " not permitted", logfile, tblock->name);
 512       goto END_OFF;
 513       }
 514
 515     DEBUG(D_transport) debug_printf("message previously sent to %s%s\n", to,
 516       (once_repeat_sec > 0)? " and repeat time not reached" : "");
 517     log_fd = logfile ? Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode) : -1;
 518     if (log_fd >= 0)
 519       {
 520       uschar *ptr = log_buffer;
 521       sprintf(CS ptr, "%s\n  previously sent to %.200s\n", tod_stamp(tod_log), to);
 522       while(*ptr) ptr++;
 523       if(write(log_fd, log_buffer, ptr - log_buffer) != ptr-log_buffer
 524         || close(log_fd))
 525         DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 526           "transport\n", logfile, tblock->name);
 527       }
 528     goto END_OFF;
 529     }
 530
 531   DEBUG(D_transport) debug_printf("%s %s\n", (then <= 0)?
 532     "no previous message sent to" : "repeat time reached for", to);
 533   }
 534
 535 /* We are going to send a message. Ensure any requested file is available. */
 536 if (file)
 537   {
 538   if (is_tainted(file))
 539     {
 540     addr->transport_return = DEFER;
 541     addr->basic_errno = EACCES;
 542     addr->message = string_sprintf("Tainted '%s' (file for %s transport)"
 543       " not permitted", file, tblock->name);
 544     return FALSE;
 545     }
 546   if (!(ff = Ufopen(file, "rb")) && !ob->file_optional)
 547     {
 548     addr->transport_return = DEFER;
 549     addr->basic_errno = errno;
 550     addr->message = string_sprintf("Failed to open file %s when sending "
 551       "message from %s transport: %s", file, tblock->name, strerror(errno));
 552     return FALSE;
 553     }
 554   }
 555
 556 /* Make a subprocess to send the message */
 557
 558 if ((pid = child_open_exim(&fd, US"autoreply")) < 0)
 559   {
 560   /* Creation of child failed; defer this delivery. */
 561
 562   addr->transport_return = DEFER;
 563   addr->basic_errno = errno;
 564   addr->message = string_sprintf("Failed to create child process to send "
 565     "message from %s transport: %s", tblock->name, strerror(errno));
 566   DEBUG(D_transport) debug_printf("%s\n", addr->message);
 567   if (dbm_file) exim_dbclose(dbm_file);
 568   return FALSE;
 569   }
 570
 571 /* Create the message to be sent - recipients are taken from the headers,
 572 as the -t option is used. The "headers" stuff *must* be last in case there
 573 are newlines in it which might, if placed earlier, screw up other headers. */
 574
 575 fp = fdopen(fd, "wb");
 576
 577 if (from) fprintf(fp, "From: %s\n", from);
 578 if (reply_to) fprintf(fp, "Reply-To: %s\n", reply_to);
 579 if (to) fprintf(fp, "To: %s\n", to);
 580 if (cc) fprintf(fp, "Cc: %s\n", cc);
 581 if (bcc) fprintf(fp, "Bcc: %s\n", bcc);
 582 if (subject) fprintf(fp, "Subject: %s\n", subject);
 583
 584 /* Generate In-Reply-To from the message_id header; there should
 585 always be one, but code defensively. */
 586
 587 for (h = header_list; h; h = h->next)
 588   if (h->type == htype_id) break;
 589
 590 if (h)
 591   {
 592   message_id = Ustrchr(h->text, ':') + 1;
 593   Uskip_whitespace(&message_id);
 594   fprintf(fp, "In-Reply-To: %s", message_id);
 595   }
 596
 597 moan_write_references(fp, message_id);
 598
 599 /* Add an Auto-Submitted: header */
 600
 601 fprintf(fp, "Auto-Submitted: auto-replied\n");
 602
 603 /* Add any specially requested headers */
 604
 605 if (headers) fprintf(fp, "%s\n", headers);
 606 fprintf(fp, "\n");
 607
 608 if (text)
 609   {
 610   fprintf(fp, "%s", CS text);
 611   if (text[Ustrlen(text)-1] != '\n') fprintf(fp, "\n");
 612   }
 613
 614 if (ff)
 615   {
 616   while (Ufgets(big_buffer, big_buffer_size, ff) != NULL)
 617     {
 618     if (file_expand)
 619       {
 620       uschar *s = expand_string(big_buffer);
 621       DEBUG(D_transport)
 622         {
 623         if (!s)
 624           debug_printf("error while expanding line from file:\n  %s\n  %s\n",
 625             big_buffer, expand_string_message);
 626         }
 627       fprintf(fp, "%s", s ? CS s : CS big_buffer);
 628       }
 629     else fprintf(fp, "%s", CS big_buffer);
 630     }
 631   (void) fclose(ff);
 632   }
 633
 634 /* Copy the original message if required, observing the return size
 635 limit if we are returning the body. */
 636
 637 if (return_message)
 638   {
 639   uschar *rubric = tblock->headers_only
 640     ? US"------ This is a copy of the message's header lines.\n"
 641     : tblock->body_only
 642     ? US"------ This is a copy of the body of the message, without the headers.\n"
 643     : US"------ This is a copy of the message, including all the headers.\n";
 644   transport_ctx tctx = {
 645     .u = {.fd = fileno(fp)},
 646     .tblock = tblock,
 647     .addr = addr,
 648     .check_string = NULL,
 649     .escape_string =  NULL,
 650     .options = (tblock->body_only ? topt_no_headers : 0)
 651         | (tblock->headers_only ? topt_no_body : 0)
 652         | (tblock->return_path_add ? topt_add_return_path : 0)
 653         | (tblock->delivery_date_add ? topt_add_delivery_date : 0)
 654         | (tblock->envelope_to_add ? topt_add_envelope_to : 0)
 655         | topt_not_socket
 656   };
 657
 658   if (bounce_return_size_limit > 0 && !tblock->headers_only)
 659     {
 660     struct stat statbuf;
 661     int max = (bounce_return_size_limit/DELIVER_IN_BUFFER_SIZE + 1) *
 662       DELIVER_IN_BUFFER_SIZE;
 663     if (fstat(deliver_datafile, &statbuf) == 0 && statbuf.st_size > max)
 664       {
 665       fprintf(fp, "\n%s"
 666 "------ The body of the message is " OFF_T_FMT " characters long; only the first\n"
 667 "------ %d or so are included here.\n\n", rubric, statbuf.st_size,
 668         (max/1000)*1000);
 669       }
 670     else fprintf(fp, "\n%s\n", rubric);
 671     }
 672   else fprintf(fp, "\n%s\n", rubric);
 673
 674   fflush(fp);
 675   transport_count = 0;
 676   transport_write_message(&tctx, bounce_return_size_limit);
 677   }
 678
 679 /* End the message and wait for the child process to end; no timeout. */
 680
 681 (void)fclose(fp);
 682 rc = child_close(pid, 0);
 683
 684 /* Update the "sent to" log whatever the yield. This errs on the side of
 685 missing out a message rather than risking sending more than one. We either have
 686 cache_fd set to a fixed size, circular buffer file, or dbm_file set to an open
 687 DBM file (or neither, if "once" is not set). */
 688
 689 /* Update fixed-size cache file. If cache_time is set, we found a previous
 690 entry; that is the spot into which to put the current time. Otherwise we have
 691 to add a new record; remove the first one in the file if the file is too big.
 692 We always rewrite the entire file in a single write operation. This is
 693 (hopefully) going to be the safest thing because there is no interlocking
 694 between multiple simultaneous deliveries. */
 695
 696 if (cache_fd >= 0)
 697   {
 698   uschar *from = cache_buff;
 699   int size = cache_size;
 700
 701   if (lseek(cache_fd, 0, SEEK_SET) == 0)
 702     {
 703     if (!cache_time)
 704       {
 705       cache_time = from + size;
 706       memcpy(cache_time + sizeof(time_t), to, add_size - sizeof(time_t));
 707       size += add_size;
 708
 709       if (cache_size > 0 && size > ob->once_file_size)
 710         {
 711         from += sizeof(time_t) + Ustrlen(from + sizeof(time_t)) + 1;
 712         size -= (from - cache_buff);
 713         }
 714       }
 715
 716     memcpy(cache_time, &now, sizeof(time_t));
 717     if(write(cache_fd, from, size) != size)
 718       DEBUG(D_transport) debug_printf("Problem writing cache file %s for %s "
 719         "transport\n", oncelog, tblock->name);
 720     }
 721   }
 722
 723 /* Update DBM file */
 724
 725 else if (dbm_file)
 726   {
 727   EXIM_DATUM key_datum, value_datum;
 728   exim_datum_init(&key_datum);          /* Some DBM libraries need to have */
 729   exim_datum_init(&value_datum);        /* cleared datums. */
 730   exim_datum_data_set(&key_datum, to);
 731   exim_datum_size_set(&key_datum, Ustrlen(to) + 1);
 732
 733   /* Many OS define the datum value, sensibly, as a void *. However, there
 734   are some which still have char *. By casting this address to a char * we
 735   can avoid warning messages from the char * systems. */
 736
 737   exim_datum_data_set(&value_datum, &now);
 738   exim_datum_size_set(&value_datum, sizeof(time_t));
 739   exim_dbput(dbm_file, &key_datum, &value_datum);
 740   }
 741
 742 /* If sending failed, defer to try again - but if once is set the next
 743 try will skip, of course. However, if there were no recipients in the
 744 message, we do not fail. */
 745
 746 if (rc != 0)
 747   if (rc == EXIT_NORECIPIENTS)
 748     {
 749     DEBUG(D_any) debug_printf("%s transport: message contained no recipients\n",
 750       tblock->name);
 751     }
 752   else
 753     {
 754     addr->transport_return = DEFER;
 755     addr->message = string_sprintf("Failed to send message from %s "
 756       "transport (%d)", tblock->name, rc);
 757     goto END_OFF;
 758     }
 759
 760 /* Log the sending of the message if successful and required. If the file
 761 fails to open, it's hard to know what to do. We cannot write to the Exim
 762 log from here, since we may be running under an unprivileged uid. We don't
 763 want to fail the delivery, since the message has been successfully sent. For
 764 the moment, ignore open failures. Write the log entry as a single write() to a
 765 file opened for appending, in order to avoid interleaving of output from
 766 different processes. The log_buffer can be used exactly as for main log
 767 writing. */
 768
 769 if (logfile)
 770   {
 771   int log_fd = Uopen(logfile, O_WRONLY|O_APPEND|O_CREAT, ob->mode);
 772   if (log_fd >= 0)
 773     {
 774     gstring gs = { .size = LOG_BUFFER_SIZE, .ptr = 0, .s = log_buffer }, *g = &gs;
 775
 776     /* Use taint-unchecked routines for writing into log_buffer, trusting
 777     that we'll never expand it. */
 778
 779     DEBUG(D_transport) debug_printf("logging message details\n");
 780     g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "%s\n", tod_stamp(tod_log));
 781     if (from)
 782       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  From: %s\n", from);
 783     if (to)
 784       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  To: %s\n", to);
 785     if (cc)
 786       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  Cc: %s\n", cc);
 787     if (bcc)
 788       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  Bcc: %s\n", bcc);
 789     if (subject)
 790       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  Subject: %s\n", subject);
 791     if (headers)
 792       g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "  %s\n", headers);
 793     if(write(log_fd, g->s, g->ptr) != g->ptr || close(log_fd))
 794       DEBUG(D_transport) debug_printf("Problem writing log file %s for %s "
 795         "transport\n", logfile, tblock->name);
 796     }
 797   else DEBUG(D_transport) debug_printf("Failed to open log file %s for %s "
 798     "transport: %s\n", logfile, tblock->name, strerror(errno));
 799   }
 800
 801 END_OFF:
 802 if (dbm_file) exim_dbclose(dbm_file);
 803 if (cache_fd > 0) (void)close(cache_fd);
 804
 805 DEBUG(D_transport) debug_printf("%s transport succeeded\n", tblock->name);
 806
 807 return FALSE;
 808 }
 809
 810 #endif  /*!MACRO_PREDEF*/
 811 #endif  /*TRANSPORT_AUTOREPOL*/
 812 /* End of transport/autoreply.c */
 813 /* vi: aw ai sw=2
 814 */