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