ec41ca035a660ac595891de62beddf139314427e
[exim.git] / src / src / transports / appendfile.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim maintainers 2020 - 2023 */
6 /* Copyright (c) University of Cambridge 1995 - 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10
11 #include "../exim.h"
12 #include "appendfile.h"
13
14 #ifdef SUPPORT_MAILDIR
15 #include "tf_maildir.h"
16 #endif
17
18
19 /* Options specific to the appendfile transport. They must be in alphabetic
20 order (note that "_" comes before the lower case letters). Some of them are
21 stored in the publicly visible instance block - these are flagged with the
22 opt_public flag. */
23 #define LOFF(field) OPT_OFF(appendfile_transport_options_block, field)
24
25 optionlist appendfile_transport_options[] = {
26 #ifdef SUPPORT_MAILDIR
27   { "*expand_maildir_use_size_file", opt_stringptr, LOFF(expand_maildir_use_size_file) },
28 #endif
29   { "*set_use_fcntl_lock",opt_bool | opt_hidden, LOFF(set_use_fcntl) },
30   { "*set_use_flock_lock",opt_bool | opt_hidden, LOFF(set_use_flock) },
31   { "*set_use_lockfile", opt_bool | opt_hidden, LOFF(set_use_lockfile) },
32 #ifdef SUPPORT_MBX
33   { "*set_use_mbx_lock", opt_bool | opt_hidden, LOFF(set_use_mbx_lock) },
34 #endif
35   { "allow_fifo",        opt_bool,      LOFF(allow_fifo) },
36   { "allow_symlink",     opt_bool,      LOFF(allow_symlink) },
37   { "batch_id",          opt_stringptr | opt_public, OPT_OFF(transport_instance, batch_id) },
38   { "batch_max",         opt_int | opt_public, OPT_OFF(transport_instance, batch_max) },
39   { "check_group",       opt_bool,      LOFF(check_group) },
40   { "check_owner",       opt_bool,      LOFF(check_owner) },
41   { "check_string",      opt_stringptr, LOFF(check_string) },
42   { "create_directory",  opt_bool,      LOFF(create_directory) },
43   { "create_file",       opt_stringptr, LOFF(create_file_string) },
44   { "directory",         opt_stringptr, LOFF(dirname) },
45   { "directory_file",    opt_stringptr, LOFF(dirfilename) },
46   { "directory_mode",    opt_octint,    LOFF(dirmode) },
47   { "escape_string",     opt_stringptr, LOFF(escape_string) },
48   { "file",              opt_stringptr, LOFF(filename) },
49   { "file_format",       opt_stringptr, LOFF(file_format) },
50   { "file_must_exist",   opt_bool,      LOFF(file_must_exist) },
51   { "lock_fcntl_timeout", opt_time,     LOFF(lock_fcntl_timeout) },
52   { "lock_flock_timeout", opt_time,     LOFF(lock_flock_timeout) },
53   { "lock_interval",     opt_time,      LOFF(lock_interval) },
54   { "lock_retries",      opt_int,       LOFF(lock_retries) },
55   { "lockfile_mode",     opt_octint,    LOFF(lockfile_mode) },
56   { "lockfile_timeout",  opt_time,      LOFF(lockfile_timeout) },
57   { "mailbox_filecount", opt_stringptr, LOFF(mailbox_filecount_string) },
58   { "mailbox_size",      opt_stringptr, LOFF(mailbox_size_string) },
59 #ifdef SUPPORT_MAILDIR
60   { "maildir_format",    opt_bool,      LOFF(maildir_format ) } ,
61   { "maildir_quota_directory_regex", opt_stringptr, LOFF(maildir_dir_regex) },
62   { "maildir_retries",   opt_int,       LOFF(maildir_retries) },
63   { "maildir_tag",       opt_stringptr, LOFF(maildir_tag) },
64   { "maildir_use_size_file", opt_expand_bool, LOFF(maildir_use_size_file ) } ,
65   { "maildirfolder_create_regex", opt_stringptr, LOFF(maildirfolder_create_regex ) },
66 #endif  /* SUPPORT_MAILDIR */
67 #ifdef SUPPORT_MAILSTORE
68   { "mailstore_format",  opt_bool,      LOFF(mailstore_format ) },
69   { "mailstore_prefix",  opt_stringptr, LOFF(mailstore_prefix ) },
70   { "mailstore_suffix",  opt_stringptr, LOFF(mailstore_suffix ) },
71 #endif  /* SUPPORT_MAILSTORE */
72 #ifdef SUPPORT_MBX
73   { "mbx_format",        opt_bool,      LOFF(mbx_format ) } ,
74 #endif  /* SUPPORT_MBX */
75   { "message_prefix",    opt_stringptr, LOFF(message_prefix) },
76   { "message_suffix",    opt_stringptr, LOFF(message_suffix) },
77   { "mode",              opt_octint,    LOFF(mode) },
78   { "mode_fail_narrower",opt_bool,      LOFF(mode_fail_narrower) },
79   { "notify_comsat",     opt_bool,      LOFF(notify_comsat) },
80   { "quota",             opt_stringptr, LOFF(quota) },
81   { "quota_directory",   opt_stringptr, LOFF(quota_directory) },
82   { "quota_filecount",   opt_stringptr, LOFF(quota_filecount) },
83   { "quota_is_inclusive", opt_bool,     LOFF(quota_is_inclusive) },
84   { "quota_size_regex",   opt_stringptr, LOFF(quota_size_regex) },
85   { "quota_warn_message", opt_stringptr | opt_public, OPT_OFF(transport_instance, warn_message) },
86   { "quota_warn_threshold", opt_stringptr, LOFF(quota_warn_threshold) },
87   { "use_bsmtp",         opt_bool,      LOFF(use_bsmtp) },
88   { "use_crlf",          opt_bool,      LOFF(use_crlf) },
89   { "use_fcntl_lock",    opt_bool_set,  LOFF(use_fcntl) },
90   { "use_flock_lock",    opt_bool_set,  LOFF(use_flock) },
91   { "use_lockfile",      opt_bool_set,  LOFF(use_lockfile) },
92 #ifdef SUPPORT_MBX
93   { "use_mbx_lock",      opt_bool_set,  LOFF(use_mbx_lock) },
94 #endif  /* SUPPORT_MBX */
95 };
96
97 /* Size of the options list. An extern variable has to be used so that its
98 address can appear in the tables drtables.c. */
99
100 int appendfile_transport_options_count =
101   sizeof(appendfile_transport_options)/sizeof(optionlist);
102
103
104 #ifdef MACRO_PREDEF
105
106 /* Dummy values */
107 appendfile_transport_options_block appendfile_transport_option_defaults = {0};
108 void appendfile_transport_init(transport_instance *tblock) {}
109 BOOL appendfile_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
110
111 #else   /*!MACRO_PREDEF*/
112
113 /* Default private options block for the appendfile transport. */
114
115 appendfile_transport_options_block appendfile_transport_option_defaults = {
116   /* all non-mentioned members zero/null/false */
117   .dirfilename = US"q${base62:$tod_epoch}-$inode",
118   .create_file_string = US"anywhere",
119   .maildir_dir_regex = US"^(?:cur|new|\\..*)$",
120   .mailbox_size_value = -1,
121   .mailbox_filecount_value = -1,
122   .mode = APPENDFILE_MODE,
123   .dirmode = APPENDFILE_DIRECTORY_MODE,
124   .lockfile_mode = APPENDFILE_LOCKFILE_MODE,
125   .lockfile_timeout = 30*60,
126   .lock_retries = 10,
127    .lock_interval = 3,
128   .maildir_retries = 10,
129   .create_file = create_anywhere,
130   .check_owner = TRUE,
131   .create_directory = TRUE,
132   .notify_comsat = FALSE,
133   .use_lockfile = TRUE,
134   .use_fcntl = TRUE,
135   .mode_fail_narrower = TRUE,
136   .quota_is_inclusive = TRUE,
137 };
138
139
140 /* Encodings for mailbox formats, and their names. MBX format is actually
141 supported only if SUPPORT_MBX is set. */
142
143 enum { mbf_unix, mbf_mbx, mbf_smail, mbf_maildir, mbf_mailstore };
144
145 static const char *mailbox_formats[] = {
146   "unix", "mbx", "smail", "maildir", "mailstore" };
147
148
149 /* Check warn threshold only if quota size set or not a percentage threshold
150    percentage check should only be done if quota > 0 */
151
152 #define THRESHOLD_CHECK  (ob->quota_warn_threshold_value > 0 && \
153   (!ob->quota_warn_threshold_is_percent || ob->quota_value > 0))
154
155
156
157 /*************************************************
158 *              Setup entry point                 *
159 *************************************************/
160
161 /* Called for each delivery in the privileged state, just before the uid/gid
162 are changed and the main entry point is called. We use this function to
163 expand any quota settings, so that it can access files that may not be readable
164 by the user. It is also used to pick up external mailbox size information, if
165 set.
166
167 Arguments:
168   tblock     points to the transport instance
169   addrlist   addresses about to be delivered (not used)
170   dummy      not used (doesn't pass back data)
171   uid        the uid that will be set (not used)
172   gid        the gid that will be set (not used)
173   errmsg     where to put an error message
174
175 Returns:     OK, FAIL, or DEFER
176 */
177
178 static int
179 appendfile_transport_setup(transport_instance *tblock, address_item *addrlist,
180   transport_feedback *dummy, uid_t uid, gid_t gid, uschar **errmsg)
181 {
182 appendfile_transport_options_block *ob =
183   (appendfile_transport_options_block *)(tblock->options_block);
184 uschar *q = ob->quota;
185 double default_value = 0.0;
186
187 if (ob->expand_maildir_use_size_file)
188         ob->maildir_use_size_file = expand_check_condition(ob->expand_maildir_use_size_file,
189                 US"`maildir_use_size_file` in transport", tblock->name);
190
191 /* Loop for quota, quota_filecount, quota_warn_threshold, mailbox_size,
192 mailbox_filecount */
193
194 for (int i = 0; i < 5; i++)
195   {
196   double d = default_value;
197   int no_check = 0;
198   uschar *which = NULL;
199
200   if (q)
201     {
202     uschar * rest, * s;
203
204     if (!(s =  expand_string(q)))
205       {
206       *errmsg = string_sprintf("Expansion of \"%s\" in %s transport failed: "
207         "%s", q, tblock->name, expand_string_message);
208       return f.search_find_defer ? DEFER : FAIL;
209       }
210
211     d = Ustrtod(s, &rest);
212
213     /* Handle following characters K, M, G, %, the latter being permitted
214     for quota_warn_threshold only. A threshold with no quota setting is
215     just ignored. */
216
217     if (tolower(*rest) == 'k') { d *= 1024.0; rest++; }
218     else if (tolower(*rest) == 'm') { d *= 1024.0*1024.0; rest++; }
219     else if (tolower(*rest) == 'g') { d *= 1024.0*1024.0*1024.0; rest++; }
220     else if (*rest == '%' && i == 2)
221       {
222       if (ob->quota_value <= 0 && !ob->maildir_use_size_file)
223         d = 0;
224       else if ((int)d < 0 || (int)d > 100)
225         {
226         *errmsg = string_sprintf("Invalid quota_warn_threshold percentage (%d)"
227           " for %s transport", (int)d, tblock->name);
228         return FAIL;
229         }
230       ob->quota_warn_threshold_is_percent = TRUE;
231       rest++;
232       }
233
234
235     /* For quota and quota_filecount there may be options
236     appended. Currently only "no_check", so we can be lazy parsing it */
237     if (i < 2 && Ustrstr(rest, "/no_check") == rest)
238       {
239        no_check = 1;
240        rest += sizeof("/no_check") - 1;
241       }
242
243     Uskip_whitespace(&rest);
244
245     if (*rest)
246       {
247       *errmsg = string_sprintf("Malformed value \"%s\" (expansion of \"%s\") "
248         "in %s transport", s, q, tblock->name);
249       return FAIL;
250       }
251     }
252
253   /* Set each value, checking for possible overflow. */
254
255   switch (i)
256     {
257     case 0:
258       if (d >= 2.0*1024.0*1024.0*1024.0 && sizeof(off_t) <= 4)
259         which = US"quota";
260       ob->quota_value = (off_t)d;
261       ob->quota_no_check = no_check;
262       q = ob->quota_filecount;
263       break;
264
265     case 1:
266       if (d >= 2.0*1024.0*1024.0*1024.0)
267         which = US"quota_filecount";
268       ob->quota_filecount_value = (int)d;
269       ob->quota_filecount_no_check = no_check;
270       q = ob->quota_warn_threshold;
271       break;
272
273     case 2:
274       if (d >= 2.0*1024.0*1024.0*1024.0 && sizeof(off_t) <= 4)
275           which = US"quota_warn_threshold";
276       ob->quota_warn_threshold_value = (off_t)d;
277       q = ob->mailbox_size_string;
278       default_value = -1.0;
279       break;
280
281     case 3:
282       if (d >= 2.0*1024.0*1024.0*1024.0 && sizeof(off_t) <= 4)
283         which = US"mailbox_size";;
284       ob->mailbox_size_value = (off_t)d;
285       q = ob->mailbox_filecount_string;
286       break;
287
288     case 4:
289       if (d >= 2.0*1024.0*1024.0*1024.0)
290         which = US"mailbox_filecount";
291       ob->mailbox_filecount_value = (int)d;
292       break;
293     }
294
295   if (which)
296     {
297     *errmsg = string_sprintf("%s value %.10g is too large (overflow) in "
298       "%s transport", which, d, tblock->name);
299     return FAIL;
300     }
301   }
302
303 return OK;
304 }
305
306
307
308 /*************************************************
309 *          Initialization entry point            *
310 *************************************************/
311
312 /* Called for each instance, after its options have been read, to
313 enable consistency checks to be done, or anything else that needs
314 to be set up. */
315
316 void
317 appendfile_transport_init(transport_instance *tblock)
318 {
319 appendfile_transport_options_block *ob =
320   (appendfile_transport_options_block *)(tblock->options_block);
321 uschar * s;
322
323 /* Set up the setup entry point, to be called in the privileged state */
324
325 tblock->setup = appendfile_transport_setup;
326
327 /* Lock_retries must be greater than zero */
328
329 if (ob->lock_retries == 0) ob->lock_retries = 1;
330
331 /* Only one of a file name or directory name must be given. */
332
333 if (ob->filename && ob->dirname)
334   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
335   "only one of \"file\" or \"directory\" can be specified", tblock->name);
336
337 /* If a file name was specified, neither quota_filecount nor quota_directory
338 must be given. */
339
340 if (ob->filename)
341   {
342   if (ob->quota_filecount)
343     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
344       "quota_filecount must not be set without \"directory\"", tblock->name);
345   if (ob->quota_directory)
346     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
347       "quota_directory must not be set without \"directory\"", tblock->name);
348   }
349
350 /* The default locking depends on whether MBX is set or not. Change the
351 built-in default if none of the lock options has been explicitly set. At least
352 one form of locking is required in all cases, but mbx locking changes the
353 meaning of fcntl and flock locking. */
354
355 /* Not all operating systems provide flock(). For those that do, if flock is
356 requested, the default for fcntl is FALSE. */
357
358 if (ob->use_flock)
359   {
360   #ifdef NO_FLOCK
361   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
362     "flock() support was not available in the operating system when this "
363     "binary was built", tblock->name);
364   #endif  /* NO_FLOCK */
365   if (!ob->set_use_fcntl) ob->use_fcntl = FALSE;
366   }
367
368 #ifdef SUPPORT_MBX
369 if (ob->mbx_format)
370   if (!ob->set_use_lockfile && !ob->set_use_fcntl && !ob->set_use_flock &&
371       !ob->set_use_mbx_lock)
372     {
373     ob->use_lockfile = ob->use_flock = FALSE;
374     ob->use_mbx_lock = ob->use_fcntl = TRUE;
375     }
376   else if (ob->use_mbx_lock)
377     {
378     if (!ob->set_use_lockfile) ob->use_lockfile = FALSE;
379     if (!ob->set_use_fcntl) ob->use_fcntl = FALSE;
380     if (!ob->set_use_flock) ob->use_flock = FALSE;
381     if (!ob->use_fcntl && !ob->use_flock) ob->use_fcntl = TRUE;
382     }
383 #endif  /* SUPPORT_MBX */
384
385 if (!ob->use_fcntl && !ob->use_flock && !ob->use_lockfile && !ob->use_mbx_lock)
386   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
387     "no locking configured", tblock->name);
388
389 /* Unset timeouts for non-used locking types */
390
391 if (!ob->use_fcntl) ob->lock_fcntl_timeout = 0;
392 if (!ob->use_flock) ob->lock_flock_timeout = 0;
393
394 /* If a directory name was specified, only one of maildir or mailstore may be
395 specified, and if quota_filecount or quota_directory is given, quota must
396 be set. */
397
398 if (ob->dirname)
399   {
400   if (ob->maildir_format && ob->mailstore_format)
401     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
402       "only one of maildir and mailstore may be specified", tblock->name);
403   if (ob->quota_filecount != NULL && ob->quota == NULL)
404     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
405       "quota must be set if quota_filecount is set", tblock->name);
406   if (ob->quota_directory != NULL && ob->quota == NULL)
407     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s transport:\n  "
408       "quota must be set if quota_directory is set", tblock->name);
409   }
410
411 /* If a fixed uid field is set, then a gid field must also be set. */
412
413 if (tblock->uid_set && !tblock->gid_set && !tblock->expand_gid)
414   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
415     "user set without group for the %s transport", tblock->name);
416
417 /* If "create_file" is set, check that a valid option is given, and set the
418 integer variable. */
419
420 if ((s = ob->create_file_string ) && *s)
421   {
422   int val = 0;
423   if (Ustrcmp(s, "anywhere") == 0)                      val = create_anywhere;
424   else if (*s == '/' || Ustrcmp(s, "belowhome") == 0)   val = create_belowhome;
425   else if (Ustrcmp(s, "inhome") == 0)                   val = create_inhome;
426   else
427     log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
428       "invalid value given for \"create_file\" for the %s transport: '%s'",
429       tblock->name, s);
430   ob->create_file = val;
431   }
432
433 /* If quota_warn_threshold is set, set up default for warn_message. It may
434 not be used if the actual threshold for a given delivery ends up as zero,
435 of if it's given as a percentage and there's no quota setting. */
436
437 if (ob->quota_warn_threshold)
438   {
439   if (!tblock->warn_message) tblock->warn_message = US
440     "To: $local_part@$domain\n"
441     "Subject: Your mailbox\n\n"
442     "This message is automatically created by mail delivery software (Exim).\n\n"
443     "The size of your mailbox has exceeded a warning threshold that is\n"
444     "set by the system administrator.\n";
445   }
446
447 /* If batch SMTP is set, force the check and escape strings, and arrange that
448 headers are also escaped. */
449
450 if (ob->use_bsmtp)
451   {
452   ob->check_string = US".";
453   ob->escape_string = US"..";
454   ob->options |= topt_escape_headers;
455   }
456
457 /* If not batch SMTP, not maildir, not mailstore, and directory is not set,
458 insert default values for for the affixes and the check/escape strings. */
459
460 else if (!ob->dirname && !ob->maildir_format && !ob->mailstore_format)
461   {
462   if (!ob->message_prefix) ob->message_prefix =
463     US"From ${if def:return_path{$return_path}{MAILER-DAEMON}} ${tod_bsdinbox}\n";
464   if (!ob->message_suffix) ob->message_suffix = US"\n";
465   if (!ob->check_string) ob->check_string = US"From ";
466   if (!ob->escape_string) ob->escape_string = US">From ";
467
468   }
469
470 /* Set up the bitwise options for transport_write_message from the various
471 driver options. Only one of body_only and headers_only can be set. */
472
473 ob->options |=
474   (tblock->body_only ? topt_no_headers : 0) |
475   (tblock->headers_only ? topt_no_body : 0) |
476   (tblock->return_path_add ? topt_add_return_path : 0) |
477   (tblock->delivery_date_add ? topt_add_delivery_date : 0) |
478   (tblock->envelope_to_add ? topt_add_envelope_to : 0) |
479   ((ob->use_crlf || ob->mbx_format) ? topt_use_crlf : 0);
480 }
481
482
483
484 /*************************************************
485 *                  Notify comsat                 *
486 *************************************************/
487
488 /* The comsat daemon is the thing that provides asynchronous notification of
489 the arrival of local messages, if requested by the user by "biff y". It is a
490 BSD thing that uses a TCP/IP protocol for communication. A message consisting
491 of the text "user@offset" must be sent, where offset is the place in the
492 mailbox where new mail starts. There is no scope for telling it which file to
493 look at, which makes it a less than useful if mail is being delivered into a
494 non-standard place such as the user's home directory. In fact, it doesn't seem
495 to pay much attention to the offset.
496
497 Arguments:
498   user       user name
499   offset     offset in mailbox
500
501 Returns:     nothing
502 */
503
504 static void
505 notify_comsat(const uschar * user, off_t offset)
506 {
507 struct servent *sp;
508 host_item host;
509 uschar * s;
510
511 DEBUG(D_transport) debug_printf("notify_comsat called\n");
512
513 s = string_sprintf("%.200s@" OFF_T_FMT "\n", user, offset);
514
515 if ((sp = getservbyname("biff", "udp")) == NULL)
516   {
517   DEBUG(D_transport) debug_printf("biff/udp is an unknown service");
518   return;
519   }
520
521 host.name = US"localhost";
522 host.next = NULL;
523
524
525 /* This code is all set up to look up "localhost" and use all its addresses
526 until one succeeds. However, it appears that at least on some systems, comsat
527 doesn't listen on the ::1 address. So for the moment, just force the address to
528 be 127.0.0.1. At some future stage, when IPv6 really is superseding IPv4, this
529 can be changed. (But actually, comsat is probably dying out anyway.) */
530
531 /******
532 if (host_find_byname(&host, NULL, 0, NULL, FALSE) == HOST_FIND_FAILED)
533   {
534   DEBUG(D_transport) debug_printf("\"localhost\" unknown\n");
535   return;
536   }
537 ******/
538
539 host.address = US"127.0.0.1";
540
541
542 for (host_item * h = &host; h; h = h->next)
543   {
544   int sock, rc;
545   int host_af = Ustrchr(h->address, ':') != NULL ? AF_INET6 : AF_INET;
546
547   DEBUG(D_transport) debug_printf("calling comsat on %s\n", h->address);
548
549   if ((sock = ip_socket(SOCK_DGRAM, host_af)) < 0) continue;
550
551   /* Connect never fails for a UDP socket, so don't set a timeout. */
552
553   (void)ip_connect(sock, host_af, h->address, ntohs(sp->s_port), 0, NULL);
554   rc = send(sock, s, Ustrlen(s) + 1, 0);
555   (void)close(sock);
556
557   if (rc >= 0) break;
558   DEBUG(D_transport)
559     debug_printf("send to comsat failed for %s: %s\n", strerror(errno),
560       h->address);
561   }
562 }
563
564
565
566 /*************************************************
567 *     Check the format of a file                 *
568 *************************************************/
569
570 /* This function is called when file_format is set, to check that an existing
571 file has the right format. The format string contains text/transport pairs. The
572 string matching is literal. we just read big_buffer_size bytes, because this is
573 all about the first few bytes of a file.
574
575 Arguments:
576   cfd          the open file
577   tblock       the transport block
578   addr         the address block - for inserting error data
579
580 Returns:       pointer to the required transport, or NULL
581 */
582
583 transport_instance *
584 check_file_format(int cfd, transport_instance *tblock, address_item *addr)
585 {
586 const uschar *format =
587   ((appendfile_transport_options_block *)(tblock->options_block))->file_format;
588 uschar data[256];
589 int len = read(cfd, data, sizeof(data));
590 int sep = 0;
591 uschar *s;
592
593 DEBUG(D_transport) debug_printf("checking file format\n");
594
595 /* An empty file matches the current transport */
596
597 if (len == 0) return tblock;
598
599 /* Search the formats for a match */
600
601 /* not expanded so cannot be tainted */
602 while ((s = string_nextinlist(&format, &sep, big_buffer, big_buffer_size)))
603   {
604   int slen = Ustrlen(s);
605   BOOL match = len >= slen && Ustrncmp(data, s, slen) == 0;
606   uschar *tp = string_nextinlist(&format, &sep, big_buffer, big_buffer_size);
607
608   if (match && tp)
609     {
610     for (transport_instance * tt = transports; tt; tt = tt->next)
611       if (Ustrcmp(tp, tt->name) == 0)
612         {
613         DEBUG(D_transport)
614           debug_printf("file format -> %s transport\n", tt->name);
615         return tt;
616         }
617     addr->basic_errno = ERRNO_BADTRANSPORT;
618     addr->message = string_sprintf("%s transport (for %.*s format) not found",
619       tp, slen, data);
620     return NULL;
621     }
622   }
623
624 /* Failed to find a match */
625
626 addr->basic_errno = ERRNO_FORMATUNKNOWN;
627 addr->message = US"mailbox file format unrecognized";
628 return NULL;
629 }
630
631
632
633
634 /*************************************************
635 *       Check directory's files for quota        *
636 *************************************************/
637
638 /* This function is called if quota is set for one of the delivery modes that
639 delivers into a specific directory. It scans the directory and stats all the
640 files in order to get a total size and count. This is an expensive thing to do,
641 but some people are prepared to bear the cost. Alternatively, if size_regex is
642 set, it is used as a regex to try to extract the size from the file name, a
643 strategy that some people use on maildir files on systems where the users have
644 no shell access.
645
646 The function is global, because it is also called from tf_maildir.c for maildir
647 folders (which should contain only regular files).
648
649 Note: Any problems can be written to debugging output, but cannot be written to
650 the log, because we are running as an unprivileged user here.
651
652 Arguments:
653   dirname       the name of the directory
654   countptr      where to add the file count (because this function recurses)
655   re            a compiled regex to get the size from a name
656
657 Returns:        the sum of the sizes of the stattable files
658                 zero if the directory cannot be opened
659 */
660
661 off_t
662 check_dir_size(const uschar * dirname, int * countptr, const pcre2_code * re)
663 {
664 DIR *dir;
665 off_t sum = 0;
666 int count = *countptr;
667
668 if (!(dir = exim_opendir(dirname))) return 0;
669
670 for (struct dirent *ent; ent = readdir(dir); )
671   {
672   uschar * path, * name = US ent->d_name;
673   struct stat statbuf;
674
675   if (Ustrcmp(name, ".") == 0 || Ustrcmp(name, "..") == 0) continue;
676
677   count++;
678
679   /* If there's a regex, try to find the size using it */
680
681   if (re)
682     {
683     pcre2_match_data * md = pcre2_match_data_create(2, pcre_gen_ctx);
684     int rc = pcre2_match(re, (PCRE2_SPTR)name, PCRE2_ZERO_TERMINATED,
685                           0, 0, md, pcre_gen_mtc_ctx);
686     PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
687     if (  rc >= 0
688        && (rc = pcre2_get_ovector_count(md)) >= 2)
689       {
690       uschar *endptr;
691       off_t size = (off_t)Ustrtod(name + ovec[2], &endptr);
692       if (endptr == name + ovec[3])
693         {
694         sum += size;
695         DEBUG(D_transport)
696           debug_printf("check_dir_size: size from %s is " OFF_T_FMT "\n", name,
697             size);
698         /* pcre2_match_data_free(md);   gen ctx needs no free */
699         continue;
700         }
701       }
702     /* pcre2_match_data_free(md);       gen ctx needs no free */
703     DEBUG(D_transport)
704       debug_printf("check_dir_size: regex did not match %s\n", name);
705     }
706
707   /* No regex or no match for the regex, or captured non-digits */
708
709   path = string_sprintf("%s/%s", dirname, name);
710
711   if (Ustat(path, &statbuf) < 0)
712     {
713     DEBUG(D_transport)
714       debug_printf("check_dir_size: stat error %d for %s: %s\n", errno, path,
715         strerror(errno));
716     }
717   else
718     if ((statbuf.st_mode & S_IFMT) == S_IFREG)
719       sum += statbuf.st_size / statbuf.st_nlink;
720     else if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
721       sum += check_dir_size(path, &count, re);
722   }
723
724 closedir(dir);
725 DEBUG(D_transport)
726   debug_printf("check_dir_size: dir=%s sum=" OFF_T_FMT " count=%d\n", dirname,
727     sum, count);
728
729 *countptr = count;
730 return sum;
731 }
732
733
734
735
736 /*************************************************
737 *         Apply a lock to a file descriptor      *
738 *************************************************/
739
740 /* This function applies a lock to a file descriptor, using a blocking or
741 non-blocking lock, depending on the timeout value. It can apply either or
742 both of a fcntl() and a flock() lock. However, not all OS support flock();
743 for those that don't, the use_flock option cannot be set.
744
745 Arguments:
746   fd          the file descriptor
747   fcntltype   type of lock, specified as F_WRLCK or F_RDLCK (that is, in
748                 fcntl() format); the flock() type is deduced if needed
749   dofcntl     do fcntl() locking
750   fcntltime   non-zero to use blocking fcntl()
751   doflock     do flock() locking
752   flocktime   non-zero to use blocking flock()
753
754 Returns:      yield of the fcntl() or flock() call, with errno preserved;
755               sigalrm_seen set if there has been a timeout
756 */
757
758 static int
759 apply_lock(int fd, int fcntltype, BOOL dofcntl, int fcntltime, BOOL doflock,
760     int flocktime)
761 {
762 int yield = 0;
763 int save_errno;
764 struct flock lock_data;
765 lock_data.l_type = fcntltype;
766 lock_data.l_whence = lock_data.l_start = lock_data.l_len = 0;
767
768 sigalrm_seen = FALSE;
769
770 if (dofcntl)
771   {
772   if (fcntltime > 0)
773     {
774     ALARM(fcntltime);
775     yield = fcntl(fd, F_SETLKW, &lock_data);
776     save_errno = errno;
777     ALARM_CLR(0);
778     errno = save_errno;
779     }
780   else yield = fcntl(fd, F_SETLK, &lock_data);
781   }
782
783 #ifndef NO_FLOCK
784 if (doflock && (yield >= 0))
785   {
786   int flocktype = (fcntltype == F_WRLCK) ? LOCK_EX : LOCK_SH;
787   if (flocktime > 0)
788     {
789     ALARM(flocktime);
790     yield = flock(fd, flocktype);
791     save_errno = errno;
792     ALARM_CLR(0);
793     errno = save_errno;
794     }
795   else yield = flock(fd, flocktype | LOCK_NB);
796   }
797 #endif  /* NO_FLOCK */
798
799 return yield;
800 }
801
802
803
804
805 #ifdef SUPPORT_MBX
806 /*************************************************
807 *         Copy message into MBX mailbox          *
808 *************************************************/
809
810 /* This function is called when a message intended for a MBX mailbox has been
811 written to a temporary file. We can now get the size of the message and then
812 copy it in MBX format to the mailbox.
813
814 Arguments:
815   to_fd        fd to write to (the real mailbox)
816   from_fd      fd to read from (the temporary file)
817   saved_size   current size of mailbox
818
819 Returns:       OK if all went well, DEFER otherwise, with errno preserved
820                the number of bytes written are added to transport_count
821                  by virtue of calling transport_write_block()
822 */
823
824 /* Values taken from c-client */
825
826 #define MBX_HDRSIZE            2048
827 #define MBX_NUSERFLAGS           30
828
829 static int
830 copy_mbx_message(int to_fd, int from_fd, off_t saved_size)
831 {
832 int used;
833 off_t size;
834 struct stat statbuf;
835 transport_ctx tctx = { .u={.fd = to_fd}, .options = topt_not_socket };
836
837 /* If the current mailbox size is zero, write a header block */
838
839 if (saved_size == 0)
840   {
841   uschar *s;
842   memset (deliver_out_buffer, '\0', MBX_HDRSIZE);
843   sprintf(CS(s = deliver_out_buffer), "*mbx*\015\012%08lx00000000\015\012",
844     (long int)time(NULL));
845   for (int i = 0; i < MBX_NUSERFLAGS; i++)
846     sprintf (CS(s += Ustrlen(s)), "\015\012");
847   if (!transport_write_block (&tctx, deliver_out_buffer, MBX_HDRSIZE, FALSE))
848     return DEFER;
849   }
850
851 DEBUG(D_transport) debug_printf("copying MBX message from temporary file\n");
852
853 /* Now construct the message's header from the time and the RFC822 file
854 size, including CRLFs, which is the size of the input (temporary) file. */
855
856 if (fstat(from_fd, &statbuf) < 0) return DEFER;
857 size = statbuf.st_size;
858
859 sprintf (CS deliver_out_buffer, "%s," OFF_T_FMT ";%08lx%04x-%08x\015\012",
860   tod_stamp(tod_mbx), size, 0L, 0, 0);
861 used = Ustrlen(deliver_out_buffer);
862
863 /* Rewind the temporary file, and copy it over in chunks. */
864
865 if (lseek(from_fd, 0 , SEEK_SET) < 0) return DEFER;
866
867 while (size > 0)
868   {
869   int len = read(from_fd, deliver_out_buffer + used,
870     DELIVER_OUT_BUFFER_SIZE - used);
871   if (len <= 0)
872     {
873     if (len == 0) errno = ERRNO_MBXLENGTH;
874     return DEFER;
875     }
876   if (!transport_write_block(&tctx, deliver_out_buffer, used + len, FALSE))
877     return DEFER;
878   size -= len;
879   used = 0;
880   }
881
882 return OK;
883 }
884 #endif  /* SUPPORT_MBX */
885
886
887
888 /*************************************************
889 *            Check creation is permitted         *
890 *************************************************/
891
892 /* This function checks whether a given file name is permitted to be created,
893 as controlled by the create_file option. If no home directory is set, however,
894 we can't do any tests.
895
896 Arguments:
897   filename     the file name
898   create_file  the ob->create_file option
899   deliver_dir  the delivery directory
900
901 Returns:       TRUE if creation is permitted
902 */
903
904 static BOOL
905 check_creation(uschar *filename, int create_file, const uschar * deliver_dir)
906 {
907 BOOL yield = TRUE;
908
909 if (deliver_dir  &&  create_file != create_anywhere)
910   {
911   int len = Ustrlen(deliver_dir);
912   uschar *file = filename;
913
914   while (file[0] == '/' && file[1] == '/') file++;
915   if (  Ustrncmp(file, deliver_dir, len) != 0
916      || file[len] != '/'
917      ||    Ustrchr(file+len+2, '/') != NULL
918         && (  create_file != create_belowhome
919            || Ustrstr(file+len, "/../") != NULL
920            )
921      ) yield = FALSE;
922
923   /* If yield is TRUE, the file name starts with the home directory, and does
924   not contain any instances of "/../" in the "belowhome" case. However, it may
925   still contain symbolic links. We can check for this by making use of
926   realpath(), which most Unixes seem to have (but make it possible to cut this
927   out). We can't just use realpath() on the whole file name, because we know
928   the file itself doesn't exist, and intermediate directories may also not
929   exist. What we want to know is the real path of the longest existing part of
930   the path. That must match the home directory's beginning, whichever is the
931   shorter. */
932
933   #ifndef NO_REALPATH
934   if (yield && create_file == create_belowhome)
935     {
936     uschar *next;
937     uschar *rp = NULL;
938     for (uschar * slash = Ustrrchr(file, '/');  /* There is known to be one */
939          !rp && slash > file;                   /* Stop if reached beginning */
940          slash = next)
941       {
942       *slash = 0;
943       rp = US realpath(CS file, CS big_buffer);
944       next = Ustrrchr(file, '/');
945       *slash = '/';
946       }
947
948     /* If rp == NULL it means that none of the relevant directories exist.
949     This is not a problem here - it means that no symbolic links can exist,
950     which is all we are worried about. Otherwise, we must compare it
951     against the start of the home directory. However, that may itself
952     contain symbolic links, so we have to "realpath" it as well, if
953     possible. */
954
955     if (rp)
956       {
957       uschar hdbuffer[PATH_MAX+1];
958       const uschar * rph = deliver_dir;
959       int rlen = Ustrlen(big_buffer);
960
961       if ((rp = US realpath(CS deliver_dir, CS hdbuffer)))
962         {
963         rph = hdbuffer;
964         len = Ustrlen(rph);
965         }
966
967       if (rlen > len) rlen = len;
968       if (Ustrncmp(rph, big_buffer, rlen) != 0)
969         {
970         yield = FALSE;
971         DEBUG(D_transport) debug_printf("Real path \"%s\" does not match \"%s\"\n",
972           big_buffer, deliver_dir);
973         }
974       }
975     }
976   #endif  /* NO_REALPATH */
977   }
978
979 return yield;
980 }
981
982
983
984 /*************************************************
985 *              Main entry point                  *
986 *************************************************/
987
988 /* See local README for general interface details. This transport always
989 returns FALSE, indicating that the status which has been placed in the first
990 address should be copied to any other addresses in a batch.
991
992 Appendfile delivery is tricky and has led to various security problems in other
993 mailers. The logic used here is therefore laid out in some detail. When this
994 function is called, we are running in a subprocess which has had its gid and
995 uid set to the appropriate values. Therefore, we cannot write directly to the
996 exim logs. Any errors must be handled by setting appropriate return codes.
997 Note that the default setting for addr->transport_return is DEFER, so it need
998 not be set unless some other value is required.
999
1000 The code below calls geteuid() rather than getuid() to get the current uid
1001 because in weird configurations not running setuid root there may be a
1002 difference. In the standard configuration, where setuid() has been used in the
1003 delivery process, there will be no difference between the uid and the euid.
1004
1005 (1)  If the af_file flag is set, this is a delivery to a file after .forward or
1006      alias expansion. Otherwise, there must be a configured file name or
1007      directory name.
1008
1009 The following items apply in the case when a file name (as opposed to a
1010 directory name) is given, that is, when appending to a single file:
1011
1012 (2f) Expand the file name.
1013
1014 (3f) If the file name is /dev/null, return success (optimization).
1015
1016 (4f) If the file_format options is set, open the file for reading, and check
1017      that the bytes at the start of the file match one of the given strings.
1018      If the check indicates a transport other than the current one should be
1019      used, pass control to that other transport. Otherwise continue. An empty
1020      or non-existent file matches the current transport. The file is closed
1021      after the check.
1022
1023 (5f) If a lock file is required, create it (see extensive separate comments
1024      below about the algorithm for doing this). It is important to do this
1025      before opening the mailbox if NFS is in use.
1026
1027 (6f) Stat the file, using lstat() rather than stat(), in order to pick up
1028      details of any symbolic link.
1029
1030 (7f) If the file already exists:
1031
1032      Check the owner and group if necessary, and defer if they are wrong.
1033
1034      If it is a symbolic link AND the allow_symlink option is set (NOT the
1035      default), go back to (6f) but this time use stat() instead of lstat().
1036
1037      If it's not a regular file (or FIFO when permitted), defer delivery.
1038
1039      Check permissions. If the required permissions are *less* than the
1040      existing ones, or supplied by the address (often by the user via filter),
1041      chmod() the file. Otherwise, defer.
1042
1043      Save the inode number.
1044
1045      Open with O_RDRW + O_APPEND, thus failing if the file has vanished.
1046
1047      If open fails because the file does not exist, go to (6f); on any other
1048      failure, defer.
1049
1050      Check the inode number hasn't changed - I realize this isn't perfect (an
1051      inode can be reused) but it's cheap and will catch some of the races.
1052
1053      Check it's still a regular file (or FIFO if permitted).
1054
1055      Check that the owner and permissions haven't changed.
1056
1057      If file_format is set, check that the file still matches the format for
1058      the current transport. If not, defer delivery.
1059
1060 (8f) If file does not exist initially:
1061
1062      Open with O_WRONLY + O_EXCL + O_CREAT with configured mode, unless we know
1063      this is via a symbolic link (only possible if allow_symlinks is set), in
1064      which case don't use O_EXCL, as it doesn't work.
1065
1066      If open fails because the file already exists, go to (6f). To avoid
1067      looping for ever in a situation where the file is continuously being
1068      created and deleted, all of this happens inside a loop that operates
1069      lock_retries times and includes the fcntl and flock locking. If the
1070      loop completes without the file getting opened, defer and request
1071      freezing, because something really weird is happening.
1072
1073      If open fails for any other reason, defer for subsequent delivery except
1074      when this is a file delivery resulting from an alias or forward expansion
1075      and the error is EPERM or ENOENT or EACCES, in which case FAIL as this is
1076      most likely a user rather than a configuration error.
1077
1078 (9f) We now have the file checked and open for writing. If so configured, lock
1079      it using fcntl, flock, or MBX locking rules. If this fails, close the file
1080      and goto (6f), up to lock_retries times, after sleeping for a while. If it
1081      still fails, give up and defer delivery.
1082
1083 (10f)Save the access time (for subsequent restoration) and the size of the
1084      file, for comsat and for re-setting if delivery fails in the middle -
1085      e.g. for quota exceeded.
1086
1087 The following items apply in the case when a directory name is given:
1088
1089 (2d) Create a new file in the directory using a temporary name, by opening for
1090      writing and with O_CREAT. If maildir format is being used, the file
1091      is created in a temporary subdirectory with a prescribed name. If
1092      mailstore format is being used, the envelope file is first created with a
1093      temporary name, then the data file.
1094
1095 The following items apply in all cases:
1096
1097 (11) We now have the file open for writing, and locked if it was given as a
1098      file name. Write the message and flush the file, unless there is a setting
1099      of the local quota option, in which case we can check for its excession
1100      without doing any writing.
1101
1102      In the case of MBX format mailboxes, the message is first written to a
1103      temporary file, in order to get its correct length. This is then copied to
1104      the real file, preceded by an MBX header.
1105
1106      If there is a quota error on writing, defer the address. Timeout logic
1107      will determine for how long retries are attempted. We restore the mailbox
1108      to its original length if it's a single file. There doesn't seem to be a
1109      uniform error code for quota excession (it even differs between SunOS4
1110      and some versions of SunOS5) so a system-dependent macro called
1111      ERRNO_QUOTA is used for it, and the value gets put into errno_quota at
1112      compile time.
1113
1114      For any other error (most commonly disk full), do the same.
1115
1116 The following applies after appending to a file:
1117
1118 (12f)Restore the atime; notify_comsat if required; close the file (which
1119      unlocks it if it was locked). Delete the lock file if it exists.
1120
1121 The following applies after writing a unique file in a directory:
1122
1123 (12d)For maildir format, rename the file into the new directory. For mailstore
1124      format, rename the envelope file to its correct name. Otherwise, generate
1125      a unique name from the directory_file option, and rename to that, possibly
1126      trying a few times if the file exists and re-expanding the name gives a
1127      different string.
1128
1129 This transport yields FAIL only when a file name is generated by an alias or
1130 forwarding operation and attempting to open it gives EPERM, ENOENT, or EACCES.
1131 All other failures return DEFER (in addr->transport_return). */
1132
1133
1134 BOOL
1135 appendfile_transport_entry(
1136   transport_instance *tblock,      /* data for this instantiation */
1137   address_item *addr)              /* address we are working on */
1138 {
1139 appendfile_transport_options_block *ob =
1140   (appendfile_transport_options_block *)(tblock->options_block);
1141 struct stat statbuf;
1142 const uschar * deliver_dir;
1143 uschar *fdname = NULL;
1144 uschar *filename = NULL;
1145 uschar *hitchname = NULL;
1146 uschar *dataname = NULL;
1147 uschar *lockname = NULL;
1148 uschar *newname = NULL;
1149 uschar *nametag = NULL;
1150 uschar *cr = US"";
1151 uschar *filecount_msg = US"";
1152 uschar *path;
1153 struct utimbuf times;
1154 struct timeval msg_tv;
1155 BOOL disable_quota = FALSE;
1156 BOOL isdirectory = FALSE;
1157 BOOL isfifo = FALSE;
1158 BOOL wait_for_tick = FALSE;
1159 uid_t uid = geteuid();     /* See note above */
1160 gid_t gid = getegid();
1161 int mbformat;
1162 int mode = (addr->mode > 0) ? addr->mode : ob->mode;
1163 off_t saved_size = -1;
1164 off_t mailbox_size = ob->mailbox_size_value;
1165 int mailbox_filecount = ob->mailbox_filecount_value;
1166 int hd = -1;
1167 int fd = -1;
1168 int yield = FAIL;
1169 int i;
1170
1171 #ifdef SUPPORT_MBX
1172 int save_fd = 0;
1173 int mbx_lockfd = -1;
1174 uschar mbx_lockname[40];
1175 FILE *temp_file = NULL;
1176 #endif  /* SUPPORT_MBX */
1177
1178 #ifdef SUPPORT_MAILDIR
1179 int maildirsize_fd = -1;      /* fd for maildirsize file */
1180 int maildir_save_errno;
1181 #endif
1182
1183
1184 DEBUG(D_transport) debug_printf("appendfile transport entered\n");
1185
1186 /* An "address_file" or "address_directory" transport is used to deliver to
1187 files specified via .forward or an alias file. Prior to release 4.20, the
1188 "file" and "directory" options were ignored in this case. This has been changed
1189 to allow the redirection data to specify what is in effect a folder, whose
1190 location is determined by the options on the transport.
1191
1192 Compatibility with the case when neither option is set is retained by forcing a
1193 value for the file or directory name. A directory delivery is assumed if the
1194 last character of the path from the router is '/'.
1195
1196 The file path is in the local part of the address, but not in the $local_part
1197 variable (that holds the parent local part). It is, however, in the
1198 $address_file variable. Below, we update the local part in the address if it
1199 changes by expansion, so that the final path ends up in the log. */
1200
1201 if (testflag(addr, af_file) && !ob->filename && !ob->dirname)
1202   {
1203   fdname = US"$address_file";
1204   if (address_file[Ustrlen(address_file)-1] == '/' ||
1205       ob->maildir_format ||
1206       ob->mailstore_format)
1207     isdirectory = TRUE;
1208   }
1209
1210 /* Handle (a) an "address file" delivery where "file" or "directory" is
1211 explicitly set and (b) a non-address_file delivery, where one of "file" or
1212 "directory" must be set; initialization ensures that they are not both set. */
1213
1214 if (!fdname)
1215   {
1216   if (!(fdname = ob->filename))
1217     {
1218     fdname = ob->dirname;
1219     isdirectory = TRUE;
1220     }
1221   if (!fdname)
1222     {
1223     addr->message = string_sprintf("Mandatory file or directory option "
1224       "missing from %s transport", tblock->name);
1225     goto ret_panic;
1226     }
1227   }
1228
1229 /* Maildir and mailstore require a directory */
1230
1231 if ((ob->maildir_format || ob->mailstore_format) && !isdirectory)
1232   {
1233   addr->message = string_sprintf("mail%s_format requires \"directory\" "
1234     "to be specified for the %s transport",
1235     ob->maildir_format ? "dir" : "store", tblock->name);
1236   goto ret_panic;
1237   }
1238
1239 if (!(path = expand_string(fdname)))
1240   {
1241   addr->message = string_sprintf("Expansion of \"%s\" (file or directory "
1242     "name for %s transport) failed: %s", fdname, tblock->name,
1243     expand_string_message);
1244   goto ret_panic;
1245   }
1246
1247 if (path[0] != '/')
1248   {
1249   addr->message = string_sprintf("appendfile: file or directory name "
1250     "\"%s\" is not absolute", path);
1251   addr->basic_errno = ERRNO_NOTABSOLUTE;
1252   return FALSE;
1253   }
1254
1255 /* For a file delivery, make sure the local part in the address(es) is updated
1256 to the true local part. */
1257
1258 if (testflag(addr, af_file))
1259   for (address_item * addr2 = addr; addr2; addr2 = addr2->next)
1260     addr2->local_part = string_copy(path);
1261
1262 /* The available mailbox formats depend on whether it is a directory or a file
1263 delivery. */
1264
1265 if (isdirectory)
1266   {
1267   mbformat =
1268   #ifdef SUPPORT_MAILDIR
1269     ob->maildir_format ? mbf_maildir :
1270   #endif
1271   #ifdef SUPPORT_MAILSTORE
1272     ob->mailstore_format ? mbf_mailstore :
1273   #endif
1274     mbf_smail;
1275   }
1276 else
1277   {
1278   mbformat =
1279   #ifdef SUPPORT_MBX
1280     ob->mbx_format ? mbf_mbx :
1281   #endif
1282     mbf_unix;
1283   }
1284
1285 DEBUG(D_transport)
1286   {
1287   debug_printf("appendfile: mode=%o notify_comsat=%d quota=" OFF_T_FMT
1288     "%s%s"
1289     " warning=" OFF_T_FMT "%s\n"
1290     "  %s=%s format=%s\n  message_prefix=%s\n  message_suffix=%s\n  "
1291     "maildir_use_size_file=%s\n",
1292     mode, ob->notify_comsat, ob->quota_value,
1293     ob->quota_no_check ? " (no_check)" : "",
1294     ob->quota_filecount_no_check ? " (no_check_filecount)" : "",
1295     ob->quota_warn_threshold_value,
1296     ob->quota_warn_threshold_is_percent ? "%" : "",
1297     isdirectory ? "directory" : "file",
1298     path, mailbox_formats[mbformat],
1299     !ob->message_prefix ? US"null" : string_printing(ob->message_prefix),
1300     !ob->message_suffix ? US"null" : string_printing(ob->message_suffix),
1301     ob->maildir_use_size_file ? "yes" : "no");
1302
1303   if (!isdirectory) debug_printf("  locking by %s%s%s%s%s\n",
1304     ob->use_lockfile ? "lockfile " : "",
1305     ob->use_mbx_lock ? "mbx locking (" : "",
1306     ob->use_fcntl ? "fcntl " : "",
1307     ob->use_flock ? "flock" : "",
1308     ob->use_mbx_lock ? ")" : "");
1309   }
1310
1311 /* If the -N option is set, can't do any more. */
1312
1313 if (f.dont_deliver)
1314   {
1315   DEBUG(D_transport)
1316     debug_printf("*** delivery by %s transport bypassed by -N option\n",
1317       tblock->name);
1318   addr->transport_return = OK;
1319   return FALSE;
1320   }
1321
1322 /* If an absolute path was given for create_file the it overrides deliver_home
1323 (here) and de-taints the filename (below, after check_creation() */
1324
1325 deliver_dir = *ob->create_file_string == '/'
1326   ? ob->create_file_string : deliver_home;
1327
1328 /* Handle the case of a file name. If the file name is /dev/null, we can save
1329 ourselves some effort and just give a success return right away. */
1330
1331 if (!isdirectory)
1332   {
1333   BOOL use_lstat = TRUE;
1334   BOOL file_opened = FALSE;
1335   BOOL allow_creation_here = TRUE;
1336
1337   if (Ustrcmp(path, "/dev/null") == 0)
1338     {
1339     addr->transport_return = OK;
1340     return FALSE;
1341     }
1342
1343   /* Set the name of the file to be opened, and the file to which the data
1344   is written, and find out if we are permitted to create a non-existent file.
1345   If the create_file option is an absolute path and the file was within it,
1346   de-taint.  Chaeck for a tainted path. */
1347
1348   if (  (allow_creation_here = check_creation(path, ob->create_file, deliver_dir))
1349      && ob->create_file == create_belowhome)
1350     if (is_tainted(path))
1351       {
1352       DEBUG(D_transport) debug_printf("de-tainting path '%s'\n", path);
1353       path = string_copy_taint(path, GET_UNTAINTED);
1354       }
1355
1356   if (is_tainted(path)) goto tainted_ret_panic;
1357   dataname = filename = path;
1358
1359   /* If ob->create_directory is set, attempt to create the directories in
1360   which this mailbox lives, but only if we are permitted to create the file
1361   itself. We know we are dealing with an absolute path, because this was
1362   checked above. */
1363
1364   if (ob->create_directory && allow_creation_here)
1365     {
1366     uschar *p = Ustrrchr(path, '/');
1367     p = string_copyn(path, p - path);
1368     if (!directory_make(NULL, p, ob->dirmode, FALSE))
1369       {
1370       addr->basic_errno = errno;
1371       addr->message =
1372         string_sprintf("failed to create directories for %s: %s", path,
1373           exim_errstr(errno));
1374       DEBUG(D_transport) debug_printf("%s transport: %s\n", tblock->name, path);
1375       return FALSE;
1376       }
1377     }
1378
1379   /* If file_format is set we must check that any existing file matches one of
1380   the configured formats by checking the bytes it starts with. A match then
1381   indicates a specific transport - if it is not this one, pass control to it.
1382   Otherwise carry on here. An empty or non-existent file matches the current
1383   transport. We don't need to distinguish between non-existence and other open
1384   failures because if an existing file fails to open here, it will also fail
1385   again later when O_RDWR is used. */
1386
1387   if (ob->file_format)
1388     {
1389     int cfd = Uopen(path, O_RDONLY, 0);
1390     if (cfd >= 0)
1391       {
1392       transport_instance *tt = check_file_format(cfd, tblock, addr);
1393       (void)close(cfd);
1394
1395       /* If another transport is indicated, call it and return; if no transport
1396       was found, just return - the error data will have been set up.*/
1397
1398       if (tt != tblock)
1399         {
1400         if (tt)
1401           {
1402           set_process_info("delivering %s to %s using %s", message_id,
1403             addr->local_part, tt->name);
1404           debug_print_string(tt->debug_string);
1405           addr->transport = tt;
1406           (tt->info->code)(tt, addr);
1407           }
1408         return FALSE;
1409         }
1410       }
1411     }
1412
1413   /* The locking of mailbox files is worse than the naming of cats, which is
1414   known to be "a difficult matter" (T.S. Eliot) and just as cats must have
1415   three different names, so several different styles of locking are used.
1416
1417   Research in other programs that lock mailboxes shows that there is no
1418   universally standard method. Having mailboxes NFS-mounted on the system that
1419   is delivering mail is not the best thing, but people do run like this,
1420   and so the code must do its best to cope.
1421
1422   Three different locking mechanisms are supported. The initialization function
1423   checks that at least one is configured.
1424
1425   LOCK FILES
1426
1427   Unless no_use_lockfile is set, we attempt to build a lock file in a way that
1428   will work over NFS. Only after that is done do we actually open the mailbox
1429   and apply locks to it (if configured).
1430
1431   Originally, Exim got the file opened before doing anything about locking.
1432   However, a very occasional problem was observed on Solaris 2 when delivering
1433   over NFS. It is seems that when a file is opened with O_APPEND, the file size
1434   gets remembered at open time. If another process on another host (that's
1435   important) has the file open and locked and writes to it and then releases
1436   the lock while the first process is waiting to get the lock, the first
1437   process may fail to write at the new end point of the file - despite the very
1438   definite statement about O_APPEND in the man page for write(). Experiments
1439   have reproduced this problem, but I do not know any way of forcing a host to
1440   update its attribute cache for an open NFS file. It would be nice if it did
1441   so when a lock was taken out, but this does not seem to happen. Anyway, to
1442   reduce the risk of this problem happening, we now create the lock file
1443   (if configured) *before* opening the mailbox. That will prevent two different
1444   Exims opening the file simultaneously. It may not prevent clashes with MUAs,
1445   however, but Pine at least seems to operate in the same way.
1446
1447   Lockfiles should normally be used when NFS is involved, because of the above
1448   problem.
1449
1450   The logic for creating the lock file is:
1451
1452   . The name of the lock file is <mailbox-name>.lock
1453
1454   . First, create a "hitching post" name by adding the primary host name,
1455     current time and pid to the lock file name. This should be unique.
1456
1457   . Create the hitching post file using WRONLY + CREAT + EXCL.
1458
1459   . If that fails EACCES, we assume it means that the user is unable to create
1460     files in the mail spool directory. Some installations might operate in this
1461     manner, so there is a configuration option to allow this state not to be an
1462     error - we proceed to lock using fcntl only, after the file is open.
1463
1464   . Otherwise, an error causes a deferment of the address.
1465
1466   . Hard link the hitching post to the lock file name.
1467
1468   . If the link succeeds, we have successfully created the lock file. Simply
1469     close and unlink the hitching post file.
1470
1471   . If the link does not succeed, proceed as follows:
1472
1473     o Fstat the hitching post file, and then close and unlink it.
1474
1475     o Now examine the stat data. If the number of links to the file is exactly
1476       2, the linking succeeded but for some reason, e.g. an NFS server crash,
1477       the return never made it back, so the link() function gave a failure
1478       return.
1479
1480   . This method allows for the lock file to be created by some other process
1481     right up to the moment of the attempt to hard link it, and is also robust
1482     against NFS server crash-reboots, which would probably result in timeouts
1483     in the middle of link().
1484
1485   . System crashes may cause lock files to get left lying around, and some means
1486     of flushing them is required. The approach of writing a pid (used by smail
1487     and by elm) into the file isn't useful when NFS may be in use. Pine uses a
1488     timeout, which seems a better approach. Since any program that writes to a
1489     mailbox using a lock file should complete its task very quickly, Pine
1490     removes lock files that are older than 5 minutes. We allow the value to be
1491     configurable on the transport.
1492
1493   FCNTL LOCKING
1494
1495   If use_fcntl_lock is set, then Exim gets an exclusive fcntl() lock on the
1496   mailbox once it is open. This is done by default with a non-blocking lock.
1497   Failures to lock cause retries after a sleep, but only for a certain number
1498   of tries. A blocking lock is deliberately not used so that we don't hold the
1499   mailbox open. This minimizes the possibility of the NFS problem described
1500   under LOCK FILES above, if for some reason NFS deliveries are happening
1501   without lock files. However, the use of a non-blocking lock and sleep, though
1502   the safest approach, does not give the best performance on very busy systems.
1503   A blocking lock plus timeout does better. Therefore Exim has an option to
1504   allow it to work this way. If lock_fcntl_timeout is set greater than zero, it
1505   enables the use of blocking fcntl() calls.
1506
1507   FLOCK LOCKING
1508
1509   If use_flock_lock is set, then Exim gets an exclusive flock() lock in the
1510   same manner as for fcntl locking above. No-blocking/timeout is also set as
1511   above in lock_flock_timeout. Not all operating systems provide or support
1512   flock(). For those that don't (as determined by the definition of LOCK_SH in
1513   /usr/include/sys/file.h), use_flock_lock may not be set. For some OS, flock()
1514   is implemented (not precisely) on top of fcntl(), which means there's no
1515   point in actually using it.
1516
1517   MBX LOCKING
1518
1519   If use_mbx_lock is set (this is supported only if SUPPORT_MBX is defined)
1520   then the rules used for locking in c-client are used. Exim takes out a shared
1521   lock on the mailbox file, and an exclusive lock on the file whose name is
1522   /tmp/.<device-number>.<inode-number>. The shared lock on the mailbox stops
1523   any other MBX client from getting an exclusive lock on it and expunging it.
1524   It also stops any other MBX client from unlinking the /tmp lock when it has
1525   finished with it.
1526
1527   The exclusive lock on the /tmp file prevents any other MBX client from
1528   updating the mailbox in any way. When writing is finished, if an exclusive
1529   lock on the mailbox can be obtained, indicating there are no current sharers,
1530   the /tmp file is unlinked.
1531
1532   MBX locking can use either fcntl() or flock() locking. If neither
1533   use_fcntl_lock or use_flock_lock is set, it defaults to using fcntl() only.
1534   The calls for getting these locks are by default non-blocking, as for non-mbx
1535   locking, but can be made blocking by setting lock_fcntl_timeout and/or
1536   lock_flock_timeout as appropriate.  As MBX delivery doesn't work over NFS, it
1537   probably makes sense to set timeouts for any MBX deliveries. */
1538
1539
1540   /* Build a lock file if configured to do so - the existence of a lock
1541   file is subsequently checked by looking for a non-negative value of the
1542   file descriptor hd - even though the file is no longer open. */
1543
1544   if (ob->use_lockfile)
1545     {
1546     /* cf. exim_lock.c */
1547     lockname = string_sprintf("%s.lock", filename);
1548     hitchname = string_sprintf( "%s.%s.%08x.%08x", lockname, primary_hostname,
1549       (unsigned int)(time(NULL)), (unsigned int)getpid());
1550
1551     DEBUG(D_transport) debug_printf("lock name: %s\nhitch name: %s\n", lockname,
1552       hitchname);
1553
1554     /* Lock file creation retry loop */
1555
1556     for (i = 0; i < ob->lock_retries; sleep(ob->lock_interval), i++)
1557       {
1558       int rc;
1559
1560       hd = Uopen(hitchname, O_WRONLY | O_CREAT | O_EXCL, ob->lockfile_mode);
1561       if (hd < 0)
1562         {
1563         addr->basic_errno = errno;
1564         addr->message =
1565           string_sprintf("creating lock file hitching post %s "
1566             "(euid=%ld egid=%ld)", hitchname, (long int)geteuid(),
1567             (long int)getegid());
1568         return FALSE;
1569         }
1570
1571       /* Attempt to hitch the hitching post to the lock file. If link()
1572       succeeds (the common case, we hope) all is well. Otherwise, fstat the
1573       file, and get rid of the hitching post. If the number of links was 2,
1574       the link was created, despite the failure of link(). If the hitch was
1575       not successful, try again, having unlinked the lock file if it is too
1576       old.
1577
1578       There's a version of Linux (2.0.27) which doesn't update its local cache
1579       of the inode after link() by default - which many think is a bug - but
1580       if the link succeeds, this code will be OK. It just won't work in the
1581       case when link() fails after having actually created the link. The Linux
1582       NFS person is fixing this; a temporary patch is available if anyone is
1583       sufficiently worried. */
1584
1585       if ((rc = Ulink(hitchname, lockname)) != 0) fstat(hd, &statbuf);
1586       (void)close(hd);
1587       Uunlink(hitchname);
1588       if (rc != 0 && statbuf.st_nlink != 2)
1589         {
1590         if (ob->lockfile_timeout > 0 && Ustat(lockname, &statbuf) == 0 &&
1591             time(NULL) - statbuf.st_ctime > ob->lockfile_timeout)
1592           {
1593           DEBUG(D_transport) debug_printf("unlinking timed-out lock file\n");
1594           Uunlink(lockname);
1595           }
1596         DEBUG(D_transport) debug_printf("link of hitching post failed - retrying\n");
1597         continue;
1598         }
1599
1600       DEBUG(D_transport) debug_printf("lock file created\n");
1601       break;
1602       }
1603
1604     /* Check for too many tries at creating the lock file */
1605
1606     if (i >= ob->lock_retries)
1607       {
1608       addr->basic_errno = ERRNO_LOCKFAILED;
1609       addr->message = string_sprintf("failed to lock mailbox %s (lock file)",
1610         filename);
1611       return FALSE;
1612       }
1613     }
1614
1615
1616   /* We now have to get the file open. First, stat() it and act on existence or
1617   non-existence. This is in a loop to handle the case of a file's being created
1618   or deleted as we watch, and also to handle retries when the locking fails.
1619   Rather than holding the file open while waiting for the fcntl() and/or
1620   flock() lock, we close and do the whole thing again. This should be safer,
1621   especially for NFS files, which might get altered from other hosts, making
1622   their cached sizes incorrect.
1623
1624   With the default settings, no symlinks are permitted, but there is an option
1625   to permit symlinks for those sysadmins that know what they are doing.
1626   Shudder. However, insist that the initial symlink is owned by the right user.
1627   Thus lstat() is used initially; if a symlink is discovered, the loop is
1628   repeated such that stat() is used, to look at the end file. */
1629
1630   for (i = 0; i < ob->lock_retries; i++)
1631     {
1632     int sleep_before_retry = TRUE;
1633     file_opened = FALSE;
1634
1635     if ((use_lstat ? Ulstat(filename, &statbuf) : Ustat(filename, &statbuf)) != 0)
1636       {
1637       /* Let's hope that failure to stat (other than non-existence) is a
1638       rare event. */
1639
1640       if (errno != ENOENT)
1641         {
1642         addr->basic_errno = errno;
1643         addr->message = string_sprintf("attempting to stat mailbox %s",
1644           filename);
1645         goto RETURN;
1646         }
1647
1648       /* File does not exist. If it is required to pre-exist this state is an
1649       error. */
1650
1651       if (ob->file_must_exist)
1652         {
1653         addr->basic_errno = errno;
1654         addr->message = string_sprintf("mailbox %s does not exist, "
1655           "but file_must_exist is set", filename);
1656         goto RETURN;
1657         }
1658
1659       /* If not permitted to create this file because it isn't in or below
1660       the home directory, generate an error. */
1661
1662       if (!allow_creation_here)
1663         {
1664         addr->basic_errno = ERRNO_BADCREATE;
1665         addr->message = string_sprintf("mailbox %s does not exist, "
1666           "but creation outside the home directory is not permitted",
1667           filename);
1668         goto RETURN;
1669         }
1670
1671       /* Attempt to create and open the file. If open fails because of
1672       pre-existence, go round the loop again. For any other error, defer the
1673       address, except for an alias or forward generated file name with EPERM,
1674       ENOENT, or EACCES, as those are most likely to be user errors rather
1675       than Exim config errors. When a symbolic link is permitted and points
1676       to a non-existent file, we get here with use_lstat = FALSE. In this case
1677       we mustn't use O_EXCL, since it doesn't work. The file is opened RDRW for
1678       consistency and because MBX locking requires it in order to be able to
1679       get a shared lock. */
1680
1681       fd = Uopen(filename, O_RDWR | O_APPEND | O_CREAT |
1682         (use_lstat ? O_EXCL : 0), mode);
1683       if (fd < 0)
1684         {
1685         if (errno == EEXIST) continue;
1686         addr->basic_errno = errno;
1687         addr->message = string_sprintf("while creating mailbox %s",
1688           filename);
1689         if (testflag(addr, af_file) &&
1690             (errno == EPERM || errno == ENOENT || errno == EACCES))
1691           addr->transport_return = FAIL;
1692         goto RETURN;
1693         }
1694
1695       /* We have successfully created and opened the file. Ensure that the group
1696       and the mode are correct. */
1697
1698       if (exim_chown(filename, uid, gid) || Uchmod(filename, mode))
1699         {
1700         addr->basic_errno = errno;
1701         addr->message = string_sprintf("while setting perms on mailbox %s",
1702           filename);
1703         addr->transport_return = FAIL;
1704         goto RETURN;
1705         }
1706       }
1707
1708
1709     /* The file already exists. Test its type, ownership, and permissions, and
1710     save the inode for checking later. If symlinks are permitted (not the
1711     default or recommended state) it may be a symlink that already exists.
1712     Check its ownership and then look for the file at the end of the link(s).
1713     This at least prevents one user creating a symlink for another user in
1714     a sticky directory. */
1715
1716     else
1717       {
1718       int oldmode = (int)statbuf.st_mode;
1719       ino_t inode = statbuf.st_ino;
1720       BOOL islink = (oldmode & S_IFMT) == S_IFLNK;
1721
1722       isfifo = FALSE;        /* In case things are changing */
1723
1724       /* Check owner if required - the default. */
1725
1726       if (ob->check_owner && statbuf.st_uid != uid)
1727         {
1728         addr->basic_errno = ERRNO_BADUGID;
1729         addr->message = string_sprintf("mailbox %s%s has wrong uid "
1730           "(%ld != %ld)", filename,
1731           islink ? " (symlink)" : "",
1732           (long int)(statbuf.st_uid), (long int)uid);
1733         goto RETURN;
1734         }
1735
1736       /* Group is checked only if check_group is set. */
1737
1738       if (ob->check_group && statbuf.st_gid != gid)
1739         {
1740         addr->basic_errno = ERRNO_BADUGID;
1741         addr->message = string_sprintf("mailbox %s%s has wrong gid (%d != %d)",
1742           filename, islink ? " (symlink)" : "", statbuf.st_gid, gid);
1743         goto RETURN;
1744         }
1745
1746       /* Just in case this is a sticky-bit mail directory, we don't want
1747       users to be able to create hard links to other users' files. */
1748
1749       if (statbuf.st_nlink != 1)
1750         {
1751         addr->basic_errno = ERRNO_NOTREGULAR;
1752         addr->message = string_sprintf("mailbox %s%s has too many links (%lu)",
1753           filename, islink ? " (symlink)" : "", (unsigned long)statbuf.st_nlink);
1754         goto RETURN;
1755
1756         }
1757
1758       /* If symlinks are permitted (not recommended), the lstat() above will
1759       have found the symlink. Its ownership has just been checked; go round
1760       the loop again, using stat() instead of lstat(). That will never yield a
1761       mode of S_IFLNK. */
1762
1763       if (islink && ob->allow_symlink)
1764         {
1765         use_lstat = FALSE;
1766         i--;                   /* Don't count this time round */
1767         continue;
1768         }
1769
1770       /* An actual file exists. Check that it is a regular file, or FIFO
1771       if permitted. */
1772
1773       if (ob->allow_fifo && (oldmode & S_IFMT) == S_IFIFO) isfifo = TRUE;
1774
1775       else if ((oldmode & S_IFMT) != S_IFREG)
1776         {
1777         addr->basic_errno = ERRNO_NOTREGULAR;
1778         addr->message = string_sprintf("mailbox %s is not a regular file%s",
1779           filename, ob->allow_fifo ? " or named pipe" : "");
1780         goto RETURN;
1781         }
1782
1783       /* If the mode is not what it would be for a newly created file, change
1784       the permissions if the mode is supplied for the address. Otherwise,
1785       reduce but do not extend the permissions. If the newly created
1786       permissions are greater than the existing permissions, don't change
1787       things when the mode is not from the address. */
1788
1789       if ((oldmode &= 07777) != mode)
1790         {
1791         int diffs = oldmode ^ mode;
1792         if (addr->mode > 0 || (diffs & oldmode) == diffs)
1793           {
1794           DEBUG(D_transport) debug_printf("chmod %o %s\n", mode, filename);
1795           if (Uchmod(filename, mode) < 0)
1796             {
1797             addr->basic_errno = errno;
1798             addr->message = string_sprintf("attempting to chmod mailbox %s",
1799               filename);
1800             goto RETURN;
1801             }
1802           oldmode = mode;
1803           }
1804
1805         /* Mode not from address, and newly-created permissions are greater
1806         than existing permissions. Default is to complain, but it can be
1807         configured to go ahead and try to deliver anyway if that's what
1808         the administration wants. */
1809
1810         else if (ob->mode_fail_narrower)
1811           {
1812           addr->basic_errno = ERRNO_BADMODE;
1813           addr->message = string_sprintf("mailbox %s has the wrong mode %o "
1814             "(%o expected)", filename, oldmode, mode);
1815           goto RETURN;
1816           }
1817         }
1818
1819       /* We are happy with the existing file. Open it, and then do further
1820       tests to ensure that it is the same file that we were just looking at.
1821       If the file does not now exist, restart this loop, going back to using
1822       lstat again. For an NFS error, just defer; other opening errors are
1823       more serious. The file is opened RDWR so that its format can be checked,
1824       and also MBX locking requires the use of a shared (read) lock. However,
1825       a FIFO is opened WRONLY + NDELAY so that it fails if there is no process
1826       reading the pipe. */
1827
1828       fd = Uopen(filename, isfifo ? (O_WRONLY|O_NDELAY) : (O_RDWR|O_APPEND),
1829         mode);
1830       if (fd < 0)
1831         {
1832         if (errno == ENOENT)
1833           {
1834           use_lstat = TRUE;
1835           continue;
1836           }
1837         addr->basic_errno = errno;
1838         if (isfifo)
1839           addr->message = string_sprintf("while opening named pipe %s "
1840             "(could mean no process is reading it)", filename);
1841         else if (errno != EWOULDBLOCK)
1842           addr->message = string_sprintf("while opening mailbox %s", filename);
1843         goto RETURN;
1844         }
1845
1846       /* This fstat really shouldn't fail, as we have an open file! There's a
1847       dilemma here. We use fstat in order to be sure we are peering at the file
1848       we have got open. However, that won't tell us if the file was reached
1849       via a symbolic link. We checked this above, but there is a race exposure
1850       if the link was created between the previous lstat and the open. However,
1851       it would have to be created with the same inode in order to pass the
1852       check below. If ob->allow_symlink is set, causing the use of stat rather
1853       than lstat above, symbolic links may be there anyway, and the checking is
1854       weaker. */
1855
1856       if (fstat(fd, &statbuf) < 0)
1857         {
1858         addr->basic_errno = errno;
1859         addr->message = string_sprintf("attempting to stat open mailbox %s",
1860           filename);
1861         goto RETURN;
1862         }
1863
1864       /* Check the inode; this is isn't a perfect check, but gives some
1865       confidence. */
1866
1867       if (inode != statbuf.st_ino)
1868         {
1869         addr->basic_errno = ERRNO_INODECHANGED;
1870         addr->message = string_sprintf("opened mailbox %s inode number changed "
1871           "from " INO_T_FMT " to " INO_T_FMT, filename, inode, statbuf.st_ino);
1872         addr->special_action = SPECIAL_FREEZE;
1873         goto RETURN;
1874         }
1875
1876       /* Check it's still a regular file or FIFO, and the uid, gid, and
1877       permissions have not changed. */
1878
1879       if ((!isfifo && (statbuf.st_mode & S_IFMT) != S_IFREG) ||
1880           (isfifo && (statbuf.st_mode & S_IFMT) != S_IFIFO))
1881         {
1882         addr->basic_errno = ERRNO_NOTREGULAR;
1883         addr->message =
1884           string_sprintf("opened mailbox %s is no longer a %s", filename,
1885             isfifo ? "named pipe" : "regular file");
1886         addr->special_action = SPECIAL_FREEZE;
1887         goto RETURN;
1888         }
1889
1890       if ((ob->check_owner && statbuf.st_uid != uid) ||
1891           (ob->check_group && statbuf.st_gid != gid))
1892         {
1893         addr->basic_errno = ERRNO_BADUGID;
1894         addr->message =
1895           string_sprintf("opened mailbox %s has wrong uid or gid", filename);
1896         addr->special_action = SPECIAL_FREEZE;
1897         goto RETURN;
1898         }
1899
1900       if ((statbuf.st_mode & 07777) != oldmode)
1901         {
1902         addr->basic_errno = ERRNO_BADMODE;
1903         addr->message = string_sprintf("opened mailbox %s has wrong mode %o "
1904           "(%o expected)", filename, statbuf.st_mode & 07777, mode);
1905         addr->special_action = SPECIAL_FREEZE;
1906         goto RETURN;
1907         }
1908
1909       /* If file_format is set, check that the format of the file has not
1910       changed. Error data is set by the testing function. */
1911
1912       if (ob->file_format  &&  check_file_format(fd, tblock, addr) != tblock)
1913         {
1914         addr->message = US"open mailbox has changed format";
1915         goto RETURN;
1916         }
1917
1918       /* The file is OK. Carry on to do the locking. */
1919       }
1920
1921     /* We now have an open file, and must lock it using fcntl(), flock() or MBX
1922     locking rules if configured to do so. If a lock file is also required, it
1923     was created above and hd was left >= 0. At least one form of locking is
1924     required by the initialization function. If locking fails here, close the
1925     file and go round the loop all over again, after waiting for a bit, unless
1926     blocking locking was used. */
1927
1928     file_opened = TRUE;
1929     if ((ob->lock_fcntl_timeout > 0) || (ob->lock_flock_timeout > 0))
1930       sleep_before_retry = FALSE;
1931
1932     /* Simple fcntl() and/or flock() locking */
1933
1934     if (!ob->use_mbx_lock && (ob->use_fcntl || ob->use_flock))
1935       {
1936       if (apply_lock(fd, F_WRLCK, ob->use_fcntl, ob->lock_fcntl_timeout,
1937          ob->use_flock, ob->lock_flock_timeout) >= 0) break;
1938       }
1939
1940     /* MBX locking rules */
1941
1942     #ifdef SUPPORT_MBX
1943     else if (ob->use_mbx_lock)
1944       {
1945       int mbx_tmp_oflags;
1946       struct stat lstatbuf, statbuf2;
1947       if (apply_lock(fd, F_RDLCK, ob->use_fcntl, ob->lock_fcntl_timeout,
1948            ob->use_flock, ob->lock_flock_timeout) >= 0 &&
1949            fstat(fd, &statbuf) >= 0)
1950         {
1951         sprintf(CS mbx_lockname, "/tmp/.%lx.%lx", (long)statbuf.st_dev,
1952           (long)statbuf.st_ino);
1953
1954         /*
1955          * 2010-05-29: SECURITY
1956          * Dan Rosenberg reported the presence of a race-condition in the
1957          * original code here.  Beware that many systems still allow symlinks
1958          * to be followed in /tmp so an attacker can create a symlink pointing
1959          * elsewhere between a stat and an open, which we should avoid
1960          * following.
1961          *
1962          * It's unfortunate that we can't just use all the heavily debugged
1963          * locking from above.
1964          *
1965          * Also: remember to mirror changes into exim_lock.c */
1966
1967         /* first leave the old pre-check in place, it provides better
1968          * diagnostics for common cases */
1969         if (Ulstat(mbx_lockname, &statbuf) >= 0)
1970           {
1971           if ((statbuf.st_mode & S_IFMT) == S_IFLNK)
1972             {
1973             addr->basic_errno = ERRNO_LOCKFAILED;
1974             addr->message = string_sprintf("symbolic link on MBX lock file %s",
1975               mbx_lockname);
1976             goto RETURN;
1977             }
1978           if (statbuf.st_nlink > 1)
1979             {
1980             addr->basic_errno = ERRNO_LOCKFAILED;
1981             addr->message = string_sprintf("hard link to MBX lock file %s",
1982               mbx_lockname);
1983             goto RETURN;
1984             }
1985           }
1986
1987         /* If we could just declare "we must be the ones who create this
1988          * file" then a hitching post in a subdir would work, since a
1989          * subdir directly in /tmp/ which we create wouldn't follow links
1990          * but this isn't our locking logic, so we can't safely change the
1991          * file existence rules. */
1992
1993         /* On systems which support O_NOFOLLOW, it's the easiest and most
1994          * obviously correct security fix */
1995         mbx_tmp_oflags = O_RDWR | O_CREAT;
1996 #ifdef O_NOFOLLOW
1997         mbx_tmp_oflags |= O_NOFOLLOW;
1998 #endif
1999         mbx_lockfd = Uopen(mbx_lockname, mbx_tmp_oflags, ob->lockfile_mode);
2000         if (mbx_lockfd < 0)
2001           {
2002           addr->basic_errno = ERRNO_LOCKFAILED;
2003           addr->message = string_sprintf("failed to open MBX lock file %s :%s",
2004             mbx_lockname, strerror(errno));
2005           goto RETURN;
2006           }
2007
2008         if (Ulstat(mbx_lockname, &lstatbuf) < 0)
2009           {
2010           addr->basic_errno = ERRNO_LOCKFAILED;
2011           addr->message = string_sprintf("attempting to lstat open MBX "
2012              "lock file %s: %s", mbx_lockname, strerror(errno));
2013           goto RETURN;
2014           }
2015         if (fstat(mbx_lockfd, &statbuf2) < 0)
2016           {
2017           addr->basic_errno = ERRNO_LOCKFAILED;
2018           addr->message = string_sprintf("attempting to stat fd of open MBX "
2019               "lock file %s: %s", mbx_lockname, strerror(errno));
2020           goto RETURN;
2021           }
2022
2023         /*
2024          * At this point:
2025          *  statbuf: if exists, is file which existed prior to opening the
2026          *           lockfile, might have been replaced since then
2027          *  statbuf2: result of stat'ing the open fd, is what was actually
2028          *            opened
2029          *  lstatbuf: result of lstat'ing the filename immediately after
2030          *            the open but there's a race condition again between
2031          *            those two steps: before open, symlink to foo, after
2032          *            open but before lstat have one of:
2033          *             * was no symlink, so is the opened file
2034          *               (we created it, no messing possible after that point)
2035          *             * hardlink to foo
2036          *             * symlink elsewhere
2037          *             * hardlink elsewhere
2038          *             * new file/other
2039          * Don't want to compare to device of /tmp because some modern systems
2040          * have regressed to having /tmp be the safe actual filesystem as
2041          * valuable data, so is mostly worthless, unless we assume that *only*
2042          * Linux systems do this and that all Linux has O_NOFOLLOW.  Something
2043          * for further consideration.
2044          * No point in doing a readlink on the lockfile as that will always be
2045          * at a different point in time from when we open it, so tells us
2046          * nothing; attempts to clean up and delete after ourselves would risk
2047          * deleting a *third* filename.
2048          */
2049         if ((statbuf2.st_nlink > 1) ||
2050             (lstatbuf.st_nlink > 1) ||
2051             (!S_ISREG(lstatbuf.st_mode)) ||
2052             (lstatbuf.st_dev != statbuf2.st_dev) ||
2053             (lstatbuf.st_ino != statbuf2.st_ino))
2054           {
2055           addr->basic_errno = ERRNO_LOCKFAILED;
2056           addr->message = string_sprintf("RACE CONDITION detected: "
2057               "mismatch post-initial-checks between \"%s\" and opened "
2058               "fd lead us to abort!", mbx_lockname);
2059           goto RETURN;
2060           }
2061
2062         (void)Uchmod(mbx_lockname, ob->lockfile_mode);
2063
2064         if (apply_lock(mbx_lockfd, F_WRLCK, ob->use_fcntl,
2065             ob->lock_fcntl_timeout, ob->use_flock, ob->lock_flock_timeout) >= 0)
2066           {
2067           struct stat ostatbuf;
2068
2069           /* This tests for a specific race condition. Ensure that we still
2070           have the same file. */
2071
2072           if (Ulstat(mbx_lockname, &statbuf) == 0 &&
2073               fstat(mbx_lockfd, &ostatbuf) == 0 &&
2074               statbuf.st_dev == ostatbuf.st_dev &&
2075               statbuf.st_ino == ostatbuf.st_ino)
2076             break;
2077           DEBUG(D_transport) debug_printf("MBX lockfile %s changed "
2078             "between creation and locking\n", mbx_lockname);
2079           }
2080
2081         DEBUG(D_transport) debug_printf("failed to lock %s: %s\n", mbx_lockname,
2082           strerror(errno));
2083         (void)close(mbx_lockfd);
2084         mbx_lockfd = -1;
2085         }
2086       else
2087         {
2088         DEBUG(D_transport) debug_printf("failed to fstat or get read lock on %s: %s\n",
2089           filename, strerror(errno));
2090         }
2091       }
2092     #endif  /* SUPPORT_MBX */
2093
2094     else break;   /* No on-file locking required; break the open/lock loop */
2095
2096     DEBUG(D_transport)
2097       debug_printf("fcntl(), flock(), or MBX locking failed - retrying\n");
2098
2099     (void)close(fd);
2100     fd = -1;
2101     use_lstat = TRUE;             /* Reset to use lstat first */
2102
2103
2104     /* If a blocking call timed out, break the retry loop if the total time
2105     so far is not less than than retries * interval. Use the larger of the
2106     flock() and fcntl() timeouts. */
2107
2108     if (sigalrm_seen &&
2109         (i+1) * ((ob->lock_fcntl_timeout > ob->lock_flock_timeout)?
2110           ob->lock_fcntl_timeout : ob->lock_flock_timeout) >=
2111           ob->lock_retries * ob->lock_interval)
2112       i = ob->lock_retries;
2113
2114     /* Wait a bit before retrying, except when it was a blocked fcntl() or
2115     flock() that caused the problem. */
2116
2117     if (i < ob->lock_retries && sleep_before_retry) sleep(ob->lock_interval);
2118     }
2119
2120   /* Test for exceeding the maximum number of tries. Either the file remains
2121   locked, or, if we haven't got it open, something is terribly wrong... */
2122
2123   if (i >= ob->lock_retries)
2124     {
2125     if (!file_opened)
2126       {
2127       addr->basic_errno = ERRNO_EXISTRACE;
2128       addr->message = string_sprintf("mailbox %s: existence unclear", filename);
2129       addr->special_action = SPECIAL_FREEZE;
2130       }
2131     else
2132       {
2133       addr->basic_errno = ERRNO_LOCKFAILED;
2134       addr->message = string_sprintf("failed to lock mailbox %s (fcntl/flock)",
2135         filename);
2136       }
2137     goto RETURN;
2138     }
2139
2140   DEBUG(D_transport) debug_printf("mailbox %s is locked\n", filename);
2141
2142   /* Save access time (for subsequent restoration), modification time (for
2143   restoration if updating fails), size of file (for comsat and for re-setting if
2144   delivery fails in the middle - e.g. for quota exceeded). */
2145
2146   if (fstat(fd, &statbuf) < 0)
2147     {
2148     addr->basic_errno = errno;
2149     addr->message = string_sprintf("while fstatting opened mailbox %s",
2150       filename);
2151     goto RETURN;
2152     }
2153
2154   times.actime = statbuf.st_atime;
2155   times.modtime = statbuf.st_mtime;
2156   saved_size = statbuf.st_size;
2157   if (mailbox_size < 0) mailbox_size = saved_size;
2158   mailbox_filecount = 0;  /* Not actually relevant for single-file mailbox */
2159   }
2160
2161 /* Prepare for writing to a new file (as opposed to appending to an old one).
2162 There are several different formats, but there is preliminary stuff concerned
2163 with quotas that applies to all of them. Finding the current size by directory
2164 scanning is expensive; for maildirs some fudges have been invented:
2165
2166   (1) A regex can be used to extract a file size from its name;
2167   (2) If maildir_use_size is set, a maildirsize file is used to cache the
2168       mailbox size.
2169 */
2170
2171 else
2172   {
2173   uschar *check_path;           /* Default quota check path */
2174   const pcre2_code * re = NULL;     /* Regex for file size from file name */
2175
2176   if (!check_creation(string_sprintf("%s/any", path),
2177                       ob->create_file, deliver_dir))
2178     {
2179     addr->basic_errno = ERRNO_BADCREATE;
2180     addr->message = string_sprintf("tried to create file in %s, but "
2181       "file creation outside the home directory is not permitted", path);
2182     goto RETURN;
2183     }
2184
2185   /* If the create_file option is an absolute path and the file was within
2186   it, de-taint. Otherwise check for taint. */
2187
2188   if (is_tainted(path))
2189     if (ob->create_file == create_belowhome)
2190       {
2191       DEBUG(D_transport) debug_printf("de-tainting path '%s'\n", path);
2192       path = string_copy_taint(path, GET_UNTAINTED);
2193       }
2194     else
2195       goto tainted_ret_panic;
2196
2197   check_path = path;
2198
2199   #ifdef SUPPORT_MAILDIR
2200   /* For a maildir delivery, ensure that all the relevant directories exist,
2201   and a maildirfolder file if necessary. */
2202
2203   if (mbformat == mbf_maildir && !maildir_ensure_directories(path, addr,
2204     ob->create_directory, ob->dirmode, ob->maildirfolder_create_regex))
2205       return FALSE;
2206   #endif  /* SUPPORT_MAILDIR */
2207
2208   /* If we are going to do a quota check, of if maildir_use_size_file is set
2209   for a maildir delivery, compile the regular expression if there is one. We
2210   may also need to adjust the path that is used. We need to do this for
2211   maildir_use_size_file even if the quota is unset, because we still want to
2212   create the file. When maildir support is not compiled,
2213   ob->maildir_use_size_file is always FALSE. */
2214
2215   if (ob->quota_value > 0 || THRESHOLD_CHECK || ob->maildir_use_size_file)
2216     {
2217     /* Compile the regex if there is one. */
2218
2219     if (ob->quota_size_regex)
2220       {
2221       if (!(re = regex_compile(ob->quota_size_regex,
2222                   MCS_NOFLAGS, &addr->message, pcre_gen_cmp_ctx)))
2223         return FALSE;
2224
2225       DEBUG(D_transport) debug_printf("using regex for file sizes: %s\n",
2226         ob->quota_size_regex);
2227       }
2228
2229     /* Use an explicitly configured directory if set */
2230
2231     if (ob->quota_directory)
2232       {
2233       if (!(check_path = expand_string(ob->quota_directory)))
2234         {
2235         addr->message = string_sprintf("Expansion of \"%s\" (quota_directory "
2236          "name for %s transport) failed: %s", ob->quota_directory,
2237           tblock->name, expand_string_message);
2238         goto ret_panic;
2239         }
2240
2241       if (check_path[0] != '/')
2242         {
2243         addr->message = string_sprintf("appendfile: quota_directory name "
2244           "\"%s\" is not absolute", check_path);
2245         addr->basic_errno = ERRNO_NOTABSOLUTE;
2246         return FALSE;
2247         }
2248       }
2249
2250     #ifdef SUPPORT_MAILDIR
2251     /* Otherwise, if we are handling a maildir delivery, and the directory
2252     contains a file called maildirfolder, this is a maildir++ feature telling
2253     us that this is a sub-directory of the real inbox. We should therefore do
2254     the quota check on the parent directory. Beware of the special case when
2255     the directory name itself ends in a slash. */
2256
2257     else if (mbformat == mbf_maildir)
2258       {
2259       struct stat statbuf;
2260       if (Ustat(string_sprintf("%s/maildirfolder", path), &statbuf) >= 0)
2261         {
2262         uschar *new_check_path = string_copy(check_path);
2263         uschar *slash = Ustrrchr(new_check_path, '/');
2264         if (slash)
2265           {
2266           if (!slash[1])
2267             {
2268             *slash = 0;
2269             slash = Ustrrchr(new_check_path, '/');
2270             }
2271           if (slash)
2272             {
2273             *slash = 0;
2274             check_path = new_check_path;
2275             DEBUG(D_transport) debug_printf("maildirfolder file exists: "
2276               "quota check directory changed to %s\n", check_path);
2277             }
2278           }
2279         }
2280       }
2281     #endif  /* SUPPORT_MAILDIR */
2282     }
2283
2284   /* If we are using maildirsize files, we need to ensure that such a file
2285   exists and, if necessary, recalculate its contents. As a byproduct of this,
2286   we obtain the current size of the maildir. If no quota is to be enforced
2287   (ob->quota_value == 0), we still need the size if a threshold check will
2288   happen later.
2289
2290   Another regular expression is used to determine which directories inside the
2291   maildir are going to be counted. */
2292
2293   #ifdef SUPPORT_MAILDIR
2294   if (ob->maildir_use_size_file)
2295     {
2296     const pcre2_code * dir_regex = NULL;
2297
2298     if (ob->maildir_dir_regex)
2299       {
2300       int check_path_len = Ustrlen(check_path);
2301
2302       if (!(dir_regex = regex_compile(ob->maildir_dir_regex,
2303             MCS_NOFLAGS, &addr->message, pcre_gen_cmp_ctx)))
2304         return FALSE;
2305
2306       DEBUG(D_transport)
2307         debug_printf("using regex for maildir directory selection: %s\n",
2308           ob->maildir_dir_regex);
2309
2310       /* Check to see if we are delivering into an ignored directory, that is,
2311       if the delivery path starts with the quota check path, and the rest
2312       of the deliver path matches the regex; if so, set a flag to disable quota
2313       checking and maildirsize updating. */
2314
2315       if (Ustrncmp(path, check_path, check_path_len) == 0)
2316         {
2317         uschar *s = path + check_path_len;
2318         while (*s == '/') s++;
2319         s = *s ? string_sprintf("%s/new", s) : US"new";
2320         if (!regex_match(dir_regex, s, -1, NULL))
2321           {
2322           disable_quota = TRUE;
2323           DEBUG(D_transport) debug_printf("delivery directory does not match "
2324             "maildir_quota_directory_regex: disabling quota\n");
2325           }
2326         }
2327       }
2328
2329     /* Quota enforcement; create and check the file. There is some discussion
2330     about whether this should happen if the quota is unset. At present, Exim
2331     always creates the file. If we ever want to change this, uncomment
2332     appropriate lines below, possibly doing a check on some option. */
2333
2334 /*  if (???? || ob->quota_value > 0) */
2335
2336     if (!disable_quota)
2337       {
2338       off_t size;
2339       int filecount;
2340
2341       if ((maildirsize_fd = maildir_ensure_sizefile(check_path, ob,  re, dir_regex,
2342           &size, &filecount)) == -1)
2343         {
2344         addr->basic_errno = errno;
2345         addr->message = string_sprintf("while opening or reading "
2346           "%s/maildirsize", check_path);
2347         return FALSE;
2348         }
2349       /* can also return -2, which means that the file was removed because of
2350       raciness; but in this case, the size & filecount will still have been
2351       updated. */
2352
2353       if (mailbox_size < 0) mailbox_size = size;
2354       if (mailbox_filecount < 0) mailbox_filecount = filecount;
2355       }
2356
2357     /* No quota enforcement; ensure file does *not* exist; calculate size if
2358     needed. */
2359
2360 /*  else
2361  *    {
2362  *    time_t old_latest;
2363  *    (void)unlink(CS string_sprintf("%s/maildirsize", check_path));
2364  *    if (THRESHOLD_CHECK)
2365  *      mailbox_size = maildir_compute_size(check_path, &mailbox_filecount, &old_latest,
2366  *         re, dir_regex, FALSE);
2367  *    }
2368 */
2369
2370     }
2371   #endif  /* SUPPORT_MAILDIR */
2372
2373   /* Otherwise if we are going to do a quota check later on, and the mailbox
2374   size is not set, find the current size of the mailbox. Ditto for the file
2375   count. Note that ob->quota_filecount_value cannot be set without
2376   ob->quota_value being set. */
2377
2378   if (  !disable_quota
2379      && (ob->quota_value > 0 || THRESHOLD_CHECK)
2380      && (  mailbox_size < 0
2381         || mailbox_filecount < 0 && ob->quota_filecount_value > 0
2382     )   )
2383     {
2384     off_t size;
2385     int filecount = 0;
2386     DEBUG(D_transport)
2387       debug_printf("quota checks on directory %s\n", check_path);
2388     size = check_dir_size(check_path, &filecount,  re);
2389     if (mailbox_size < 0) mailbox_size = size;
2390     if (mailbox_filecount < 0) mailbox_filecount = filecount;
2391     }
2392
2393   /* Handle the case of creating a unique file in a given directory (not in
2394   maildir or mailstore format - this is how smail did it). A temporary name is
2395   used to create the file. Later, when it is written, the name is changed to a
2396   unique one. There is no need to lock the file. An attempt is made to create
2397   the directory if it does not exist. */
2398
2399   if (mbformat == mbf_smail)
2400     {
2401     DEBUG(D_transport)
2402       debug_printf("delivering to new file in %s\n", path);
2403     filename = dataname =
2404       string_sprintf("%s/temp.%d.%s", path, (int)getpid(), primary_hostname);
2405     fd = Uopen(filename, O_WRONLY|O_CREAT, mode);
2406     if (fd < 0 &&                                 /* failed to open, and */
2407         (errno != ENOENT ||                       /* either not non-exist */
2408          !ob->create_directory ||                 /* or not allowed to make */
2409          !directory_make(NULL, path, ob->dirmode, FALSE) ||  /* or failed to create dir */
2410          (fd = Uopen(filename, O_WRONLY|O_CREAT|O_EXCL, mode)) < 0)) /* or then failed to open */
2411       {
2412       addr->basic_errno = errno;
2413       addr->message = string_sprintf("while creating file %s", filename);
2414       return FALSE;
2415       }
2416     }
2417
2418   #ifdef SUPPORT_MAILDIR
2419
2420   /* Handle the case of a unique file in maildir format. The file is written to
2421   the tmp subdirectory, with a prescribed form of name. */
2422
2423   else if (mbformat == mbf_maildir)
2424     {
2425     DEBUG(D_transport)
2426       debug_printf("delivering in maildir format in %s\n", path);
2427
2428     nametag = ob->maildir_tag;
2429
2430     /* Check that nametag expands successfully; a hard failure causes a panic
2431     return. The actual expansion for use happens again later, when
2432     $message_size is accurately known. */
2433
2434     if (nametag && !expand_string(nametag) && !f.expand_string_forcedfail)
2435       {
2436       addr->message = string_sprintf("Expansion of \"%s\" (maildir_tag "
2437         "for %s transport) failed: %s", nametag, tblock->name,
2438         expand_string_message);
2439       goto ret_panic;
2440       }
2441
2442     /* We ensured the existence of all the relevant directories above. Attempt
2443     to open the temporary file a limited number of times. I think this rather
2444     scary-looking for statement is actually OK. If open succeeds, the loop is
2445     broken; if not, there is a test on the value of i. Get the time again
2446     afresh each time round the loop. Its value goes into a variable that is
2447     checked at the end, to make sure we don't release this process until the
2448     clock has ticked. */
2449
2450     for (int i = 1;; i++)
2451       {
2452       uschar *basename;
2453
2454       (void)gettimeofday(&msg_tv, NULL);
2455       basename = string_sprintf(TIME_T_FMT ".M%luP" PID_T_FMT ".%s",
2456         msg_tv.tv_sec, msg_tv.tv_usec, getpid(), primary_hostname);
2457
2458       filename = dataname = string_sprintf("tmp/%s", basename);
2459       newname = string_sprintf("new/%s", basename);
2460
2461       if (Ustat(filename, &statbuf) == 0)
2462         errno = EEXIST;
2463       else if (errno == ENOENT)
2464         {
2465         if ((fd = Uopen(filename, O_WRONLY | O_CREAT | O_EXCL, mode)) >= 0)
2466           break;
2467         DEBUG (D_transport) debug_printf ("open failed for %s: %s\n",
2468           filename, strerror(errno));
2469         }
2470
2471       /* Too many retries - give up */
2472
2473       if (i >= ob->maildir_retries)
2474         {
2475         addr->message = string_sprintf ("failed to open %s (%d tr%s)",
2476           filename, i, (i == 1) ? "y" : "ies");
2477         addr->basic_errno = errno;
2478         if (errno == errno_quota || errno == ENOSPC)
2479           addr->user_message = US"mailbox is full";
2480         return FALSE;
2481         }
2482
2483       /* Open or stat failed but we haven't tried too many times yet. */
2484
2485       sleep(2);
2486       }
2487
2488     /* Note that we have to ensure the clock has ticked before leaving */
2489
2490     wait_for_tick = TRUE;
2491
2492     /* Why are these here? Put in because they are present in the non-maildir
2493     directory case above. */
2494
2495     if (exim_chown(filename, uid, gid) || Uchmod(filename, mode))
2496       {
2497       addr->basic_errno = errno;
2498       addr->message = string_sprintf("while setting perms on maildir %s",
2499         filename);
2500       return FALSE;
2501       }
2502     }
2503
2504   #endif  /* SUPPORT_MAILDIR */
2505
2506   #ifdef SUPPORT_MAILSTORE
2507
2508   /* Handle the case of a unique file in mailstore format. First write the
2509   envelope to a temporary file, then open the main file. The unique base name
2510   for the files consists of the message id plus the pid of this delivery
2511   process. */
2512
2513   else
2514     {
2515     FILE * env_file;
2516     mailstore_basename = string_sprintf("%s/%s-%s", path, message_id,
2517       string_base62_64((long int)getpid()));
2518
2519     DEBUG(D_transport)
2520       debug_printf("delivering in mailstore format in %s\n", path);
2521
2522     filename = string_sprintf("%s.tmp", mailstore_basename);
2523     newname  = string_sprintf("%s.env", mailstore_basename);
2524     dataname = string_sprintf("%s.msg", mailstore_basename);
2525
2526     fd = Uopen(filename, O_WRONLY|O_CREAT|O_EXCL, mode);
2527     if (  fd < 0                                /* failed to open, and */
2528        && (   errno != ENOENT                   /* either not non-exist */
2529           || !ob->create_directory              /* or not allowed to make */
2530           || !directory_make(NULL, path, ob->dirmode, FALSE)  /* or failed to create dir */
2531           || (fd = Uopen(filename, O_WRONLY|O_CREAT|O_EXCL, mode)) < 0 /* or then failed to open */
2532        )  )
2533       {
2534       addr->basic_errno = errno;
2535       addr->message = string_sprintf("while creating file %s", filename);
2536       return FALSE;
2537       }
2538
2539     /* Why are these here? Put in because they are present in the non-maildir
2540     directory case above. */
2541
2542     if (exim_chown(filename, uid, gid) || Uchmod(filename, mode))
2543       {
2544       addr->basic_errno = errno;
2545       addr->message = string_sprintf("while setting perms on file %s",
2546         filename);
2547       return FALSE;
2548       }
2549
2550     /* Built a C stream from the open file descriptor. */
2551
2552     if (!(env_file = fdopen(fd, "wb")))
2553       {
2554       addr->basic_errno = errno;
2555       addr->message = string_sprintf("fdopen of %s ("
2556         "for %s transport) failed", filename, tblock->name);
2557       (void)close(fd);
2558       Uunlink(filename);
2559       goto ret_panic;
2560       }
2561
2562     /* Write the envelope file, then close it. */
2563
2564     if (ob->mailstore_prefix)
2565       {
2566       uschar *s = expand_string(ob->mailstore_prefix);
2567       if (!s)
2568         {
2569         if (!f.expand_string_forcedfail)
2570           {
2571           addr->message = string_sprintf("Expansion of \"%s\" (mailstore "
2572             "prefix for %s transport) failed: %s", ob->mailstore_prefix,
2573             tblock->name, expand_string_message);
2574           (void)fclose(env_file);
2575           Uunlink(filename);
2576           goto ret_panic;
2577           }
2578         }
2579       else
2580         {
2581         int n = Ustrlen(s);
2582         fprintf(env_file, "%s", CS s);
2583         if (n == 0 || s[n-1] != '\n') fprintf(env_file, "\n");
2584         }
2585       }
2586
2587     fprintf(env_file, "%s\n", sender_address);
2588
2589     for (address_item * taddr = addr; taddr; taddr = taddr->next)
2590       fprintf(env_file, "%s@%s\n", taddr->local_part, taddr->domain);
2591
2592     if (ob->mailstore_suffix)
2593       {
2594       uschar *s = expand_string(ob->mailstore_suffix);
2595       if (!s)
2596         {
2597         if (!f.expand_string_forcedfail)
2598           {
2599           addr->message = string_sprintf("Expansion of \"%s\" (mailstore "
2600             "suffix for %s transport) failed: %s", ob->mailstore_suffix,
2601             tblock->name, expand_string_message);
2602           (void)fclose(env_file);
2603           Uunlink(filename);
2604           goto ret_panic;
2605           }
2606         }
2607       else
2608         {
2609         int n = Ustrlen(s);
2610         fprintf(env_file, "%s", CS s);
2611         if (n == 0 || s[n-1] != '\n') fprintf(env_file, "\n");
2612         }
2613       }
2614
2615     if (fclose(env_file) != 0)
2616       {
2617       addr->basic_errno = errno;
2618       addr->message = string_sprintf("while closing %s", filename);
2619       Uunlink(filename);
2620       return FALSE;
2621       }
2622
2623     DEBUG(D_transport) debug_printf("Envelope file %s written\n", filename);
2624
2625     /* Now open the data file, and ensure that it has the correct ownership and
2626     mode. */
2627
2628     if ((fd = Uopen(dataname, O_WRONLY|O_CREAT|O_EXCL, mode)) < 0)
2629       {
2630       addr->basic_errno = errno;
2631       addr->message = string_sprintf("while creating file %s", dataname);
2632       Uunlink(filename);
2633       return FALSE;
2634       }
2635     if (exim_chown(dataname, uid, gid) || Uchmod(dataname, mode))
2636       {
2637       addr->basic_errno = errno;
2638       addr->message = string_sprintf("while setting perms on file %s",
2639         dataname);
2640       return FALSE;
2641       }
2642     }
2643
2644   #endif  /* SUPPORT_MAILSTORE */
2645
2646
2647   /* In all cases of writing to a new file, ensure that the file which is
2648   going to be renamed has the correct ownership and mode. */
2649
2650   if (exim_chown(filename, uid, gid) || Uchmod(filename, mode))
2651     {
2652     addr->basic_errno = errno;
2653     addr->message = string_sprintf("while setting perms on file %s",
2654       filename);
2655     return FALSE;
2656     }
2657   }
2658
2659
2660 /* At last we can write the message to the file, preceded by any configured
2661 prefix line, and followed by any configured suffix line. If there are any
2662 writing errors, we must defer. */
2663
2664 DEBUG(D_transport) debug_printf("writing to file %s\n", dataname);
2665
2666 yield = OK;
2667 errno = 0;
2668
2669 /* If there is a local quota setting, check that we are not going to exceed it
2670 with this message if quota_is_inclusive is set; if it is not set, the check
2671 is for the mailbox already being over quota (i.e. the current message is not
2672 included in the check). */
2673
2674 if (!disable_quota && ob->quota_value > 0)
2675   {
2676   DEBUG(D_transport)
2677     {
2678     debug_printf("Exim quota = " OFF_T_FMT " old size = " OFF_T_FMT
2679       " this message = %d (%sincluded)\n",
2680       ob->quota_value, mailbox_size, message_size,
2681       ob->quota_is_inclusive ? "" : "not ");
2682     debug_printf("  file count quota = %d count = %d\n",
2683       ob->quota_filecount_value, mailbox_filecount);
2684     }
2685
2686   if (mailbox_size + (ob->quota_is_inclusive ? message_size:0) > ob->quota_value)
2687     if (!ob->quota_no_check)
2688       {
2689       DEBUG(D_transport) debug_printf("mailbox quota exceeded\n");
2690       yield = DEFER;
2691       errno = ERRNO_EXIMQUOTA;
2692       }
2693     else
2694       DEBUG(D_transport) debug_printf("mailbox quota exceeded but ignored\n");
2695
2696   if (ob->quota_filecount_value > 0
2697            && mailbox_filecount + (ob->quota_is_inclusive ? 1:0) >
2698               ob->quota_filecount_value)
2699     if (!ob->quota_filecount_no_check)
2700       {
2701       DEBUG(D_transport) debug_printf("mailbox file count quota exceeded\n");
2702       yield = DEFER;
2703       errno = ERRNO_EXIMQUOTA;
2704       filecount_msg = US" filecount";
2705       }
2706     else DEBUG(D_transport) if (ob->quota_filecount_no_check)
2707       debug_printf("mailbox file count quota exceeded but ignored\n");
2708
2709   }
2710
2711 if (verify_mode)
2712   {
2713   addr->basic_errno = errno;
2714   addr->message = US"Over quota";
2715   addr->transport_return = yield;
2716   DEBUG(D_transport)
2717     debug_printf("appendfile (verify) yields %d with errno=%d more_errno=%d\n",
2718       yield, addr->basic_errno, addr->more_errno);
2719
2720   goto RETURN;
2721   }
2722
2723 /* If we are writing in MBX format, what we actually do is to write the message
2724 to a temporary file, and then copy it to the real file once we know its size.
2725 This is the most straightforward way of getting the correct length in the
2726 separator line. So, what we do here is to save the real file descriptor, and
2727 replace it with one for a temporary file. The temporary file gets unlinked once
2728 opened, so that it goes away on closure. */
2729
2730 #ifdef SUPPORT_MBX
2731 if (yield == OK && ob->mbx_format)
2732   {
2733   if (!(temp_file = tmpfile()))
2734     {
2735     addr->basic_errno = errno;
2736     addr->message = US"while setting up temporary file";
2737     yield = DEFER;
2738     goto RETURN;
2739     }
2740   save_fd = fd;
2741   fd = fileno(temp_file);
2742   DEBUG(D_transport) debug_printf("writing to temporary file\n");
2743   }
2744 #endif  /* SUPPORT_MBX */
2745
2746 /* Zero the count of bytes written. It is incremented by the transport_xxx()
2747 functions. */
2748
2749 transport_count = 0;
2750 transport_newlines = 0;
2751
2752 /* Write any configured prefix text first */
2753
2754 if (yield == OK && ob->message_prefix && *ob->message_prefix)
2755   {
2756   uschar *prefix = expand_string(ob->message_prefix);
2757   if (!prefix)
2758     {
2759     errno = ERRNO_EXPANDFAIL;
2760     addr->transport_return = PANIC;
2761     addr->message = string_sprintf("Expansion of \"%s\" (prefix for %s "
2762       "transport) failed", ob->message_prefix, tblock->name);
2763     yield = DEFER;
2764     }
2765   else if (!transport_write_string(fd, "%s", prefix)) yield = DEFER;
2766   }
2767
2768 /* If the use_bsmtp option is on, we need to write SMTP prefix information. The
2769 various different values for batching are handled outside; if there is more
2770 than one address available here, all must be included. If any address is a
2771 file, use its parent in the RCPT TO. */
2772
2773 if (yield == OK && ob->use_bsmtp)
2774   {
2775   transport_count = 0;
2776   transport_newlines = 0;
2777   if (ob->use_crlf) cr = US"\r";
2778   if (!transport_write_string(fd, "MAIL FROM:<%s>%s\n", return_path, cr))
2779     yield = DEFER;
2780   else
2781     {
2782     transport_newlines++;
2783     for (address_item * a = addr; a; a = a->next)
2784       {
2785       address_item * b = testflag(a, af_pfr) ? a->parent : a;
2786       if (!transport_write_string(fd, "RCPT TO:<%s>%s\n",
2787         transport_rcpt_address(b, tblock->rcpt_include_affixes), cr))
2788           { yield = DEFER; break; }
2789       transport_newlines++;
2790       }
2791     if (yield == OK && !transport_write_string(fd, "DATA%s\n", cr))
2792       yield = DEFER;
2793     else
2794       transport_newlines++;
2795     }
2796   }
2797
2798 /* Now the message itself. The options for transport_write_message were set up
2799 at initialization time. */
2800
2801 if (yield == OK)
2802   {
2803   transport_ctx tctx = {
2804     .u = {.fd=fd},
2805     .tblock = tblock,
2806     .addr = addr,
2807     .check_string = ob->check_string,
2808     .escape_string = ob->escape_string,
2809     .options =  ob->options | topt_not_socket
2810   };
2811   if (!transport_write_message(&tctx, 0))
2812     yield = DEFER;
2813   }
2814
2815 /* Now a configured suffix. */
2816
2817 if (yield == OK && ob->message_suffix && *ob->message_suffix)
2818   {
2819   uschar *suffix = expand_string(ob->message_suffix);
2820   if (!suffix)
2821     {
2822     errno = ERRNO_EXPANDFAIL;
2823     addr->transport_return = PANIC;
2824     addr->message = string_sprintf("Expansion of \"%s\" (suffix for %s "
2825       "transport) failed", ob->message_suffix, tblock->name);
2826     yield = DEFER;
2827     }
2828   else if (!transport_write_string(fd, "%s", suffix)) yield = DEFER;
2829   }
2830
2831 /* If batch smtp, write the terminating dot. */
2832
2833 if (yield == OK && ob->use_bsmtp)
2834   if (!transport_write_string(fd, ".%s\n", cr)) yield = DEFER;
2835   else transport_newlines++;
2836
2837 /* If MBX format is being used, all that writing was to the temporary file.
2838 However, if there was an earlier failure (Exim quota exceeded, for example),
2839 the temporary file won't have got opened - and no writing will have been done.
2840 If writing was OK, we restore the fd, and call a function that copies the
2841 message in MBX format into the real file. Otherwise use the temporary name in
2842 any messages. */
2843
2844 #ifdef SUPPORT_MBX
2845 if (temp_file && ob->mbx_format)
2846   {
2847   int mbx_save_errno;
2848   fd = save_fd;
2849
2850   if (yield == OK)
2851     {
2852     transport_count = 0;   /* Reset transport count for actual write */
2853     /* No need to reset transport_newlines as we're just using a block copy
2854      * routine so the number won't be affected */
2855     yield = copy_mbx_message(fd, fileno(temp_file), saved_size);
2856     }
2857   else if (errno >= 0) dataname = US"temporary file";
2858
2859   /* Preserve errno while closing the temporary file. */
2860
2861   mbx_save_errno = errno;
2862   (void)fclose(temp_file);
2863   errno = mbx_save_errno;
2864   }
2865 #endif  /* SUPPORT_MBX */
2866
2867 /* Force out the remaining data to check for any errors; some OS don't allow
2868 fsync() to be called for a FIFO. */
2869
2870 if (yield == OK && !isfifo && EXIMfsync(fd) < 0) yield = DEFER;
2871
2872 /* Update message_size and message_linecount to the accurate count of bytes
2873 written, including added headers. Note; we subtract 1 from message_linecount as
2874 this variable doesn't count the new line between the header and the body of the
2875 message. */
2876
2877 message_size = transport_count;
2878 message_linecount = transport_newlines - 1;
2879
2880 /* If using a maildir++ quota file, add this message's size to it, and
2881 close the file descriptor, except when the quota has been disabled because we
2882 are delivering into an uncounted folder. */
2883
2884 #ifdef SUPPORT_MAILDIR
2885 if (!disable_quota)
2886   {
2887   if (yield == OK && maildirsize_fd >= 0)
2888     maildir_record_length(maildirsize_fd, message_size);
2889   maildir_save_errno = errno;    /* Preserve errno while closing the file */
2890   if (maildirsize_fd >= 0)
2891     (void)close(maildirsize_fd);
2892   errno = maildir_save_errno;
2893   }
2894 #endif  /* SUPPORT_MAILDIR */
2895
2896 /* If there is a quota warning threshold and we are have crossed it with this
2897 message, set the SPECIAL_WARN flag in the address, to cause a warning message
2898 to be sent. */
2899
2900 if (!disable_quota && THRESHOLD_CHECK)
2901   {
2902   off_t threshold = ob->quota_warn_threshold_value;
2903   if (ob->quota_warn_threshold_is_percent)
2904     threshold = (off_t)(((double)ob->quota_value * threshold) / 100);
2905   DEBUG(D_transport)
2906     debug_printf("quota = " OFF_T_FMT
2907       " threshold = " OFF_T_FMT
2908       " old size = " OFF_T_FMT
2909       " message size = %d\n",
2910       ob->quota_value, threshold, mailbox_size,
2911       message_size);
2912   if (mailbox_size <= threshold && mailbox_size + message_size > threshold)
2913     addr->special_action = SPECIAL_WARN;
2914
2915   /******* You might think that the test ought to be this:
2916   *
2917   * if (ob->quota_value > 0 && threshold > 0 && mailbox_size > 0 &&
2918   *     mailbox_size <= threshold && mailbox_size + message_size > threshold)
2919   *
2920   * (indeed, I was sent a patch with that in). However, it is possible to
2921   * have a warning threshold without actually imposing a quota, and I have
2922   * therefore kept Exim backwards compatible.
2923   ********/
2924
2925   }
2926
2927 /* Handle error while writing the file. Control should come here directly after
2928 the error, with the reason in errno. In the case of expansion failure in prefix
2929 or suffix, it will be ERRNO_EXPANDFAIL. */
2930
2931 if (yield != OK)
2932   {
2933   addr->special_action = SPECIAL_NONE;     /* Cancel any quota warning */
2934
2935   /* Save the error number. If positive, it will ultimately cause a strerror()
2936   call to generate some text. */
2937
2938   addr->basic_errno = errno;
2939
2940   /* For system or Exim quota excession, or disk full, set more_errno to the
2941   time since the file was last read. If delivery was into a directory, the
2942   time since last read logic is not relevant, in general. However, for maildir
2943   deliveries we can approximate it by looking at the last modified time of the
2944   "new" subdirectory. Since Exim won't be adding new messages, a change to the
2945   "new" subdirectory implies that an MUA has moved a message from there to the
2946   "cur" directory. */
2947
2948   if (errno == errno_quota || errno == ERRNO_EXIMQUOTA || errno == ENOSPC)
2949     {
2950     addr->more_errno = 0;
2951     if (!isdirectory) addr->more_errno = (int)(time(NULL) - times.actime);
2952
2953     #ifdef SUPPORT_MAILDIR
2954     else if (mbformat == mbf_maildir)
2955       {
2956       struct stat statbuf;
2957       if (Ustat("new", &statbuf) < 0)
2958         {
2959         DEBUG(D_transport) debug_printf("maildir quota exceeded: "
2960           "stat error %d for \"new\": %s\n", errno, strerror(errno));
2961         }
2962       else   /* Want a repeatable time when in test harness */
2963         addr->more_errno = f.running_in_test_harness ? 10 :
2964           (int)time(NULL) - statbuf.st_mtime;
2965
2966       DEBUG(D_transport)
2967         debug_printf("maildir: time since \"new\" directory modified = %s\n",
2968         readconf_printtime(addr->more_errno));
2969       }
2970     #endif /* SUPPORT_MAILDIR */
2971     }
2972
2973   /* Handle system quota excession. Add an explanatory phrase for the error
2974   message, since some systems don't have special quota-excession errors,
2975   and on those that do, "quota" doesn't always mean anything to the user. */
2976
2977   if (errno == errno_quota)
2978     {
2979     #ifndef EDQUOT
2980     addr->message = string_sprintf("mailbox is full "
2981       "(quota exceeded while writing to file %s)", filename);
2982     #else
2983     addr->message = US"mailbox is full";
2984     #endif  /* EDQUOT */
2985     addr->user_message = US"mailbox is full";
2986     DEBUG(D_transport) debug_printf("System quota exceeded for %s%s%s\n",
2987       dataname,
2988       isdirectory ? US"" : US": time since file read = ",
2989       isdirectory ? US"" : readconf_printtime(addr->more_errno));
2990     }
2991
2992   /* Handle Exim's own quota-imposition */
2993
2994   else if (errno == ERRNO_EXIMQUOTA)
2995     {
2996     addr->message = string_sprintf("mailbox is full "
2997       "(MTA-imposed%s quota exceeded while writing to %s)", filecount_msg,
2998         dataname);
2999     addr->user_message = US"mailbox is full";
3000     DEBUG(D_transport) debug_printf("Exim%s quota exceeded for %s%s%s\n",
3001       filecount_msg, dataname,
3002       isdirectory ? US"" : US": time since file read = ",
3003       isdirectory ? US"" : readconf_printtime(addr->more_errno));
3004     }
3005
3006   /* Handle a process failure while writing via a filter; the return
3007   from child_close() is in more_errno. */
3008
3009   else if (errno == ERRNO_FILTER_FAIL)
3010     {
3011     yield = PANIC;
3012     addr->message = string_sprintf("transport filter process failed (%d) "
3013       "while writing to %s%s", addr->more_errno, dataname,
3014       (addr->more_errno == EX_EXECFAILED) ? ": unable to execute command" : "");
3015     }
3016
3017   /* Handle failure to expand header changes */
3018
3019   else if (errno == ERRNO_CHHEADER_FAIL)
3020     {
3021     yield = PANIC;
3022     addr->message =
3023       string_sprintf("failed to expand headers_add or headers_remove while "
3024         "writing to %s: %s", dataname, expand_string_message);
3025     }
3026
3027   /* Handle failure to complete writing of a data block */
3028
3029   else if (errno == ERRNO_WRITEINCOMPLETE)
3030     addr->message = string_sprintf("failed to write data block while "
3031       "writing to %s", dataname);
3032
3033   /* Handle length mismatch on MBX copying */
3034
3035   #ifdef SUPPORT_MBX
3036   else if (errno == ERRNO_MBXLENGTH)
3037     addr->message = string_sprintf("length mismatch while copying MBX "
3038       "temporary file to %s", dataname);
3039   #endif  /* SUPPORT_MBX */
3040
3041   /* For other errors, a general-purpose explanation, if the message is
3042   not already set. */
3043
3044   else if (addr->message == NULL)
3045     addr->message = string_sprintf("error while writing to %s", dataname);
3046
3047   /* For a file, reset the file size to what it was before we started, leaving
3048   the last modification time unchanged, so it will get reset also. All systems
3049   investigated so far have ftruncate(), whereas not all have the F_FREESP
3050   fcntl() call (BSDI & FreeBSD do not). */
3051
3052   if (!isdirectory && ftruncate(fd, saved_size))
3053     DEBUG(D_transport) debug_printf("Error resetting file size\n");
3054   }
3055
3056 /* Handle successful writing - we want the modification time to be now for
3057 appended files. Remove the default backstop error number. For a directory, now
3058 is the time to rename the file with a unique name. As soon as such a name
3059 appears it may get used by another process, so we close the file first and
3060 check that all is well. */
3061
3062 else
3063   {
3064   times.modtime = time(NULL);
3065   addr->basic_errno = 0;
3066
3067   /* Handle the case of writing to a new file in a directory. This applies
3068   to all single-file formats - maildir, mailstore, and "smail format". */
3069
3070   if (isdirectory)
3071     {
3072     if (fstat(fd, &statbuf) < 0)
3073       {
3074       addr->basic_errno = errno;
3075       addr->message = string_sprintf("while fstatting opened message file %s",
3076         filename);
3077       yield = DEFER;
3078       }
3079
3080     else if (close(fd) < 0)
3081       {
3082       addr->basic_errno = errno;
3083       addr->message = string_sprintf("close() error for %s",
3084         (ob->mailstore_format) ? dataname : filename);
3085       yield = DEFER;
3086       }
3087
3088     /* File is successfully written and closed. Arrange to rename it. For the
3089     different kinds of single-file delivery, some games can be played with the
3090     name. The message size is by this time set to the accurate value so that
3091     its value can be used in expansions. */
3092
3093     else
3094       {
3095       uschar *renamename = newname;
3096       fd = -1;
3097
3098       DEBUG(D_transport) debug_printf("renaming temporary file\n");
3099
3100       /* If there is no rename name set, we are in a non-maildir, non-mailstore
3101       situation. The name is built by expanding the directory_file option, and
3102       we make the inode number available for use in this. The expansion was
3103       checked for syntactic validity above, before we wrote the file.
3104
3105       We have to be careful here, in case the file name exists. (In the other
3106       cases, the names used are constructed to be unique.) The rename()
3107       function just replaces an existing file - we don't want that! So instead
3108       of calling rename(), we must use link() and unlink().
3109
3110       In this case, if the link fails because of an existing file, we wait
3111       for one second and try the expansion again, to see if it produces a
3112       different value. Do this up to 5 times unless the name stops changing.
3113       This makes it possible to build values that are based on the time, and
3114       still cope with races from multiple simultaneous deliveries. */
3115
3116       if (!newname)
3117         {
3118         uschar *renameleaf;
3119         uschar *old_renameleaf = US"";
3120
3121         for (int i = 0; ; sleep(1), i++)
3122           {
3123           deliver_inode = statbuf.st_ino;
3124           renameleaf = expand_string(ob->dirfilename);
3125           deliver_inode = 0;
3126
3127           if (!renameleaf)
3128             {
3129             addr->transport_return = PANIC;
3130             addr->message = string_sprintf("Expansion of \"%s\" "
3131               "(directory_file for %s transport) failed: %s",
3132               ob->dirfilename, tblock->name, expand_string_message);
3133             goto RETURN;
3134             }
3135
3136           renamename = string_sprintf("%s/%s", path, renameleaf);
3137           if (Ulink(filename, renamename) < 0)
3138             {
3139             DEBUG(D_transport) debug_printf("link failed: %s\n",
3140               strerror(errno));
3141             if (errno != EEXIST || i >= 4 ||
3142                 Ustrcmp(renameleaf, old_renameleaf) == 0)
3143               {
3144               addr->basic_errno = errno;
3145               addr->message = string_sprintf("while renaming %s as %s",
3146                 filename, renamename);
3147               yield = DEFER;
3148               break;
3149               }
3150             old_renameleaf = renameleaf;
3151             DEBUG(D_transport) debug_printf("%s exists - trying again\n",
3152               renamename);
3153             }
3154           else
3155             {
3156             Uunlink(filename);
3157             filename = NULL;
3158             break;
3159             }
3160           }        /* re-expand loop */
3161         }          /* not mailstore or maildir */
3162
3163       /* For maildir and mailstore formats, the new name was created earlier,
3164       except that for maildir, there is the possibility of adding a "tag" on
3165       the end of the name by expanding the value of nametag. This usually
3166       includes a reference to the message size. The expansion of nametag was
3167       checked above, before the file was opened. It either succeeded, or
3168       provoked a soft failure. So any failure here can be treated as soft.
3169       Ignore non-printing characters and / and put a colon at the start if the
3170       first character is alphanumeric. */
3171
3172       else
3173         {
3174         if (nametag)
3175           {
3176           uschar *iptr = expand_string(nametag);
3177           if (iptr)
3178             {
3179             uschar *etag = store_get(Ustrlen(iptr) + 2, iptr);
3180             uschar *optr = etag;
3181             for ( ; *iptr; iptr++)
3182               if (mac_isgraph(*iptr) && *iptr != '/')
3183                 {
3184                 if (optr == etag && isalnum(*iptr)) *optr++ = ':';
3185                 *optr++ = *iptr;
3186                 }
3187             *optr = 0;
3188             renamename = string_sprintf("%s%s", newname, etag);
3189             }
3190           }
3191
3192         /* Do the rename. If the name is too long and a tag exists, try again
3193         without the tag. */
3194
3195         if (Urename(filename, renamename) < 0 &&
3196                (nametag == NULL || errno != ENAMETOOLONG ||
3197                (renamename = newname, Urename(filename, renamename) < 0)))
3198           {
3199           addr->basic_errno = errno;
3200           addr->message = string_sprintf("while renaming %s as %s",
3201             filename, renamename);
3202           yield = DEFER;
3203           }
3204
3205         /* Rename succeeded */
3206
3207         else
3208           {
3209           DEBUG(D_transport) debug_printf("renamed %s as %s\n", filename,
3210             renamename);
3211           filename = dataname = NULL;   /* Prevents attempt to unlink at end */
3212           }
3213         }        /* maildir or mailstore */
3214       }          /* successful write + close */
3215     }            /* isdirectory */
3216   }              /* write success */
3217
3218
3219 /* For a file, restore the last access time (atime), and set the modification
3220 time as required - changed if write succeeded, unchanged if not. */
3221
3222 if (!isdirectory) utime(CS filename, &times);
3223
3224 /* Notify comsat if configured to do so. It only makes sense if the configured
3225 file is the one that the comsat daemon knows about. */
3226
3227 if (ob->notify_comsat && yield == OK && deliver_localpart)
3228   notify_comsat(deliver_localpart, saved_size);
3229
3230 /* Pass back the final return code in the address structure */
3231
3232 DEBUG(D_transport)
3233   debug_printf("appendfile yields %d with errno=%d more_errno=%d\n",
3234     yield, addr->basic_errno, addr->more_errno);
3235
3236 addr->transport_return = yield;
3237
3238 /* Close the file, which will release the fcntl lock. For a directory write it
3239 is closed above, except in cases of error which goto RETURN, when we also need
3240 to remove the original file(s). For MBX locking, if all has gone well, before
3241 closing the file, see if we can get an exclusive lock on it, in which case we
3242 can unlink the /tmp lock file before closing it. This is always a non-blocking
3243 lock; there's no need to wait if we can't get it. If everything has gone right
3244 but close fails, defer the message. Then unlink the lock file, if present. This
3245 point in the code is jumped to from a number of places when errors are
3246 detected, in order to get the file closed and the lock file tidied away. */
3247
3248 RETURN:
3249
3250 #ifdef SUPPORT_MBX
3251 if (mbx_lockfd >= 0)
3252   {
3253   if (yield == OK && apply_lock(fd, F_WRLCK, ob->use_fcntl, 0,
3254       ob->use_flock, 0) >= 0)
3255     {
3256     DEBUG(D_transport)
3257       debug_printf("unlinking MBX lock file %s\n", mbx_lockname);
3258     Uunlink(mbx_lockname);
3259     }
3260   (void)close(mbx_lockfd);
3261   }
3262 #endif  /* SUPPORT_MBX */
3263
3264 if (fd >= 0 && close(fd) < 0 && yield == OK)
3265   {
3266   addr->basic_errno = errno;
3267   addr->message = string_sprintf("while closing %s", filename);
3268   addr->transport_return = DEFER;
3269   }
3270
3271 if (hd >= 0) Uunlink(lockname);
3272
3273 /* We get here with isdirectory and filename set only in error situations. */
3274
3275 if (isdirectory && filename)
3276   {
3277   Uunlink(filename);
3278   if (dataname != filename) Uunlink(dataname);
3279   }
3280
3281 /* If wait_for_tick is TRUE, we have done a delivery where the uniqueness of a
3282 file name relies on time + pid. We must not allow the process to finish until
3283 the clock has move on by at least one microsecond. Usually we expect this
3284 already to be the case, but machines keep getting faster... */
3285
3286 if (wait_for_tick) exim_wait_tick(&msg_tv, 1);
3287
3288 /* A return of FALSE means that if there was an error, a common error was
3289 put in the first address of a batch. */
3290
3291 return FALSE;
3292
3293 tainted_ret_panic:
3294   addr->message = string_sprintf("Tainted '%s' (file or directory "
3295       "name for %s transport) not permitted", path, tblock->name);
3296 ret_panic:
3297   addr->transport_return = PANIC;
3298   return FALSE;
3299 }
3300
3301 #endif  /*!MACRO_PREDEF*/
3302 /* End of transport/appendfile.c */