lib/clean-temp.c

   1 /* Temporary directories and temporary files with automatic cleanup.
   2    Copyright (C) 2001, 2003, 2006-2007 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2006.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19
  20 #include <config.h>
  21
  22 /* Specification.  */
  23 #include "clean-temp.h"
  24
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <limits.h>
  28 #include <stdbool.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
  34 # define WIN32_LEAN_AND_MEAN  /* avoid including junk */
  35 # include <windows.h>
  36 #endif
  37
  38 #include "error.h"
  39 #include "fatal-signal.h"
  40 #include "pathmax.h"
  41 #include "tmpdir.h"
  42 #include "mkdtemp.h"
  43 #include "xalloc.h"
  44 #include "xallocsa.h"
  45 #include "gl_linkedhash_list.h"
  46 #include "gettext.h"
  47 #if GNULIB_FWRITEERROR
  48 # include "fwriteerror.h"
  49 #endif
  50 #if GNULIB_CLOSE_STREAM
  51 # include "close-stream.h"
  52 #endif
  53 #if GNULIB_FCNTL_SAFER
  54 # include "fcntl--.h"
  55 #endif
  56 #if GNULIB_FOPEN_SAFER
  57 # include "stdio--.h"
  58 #endif
  59
  60 #define _(str) gettext (str)
  61
  62 /* GNU Hurd doesn't have PATH_MAX.  */
  63 #ifndef PATH_MAX
  64 # ifdef MAXPATHLEN
  65 #  define PATH_MAX MAXPATHLEN
  66 # else
  67 #  define PATH_MAX 1024
  68 # endif
  69 #endif
  70
  71 #ifndef uintptr_t
  72 # define uintptr_t unsigned long
  73 #endif
  74
  75 #if !GNULIB_FCNTL_SAFER
  76 /* The results of open() in this file are not used with fchdir,
  77    therefore save some unnecessary work in fchdir.c.  */
  78 # undef open
  79 # undef close
  80 #endif
  81
  82
  83 /* The use of 'volatile' in the types below (and ISO C 99 section 5.1.2.3.(5))
  84    ensure that while constructing or modifying the data structures, the field
  85    values are written to memory in the order of the C statements.  So the
  86    signal handler can rely on these field values to be up to date.  */
  87
  88
  89 /* Registry for a single temporary directory.
  90    'struct temp_dir' from the public header file overlaps with this.  */
  91 struct tempdir
  92 {
  93   /* The absolute pathname of the directory.  */
  94   char * volatile dirname;
  95   /* Whether errors during explicit cleanup are reported to standard error.  */
  96   bool cleanup_verbose;
  97   /* Absolute pathnames of subdirectories.  */
  98   gl_list_t /* <char *> */ volatile subdirs;
  99   /* Absolute pathnames of files.  */
 100   gl_list_t /* <char *> */ volatile files;
 101 };
 102
 103 /* List of all temporary directories.  */
 104 static struct
 105 {
 106   struct tempdir * volatile * volatile tempdir_list;
 107   size_t volatile tempdir_count;
 108   size_t tempdir_allocated;
 109 } cleanup_list /* = { NULL, 0, 0 } */;
 110
 111 /* List of all open file descriptors to temporary files.  */
 112 static gl_list_t /* <int> */ volatile descriptors;
 113
 114
 115 /* For the subdirs and for the files, we use a gl_list_t of type LINKEDHASH.
 116    Why?  We need a data structure that
 117
 118      1) Can contain an arbitrary number of 'char *' values.  The strings
 119         are compared via strcmp, not pointer comparison.
 120      2) Has insertion and deletion operations that are fast: ideally O(1),
 121         or possibly O(log n).  This is important for GNU sort, which may
 122         create a large number of temporary files.
 123      3) Allows iteration through all elements from within a signal handler.
 124      4) May or may not allow duplicates.  It doesn't matter here, since
 125         any file or subdir can only be removed once.
 126
 127    Criterion 1) would allow any gl_list_t or gl_oset_t implementation.
 128
 129    Criterion 2) leaves only GL_LINKEDHASH_LIST, GL_TREEHASH_LIST, or
 130    GL_TREE_OSET.
 131
 132    Criterion 3) puts at disadvantage GL_TREEHASH_LIST and GL_TREE_OSET.
 133    Namely, iteration through the elements of a binary tree requires access
 134    to many ->left, ->right, ->parent pointers. However, the rebalancing
 135    code for insertion and deletion in an AVL or red-black tree is so
 136    complicated that we cannot assume that >left, ->right, ->parent pointers
 137    are in a consistent state throughout these operations.  Therefore, to
 138    avoid a crash in the signal handler, all destructive operations to the
 139    lists would have to be protected by a
 140        block_fatal_signals ();
 141        ...
 142        unblock_fatal_signals ();
 143    pair.  Which causes extra system calls.
 144
 145    Criterion 3) would also discourage GL_ARRAY_LIST and GL_CARRAY_LIST,
 146    if they were not already excluded.  Namely, these implementations use
 147    xrealloc(), leaving a time window in which in the list->elements pointer
 148    points to already deallocated memory.  To avoid a crash in the signal
 149    handler at such a moment, all destructive operations would have to
 150    protected by block/unblock_fatal_signals (), in this case too.
 151
 152    A list of type GL_LINKEDHASH_LIST without duplicates fulfills all
 153    requirements:
 154      2) Insertion and deletion are O(1) on average.
 155      3) The gl_list_iterator, gl_list_iterator_next implementations do
 156         not trigger memory allocations, nor other system calls, and are
 157         therefore safe to be called from a signal handler.
 158         Furthermore, since SIGNAL_SAFE_LIST is defined, the implementation
 159         of the destructive functions ensures that the list structure is
 160         safe to be traversed at any moment, even when interrupted by an
 161         asynchronous signal.
 162  */
 163
 164 /* String equality and hash code functions used by the lists.  */
 165
 166 static bool
 167 string_equals (const void *x1, const void *x2)
 168 {
 169   const char *s1 = (const char *) x1;
 170   const char *s2 = (const char *) x2;
 171   return strcmp (s1, s2) == 0;
 172 }
 173
 174 #define SIZE_BITS (sizeof (size_t) * CHAR_BIT)
 175
 176 /* A hash function for NUL-terminated char* strings using
 177    the method described by Bruno Haible.
 178    See http://www.haible.de/bruno/hashfunc.html.  */
 179 static size_t
 180 string_hash (const void *x)
 181 {
 182   const char *s = (const char *) x;
 183   size_t h = 0;
 184
 185   for (; *s; s++)
 186     h = *s + ((h << 9) | (h >> (SIZE_BITS - 9)));
 187
 188   return h;
 189 }
 190
 191
 192 /* The signal handler.  It gets called asynchronously.  */
 193 static void
 194 cleanup ()
 195 {
 196   size_t i;
 197
 198   /* First close all file descriptors to temporary files.  */
 199   {
 200     gl_list_t fds = descriptors;
 201
 202     if (fds != NULL)
 203       {
 204         gl_list_iterator_t iter;
 205         const void *element;
 206
 207         iter = gl_list_iterator (fds);
 208         while (gl_list_iterator_next (&iter, &element, NULL))
 209           {
 210             int fd = (int) (uintptr_t) element;
 211             close (fd);
 212           }
 213         gl_list_iterator_free (&iter);
 214       }
 215   }
 216
 217   for (i = 0; i < cleanup_list.tempdir_count; i++)
 218     {
 219       struct tempdir *dir = cleanup_list.tempdir_list[i];
 220
 221       if (dir != NULL)
 222         {
 223           gl_list_iterator_t iter;
 224           const void *element;
 225
 226           /* First cleanup the files in the subdirectories.  */
 227           iter = gl_list_iterator (dir->files);
 228           while (gl_list_iterator_next (&iter, &element, NULL))
 229             {
 230               const char *file = (const char *) element;
 231               unlink (file);
 232             }
 233           gl_list_iterator_free (&iter);
 234
 235           /* Then cleanup the subdirectories.  */
 236           iter = gl_list_iterator (dir->subdirs);
 237           while (gl_list_iterator_next (&iter, &element, NULL))
 238             {
 239               const char *subdir = (const char *) element;
 240               rmdir (subdir);
 241             }
 242           gl_list_iterator_free (&iter);
 243
 244           /* Then cleanup the temporary directory itself.  */
 245           rmdir (dir->dirname);
 246         }
 247     }
 248 }
 249
 250 /* Create a temporary directory.
 251    PREFIX is used as a prefix for the name of the temporary directory. It
 252    should be short and still give an indication about the program.
 253    PARENTDIR can be used to specify the parent directory; if NULL, a default
 254    parent directory is used (either $TMPDIR or /tmp or similar).
 255    CLEANUP_VERBOSE determines whether errors during explicit cleanup are
 256    reported to standard error.
 257    Return a fresh 'struct temp_dir' on success.  Upon error, an error message
 258    is shown and NULL is returned.  */
 259 struct temp_dir *
 260 create_temp_dir (const char *prefix, const char *parentdir,
 261                  bool cleanup_verbose)
 262 {
 263   struct tempdir * volatile *tmpdirp = NULL;
 264   struct tempdir *tmpdir;
 265   size_t i;
 266   char *xtemplate;
 267   char *tmpdirname;
 268
 269   /* See whether it can take the slot of an earlier temporary directory
 270      already cleaned up.  */
 271   for (i = 0; i < cleanup_list.tempdir_count; i++)
 272     if (cleanup_list.tempdir_list[i] == NULL)
 273       {
 274         tmpdirp = &cleanup_list.tempdir_list[i];
 275         break;
 276       }
 277   if (tmpdirp == NULL)
 278     {
 279       /* See whether the array needs to be extended.  */
 280       if (cleanup_list.tempdir_count == cleanup_list.tempdir_allocated)
 281         {
 282           /* Note that we cannot use xrealloc(), because then the cleanup()
 283              function could access an already deallocated array.  */
 284           struct tempdir * volatile *old_array = cleanup_list.tempdir_list;
 285           size_t old_allocated = cleanup_list.tempdir_allocated;
 286           size_t new_allocated = 2 * cleanup_list.tempdir_allocated + 1;
 287           struct tempdir * volatile *new_array =
 288             XNMALLOC (new_allocated, struct tempdir * volatile);
 289
 290           if (old_allocated == 0)
 291             /* First use of this facility.  Register the cleanup handler.  */
 292             at_fatal_signal (&cleanup);
 293           else
 294             {
 295               /* Don't use memcpy() here, because memcpy takes non-volatile
 296                  arguments and is therefore not guaranteed to complete all
 297                  memory stores before the next statement.  */
 298               size_t k;
 299
 300               for (k = 0; k < old_allocated; k++)
 301                 new_array[k] = old_array[k];
 302             }
 303
 304           cleanup_list.tempdir_list = new_array;
 305           cleanup_list.tempdir_allocated = new_allocated;
 306
 307           /* Now we can free the old array.  */
 308           if (old_array != NULL)
 309             free ((struct tempdir **) old_array);
 310         }
 311
 312       tmpdirp = &cleanup_list.tempdir_list[cleanup_list.tempdir_count];
 313       /* Initialize *tmpdirp before incrementing tempdir_count, so that
 314          cleanup() will skip this entry before it is fully initialized.  */
 315       *tmpdirp = NULL;
 316       cleanup_list.tempdir_count++;
 317     }
 318
 319   /* Initialize a 'struct tempdir'.  */
 320   tmpdir = XMALLOC (struct tempdir);
 321   tmpdir->dirname = NULL;
 322   tmpdir->cleanup_verbose = cleanup_verbose;
 323   tmpdir->subdirs = gl_list_create_empty (GL_LINKEDHASH_LIST,
 324                                           string_equals, string_hash, false);
 325   tmpdir->files = gl_list_create_empty (GL_LINKEDHASH_LIST,
 326                                         string_equals, string_hash, false);
 327
 328   /* Create the temporary directory.  */
 329   xtemplate = (char *) xallocsa (PATH_MAX);
 330   if (path_search (xtemplate, PATH_MAX, parentdir, prefix, parentdir == NULL))
 331     {
 332       error (0, errno,
 333              _("cannot find a temporary directory, try setting $TMPDIR"));
 334       goto quit;
 335     }
 336   block_fatal_signals ();
 337   tmpdirname = mkdtemp (xtemplate);
 338   if (tmpdirname != NULL)
 339     {
 340       tmpdir->dirname = tmpdirname;
 341       *tmpdirp = tmpdir;
 342     }
 343   unblock_fatal_signals ();
 344   if (tmpdirname == NULL)
 345     {
 346       error (0, errno,
 347              _("cannot create a temporary directory using template \"%s\""),
 348              xtemplate);
 349       goto quit;
 350     }
 351   /* Replace tmpdir->dirname with a copy that has indefinite extent.
 352      We cannot do this inside the block_fatal_signals/unblock_fatal_signals
 353      block because then the cleanup handler would not remove the directory
 354      if xstrdup fails.  */
 355   tmpdir->dirname = xstrdup (tmpdirname);
 356   freesa (xtemplate);
 357   return (struct temp_dir *) tmpdir;
 358
 359  quit:
 360   freesa (xtemplate);
 361   return NULL;
 362 }
 363
 364 /* Register the given ABSOLUTE_FILE_NAME as being a file inside DIR, that
 365    needs to be removed before DIR can be removed.
 366    Should be called before the file ABSOLUTE_FILE_NAME is created.  */
 367 void
 368 register_temp_file (struct temp_dir *dir,
 369                     const char *absolute_file_name)
 370 {
 371   struct tempdir *tmpdir = (struct tempdir *)dir;
 372
 373   /* Add absolute_file_name to tmpdir->files, without duplicates.  */
 374   if (gl_list_search (tmpdir->files, absolute_file_name) == NULL)
 375     gl_list_add_first (tmpdir->files, xstrdup (absolute_file_name));
 376 }
 377
 378 /* Unregister the given ABSOLUTE_FILE_NAME as being a file inside DIR, that
 379    needs to be removed before DIR can be removed.
 380    Should be called when the file ABSOLUTE_FILE_NAME could not be created.  */
 381 void
 382 unregister_temp_file (struct temp_dir *dir,
 383                       const char *absolute_file_name)
 384 {
 385   struct tempdir *tmpdir = (struct tempdir *)dir;
 386   gl_list_t list = tmpdir->files;
 387   gl_list_node_t node;
 388
 389   node = gl_list_search (list, absolute_file_name);
 390   if (node != NULL)
 391     {
 392       char *old_string = (char *) gl_list_node_value (list, node);
 393
 394       gl_list_remove_node (list, node);
 395       free (old_string);
 396     }
 397 }
 398
 399 /* Register the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR,
 400    that needs to be removed before DIR can be removed.
 401    Should be called before the subdirectory ABSOLUTE_DIR_NAME is created.  */
 402 void
 403 register_temp_subdir (struct temp_dir *dir,
 404                       const char *absolute_dir_name)
 405 {
 406   struct tempdir *tmpdir = (struct tempdir *)dir;
 407
 408   /* Add absolute_dir_name to tmpdir->subdirs, without duplicates.  */
 409   if (gl_list_search (tmpdir->subdirs, absolute_dir_name) == NULL)
 410     gl_list_add_first (tmpdir->subdirs, xstrdup (absolute_dir_name));
 411 }
 412
 413 /* Unregister the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR,
 414    that needs to be removed before DIR can be removed.
 415    Should be called when the subdirectory ABSOLUTE_DIR_NAME could not be
 416    created.  */
 417 void
 418 unregister_temp_subdir (struct temp_dir *dir,
 419                         const char *absolute_dir_name)
 420 {
 421   struct tempdir *tmpdir = (struct tempdir *)dir;
 422   gl_list_t list = tmpdir->subdirs;
 423   gl_list_node_t node;
 424
 425   node = gl_list_search (list, absolute_dir_name);
 426   if (node != NULL)
 427     {
 428       char *old_string = (char *) gl_list_node_value (list, node);
 429
 430       gl_list_remove_node (list, node);
 431       free (old_string);
 432     }
 433 }
 434
 435 /* Remove a file, with optional error message.
 436    Return 0 upon success, or -1 if there was some problem.  */
 437 static int
 438 do_unlink (struct temp_dir *dir, const char *absolute_file_name)
 439 {
 440   if (unlink (absolute_file_name) < 0 && dir->cleanup_verbose
 441       && errno != ENOENT)
 442     {
 443       error (0, errno, _("cannot remove temporary file %s"), absolute_file_name);
 444       return -1;
 445     }
 446   return 0;
 447 }
 448
 449 /* Remove a directory, with optional error message.
 450    Return 0 upon success, or -1 if there was some problem.  */
 451 static int
 452 do_rmdir (struct temp_dir *dir, const char *absolute_dir_name)
 453 {
 454   if (rmdir (absolute_dir_name) < 0 && dir->cleanup_verbose
 455       && errno != ENOENT)
 456     {
 457       error (0, errno,
 458              _("cannot remove temporary directory %s"), absolute_dir_name);
 459       return -1;
 460     }
 461   return 0;
 462 }
 463
 464 /* Remove the given ABSOLUTE_FILE_NAME and unregister it.
 465    Return 0 upon success, or -1 if there was some problem.  */
 466 int
 467 cleanup_temp_file (struct temp_dir *dir,
 468                    const char *absolute_file_name)
 469 {
 470   int err;
 471
 472   err = do_unlink (dir, absolute_file_name);
 473   unregister_temp_file (dir, absolute_file_name);
 474
 475   return err;
 476 }
 477
 478 /* Remove the given ABSOLUTE_DIR_NAME and unregister it.
 479    Return 0 upon success, or -1 if there was some problem.  */
 480 int
 481 cleanup_temp_subdir (struct temp_dir *dir,
 482                      const char *absolute_dir_name)
 483 {
 484   int err;
 485
 486   err = do_rmdir (dir, absolute_dir_name);
 487   unregister_temp_subdir (dir, absolute_dir_name);
 488
 489   return err;
 490 }
 491
 492 /* Remove all registered files and subdirectories inside DIR.
 493    Return 0 upon success, or -1 if there was some problem.  */
 494 int
 495 cleanup_temp_dir_contents (struct temp_dir *dir)
 496 {
 497   struct tempdir *tmpdir = (struct tempdir *)dir;
 498   int err = 0;
 499   gl_list_t list;
 500   gl_list_iterator_t iter;
 501   const void *element;
 502   gl_list_node_t node;
 503
 504   /* First cleanup the files in the subdirectories.  */
 505   list = tmpdir->files;
 506   iter = gl_list_iterator (list);
 507   while (gl_list_iterator_next (&iter, &element, &node))
 508     {
 509       char *file = (char *) element;
 510
 511       err |= do_unlink (dir, file);
 512       gl_list_remove_node (list, node);
 513       /* Now only we can free file.  */
 514       free (file);
 515     }
 516   gl_list_iterator_free (&iter);
 517
 518   /* Then cleanup the subdirectories.  */
 519   list = tmpdir->subdirs;
 520   iter = gl_list_iterator (list);
 521   while (gl_list_iterator_next (&iter, &element, &node))
 522     {
 523       char *subdir = (char *) element;
 524
 525       err |= do_rmdir (dir, subdir);
 526       gl_list_remove_node (list, node);
 527       /* Now only we can free subdir.  */
 528       free (subdir);
 529     }
 530   gl_list_iterator_free (&iter);
 531
 532   return err;
 533 }
 534
 535 /* Remove all registered files and subdirectories inside DIR and DIR itself.
 536    DIR cannot be used any more after this call.
 537    Return 0 upon success, or -1 if there was some problem.  */
 538 int
 539 cleanup_temp_dir (struct temp_dir *dir)
 540 {
 541   struct tempdir *tmpdir = (struct tempdir *)dir;
 542   int err = 0;
 543   size_t i;
 544
 545   err |= cleanup_temp_dir_contents (dir);
 546   err |= do_rmdir (dir, tmpdir->dirname);
 547
 548   for (i = 0; i < cleanup_list.tempdir_count; i++)
 549     if (cleanup_list.tempdir_list[i] == tmpdir)
 550       {
 551         /* Remove cleanup_list.tempdir_list[i].  */
 552         if (i + 1 == cleanup_list.tempdir_count)
 553           {
 554             while (i > 0 && cleanup_list.tempdir_list[i - 1] == NULL)
 555               i--;
 556             cleanup_list.tempdir_count = i;
 557           }
 558         else
 559           cleanup_list.tempdir_list[i] = NULL;
 560         /* Now only we can free the tmpdir->dirname and tmpdir itself.  */
 561         free (tmpdir->dirname);
 562         free (tmpdir);
 563         return err;
 564       }
 565
 566   /* The user passed an invalid DIR argument.  */
 567   abort ();
 568 }
 569
 570
 571 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 572
 573 /* On Windows, opening a file with _O_TEMPORARY has the effect of passing
 574    the FILE_FLAG_DELETE_ON_CLOSE flag to CreateFile(), which has the effect
 575    of deleting the file when it is closed - even when the program crashes.
 576    But (according to the Cygwin sources) it works only on Windows NT or newer.
 577    So we cache the info whether we are running on Windows NT or newer.  */
 578
 579 static bool
 580 supports_delete_on_close ()
 581 {
 582   static int known; /* 1 = yes, -1 = no, 0 = unknown */
 583   if (!known)
 584     {
 585       OSVERSIONINFO v;
 586
 587       if (GetVersionEx (&v))
 588         known = (v.dwPlatformId == VER_PLATFORM_WIN32_NT ? 1 : -1);
 589       else
 590         known = -1;
 591     }
 592   return (known > 0);
 593 }
 594
 595 #endif
 596
 597
 598 /* Register a file descriptor to be closed.  */
 599 static void
 600 register_fd (int fd)
 601 {
 602   if (descriptors == NULL)
 603     descriptors = gl_list_create_empty (GL_LINKEDHASH_LIST, NULL, NULL, false);
 604   gl_list_add_first (descriptors, (void *) (uintptr_t) fd);
 605 }
 606
 607 /* Unregister a file descriptor to be closed.  */
 608 static void
 609 unregister_fd (int fd)
 610 {
 611   gl_list_t fds = descriptors;
 612   gl_list_node_t node;
 613
 614   if (fds == NULL)
 615     /* descriptors should already contain fd.  */
 616     abort ();
 617   node = gl_list_search (fds, (void *) (uintptr_t) fd);
 618   if (node == NULL)
 619     /* descriptors should already contain fd.  */
 620     abort ();
 621   gl_list_remove_node (fds, node);
 622 }
 623
 624 /* Open a temporary file in a temporary directory.
 625    Registers the resulting file descriptor to be closed.  */
 626 int
 627 open_temp (const char *file_name, int flags, mode_t mode)
 628 {
 629   int fd;
 630   int saved_errno;
 631
 632   block_fatal_signals ();
 633   /* Note: 'open' here is actually open() or open_safer().  */
 634 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 635   /* Use _O_TEMPORARY when possible, to increase the chances that the
 636      temporary file is removed when the process crashes.  */
 637   if (supports_delete_on_close ())
 638     fd = open (file_name, flags | _O_TEMPORARY, mode);
 639   else
 640 #endif
 641     fd = open (file_name, flags, mode);
 642   saved_errno = errno;
 643   if (fd >= 0)
 644     register_fd (fd);
 645   unblock_fatal_signals ();
 646   errno = saved_errno;
 647   return fd;
 648 }
 649
 650 /* Open a temporary file in a temporary directory.
 651    Registers the resulting file descriptor to be closed.  */
 652 FILE *
 653 fopen_temp (const char *file_name, const char *mode)
 654 {
 655   FILE *fp;
 656   int saved_errno;
 657
 658   block_fatal_signals ();
 659   /* Note: 'fopen' here is actually fopen() or fopen_safer().  */
 660 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 661   /* Use _O_TEMPORARY when possible, to increase the chances that the
 662      temporary file is removed when the process crashes.  */
 663   if (supports_delete_on_close ())
 664     {
 665       size_t mode_len = strlen (mode);
 666       char *augmented_mode = (char *) xallocsa (mode_len + 2);
 667       memcpy (augmented_mode, mode, mode_len);
 668       memcpy (augmented_mode + mode_len, "D", 2);
 669
 670       fp = fopen (file_name, augmented_mode);
 671       saved_errno = errno;
 672
 673       freesa (augmented_mode);
 674     }
 675   else
 676 #endif
 677     {
 678       fp = fopen (file_name, mode);
 679       saved_errno = errno;
 680     }
 681   if (fp != NULL)
 682     {
 683       /* It is sufficient to register fileno (fp) instead of the entire fp,
 684          because at cleanup time there is no need to do an fflush (fp); a
 685          close (fileno (fp)) will be enough.  */
 686       int fd = fileno (fp);
 687       if (!(fd >= 0))
 688         abort ();
 689       register_fd (fd);
 690     }
 691   unblock_fatal_signals ();
 692   errno = saved_errno;
 693   return fp;
 694 }
 695
 696 /* Close a temporary file in a temporary directory.
 697    Unregisters the previously registered file descriptor.  */
 698 int
 699 close_temp (int fd)
 700 {
 701   if (fd >= 0)
 702     {
 703       /* No blocking of signals is needed here, since a double close of a
 704          file descriptor is harmless.  */
 705       int result = close (fd);
 706       int saved_errno = errno;
 707
 708       /* No race condition here: we assume a single-threaded program, hence
 709          fd cannot be re-opened here.  */
 710
 711       unregister_fd (fd);
 712
 713       errno = saved_errno;
 714       return result;
 715     }
 716   else
 717     return close (fd);
 718 }
 719
 720 /* Close a temporary file in a temporary directory.
 721    Unregisters the previously registered file descriptor.  */
 722 int
 723 fclose_temp (FILE *fp)
 724 {
 725   int fd = fileno (fp);
 726   /* No blocking of signals is needed here, since a double close of a
 727      file descriptor is harmless.  */
 728   int result = fclose (fp);
 729   int saved_errno = errno;
 730
 731   /* No race condition here: we assume a single-threaded program, hence
 732      fd cannot be re-opened here.  */
 733
 734   unregister_fd (fd);
 735
 736   errno = saved_errno;
 737   return result;
 738 }
 739
 740 #if GNULIB_FWRITEERROR
 741 /* Like fwriteerror.
 742    Unregisters the previously registered file descriptor.  */
 743 int
 744 fwriteerror_temp (FILE *fp)
 745 {
 746   int fd = fileno (fp);
 747   /* No blocking of signals is needed here, since a double close of a
 748      file descriptor is harmless.  */
 749   int result = fwriteerror (fp);
 750   int saved_errno = errno;
 751
 752   /* No race condition here: we assume a single-threaded program, hence
 753      fd cannot be re-opened here.  */
 754
 755   unregister_fd (fd);
 756
 757   errno = saved_errno;
 758   return result;
 759 }
 760 #endif
 761
 762 #if GNULIB_CLOSE_STREAM
 763 /* Like close_stream.
 764    Unregisters the previously registered file descriptor.  */
 765 int
 766 close_stream_temp (FILE *fp)
 767 {
 768   int fd = fileno (fp);
 769   /* No blocking of signals is needed here, since a double close of a
 770      file descriptor is harmless.  */
 771   int result = close_stream (fp);
 772   int saved_errno = errno;
 773
 774   /* No race condition here: we assume a single-threaded program, hence
 775      fd cannot be re-opened here.  */
 776
 777   unregister_fd (fd);
 778
 779   errno = saved_errno;
 780   return result;
 781 }
 782 #endif