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