X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmisc.c;h=1cf0c3b666054da93446f44ae94dff1ae53dc3c0;hb=ecbcb7b6d74c2d69386c8d7e435486a4690c9993;hp=3e7941d18b883df3372110e27692e7063c384d93;hpb=f6edb92580aa886a2a0189463c19189a050dc62d;p=chaz%2Ftar diff --git a/src/misc.c b/src/misc.c index 3e7941d..1cf0c3b 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 Free Software Foundation, Inc. + 2003, 2004, 2005, 2006, 2007, 2009, 2010 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 @@ -24,14 +24,6 @@ #include #include #include -#include - -#if HAVE_STROPTS_H -# include -#endif -#if HAVE_SYS_FILIO_H -# include -#endif #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0 @@ -50,6 +42,9 @@ assign_string (char **string, const char *value) *string = value ? xstrdup (value) : 0; } +#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 @@ -62,7 +57,7 @@ assign_string (char **string, const char *value) when reading directory files. This means that we can't use quotearg, as quotearg is locale-dependent and is meant for human consumption. */ -char * +static char * quote_copy_string (const char *string) { const char *source = string; @@ -103,6 +98,7 @@ quote_copy_string (const char *string) } 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 @@ -233,99 +229,79 @@ zap_slashes (char *name) return name; } -/* Normalize NAME by resolving any relative references and - removing trailing slashes. Destructive version: modifies its argument. */ -static int -normalize_filename_x (char *name) -{ - char *p, *q; - - p = name; - if (DOUBLE_SLASH_IS_DISTINCT_ROOT && ISSLASH (*p)) - p++; - - /* Remove /./, resolve /../ and compress sequences of slashes */ - for (q = p; *q; ) +/* 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 +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) { - if (ISSLASH (*q)) - { - *p++ = *q++; - while (ISSLASH (*q)) - q++; - continue; - } - else if (p == name) - { - if (*q == '.') - { - if (ISSLASH (q[1])) - { - q += 2; - continue; - } - if (q[1] == '.' && ISSLASH (q[2])) - return 1; - } - } - else - { - if (*q == '.' && ISSLASH (p[-1])) - { - if (ISSLASH (q[1])) - { - q += 2; - while (ISSLASH (*q)) - q++; - continue; - } - else if (q[1] == '.' && ISSLASH (q[2])) - { - do - { - --p; - } - while (p > name && !ISSLASH (p[-1])); - q += 3; - continue; - } - } - } - *p++ = *q++; + p -= p[-2] == '.' && ISSLASH (p[-3]); + p -= 2 < p - name && ISSLASH (p[-2]); + p[-1] = '\0'; } - - /* Remove trailing slashes */ - while (p - 1 > name && ISSLASH (p[-1])) - p--; - - *p = 0; - return 0; } -/* Normalize NAME by resolving any relative references, removing trailing - slashes, and converting it to absolute file name. Return the normalized - name, or NULL in case of error. */ +/* Normalize NAME by removing redundant slashes and "." components, + including redundant trailing slashes. Return a normalized + newly-allocated copy. */ char * normalize_filename (const char *name) { - char *copy; + char *copy = NULL; - if (name[0] != '/') + if (IS_RELATIVE_FILE_NAME (name)) { - copy = xgetcwd (); - copy = xrealloc (copy, strlen (copy) + strlen (name) + 2); + /* Set COPY to the absolute file name if possible. - strcat (copy, "/"); - strcat (copy, 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"))); } - else + + if (! copy) copy = xstrdup (name); - if (normalize_filename_x (copy)) - { - free (copy); - return NULL; - } - return xrealloc (copy, strlen (copy) + 1); + normalize_filename_x (copy); + return copy; } @@ -637,31 +613,44 @@ deref_stat (bool deref, char const *name, struct stat *buf) return deref ? stat (name, buf) : lstat (name, buf); } -/* Set FD's (i.e., FILE's) access time to TIMESPEC[0]. If that's not - possible to do by itself, set its access and data modification - times to TIMESPEC[0] and TIMESPEC[1], respectively. */ +/* Use futimens if possible, utimensat otherwise. */ int -set_file_atime (int fd, char const *file, struct timespec const timespec[2]) +fd_utimensat (int fd, int parentfd, char const *file, + struct timespec const ts[2], int atflag) { -#ifdef _FIOSATIME if (0 <= fd) { - struct timeval timeval; - timeval.tv_sec = timespec[0].tv_sec; - timeval.tv_usec = timespec[0].tv_nsec / 1000; - if (ioctl (fd, _FIOSATIME, &timeval) == 0) - return 0; + int result = futimens (fd, ts); + if (! (result < 0 && errno == ENOSYS)) + return result; } -#endif - return gl_futimens (fd, file, timespec); + return utimensat (parentfd, file, ts, atflag); +} + +/* Set FD's (i.e., FILE's) access time to ATIME. + ATFLAG controls symbolic-link following, in the style of openat. */ +int +set_file_atime (int fd, char const *file, struct timespec atime, int atflag) +{ + struct timespec ts[2]; + ts[0] = atime; + ts[1].tv_nsec = UTIME_OMIT; + return fd_utimensat (fd, AT_FDCWD, file, ts, atflag); } /* A description of a working directory. */ struct wd { + /* The directory's name. */ char const *name; - int saved; + + /* A negative value if no attempt has been made to save the + directory, 0 if it was saved successfully, and a positive errno + value if it was not saved successfully. */ + int err; + + /* The saved version of the directory, if ERR == 0. */ struct saved_cwd saved_cwd; }; @@ -700,7 +689,7 @@ chdir_arg (char const *dir) if (! wd_count) { wd[wd_count].name = "."; - wd[wd_count].saved = 0; + wd[wd_count].err = -1; wd_count++; } } @@ -717,28 +706,28 @@ chdir_arg (char const *dir) } wd[wd_count].name = dir; - wd[wd_count].saved = 0; + wd[wd_count].err = -1; return wd_count++; } +/* Index of current directory. */ +int chdir_current; + /* Change to directory I. If I is 0, change to the initial working directory; otherwise, I must be a value returned by chdir_arg. */ void chdir_do (int i) { - static int previous; - - if (previous != i) + if (chdir_current != i) { - struct wd *prev = &wd[previous]; + struct wd *prev = &wd[chdir_current]; struct wd *curr = &wd[i]; - if (! prev->saved) + if (prev->err < 0) { - int err = 0; - prev->saved = 1; + prev->err = 0; if (save_cwd (&prev->saved_cwd) != 0) - err = errno; + prev->err = errno; else if (0 <= prev->saved_cwd.desc) { /* Make sure we still have at least one descriptor available. */ @@ -752,19 +741,21 @@ chdir_do (int i) close (fd1); prev->saved_cwd.desc = -1; prev->saved_cwd.name = xgetcwd (); + if (! prev->saved_cwd.name) + prev->err = errno; } else - err = errno; + prev->err = errno; } - - if (err) - FATAL_ERROR ((0, err, _("Cannot save working directory"))); } - if (curr->saved) + if (0 <= curr->err) { - if (restore_cwd (&curr->saved_cwd)) - FATAL_ERROR ((0, 0, _("Cannot change working directory"))); + int err = curr->err; + if (err == 0 && restore_cwd (&curr->saved_cwd) != 0) + err = errno; + if (err) + FATAL_ERROR ((0, err, _("Cannot restore working directory"))); } else { @@ -774,7 +765,7 @@ chdir_do (int i) chdir_fatal (curr->name); } - previous = i; + chdir_current = i; } }