X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fmisc.c;h=55bedd2b2c901669ff4025feadbb2fd338984831;hb=d659cbaccdc1f3279c49107cf15f15a639738529;hp=d75890e00db0eed254815be0773fc1b2d53a8be6;hpb=3728196fa69fb0908f5c175d750978d1423b8340;p=chaz%2Ftar diff --git a/src/misc.c b/src/misc.c index d75890e..55bedd2 100644 --- a/src/misc.c +++ b/src/misc.c @@ -1,5 +1,7 @@ /* Miscellaneous functions, not really specific to GNU tar. - Copyright (C) 1988, 92, 94, 95, 96, 97 Free Software Foundation, Inc. + + Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001, + 2003, 2004, 2005 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 @@ -13,119 +15,72 @@ 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. */ - -#include "system.h" + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "backupfile.h" -#include "rmt.h" - -/* The following inclusion for crosschecking prototypes, only. */ +#include +#include #include "common.h" +#include +#include +#include + /* 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; + *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. | -`------------------------------------------------------------------------*/ - +/* 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. */ 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) @@ -133,21 +88,19 @@ quote_copy_string (const char *string) *destination = '\0'; return buffer; } - return NULL; + return 0; } -/*-------------------------------------------------------------------------. -| 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) { @@ -155,6 +108,11 @@ 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) @@ -164,13 +122,13 @@ unquote_string (char *string) source++; break; - case 'n': - *destination++ = '\n'; + case 'a': + *destination++ = '\a'; source++; break; - case 't': - *destination++ = '\t'; + case 'b': + *destination++ = '\b'; source++; break; @@ -179,8 +137,8 @@ unquote_string (char *string) source++; break; - case 'b': - *destination++ = '\b'; + case 'n': + *destination++ = '\n'; source++; break; @@ -189,6 +147,16 @@ unquote_string (char *string) source++; break; + case 't': + *destination++ = '\t'; + source++; + break; + + case 'v': + *destination++ = '\v'; + source++; + break; + case '?': *destination++ = 0177; source++; @@ -238,244 +206,466 @@ unquote_string (char *string) return result; } -/* Sorting lists. */ +/* Handling numbers. */ -/*---. -| ? | -`---*/ +/* Output fraction and trailing digits appropriate for a nanoseconds + count equal to NS, but don't output unnecessary '.' or trailing + zeros. */ -char * -merge_sort (char *list, int length, int offset, int (*compare) (char *, char *)) +void +code_ns_fraction (int ns, char *p) { - char *first_list; - char *second_list; - int first_length; - int second_length; - char *result; - char **merge_point; - char *cursor; - int counter; - -#define SUCCESSOR(Pointer) \ - (*((char **) (((char *) (Pointer)) + offset))) - - if (length == 1) - return list; - - if (length == 2) + if (ns == 0) + *p = '\0'; + else { - if ((*compare) (list, SUCCESSOR (list)) > 0) + int i = 9; + *p++ = '.'; + + while (ns % 10 == 0) { - result = SUCCESSOR (list); - SUCCESSOR (result) = list; - SUCCESSOR (list) = NULL; - return result; + ns /= 10; + i--; } - return list; - } - 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; - else - *merge_point = second_list; - - return result; + p[i] = '\0'; -#undef SUCCESSOR + for (;;) + { + p[--i] = '0' + ns % 10; + if (i == 0) + break; + ns /= 10; + } + } } /* 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 "/". */ +static bool +must_be_dot_or_slash (char const *file_name) +{ + file_name += FILE_SYSTEM_PREFIX_LEN (file_name); + + 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++; + } -/* 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. */ + return ! file_name[0] || (file_name[0] == '.' && ! file_name[1]); + } +} -int -is_dot_or_dotdot (const char *p) +/* 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) { - return (p[0] == '\0' - || (p[0] == '.' && (p[1] == '\0' - || (p[1] == '.' && p[2] == '\0')))); -} + if (must_be_dot_or_slash (file_name)) + { + errno = 0; + return -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). | -`-------------------------------------------------------------------------*/ + return rmdir (file_name); +} +/* 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 (unlink (file_name) == 0) + return 1; - if (S_ISDIR (stat_buffer.st_mode)) - if (recurse) - { - DIR *dirp = opendir (path); - struct dirent *dp; + /* 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 (dirp == NULL) - return 0; + if (safer_rmdir (file_name) == 0) + return 1; + + switch (errno) + { + case ENOTDIR: + return !try_unlink_first && unlink (file_name) == 0; + + case 0: + case EEXIST: +#if defined ENOTEMPTY && ENOTEMPTY != EEXIST + case ENOTEMPTY: +#endif + switch (option) + { + case ORDINARY_REMOVE_OPTION: + break; - while (dp = readdir (dirp), dp && !is_dot_or_dotdot (dp->d_name)) + case WANT_DIRECTORY_REMOVE_OPTION: + return -1; + + case RECURSIVE_REMOVE_OPTION: { - char *path_buffer = new_name (path, dp->d_name); + char *directory = savedir (file_name); + 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, int this_is_the_archive) { struct stat file_stat; /* 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 (stat (file_name, &file_stat)) { 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; -#endif + if (this_is_the_archive + && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode))) + return true; -#ifdef S_ISCHR - if (archive && S_ISCHR (file_stat.st_mode)) - return 1; -#endif - - assign_string (&before_backup_name, path); + 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, NULL); - after_backup_name = find_backup_file_name (path); - if (after_backup_name == NULL) - FATAL_ERROR ((0, 0, "Virtual memory exhausted")); + assign_string (&after_backup_name, 0); + after_backup_name = find_backup_file_name (file_name, backup_type); + if (! after_backup_name) + xalloc_die (); if (rename (before_backup_name, after_backup_name) == 0) { if (verbose_option) - fprintf (stdlis, _("Renaming previous `%s' to `%s'\n"), - before_backup_name, after_backup_name); - return 1; + 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; } - - /* The backup operation failed. */ - - ERROR ((0, errno, _("%s: Cannot rename for backup"), before_backup_name)); - assign_string (&after_backup_name, NULL); - return 0; } -/*-----------------------------------------------------------------------. -| Try to restore the recently backed up file to its original name. This | -| is usually only needed after a failed extraction. | -`-----------------------------------------------------------------------*/ - +/* 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 (rename (after_backup_name, before_backup_name) != 0) - ERROR ((0, errno, _("%s: Cannot rename from backup"), - before_backup_name)); + { + 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"), - after_backup_name, before_backup_name); - assign_string (&after_backup_name, NULL); + 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); } } + +/* Depending on DEREF, apply either stat or lstat to (NAME, BUF). */ +int +deref_stat (bool deref, char const *name, struct stat *buf) +{ + return deref ? stat (name, buf) : lstat (name, buf); +} + +/* A description of a working directory. */ +struct wd +{ + char const *name; + int saved; + struct saved_cwd saved_cwd; +}; + +/* 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 wds; + +/* The allocated size of the vector. */ +static size_t wd_alloc; + +/* 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) +{ + if (wds == wd_alloc) + { + wd_alloc = 2 * (wd_alloc + 1); + wd = xrealloc (wd, sizeof *wd * wd_alloc); + if (! wds) + { + wd[wds].name = "."; + wd[wds].saved = 0; + wds++; + } + } + + /* 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 wds - 1; + } + + wd[wds].name = dir; + wd[wds].saved = 0; + return wds++; +} + +/* 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) + { + struct wd *prev = &wd[previous]; + struct wd *curr = &wd[i]; + + if (! prev->saved) + { + prev->saved = 1; + if (save_cwd (&prev->saved_cwd) != 0) + FATAL_ERROR ((0, 0, _("Cannot save working directory"))); + } + + if (curr->saved) + { + if (restore_cwd (&curr->saved_cwd)) + FATAL_ERROR ((0, 0, _("Cannot change working directory"))); + } + else + { + if (i && ! ISSLASH (curr->name[0])) + chdir_do (i - 1); + if (chdir (curr->name) != 0) + chdir_fatal (curr->name); + } + + previous = i; + } +} + +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 +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); +}