9c5e8eb33d9aa00e83807baa5900275682dbd546
[exim.git] / src / src / spool_out.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10 /* Functions for writing spool files, and moving them about. */
11
12
13 #include "exim.h"
14
15
16
17 /*************************************************
18 *       Deal with header writing errors          *
19 *************************************************/
20
21 /* This function is called immediately after errors in writing the spool, with
22 errno still set. It creates an error message, depending on the circumstances.
23 If errmsg is NULL, it logs the message and panic-dies. Otherwise errmsg is set
24 to point to the message, and -1 is returned. This function makes the code of
25 spool_write_header() a bit neater.
26
27 Arguments:
28    where      SW_RECEIVING, SW_DELIVERING, or SW_MODIFYING
29    errmsg     where to put the message; NULL => panic-die
30    s          text to add to log string
31    temp_name  name of temp file to unlink
32    f          FILE to close, if not NULL
33
34 Returns:      -1 if errmsg is not NULL; otherwise doesn't return
35 */
36
37 static int
38 spool_write_error(int where, uschar **errmsg, uschar *s, uschar *temp_name,
39   FILE *f)
40 {
41 uschar *msg = where == SW_RECEIVING
42   ? string_sprintf("spool file %s error while receiving from %s: %s", s,
43       sender_fullhost ? sender_fullhost : sender_ident,
44       strerror(errno))
45   : string_sprintf("spool file %s error while %s: %s", s,
46       where == SW_DELIVERING ? "delivering" : "modifying",
47       strerror(errno));
48
49 if (temp_name) Uunlink(temp_name);
50 if (f) (void)fclose(f);
51
52 if (errmsg)
53   *errmsg = msg;
54 else
55   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", msg);
56
57 return -1;
58 }
59
60
61
62 /*************************************************
63 *            Open file under temporary name      *
64 *************************************************/
65
66 /* This is used for opening spool files under a temporary name,
67 with a single attempt at deleting if they already exist.
68
69 Argument: temporary name for spool header file
70 Returns:  file descriptor of open file, or < 0 on failure, with errno unchanged
71 */
72
73 int
74 spool_open_temp(uschar *temp_name)
75 {
76 int fd = Uopen(temp_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE);
77
78 /* If the file already exists, something has gone wrong. This process may well
79 have previously created the file if it is delivering more than one address, but
80 it should have renamed it almost immediately. A file could, however, be left
81 around as a result of a system crash, and by coincidence this process might
82 have the same pid. We therefore have one go at unlinking it before giving up.
83 */
84
85 if (fd < 0 && errno == EEXIST)
86   {
87   DEBUG(D_any) debug_printf("%s exists: unlinking\n", temp_name);
88   Uunlink(temp_name);
89   fd = Uopen(temp_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE);
90   }
91
92 /* If the file has been opened, make sure the file's group is the Exim gid, and
93 double-check the mode because the group setting doesn't always get set
94 automatically. */
95
96 if (fd >= 0)
97   if (exim_fchown(fd, exim_uid, exim_gid, temp_name) || fchmod(fd, SPOOL_MODE))
98     {
99     DEBUG(D_any) debug_printf("failed setting perms on %s\n", temp_name);
100     (void) close(fd); fd = -1;
101     Uunlink(temp_name);
102     }
103
104 return fd;
105 }
106
107
108
109 static const uschar *
110 zap_newlines(const uschar *s)
111 {
112 uschar *z, *p;
113
114 if (Ustrchr(s, '\n') == NULL) return s;
115
116 p = z = string_copy(s);
117 while ((p = Ustrchr(p, '\n')) != NULL) *p++ = ' ';
118 return z;
119 }
120
121 static void
122 spool_var_write(FILE * fp, const uschar * name, const uschar * val)
123 {
124 putc('-', fp);
125 if (is_tainted(val))
126   {
127   int q = quoter_for_address(val);
128   putc('-', fp);
129   if (is_real_quoter(q)) fprintf(fp, "(%s)", lookup_list[q]->name);
130   }
131 fprintf(fp, "%s %s\n", name, val);
132 }
133
134 /*************************************************
135 *          Write the header spool file           *
136 *************************************************/
137
138 /* Returns the size of the file for success; zero for failure. The file is
139 written under a temporary name, and then renamed. It's done this way so that it
140 works with re-writing the file on message deferral as well as for the initial
141 write. Whenever this function is called, the data file for the message should
142 be open and locked, thus preventing any other exim process from working on this
143 message.
144
145 Argument:
146   id      the message id
147   where   SW_RECEIVING, SW_DELIVERING, or SW_MODIFYING
148   errmsg  where to put an error message; if NULL, panic-die on error
149
150 Returns:  the size of the header texts on success;
151           negative on writing failure, unless errmsg == NULL
152 */
153
154 int
155 spool_write_header(uschar *id, int where, uschar **errmsg)
156 {
157 int fd;
158 int size_correction;
159 FILE * fp;
160 struct stat statbuf;
161 uschar * tname;
162 uschar * fname;
163
164 tname = spool_fname(US"input", message_subdir, US"hdr.", message_id);
165
166 if ((fd = spool_open_temp(tname)) < 0)
167   return spool_write_error(where, errmsg, US"open", NULL, NULL);
168 fp = fdopen(fd, "wb");
169 DEBUG(D_receive|D_deliver) debug_printf("Writing spool header file: %s\n", tname);
170
171 /* We now have an open file to which the header data is to be written. Start
172 with the file's leaf name, to make the file self-identifying. Continue with the
173 identity of the submitting user, followed by the sender's address. The sender's
174 address is enclosed in <> because it might be the null address. Then write the
175 received time and the number of warning messages that have been sent. */
176
177 fprintf(fp, "%s-H\n", message_id);
178 fprintf(fp, "%.63s %ld %ld\n", originator_login, (long int)originator_uid,
179   (long int)originator_gid);
180 fprintf(fp, "<%s>\n", sender_address);
181 fprintf(fp, "%d %d\n", (int)received_time.tv_sec, warning_count);
182
183 fprintf(fp, "-received_time_usec .%06d\n", (int)received_time.tv_usec);
184 fprintf(fp, "-received_time_complete %d.%06d\n",
185   (int)received_time_complete.tv_sec, (int)received_time_complete.tv_usec);
186
187 /* If there is information about a sending host, remember it. The HELO
188 data can be set for local SMTP as well as remote. */
189
190 if (sender_helo_name) spool_var_write(fp, US"helo_name", sender_helo_name);
191
192 if (sender_host_address)
193   {
194   if (is_tainted(sender_host_address)) putc('-', fp);
195   fprintf(fp, "-host_address [%s]:%d\n", sender_host_address, sender_host_port);
196   if (sender_host_name)
197     spool_var_write(fp, US"host_name", sender_host_name);
198   }
199 if (sender_host_authenticated)
200   spool_var_write(fp, US"host_auth", sender_host_authenticated);
201 if (sender_host_auth_pubname)
202   spool_var_write(fp, US"host_auth_pubname", sender_host_auth_pubname);
203
204 /* Also about the interface a message came in on */
205
206 if (interface_address)
207   {
208   if (is_tainted(interface_address)) putc('-', fp);
209   fprintf(fp, "-interface_address [%s]:%d\n", interface_address, interface_port);
210   }
211
212 if (smtp_active_hostname != primary_hostname)
213   spool_var_write(fp, US"active_hostname", smtp_active_hostname);
214
215 /* Likewise for any ident information; for local messages this is
216 likely to be the same as originator_login, but will be different if
217 the originator was root, forcing a different ident. */
218
219 if (sender_ident)
220   spool_var_write(fp, US"ident", sender_ident);
221
222 /* Ditto for the received protocol */
223
224 if (received_protocol)
225   spool_var_write(fp, US"received_protocol", received_protocol);
226
227 /* Preserve any ACL variables that are set. */
228
229 tree_walk(acl_var_c, &acl_var_write, fp);
230 tree_walk(acl_var_m, &acl_var_write, fp);
231
232 /* Now any other data that needs to be remembered. */
233
234 if (*debuglog_name)
235   {
236   fprintf(fp, "-debug_selector 0x%x\n", debug_selector);
237   fprintf(fp, "-debuglog_name %s\n", debuglog_name);
238   }
239
240 if (f.spool_file_wireformat)
241   fprintf(fp, "-spool_file_wireformat\n");
242 else
243   fprintf(fp, "-body_linecount %d\n", body_linecount);
244 fprintf(fp, "-max_received_linelength %d\n", max_received_linelength);
245
246 if (body_zerocount > 0) fprintf(fp, "-body_zerocount %d\n", body_zerocount);
247
248 if (authenticated_id)
249   spool_var_write(fp, US"auth_id", authenticated_id);
250 if (authenticated_sender)
251   spool_var_write(fp, US"auth_sender", zap_newlines(authenticated_sender));
252
253 if (f.allow_unqualified_recipient) fprintf(fp, "-allow_unqualified_recipient\n");
254 if (f.allow_unqualified_sender) fprintf(fp, "-allow_unqualified_sender\n");
255 if (f.deliver_firsttime) fprintf(fp, "-deliver_firsttime\n");
256 if (f.deliver_freeze) fprintf(fp, "-frozen " TIME_T_FMT "\n", deliver_frozen_at);
257 if (f.dont_deliver) fprintf(fp, "-N\n");
258 if (host_lookup_deferred) fprintf(fp, "-host_lookup_deferred\n");
259 if (host_lookup_failed) fprintf(fp, "-host_lookup_failed\n");
260 if (f.sender_local) fprintf(fp, "-local\n");
261 if (f.local_error_message) fprintf(fp, "-localerror\n");
262 #ifdef HAVE_LOCAL_SCAN
263 if (local_scan_data) spool_var_write(fp, US"local_scan", local_scan_data);
264 #endif
265 #ifdef WITH_CONTENT_SCAN
266 if (spam_bar)       spool_var_write(fp, US"spam_bar",       spam_bar);
267 if (spam_score)     spool_var_write(fp, US"spam_score",     spam_score);
268 if (spam_score_int) spool_var_write(fp, US"spam_score_int", spam_score_int);
269 #endif
270 if (f.deliver_manual_thaw) fprintf(fp, "-manual_thaw\n");
271 if (f.sender_set_untrusted) fprintf(fp, "-sender_set_untrusted\n");
272
273 #ifdef EXPERIMENTAL_BRIGHTMAIL
274 if (bmi_verdicts) spool_var_write(fp, US"bmi_verdicts", bmi_verdicts);
275 #endif
276
277 #ifndef DISABLE_TLS
278 if (tls_in.certificate_verified) fprintf(fp, "-tls_certificate_verified\n");
279 if (tls_in.cipher) spool_var_write(fp, US"tls_cipher", tls_in.cipher);
280 if (tls_in.peercert)
281   {
282   if (tls_export_cert(big_buffer, big_buffer_size, tls_in.peercert))
283     fprintf(fp, "--tls_peercert %s\n", CS big_buffer);
284   }
285 if (tls_in.peerdn)       spool_var_write(fp, US"tls_peerdn", string_printing(tls_in.peerdn));
286 if (tls_in.sni)          spool_var_write(fp, US"tls_sni",    string_printing(tls_in.sni));
287 if (tls_in.ourcert)
288   {
289   if (tls_export_cert(big_buffer, big_buffer_size, tls_in.ourcert))
290     fprintf(fp, "-tls_ourcert %s\n", CS big_buffer);
291   }
292 if (tls_in.ocsp)         fprintf(fp, "-tls_ocsp %d\n",   tls_in.ocsp);
293 # ifndef DISABLE_TLS_RESUME
294 fprintf(fp, "-tls_resumption %c\n", 'A' + tls_in.resumption);
295 # endif
296 if (tls_in.ver) spool_var_write(fp, US"tls_ver", tls_in.ver);
297 #endif
298
299 #ifdef SUPPORT_I18N
300 if (message_smtputf8)
301   {
302   fprintf(fp, "-smtputf8\n");
303   if (message_utf8_downconvert)
304     fprintf(fp, "-utf8_%sdowncvt\n", message_utf8_downconvert < 0 ? "opt" : "");
305   }
306 #endif
307
308 /* Write the dsn flags to the spool header file */
309 /* DEBUG(D_deliver) debug_printf("DSN: Write SPOOL: -dsn_envid %s\n", dsn_envid); */
310 if (dsn_envid) fprintf(fp, "-dsn_envid %s\n", dsn_envid);
311 /* DEBUG(D_deliver) debug_printf("DSN: Write SPOOL: -dsn_ret %d\n", dsn_ret); */
312 if (dsn_ret) fprintf(fp, "-dsn_ret %d\n", dsn_ret);
313
314 /* To complete the envelope, write out the tree of non-recipients, followed by
315 the list of recipients. These won't be disjoint the first time, when no
316 checking has been done. If a recipient is a "one-time" alias, it is followed by
317 a space and its parent address number (pno). */
318
319 tree_write(tree_nonrecipients, fp);
320 fprintf(fp, "%d\n", recipients_count);
321 for (int i = 0; i < recipients_count; i++)
322   {
323   recipient_item *r = recipients_list + i;
324   const uschar *address = zap_newlines(r->address);
325
326   /* DEBUG(D_deliver) debug_printf("DSN: Flags: 0x%x\n", r->dsn_flags); */
327
328   if (r->pno < 0 && !r->errors_to && r->dsn_flags == 0)
329     fprintf(fp, "%s\n", address);
330   else
331     {
332     const uschar *errors_to = r->errors_to ? zap_newlines(r->errors_to) : CUS"";
333     /* for DSN SUPPORT extend exim 4 spool in a compatible way by
334     adding new values upfront and add flag 0x02 */
335     const uschar *orcpt = r->orcpt ? zap_newlines(r->orcpt) : CUS"";
336
337     fprintf(fp, "%s %s %d,%d %s %d,%d#3\n", address, orcpt, Ustrlen(orcpt),
338       r->dsn_flags, errors_to, Ustrlen(errors_to), r->pno);
339     }
340
341     DEBUG(D_deliver) debug_printf("DSN: **** SPOOL_OUT - "
342       "address: <%s> errorsto: <%s> orcpt: <%s> dsn_flags: 0x%x\n",
343       r->address, r->errors_to, r->orcpt, r->dsn_flags);
344   }
345
346 /* Put a blank line before the headers */
347
348 fprintf(fp, "\n");
349
350 /* Save the size of the file so far so we can subtract it from the final length
351 to get the actual size of the headers. */
352
353 fflush(fp);
354 if (fstat(fd, &statbuf))
355   return spool_write_error(where, errmsg, US"fstat", tname, fp);
356 size_correction = statbuf.st_size;
357
358 /* Finally, write out the message's headers. To make it easier to read them
359 in again, precede each one with the count of its length. Make the count fixed
360 length to aid human eyes when debugging and arrange for it not be included in
361 the size. It is followed by a space for normal headers, a flagging letter for
362 various other headers, or an asterisk for old headers that have been rewritten.
363 These are saved as a record for debugging. Don't included them in the message's
364 size. */
365
366 for (header_line * h = header_list; h; h = h->next)
367   {
368   fprintf(fp, "%03d%c %s", h->slen, h->type, h->text);
369   size_correction += 5;
370   if (h->type == '*') size_correction += h->slen;
371   }
372
373 /* Flush and check for any errors while writing */
374
375 if (fflush(fp) != 0 || ferror(fp))
376   return spool_write_error(where, errmsg, US"write", tname, fp);
377
378 /* Force the file's contents to be written to disk. Note that fflush()
379 just pushes it out of C, and fclose() doesn't guarantee to do the write
380 either. That's just the way Unix works... */
381
382 if (EXIMfsync(fileno(fp)) < 0)
383   return spool_write_error(where, errmsg, US"sync", tname, fp);
384
385 /* Get the size of the file, and close it. */
386
387 if (fstat(fd, &statbuf) != 0)
388   return spool_write_error(where, errmsg, US"fstat", tname, NULL);
389 if (fclose(fp) != 0)
390   return spool_write_error(where, errmsg, US"close", tname, NULL);
391
392 /* Rename the file to its correct name, thereby replacing any previous
393 incarnation. */
394
395 fname = spool_fname(US"input", message_subdir, id, US"-H");
396 DEBUG(D_receive|D_deliver) debug_printf("Renaming spool header file: %s\n", fname);
397
398 if (Urename(tname, fname) < 0)
399   return spool_write_error(where, errmsg, US"rename", tname, NULL);
400
401 /* Linux (and maybe other OS?) does not automatically sync a directory after
402 an operation like rename. We therefore have to do it forcibly ourselves in
403 these cases, to make sure the file is actually accessible on disk, as opposed
404 to just the data being accessible from a file in lost+found. Linux also has
405 O_DIRECTORY, for opening a directory.
406
407 However, it turns out that some file systems (some versions of NFS?) do not
408 support directory syncing. It seems safe enough to ignore EINVAL to cope with
409 these cases. One hack on top of another... but that's life. */
410
411 #ifdef NEED_SYNC_DIRECTORY
412
413 tname = spool_fname(US"input", message_subdir, US".", US"");
414
415 # ifndef O_DIRECTORY
416 #  define O_DIRECTORY 0
417 # endif
418
419 if ((fd = Uopen(tname, O_RDONLY|O_DIRECTORY, 0)) < 0)
420   return spool_write_error(where, errmsg, US"directory open", fname, NULL);
421
422 if (EXIMfsync(fd) < 0 && errno != EINVAL)
423   return spool_write_error(where, errmsg, US"directory sync", fname, NULL);
424
425 if (close(fd) < 0)
426   return spool_write_error(where, errmsg, US"directory close", fname, NULL);
427
428 #endif  /* NEED_SYNC_DIRECTORY */
429
430 /* Return the number of characters in the headers, which is the file size, less
431 the preliminary stuff, less the additional count fields on the headers. */
432
433 DEBUG(D_receive) debug_printf("Size of headers = %d\n",
434   (int)(statbuf.st_size - size_correction));
435
436 return statbuf.st_size - size_correction;
437 }
438
439
440 /************************************************
441 *              Make a hard link                 *
442 ************************************************/
443
444 /* Used by spool_move_message() below. Note re the use of sprintf(): the value
445 of spool_directory is checked to ensure that it is less than 200 characters at
446 start-up time.
447
448 Arguments:
449   dir        base directory name
450   dq         destiinationqueue name
451   subdir     subdirectory name
452   id         message id
453   suffix     suffix to add to id
454   from       source directory prefix
455   to         destination directory prefix
456   noentok    if TRUE, absence of file is not an error
457
458 Returns:     TRUE if all went well
459              FALSE, having panic logged if not
460 */
461
462 static BOOL
463 make_link(uschar *dir, uschar * dq, uschar *subdir, uschar *id, uschar *suffix,
464   uschar *from, uschar *to, BOOL noentok)
465 {
466 uschar * fname = spool_fname(string_sprintf("%s%s", from, dir), subdir, id, suffix);
467 uschar * tname = spool_q_fname(string_sprintf("%s%s", to,   dir), dq, subdir, id, suffix);
468 if (Ulink(fname, tname) < 0 && (!noentok || errno != ENOENT))
469   {
470   log_write(0, LOG_MAIN|LOG_PANIC, "link(\"%s\", \"%s\") failed while moving "
471     "message: %s", fname, tname, strerror(errno));
472   return FALSE;
473   }
474 return TRUE;
475 }
476
477
478
479 /************************************************
480 *                Break a link                   *
481 ************************************************/
482
483 /* Used by spool_move_message() below. Note re the use of sprintf(): the value
484 of spool_directory is checked to ensure that it is less than 200 characters at
485 start-up time.
486
487 Arguments:
488   dir        base directory name
489   subdir     subdirectory name
490   id         message id
491   suffix     suffix to add to id
492   from       source directory prefix
493   noentok    if TRUE, absence of file is not an error
494
495 Returns:     TRUE if all went well
496              FALSE, having panic logged if not
497 */
498
499 static BOOL
500 break_link(uschar *dir, uschar *subdir, uschar *id, uschar *suffix, uschar *from,
501   BOOL noentok)
502 {
503 uschar * fname = spool_fname(string_sprintf("%s%s", from, dir), subdir, id, suffix);
504 if (Uunlink(fname) < 0 && (!noentok || errno != ENOENT))
505   {
506   log_write(0, LOG_MAIN|LOG_PANIC, "unlink(\"%s\") failed while moving "
507     "message: %s", fname, strerror(errno));
508   return FALSE;
509   }
510 return TRUE;
511 }
512
513
514
515 /************************************************
516 *            Move message files                 *
517 ************************************************/
518
519 /* Move the files for a message (-H, -D, and msglog) from one directory (or
520 hierarchy) to another. It is assume that there is no -J file in existence when
521 this is done.
522
523 Arguments:
524   id          the id of the message to be delivered
525   subdir      the subdirectory name, or an empty string
526   from        a prefix for "input" or "msglog" for where the message is now
527   to          a prefix for "input" or "msglog" for where the message is to go
528
529 Returns:      TRUE if all is well
530               FALSE if not, with error logged in panic and main logs
531 */
532
533 BOOL
534 spool_move_message(uschar *id, uschar *subdir, uschar *from, uschar *to)
535 {
536 uschar * dest_qname = queue_name_dest ? queue_name_dest : queue_name;
537
538 /* Since we are working within the spool, de-taint the dest queue name */
539 dest_qname = string_copy_taint(dest_qname, GET_UNTAINTED);
540
541 /* Create any output directories that do not exist. */
542
543 (void) directory_make(spool_directory,
544   spool_q_sname(string_sprintf("%sinput", to), dest_qname, subdir),
545   INPUT_DIRECTORY_MODE, TRUE);
546 (void) directory_make(spool_directory,
547   spool_q_sname(string_sprintf("%smsglog", to), dest_qname, subdir),
548   INPUT_DIRECTORY_MODE, TRUE);
549
550 /* Move the message by first creating new hard links for all the files, and
551 then removing the old links. When moving messages onto the main spool, the -H
552 file should be set up last, because that's the one that tells Exim there is a
553 message to be delivered, so we create its new link last and remove its old link
554 first. Programs that look at the alternate directories should follow the same
555 rule of waiting for a -H file before doing anything. When moving messages off
556 the mail spool, the -D file should be open and locked at the time, thus keeping
557 Exim's hands off. */
558
559 if (!make_link(US"msglog", dest_qname, subdir, id, US"", from, to, TRUE) ||
560     !make_link(US"input",  dest_qname, subdir, id, US"-D", from, to, FALSE) ||
561     !make_link(US"input",  dest_qname, subdir, id, US"-H", from, to, FALSE))
562   return FALSE;
563
564 if (!break_link(US"input",  subdir, id, US"-H", from, FALSE) ||
565     !break_link(US"input",  subdir, id, US"-D", from, FALSE) ||
566     !break_link(US"msglog", subdir, id, US"", from, TRUE))
567   return FALSE;
568
569 log_write(0, LOG_MAIN, "moved from %s%s%s%sinput, %smsglog to %s%s%s%sinput, %smsglog",
570    *queue_name?"(":"", *queue_name?queue_name:US"", *queue_name?") ":"",
571    from, from,
572    *dest_qname?"(":"", *dest_qname?dest_qname:US"", *dest_qname?") ":"",
573    to, to);
574
575 return TRUE;
576 }
577
578
579 /* End of spool_out.c */
580 /* vi: aw ai sw=2
581 */