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