src/src/transports/autoreply.c

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