1 /* Miscellaneous functions, not really specific to GNU tar.
3 Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
25 #include <unlinkdir.h>
28 #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
29 # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
33 /* Handling strings. */
35 /* Assign STRING to a copy of VALUE if not zero, or to zero. If
36 STRING was nonzero, it is freed first. */
38 assign_string (char **string
, const char *value
)
41 *string
= value
? xstrdup (value
) : 0;
45 /* This function is currently unused; perhaps it should be removed? */
47 /* Allocate a copy of the string quoted as in C, and returns that. If
48 the string does not have to be quoted, it returns a null pointer.
49 The allocated copy should normally be freed with free() after the
50 caller is done with it.
52 This is used in one context only: generating the directory file in
53 incremental dumps. The quoted string is not intended for human
54 consumption; it is intended only for unquote_string. The quoting
55 is locale-independent, so that users needn't worry about locale
56 when reading directory files. This means that we can't use
57 quotearg, as quotearg is locale-dependent and is meant for human
60 quote_copy_string (const char *string
)
62 const char *source
= string
;
63 char *destination
= 0;
69 int character
= *source
++;
76 size_t length
= (source
- string
) - 1;
79 buffer
= xmalloc (length
+ 2 + 2 * strlen (source
) + 1);
80 memcpy (buffer
, string
, length
);
81 destination
= buffer
+ length
;
83 *destination
++ = '\\';
84 *destination
++ = character
== '\\' ? '\\' : 'n';
89 *destination
++ = character
;
102 /* Takes a quoted C string (like those produced by quote_copy_string)
103 and turns it back into the un-quoted original. This is done in
104 place. Returns 0 only if the string was not properly quoted, but
105 completes the unquoting anyway.
107 This is used for reading the saved directory file in incremental
108 dumps. It is used for decoding old `N' records (demangling names).
109 But also, it is used for decoding file arguments, would they come
110 from the shell or a -T file, and for decoding the --exclude
113 unquote_string (char *string
)
116 char *source
= string
;
117 char *destination
= string
;
119 /* Escape sequences other than \\ and \n are no longer generated by
120 quote_copy_string, but accept them for backwards compatibility,
121 and also because unquote_string is used for purposes other than
122 parsing the output of quote_copy_string. */
129 *destination
++ = '\\';
134 *destination
++ = '\a';
139 *destination
++ = '\b';
144 *destination
++ = '\f';
149 *destination
++ = '\n';
154 *destination
++ = '\r';
159 *destination
++ = '\t';
164 *destination
++ = '\v';
169 *destination
++ = 0177;
182 int value
= *source
++ - '0';
184 if (*source
< '0' || *source
> '7')
186 *destination
++ = value
;
189 value
= value
* 8 + *source
++ - '0';
190 if (*source
< '0' || *source
> '7')
192 *destination
++ = value
;
195 value
= value
* 8 + *source
++ - '0';
196 *destination
++ = value
;
202 *destination
++ = '\\';
204 *destination
++ = *source
++;
207 else if (source
!= destination
)
208 *destination
++ = *source
++;
210 source
++, destination
++;
212 if (source
!= destination
)
217 /* Zap trailing slashes. */
219 zap_slashes (char *name
)
223 if (!name
|| *name
== 0)
225 q
= name
+ strlen (name
) - 1;
226 while (q
> name
&& ISSLASH (*q
))
231 /* Normalize FILE_NAME by removing redundant slashes and "."
232 components, including redundant trailing slashes. Leave ".."
233 alone, as it may be significant in the presence of symlinks and on
234 platforms where "/.." != "/". Destructive version: modifies its
237 normalize_filename_x (char *file_name
)
239 char *name
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
244 /* Don't squeeze leading "//" to "/", on hosts where they're distinct. */
245 name
+= (DOUBLE_SLASH_IS_DISTINCT_ROOT
246 && ISSLASH (*name
) && ISSLASH (name
[1]) && ! ISSLASH (name
[2]));
248 /* Omit redundant leading "." components. */
249 for (q
= p
= name
; (*p
= *q
) == '.' && ISSLASH (q
[1]); p
+= !*q
)
250 for (q
+= 2; ISSLASH (*q
); q
++)
253 /* Copy components from Q to P, omitting redundant slashes and
254 internal "." components. */
255 while ((*p
++ = c
= *q
++) != '\0')
257 while (ISSLASH (q
[*q
== '.']))
258 q
+= (*q
== '.') + 1;
260 /* Omit redundant trailing "." component and slash. */
263 p
-= p
[-2] == '.' && ISSLASH (p
[-3]);
264 p
-= 2 < p
- name
&& ISSLASH (p
[-2]);
269 /* Normalize NAME by removing redundant slashes and "." components,
270 including redundant trailing slashes. Return a normalized
271 newly-allocated copy. */
274 normalize_filename (const char *name
)
278 if (IS_RELATIVE_FILE_NAME (name
))
280 /* Set COPY to the absolute file name if possible.
282 FIXME: There should be no need to get the absolute file name.
283 getcwd is slow, it might fail, and it does not necessarily
284 return a canonical name even when it succeeds. Perhaps we
285 can use dev+ino pairs instead of names? */
289 size_t copylen
= strlen (copy
);
290 bool need_separator
= ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
291 && copylen
== 2 && ISSLASH (copy
[1]));
292 copy
= xrealloc (copy
, copylen
+ need_separator
+ strlen (name
) + 1);
293 copy
[copylen
] = DIRECTORY_SEPARATOR
;
294 strcpy (copy
+ copylen
+ need_separator
, name
);
297 WARN ((0, errno
, _("Cannot get working directory")));
301 copy
= xstrdup (name
);
302 normalize_filename_x (copy
);
308 replace_prefix (char **pname
, const char *samp
, size_t slen
,
309 const char *repl
, size_t rlen
)
312 size_t nlen
= strlen (name
);
313 if (nlen
> slen
&& memcmp (name
, samp
, slen
) == 0 && ISSLASH (name
[slen
]))
317 name
= xrealloc (name
, nlen
- slen
+ rlen
+ 1);
320 memmove (name
+ rlen
, name
+ slen
, nlen
- slen
+ 1);
321 memcpy (name
, repl
, rlen
);
326 /* Handling numbers. */
328 /* Output fraction and trailing digits appropriate for a nanoseconds
329 count equal to NS, but don't output unnecessary '.' or trailing
333 code_ns_fraction (int ns
, char *p
)
352 p
[--i
] = '0' + ns
% 10;
361 code_timespec (struct timespec t
, char sbuf
[TIMESPEC_STRSIZE_BOUND
])
366 bool negative
= s
< 0;
368 /* ignore invalid values of ns */
369 if (BILLION
<= ns
|| ns
< 0)
372 if (negative
&& ns
!= 0)
378 np
= umaxtostr (negative
? - (uintmax_t) s
: (uintmax_t) s
, sbuf
+ 1);
381 code_ns_fraction (ns
, sbuf
+ UINTMAX_STRSIZE_BOUND
);
387 /* Saved names in case backup needs to be undone. */
388 static char *before_backup_name
;
389 static char *after_backup_name
;
391 /* Return 1 if FILE_NAME is obviously "." or "/". */
393 must_be_dot_or_slash (char const *file_name
)
395 file_name
+= FILE_SYSTEM_PREFIX_LEN (file_name
);
397 if (ISSLASH (file_name
[0]))
400 if (ISSLASH (file_name
[1]))
402 else if (file_name
[1] == '.'
403 && ISSLASH (file_name
[2 + (file_name
[2] == '.')]))
404 file_name
+= 2 + (file_name
[2] == '.');
406 return ! file_name
[1];
410 while (file_name
[0] == '.' && ISSLASH (file_name
[1]))
413 while (ISSLASH (*file_name
))
417 return ! file_name
[0] || (file_name
[0] == '.' && ! file_name
[1]);
421 /* Some implementations of rmdir let you remove '.' or '/'.
422 Report an error with errno set to zero for obvious cases of this;
423 otherwise call rmdir. */
425 safer_rmdir (const char *file_name
)
427 if (must_be_dot_or_slash (file_name
))
433 return unlinkat (chdir_fd
, file_name
, AT_REMOVEDIR
);
436 /* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
437 then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
438 recursively; otherwise, remove it only if it is empty. If FILE_NAME is
439 a directory that cannot be removed (e.g., because it is nonempty)
440 and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
441 Return 0 on error, with errno set; if FILE_NAME is obviously the working
442 directory return zero with errno set to zero. */
444 remove_any_file (const char *file_name
, enum remove_option option
)
446 /* Try unlink first if we cannot unlink directories, as this saves
447 us a system call in the common case where we're removing a
449 bool try_unlink_first
= cannot_unlink_dir ();
451 if (try_unlink_first
)
453 if (unlinkat (chdir_fd
, file_name
, 0) == 0)
456 /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
457 directory without appropriate privileges, but many Linux
458 kernels return the more-sensible EISDIR. */
459 if (errno
!= EPERM
&& errno
!= EISDIR
)
463 if (safer_rmdir (file_name
) == 0)
469 return !try_unlink_first
&& unlinkat (chdir_fd
, file_name
, 0) == 0;
473 #if defined ENOTEMPTY && ENOTEMPTY != EEXIST
478 case ORDINARY_REMOVE_OPTION
:
481 case WANT_DIRECTORY_REMOVE_OPTION
:
484 case RECURSIVE_REMOVE_OPTION
:
486 char *directory
= savedir (file_name
);
493 for (entry
= directory
;
494 (entrylen
= strlen (entry
)) != 0;
495 entry
+= entrylen
+ 1)
497 char *file_name_buffer
= new_name (file_name
, entry
);
498 int r
= remove_any_file (file_name_buffer
,
499 RECURSIVE_REMOVE_OPTION
);
501 free (file_name_buffer
);
512 return safer_rmdir (file_name
) == 0;
521 /* Check if FILE_NAME already exists and make a backup of it right now.
522 Return success (nonzero) only if the backup is either unneeded, or
523 successful. For now, directories are considered to never need
524 backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
525 so, we do not have to backup block or character devices, nor remote
528 maybe_backup_file (const char *file_name
, bool this_is_the_archive
)
530 struct stat file_stat
;
532 assign_string (&before_backup_name
, file_name
);
534 /* A run situation may exist between Emacs or other GNU programs trying to
535 make a backup for the same file simultaneously. If theoretically
536 possible, real problems are unlikely. Doing any better would require a
537 convention, GNU-wide, for all programs doing backups. */
539 assign_string (&after_backup_name
, 0);
541 /* Check if we really need to backup the file. */
543 if (this_is_the_archive
&& _remdev (file_name
))
546 if (deref_stat (file_name
, &file_stat
) != 0)
551 stat_error (file_name
);
555 if (S_ISDIR (file_stat
.st_mode
))
558 if (this_is_the_archive
559 && (S_ISBLK (file_stat
.st_mode
) || S_ISCHR (file_stat
.st_mode
)))
562 after_backup_name
= find_backup_file_name (file_name
, backup_type
);
563 if (! after_backup_name
)
566 if (renameat (chdir_fd
, before_backup_name
, chdir_fd
, after_backup_name
)
570 fprintf (stdlis
, _("Renaming %s to %s\n"),
571 quote_n (0, before_backup_name
),
572 quote_n (1, after_backup_name
));
577 /* The backup operation failed. */
579 ERROR ((0, e
, _("%s: Cannot rename to %s"),
580 quotearg_colon (before_backup_name
),
581 quote_n (1, after_backup_name
)));
582 assign_string (&after_backup_name
, 0);
587 /* Try to restore the recently backed up file to its original name.
588 This is usually only needed after a failed extraction. */
590 undo_last_backup (void)
592 if (after_backup_name
)
594 if (renameat (chdir_fd
, after_backup_name
, chdir_fd
, before_backup_name
)
598 ERROR ((0, e
, _("%s: Cannot rename to %s"),
599 quotearg_colon (after_backup_name
),
600 quote_n (1, before_backup_name
)));
603 fprintf (stdlis
, _("Renaming %s back to %s\n"),
604 quote_n (0, after_backup_name
),
605 quote_n (1, before_backup_name
));
606 assign_string (&after_backup_name
, 0);
610 /* Apply either stat or lstat to (NAME, BUF), depending on the
611 presence of the --dereference option. NAME is relative to the
612 most-recent argument to chdir_do. */
614 deref_stat (char const *name
, struct stat
*buf
)
616 return fstatat (chdir_fd
, name
, buf
, fstatat_flags
);
619 /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
620 access time to ATIME. */
622 set_file_atime (int fd
, int parentfd
, char const *file
, struct timespec atime
)
624 struct timespec ts
[2];
626 ts
[1].tv_nsec
= UTIME_OMIT
;
627 return fdutimensat (fd
, parentfd
, file
, ts
, fstatat_flags
);
630 /* A description of a working directory. */
633 /* The directory's name. */
636 /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
637 the working directory. If zero, the directory needs to be opened
642 /* A vector of chdir targets. wd[0] is the initial working directory. */
643 static struct wd
*wd
;
645 /* The number of working directories in the vector. */
646 static size_t wd_count
;
648 /* The allocated size of the vector. */
649 static size_t wd_alloc
;
651 /* The maximum number of chdir targets with open directories.
652 Don't make it too large, as many operating systems have a small
653 limit on the number of open file descriptors. Also, the current
654 implementation does not scale well. */
655 enum { CHDIR_CACHE_SIZE
= 16 };
657 /* Indexes into WD of chdir targets with open file descriptors, sorted
658 most-recently used first. Zero indexes are unused. */
659 static int wdcache
[CHDIR_CACHE_SIZE
];
661 /* Number of nonzero entries in WDCACHE. */
662 static size_t wdcache_count
;
672 /* DIR is the operand of a -C option; add it to vector of chdir targets,
673 and return the index of its location. */
675 chdir_arg (char const *dir
)
677 if (wd_count
== wd_alloc
)
682 wd
= xmalloc (sizeof *wd
* wd_alloc
);
685 wd
= x2nrealloc (wd
, &wd_alloc
, sizeof *wd
);
689 wd
[wd_count
].name
= ".";
690 wd
[wd_count
].fd
= AT_FDCWD
;
695 /* Optimize the common special case of the working directory,
696 or the working directory as a prefix. */
699 while (dir
[0] == '.' && ISSLASH (dir
[1]))
700 for (dir
+= 2; ISSLASH (*dir
); dir
++)
702 if (! dir
[dir
[0] == '.'])
706 wd
[wd_count
].name
= dir
;
711 /* Index of current directory. */
714 /* Value suitable for use as the first argument to openat, and in
715 similar locations for fstatat, etc. This is an open file
716 descriptor, or AT_FDCWD if the working directory is current. It is
717 valid until the next invocation of chdir_do. */
718 int chdir_fd
= AT_FDCWD
;
720 /* Change to directory I, in a virtual way. This does not actually
721 invoke chdir; it merely sets chdir_fd to an int suitable as the
722 first argument for openat, etc. If I is 0, change to the initial
723 working directory; otherwise, I must be a value returned by
728 if (chdir_current
!= i
)
730 struct wd
*curr
= &wd
[i
];
735 if (! IS_ABSOLUTE_FILE_NAME (curr
->name
))
737 fd
= openat (chdir_fd
, curr
->name
,
738 open_searchdir_flags
& ~ O_NOFOLLOW
);
740 open_fatal (curr
->name
);
744 /* Add I to the cache, tossing out the lowest-ranking entry if the
746 if (wdcache_count
< CHDIR_CACHE_SIZE
)
747 wdcache
[wdcache_count
++] = i
;
750 struct wd
*stale
= &wd
[wdcache
[CHDIR_CACHE_SIZE
- 1]];
751 if (close (stale
->fd
) != 0)
752 close_diag (stale
->name
);
754 wdcache
[CHDIR_CACHE_SIZE
- 1] = i
;
760 /* Move the i value to the front of the cache. This is
761 O(CHDIR_CACHE_SIZE), but the cache is small. */
763 int prev
= wdcache
[0];
764 for (ci
= 1; prev
!= i
; ci
++)
766 int curr
= wdcache
[ci
];
781 close_diag (char const *name
)
783 if (ignore_failed_read_option
)
790 open_diag (char const *name
)
792 if (ignore_failed_read_option
)
799 read_diag_details (char const *name
, off_t offset
, size_t size
)
801 if (ignore_failed_read_option
)
802 read_warn_details (name
, offset
, size
);
804 read_error_details (name
, offset
, size
);
808 readlink_diag (char const *name
)
810 if (ignore_failed_read_option
)
811 readlink_warn (name
);
813 readlink_error (name
);
817 savedir_diag (char const *name
)
819 if (ignore_failed_read_option
)
822 savedir_error (name
);
826 seek_diag_details (char const *name
, off_t offset
)
828 if (ignore_failed_read_option
)
829 seek_warn_details (name
, offset
);
831 seek_error_details (name
, offset
);
835 stat_diag (char const *name
)
837 if (ignore_failed_read_option
)
844 file_removed_diag (const char *name
, bool top_level
,
845 void (*diagfn
) (char const *name
))
847 if (!top_level
&& errno
== ENOENT
)
849 WARNOPT (WARN_FILE_REMOVED
,
850 (0, 0, _("%s: File removed before we read it"),
851 quotearg_colon (name
)));
852 set_exit_status (TAREXIT_DIFFERS
);
859 write_fatal_details (char const *name
, ssize_t status
, size_t size
)
861 write_error_details (name
, status
, size
);
865 /* Fork, aborting if unsuccessful. */
871 call_arg_fatal ("fork", _("child process"));
875 /* Create a pipe, aborting if unsuccessful. */
880 call_arg_fatal ("pipe", _("interprocess channel"));
883 /* Return PTR, aligned upward to the next multiple of ALIGNMENT.
884 ALIGNMENT must be nonzero. The caller must arrange for ((char *)
885 PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
889 ptr_align (void *ptr
, size_t alignment
)
892 char *p1
= p0
+ alignment
- 1;
893 return p1
- (size_t) p1
% alignment
;
896 /* Return the address of a page-aligned buffer of at least SIZE bytes.
897 The caller should free *PTR when done with the buffer. */
900 page_aligned_alloc (void **ptr
, size_t size
)
902 size_t alignment
= getpagesize ();
903 size_t size1
= size
+ alignment
;
906 *ptr
= xmalloc (size1
);
907 return ptr_align (*ptr
, alignment
);
914 char *buffer
; /* directory, `/', and directory member */
915 size_t buffer_size
; /* allocated size of name_buffer */
916 size_t dir_length
; /* length of directory part in buffer */
920 namebuf_create (const char *dir
)
922 namebuf_t buf
= xmalloc (sizeof (*buf
));
923 buf
->buffer_size
= strlen (dir
) + 2;
924 buf
->buffer
= xmalloc (buf
->buffer_size
);
925 strcpy (buf
->buffer
, dir
);
926 buf
->dir_length
= strlen (buf
->buffer
);
927 if (!ISSLASH (buf
->buffer
[buf
->dir_length
- 1]))
928 buf
->buffer
[buf
->dir_length
++] = DIRECTORY_SEPARATOR
;
933 namebuf_free (namebuf_t buf
)
940 namebuf_name (namebuf_t buf
, const char *name
)
942 size_t len
= strlen (name
);
943 while (buf
->dir_length
+ len
+ 1 >= buf
->buffer_size
)
944 buf
->buffer
= x2realloc (buf
->buffer
, &buf
->buffer_size
);
945 strcpy (buf
->buffer
+ buf
->dir_length
, name
);