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