src/src/spool_in.c

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