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