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