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