/* Miscellaneous functions, not really specific to GNU tar.
- Copyright (C) 1988, 92, 94, 95, 96, 97 Free Software Foundation, Inc.
+
+ Copyright 1988, 1992, 1994-1997, 1999-2001, 2003-2007, 2009-2010,
+ 2012-2014 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
- Free Software Foundation; either version 2, or (at your option) any later
+ Free Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
Public License for more details.
You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 59 Place - Suite 330, Boston, MA 02111-1307, USA. */
+ with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#define COMMON_INLINE _GL_EXTERN_INLINE
+#include <system.h>
+#include <rmt.h>
+#include "common.h"
+#include <quotearg.h>
+#include <xgetcwd.h>
+#include <unlinkdir.h>
+#include <utimens.h>
-#include "system.h"
+#ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
+# define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
+#endif
-#include "backupfile.h"
-#include "rmt.h"
+static const char *tar_getcdpath (int);
-/* The following inclusion for crosschecking prototypes, only. */
-#include "common.h"
\f
/* Handling strings. */
-#define ISPRINT(Char) (ISASCII (Char) && isprint (Char))
-
-/*-------------------------------------------------------------------------.
-| Assign STRING to a copy of VALUE if not NULL, or to NULL. If STRING was |
-| not NULL, it is freed first. |
-`-------------------------------------------------------------------------*/
-
+/* Assign STRING to a copy of VALUE if not zero, or to zero. If
+ STRING was nonzero, it is freed first. */
void
assign_string (char **string, const char *value)
{
- if (*string)
- free (*string);
- *string = value ? xstrdup (value) : NULL;
+ free (*string);
+ *string = value ? xstrdup (value) : 0;
}
-/*------------------------------------------------------------------------.
-| Allocate a copy of the string quoted as in C, and returns that. If the |
-| string does not have to be quoted, it returns the NULL string. The |
-| allocated copy should normally be freed with free() after the caller is |
-| done with it. |
-| |
-| This is used in two contexts only: either listing a tar file for the |
-| --list (-t) option, or generating the directory file in incremental |
-| dumps. |
-`------------------------------------------------------------------------*/
-
-char *
+#if 0
+/* This function is currently unused; perhaps it should be removed? */
+
+/* Allocate a copy of the string quoted as in C, and returns that. If
+ the string does not have to be quoted, it returns a null pointer.
+ The allocated copy should normally be freed with free() after the
+ caller is done with it.
+
+ This is used in one context only: generating the directory file in
+ incremental dumps. The quoted string is not intended for human
+ consumption; it is intended only for unquote_string. The quoting
+ is locale-independent, so that users needn't worry about locale
+ when reading directory files. This means that we can't use
+ quotearg, as quotearg is locale-dependent and is meant for human
+ consumption. */
+static char *
quote_copy_string (const char *string)
{
const char *source = string;
- char *destination = NULL;
- char *buffer = NULL;
+ char *destination = 0;
+ char *buffer = 0;
int copying = 0;
while (*source)
{
- int character = (unsigned char) *source++;
+ int character = *source++;
- if (character == '\\')
+ switch (character)
{
+ case '\n': case '\\':
if (!copying)
{
- int length = (source - string) - 1;
+ size_t length = (source - string) - 1;
copying = 1;
- buffer = (char *) xmalloc (length + 5 + strlen (source) * 4);
- memcpy (buffer, string, (size_t) length);
+ buffer = xmalloc (length + 2 + 2 * strlen (source) + 1);
+ memcpy (buffer, string, length);
destination = buffer + length;
}
*destination++ = '\\';
- *destination++ = '\\';
- }
- else if (ISPRINT (character))
- {
+ *destination++ = character == '\\' ? '\\' : 'n';
+ break;
+
+ default:
if (copying)
*destination++ = character;
- }
- else
- {
- if (!copying)
- {
- int length = (source - string) - 1;
-
- copying = 1;
- buffer = (char *) xmalloc (length + 5 + strlen (source) * 4);
- memcpy (buffer, string, (size_t) length);
- destination = buffer + length;
- }
- *destination++ = '\\';
- switch (character)
- {
- case '\n':
- *destination++ = 'n';
- break;
-
- case '\t':
- *destination++ = 't';
- break;
-
- case '\f':
- *destination++ = 'f';
- break;
-
- case '\b':
- *destination++ = 'b';
- break;
-
- case '\r':
- *destination++ = 'r';
- break;
-
- case '\177':
- *destination++ = '?';
- break;
-
- default:
- *destination++ = (character >> 6) + '0';
- *destination++ = ((character >> 3) & 07) + '0';
- *destination++ = (character & 07) + '0';
- break;
- }
+ break;
}
}
if (copying)
*destination = '\0';
return buffer;
}
- return NULL;
+ return 0;
}
+#endif
-/*-------------------------------------------------------------------------.
-| Takes a quoted C string (like those produced by quote_copy_string) and |
-| turns it back into the un-quoted original. This is done in place. |
-| Returns 0 only if the string was not properly quoted, but completes the |
-| unquoting anyway. |
-| |
-| This is used for reading the saved directory file in incremental dumps. |
-| It is used for decoding old `N' records (demangling names). But also, |
-| it is used for decoding file arguments, would they come from the shell |
-| or a -T file, and for decoding the --exclude argument. |
-`-------------------------------------------------------------------------*/
+/* Takes a quoted C string (like those produced by quote_copy_string)
+ and turns it back into the un-quoted original. This is done in
+ place. Returns 0 only if the string was not properly quoted, but
+ completes the unquoting anyway.
+ This is used for reading the saved directory file in incremental
+ dumps. It is used for decoding old 'N' records (demangling names).
+ But also, it is used for decoding file arguments, would they come
+ from the shell or a -T file, and for decoding the --exclude
+ argument. */
int
unquote_string (char *string)
{
char *source = string;
char *destination = string;
+ /* Escape sequences other than \\ and \n are no longer generated by
+ quote_copy_string, but accept them for backwards compatibility,
+ and also because unquote_string is used for purposes other than
+ parsing the output of quote_copy_string. */
+
while (*source)
if (*source == '\\')
switch (*++source)
source++;
break;
- case 'n':
- *destination++ = '\n';
+ case 'a':
+ *destination++ = '\a';
source++;
break;
- case 't':
- *destination++ = '\t';
+ case 'b':
+ *destination++ = '\b';
source++;
break;
source++;
break;
- case 'b':
- *destination++ = '\b';
+ case 'n':
+ *destination++ = '\n';
source++;
break;
source++;
break;
+ case 't':
+ *destination++ = '\t';
+ source++;
+ break;
+
+ case 'v':
+ *destination++ = '\v';
+ source++;
+ break;
+
case '?':
*destination++ = 0177;
source++;
*destination = '\0';
return result;
}
-\f
-/* Sorting lists. */
-/*---.
-| ? |
-`---*/
+/* Zap trailing slashes. */
+char *
+zap_slashes (char *name)
+{
+ char *q;
+
+ if (!name || *name == 0)
+ return name;
+ q = name + strlen (name) - 1;
+ while (q > name && ISSLASH (*q))
+ *q-- = '\0';
+ return name;
+}
+
+/* Normalize FILE_NAME by removing redundant slashes and "."
+ components, including redundant trailing slashes.
+ Leave ".." alone, as it may be significant in the presence
+ of symlinks and on platforms where "/.." != "/".
+
+ Destructive version: modifies its argument. */
+void
+normalize_filename_x (char *file_name)
+{
+ char *name = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
+ char *p;
+ char const *q;
+ char c;
+
+ /* Don't squeeze leading "//" to "/", on hosts where they're distinct. */
+ name += (DOUBLE_SLASH_IS_DISTINCT_ROOT
+ && ISSLASH (*name) && ISSLASH (name[1]) && ! ISSLASH (name[2]));
+
+ /* Omit redundant leading "." components. */
+ for (q = p = name; (*p = *q) == '.' && ISSLASH (q[1]); p += !*q)
+ for (q += 2; ISSLASH (*q); q++)
+ continue;
+
+ /* Copy components from Q to P, omitting redundant slashes and
+ internal "." components. */
+ while ((*p++ = c = *q++) != '\0')
+ if (ISSLASH (c))
+ while (ISSLASH (q[*q == '.']))
+ q += (*q == '.') + 1;
+
+ /* Omit redundant trailing "." component and slash. */
+ if (2 < p - name)
+ {
+ p -= p[-2] == '.' && ISSLASH (p[-3]);
+ p -= 2 < p - name && ISSLASH (p[-2]);
+ p[-1] = '\0';
+ }
+}
+
+/* Normalize NAME by removing redundant slashes and "." components,
+ including redundant trailing slashes.
+
+ Return a normalized newly-allocated copy. */
char *
-merge_sort (char *list, int length, int offset, int (*compare) (char *, char *))
+normalize_filename (int cdidx, const char *name)
{
- char *first_list;
- char *second_list;
- int first_length;
- int second_length;
- char *result;
- char **merge_point;
- char *cursor;
- int counter;
+ char *copy = NULL;
-#define SUCCESSOR(Pointer) \
- (*((char **) (((char *) (Pointer)) + offset)))
+ if (IS_RELATIVE_FILE_NAME (name))
+ {
+ /* Set COPY to the absolute path for this name.
+
+ FIXME: There should be no need to get the absolute file name.
+ tar_getcdpath does not return a true "canonical" path, so
+ this following approach may lead to situations where the same
+ file or directory is processed twice under different absolute
+ paths without that duplication being detected. Perhaps we
+ should use dev+ino pairs instead of names? */
+ const char *cdpath = tar_getcdpath (cdidx);
+ size_t copylen;
+ bool need_separator;
+
+ if (!cdpath)
+ call_arg_fatal ("getcwd", ".");
+ copylen = strlen (cdpath);
+ need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
+ && copylen == 2 && ISSLASH (cdpath[1]));
+ copy = xmalloc (copylen + need_separator + strlen (name) + 1);
+ strcpy (copy, cdpath);
+ copy[copylen] = DIRECTORY_SEPARATOR;
+ strcpy (copy + copylen + need_separator, name);
+ }
- if (length == 1)
- return list;
+ if (!copy)
+ copy = xstrdup (name);
+ normalize_filename_x (copy);
+ return copy;
+}
- if (length == 2)
+\f
+void
+replace_prefix (char **pname, const char *samp, size_t slen,
+ const char *repl, size_t rlen)
+{
+ char *name = *pname;
+ size_t nlen = strlen (name);
+ if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
{
- if ((*compare) (list, SUCCESSOR (list)) > 0)
+ if (rlen > slen)
{
- result = SUCCESSOR (list);
- SUCCESSOR (result) = list;
- SUCCESSOR (list) = NULL;
- return result;
+ name = xrealloc (name, nlen - slen + rlen + 1);
+ *pname = name;
}
- return list;
+ memmove (name + rlen, name + slen, nlen - slen + 1);
+ memcpy (name, repl, rlen);
}
+}
- first_list = list;
- first_length = (length + 1) / 2;
- second_length = length / 2;
- for (cursor = list, counter = first_length - 1;
- counter;
- cursor = SUCCESSOR (cursor), counter--)
- continue;
- second_list = SUCCESSOR (cursor);
- SUCCESSOR (cursor) = NULL;
-
- first_list = merge_sort (first_list, first_length, offset, compare);
- second_list = merge_sort (second_list, second_length, offset, compare);
-
- merge_point = &result;
- while (first_list && second_list)
- if ((*compare) (first_list, second_list) < 0)
- {
- cursor = SUCCESSOR (first_list);
- *merge_point = first_list;
- merge_point = &SUCCESSOR (first_list);
- first_list = cursor;
- }
- else
- {
- cursor = SUCCESSOR (second_list);
- *merge_point = second_list;
- merge_point = &SUCCESSOR (second_list);
- second_list = cursor;
- }
- if (first_list)
- *merge_point = first_list;
+\f
+/* Handling numbers. */
+
+/* Convert VALUE, which is converted from a system integer type whose
+ minimum value is MINVAL and maximum MINVAL, to an decimal
+ integer string. Use the storage in BUF and return a pointer to the
+ converted string. If VALUE is converted from a negative integer in
+ the range MINVAL .. -1, represent it with a string representation
+ of the negative integer, using leading '-'. */
+#if ! (INTMAX_MAX <= UINTMAX_MAX / 2)
+# error "sysinttostr: uintmax_t cannot represent all intmax_t values"
+#endif
+char *
+sysinttostr (uintmax_t value, intmax_t minval, uintmax_t maxval,
+ char buf[SYSINT_BUFSIZE])
+{
+ if (value <= maxval)
+ return umaxtostr (value, buf);
else
- *merge_point = second_list;
+ {
+ intmax_t i = value - minval;
+ return imaxtostr (i + minval, buf);
+ }
+}
- return result;
+/* Convert a prefix of the string ARG to a system integer type whose
+ minimum value is MINVAL and maximum MAXVAL. If MINVAL is negative,
+ negative integers MINVAL .. -1 are assumed to be represented using
+ leading '-' in the usual way. If the represented value exceeds
+ INTMAX_MAX, return a negative integer V such that (uintmax_t) V
+ yields the represented value. If ARGLIM is nonnull, store into
+ *ARGLIM a pointer to the first character after the prefix.
+
+ This is the inverse of sysinttostr.
+
+ On a normal return, set errno = 0.
+ On conversion error, return 0 and set errno = EINVAL.
+ On overflow, return an extreme value and set errno = ERANGE. */
+#if ! (INTMAX_MAX <= UINTMAX_MAX)
+# error "strtosysint: nonnegative intmax_t does not fit in uintmax_t"
+#endif
+intmax_t
+strtosysint (char const *arg, char **arglim, intmax_t minval, uintmax_t maxval)
+{
+ errno = 0;
+ if (maxval <= INTMAX_MAX)
+ {
+ if (ISDIGIT (arg[*arg == '-']))
+ {
+ intmax_t i = strtoimax (arg, arglim, 10);
+ intmax_t imaxval = maxval;
+ if (minval <= i && i <= imaxval)
+ return i;
+ errno = ERANGE;
+ return i < minval ? minval : maxval;
+ }
+ }
+ else
+ {
+ if (ISDIGIT (*arg))
+ {
+ uintmax_t i = strtoumax (arg, arglim, 10);
+ if (i <= maxval)
+ return represent_uintmax (i);
+ errno = ERANGE;
+ return maxval;
+ }
+ }
+
+ errno = EINVAL;
+ return 0;
+}
+
+/* Output fraction and trailing digits appropriate for a nanoseconds
+ count equal to NS, but don't output unnecessary '.' or trailing
+ zeros. */
-#undef SUCCESSOR
+void
+code_ns_fraction (int ns, char *p)
+{
+ if (ns == 0)
+ *p = '\0';
+ else
+ {
+ int i = 9;
+ *p++ = '.';
+
+ while (ns % 10 == 0)
+ {
+ ns /= 10;
+ i--;
+ }
+
+ p[i] = '\0';
+
+ for (;;)
+ {
+ p[--i] = '0' + ns % 10;
+ if (i == 0)
+ break;
+ ns /= 10;
+ }
+ }
+}
+
+char const *
+code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
+{
+ time_t s = t.tv_sec;
+ int ns = t.tv_nsec;
+ char *np;
+ bool negative = s < 0;
+
+ /* ignore invalid values of ns */
+ if (BILLION <= ns || ns < 0)
+ ns = 0;
+
+ if (negative && ns != 0)
+ {
+ s++;
+ ns = BILLION - ns;
+ }
+
+ np = umaxtostr (negative ? - (uintmax_t) s : (uintmax_t) s, sbuf + 1);
+ if (negative)
+ *--np = '-';
+ code_ns_fraction (ns, sbuf + UINTMAX_STRSIZE_BOUND);
+ return np;
+}
+
+struct timespec
+decode_timespec (char const *arg, char **arg_lim, bool parse_fraction)
+{
+ time_t s = TYPE_MINIMUM (time_t);
+ int ns = -1;
+ char const *p = arg;
+ bool negative = *arg == '-';
+ struct timespec r;
+
+ if (! ISDIGIT (arg[negative]))
+ errno = EINVAL;
+ else
+ {
+ errno = 0;
+
+ if (negative)
+ {
+ intmax_t i = strtoimax (arg, arg_lim, 10);
+ if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i : 0 <= i)
+ s = i;
+ else
+ errno = ERANGE;
+ }
+ else
+ {
+ uintmax_t i = strtoumax (arg, arg_lim, 10);
+ if (i <= TYPE_MAXIMUM (time_t))
+ s = i;
+ else
+ errno = ERANGE;
+ }
+
+ p = *arg_lim;
+ ns = 0;
+
+ if (parse_fraction && *p == '.')
+ {
+ int digits = 0;
+ bool trailing_nonzero = false;
+
+ while (ISDIGIT (*++p))
+ if (digits < LOG10_BILLION)
+ digits++, ns = 10 * ns + (*p - '0');
+ else
+ trailing_nonzero |= *p != '0';
+
+ while (digits < LOG10_BILLION)
+ digits++, ns *= 10;
+
+ if (negative)
+ {
+ /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
+ I.e., truncate time stamps towards minus infinity while
+ converting them to internal form. */
+ ns += trailing_nonzero;
+ if (ns != 0)
+ {
+ if (s == TYPE_MINIMUM (time_t))
+ ns = -1;
+ else
+ {
+ s--;
+ ns = BILLION - ns;
+ }
+ }
+ }
+ }
+
+ if (errno == ERANGE)
+ ns = -1;
+ }
+
+ *arg_lim = (char *) p;
+ r.tv_sec = s;
+ r.tv_nsec = ns;
+ return r;
}
\f
/* File handling. */
/* Saved names in case backup needs to be undone. */
-static char *before_backup_name = NULL;
-static char *after_backup_name = NULL;
+static char *before_backup_name;
+static char *after_backup_name;
-/*------------------------------------------------------------------------.
-| Returns nonzero if p is `.' or `..'. This could be a macro for speed. |
-`------------------------------------------------------------------------*/
+/* Return 1 if FILE_NAME is obviously "." or "/". */
+bool
+must_be_dot_or_slash (char const *file_name)
+{
+ file_name += FILE_SYSTEM_PREFIX_LEN (file_name);
-/* Early Solaris 2.4 readdir may return d->d_name as `' in NFS-mounted
- directories. The workaround here skips `' just like `.'. Without it,
- GNU tar would then treat `' much like `.' and loop endlessly. */
+ if (ISSLASH (file_name[0]))
+ {
+ for (;;)
+ if (ISSLASH (file_name[1]))
+ file_name++;
+ else if (file_name[1] == '.'
+ && ISSLASH (file_name[2 + (file_name[2] == '.')]))
+ file_name += 2 + (file_name[2] == '.');
+ else
+ return ! file_name[1];
+ }
+ else
+ {
+ while (file_name[0] == '.' && ISSLASH (file_name[1]))
+ {
+ file_name += 2;
+ while (ISSLASH (*file_name))
+ file_name++;
+ }
-int
-is_dot_or_dotdot (const char *p)
-{
- return (p[0] == '\0'
- || (p[0] == '.' && (p[1] == '\0'
- || (p[1] == '.' && p[2] == '\0'))));
+ return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]);
+ }
}
-/*-------------------------------------------------------------------------.
-| Delete PATH, whatever it might be. If RECURSE, first recursively delete |
-| the contents of PATH when it is a directory. Return zero on any error, |
-| with errno set. As a special case, if we fail to delete a directory |
-| when not RECURSE, do not set errno (just be tolerant to this error). |
-`-------------------------------------------------------------------------*/
+/* Some implementations of rmdir let you remove '.' or '/'.
+ Report an error with errno set to zero for obvious cases of this;
+ otherwise call rmdir. */
+static int
+safer_rmdir (const char *file_name)
+{
+ if (must_be_dot_or_slash (file_name))
+ {
+ errno = 0;
+ return -1;
+ }
+
+ return unlinkat (chdir_fd, file_name, AT_REMOVEDIR);
+}
+/* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
+ then if OPTION is RECURSIVE_REMOVE_OPTION is set remove FILE_NAME
+ recursively; otherwise, remove it only if it is empty. If FILE_NAME is
+ a directory that cannot be removed (e.g., because it is nonempty)
+ and if OPTION is WANT_DIRECTORY_REMOVE_OPTION, then return -1.
+ Return 0 on error, with errno set; if FILE_NAME is obviously the working
+ directory return zero with errno set to zero. */
int
-remove_any_file (const char *path, int recurse)
+remove_any_file (const char *file_name, enum remove_option option)
{
- struct stat stat_buffer;
+ /* Try unlink first if we cannot unlink directories, as this saves
+ us a system call in the common case where we're removing a
+ non-directory. */
+ bool try_unlink_first = cannot_unlink_dir ();
- if (lstat (path, &stat_buffer) < 0)
- return 0;
+ if (try_unlink_first)
+ {
+ if (unlinkat (chdir_fd, file_name, 0) == 0)
+ return 1;
+
+ /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
+ directory without appropriate privileges, but many Linux
+ kernels return the more-sensible EISDIR. */
+ if (errno != EPERM && errno != EISDIR)
+ return 0;
+ }
- if (S_ISDIR (stat_buffer.st_mode))
- if (recurse)
- {
- DIR *dirp = opendir (path);
- struct dirent *dp;
+ if (safer_rmdir (file_name) == 0)
+ return 1;
+
+ switch (errno)
+ {
+ case ENOTDIR:
+ return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0;
+
+ case 0:
+ case EEXIST:
+#if defined ENOTEMPTY && ENOTEMPTY != EEXIST
+ case ENOTEMPTY:
+#endif
+ switch (option)
+ {
+ case ORDINARY_REMOVE_OPTION:
+ break;
- if (dirp == NULL)
- return 0;
+ case WANT_DIRECTORY_REMOVE_OPTION:
+ return -1;
- while (dp = readdir (dirp), dp && !is_dot_or_dotdot (dp->d_name))
+ case RECURSIVE_REMOVE_OPTION:
{
- char *path_buffer = new_name (path, dp->d_name);
+ char *directory = tar_savedir (file_name, 0);
+ char const *entry;
+ size_t entrylen;
- if (!remove_any_file (path_buffer, 1))
- {
- int saved_errno = errno;
+ if (! directory)
+ return 0;
- free (path_buffer);
- closedir (dirp);
- errno = saved_errno; /* FIXME: errno should be read-only */
- return 0;
+ for (entry = directory;
+ (entrylen = strlen (entry)) != 0;
+ entry += entrylen + 1)
+ {
+ char *file_name_buffer = new_name (file_name, entry);
+ int r = remove_any_file (file_name_buffer,
+ RECURSIVE_REMOVE_OPTION);
+ int e = errno;
+ free (file_name_buffer);
+
+ if (! r)
+ {
+ free (directory);
+ errno = e;
+ return 0;
+ }
}
- free (path_buffer);
+
+ free (directory);
+ return safer_rmdir (file_name) == 0;
}
- closedir (dirp);
- return rmdir (path) >= 0;
- }
- else
- {
- /* FIXME: Saving errno might not be needed anymore, now that
- extract_archive tests for the special case before recovery. */
- int saved_errno = errno;
-
- if (rmdir (path) >= 0)
- return 1;
- errno = saved_errno; /* FIXME: errno should be read-only */
- return 0;
- }
+ }
+ break;
+ }
- return unlink (path) >= 0;
+ return 0;
}
-/*-------------------------------------------------------------------------.
-| Check if PATH already exists and make a backup of it right now. Return |
-| success (nonzero) only if the backup in either unneeded, or successful. |
-| |
-| For now, directories are considered to never need backup. If ARCHIVE is |
-| nonzero, this is the archive and so, we do not have to backup block or |
-| character devices, nor remote entities. |
-`-------------------------------------------------------------------------*/
-
-int
-maybe_backup_file (const char *path, int archive)
+/* Check if FILE_NAME already exists and make a backup of it right now.
+ Return success (nonzero) only if the backup is either unneeded, or
+ successful. For now, directories are considered to never need
+ backup. If THIS_IS_THE_ARCHIVE is nonzero, this is the archive and
+ so, we do not have to backup block or character devices, nor remote
+ entities. */
+bool
+maybe_backup_file (const char *file_name, bool this_is_the_archive)
{
struct stat file_stat;
+ assign_string (&before_backup_name, file_name);
+
+ /* A run situation may exist between Emacs or other GNU programs trying to
+ make a backup for the same file simultaneously. If theoretically
+ possible, real problems are unlikely. Doing any better would require a
+ convention, GNU-wide, for all programs doing backups. */
+
+ assign_string (&after_backup_name, 0);
+
/* Check if we really need to backup the file. */
- if (archive && _remdev (path))
- return 1;
+ if (this_is_the_archive && _remdev (file_name))
+ return true;
- if (stat (path, &file_stat))
+ if (deref_stat (file_name, &file_stat) != 0)
{
if (errno == ENOENT)
- return 1;
+ return true;
- ERROR ((0, errno, "%s", path));
- return 0;
+ stat_error (file_name);
+ return false;
}
if (S_ISDIR (file_stat.st_mode))
- return 1;
+ return true;
-#ifdef S_ISBLK
- if (archive && S_ISBLK (file_stat.st_mode))
- return 1;
+ if (this_is_the_archive
+ && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode)))
+ return true;
+
+ after_backup_name = find_backup_file_name (file_name, backup_type);
+ if (! after_backup_name)
+ xalloc_die ();
+
+ if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name)
+ == 0)
+ {
+ if (verbose_option)
+ fprintf (stdlis, _("Renaming %s to %s\n"),
+ quote_n (0, before_backup_name),
+ quote_n (1, after_backup_name));
+ return true;
+ }
+ else
+ {
+ /* The backup operation failed. */
+ int e = errno;
+ ERROR ((0, e, _("%s: Cannot rename to %s"),
+ quotearg_colon (before_backup_name),
+ quote_n (1, after_backup_name)));
+ assign_string (&after_backup_name, 0);
+ return false;
+ }
+}
+
+/* Try to restore the recently backed up file to its original name.
+ This is usually only needed after a failed extraction. */
+void
+undo_last_backup (void)
+{
+ if (after_backup_name)
+ {
+ if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name)
+ != 0)
+ {
+ int e = errno;
+ ERROR ((0, e, _("%s: Cannot rename to %s"),
+ quotearg_colon (after_backup_name),
+ quote_n (1, before_backup_name)));
+ }
+ if (verbose_option)
+ fprintf (stdlis, _("Renaming %s back to %s\n"),
+ quote_n (0, after_backup_name),
+ quote_n (1, before_backup_name));
+ assign_string (&after_backup_name, 0);
+ }
+}
+
+/* Apply either stat or lstat to (NAME, BUF), depending on the
+ presence of the --dereference option. NAME is relative to the
+ most-recent argument to chdir_do. */
+int
+deref_stat (char const *name, struct stat *buf)
+{
+ return fstatat (chdir_fd, name, buf, fstatat_flags);
+}
+
+/* Read from FD into the buffer BUF with COUNT bytes. Attempt to fill
+ BUF. Wait until input is available; this matters because files are
+ opened O_NONBLOCK for security reasons, and on some file systems
+ this can cause read to fail with errno == EAGAIN. Return the
+ actual number of bytes read, zero for EOF, or
+ SAFE_READ_ERROR upon error. */
+size_t
+blocking_read (int fd, void *buf, size_t count)
+{
+ size_t bytes = safe_read (fd, buf, count);
+
+#if defined F_SETFL && O_NONBLOCK
+ if (bytes == SAFE_READ_ERROR && errno == EAGAIN)
+ {
+ int flags = fcntl (fd, F_GETFL);
+ if (0 <= flags && flags & O_NONBLOCK
+ && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
+ bytes = safe_read (fd, buf, count);
+ }
#endif
-#ifdef S_ISCHR
- if (archive && S_ISCHR (file_stat.st_mode))
- return 1;
+ return bytes;
+}
+
+/* Write to FD from the buffer BUF with COUNT bytes. Do a full write.
+ Wait until an output buffer is available; this matters because
+ files are opened O_NONBLOCK for security reasons, and on some file
+ systems this can cause write to fail with errno == EAGAIN. Return
+ the actual number of bytes written, setting errno if that is less
+ than COUNT. */
+size_t
+blocking_write (int fd, void const *buf, size_t count)
+{
+ size_t bytes = full_write (fd, buf, count);
+
+#if defined F_SETFL && O_NONBLOCK
+ if (bytes < count && errno == EAGAIN)
+ {
+ int flags = fcntl (fd, F_GETFL);
+ if (0 <= flags && flags & O_NONBLOCK
+ && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
+ {
+ char const *buffer = buf;
+ bytes += full_write (fd, buffer + bytes, count - bytes);
+ }
+ }
#endif
- assign_string (&before_backup_name, path);
+ return bytes;
+}
- /* A run situation may exist between Emacs or other GNU programs trying to
- make a backup for the same file simultaneously. If theoretically
- possible, real problems are unlikely. Doing any better would require a
- convention, GNU-wide, for all programs doing backups. */
+/* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
+ access time to ATIME. */
+int
+set_file_atime (int fd, int parentfd, char const *file, struct timespec atime)
+{
+ struct timespec ts[2];
+ ts[0] = atime;
+ ts[1].tv_nsec = UTIME_OMIT;
+ return fdutimensat (fd, parentfd, file, ts, fstatat_flags);
+}
- assign_string (&after_backup_name, NULL);
- after_backup_name = find_backup_file_name (path);
- if (after_backup_name == NULL)
- FATAL_ERROR ((0, 0, "Virtual memory exhausted"));
+/* A description of a working directory. */
+struct wd
+{
+ /* The directory's name. */
+ char const *name;
+ /* "Absolute" path representing this directory; in the contrast to
+ the real absolute pathname, it can contain /../ components (see
+ normalize_filename_x for the reason of it). It is NULL if the
+ absolute path could not be determined. */
+ char *abspath;
+ /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
+ the working directory. If zero, the directory needs to be opened
+ to be used. */
+ int fd;
+};
+
+/* A vector of chdir targets. wd[0] is the initial working directory. */
+static struct wd *wd;
+
+/* The number of working directories in the vector. */
+static size_t wd_count;
+
+/* The allocated size of the vector. */
+static size_t wd_alloc;
+
+/* The maximum number of chdir targets with open directories.
+ Don't make it too large, as many operating systems have a small
+ limit on the number of open file descriptors. Also, the current
+ implementation does not scale well. */
+enum { CHDIR_CACHE_SIZE = 16 };
+
+/* Indexes into WD of chdir targets with open file descriptors, sorted
+ most-recently used first. Zero indexes are unused. */
+static int wdcache[CHDIR_CACHE_SIZE];
+
+/* Number of nonzero entries in WDCACHE. */
+static size_t wdcache_count;
- if (rename (before_backup_name, after_backup_name) == 0)
+int
+chdir_count (void)
+{
+ if (wd_count == 0)
+ return wd_count;
+ return wd_count - 1;
+}
+
+/* DIR is the operand of a -C option; add it to vector of chdir targets,
+ and return the index of its location. */
+int
+chdir_arg (char const *dir)
+{
+ char *absdir;
+
+ if (wd_count == wd_alloc)
{
- if (verbose_option)
- fprintf (stdlis, _("Renaming previous `%s' to `%s'\n"),
- before_backup_name, after_backup_name);
- return 1;
+ if (wd_alloc == 0)
+ wd_alloc = 2;
+ wd = x2nrealloc (wd, &wd_alloc, sizeof *wd);
+
+ if (! wd_count)
+ {
+ wd[wd_count].name = ".";
+ wd[wd_count].abspath = xgetcwd ();
+ wd[wd_count].fd = AT_FDCWD;
+ wd_count++;
+ }
}
- /* The backup operation failed. */
+ /* Optimize the common special case of the working directory,
+ or the working directory as a prefix. */
+ if (dir[0])
+ {
+ while (dir[0] == '.' && ISSLASH (dir[1]))
+ for (dir += 2; ISSLASH (*dir); dir++)
+ continue;
+ if (! dir[dir[0] == '.'])
+ return wd_count - 1;
+ }
- ERROR ((0, errno, _("%s: Cannot rename for backup"), before_backup_name));
- assign_string (&after_backup_name, NULL);
- return 0;
+
+ /* If the given name is absolute, use it to represent this directory;
+ otherwise, construct a name based on the previous -C option. */
+ if (IS_ABSOLUTE_FILE_NAME (dir))
+ absdir = xstrdup (dir);
+ else if (wd[wd_count - 1].abspath)
+ {
+ namebuf_t nbuf = namebuf_create (wd[wd_count - 1].abspath);
+ namebuf_add_dir (nbuf, dir);
+ absdir = namebuf_finish (nbuf);
+ }
+ else
+ absdir = 0;
+
+ wd[wd_count].name = dir;
+ wd[wd_count].abspath = absdir;
+ wd[wd_count].fd = 0;
+ return wd_count++;
}
-/*-----------------------------------------------------------------------.
-| Try to restore the recently backed up file to its original name. This |
-| is usually only needed after a failed extraction. |
-`-----------------------------------------------------------------------*/
+/* Index of current directory. */
+int chdir_current;
+/* Value suitable for use as the first argument to openat, and in
+ similar locations for fstatat, etc. This is an open file
+ descriptor, or AT_FDCWD if the working directory is current. It is
+ valid until the next invocation of chdir_do. */
+int chdir_fd = AT_FDCWD;
+
+/* Change to directory I, in a virtual way. This does not actually
+ invoke chdir; it merely sets chdir_fd to an int suitable as the
+ first argument for openat, etc. If I is 0, change to the initial
+ working directory; otherwise, I must be a value returned by
+ chdir_arg. */
void
-undo_last_backup (void)
+chdir_do (int i)
{
- if (after_backup_name)
+ if (chdir_current != i)
{
- if (rename (after_backup_name, before_backup_name) != 0)
- ERROR ((0, errno, _("%s: Cannot rename from backup"),
- before_backup_name));
- if (verbose_option)
- fprintf (stdlis, _("Renaming `%s' back to `%s'\n"),
- after_backup_name, before_backup_name);
- assign_string (&after_backup_name, NULL);
+ struct wd *curr = &wd[i];
+ int fd = curr->fd;
+
+ if (! fd)
+ {
+ if (! IS_ABSOLUTE_FILE_NAME (curr->name))
+ chdir_do (i - 1);
+ fd = openat (chdir_fd, curr->name,
+ open_searchdir_flags & ~ O_NOFOLLOW);
+ if (fd < 0)
+ open_fatal (curr->name);
+
+ curr->fd = fd;
+
+ /* Add I to the cache, tossing out the lowest-ranking entry if the
+ cache is full. */
+ if (wdcache_count < CHDIR_CACHE_SIZE)
+ wdcache[wdcache_count++] = i;
+ else
+ {
+ struct wd *stale = &wd[wdcache[CHDIR_CACHE_SIZE - 1]];
+ if (close (stale->fd) != 0)
+ close_diag (stale->name);
+ stale->fd = 0;
+ wdcache[CHDIR_CACHE_SIZE - 1] = i;
+ }
+ }
+
+ if (0 < fd)
+ {
+ /* Move the i value to the front of the cache. This is
+ O(CHDIR_CACHE_SIZE), but the cache is small. */
+ size_t ci;
+ int prev = wdcache[0];
+ for (ci = 1; prev != i; ci++)
+ {
+ int cur = wdcache[ci];
+ wdcache[ci] = prev;
+ if (cur == i)
+ break;
+ prev = cur;
+ }
+ wdcache[0] = i;
+ }
+
+ chdir_current = i;
+ chdir_fd = fd;
+ }
+}
+\f
+const char *
+tar_dirname (void)
+{
+ return wd[chdir_current].name;
+}
+
+/* Return the absolute path that represents the working
+ directory referenced by IDX.
+
+ If wd is empty, then there were no -C options given, and
+ chdir_args() has never been called, so we simply return the
+ process's actual cwd. (Note that in this case IDX is ignored,
+ since it should always be 0.) */
+static const char *
+tar_getcdpath (int idx)
+{
+ if (!wd)
+ {
+ static char *cwd;
+ if (!cwd)
+ cwd = xgetcwd ();
+ return cwd;
+ }
+ return wd[idx].abspath;
+}
+\f
+void
+close_diag (char const *name)
+{
+ if (ignore_failed_read_option)
+ close_warn (name);
+ else
+ close_error (name);
+}
+
+void
+open_diag (char const *name)
+{
+ if (ignore_failed_read_option)
+ open_warn (name);
+ else
+ open_error (name);
+}
+
+void
+read_diag_details (char const *name, off_t offset, size_t size)
+{
+ if (ignore_failed_read_option)
+ read_warn_details (name, offset, size);
+ else
+ read_error_details (name, offset, size);
+}
+
+void
+readlink_diag (char const *name)
+{
+ if (ignore_failed_read_option)
+ readlink_warn (name);
+ else
+ readlink_error (name);
+}
+
+void
+savedir_diag (char const *name)
+{
+ if (ignore_failed_read_option)
+ savedir_warn (name);
+ else
+ savedir_error (name);
+}
+
+void
+seek_diag_details (char const *name, off_t offset)
+{
+ if (ignore_failed_read_option)
+ seek_warn_details (name, offset);
+ else
+ seek_error_details (name, offset);
+}
+
+void
+stat_diag (char const *name)
+{
+ if (ignore_failed_read_option)
+ stat_warn (name);
+ else
+ stat_error (name);
+}
+
+void
+file_removed_diag (const char *name, bool top_level,
+ void (*diagfn) (char const *name))
+{
+ if (!top_level && errno == ENOENT)
+ {
+ WARNOPT (WARN_FILE_REMOVED,
+ (0, 0, _("%s: File removed before we read it"),
+ quotearg_colon (name)));
+ set_exit_status (TAREXIT_DIFFERS);
}
+ else
+ diagfn (name);
+}
+
+void
+write_fatal_details (char const *name, ssize_t status, size_t size)
+{
+ write_error_details (name, status, size);
+ fatal_exit ();
+}
+
+/* Fork, aborting if unsuccessful. */
+pid_t
+xfork (void)
+{
+ pid_t p = fork ();
+ if (p == (pid_t) -1)
+ call_arg_fatal ("fork", _("child process"));
+ return p;
+}
+
+/* Create a pipe, aborting if unsuccessful. */
+void
+xpipe (int fd[2])
+{
+ if (pipe (fd) < 0)
+ call_arg_fatal ("pipe", _("interprocess channel"));
+}
+
+/* Return PTR, aligned upward to the next multiple of ALIGNMENT.
+ ALIGNMENT must be nonzero. The caller must arrange for ((char *)
+ PTR) through ((char *) PTR + ALIGNMENT - 1) to be addressable
+ locations. */
+
+static inline void *
+ptr_align (void *ptr, size_t alignment)
+{
+ char *p0 = ptr;
+ char *p1 = p0 + alignment - 1;
+ return p1 - (size_t) p1 % alignment;
+}
+
+/* Return the address of a page-aligned buffer of at least SIZE bytes.
+ The caller should free *PTR when done with the buffer. */
+
+void *
+page_aligned_alloc (void **ptr, size_t size)
+{
+ size_t alignment = getpagesize ();
+ size_t size1 = size + alignment;
+ if (size1 < size)
+ xalloc_die ();
+ *ptr = xmalloc (size1);
+ return ptr_align (*ptr, alignment);
+}
+
+\f
+
+struct namebuf
+{
+ char *buffer; /* directory, '/', and directory member */
+ size_t buffer_size; /* allocated size of name_buffer */
+ size_t dir_length; /* length of directory part in buffer */
+};
+
+namebuf_t
+namebuf_create (const char *dir)
+{
+ namebuf_t buf = xmalloc (sizeof (*buf));
+ buf->buffer_size = strlen (dir) + 2;
+ buf->buffer = xmalloc (buf->buffer_size);
+ strcpy (buf->buffer, dir);
+ buf->dir_length = strlen (buf->buffer);
+ if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
+ buf->buffer[buf->dir_length++] = DIRECTORY_SEPARATOR;
+ return buf;
+}
+
+void
+namebuf_free (namebuf_t buf)
+{
+ free (buf->buffer);
+ free (buf);
+}
+
+char *
+namebuf_name (namebuf_t buf, const char *name)
+{
+ size_t len = strlen (name);
+ while (buf->dir_length + len + 1 >= buf->buffer_size)
+ buf->buffer = x2realloc (buf->buffer, &buf->buffer_size);
+ strcpy (buf->buffer + buf->dir_length, name);
+ return buf->buffer;
+}
+
+void
+namebuf_add_dir (namebuf_t buf, const char *name)
+{
+ static char dirsep[] = { DIRECTORY_SEPARATOR, 0 };
+ if (!ISSLASH (buf->buffer[buf->dir_length - 1]))
+ {
+ namebuf_name (buf, dirsep);
+ buf->dir_length++;
+ }
+ namebuf_name (buf, name);
+ buf->dir_length += strlen (name);
+}
+
+char *
+namebuf_finish (namebuf_t buf)
+{
+ char *res = buf->buffer;
+
+ if (ISSLASH (buf->buffer[buf->dir_length - 1]))
+ buf->buffer[buf->dir_length] = 0;
+ free (buf);
+ return res;
+}
+
+/* Return the filenames in directory NAME, relative to the chdir_fd.
+ If the directory does not exist, report error if MUST_EXIST is
+ true.
+
+ Return NULL on errors.
+*/
+char *
+tar_savedir (const char *name, int must_exist)
+{
+ char *ret = NULL;
+ DIR *dir = NULL;
+ int fd = openat (chdir_fd, name, open_read_flags | O_DIRECTORY);
+ if (fd < 0)
+ {
+ if (!must_exist && errno == ENOENT)
+ return NULL;
+ open_error (name);
+ }
+ else if (! ((dir = fdopendir (fd))
+ && (ret = streamsavedir (dir))))
+ savedir_error (name);
+
+ if (dir ? closedir (dir) != 0 : 0 <= fd && close (fd) != 0)
+ savedir_error (name);
+
+ return ret;
}
projects / chaz / tar / blobdiff