src/src/transports/autoreply.c

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