|
7044
|
1 /* Temporary directories and temporary files with automatic cleanup. |
|
|
2 Copyright (C) 2001, 2003, 2006 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 #ifdef HAVE_CONFIG_H |
|
|
21 # include "config.h" |
|
|
22 #endif |
|
|
23 |
|
|
24 /* Specification. */ |
|
|
25 #include "clean-temp.h" |
|
|
26 |
|
|
27 #include <errno.h> |
|
|
28 #include <limits.h> |
|
|
29 #include <stdbool.h> |
|
|
30 #include <stdlib.h> |
|
|
31 #include <string.h> |
|
|
32 #include <unistd.h> |
|
|
33 |
|
|
34 #include "error.h" |
|
|
35 #include "fatal-signal.h" |
|
|
36 #include "pathmax.h" |
|
|
37 #include "tmpdir.h" |
|
|
38 #include "mkdtemp.h" |
|
|
39 #include "xalloc.h" |
|
|
40 #include "xallocsa.h" |
|
|
41 #include "gl_linkedhash_list.h" |
|
|
42 #include "gettext.h" |
|
|
43 |
|
|
44 #define _(str) gettext (str) |
|
|
45 |
|
|
46 |
|
|
47 /* The use of 'volatile' in the types below (and ISO C 99 section 5.1.2.3.(5)) |
|
|
48 ensure that while constructing or modifying the data structures, the field |
|
|
49 values are written to memory in the order of the C statements. So the |
|
|
50 signal handler can rely on these field values to be up to date. */ |
|
|
51 |
|
|
52 |
|
|
53 /* Registry for a single temporary directory. |
|
|
54 'struct temp_dir' from the public header file overlaps with this. */ |
|
|
55 struct tempdir |
|
|
56 { |
|
|
57 /* The absolute pathname of the directory. */ |
|
|
58 char * volatile dirname; |
|
|
59 /* Whether errors during explicit cleanup are reported to standard error. */ |
|
|
60 bool cleanup_verbose; |
|
|
61 /* Absolute pathnames of subdirectories. */ |
|
|
62 gl_list_t /* <char *> */ volatile subdirs; |
|
|
63 /* Absolute pathnames of files. */ |
|
|
64 gl_list_t /* <char *> */ volatile files; |
|
|
65 }; |
|
|
66 |
|
|
67 /* List of all temporary directories. */ |
|
|
68 static struct |
|
|
69 { |
|
|
70 struct tempdir * volatile * volatile tempdir_list; |
|
|
71 size_t volatile tempdir_count; |
|
|
72 size_t tempdir_allocated; |
|
|
73 } cleanup_list /* = { NULL, 0, 0 } */; |
|
|
74 |
|
|
75 |
|
|
76 /* For the subdirs and for the files, we use a gl_list_t of type LINKEDHASH. |
|
|
77 Why? We need a data structure that |
|
|
78 |
|
|
79 1) Can contain an arbitrary number of 'char *' values. The strings |
|
|
80 are compared via strcmp, not pointer comparison. |
|
|
81 2) Has insertion and deletion operations that are fast: ideally O(1), |
|
|
82 or possibly O(log n). This is important for GNU sort, which may |
|
|
83 create a large number of temporary files. |
|
|
84 3) Allows iteration through all elements from within a signal handler. |
|
|
85 4) May or may not allow duplicates. It doesn't matter here, since |
|
|
86 any file or subdir can only be removed once. |
|
|
87 |
|
|
88 Criterion 1) would allow any gl_list_t or gl_oset_t implementation. |
|
|
89 |
|
|
90 Criterion 2) leaves only GL_LINKEDHASH_LIST, GL_TREEHASH_LIST, or |
|
|
91 GL_TREE_OSET. |
|
|
92 |
|
|
93 Criterion 3) puts at disadvantage GL_TREEHASH_LIST and GL_TREE_OSET. |
|
|
94 Namely, iteration through the elements of a binary tree requires access |
|
|
95 to many ->left, ->right, ->parent pointers. However, the rebalancing |
|
|
96 code for insertion and deletion in an AVL or red-black tree is so |
|
|
97 complicated that we cannot assume that >left, ->right, ->parent pointers |
|
|
98 are in a consistent state throughout these operations. Therefore, to |
|
|
99 avoid a crash in the signal handler, all destructive operations to the |
|
|
100 lists would have to be protected by a |
|
|
101 block_fatal_signals (); |
|
|
102 ... |
|
|
103 unblock_fatal_signals (); |
|
|
104 pair. Which causes extra system calls. |
|
|
105 |
|
|
106 Criterion 3) would also discourage GL_ARRAY_LIST and GL_CARRAY_LIST, |
|
|
107 if they were not already excluded. Namely, these implementations use |
|
|
108 xrealloc(), leaving a time window in which in the list->elements pointer |
|
|
109 points to already deallocated memory. To avoid a crash in the signal |
|
|
110 handler at such a moment, all destructive operations would have to |
|
|
111 protected by block/unblock_fatal_signals (), in this case too. |
|
|
112 |
|
|
113 A list of type GL_LINKEDHASH_LIST without duplicates fulfills all |
|
|
114 requirements: |
|
|
115 2) Insertion and deletion are O(1) on average. |
|
|
116 3) The gl_list_iterator, gl_list_iterator_next implementations do |
|
|
117 not trigger memory allocations, nor other system calls, and are |
|
|
118 therefore safe to be called from a signal handler. |
|
|
119 Furthermore, since SIGNAL_SAFE_LIST is defined, the implementation |
|
|
120 of the destructive functions ensures that the list structure is |
|
|
121 safe to be traversed at any moment, even when interrupted by an |
|
|
122 asynchronous signal. |
|
|
123 */ |
|
|
124 |
|
|
125 /* String equality and hash code functions used by the lists. */ |
|
|
126 |
|
|
127 static bool |
|
|
128 string_equals (const void *x1, const void *x2) |
|
|
129 { |
|
|
130 const char *s1 = x1; |
|
|
131 const char *s2 = x2; |
|
|
132 return strcmp (s1, s2) == 0; |
|
|
133 } |
|
|
134 |
|
|
135 #define SIZE_BITS (sizeof (size_t) * CHAR_BIT) |
|
|
136 |
|
|
137 /* A hash function for NUL-terminated char* strings using |
|
|
138 the method described by Bruno Haible. |
|
|
139 See http://www.haible.de/bruno/hashfunc.html. */ |
|
|
140 static size_t |
|
|
141 string_hash (const void *x) |
|
|
142 { |
|
|
143 const char *s = x; |
|
|
144 size_t h = 0; |
|
|
145 |
|
|
146 for (; *s; s++) |
|
|
147 h = *s + ((h << 9) | (h >> (SIZE_BITS - 9))); |
|
|
148 |
|
|
149 return h; |
|
|
150 } |
|
|
151 |
|
|
152 |
|
|
153 /* The signal handler. It gets called asynchronously. */ |
|
|
154 static void |
|
|
155 cleanup () |
|
|
156 { |
|
|
157 size_t i; |
|
|
158 |
|
|
159 for (i = 0; i < cleanup_list.tempdir_count; i++) |
|
|
160 { |
|
|
161 struct tempdir *dir = cleanup_list.tempdir_list[i]; |
|
|
162 |
|
|
163 if (dir != NULL) |
|
|
164 { |
|
|
165 gl_list_iterator_t iter; |
|
|
166 const void *element; |
|
|
167 |
|
|
168 /* First cleanup the files in the subdirectories. */ |
|
|
169 iter = gl_list_iterator (dir->files); |
|
|
170 while (gl_list_iterator_next (&iter, &element, NULL)) |
|
|
171 { |
|
|
172 const char *file = (const char *) element; |
|
|
173 unlink (file); |
|
|
174 } |
|
|
175 gl_list_iterator_free (&iter); |
|
|
176 |
|
|
177 /* Then cleanup the subdirectories. */ |
|
|
178 iter = gl_list_iterator (dir->subdirs); |
|
|
179 while (gl_list_iterator_next (&iter, &element, NULL)) |
|
|
180 { |
|
|
181 const char *subdir = (const char *) element; |
|
|
182 rmdir (subdir); |
|
|
183 } |
|
|
184 gl_list_iterator_free (&iter); |
|
|
185 |
|
|
186 /* Then cleanup the temporary directory itself. */ |
|
|
187 rmdir (dir->dirname); |
|
|
188 } |
|
|
189 } |
|
|
190 } |
|
|
191 |
|
|
192 /* Create a temporary directory. |
|
|
193 PREFIX is used as a prefix for the name of the temporary directory. It |
|
|
194 should be short and still give an indication about the program. |
|
|
195 PARENTDIR can be used to specify the parent directory; if NULL, a default |
|
|
196 parent directory is used (either $TMPDIR or /tmp or similar). |
|
|
197 CLEANUP_VERBOSE determines whether errors during explicit cleanup are |
|
|
198 reported to standard error. |
|
|
199 Return a fresh 'struct temp_dir' on success. Upon error, an error message |
|
|
200 is shown and NULL is returned. */ |
|
|
201 struct temp_dir * |
|
|
202 create_temp_dir (const char *prefix, const char *parentdir, |
|
|
203 bool cleanup_verbose) |
|
|
204 { |
|
|
205 struct tempdir * volatile *tmpdirp = NULL; |
|
|
206 struct tempdir *tmpdir; |
|
|
207 size_t i; |
|
|
208 char *template; |
|
|
209 char *tmpdirname; |
|
|
210 |
|
|
211 /* See whether it can take the slot of an earlier temporary directory |
|
|
212 already cleaned up. */ |
|
|
213 for (i = 0; i < cleanup_list.tempdir_count; i++) |
|
|
214 if (cleanup_list.tempdir_list[i] == NULL) |
|
|
215 { |
|
|
216 tmpdirp = &cleanup_list.tempdir_list[i]; |
|
|
217 break; |
|
|
218 } |
|
|
219 if (tmpdirp == NULL) |
|
|
220 { |
|
|
221 /* See whether the array needs to be extended. */ |
|
|
222 if (cleanup_list.tempdir_count == cleanup_list.tempdir_allocated) |
|
|
223 { |
|
|
224 /* Note that we cannot use xrealloc(), because then the cleanup() |
|
|
225 function could access an already deallocated array. */ |
|
|
226 struct tempdir * volatile *old_array = cleanup_list.tempdir_list; |
|
|
227 size_t old_allocated = cleanup_list.tempdir_allocated; |
|
|
228 size_t new_allocated = 2 * cleanup_list.tempdir_allocated + 1; |
|
|
229 struct tempdir * volatile *new_array = |
|
|
230 (struct tempdir * volatile *) |
|
|
231 xmalloc (new_allocated * sizeof (struct tempdir * volatile)); |
|
|
232 |
|
|
233 if (old_allocated == 0) |
|
|
234 /* First use of this facility. Register the cleanup handler. */ |
|
|
235 at_fatal_signal (&cleanup); |
|
|
236 else |
|
|
237 { |
|
|
238 /* Don't use memcpy() here, because memcpy takes non-volatile |
|
|
239 arguments and is therefore not guaranteed to complete all |
|
|
240 memory stores before the next statement. */ |
|
|
241 size_t k; |
|
|
242 |
|
|
243 for (k = 0; k < old_allocated; k++) |
|
|
244 new_array[k] = old_array[k]; |
|
|
245 } |
|
|
246 |
|
|
247 cleanup_list.tempdir_list = new_array; |
|
|
248 cleanup_list.tempdir_allocated = new_allocated; |
|
|
249 |
|
|
250 /* Now we can free the old array. */ |
|
|
251 if (old_array != NULL) |
|
|
252 free ((struct tempdir **) old_array); |
|
|
253 } |
|
|
254 |
|
|
255 tmpdirp = &cleanup_list.tempdir_list[cleanup_list.tempdir_count]; |
|
|
256 /* Initialize *tmpdirp before incrementing tempdir_count, so that |
|
|
257 cleanup() will skip this entry before it is fully initialized. */ |
|
|
258 *tmpdirp = NULL; |
|
|
259 cleanup_list.tempdir_count++; |
|
|
260 } |
|
|
261 |
|
|
262 /* Initialize a 'struct tempdir'. */ |
|
|
263 tmpdir = (struct tempdir *) xmalloc (sizeof (struct tempdir)); |
|
|
264 tmpdir->dirname = NULL; |
|
|
265 tmpdir->cleanup_verbose = cleanup_verbose; |
|
|
266 tmpdir->subdirs = gl_list_create_empty (GL_LINKEDHASH_LIST, |
|
|
267 string_equals, string_hash, false); |
|
|
268 tmpdir->files = gl_list_create_empty (GL_LINKEDHASH_LIST, |
|
|
269 string_equals, string_hash, false); |
|
|
270 |
|
|
271 /* Create the temporary directory. */ |
|
|
272 template = (char *) xallocsa (PATH_MAX); |
|
|
273 if (path_search (template, PATH_MAX, parentdir, prefix, parentdir == NULL)) |
|
|
274 { |
|
|
275 error (0, errno, |
|
|
276 _("cannot find a temporary directory, try setting $TMPDIR")); |
|
|
277 goto quit; |
|
|
278 } |
|
|
279 block_fatal_signals (); |
|
|
280 tmpdirname = mkdtemp (template); |
|
|
281 if (tmpdirname != NULL) |
|
|
282 { |
|
|
283 tmpdir->dirname = tmpdirname; |
|
|
284 *tmpdirp = tmpdir; |
|
|
285 } |
|
|
286 unblock_fatal_signals (); |
|
|
287 if (tmpdirname == NULL) |
|
|
288 { |
|
|
289 error (0, errno, |
|
|
290 _("cannot create a temporary directory using template \"%s\""), |
|
|
291 template); |
|
|
292 goto quit; |
|
|
293 } |
|
|
294 /* Replace tmpdir->dirname with a copy that has indefinite extent. |
|
|
295 We cannot do this inside the block_fatal_signals/unblock_fatal_signals |
|
|
296 block because then the cleanup handler would not remove the directory |
|
|
297 if xstrdup fails. */ |
|
|
298 tmpdir->dirname = xstrdup (tmpdirname); |
|
|
299 freesa (template); |
|
|
300 return (struct temp_dir *) tmpdir; |
|
|
301 |
|
|
302 quit: |
|
|
303 freesa (template); |
|
|
304 return NULL; |
|
|
305 } |
|
|
306 |
|
|
307 /* Register the given ABSOLUTE_FILE_NAME as being a file inside DIR, that |
|
|
308 needs to be removed before DIR can be removed. |
|
|
309 Should be called before the file ABSOLUTE_FILE_NAME is created. */ |
|
|
310 void |
|
|
311 register_temp_file (struct temp_dir *dir, |
|
|
312 const char *absolute_file_name) |
|
|
313 { |
|
|
314 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
315 |
|
|
316 /* Add absolute_file_name to tmpdir->files, without duplicates. */ |
|
|
317 if (gl_list_search (tmpdir->files, absolute_file_name) == NULL) |
|
|
318 gl_list_add_first (tmpdir->files, xstrdup (absolute_file_name)); |
|
|
319 } |
|
|
320 |
|
|
321 /* Unregister the given ABSOLUTE_FILE_NAME as being a file inside DIR, that |
|
|
322 needs to be removed before DIR can be removed. |
|
|
323 Should be called when the file ABSOLUTE_FILE_NAME could not be created. */ |
|
|
324 void |
|
|
325 unregister_temp_file (struct temp_dir *dir, |
|
|
326 const char *absolute_file_name) |
|
|
327 { |
|
|
328 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
329 gl_list_t list = tmpdir->files; |
|
|
330 gl_list_node_t node; |
|
|
331 |
|
|
332 node = gl_list_search (list, absolute_file_name); |
|
|
333 if (node != NULL) |
|
|
334 { |
|
|
335 char *old_string = (char *) gl_list_node_value (list, node); |
|
|
336 |
|
|
337 gl_list_remove_node (list, node); |
|
|
338 free (old_string); |
|
|
339 } |
|
|
340 } |
|
|
341 |
|
|
342 /* Register the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR, |
|
|
343 that needs to be removed before DIR can be removed. |
|
|
344 Should be called before the subdirectory ABSOLUTE_DIR_NAME is created. */ |
|
|
345 void |
|
|
346 register_temp_subdir (struct temp_dir *dir, |
|
|
347 const char *absolute_dir_name) |
|
|
348 { |
|
|
349 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
350 |
|
|
351 /* Add absolute_dir_name to tmpdir->subdirs, without duplicates. */ |
|
|
352 if (gl_list_search (tmpdir->subdirs, absolute_dir_name) == NULL) |
|
|
353 gl_list_add_first (tmpdir->subdirs, xstrdup (absolute_dir_name)); |
|
|
354 } |
|
|
355 |
|
|
356 /* Unregister the given ABSOLUTE_DIR_NAME as being a subdirectory inside DIR, |
|
|
357 that needs to be removed before DIR can be removed. |
|
|
358 Should be called when the subdirectory ABSOLUTE_DIR_NAME could not be |
|
|
359 created. */ |
|
|
360 void |
|
|
361 unregister_temp_subdir (struct temp_dir *dir, |
|
|
362 const char *absolute_dir_name) |
|
|
363 { |
|
|
364 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
365 gl_list_t list = tmpdir->subdirs; |
|
|
366 gl_list_node_t node; |
|
|
367 |
|
|
368 node = gl_list_search (list, absolute_dir_name); |
|
|
369 if (node != NULL) |
|
|
370 { |
|
|
371 char *old_string = (char *) gl_list_node_value (list, node); |
|
|
372 |
|
|
373 gl_list_remove_node (list, node); |
|
|
374 free (old_string); |
|
|
375 } |
|
|
376 } |
|
|
377 |
|
|
378 /* Remove a file, with optional error message. */ |
|
|
379 static void |
|
|
380 do_unlink (struct temp_dir *dir, const char *absolute_file_name) |
|
|
381 { |
|
|
382 if (unlink (absolute_file_name) < 0 && dir->cleanup_verbose |
|
|
383 && errno != ENOENT) |
|
|
384 error (0, errno, _("cannot remove temporary file %s"), absolute_file_name); |
|
|
385 } |
|
|
386 |
|
|
387 /* Remove a directory, with optional error message. */ |
|
|
388 static void |
|
|
389 do_rmdir (struct temp_dir *dir, const char *absolute_dir_name) |
|
|
390 { |
|
|
391 if (rmdir (absolute_dir_name) < 0 && dir->cleanup_verbose |
|
|
392 && errno != ENOENT) |
|
|
393 error (0, errno, |
|
|
394 _("cannot remove temporary directory %s"), absolute_dir_name); |
|
|
395 } |
|
|
396 |
|
|
397 /* Remove the given ABSOLUTE_FILE_NAME and unregister it. */ |
|
|
398 void |
|
|
399 cleanup_temp_file (struct temp_dir *dir, |
|
|
400 const char *absolute_file_name) |
|
|
401 { |
|
|
402 do_unlink (dir, absolute_file_name); |
|
|
403 unregister_temp_file (dir, absolute_file_name); |
|
|
404 } |
|
|
405 |
|
|
406 /* Remove the given ABSOLUTE_DIR_NAME and unregister it. */ |
|
|
407 void |
|
|
408 cleanup_temp_subdir (struct temp_dir *dir, |
|
|
409 const char *absolute_dir_name) |
|
|
410 { |
|
|
411 do_rmdir (dir, absolute_dir_name); |
|
|
412 unregister_temp_subdir (dir, absolute_dir_name); |
|
|
413 } |
|
|
414 |
|
|
415 /* Remove all registered files and subdirectories inside DIR. */ |
|
|
416 void |
|
|
417 cleanup_temp_dir_contents (struct temp_dir *dir) |
|
|
418 { |
|
|
419 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
420 gl_list_t list; |
|
|
421 gl_list_iterator_t iter; |
|
|
422 const void *element; |
|
|
423 gl_list_node_t node; |
|
|
424 |
|
|
425 /* First cleanup the files in the subdirectories. */ |
|
|
426 list = tmpdir->files; |
|
|
427 iter = gl_list_iterator (list); |
|
|
428 while (gl_list_iterator_next (&iter, &element, &node)) |
|
|
429 { |
|
|
430 char *file = (char *) element; |
|
|
431 |
|
|
432 do_unlink (dir, file); |
|
|
433 gl_list_remove_node (list, node); |
|
|
434 /* Now only we can free file. */ |
|
|
435 free (file); |
|
|
436 } |
|
|
437 gl_list_iterator_free (&iter); |
|
|
438 |
|
|
439 /* Then cleanup the subdirectories. */ |
|
|
440 list = tmpdir->subdirs; |
|
|
441 iter = gl_list_iterator (list); |
|
|
442 while (gl_list_iterator_next (&iter, &element, &node)) |
|
|
443 { |
|
|
444 char *subdir = (char *) element; |
|
|
445 |
|
|
446 do_rmdir (dir, subdir); |
|
|
447 gl_list_remove_node (list, node); |
|
|
448 /* Now only we can free subdir. */ |
|
|
449 free (subdir); |
|
|
450 } |
|
|
451 gl_list_iterator_free (&iter); |
|
|
452 } |
|
|
453 |
|
|
454 /* Remove all registered files and subdirectories inside DIR and DIR itself. |
|
|
455 DIR cannot be used any more after this call. */ |
|
|
456 void |
|
|
457 cleanup_temp_dir (struct temp_dir *dir) |
|
|
458 { |
|
|
459 struct tempdir *tmpdir = (struct tempdir *)dir; |
|
|
460 size_t i; |
|
|
461 |
|
|
462 cleanup_temp_dir_contents (dir); |
|
|
463 do_rmdir (dir, tmpdir->dirname); |
|
|
464 |
|
|
465 for (i = 0; i < cleanup_list.tempdir_count; i++) |
|
|
466 if (cleanup_list.tempdir_list[i] == tmpdir) |
|
|
467 { |
|
|
468 /* Remove cleanup_list.tempdir_list[i]. */ |
|
|
469 if (i + 1 == cleanup_list.tempdir_count) |
|
|
470 { |
|
|
471 while (i > 0 && cleanup_list.tempdir_list[i - 1] == NULL) |
|
|
472 i--; |
|
|
473 cleanup_list.tempdir_count = i; |
|
|
474 } |
|
|
475 else |
|
|
476 cleanup_list.tempdir_list[i] = NULL; |
|
|
477 /* Now only we can free the tmpdir->dirname and tmpdir itself. */ |
|
|
478 free (tmpdir->dirname); |
|
|
479 free (tmpdir); |
|
|
480 return; |
|
|
481 } |
|
|
482 |
|
|
483 /* The user passed an invalid DIR argument. */ |
|
|
484 abort (); |
|
|
485 } |
