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