1 /* Temporary directories and temporary files with automatic cleanup.
2 Copyright (C) 2001, 2003, 2006-2007, 2009-2021 Free Software Foundation,
3 Inc.
4 Written by Bruno Haible <bruno@clisp.org>, 2006.
5
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <https://www.gnu.org/licenses/>. */
18
19 #include <config.h>
20
21 /* Specification. */
22 #include "clean-temp.h"
23
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <signal.h>
27 #include <stdbool.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32
33 #if defined _WIN32 && ! defined __CYGWIN__
34 # define WIN32_LEAN_AND_MEAN /* avoid including junk */
35 # include <windows.h>
36 #endif
37
38 #include "clean-temp-simple.h"
39 #include "clean-temp-private.h"
40 #include "error.h"
41 #include "fatal-signal.h"
42 #include "asyncsafe-spin.h"
43 #include "pathmax.h"
44 #include "tmpdir.h"
45 #include "xalloc.h"
46 #include "xmalloca.h"
47 #include "glthread/lock.h"
48 #include "thread-optim.h"
49 #include "gl_xlist.h"
50 #include "gl_linkedhash_list.h"
51 #include "gl_linked_list.h"
52 #include "gettext.h"
53 #if GNULIB_TEMPNAME
54 # include "tempname.h"
55 #endif
56 #if GNULIB_FWRITEERROR
57 # include "fwriteerror.h"
58 #endif
59 #if GNULIB_CLOSE_STREAM
60 # include "close-stream.h"
61 #endif
62 #if GNULIB_FCNTL_SAFER
63 # include "fcntl--.h"
64 #endif
65 #if GNULIB_FOPEN_SAFER
66 # include "stdio--.h"
67 #endif
68
69 #define _(str) gettext (str)
70
71 /* GNU Hurd doesn't have PATH_MAX. Use a fallback.
72 Temporary directory names are usually not that long. */
73 #ifndef PATH_MAX
74 # define PATH_MAX 1024
75 #endif
76
77 #if defined _WIN32 && ! defined __CYGWIN__
78 /* Don't assume that UNICODE is not defined. */
79 # undef OSVERSIONINFO
80 # define OSVERSIONINFO OSVERSIONINFOA
81 # undef GetVersionEx
82 # define GetVersionEx GetVersionExA
83 #endif
84
85
86 /* Lock that protects the dir_cleanup_list from concurrent modification in
87 different threads. */
88 gl_lock_define_initialized (static, dir_cleanup_list_lock)
89
90 /* Lock that protects the descriptors list from concurrent modification in
91 different threads. */
92 gl_lock_define_initialized (static, descriptors_lock)
93
94
95 /* Close a file descriptor and the stream that contains it.
96 Avoids race conditions with signal-handler code that might want to close the
97 same file descriptor. */
98 static int
99 asyncsafe_fclose_variant (struct closeable_fd *element, FILE *fp,
100 int (*fclose_variant) (FILE *))
101 {
102 if (fileno (fp) != element->fd)
103 abort ();
104
105 /* Flush buffered data first, to minimize the duration of the spin lock. */
106 fflush (fp);
107
108 sigset_t saved_mask;
109 int ret;
110 int saved_errno;
111
112 asyncsafe_spin_lock (&element->lock, get_fatal_signal_set (), &saved_mask);
113 if (!element->closed)
114 {
115 ret = fclose_variant (fp); /* invokes close (element->fd) */
116 saved_errno = errno;
117 element->closed = true;
118 }
119 else
120 {
121 ret = 0;
122 saved_errno = 0;
123 }
124 asyncsafe_spin_unlock (&element->lock, &saved_mask);
125 element->done = true;
126
127 errno = saved_errno;
128 return ret;
129 }
130
131
132 /* ========= Temporary directories and temporary files inside them ========= */
133
134 /* Create a temporary directory.
135 PREFIX is used as a prefix for the name of the temporary directory. It
136 should be short and still give an indication about the program.
137 PARENTDIR can be used to specify the parent directory; if NULL, a default
138 parent directory is used (either $TMPDIR or /tmp or similar).
139 CLEANUP_VERBOSE determines whether errors during explicit cleanup are
140 reported to standard error.
141 Return a fresh 'struct temp_dir' on success. Upon error, an error message
142 is shown and NULL is returned. */
143 struct temp_dir *
144 create_temp_dir (const char *prefix, const char *parentdir,
145 bool cleanup_verbose)
146 {
147 bool mt = gl_multithreaded ();
148
149 if (mt) gl_lock_lock (dir_cleanup_list_lock);
150
151 struct tempdir * volatile *tmpdirp = NULL;
152 struct tempdir *tmpdir;
153 size_t i;
154 char *xtemplate;
155 char *tmpdirname;
156
157 /* See whether it can take the slot of an earlier temporary directory
158 already cleaned up. */
159 for (i = 0; i < dir_cleanup_list.tempdir_count; i++)
160 if (dir_cleanup_list.tempdir_list[i] == NULL)
161 {
162 tmpdirp = &dir_cleanup_list.tempdir_list[i];
163 break;
164 }
165 if (tmpdirp == NULL)
166 {
167 /* See whether the array needs to be extended. */
168 if (dir_cleanup_list.tempdir_count == dir_cleanup_list.tempdir_allocated)
169 {
170 /* Note that we cannot use xrealloc(), because then the cleanup()
171 function could access an already deallocated array. */
172 struct tempdir * volatile *old_array = dir_cleanup_list.tempdir_list;
173 size_t old_allocated = dir_cleanup_list.tempdir_allocated;
174 size_t new_allocated = 2 * dir_cleanup_list.tempdir_allocated + 1;
175 struct tempdir * volatile *new_array =
176 XNMALLOC (new_allocated, struct tempdir * volatile);
177
178 if (old_allocated == 0)
179 {
180 /* First use of this facility. */
181 if (clean_temp_init () < 0)
182 xalloc_die ();
183 }
184 else
185 {
186 /* Don't use memcpy() here, because memcpy takes non-volatile
187 arguments and is therefore not guaranteed to complete all
188 memory stores before the next statement. */
189 size_t k;
190
191 for (k = 0; k < old_allocated; k++)
192 new_array[k] = old_array[k];
193 }
194
195 dir_cleanup_list.tempdir_list = new_array;
196 dir_cleanup_list.tempdir_allocated = new_allocated;
197
198 /* Now we can free the old array. */
199 /* No, we can't do that. If cleanup_action is running in a different
200 thread and has already fetched the tempdir_list pointer (getting
201 old_array) but not yet accessed its i-th element, that thread may
202 crash when accessing an element of the already freed old_array
203 array. */
204 #if 0
205 if (old_array != NULL)
206 free ((struct tempdir **) old_array);
207 #endif
208 }
209
210 tmpdirp = &dir_cleanup_list.tempdir_list[dir_cleanup_list.tempdir_count];
211 /* Initialize *tmpdirp before incrementing tempdir_count, so that
212 cleanup() will skip this entry before it is fully initialized. */
213 *tmpdirp = NULL;
214 dir_cleanup_list.tempdir_count++;
215 }
216
217 /* Initialize a 'struct tempdir'. */
218 tmpdir = XMALLOC (struct tempdir);
219 tmpdir->dirname = NULL;
220 tmpdir->cleanup_verbose = cleanup_verbose;
221 tmpdir->subdirs =
222 gl_list_create_empty (GL_LINKEDHASH_LIST,
223 clean_temp_string_equals, clean_temp_string_hash,
224 NULL, false);
225 tmpdir->files =
226 gl_list_create_empty (GL_LINKEDHASH_LIST,
227 clean_temp_string_equals, clean_temp_string_hash,
228 NULL, false);
229
230 /* Create the temporary directory. */
231 xtemplate = (char *) xmalloca (PATH_MAX);
232 if (path_search (xtemplate, PATH_MAX, parentdir, prefix, parentdir == NULL))
233 {
234 error (0, errno,
235 _("cannot find a temporary directory, try setting $TMPDIR"));
236 goto quit;
237 }
238 block_fatal_signals ();
239 tmpdirname = mkdtemp (xtemplate);
240 int saved_errno = errno;
241 if (tmpdirname != NULL)
242 {
243 tmpdir->dirname = tmpdirname;
244 *tmpdirp = tmpdir;
245 }
246 unblock_fatal_signals ();
247 if (tmpdirname == NULL)
248 {
249 error (0, saved_errno,
250 _("cannot create a temporary directory using template \"%s\""),
251 xtemplate);
252 goto quit;
253 }
254 /* Replace tmpdir->dirname with a copy that has indefinite extent.
255 We cannot do this inside the block_fatal_signals/unblock_fatal_signals
256 block because then the cleanup handler would not remove the directory
257 if xstrdup fails. */
258 tmpdir->dirname = xstrdup (tmpdirname);
259 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
260 freea (xtemplate);
261 return (struct temp_dir *) tmpdir;
262
263 quit:
264 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
265 freea (xtemplate);
266 return NULL;
267 }
268
269 /* Register the given ABSOLUTE_FILE_NAME as being a file inside DIR, that
270 needs to be removed before DIR can be removed.
271 Should be called before the file ABSOLUTE_FILE_NAME is created. */
272 void
273 register_temp_file (struct temp_dir *dir,
274 const char *absolute_file_name)
275 {
276 struct tempdir *tmpdir = (struct tempdir *)dir;
277 bool mt = gl_multithreaded ();
278
279 if (mt) gl_lock_lock (dir_cleanup_list_lock);
280
281 /* Add absolute_file_name to tmpdir->files, without duplicates. */
282 if (gl_list_search (tmpdir->files, absolute_file_name) == NULL)
283 gl_list_add_first (tmpdir->files, xstrdup (absolute_file_name));
284
285 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
286 }
287
288 /* Unregister the given ABSOLUTE_FILE_NAME as being a file inside DIR, that
289 needs to be removed before DIR can be removed.
290 Should be called when the file ABSOLUTE_FILE_NAME could not be created. */
291 void
292 unregister_temp_file (struct temp_dir *dir,
293 const char *absolute_file_name)
294 {
295 struct tempdir *tmpdir = (struct tempdir *)dir;
296 bool mt = gl_multithreaded ();
297
298 if (mt) gl_lock_lock (dir_cleanup_list_lock);
299
300 gl_list_t list = tmpdir->files;
301 gl_list_node_t node;
302
303 node = gl_list_search (list, absolute_file_name);
304 if (node != NULL)
305 {
306 char *old_string = (char *) gl_list_node_value (list, node);
307
308 gl_list_remove_node (list, node);
309 free (old_string);
310 }
311
312 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
313 }
314
315 /* Register the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR,
316 that needs to be removed before DIR can be removed.
317 Should be called before the subdirectory ABSOLUTE_DIR_NAME is created. */
318 void
319 register_temp_subdir (struct temp_dir *dir,
320 const char *absolute_dir_name)
321 {
322 struct tempdir *tmpdir = (struct tempdir *)dir;
323 bool mt = gl_multithreaded ();
324
325 if (mt) gl_lock_lock (dir_cleanup_list_lock);
326
327 /* Add absolute_dir_name to tmpdir->subdirs, without duplicates. */
328 if (gl_list_search (tmpdir->subdirs, absolute_dir_name) == NULL)
329 gl_list_add_first (tmpdir->subdirs, xstrdup (absolute_dir_name));
330
331 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
332 }
333
334 /* Unregister the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR,
335 that needs to be removed before DIR can be removed.
336 Should be called when the subdirectory ABSOLUTE_DIR_NAME could not be
337 created. */
338 void
339 unregister_temp_subdir (struct temp_dir *dir,
340 const char *absolute_dir_name)
341 {
342 struct tempdir *tmpdir = (struct tempdir *)dir;
343 bool mt = gl_multithreaded ();
344
345 if (mt) gl_lock_lock (dir_cleanup_list_lock);
346
347 gl_list_t list = tmpdir->subdirs;
348 gl_list_node_t node;
349
350 node = gl_list_search (list, absolute_dir_name);
351 if (node != NULL)
352 {
353 char *old_string = (char *) gl_list_node_value (list, node);
354
355 gl_list_remove_node (list, node);
356 free (old_string);
357 }
358
359 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
360 }
361
362 /* Remove a directory, with optional error message.
363 Return 0 upon success, or -1 if there was some problem. */
364 static int
365 do_rmdir (const char *absolute_dir_name, bool cleanup_verbose)
366 {
367 if (rmdir (absolute_dir_name) < 0 && cleanup_verbose
368 && errno != ENOENT)
369 {
370 error (0, errno,
371 _("cannot remove temporary directory %s"), absolute_dir_name);
372 return -1;
373 }
374 return 0;
375 }
376
377 /* Remove the given ABSOLUTE_FILE_NAME and unregister it.
378 Return 0 upon success, or -1 if there was some problem. */
379 int
380 cleanup_temp_file (struct temp_dir *dir,
381 const char *absolute_file_name)
382 {
383 int err;
384
385 err = clean_temp_unlink (absolute_file_name, dir->cleanup_verbose);
386 unregister_temp_file (dir, absolute_file_name);
387
388 return err;
389 }
390
391 /* Remove the given ABSOLUTE_DIR_NAME and unregister it.
392 Return 0 upon success, or -1 if there was some problem. */
393 int
394 cleanup_temp_subdir (struct temp_dir *dir,
395 const char *absolute_dir_name)
396 {
397 int err;
398
399 err = do_rmdir (absolute_dir_name, dir->cleanup_verbose);
400 unregister_temp_subdir (dir, absolute_dir_name);
401
402 return err;
403 }
404
405 /* Remove all registered files and subdirectories inside DIR.
406 Only to be called with dir_cleanup_list_lock locked.
407 Return 0 upon success, or -1 if there was some problem. */
408 int
409 cleanup_temp_dir_contents (struct temp_dir *dir)
410 {
411 struct tempdir *tmpdir = (struct tempdir *)dir;
412 int err = 0;
413 gl_list_t list;
414 gl_list_iterator_t iter;
415 const void *element;
416 gl_list_node_t node;
417
418 /* First cleanup the files in the subdirectories. */
419 list = tmpdir->files;
420 iter = gl_list_iterator (list);
421 while (gl_list_iterator_next (&iter, &element, &node))
422 {
423 char *file = (char *) element;
424
425 err |= clean_temp_unlink (file, dir->cleanup_verbose);
426 gl_list_remove_node (list, node);
427 /* Now only we can free file. */
428 free (file);
429 }
430 gl_list_iterator_free (&iter);
431
432 /* Then cleanup the subdirectories. */
433 list = tmpdir->subdirs;
434 iter = gl_list_iterator (list);
435 while (gl_list_iterator_next (&iter, &element, &node))
436 {
437 char *subdir = (char *) element;
438
439 err |= do_rmdir (subdir, dir->cleanup_verbose);
440 gl_list_remove_node (list, node);
441 /* Now only we can free subdir. */
442 free (subdir);
443 }
444 gl_list_iterator_free (&iter);
445
446 return err;
447 }
448
449 /* Remove all registered files and subdirectories inside DIR and DIR itself.
450 DIR cannot be used any more after this call.
451 Return 0 upon success, or -1 if there was some problem. */
452 int
453 cleanup_temp_dir (struct temp_dir *dir)
454 {
455 bool mt = gl_multithreaded ();
456
457 if (mt) gl_lock_lock (dir_cleanup_list_lock);
458
459 struct tempdir *tmpdir = (struct tempdir *)dir;
460 int err = 0;
461 size_t i;
462
463 err |= cleanup_temp_dir_contents (dir);
464 err |= do_rmdir (tmpdir->dirname, dir->cleanup_verbose);
465
466 for (i = 0; i < dir_cleanup_list.tempdir_count; i++)
467 if (dir_cleanup_list.tempdir_list[i] == tmpdir)
468 {
469 /* Remove dir_cleanup_list.tempdir_list[i]. */
470 if (i + 1 == dir_cleanup_list.tempdir_count)
471 {
472 while (i > 0 && dir_cleanup_list.tempdir_list[i - 1] == NULL)
473 i--;
474 dir_cleanup_list.tempdir_count = i;
475 }
476 else
477 dir_cleanup_list.tempdir_list[i] = NULL;
478 /* Now only we can free the tmpdir->dirname, tmpdir->subdirs,
479 tmpdir->files, and tmpdir itself. */
480 gl_list_free (tmpdir->files);
481 gl_list_free (tmpdir->subdirs);
482 free (tmpdir->dirname);
483 free (tmpdir);
484 if (mt) gl_lock_unlock (dir_cleanup_list_lock);
485 return err;
486 }
487
488 /* The user passed an invalid DIR argument. */
489 abort ();
490 }
491
492
493 /* ================== Opening and closing temporary files ================== */
494
495 #if defined _WIN32 && ! defined __CYGWIN__
496
497 /* On Windows, opening a file with _O_TEMPORARY has the effect of passing
498 the FILE_FLAG_DELETE_ON_CLOSE flag to CreateFile(), which has the effect
499 of deleting the file when it is closed - even when the program crashes.
500 But (according to the Cygwin sources) it works only on Windows NT or newer.
501 So we cache the info whether we are running on Windows NT or newer. */
502
503 static bool
504 supports_delete_on_close ()
505 {
506 static int known; /* 1 = yes, -1 = no, 0 = unknown */
507 if (!known)
508 {
509 OSVERSIONINFO v;
510
511 /* According to
512 <https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getversionexa>
513 this structure must be initialized as follows: */
514 v.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
515
516 if (GetVersionEx (&v))
517 known = (v.dwPlatformId == VER_PLATFORM_WIN32_NT ? 1 : -1);
518 else
519 known = -1;
520 }
521 return (known > 0);
522 }
523
524 #endif
525
526
527 /* Register a file descriptor to be closed. */
528 static void
529 register_fd (int fd)
530 {
531 bool mt = gl_multithreaded ();
532
533 if (mt) gl_lock_lock (descriptors_lock);
534
535 if (descriptors == NULL)
536 descriptors = gl_list_create_empty (GL_LINKED_LIST, NULL, NULL, NULL,
537 false);
538
539 struct closeable_fd *element = XMALLOC (struct closeable_fd);
540 element->fd = fd;
541 element->closed = false;
542 asyncsafe_spin_init (&element->lock);
543 element->done = false;
544
545 gl_list_add_first (descriptors, element);
546
547 if (mt) gl_lock_unlock (descriptors_lock);
548 }
549
550 /* Open a temporary file in a temporary directory.
551 FILE_NAME must already have been passed to register_temp_file.
552 Registers the resulting file descriptor to be closed.
553 DELETE_ON_CLOSE indicates whether the file can be deleted when the resulting
554 file descriptor or stream is closed. */
555 int
556 open_temp (const char *file_name, int flags, mode_t mode, bool delete_on_close)
557 {
558 int fd;
559 int saved_errno;
560
561 block_fatal_signals ();
562 /* Note: 'open' here is actually open() or open_safer(). */
563 #if defined _WIN32 && ! defined __CYGWIN__
564 /* Use _O_TEMPORARY when possible, to increase the chances that the
565 temporary file is removed when the process crashes. */
566 if (delete_on_close && supports_delete_on_close ())
567 fd = open (file_name, flags | _O_TEMPORARY, mode);
568 else
569 #endif
570 fd = open (file_name, flags, mode);
571 saved_errno = errno;
572 if (fd >= 0)
573 register_fd (fd);
574 unblock_fatal_signals ();
575 errno = saved_errno;
576 return fd;
577 }
578
579 /* Open a temporary file in a temporary directory.
580 FILE_NAME must already have been passed to register_temp_file.
581 Registers the resulting file descriptor to be closed.
582 DELETE_ON_CLOSE indicates whether the file can be deleted when the resulting
583 file descriptor or stream is closed. */
584 FILE *
585 fopen_temp (const char *file_name, const char *mode, bool delete_on_close)
586 {
587 FILE *fp;
588 int saved_errno;
589
590 block_fatal_signals ();
591 /* Note: 'fopen' here is actually fopen() or fopen_safer(). */
592 #if defined _WIN32 && ! defined __CYGWIN__
593 /* Use _O_TEMPORARY when possible, to increase the chances that the
594 temporary file is removed when the process crashes. */
595 if (delete_on_close && supports_delete_on_close ())
596 {
597 size_t mode_len = strlen (mode);
598 char *augmented_mode = (char *) xmalloca (mode_len + 2);
599 memcpy (augmented_mode, mode, mode_len);
600 memcpy (augmented_mode + mode_len, "D", 2);
601
602 fp = fopen (file_name, augmented_mode);
603 saved_errno = errno;
604
605 freea (augmented_mode);
606 }
607 else
608 #endif
609 {
610 fp = fopen (file_name, mode);
611 saved_errno = errno;
612 }
613 if (fp != NULL)
614 {
615 /* It is sufficient to register fileno (fp) instead of the entire fp,
616 because at cleanup time there is no need to do an fflush (fp); a
617 close (fileno (fp)) will be enough. */
618 int fd = fileno (fp);
619 if (!(fd >= 0))
620 abort ();
621 register_fd (fd);
622 }
623 unblock_fatal_signals ();
624 errno = saved_errno;
625 return fp;
626 }
627
628 #if GNULIB_TEMPNAME
629
630 struct try_create_file_params
631 {
632 int flags;
633 mode_t mode;
634 };
635
636 static int
637 try_create_file (char *file_name_tmpl, void *params_)
638 {
639 struct try_create_file_params *params = params_;
640 return open (file_name_tmpl,
641 (params->flags & ~O_ACCMODE) | O_RDWR | O_CREAT | O_EXCL,
642 params->mode);
643 }
644
645 /* Open a temporary file, generating its name based on FILE_NAME_TMPL.
646 FILE_NAME_TMPL must match the rules for mk[s]temp (i.e. end in "XXXXXX",
647 possibly with a suffix). The name constructed does not exist at the time
648 of the call. FILE_NAME_TMPL is overwritten with the result.
649 A safe choice for MODE is S_IRUSR | S_IWUSR, a.k.a. 0600.
650 Registers the file for deletion.
651 Opens the file, with the given FLAGS and mode MODE.
652 Registers the resulting file descriptor to be closed. */
653 int
654 gen_register_open_temp (char *file_name_tmpl, int suffixlen,
655 int flags, mode_t mode)
656 {
657 block_fatal_signals ();
658
659 struct try_create_file_params params;
660 params.flags = flags;
661 params.mode = mode;
662
663 int fd = try_tempname (file_name_tmpl, suffixlen, ¶ms, try_create_file);
664
665 int saved_errno = errno;
666 if (fd >= 0)
667 {
668 if (clean_temp_init () < 0)
669 xalloc_die ();
670 register_fd (fd);
671 if (register_temporary_file (file_name_tmpl) < 0)
672 xalloc_die ();
673 }
674 unblock_fatal_signals ();
675 errno = saved_errno;
676 return fd;
677 }
678
679 #endif
680
681 /* Close a temporary file.
682 FD must have been returned by open_temp or gen_register_open_temp.
683 Unregisters the previously registered file descriptor. */
684 int
685 close_temp (int fd)
686 {
687 if (fd < 0)
688 return close (fd);
689
690 clean_temp_init_asyncsafe_close ();
691
692 int result = 0;
693 int saved_errno = 0;
694
695 bool mt = gl_multithreaded ();
696
697 if (mt) gl_lock_lock (descriptors_lock);
698
699 gl_list_t list = descriptors;
700 if (list == NULL)
701 /* descriptors should already contain fd. */
702 abort ();
703
704 /* Search through the list, and clean it up on the fly. */
705 bool found = false;
706 gl_list_iterator_t iter = gl_list_iterator (list);
707 const void *elt;
708 gl_list_node_t node;
709 if (gl_list_iterator_next (&iter, &elt, &node))
710 for (;;)
711 {
712 struct closeable_fd *element = (struct closeable_fd *) elt;
713
714 /* Close the file descriptor, avoiding races with the signal
715 handler. */
716 if (element->fd == fd)
717 {
718 found = true;
719 result = clean_temp_asyncsafe_close (element);
720 saved_errno = errno;
721 }
722
723 bool free_this_node = element->done;
724 struct closeable_fd *element_to_free = element;
725 gl_list_node_t node_to_free = node;
726
727 bool have_next = gl_list_iterator_next (&iter, &elt, &node);
728
729 if (free_this_node)
730 {
731 free (element_to_free);
732 gl_list_remove_node (list, node_to_free);
733 }
734
735 if (!have_next)
736 break;
737 }
738 gl_list_iterator_free (&iter);
739 if (!found)
740 /* descriptors should already contain fd. */
741 abort ();
742
743 if (mt) gl_lock_unlock (descriptors_lock);
744
745 errno = saved_errno;
746 return result;
747 }
748
749 static int
750 fclose_variant_temp (FILE *fp, int (*fclose_variant) (FILE *))
751 {
752 int fd = fileno (fp);
753
754 int result = 0;
755 int saved_errno = 0;
756
757 bool mt = gl_multithreaded ();
758
759 if (mt) gl_lock_lock (descriptors_lock);
760
761 gl_list_t list = descriptors;
762 if (list == NULL)
763 /* descriptors should already contain fd. */
764 abort ();
765
766 /* Search through the list, and clean it up on the fly. */
767 bool found = false;
768 gl_list_iterator_t iter = gl_list_iterator (list);
769 const void *elt;
770 gl_list_node_t node;
771 if (gl_list_iterator_next (&iter, &elt, &node))
772 for (;;)
773 {
774 struct closeable_fd *element = (struct closeable_fd *) elt;
775
776 /* Close the file descriptor and the stream, avoiding races with the
777 signal handler. */
778 if (element->fd == fd)
779 {
780 found = true;
781 result = asyncsafe_fclose_variant (element, fp, fclose_variant);
782 saved_errno = errno;
783 }
784
785 bool free_this_node = element->done;
786 struct closeable_fd *element_to_free = element;
787 gl_list_node_t node_to_free = node;
788
789 bool have_next = gl_list_iterator_next (&iter, &elt, &node);
790
791 if (free_this_node)
792 {
793 free (element_to_free);
794 gl_list_remove_node (list, node_to_free);
795 }
796
797 if (!have_next)
798 break;
799 }
800 gl_list_iterator_free (&iter);
801 if (!found)
802 /* descriptors should have contained fd. */
803 abort ();
804
805 if (mt) gl_lock_unlock (descriptors_lock);
806
807 errno = saved_errno;
808 return result;
809 }
810
811 /* Close a temporary file.
812 FP must have been returned by fopen_temp, or by fdopen on a file descriptor
813 returned by open_temp or gen_register_open_temp.
814 Unregisters the previously registered file descriptor. */
815 int
816 fclose_temp (FILE *fp)
817 {
818 return fclose_variant_temp (fp, fclose);
819 }
820
821 #if GNULIB_FWRITEERROR
822 /* Like fwriteerror.
823 FP must have been returned by fopen_temp, or by fdopen on a file descriptor
824 returned by open_temp or gen_register_open_temp.
825 Unregisters the previously registered file descriptor. */
826 int
827 fwriteerror_temp (FILE *fp)
828 {
829 return fclose_variant_temp (fp, fwriteerror);
830 }
831 #endif
832
833 #if GNULIB_CLOSE_STREAM
834 /* Like close_stream.
835 FP must have been returned by fopen_temp, or by fdopen on a file descriptor
836 returned by open_temp or gen_register_open_temp.
837 Unregisters the previously registered file descriptor. */
838 int
839 close_stream_temp (FILE *fp)
840 {
841 return fclose_variant_temp (fp, close_stream);
842 }
843 #endif