src/src/spool_in.c

   1 /* $Cambridge: exim/src/src/spool_in.c,v 1.1 2004/10/07 10:39:01 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2004 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   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 Argument: the id of the message
  31 Returns:  TRUE if file successfully opened and locked
  32
  33 Side effect: deliver_datafile is set to the fd of the open file.
  34 */
  35
  36 BOOL
  37 spool_open_datafile(uschar *id)
  38 {
  39 int i;
  40 struct stat statbuf;
  41 flock_t lock_data;
  42 uschar spoolname[256];
  43
  44 /* If split_spool_directory is set, first look for the file in the appropriate
  45 sub-directory of the input directory. If it is not found there, try the input
  46 directory itself, to pick up leftovers from before the splitting. If split_
  47 spool_directory is not set, first look in the main input directory. If it is
  48 not found there, try the split sub-directory, in case it is left over from a
  49 splitting state. */
  50
  51 for (i = 0; i < 2; i++)
  52   {
  53   int save_errno;
  54   message_subdir[0] = (split_spool_directory == (i == 0))? id[5] : 0;
  55   sprintf(CS spoolname, "%s/input/%s/%s-D", spool_directory, message_subdir, id);
  56   deliver_datafile = Uopen(spoolname, O_RDWR | O_APPEND, 0);
  57   if (deliver_datafile >= 0) break;
  58   save_errno = errno;
  59   if (errno == ENOENT)
  60     {
  61     if (i == 0) continue;
  62     if (!queue_running)
  63       log_write(0, LOG_MAIN, "Spool file %s-D not found", id);
  64     }
  65   else log_write(0, LOG_MAIN, "Spool error for %s: %s", spoolname,
  66     strerror(errno));
  67   errno = save_errno;
  68   return FALSE;
  69   }
  70
  71 /* File is open and message_subdir is set. Set the close-on-exec flag, and lock
  72 the file. We lock only the first line of the file (containing the message ID)
  73 because this apparently is needed for running Exim under Cygwin. If the entire
  74 file is locked in one process, a sub-process cannot access it, even when passed
  75 an open file descriptor (at least, I think that's the Cygwin story). On real
  76 Unix systems it doesn't make any difference as long as Exim is consistent in
  77 what it locks. */
  78
  79 fcntl(deliver_datafile, F_SETFD, fcntl(deliver_datafile, F_GETFD) |
  80   FD_CLOEXEC);
  81
  82 lock_data.l_type = F_WRLCK;
  83 lock_data.l_whence = SEEK_SET;
  84 lock_data.l_start = 0;
  85 lock_data.l_len = SPOOL_DATA_START_OFFSET;
  86
  87 if (fcntl(deliver_datafile, F_SETLK, &lock_data) < 0)
  88   {
  89   log_write(L_skip_delivery,
  90             LOG_MAIN,
  91             "Spool file is locked (another process is handling this message)");
  92   close(deliver_datafile);
  93   deliver_datafile = -1;
  94   errno = 0;
  95   return FALSE;
  96   }
  97
  98 /* Get the size of the data; don't include the leading filename line
  99 in the count, but add one for the newline before the data. */
 100
 101 if (fstat(deliver_datafile, &statbuf) == 0)
 102   {
 103   message_body_size = statbuf.st_size - SPOOL_DATA_START_OFFSET;
 104   message_size = message_body_size + 1;
 105   }
 106
 107 return TRUE;
 108 }
 109 #endif  /* COMPILE_UTILITY */
 110
 111
 112
 113 /*************************************************
 114 *    Read non-recipients tree from spool file    *
 115 *************************************************/
 116
 117 /* The tree of non-recipients is written to the spool file in a form that
 118 makes it easy to read back into a tree. The format is as follows:
 119
 120    . Each node is preceded by two letter(Y/N) indicating whether it has left
 121      or right children. There's one space after the two flags, before the name.
 122
 123    . The left subtree (if any) then follows, then the right subtree (if any).
 124
 125 This function is entered with the next input line in the buffer. Note we must
 126 save the right flag before recursing with the same buffer.
 127
 128 Once the tree is read, we re-construct the balance fields by scanning the tree.
 129 I forgot to write them out originally, and the compatible fix is to do it this
 130 way. This initial local recursing function does the necessary.
 131
 132 Arguments:
 133   node      tree node
 134
 135 Returns:    maximum depth below the node, including the node itself
 136 */
 137
 138 static int
 139 count_below(tree_node *node)
 140 {
 141 int nleft, nright;
 142 if (node == NULL) return 0;
 143 nleft = count_below(node->left);
 144 nright = count_below(node->right);
 145 node->balance = (nleft > nright)? 1 : ((nright > nleft)? 2 : 0);
 146 return 1 + ((nleft > nright)? nleft : nright);
 147 }
 148
 149 /* This is the real function...
 150
 151 Arguments:
 152   connect      pointer to the root of the tree
 153   f            FILE to read data from
 154   buffer       contains next input line; further lines read into it
 155   buffer_size  size of the buffer
 156
 157 Returns:       FALSE on format error
 158 */
 159
 160 static BOOL
 161 read_nonrecipients_tree(tree_node **connect, FILE *f, uschar *buffer,
 162   int buffer_size)
 163 {
 164 tree_node *node;
 165 int n = Ustrlen(buffer);
 166 BOOL right = buffer[1] == 'Y';
 167
 168 if (n < 5) return FALSE;    /* malformed line */
 169 buffer[n-1] = 0;            /* Remove \n */
 170 node = store_get(sizeof(tree_node) + n - 3);
 171 *connect = node;
 172 Ustrcpy(node->name, buffer + 3);
 173 node->data.ptr = NULL;
 174
 175 if (buffer[0] == 'Y')
 176   {
 177   if (Ufgets(buffer, buffer_size, f) == NULL ||
 178     !read_nonrecipients_tree(&node->left, f, buffer, buffer_size))
 179       return FALSE;
 180   }
 181 else node->left = NULL;
 182
 183 if (right)
 184   {
 185   if (Ufgets(buffer, buffer_size, f) == NULL ||
 186     !read_nonrecipients_tree(&node->right, f, buffer, buffer_size))
 187       return FALSE;
 188   }
 189 else node->right = NULL;
 190
 191 (void) count_below(*connect);
 192 return TRUE;
 193 }
 194
 195
 196
 197
 198 /*************************************************
 199 *             Read spool header file             *
 200 *************************************************/
 201
 202 /* This function reads a spool header file and places the data into the
 203 appropriate global variables. The header portion is always read, but header
 204 structures are built only if read_headers is set true. It isn't, for example,
 205 while generating -bp output.
 206
 207 It may be possible for blocks of nulls (binary zeroes) to get written on the
 208 end of a file if there is a system crash during writing. It was observed on an
 209 earlier version of Exim that omitted to fsync() the files - this is thought to
 210 have been the cause of that incident, but in any case, this code must be robust
 211 against such an event, and if such a file is encountered, it must be treated as
 212 malformed.
 213
 214 Arguments:
 215   name          name of the header file, including the -H
 216   read_headers  TRUE if in-store header structures are to be built
 217   subdir_set    TRUE is message_subdir is already set
 218
 219 Returns:        spool_read_OK        success
 220                 spool_read_notopen   open failed
 221                 spool_read_enverror  error in the envelope portion
 222                 spool_read_hdrdrror  error in the header portion
 223 */
 224
 225 int
 226 spool_read_header(uschar *name, BOOL read_headers, BOOL subdir_set)
 227 {
 228 FILE *f = NULL;
 229 int n;
 230 int rcount = 0;
 231 long int uid, gid;
 232 BOOL inheader = FALSE;
 233 uschar originator[64];
 234
 235 /* Reset all the global variables to their default values. However, there is
 236 one exception. DO NOT change the default value of dont_deliver, because it may
 237 be forced by an external setting. */
 238
 239 for (n = 0; n < ACL_C_MAX + ACL_M_MAX; n++) acl_var[n] = NULL;
 240
 241 authenticated_id = NULL;
 242 authenticated_sender = NULL;
 243 allow_unqualified_recipient = FALSE;
 244 allow_unqualified_sender = FALSE;
 245 body_linecount = 0;
 246 body_zerocount = 0;
 247 deliver_firsttime = FALSE;
 248 deliver_freeze = FALSE;
 249 deliver_frozen_at = 0;
 250 deliver_manual_thaw = FALSE;
 251 /* dont_deliver must NOT be reset */
 252 header_list = header_last = NULL;
 253 host_lookup_failed = FALSE;
 254 interface_address = NULL;
 255 interface_port = 0;
 256 local_error_message = FALSE;
 257 local_scan_data = NULL;
 258 message_linecount = 0;
 259 received_protocol = NULL;
 260 received_count = 0;
 261 recipients_list = NULL;
 262 sender_address = NULL;
 263 sender_fullhost = NULL;
 264 sender_helo_name = NULL;
 265 sender_host_address = NULL;
 266 sender_host_name = NULL;
 267 sender_host_port = 0;
 268 sender_host_authenticated = NULL;
 269 sender_ident = NULL;
 270 sender_local = FALSE;
 271 sender_set_untrusted = FALSE;
 272 tree_nonrecipients = NULL;
 273
 274 #ifdef SUPPORT_TLS
 275 tls_certificate_verified = FALSE;
 276 tls_cipher = NULL;
 277 tls_peerdn = NULL;
 278 #endif
 279
 280 /* Generate the full name and open the file. If message_subdir is already
 281 set, just look in the given directory. Otherwise, look in both the split
 282 and unsplit directories, as for the data file above. */
 283
 284 for (n = 0; n < 2; n++)
 285   {
 286   if (!subdir_set)
 287     message_subdir[0] = (split_spool_directory == (n == 0))? name[5] : 0;
 288   sprintf(CS big_buffer, "%s/input/%s/%s", spool_directory, message_subdir,
 289     name);
 290   f = Ufopen(big_buffer, "rb");
 291   if (f != NULL) break;
 292   if (n != 0 || subdir_set || errno != ENOENT) return spool_read_notopen;
 293   }
 294
 295 errno = 0;
 296
 297 #ifndef COMPILE_UTILITY
 298 DEBUG(D_deliver) debug_printf("reading spool file %s\n", name);
 299 #endif  /* COMPILE_UTILITY */
 300
 301 /* The first line of a spool file contains the message id followed by -H (i.e.
 302 the file name), in order to make the file self-identifying. */
 303
 304 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 305 if (Ustrlen(big_buffer) != MESSAGE_ID_LENGTH + 3 ||
 306     Ustrncmp(big_buffer, name, MESSAGE_ID_LENGTH + 2) != 0)
 307   goto SPOOL_FORMAT_ERROR;
 308
 309 /* The next three lines in the header file are in a fixed format. The first
 310 contains the login, uid, and gid of the user who caused the file to be written.
 311 The second contains the mail address of the message's sender, enclosed in <>.
 312 The third contains the time the message was received, and the number of warning
 313 messages for delivery delays that have been sent. */
 314
 315 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 316
 317 if (sscanf(CS big_buffer, "%s %ld %ld", originator, &uid, &gid) != 3)
 318   goto SPOOL_FORMAT_ERROR;
 319 originator_login = string_copy(originator);
 320 originator_uid = (uid_t)uid;
 321 originator_gid = (gid_t)gid;
 322
 323 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 324 n = Ustrlen(big_buffer);
 325 if (n < 3 || big_buffer[0] != '<' || big_buffer[n-2] != '>')
 326   goto SPOOL_FORMAT_ERROR;
 327
 328 sender_address = store_get(n-2);
 329 Ustrncpy(sender_address, big_buffer+1, n-3);
 330 sender_address[n-3] = 0;
 331
 332 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 333 if (sscanf(CS big_buffer, "%d %d", &received_time, &warning_count) != 2)
 334   goto SPOOL_FORMAT_ERROR;
 335
 336 message_age = time(NULL) - received_time;
 337
 338 #ifndef COMPILE_UTILITY
 339 DEBUG(D_deliver) debug_printf("user=%s uid=%ld gid=%ld sender=%s\n",
 340   originator_login, (long int)originator_uid, (long int)originator_gid,
 341   sender_address);
 342 #endif  /* COMPILE_UTILITY */
 343
 344 /* Now there may be a number of optional lines, each starting with "-".
 345 If you add a new setting here, make sure you set the default above. */
 346
 347 for (;;)
 348   {
 349   if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 350   if (big_buffer[0] != '-') break;
 351
 352   big_buffer[Ustrlen(big_buffer) - 1] = 0;
 353   if (Ustrncmp(big_buffer, "-acl ", 5) == 0)
 354     {
 355     int index, count;
 356     if (sscanf(CS big_buffer + 5, "%d %d", &index, &count) != 2)
 357       goto SPOOL_FORMAT_ERROR;
 358     /* Ignore if index too big - might be if a later release with more
 359     variables built this spool file. */
 360     if (index < ACL_C_MAX + ACL_M_MAX)
 361       {
 362       acl_var[index] = store_get(count + 1);
 363       if (fread(acl_var[index], 1, count+1, f) < count) goto SPOOL_READ_ERROR;
 364       acl_var[index][count] = 0;
 365       }
 366     }
 367   else if (Ustrcmp(big_buffer, "-local") == 0) sender_local = TRUE;
 368   else if (Ustrcmp(big_buffer, "-localerror") == 0)
 369     local_error_message = TRUE;
 370   else if (Ustrncmp(big_buffer, "-local_scan ", 12) == 0)
 371     local_scan_data = string_copy(big_buffer + 12);
 372   else if (Ustrcmp(big_buffer, "-host_lookup_failed") == 0)
 373     host_lookup_failed = TRUE;
 374   else if (Ustrncmp(big_buffer, "-body_linecount", 15) == 0)
 375     body_linecount = Uatoi(big_buffer + 15);
 376   else if (Ustrncmp(big_buffer, "-body_zerocount", 15) == 0)
 377     body_zerocount = Uatoi(big_buffer + 15);
 378   else if (Ustrncmp(big_buffer, "-frozen", 7) == 0)
 379     {
 380     deliver_freeze = TRUE;
 381     deliver_frozen_at = Uatoi(big_buffer + 7);
 382     }
 383   else if (Ustrcmp(big_buffer, "-allow_unqualified_recipient") == 0)
 384     allow_unqualified_recipient = TRUE;
 385   else if (Ustrcmp(big_buffer, "-allow_unqualified_sender") == 0)
 386     allow_unqualified_sender = TRUE;
 387   else if (Ustrcmp(big_buffer, "-deliver_firsttime") == 0)
 388     deliver_firsttime = TRUE;
 389   else if (Ustrcmp(big_buffer, "-manual_thaw") == 0)
 390     deliver_manual_thaw = TRUE;
 391   else if (Ustrncmp(big_buffer, "-auth_id", 8) == 0)
 392     authenticated_id = string_copy(big_buffer + 9);
 393   else if (Ustrncmp(big_buffer, "-auth_sender", 12) == 0)
 394     authenticated_sender = string_copy(big_buffer + 13);
 395   else if (Ustrncmp(big_buffer, "-sender_set_untrusted", 21) == 0)
 396     sender_set_untrusted = TRUE;
 397
 398   #ifdef SUPPORT_TLS
 399   else if (Ustrncmp(big_buffer, "-tls_certificate_verified", 25) == 0)
 400     tls_certificate_verified = TRUE;
 401   else if (Ustrncmp(big_buffer, "-tls_cipher", 11) == 0)
 402     tls_cipher = string_copy(big_buffer + 12);
 403   else if (Ustrncmp(big_buffer, "-tls_peerdn", 11) == 0)
 404     tls_peerdn = string_copy(big_buffer + 12);
 405   #endif
 406
 407   /* We now record the port number after the address, separated by a
 408   dot. For compatibility during upgrading, do nothing if there
 409   isn't a value (it gets left at zero). */
 410
 411   else if (Ustrncmp(big_buffer, "-host_address", 13) == 0)
 412     {
 413     sender_host_port = host_extract_port(big_buffer + 14);
 414     sender_host_address = string_copy(big_buffer + 14);
 415     }
 416
 417   else if (Ustrncmp(big_buffer, "-interface_address", 18) == 0)
 418     {
 419     interface_port = host_extract_port(big_buffer + 19);
 420     interface_address = string_copy(big_buffer + 19);
 421     }
 422
 423   else if (Ustrncmp(big_buffer, "-host_auth", 10) == 0)
 424     sender_host_authenticated = string_copy(big_buffer + 11);
 425   else if (Ustrncmp(big_buffer, "-host_name", 10) == 0)
 426     sender_host_name = string_copy(big_buffer + 11);
 427   else if (Ustrncmp(big_buffer, "-helo_name", 10) == 0)
 428     sender_helo_name = string_copy(big_buffer + 11);
 429   else if (Ustrncmp(big_buffer, "-ident", 6) == 0)
 430     sender_ident = string_copy(big_buffer + 7);
 431   else if (Ustrncmp(big_buffer, "-received_protocol", 18) == 0)
 432     received_protocol = string_copy(big_buffer + 19);
 433   else if (Ustrncmp(big_buffer, "-N", 2) == 0)
 434     dont_deliver = TRUE;
 435
 436   /* To allow new versions of Exim that add additional flags to interwork
 437   with older versions that do not understand them, just ignore any flagged
 438   lines that we don't recognize. Otherwise it wouldn't be possible to back
 439   off a new version that left new-style flags written on the spool. That's
 440   why the following line is commented out. */
 441
 442     /* else goto SPOOL_FORMAT_ERROR; */
 443   }
 444
 445 /* Build sender_fullhost if required */
 446
 447 #ifndef COMPILE_UTILITY
 448 host_build_sender_fullhost();
 449 #endif  /* COMPILE_UTILITY */
 450
 451 #ifndef COMPILE_UTILITY
 452 DEBUG(D_deliver)
 453   debug_printf("sender_local=%d ident=%s\n", sender_local,
 454     (sender_ident == NULL)? US"unset" : sender_ident);
 455 #endif  /* COMPILE_UTILITY */
 456
 457 /* We now have the tree of addresses NOT to deliver to, or a line
 458 containing "XX", indicating no tree. */
 459
 460 if (Ustrncmp(big_buffer, "XX\n", 3) != 0 &&
 461   !read_nonrecipients_tree(&tree_nonrecipients, f, big_buffer, big_buffer_size))
 462     goto SPOOL_FORMAT_ERROR;
 463
 464 #ifndef COMPILE_UTILITY
 465 DEBUG(D_deliver)
 466   {
 467   debug_printf("Non-recipients:\n");
 468   debug_print_tree(tree_nonrecipients);
 469   }
 470 #endif  /* COMPILE_UTILITY */
 471
 472 /* After reading the tree, the next line has not yet been read into the
 473 buffer. It contains the count of recipients which follow on separate lines. */
 474
 475 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 476 if (sscanf(CS big_buffer, "%d", &rcount) != 1) goto SPOOL_FORMAT_ERROR;
 477
 478 #ifndef COMPILE_UTILITY
 479 DEBUG(D_deliver) debug_printf("recipients_count=%d\n", rcount);
 480 #endif  /* COMPILE_UTILITY */
 481
 482 recipients_list_max = rcount;
 483 recipients_list = store_get(rcount * sizeof(recipient_item));
 484
 485 for (recipients_count = 0; recipients_count < rcount; recipients_count++)
 486   {
 487   int nn;
 488   int pno = -1;
 489   uschar *errors_to = NULL;
 490   uschar *p;
 491
 492   if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 493   nn = Ustrlen(big_buffer);
 494   if (nn < 2) goto SPOOL_FORMAT_ERROR;
 495
 496   /* Remove the newline; this terminates the address if there is no additional
 497   data on the line. */
 498
 499   p = big_buffer + nn - 1;
 500   *p-- = 0;
 501
 502   /* Look back from the end of the line for digits and special terminators.
 503   Since an address must end with a domain, we can tell that extra data is
 504   present by the presence of the terminator, which is always some character
 505   that cannot exist in a domain. (If I'd thought of the need for additional
 506   data early on, I'd have put it at the start, with the address at the end. As
 507   it is, we have to operate backwards. Addresses are permitted to contain
 508   spaces, you see.)
 509
 510   This code has to cope with various versions of this data that have evolved
 511   over time. In all cases, the line might just contain an address, with no
 512   additional data. Otherwise, the possibilities are as follows:
 513
 514   Exim 3 type:       <address><space><digits>,<digits>,<digits>
 515
 516     The second set of digits is the parent number for one_time addresses. The
 517     other values were remnants of earlier experiments that were abandoned.
 518
 519   Exim 4 first type: <address><space><digits>
 520
 521     The digits are the parent number for one_time addresses.
 522
 523   Exim 4 new type:   <address><space><data>#<type bits>
 524
 525     The type bits indicate what the contents of the data are.
 526
 527     Bit 01 indicates that, reading from right to left, the data
 528       ends with <errors_to address><space><len>,<pno> where pno is
 529       the parent number for one_time addresses, and len is the length
 530       of the errors_to address (zero meaning none).
 531    */
 532
 533   while (isdigit(*p)) p--;
 534
 535   /* Handle Exim 3 spool files */
 536
 537   if (*p == ',')
 538     {
 539     int dummy;
 540     while (isdigit(*(--p)) || *p == ',');
 541     if (*p == ' ')
 542       {
 543       *p++ = 0;
 544       sscanf(CS p, "%d,%d", &dummy, &pno);
 545       }
 546     }
 547
 548   /* Handle early Exim 4 spool files */
 549
 550   else if (*p == ' ')
 551     {
 552     *p++ = 0;
 553     sscanf(CS p, "%d", &pno);
 554     }
 555
 556   /* Handle current format Exim 4 spool files */
 557
 558   else if (*p == '#')
 559     {
 560     int flags;
 561     sscanf(CS p+1, "%d", &flags);
 562
 563     if ((flags & 0x01) != 0)      /* one_time data exists */
 564       {
 565       int len;
 566       while (isdigit(*(--p)) || *p == ',' || *p == '-');
 567       sscanf(CS p+1, "%d,%d", &len, &pno);
 568       *p = 0;
 569       if (len > 0)
 570         {
 571         p -= len;
 572         errors_to = string_copy(p);
 573         }
 574       }
 575
 576     *(--p) = 0;   /* Terminate address */
 577     }
 578
 579   recipients_list[recipients_count].address = string_copy(big_buffer);
 580   recipients_list[recipients_count].pno = pno;
 581   recipients_list[recipients_count].errors_to = errors_to;
 582   }
 583
 584 /* The remainder of the spool header file contains the headers for the message,
 585 separated off from the previous data by a blank line. Each header is preceded
 586 by a count of its length and either a certain letter (for various identified
 587 headers), space (for a miscellaneous live header) or an asterisk (for a header
 588 that has been rewritten). Count the Received: headers. We read the headers
 589 always, in order to check on the format of the file, but only create a header
 590 list if requested to do so. */
 591
 592 inheader = TRUE;
 593 if (Ufgets(big_buffer, big_buffer_size, f) == NULL) goto SPOOL_READ_ERROR;
 594 if (big_buffer[0] != '\n') goto SPOOL_FORMAT_ERROR;
 595
 596 while ((n = fgetc(f)) != EOF)
 597   {
 598   header_line *h;
 599   uschar flag[4];
 600   int i;
 601
 602   if (!isdigit(n)) goto SPOOL_FORMAT_ERROR;
 603   ungetc(n, f);
 604   fscanf(f, "%d%c ", &n, flag);
 605   if (flag[0] != '*') message_size += n;  /* Omit non-transmitted headers */
 606
 607   if (read_headers)
 608     {
 609     h = store_get(sizeof(header_line));
 610     h->next = NULL;
 611     h->type = flag[0];
 612     h->slen = n;
 613     h->text = store_get(n+1);
 614
 615     if (h->type == htype_received) received_count++;
 616
 617     if (header_list == NULL) header_list = h;
 618       else header_last->next = h;
 619     header_last = h;
 620
 621     for (i = 0; i < n; i++)
 622       {
 623       int c = fgetc(f);
 624       if (c == 0 || c == EOF) goto SPOOL_FORMAT_ERROR;
 625       if (c == '\n' && h->type != htype_old) message_linecount++;
 626       h->text[i] = c;
 627       }
 628     h->text[i] = 0;
 629     }
 630
 631   /* Not requiring header data, just skip through the bytes */
 632
 633   else for (i = 0; i < n; i++)
 634     {
 635     int c = fgetc(f);
 636     if (c == 0 || c == EOF) goto SPOOL_FORMAT_ERROR;
 637     }
 638   }
 639
 640 /* We have successfully read the data in the header file. Update the message
 641 line count by adding the body linecount to the header linecount. Close the file
 642 and give a positive response. */
 643
 644 #ifndef COMPILE_UTILITY
 645 DEBUG(D_deliver) debug_printf("body_linecount=%d message_linecount=%d\n",
 646   body_linecount, message_linecount);
 647 #endif  /* COMPILE_UTILITY */
 648
 649 message_linecount += body_linecount;
 650
 651 fclose(f);
 652 return spool_read_OK;
 653
 654
 655 /* There was an error reading the spool or there was missing data,
 656 or there was a format error. A "read error" with no errno means an
 657 unexpected EOF, which we treat as a format error. */
 658
 659 SPOOL_READ_ERROR:
 660 if (errno != 0)
 661   {
 662   n = errno;
 663
 664   #ifndef COMPILE_UTILITY
 665   DEBUG(D_any) debug_printf("Error while reading spool file %s\n", name);
 666   #endif  /* COMPILE_UTILITY */
 667
 668   fclose(f);
 669   errno = n;
 670   return inheader? spool_read_hdrerror : spool_read_enverror;
 671   }
 672
 673 SPOOL_FORMAT_ERROR:
 674
 675 #ifndef COMPILE_UTILITY
 676 DEBUG(D_any) debug_printf("Format error in spool file %s\n", name);
 677 #endif  /* COMPILE_UTILITY */
 678
 679 fclose(f);
 680 errno = ERRNO_SPOOLFORMAT;
 681 return inheader? spool_read_hdrerror : spool_read_enverror;
 682 }
 683
 684 /* End of spool_in.c */