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