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