src/src/spool_in.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 /* Functions for reading spool files. When compiling for a utility (eximon),
  11 not all are needed, and some functionality can be cut out. */
  12
  13
  14 #include "exim.h"
  15
  16
  17
  18 #ifndef COMPILE_UTILITY
  19 /*************************************************
  20 *           Open and lock data file              *
  21 *************************************************/
  22
  23 /* The data file is the one that is used for locking, because the header file
  24 can get replaced during delivery because of header rewriting. The file has
  25 to opened with write access so that we can get an exclusive lock, but in
  26 fact it won't be written to. Just in case there's a major disaster (e.g.
  27 overwriting some other file descriptor with the value of this one), open it
  28 with append.
  29
  30 As called by deliver_message() (at least) we are operating as root.
  31
  32 Argument: the id of the message
  33 Returns:  fd if file successfully opened and locked, else -1
  34
  35 Side effect: message_subdir is set for the (possibly split) spool directory
  36 */
  37
  38 int
  39 spool_open_datafile(uschar *id)
  40 {
  41 struct stat statbuf;
  42 flock_t lock_data;
  43 int fd;
  44
  45 /* If split_spool_directory is set, first look for the file in the appropriate
  46 sub-directory of the input directory. If it is not found there, try the input
  47 directory itself, to pick up leftovers from before the splitting. If split_
  48 spool_directory is not set, first look in the main input directory. If it is
  49 not found there, try the split sub-directory, in case it is left over from a
  50 splitting state. */
  51
  52 for (int i = 0; i < 2; i++)
  53   {
  54   uschar * fname;
  55   int save_errno;
  56
  57   set_subdir_str(message_subdir, id, i);
  58   fname = spool_fname(US"input", message_subdir, id, US"-D");
  59   DEBUG(D_deliver) debug_printf_indent("Trying spool file %s\n", fname);
  60
  61   /* We protect against symlink attacks both in not propagating the
  62    * file-descriptor to other processes as we exec, and also ensuring that we
  63    * don't even open symlinks.
  64    * No -D file inside the spool area should be a symlink.
  65    */
  66   if ((fd = Uopen(fname,
  67 #ifdef O_CLOEXEC
  68                       O_CLOEXEC |
  69 #endif
  70 #ifdef O_NOFOLLOW
  71                       O_NOFOLLOW |
  72 #endif
  73                       O_RDWR | O_APPEND, 0)) >= 0)
  74     break;
  75   save_errno = errno;
  76   if (errno == ENOENT)
  77     {
  78     if (i == 0) continue;
  79     if (!f.queue_running)
  80       log_write(0, LOG_MAIN, "Spool%s%s file %s-D not found",
  81         *queue_name ? US" Q=" : US"",
  82         *queue_name ? queue_name : US"",
  83         id);
  84     }
  85   else
  86     log_write(0, LOG_MAIN, "Spool error for %s: %s", fname, strerror(errno));
  87   errno = save_errno;
  88   return -1;
  89   }
  90
  91 /* File is open and message_subdir is set. Set the close-on-exec flag, and lock
  92 the file. We lock only the first line of the file (containing the message ID)
  93 because this apparently is needed for running Exim under Cygwin. If the entire
  94 file is locked in one process, a sub-process cannot access it, even when passed
  95 an open file descriptor (at least, I think that's the Cygwin story). On real
  96 Unix systems it doesn't make any difference as long as Exim is consistent in
  97 what it locks. */
  98
  99 #ifndef O_CLOEXEC
 100 (void)fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
 101 #endif
 102
 103 lock_data.l_type = F_WRLCK;
 104 lock_data.l_whence = SEEK_SET;
 105 lock_data.l_start = 0;
 106 lock_data.l_len = SPOOL_DATA_START_OFFSET;
 107
 108 if (fcntl(fd, F_SETLK, &lock_data) < 0)
 109   {
 110   log_write(L_skip_delivery, LOG_MAIN,
 111       "Spool file for %s is locked (another process is handling this message)",
 112       id);
 113   (void)close(fd);
 114   errno = 0;
 115   return -1;
 116   }
 117
 118 /* Get the size of the data; don't include the leading filename line
 119 in the count, but add one for the newline before the data. */
 120
 121 if (fstat(fd, &statbuf) == 0)
 122   {
 123   message_body_size = statbuf.st_size - SPOOL_DATA_START_OFFSET;
 124   message_size = message_body_size + 1;
 125   }
 126
 127 return fd;
 128 }
 129 #endif  /* COMPILE_UTILITY */
 130
 131
 132
 133 /*************************************************
 134 *    Read non-recipients tree from spool file    *
 135 *************************************************/
 136
 137 /* The tree of non-recipients is written to the spool file in a form that
 138 makes it easy to read back into a tree. The format is as follows:
 139
 140    . Each node is preceded by two letter(Y/N) indicating whether it has left
 141      or right children. There's one space after the two flags, before the name.
 142
 143    . The left subtree (if any) then follows, then the right subtree (if any).
 144
 145 This function is entered with the next input line in the buffer. Note we must
 146 save the right flag before recursing with the same buffer.
 147
 148 Once the tree is read, we re-construct the balance fields by scanning the tree.
 149 I forgot to write them out originally, and the compatible fix is to do it this
 150 way. This initial local recursing function does the necessary.
 151
 152 Arguments:
 153   node      tree node
 154
 155 Returns:    maximum depth below the node, including the node itself
 156 */
 157
 158 static int
 159 count_below(tree_node *node)
 160 {
 161 int nleft, nright;
 162 if (node == NULL) return 0;
 163 nleft = count_below(node->left);
 164 nright = count_below(node->right);
 165 node->balance = (nleft > nright)? 1 : ((nright > nleft)? 2 : 0);
 166 return 1 + ((nleft > nright)? nleft : nright);
 167 }
 168
 169 /* This is the real function...
 170
 171 Arguments:
 172   connect      pointer to the root of the tree
 173   f            FILE to read data from
 174   buffer       contains next input line; further lines read into it
 175   buffer_size  size of the buffer
 176
 177 Returns:       FALSE on format error
 178 */
 179
 180 static BOOL
 181 read_nonrecipients_tree(tree_node **connect, FILE *f, uschar *buffer,
 182   int buffer_size)
 183 {
 184 tree_node *node;
 185 int n = Ustrlen(buffer);
 186 BOOL right = buffer[1] == 'Y';
 187
 188 if (n < 5) return FALSE;    /* malformed line */
 189 buffer[n-1] = 0;            /* Remove \n */
 190 node = store_get(sizeof(tree_node) + n - 3, GET_TAINTED);       /* rcpt names tainted */
 191 *connect = node;
 192 Ustrcpy(node->name, buffer + 3);
 193 node->data.ptr = NULL;
 194
 195 if (buffer[0] == 'Y')
 196   {
 197   if (Ufgets(buffer, buffer_size, f) == NULL ||
 198     !read_nonrecipients_tree(&node->left, f, buffer, buffer_size))
 199       return FALSE;
 200   }
 201 else node->left = NULL;
 202
 203 if (right)
 204   {
 205   if (Ufgets(buffer, buffer_size, f) == NULL ||
 206     !read_nonrecipients_tree(&node->right, f, buffer, buffer_size))
 207       return FALSE;
 208   }
 209 else node->right = NULL;
 210
 211 (void) count_below(*connect);
 212 return TRUE;
 213 }
 214
 215
 216
 217
 218 /* Reset all the global variables to their default values. However, there is
 219 one exception. DO NOT change the default value of dont_deliver, because it may
 220 be forced by an external setting. */
 221
 222 void
 223 spool_clear_header_globals(void)
 224 {
 225 acl_var_c = acl_var_m = NULL;
 226 authenticated_id = NULL;
 227 authenticated_sender = NULL;
 228 f.allow_unqualified_recipient = FALSE;
 229 f.allow_unqualified_sender = FALSE;
 230 body_linecount = 0;
 231 body_zerocount = 0;
 232 f.deliver_firsttime = FALSE;
 233 f.deliver_freeze = FALSE;
 234 deliver_frozen_at = 0;
 235 f.deliver_manual_thaw = FALSE;
 236 /* f.dont_deliver must NOT be reset */
 237 header_list = header_last = NULL;
 238 host_lookup_deferred = FALSE;
 239 host_lookup_failed = FALSE;
 240 interface_address = NULL;
 241 interface_port = 0;
 242 f.local_error_message = FALSE;
 243 #ifdef HAVE_LOCAL_SCAN
 244 local_scan_data = NULL;
 245 #endif
 246 max_received_linelength = 0;
 247 message_linecount = 0;
 248 received_protocol = NULL;
 249 received_count = 0;
 250 recipients_list = NULL;
 251 sender_address = NULL;
 252 sender_fullhost = NULL;
 253 sender_helo_name = NULL;
 254 sender_host_address = NULL;
 255 sender_host_name = NULL;
 256 sender_host_port = 0;
 257 sender_host_authenticated = sender_host_auth_pubname = NULL;
 258 sender_ident = NULL;
 259 f.sender_local = FALSE;
 260 f.sender_set_untrusted = FALSE;
 261 smtp_active_hostname = primary_hostname;
 262 #ifndef COMPILE_UTILITY
 263 f.spool_file_wireformat = FALSE;
 264 #endif
 265 tree_nonrecipients = NULL;
 266
 267 #ifdef EXPERIMENTAL_BRIGHTMAIL
 268 bmi_run = 0;
 269 bmi_verdicts = NULL;
 270 #endif
 271
 272 #ifndef DISABLE_DKIM
 273 dkim_signers = NULL;
 274 f.dkim_disable_verify = FALSE;
 275 dkim_collect_input = 0;
 276 #endif
 277
 278 #ifndef DISABLE_TLS
 279 tls_in.certificate_verified = FALSE;
 280 # ifdef SUPPORT_DANE
 281 tls_in.dane_verified = FALSE;
 282 # endif
 283 tls_in.ver = tls_in.cipher = NULL;
 284 # ifndef COMPILE_UTILITY        /* tls support fns not built in */
 285 tls_free_cert(&tls_in.ourcert);
 286 tls_free_cert(&tls_in.peercert);
 287 # endif
 288 tls_in.peerdn = NULL;
 289 tls_in.sni = NULL;
 290 tls_in.ocsp = OCSP_NOT_REQ;
 291 #endif
 292
 293 #ifdef WITH_CONTENT_SCAN
 294 spam_bar = NULL;
 295 spam_score = NULL;
 296 spam_score_int = NULL;
 297 #endif
 298
 299 #if defined(SUPPORT_I18N) && !defined(COMPILE_UTILITY)
 300 message_smtputf8 = FALSE;
 301 message_utf8_downconvert = 0;
 302 #endif
 303
 304 #ifndef COMPILE_UTILITY
 305 debuglog_name[0] = '\0';
 306 #endif
 307 dsn_ret = 0;
 308 dsn_envid = NULL;
 309 }
 310
 311 static void *
 312 fgets_big_buffer(FILE *fp)
 313 {
 314 int len = 0;
 315
 316 big_buffer[0] = 0;
 317 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) return NULL;
 318
 319 while ((len = Ustrlen(big_buffer)) == big_buffer_size-1
 320       && big_buffer[len-1] != '\n')
 321   {
 322   uschar *newbuffer;
 323   int newsize;
 324
 325   if (big_buffer_size >= BIG_BUFFER_SIZE * 4) return NULL;
 326   newsize = big_buffer_size * 2;
 327   newbuffer = store_get_perm(newsize, FALSE);
 328   memcpy(newbuffer, big_buffer, len);
 329
 330   big_buffer = newbuffer;
 331   big_buffer_size = newsize;
 332   if (Ufgets(big_buffer + len, big_buffer_size - len, fp) == NULL) return NULL;
 333   }
 334
 335 if (len <= 0 || big_buffer[len-1] != '\n') return NULL;
 336 return big_buffer;
 337 }
 338
 339
 340
 341 /*************************************************
 342 *             Read spool header file             *
 343 *************************************************/
 344
 345 /* This function reads a spool header file and places the data into the
 346 appropriate global variables. The header portion is always read, but header
 347 structures are built only if read_headers is set true. It isn't, for example,
 348 while generating -bp output.
 349
 350 It may be possible for blocks of nulls (binary zeroes) to get written on the
 351 end of a file if there is a system crash during writing. It was observed on an
 352 earlier version of Exim that omitted to fsync() the files - this is thought to
 353 have been the cause of that incident, but in any case, this code must be robust
 354 against such an event, and if such a file is encountered, it must be treated as
 355 malformed.
 356
 357 As called from deliver_message() (at least) we are running as root.
 358
 359 Arguments:
 360   name          name of the header file, including the -H
 361   read_headers  TRUE if in-store header structures are to be built
 362   subdir_set    TRUE is message_subdir is already set
 363
 364 Returns:        spool_read_OK        success
 365                 spool_read_notopen   open failed
 366                 spool_read_enverror  error in the envelope portion
 367                 spool_read_hdrerror  error in the header portion
 368 */
 369
 370 int
 371 spool_read_header(uschar *name, BOOL read_headers, BOOL subdir_set)
 372 {
 373 FILE * fp = NULL;
 374 int n;
 375 int rcount = 0;
 376 long int uid, gid;
 377 BOOL inheader = FALSE;
 378
 379 /* Reset all the global variables to their default values. However, there is
 380 one exception. DO NOT change the default value of dont_deliver, because it may
 381 be forced by an external setting. */
 382
 383 spool_clear_header_globals();
 384
 385 /* Generate the full name and open the file. If message_subdir is already
 386 set, just look in the given directory. Otherwise, look in both the split
 387 and unsplit directories, as for the data file above. */
 388
 389 for (int n = 0; n < 2; n++)
 390   {
 391   if (!subdir_set)
 392     set_subdir_str(message_subdir, name, n);
 393
 394   if ((fp = Ufopen(spool_fname(US"input", message_subdir, name, US""), "rb")))
 395     break;
 396   if (n != 0 || subdir_set || errno != ENOENT)
 397     return spool_read_notopen;
 398   }
 399
 400 errno = 0;
 401
 402 #ifndef COMPILE_UTILITY
 403 DEBUG(D_deliver) debug_printf_indent("reading spool file %s\n", name);
 404 #endif  /* COMPILE_UTILITY */
 405
 406 /* The first line of a spool file contains the message id followed by -H (i.e.
 407 the file name), in order to make the file self-identifying. */
 408
 409 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 410 if (Ustrlen(big_buffer) != MESSAGE_ID_LENGTH + 3 ||
 411     Ustrncmp(big_buffer, name, MESSAGE_ID_LENGTH + 2) != 0)
 412   goto SPOOL_FORMAT_ERROR;
 413
 414 /* The next three lines in the header file are in a fixed format. The first
 415 contains the login, uid, and gid of the user who caused the file to be written.
 416 There are known cases where a negative gid is used, so we allow for both
 417 negative uids and gids. The second contains the mail address of the message's
 418 sender, enclosed in <>. The third contains the time the message was received,
 419 and the number of warning messages for delivery delays that have been sent. */
 420
 421 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 422
 423  {
 424   uschar *p = big_buffer + Ustrlen(big_buffer);
 425   while (p > big_buffer && isspace(p[-1])) p--;
 426   *p = 0;
 427   if (!isdigit(p[-1])) goto SPOOL_FORMAT_ERROR;
 428   while (p > big_buffer && (isdigit(p[-1]) || '-' == p[-1])) p--;
 429   gid = Uatoi(p);
 430   if (p <= big_buffer || *(--p) != ' ') goto SPOOL_FORMAT_ERROR;
 431   *p = 0;
 432   if (!isdigit(p[-1])) goto SPOOL_FORMAT_ERROR;
 433   while (p > big_buffer && (isdigit(p[-1]) || '-' == p[-1])) p--;
 434   uid = Uatoi(p);
 435   if (p <= big_buffer || *(--p) != ' ') goto SPOOL_FORMAT_ERROR;
 436   *p = 0;
 437  }
 438
 439 originator_login = string_copy(big_buffer);
 440 originator_uid = (uid_t)uid;
 441 originator_gid = (gid_t)gid;
 442
 443 /* envelope from */
 444 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 445 n = Ustrlen(big_buffer);
 446 if (n < 3 || big_buffer[0] != '<' || big_buffer[n-2] != '>')
 447   goto SPOOL_FORMAT_ERROR;
 448
 449 sender_address = store_get(n-2, GET_TAINTED);
 450 Ustrncpy(sender_address, big_buffer+1, n-3);
 451 sender_address[n-3] = 0;
 452
 453 /* time */
 454 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 455 if (sscanf(CS big_buffer, TIME_T_FMT " %d", &received_time.tv_sec, &warning_count) != 2)
 456   goto SPOOL_FORMAT_ERROR;
 457 received_time.tv_usec = 0;
 458 received_time_complete = received_time;
 459
 460
 461 message_age = time(NULL) - received_time.tv_sec;
 462 #ifndef COMPILE_UTILITY
 463 if (f.running_in_test_harness)
 464   message_age = test_harness_fudged_queue_time(message_age);
 465 #endif
 466
 467 #ifndef COMPILE_UTILITY
 468 DEBUG(D_deliver) debug_printf_indent("user=%s uid=%ld gid=%ld sender=%s\n",
 469   originator_login, (long int)originator_uid, (long int)originator_gid,
 470   sender_address);
 471 #endif
 472
 473 /* Now there may be a number of optional lines, each starting with "-". If you
 474 add a new setting here, make sure you set the default above.
 475
 476 Because there are now quite a number of different possibilities, we use a
 477 switch on the first character to avoid too many failing tests. Thanks to Nico
 478 Erfurth for the patch that implemented this. I have made it even more efficient
 479 by not re-scanning the first two characters.
 480
 481 To allow new versions of Exim that add additional flags to interwork with older
 482 versions that do not understand them, just ignore any lines starting with "-"
 483 that we don't recognize. Otherwise it wouldn't be possible to back off a new
 484 version that left new-style flags written on the spool.
 485
 486 If the line starts with "--" the content of the variable is tainted.
 487 If the line start "--(<lookuptype>)" it is also quoted for the given <lookuptype>.
 488 */
 489
 490 for (;;)
 491   {
 492   const void * proto_mem;
 493   uschar * var;
 494   const uschar * p;
 495
 496   if (fgets_big_buffer(fp) == NULL) goto SPOOL_READ_ERROR;
 497   if (big_buffer[0] != '-') break;
 498   big_buffer[Ustrlen(big_buffer)-1] = 0;
 499
 500   proto_mem = big_buffer[1] == '-' ? GET_TAINTED : GET_UNTAINTED;
 501   var =  big_buffer + (proto_mem == GET_UNTAINTED ? 1 : 2);
 502   if (*var == '(')                              /* marker for quoted value */
 503     {
 504     uschar * s;
 505     int idx;
 506     for (s = ++var; *s != ')'; ) s++;
 507 #ifndef COMPILE_UTILITY
 508     if ((idx = search_findtype(var, s - var)) < 0)
 509       {
 510       DEBUG(D_any) debug_printf("Unrecognised quoter %.*s\n", (int)(s - var), var+1);
 511       goto SPOOL_FORMAT_ERROR;
 512       }
 513     proto_mem = store_get_quoted(1, GET_TAINTED, idx);
 514 #endif  /* COMPILE_UTILITY */
 515     var = s + 1;
 516     }
 517   p = var + 1;
 518
 519   switch(*var)
 520     {
 521     case 'a':
 522
 523     /* Nowadays we use "-aclc" and "-aclm" for the different types of ACL
 524     variable, because Exim allows any number of them, with arbitrary names.
 525     The line in the spool file is "-acl[cm] <name> <length>". The name excludes
 526     the c or m. */
 527
 528     if (Ustrncmp(p, "clc ", 4) == 0 ||
 529         Ustrncmp(p, "clm ", 4) == 0)
 530       {
 531       uschar *name, *endptr;
 532       int count;
 533       tree_node *node;
 534       endptr = Ustrchr(var + 5, ' ');
 535       if (endptr == NULL) goto SPOOL_FORMAT_ERROR;
 536       name = string_sprintf("%c%.*s", var[3],
 537         (int)(endptr - var - 5), var + 5);
 538       if (sscanf(CS endptr, " %d", &count) != 1) goto SPOOL_FORMAT_ERROR;
 539       node = acl_var_create(name);
 540       node->data.ptr = store_get(count + 1, proto_mem);
 541       if (fread(node->data.ptr, 1, count+1, fp) < count) goto SPOOL_READ_ERROR;
 542       ((uschar*)node->data.ptr)[count] = 0;
 543       }
 544
 545     else if (Ustrcmp(p, "llow_unqualified_recipient") == 0)
 546       f.allow_unqualified_recipient = TRUE;
 547     else if (Ustrcmp(p, "llow_unqualified_sender") == 0)
 548       f.allow_unqualified_sender = TRUE;
 549
 550     else if (Ustrncmp(p, "uth_id", 6) == 0)
 551       authenticated_id = string_copy_taint(var + 8, proto_mem);
 552     else if (Ustrncmp(p, "uth_sender", 10) == 0)
 553       authenticated_sender = string_copy_taint(var + 12, proto_mem);
 554     else if (Ustrncmp(p, "ctive_hostname", 14) == 0)
 555       smtp_active_hostname = string_copy_taint(var + 16, proto_mem);
 556
 557     /* For long-term backward compatibility, we recognize "-acl", which was
 558     used before the number of ACL variables changed from 10 to 20. This was
 559     before the subsequent change to an arbitrary number of named variables.
 560     This code is retained so that upgrades from very old versions can still
 561     handle old-format spool files. The value given after "-acl" is a number
 562     that is 0-9 for connection variables, and 10-19 for message variables. */
 563
 564     else if (Ustrncmp(p, "cl ", 3) == 0)
 565       {
 566       unsigned index, count;
 567       uschar name[20];   /* Need plenty of space for %u format */
 568       tree_node * node;
 569       if (  sscanf(CS var + 4, "%u %u", &index, &count) != 2
 570          || index >= 20
 571          || count > 16384       /* arbitrary limit on variable size */
 572          )
 573         goto SPOOL_FORMAT_ERROR;
 574       if (index < 10)
 575         (void) string_format(name, sizeof(name), "%c%u", 'c', index);
 576       else
 577         (void) string_format(name, sizeof(name), "%c%u", 'm', index - 10);
 578       node = acl_var_create(name);
 579       node->data.ptr = store_get(count + 1, proto_mem);
 580       /* We sanity-checked the count, so disable the Coverity error */
 581       /* coverity[tainted_data] */
 582       if (fread(node->data.ptr, 1, count+1, fp) < count) goto SPOOL_READ_ERROR;
 583       (US node->data.ptr)[count] = '\0';
 584       }
 585     break;
 586
 587     case 'b':
 588     if (Ustrncmp(p, "ody_linecount", 13) == 0)
 589       body_linecount = Uatoi(var + 14);
 590     else if (Ustrncmp(p, "ody_zerocount", 13) == 0)
 591       body_zerocount = Uatoi(var + 14);
 592 #ifdef EXPERIMENTAL_BRIGHTMAIL
 593     else if (Ustrncmp(p, "mi_verdicts ", 12) == 0)
 594       bmi_verdicts = string_copy_taint(var + 13, proto_mem);
 595 #endif
 596     break;
 597
 598     case 'd':
 599     if (Ustrcmp(p, "eliver_firsttime") == 0)
 600       f.deliver_firsttime = TRUE;
 601     else if (Ustrncmp(p, "sn_ret", 6) == 0)
 602       dsn_ret= atoi(CS var + 7);
 603     else if (Ustrncmp(p, "sn_envid", 8) == 0)
 604       dsn_envid = string_copy_taint(var + 10, proto_mem);
 605 #ifndef COMPILE_UTILITY
 606     else if (Ustrncmp(p, "ebug_selector ", 14) == 0)
 607       debug_selector = strtol(CS var + 15, NULL, 0);
 608     else if (Ustrncmp(p, "ebuglog_name ", 13) == 0)
 609       debug_logging_from_spool(var + 14);
 610 #endif
 611     break;
 612
 613     case 'f':
 614     if (Ustrncmp(p, "rozen", 5) == 0)
 615       {
 616       f.deliver_freeze = TRUE;
 617       if (sscanf(CS var+6, TIME_T_FMT, &deliver_frozen_at) != 1)
 618         goto SPOOL_READ_ERROR;
 619       }
 620     break;
 621
 622     case 'h':
 623     if (Ustrcmp(p, "ost_lookup_deferred") == 0)
 624       host_lookup_deferred = TRUE;
 625     else if (Ustrcmp(p, "ost_lookup_failed") == 0)
 626       host_lookup_failed = TRUE;
 627     else if (Ustrncmp(p, "ost_auth_pubname", 16) == 0)
 628       sender_host_auth_pubname = string_copy_taint(var + 18, proto_mem);
 629     else if (Ustrncmp(p, "ost_auth", 8) == 0)
 630       sender_host_authenticated = string_copy_taint(var + 10, proto_mem);
 631     else if (Ustrncmp(p, "ost_name", 8) == 0)
 632       sender_host_name = string_copy_taint(var + 10, proto_mem);
 633     else if (Ustrncmp(p, "elo_name", 8) == 0)
 634       sender_helo_name = string_copy_taint(var + 10, proto_mem);
 635
 636     /* We now record the port number after the address, separated by a
 637     dot. For compatibility during upgrading, do nothing if there
 638     isn't a value (it gets left at zero). */
 639
 640     else if (Ustrncmp(p, "ost_address", 11) == 0)
 641       {
 642       sender_host_port = host_address_extract_port(var + 13);
 643       sender_host_address = string_copy_taint(var + 13, proto_mem);
 644       }
 645     break;
 646
 647     case 'i':
 648     if (Ustrncmp(p, "nterface_address", 16) == 0)
 649       {
 650       interface_port = host_address_extract_port(var + 18);
 651       interface_address = string_copy_taint(var + 18, proto_mem);
 652       }
 653     else if (Ustrncmp(p, "dent", 4) == 0)
 654       sender_ident = string_copy_taint(var + 6, proto_mem);
 655     break;
 656
 657     case 'l':
 658     if (Ustrcmp(p, "ocal") == 0)
 659       f.sender_local = TRUE;
 660     else if (Ustrcmp(var, "localerror") == 0)
 661       f.local_error_message = TRUE;
 662 #ifdef HAVE_LOCAL_SCAN
 663     else if (Ustrncmp(p, "ocal_scan ", 10) == 0)
 664       local_scan_data = string_copy_taint(var + 11, proto_mem);
 665 #endif
 666     break;
 667
 668     case 'm':
 669     if (Ustrcmp(p, "anual_thaw") == 0)
 670       f.deliver_manual_thaw = TRUE;
 671     else if (Ustrncmp(p, "ax_received_linelength", 22) == 0)
 672       max_received_linelength = Uatoi(var + 23);
 673     break;
 674
 675     case 'N':
 676     if (*p == 0) f.dont_deliver = TRUE;   /* -N */
 677     break;
 678
 679     case 'r':
 680     if (Ustrncmp(p, "eceived_protocol", 16) == 0)
 681       received_protocol = string_copy_taint(var + 18, proto_mem);
 682     else if (Ustrncmp(p, "eceived_time_usec", 17) == 0)
 683       {
 684       unsigned usec;
 685       if (sscanf(CS var + 20, "%u", &usec) == 1)
 686         {
 687         received_time.tv_usec = usec;
 688         if (!received_time_complete.tv_sec) received_time_complete.tv_usec = usec;
 689         }
 690       }
 691     else if (Ustrncmp(p, "eceived_time_complete", 21) == 0)
 692       {
 693       unsigned sec, usec;
 694       if (sscanf(CS var + 23, "%u.%u", &sec, &usec) == 2)
 695         {
 696         received_time_complete.tv_sec = sec;
 697         received_time_complete.tv_usec = usec;
 698         }
 699       }
 700     break;
 701
 702     case 's':
 703     if (Ustrncmp(p, "ender_set_untrusted", 19) == 0)
 704       f.sender_set_untrusted = TRUE;
 705 #ifdef WITH_CONTENT_SCAN
 706     else if (Ustrncmp(p, "pam_bar ", 8) == 0)
 707       spam_bar = string_copy_taint(var + 9, proto_mem);
 708     else if (Ustrncmp(p, "pam_score ", 10) == 0)
 709       spam_score = string_copy_taint(var + 11, proto_mem);
 710     else if (Ustrncmp(p, "pam_score_int ", 14) == 0)
 711       spam_score_int = string_copy_taint(var + 15, proto_mem);
 712 #endif
 713 #ifndef COMPILE_UTILITY
 714     else if (Ustrncmp(p, "pool_file_wireformat", 20) == 0)
 715       f.spool_file_wireformat = TRUE;
 716 #endif
 717 #if defined(SUPPORT_I18N) && !defined(COMPILE_UTILITY)
 718     else if (Ustrncmp(p, "mtputf8", 7) == 0)
 719       message_smtputf8 = TRUE;
 720 #endif
 721     break;
 722
 723 #ifndef DISABLE_TLS
 724     case 't':
 725     if (Ustrncmp(p, "ls_", 3) == 0)
 726       {
 727       const uschar * q = p + 3;
 728       if (Ustrncmp(q, "certificate_verified", 20) == 0)
 729         tls_in.certificate_verified = TRUE;
 730       else if (Ustrncmp(q, "cipher", 6) == 0)
 731         tls_in.cipher = string_copy_taint(q+7, proto_mem);
 732 # ifndef COMPILE_UTILITY        /* tls support fns not built in */
 733       else if (Ustrncmp(q, "ourcert", 7) == 0)
 734         (void) tls_import_cert(q+8, &tls_in.ourcert);
 735       else if (Ustrncmp(q, "peercert", 8) == 0)
 736         (void) tls_import_cert(q+9, &tls_in.peercert);
 737 # endif
 738       else if (Ustrncmp(q, "peerdn", 6) == 0)
 739         tls_in.peerdn = string_unprinting(string_copy_taint(q+7, proto_mem));
 740       else if (Ustrncmp(q, "sni", 3) == 0)
 741         tls_in.sni = string_unprinting(string_copy_taint(q+4, proto_mem));
 742       else if (Ustrncmp(q, "ocsp", 4) == 0)
 743         tls_in.ocsp = q[5] - '0';
 744 # ifndef DISABLE_TLS_RESUME
 745       else if (Ustrncmp(q, "resumption", 10) == 0)
 746         tls_in.resumption = q[11] - 'A';
 747 # endif
 748       else if (Ustrncmp(q, "ver", 3) == 0)
 749         tls_in.ver = string_copy_taint(q+4, proto_mem);
 750       }
 751     break;
 752 #endif
 753
 754 #if defined(SUPPORT_I18N) && !defined(COMPILE_UTILITY)
 755     case 'u':
 756     if (Ustrncmp(p, "tf8_downcvt", 11) == 0)
 757       message_utf8_downconvert = 1;
 758     else if (Ustrncmp(p, "tf8_optdowncvt", 15) == 0)
 759       message_utf8_downconvert = -1;
 760     break;
 761 #endif
 762
 763     default:    /* Present because some compilers complain if all */
 764     break;      /* possibilities are not covered. */
 765     }
 766   }
 767
 768 /* Build sender_fullhost if required */
 769
 770 #ifndef COMPILE_UTILITY
 771 host_build_sender_fullhost();
 772 #endif  /* COMPILE_UTILITY */
 773
 774 #ifndef COMPILE_UTILITY
 775 DEBUG(D_deliver)
 776   debug_printf_indent("sender_local=%d ident=%s\n", f.sender_local,
 777     sender_ident ? sender_ident : US"unset");
 778 #endif  /* COMPILE_UTILITY */
 779
 780 /* We now have the tree of addresses NOT to deliver to, or a line
 781 containing "XX", indicating no tree. */
 782
 783 if (Ustrncmp(big_buffer, "XX\n", 3) != 0 &&
 784   !read_nonrecipients_tree(&tree_nonrecipients, fp, big_buffer, big_buffer_size))
 785     goto SPOOL_FORMAT_ERROR;
 786
 787 #ifndef COMPILE_UTILITY
 788 DEBUG(D_deliver) debug_print_tree("Non-recipients", tree_nonrecipients);
 789 #endif  /* COMPILE_UTILITY */
 790
 791 /* After reading the tree, the next line has not yet been read into the
 792 buffer. It contains the count of recipients which follow on separate lines.
 793 Apply an arbitrary sanity check.*/
 794
 795 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 796 if (sscanf(CS big_buffer, "%d", &rcount) != 1 || rcount > 16384)
 797   goto SPOOL_FORMAT_ERROR;
 798
 799 #ifndef COMPILE_UTILITY
 800 DEBUG(D_deliver) debug_printf_indent("recipients_count=%d\n", rcount);
 801 #endif  /* COMPILE_UTILITY */
 802
 803 recipients_list_max = rcount;
 804 recipients_list = store_get(rcount * sizeof(recipient_item), GET_UNTAINTED);
 805
 806 /* We sanitised the count and know we have enough memory, so disable
 807 the Coverity error on recipients_count */
 808 /* coverity[tainted_data] */
 809
 810 for (recipients_count = 0; recipients_count < rcount; recipients_count++)
 811   {
 812   int nn;
 813   int pno = -1;
 814   int dsn_flags = 0;
 815   uschar *orcpt = NULL;
 816   uschar *errors_to = NULL;
 817   uschar *p;
 818
 819   if (fgets_big_buffer(fp) == NULL) goto SPOOL_READ_ERROR;
 820   nn = Ustrlen(big_buffer);
 821   if (nn < 2) goto SPOOL_FORMAT_ERROR;
 822
 823   /* Remove the newline; this terminates the address if there is no additional
 824   data on the line. */
 825
 826   p = big_buffer + nn - 1;
 827   *p-- = 0;
 828
 829   /* Look back from the end of the line for digits and special terminators.
 830   Since an address must end with a domain, we can tell that extra data is
 831   present by the presence of the terminator, which is always some character
 832   that cannot exist in a domain. (If I'd thought of the need for additional
 833   data early on, I'd have put it at the start, with the address at the end. As
 834   it is, we have to operate backwards. Addresses are permitted to contain
 835   spaces, you see.)
 836
 837   This code has to cope with various versions of this data that have evolved
 838   over time. In all cases, the line might just contain an address, with no
 839   additional data. Otherwise, the possibilities are as follows:
 840
 841   Exim 3 type:       <address><space><digits>,<digits>,<digits>
 842
 843     The second set of digits is the parent number for one_time addresses. The
 844     other values were remnants of earlier experiments that were abandoned.
 845
 846   Exim 4 first type: <address><space><digits>
 847
 848     The digits are the parent number for one_time addresses.
 849
 850   Exim 4 new type:   <address><space><data>#<type bits>
 851
 852     The type bits indicate what the contents of the data are.
 853
 854     Bit 01 indicates that, reading from right to left, the data
 855       ends with <errors_to address><space><len>,<pno> where pno is
 856       the parent number for one_time addresses, and len is the length
 857       of the errors_to address (zero meaning none).
 858
 859     Bit 02 indicates that, again reading from right to left, the data continues
 860      with orcpt len(orcpt),dsn_flags
 861    */
 862
 863   while (isdigit(*p)) p--;
 864
 865   /* Handle Exim 3 spool files */
 866
 867   if (*p == ',')
 868     {
 869     int dummy;
 870 #if !defined (COMPILE_UTILITY)
 871     DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - Exim 3 spool file\n");
 872 #endif
 873     while (isdigit(*(--p)) || *p == ',');
 874     if (*p == ' ')
 875       {
 876       *p++ = 0;
 877       (void)sscanf(CS p, "%d,%d", &dummy, &pno);
 878       }
 879     }
 880
 881   /* Handle early Exim 4 spool files */
 882
 883   else if (*p == ' ')
 884     {
 885 #if !defined (COMPILE_UTILITY)
 886     DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - early Exim 4 spool file\n");
 887 #endif
 888     *p++ = 0;
 889     (void)sscanf(CS p, "%d", &pno);
 890     }
 891
 892   /* Handle current format Exim 4 spool files */
 893
 894   else if (*p == '#')
 895     {
 896     int flags;
 897
 898 #if !defined (COMPILE_UTILITY)
 899     DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - Exim standard format spoolfile\n");
 900 #endif
 901
 902     (void)sscanf(CS p+1, "%d", &flags);
 903
 904     if (flags & 0x01)      /* one_time data exists */
 905       {
 906       int len;
 907       while (isdigit(*(--p)) || *p == ',' || *p == '-');
 908       (void)sscanf(CS p+1, "%d,%d", &len, &pno);
 909       *p = 0;
 910       if (len > 0)
 911         {
 912         p -= len;
 913         errors_to = string_copy_taint(p, GET_TAINTED);
 914         }
 915       }
 916
 917     *--p = 0;   /* Terminate address */
 918     if (flags & 0x02)      /* one_time data exists */
 919       {
 920       int len;
 921       while (isdigit(*(--p)) || *p == ',' || *p == '-');
 922       (void)sscanf(CS p+1, "%d,%d", &len, &dsn_flags);
 923       *p = 0;
 924       if (len > 0)
 925         {
 926         p -= len;
 927         orcpt = string_copy_taint(p, GET_TAINTED);
 928         }
 929       }
 930
 931     *--p = 0;   /* Terminate address */
 932     }
 933 #if !defined(COMPILE_UTILITY)
 934   else
 935     { DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - No additional fields\n"); }
 936
 937   if (orcpt || dsn_flags)
 938     DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - address: <%s> orcpt: <%s> dsn_flags: 0x%x\n",
 939       big_buffer, orcpt, dsn_flags);
 940   if (errors_to)
 941     DEBUG(D_deliver) debug_printf_indent("**** SPOOL_IN - address: <%s> errorsto: <%s>\n",
 942       big_buffer, errors_to);
 943 #endif
 944
 945   recipients_list[recipients_count].address = string_copy_taint(big_buffer, GET_TAINTED);
 946   recipients_list[recipients_count].pno = pno;
 947   recipients_list[recipients_count].errors_to = errors_to;
 948   recipients_list[recipients_count].orcpt = orcpt;
 949   recipients_list[recipients_count].dsn_flags = dsn_flags;
 950   }
 951
 952 /* The remainder of the spool header file contains the headers for the message,
 953 separated off from the previous data by a blank line. Each header is preceded
 954 by a count of its length and either a certain letter (for various identified
 955 headers), space (for a miscellaneous live header) or an asterisk (for a header
 956 that has been rewritten). Count the Received: headers. We read the headers
 957 always, in order to check on the format of the file, but only create a header
 958 list if requested to do so. */
 959
 960 inheader = TRUE;
 961 if (Ufgets(big_buffer, big_buffer_size, fp) == NULL) goto SPOOL_READ_ERROR;
 962 if (big_buffer[0] != '\n') goto SPOOL_FORMAT_ERROR;
 963
 964 while ((n = fgetc(fp)) != EOF)
 965   {
 966   header_line *h;
 967   uschar flag[4];
 968   int i;
 969
 970   if (!isdigit(n)) goto SPOOL_FORMAT_ERROR;
 971   if(ungetc(n, fp) == EOF  ||  fscanf(fp, "%d%c ", &n, flag) == EOF)
 972     goto SPOOL_READ_ERROR;
 973   if (flag[0] != '*') message_size += n;  /* Omit non-transmitted headers */
 974
 975   if (read_headers)
 976     {
 977     h = store_get(sizeof(header_line), GET_UNTAINTED);
 978     h->next = NULL;
 979     h->type = flag[0];
 980     h->slen = n;
 981     h->text = store_get(n+1, GET_TAINTED);
 982
 983     if (h->type == htype_received) received_count++;
 984
 985     if (header_list) header_last->next = h;
 986     else header_list = h;
 987     header_last = h;
 988
 989     for (i = 0; i < n; i++)
 990       {
 991       int c = fgetc(fp);
 992       if (c == 0 || c == EOF) goto SPOOL_FORMAT_ERROR;
 993       if (c == '\n' && h->type != htype_old) message_linecount++;
 994       h->text[i] = c;
 995       }
 996     h->text[i] = 0;
 997     }
 998
 999   /* Not requiring header data, just skip through the bytes */
1000
1001   else for (i = 0; i < n; i++)
1002     {
1003     int c = fgetc(fp);
1004     if (c == 0 || c == EOF) goto SPOOL_FORMAT_ERROR;
1005     }
1006   }
1007
1008 /* We have successfully read the data in the header file. Update the message
1009 line count by adding the body linecount to the header linecount. Close the file
1010 and give a positive response. */
1011
1012 #ifndef COMPILE_UTILITY
1013 DEBUG(D_deliver) debug_printf_indent("body_linecount=%d message_linecount=%d\n",
1014   body_linecount, message_linecount);
1015 #endif  /* COMPILE_UTILITY */
1016
1017 message_linecount += body_linecount;
1018
1019 fclose(fp);
1020 return spool_read_OK;
1021
1022
1023 /* There was an error reading the spool or there was missing data,
1024 or there was a format error. A "read error" with no errno means an
1025 unexpected EOF, which we treat as a format error. */
1026
1027 SPOOL_READ_ERROR:
1028 if (errno != 0)
1029   {
1030   n = errno;
1031
1032 #ifndef COMPILE_UTILITY
1033   DEBUG(D_any) debug_printf("Error while reading spool file %s\n", name);
1034 #endif  /* COMPILE_UTILITY */
1035
1036   fclose(fp);
1037   errno = n;
1038   return inheader ? spool_read_hdrerror : spool_read_enverror;
1039   }
1040
1041 SPOOL_FORMAT_ERROR:
1042
1043 #ifndef COMPILE_UTILITY
1044 DEBUG(D_any) debug_printf("Format error in spool file %s\n", name);
1045 #endif  /* COMPILE_UTILITY */
1046
1047 fclose(fp);
1048 errno = ERRNO_SPOOLFORMAT;
1049 return inheader? spool_read_hdrerror : spool_read_enverror;
1050 }
1051
1052
1053 #ifndef COMPILE_UTILITY
1054 /* Read out just the (envelope) sender string from the spool -H file.
1055 Remove the <> wrap and return it in allocated store.  Return NULL on error.
1056
1057 We assume that message_subdir is already set.
1058 */
1059
1060 uschar *
1061 spool_sender_from_msgid(const uschar * id)
1062 {
1063 uschar * name = string_sprintf("%s-H", id);
1064 FILE * fp;
1065 int n;
1066 uschar * yield = NULL;
1067
1068 if (!(fp = Ufopen(spool_fname(US"input", message_subdir, name, US""), "rb")))
1069   return NULL;
1070
1071 DEBUG(D_deliver) debug_printf_indent("reading spool file %s\n", name);
1072
1073 /* Skip the line with the copy of the filename, then the line with login/uid/gid.
1074 Read the next line, which should be the envelope sender.
1075 Do basic validation on that. */
1076
1077 if (  Ufgets(big_buffer, big_buffer_size, fp) != NULL
1078    && Ufgets(big_buffer, big_buffer_size, fp) != NULL
1079    && Ufgets(big_buffer, big_buffer_size, fp) != NULL
1080    && (n = Ustrlen(big_buffer)) >= 3
1081    && big_buffer[0] == '<' && big_buffer[n-2] == '>'
1082    )
1083   {
1084   yield = store_get(n-2, GET_TAINTED);
1085   Ustrncpy(yield, big_buffer+1, n-3);
1086   yield[n-3] = 0;
1087   }
1088 fclose(fp);
1089 return yield;
1090 }
1091 #endif  /* COMPILE_UTILITY */
1092
1093 /* vi: aw ai sw=2
1094 */
1095 /* End of spool_in.c */