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