X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmisc.c;h=734dc4eded7adcac4f7a29d84111a0d49306cfb4;hb=4ac671c49ba5df93c2f386bc8d7dbe50f4671a57;hp=f1ebdd4970ae3671fa82ee92d8ae06e3a943bb68;hpb=6e08ab76949954eccd059db0d5da90e011a11c27;p=chaz%2Ftar diff --git a/src/misc.c b/src/misc.c index f1ebdd4..734dc4e 100644 --- a/src/misc.c +++ b/src/misc.c @@ -21,9 +21,9 @@ #include #include "common.h" #include -#include #include #include +#include #ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT # define DOUBLE_SLASH_IS_DISTINCT_ROOT 0 @@ -37,8 +37,7 @@ void assign_string (char **string, const char *value) { - if (*string) - free (*string); + free (*string); *string = value ? xstrdup (value) : 0; } @@ -106,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. */ @@ -431,7 +430,7 @@ safer_rmdir (const char *file_name) return -1; } - return rmdir (file_name); + return unlinkat (chdir_fd, file_name, AT_REMOVEDIR); } /* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory, @@ -451,7 +450,7 @@ remove_any_file (const char *file_name, enum remove_option option) if (try_unlink_first) { - if (unlink (file_name) == 0) + if (unlinkat (chdir_fd, file_name, 0) == 0) return 1; /* POSIX 1003.1-2001 requires EPERM when attempting to unlink a @@ -467,7 +466,7 @@ remove_any_file (const char *file_name, enum remove_option option) switch (errno) { case ENOTDIR: - return !try_unlink_first && unlink (file_name) == 0; + return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0; case 0: case EEXIST: @@ -544,7 +543,7 @@ maybe_backup_file (const char *file_name, bool this_is_the_archive) if (this_is_the_archive && _remdev (file_name)) return true; - if (stat (file_name, &file_stat)) + if (deref_stat (file_name, &file_stat) != 0) { if (errno == ENOENT) return true; @@ -564,7 +563,8 @@ maybe_backup_file (const char *file_name, bool this_is_the_archive) if (! after_backup_name) xalloc_die (); - if (rename (before_backup_name, after_backup_name) == 0) + if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name) + == 0) { if (verbose_option) fprintf (stdlis, _("Renaming %s to %s\n"), @@ -591,7 +591,8 @@ undo_last_backup (void) { if (after_backup_name) { - if (rename (after_backup_name, before_backup_name) != 0) + if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name) + != 0) { int e = errno; ERROR ((0, e, _("%s: Cannot rename to %s"), @@ -606,39 +607,75 @@ undo_last_backup (void) } } -/* Depending on DEREF, apply either stat or lstat to (NAME, BUF). */ +/* 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 (bool deref, char const *name, struct stat *buf) +deref_stat (char const *name, struct stat *buf) { - return deref ? stat (name, buf) : lstat (name, buf); + return fstatat (chdir_fd, name, buf, fstatat_flags); } -/* Use futimens if possible, utimensat otherwise. */ -int -fd_utimensat (int fd, int parentfd, char const *file, - struct timespec const ts[2], int atflag) +/* 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) { - if (0 <= fd) + size_t bytes = safe_read (fd, buf, count); + +#if defined F_SETFL && O_NONBLOCK + if (bytes == SAFE_READ_ERROR && errno == EAGAIN) { - int result = futimens (fd, ts); - if (! (result < 0 && errno == ENOSYS)) - return result; + 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 - return utimensat (parentfd, file, ts, atflag); + 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 + + return bytes; } /* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's) - access time to ATIME. ATFLAG controls symbolic-link following, in - the style of openat. */ + access time to ATIME. */ int -set_file_atime (int fd, int parentfd, char const *file, struct timespec atime, - int atflag) +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 fd_utimensat (fd, parentfd, file, ts, atflag); + return fdutimensat (fd, parentfd, file, ts, fstatat_flags); } /* A description of a working directory. */ @@ -647,13 +684,10 @@ struct wd /* The directory's name. */ char const *name; - /* 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; + /* 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. */ @@ -665,8 +699,21 @@ 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; + int -chdir_count () +chdir_count (void) { if (wd_count == 0) return wd_count; @@ -691,7 +738,7 @@ chdir_arg (char const *dir) if (! wd_count) { wd[wd_count].name = "."; - wd[wd_count].err = -1; + wd[wd_count].fd = AT_FDCWD; wd_count++; } } @@ -708,66 +755,76 @@ chdir_arg (char const *dir) } wd[wd_count].name = dir; - wd[wd_count].err = -1; + wd[wd_count].fd = 0; 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. */ +/* 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 chdir_do (int i) { if (chdir_current != i) { - struct wd *prev = &wd[chdir_current]; struct wd *curr = &wd[i]; + int fd = curr->fd; - if (prev->err < 0) + if (! fd) { - prev->err = 0; - if (save_cwd (&prev->saved_cwd) != 0) - prev->err = errno; - else if (0 <= prev->saved_cwd.desc) + 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 { - /* Make sure we still have at least one descriptor available. */ - int fd1 = prev->saved_cwd.desc; - int fd2 = dup (fd1); - if (0 <= fd2) - close (fd2); - else if (errno == EMFILE) - { - /* Force restore_cwd to use chdir_long. */ - close (fd1); - prev->saved_cwd.desc = -1; - prev->saved_cwd.name = xgetcwd (); - if (! prev->saved_cwd.name) - prev->err = errno; - } - else - prev->err = errno; + 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 <= curr->err) - { - 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 + if (0 < fd) { - if (i && ! ISSLASH (curr->name[0])) - chdir_do (i - 1); - if (chdir (curr->name) != 0) - chdir_fatal (curr->name); + /* 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; } } @@ -849,21 +906,6 @@ file_removed_diag (const char *name, bool top_level, diagfn (name); } -void -dir_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: Directory 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) { @@ -920,7 +962,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 */ };