X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmisc.c;h=0424ea7cc2f9a582805a99e6463ce042cf68d626;hb=3125d311e17c91da85de3bca326cf485523d78a0;hp=3add37188903ff2d0f194b81ec8c8ce8c3ceed8c;hpb=03858cf583ce299b836d8a848967ce290a6bf303;p=chaz%2Ftar
diff --git a/src/misc.c b/src/misc.c
index 3add371..0424ea7 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -1,7 +1,7 @@
/* Miscellaneous functions, not really specific to GNU tar.
- Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001,
- 2003, 2004, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+ Copyright 1988, 1992, 1994-1997, 1999-2001, 2003-2007, 2009-2010,
+ 2012-2013 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
@@ -14,9 +14,9 @@
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.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
+ with this program. If not, see . */
+#define COMMON_INLINE _GL_EXTERN_INLINE
#include
#include
#include "common.h"
@@ -105,7 +105,7 @@ quote_copy_string (const char *string)
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).
+ 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. */
@@ -229,11 +229,12 @@ zap_slashes (char *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. */
-static void
+ 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);
@@ -267,37 +268,39 @@ normalize_filename_x (char *file_name)
}
/* Normalize NAME by removing redundant slashes and "." components,
- including redundant trailing slashes. Return a normalized
- newly-allocated copy. */
+ including redundant trailing slashes.
+
+ Return a normalized newly-allocated copy. */
char *
-normalize_filename (const char *name)
+normalize_filename (int cdidx, const char *name)
{
char *copy = NULL;
if (IS_RELATIVE_FILE_NAME (name))
{
- /* Set COPY to the absolute file name if possible.
+ /* Set COPY to the absolute path for this name.
FIXME: There should be no need to get the absolute file name.
- getcwd is slow, it might fail, and it does not necessarily
- return a canonical name even when it succeeds. Perhaps we
- can use dev+ino pairs instead of names? */
- copy = xgetcwd ();
- if (copy)
- {
- size_t copylen = strlen (copy);
- bool need_separator = ! (DOUBLE_SLASH_IS_DISTINCT_ROOT
- && copylen == 2 && ISSLASH (copy[1]));
- copy = xrealloc (copy, copylen + need_separator + strlen (name) + 1);
- copy[copylen] = DIRECTORY_SEPARATOR;
- strcpy (copy + copylen + need_separator, name);
- }
- else
- WARN ((0, errno, _("Cannot get working directory")));
+ 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;
+
+ 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 (! copy)
+ if (!copy)
copy = xstrdup (name);
normalize_filename_x (copy);
return copy;
@@ -325,6 +328,76 @@ replace_prefix (char **pname, const char *samp, size_t slen,
/* 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
+ {
+ intmax_t i = value - minval;
+ return imaxtostr (i + minval, buf);
+ }
+}
+
+/* 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. */
@@ -381,6 +454,84 @@ code_timespec (struct timespec t, char sbuf[TIMESPEC_STRSIZE_BOUND])
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;
+}
/* File handling. */
@@ -483,7 +634,7 @@ remove_any_file (const char *file_name, enum remove_option option)
case RECURSIVE_REMOVE_OPTION:
{
- char *directory = savedir (file_name);
+ char *directory = tar_savedir (file_name, 0);
char const *entry;
size_t entrylen;
@@ -683,7 +834,10 @@ 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). */
+ 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. */
@@ -713,7 +867,7 @@ static int wdcache[CHDIR_CACHE_SIZE];
static size_t wdcache_count;
int
-chdir_count ()
+chdir_count (void)
{
if (wd_count == 0)
return wd_count;
@@ -738,6 +892,7 @@ chdir_arg (char const *dir)
if (! wd_count)
{
wd[wd_count].name = ".";
+ wd[wd_count].abspath = xgetcwd ();
wd[wd_count].fd = AT_FDCWD;
wd_count++;
}
@@ -755,6 +910,17 @@ chdir_arg (char const *dir)
}
wd[wd_count].name = dir;
+ /* if the given name is an absolute path, then use that path
+ to represent this working directory; otherwise, construct
+ a path based on the previous -C option's absolute path */
+ if (IS_ABSOLUTE_FILE_NAME (wd[wd_count].name))
+ wd[wd_count].abspath = xstrdup (wd[wd_count].name);
+ else
+ {
+ namebuf_t nbuf = namebuf_create (wd[wd_count - 1].abspath);
+ namebuf_add_dir (nbuf, wd[wd_count].name);
+ wd[wd_count].abspath = namebuf_finish (nbuf);
+ }
wd[wd_count].fd = 0;
return wd_count++;
}
@@ -814,11 +980,11 @@ chdir_do (int i)
int prev = wdcache[0];
for (ci = 1; prev != i; ci++)
{
- int curr = wdcache[ci];
+ int cur = wdcache[ci];
wdcache[ci] = prev;
- if (curr == i)
+ if (cur == i)
break;
- prev = curr;
+ prev = cur;
}
wdcache[0] = i;
}
@@ -828,6 +994,32 @@ chdir_do (int i)
}
}
+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.) */
+const char *
+tar_getcdpath (int idx)
+{
+ if (!wd)
+ {
+ static char *cwd;
+ if (!cwd)
+ cwd = xgetcwd ();
+ return cwd;
+ }
+ return wd[idx].abspath;
+}
+
void
close_diag (char const *name)
{
@@ -962,7 +1154,7 @@ page_aligned_alloc (void **ptr, size_t size)
struct namebuf
{
- char *buffer; /* directory, `/', and directory member */
+ 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 */
};
@@ -996,3 +1188,55 @@ namebuf_name (namebuf_t buf, const char *name)
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;
+}