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