From: Sergey Poznyakoff Date: Thu, 24 Jul 2003 14:44:51 +0000 (+0000) Subject: (chdir_do): Fixed call to restore_cwd X-Git-Url: https://git.dogcows.com/gitweb?a=commitdiff_plain;h=31d9c7e2a4344d8f884c93dd4fb467894de69e99;p=chaz%2Ftar (chdir_do): Fixed call to restore_cwd --- diff --git a/src/misc.c b/src/misc.c index d75890e..8112ee8 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 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,73 @@ 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. */ + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "system.h" - -#include "backupfile.h" #include "rmt.h" - -/* The following inclusion for crosschecking prototypes, only. */ #include "common.h" +#include +#include + +static void call_arg_fatal (char const *, char const *) + __attribute__ ((noreturn)); /* 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 +89,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 +109,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) @@ -238,169 +197,142 @@ unquote_string (char *string) return result; } -/* Sorting lists. */ +/* File handling. */ -/*---. -| ? | -`---*/ +/* Saved names in case backup needs to be undone. */ +static char *before_backup_name; +static char *after_backup_name; -char * -merge_sort (char *list, int length, int offset, int (*compare) (char *, char *)) +/* Return 1 if PATH is obviously "." or "/". */ +static bool +must_be_dot_or_slash (char const *path) { - 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; + path += FILESYSTEM_PREFIX_LEN (path); - if (length == 2) + if (ISSLASH (path[0])) { - if ((*compare) (list, SUCCESSOR (list)) > 0) - { - result = SUCCESSOR (list); - SUCCESSOR (result) = list; - SUCCESSOR (list) = NULL; - return result; - } - return list; + for (;;) + if (ISSLASH (path[1])) + path++; + else if (path[1] == '.' && ISSLASH (path[2 + (path[2] == '.')])) + path += 2 + (path[2] == '.'); + else + return ! path[1]; } - - 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; + { + while (path[0] == '.' && ISSLASH (path[1])) + { + path += 2; + while (ISSLASH (*path)) + path++; + } -#undef SUCCESSOR + return ! path[0] || (path[0] == '.' && ! path[1]); + } } - -/* File handling. */ - -/* Saved names in case backup needs to be undone. */ -static char *before_backup_name = NULL; -static char *after_backup_name = NULL; -/*------------------------------------------------------------------------. -| Returns nonzero if p is `.' or `..'. This could be a macro for speed. | -`------------------------------------------------------------------------*/ +/* 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 *path) +{ + if (must_be_dot_or_slash (path)) + { + errno = 0; + return -1; + } -/* 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 rmdir (path); +} +/* Remove PATH, returning 1 on success. If PATH is a directory, then + if OPTION is RECURSIVE_REMOVE_OPTION is set remove PATH + recursively; otherwise, remove it only if it is empty. If PATH 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 PATH is obviously the working + directory return zero with errno set to zero. */ int -is_dot_or_dotdot (const char *p) +remove_any_file (const char *path, enum remove_option option) { - return (p[0] == '\0' - || (p[0] == '.' && (p[1] == '\0' - || (p[1] == '.' && p[2] == '\0')))); -} + /* Try unlink first if we are not root, as this saves us a system + call in the common case where we're removing a non-directory. */ + if (! we_are_root) + { + if (unlink (path) == 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). | -`-------------------------------------------------------------------------*/ + /* 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; + } -int -remove_any_file (const char *path, int recurse) -{ - struct stat stat_buffer; + if (safer_rmdir (path) == 0) + return 1; - if (lstat (path, &stat_buffer) < 0) - return 0; + switch (errno) + { + case ENOTDIR: + return we_are_root && unlink (path) == 0; - if (S_ISDIR (stat_buffer.st_mode)) - if (recurse) - { - DIR *dirp = opendir (path); - struct dirent *dp; + 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 = savedir (path); + char const *entry; + size_t entrylen; - if (!remove_any_file (path_buffer, 1)) - { - int saved_errno = errno; + if (! directory) + return 0; + for (entry = directory; + (entrylen = strlen (entry)) != 0; + entry += entrylen + 1) + { + char *path_buffer = new_name (path, entry); + int r = remove_any_file (path_buffer, 1); + int e = errno; free (path_buffer); - closedir (dirp); - errno = saved_errno; /* FIXME: errno should be read-only */ - return 0; + + if (! r) + { + free (directory); + errno = e; + return 0; + } } - free (path_buffer); + + free (directory); + return safer_rmdir (path) == 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. | -`-------------------------------------------------------------------------*/ - +/* 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) { @@ -416,22 +348,15 @@ maybe_backup_file (const char *path, int archive) if (errno == ENOENT) return 1; - ERROR ((0, errno, "%s", path)); + stat_error (path); return 0; } if (S_ISDIR (file_stat.st_mode)) return 1; -#ifdef S_ISBLK - if (archive && S_ISBLK (file_stat.st_mode)) + if (archive && (S_ISBLK (file_stat.st_mode) || S_ISCHR (file_stat.st_mode))) return 1; -#endif - -#ifdef S_ISCHR - if (archive && S_ISCHR (file_stat.st_mode)) - return 1; -#endif assign_string (&before_backup_name, path); @@ -440,42 +365,500 @@ maybe_backup_file (const char *path, int archive) 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 (path, 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); + fprintf (stdlis, _("Renaming %s to %s\n"), + quote_n (0, before_backup_name), + quote_n (1, after_backup_name)); return 1; } - - /* The backup operation failed. */ - - ERROR ((0, errno, _("%s: Cannot rename for backup"), before_backup_name)); - assign_string (&after_backup_name, NULL); - return 0; + 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 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; + } +} + +/* Decode MODE from its binary form in a stat structure, and encode it + into a 9-byte string STRING, terminated with a NUL. */ + +void +decode_mode (mode_t mode, char *string) +{ + *string++ = mode & S_IRUSR ? 'r' : '-'; + *string++ = mode & S_IWUSR ? 'w' : '-'; + *string++ = (mode & S_ISUID + ? (mode & S_IXUSR ? 's' : 'S') + : (mode & S_IXUSR ? 'x' : '-')); + *string++ = mode & S_IRGRP ? 'r' : '-'; + *string++ = mode & S_IWGRP ? 'w' : '-'; + *string++ = (mode & S_ISGID + ? (mode & S_IXGRP ? 's' : 'S') + : (mode & S_IXGRP ? 'x' : '-')); + *string++ = mode & S_IROTH ? 'r' : '-'; + *string++ = mode & S_IWOTH ? 'w' : '-'; + *string++ = (mode & S_ISVTX + ? (mode & S_IXOTH ? 't' : 'T') + : (mode & S_IXOTH ? 'x' : '-')); + *string = '\0'; +} + +/* Report an error associated with the system call CALL and the + optional name NAME. */ +static void +call_arg_error (char const *call, char const *name) +{ + int e = errno; + ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name), call)); +} + +/* Report a fatal error associated with the system call CALL and + the optional file name NAME. */ +static void +call_arg_fatal (char const *call, char const *name) +{ + int e = errno; + FATAL_ERROR ((0, e, _("%s: Cannot %s"), quotearg_colon (name), call)); +} + +/* Report a warning associated with the system call CALL and + the optional file name NAME. */ +static void +call_arg_warn (char const *call, char const *name) +{ + int e = errno; + WARN ((0, e, _("%s: Warning: Cannot %s"), quotearg_colon (name), call)); +} + +void +chdir_fatal (char const *name) +{ + call_arg_fatal ("chdir", name); +} + +void +chmod_error_details (char const *name, mode_t mode) +{ + int e = errno; + char buf[10]; + decode_mode (mode, buf); + ERROR ((0, e, _("%s: Cannot change mode to %s"), + quotearg_colon (name), buf)); +} + +void +chown_error_details (char const *name, uid_t uid, gid_t gid) +{ + int e = errno; + ERROR ((0, e, _("%s: Cannot change ownership to uid %lu, gid %lu"), + quotearg_colon (name), (unsigned long) uid, (unsigned long) gid)); +} + +void +close_error (char const *name) +{ + call_arg_error ("close", name); +} + +void +close_fatal (char const *name) +{ + call_arg_fatal ("close", name); +} + +void +close_warn (char const *name) +{ + call_arg_warn ("close", name); +} + +void +exec_fatal (char const *name) +{ + call_arg_fatal ("exec", name); +} + +void +link_error (char const *target, char const *source) +{ + int e = errno; + ERROR ((0, e, _("%s: Cannot hard link to %s"), + quotearg_colon (source), quote_n (1, target))); +} + +void +mkdir_error (char const *name) +{ + call_arg_error ("mkdir", name); +} + +void +mkfifo_error (char const *name) +{ + call_arg_error ("mkfifo", name); +} + +void +mknod_error (char const *name) +{ + call_arg_error ("mknod", name); +} + +void +open_error (char const *name) +{ + call_arg_error ("open", name); +} + +void +open_fatal (char const *name) +{ + call_arg_fatal ("open", name); +} + +void +open_warn (char const *name) +{ + call_arg_warn ("open", name); +} + +void +read_error (char const *name) +{ + call_arg_error ("read", name); +} + +void +read_error_details (char const *name, off_t offset, size_t size) +{ + char buf[UINTMAX_STRSIZE_BOUND]; + int e = errno; + ERROR ((0, e, + _("%s: Read error at byte %s, reading %lu bytes"), + quotearg_colon (name), STRINGIFY_BIGINT (offset, buf), + (unsigned long) size)); +} + +void +read_warn_details (char const *name, off_t offset, size_t size) +{ + char buf[UINTMAX_STRSIZE_BOUND]; + int e = errno; + WARN ((0, e, + _("%s: Warning: Read error at byte %s, reading %lu bytes"), + quotearg_colon (name), STRINGIFY_BIGINT (offset, buf), + (unsigned long) size)); +} + +void +read_fatal (char const *name) +{ + call_arg_fatal ("read", name); +} + +void +read_fatal_details (char const *name, off_t offset, size_t size) +{ + char buf[UINTMAX_STRSIZE_BOUND]; + int e = errno; + FATAL_ERROR ((0, e, + _("%s: Read error at byte %s, reading %lu bytes"), + quotearg_colon (name), STRINGIFY_BIGINT (offset, buf), + (unsigned long) size)); +} + +void +readlink_error (char const *name) +{ + call_arg_error ("readlink", name); +} + +void +readlink_warn (char const *name) +{ + call_arg_warn ("readlink", name); +} + +void +savedir_error (char const *name) +{ + call_arg_error ("savedir", name); +} + +void +savedir_warn (char const *name) +{ + call_arg_warn ("savedir", name); +} + +void +seek_error (char const *name) +{ + call_arg_error ("seek", name); +} + +void +seek_error_details (char const *name, off_t offset) +{ + char buf[UINTMAX_STRSIZE_BOUND]; + int e = errno; + ERROR ((0, e, _("%s: Cannot seek to %s"), + quotearg_colon (name), + STRINGIFY_BIGINT (offset, buf))); +} + +void +seek_warn (char const *name) +{ + call_arg_warn ("seek", name); +} + +void +seek_warn_details (char const *name, off_t offset) +{ + char buf[UINTMAX_STRSIZE_BOUND]; + int e = errno; + WARN ((0, e, _("%s: Warning: Cannot seek to %s"), + quotearg_colon (name), + STRINGIFY_BIGINT (offset, buf))); +} + +void +symlink_error (char const *contents, char const *name) +{ + int e = errno; + ERROR ((0, e, _("%s: Cannot create symlink to %s"), + quotearg_colon (name), quote_n (1, contents))); +} + +void +stat_error (char const *name) +{ + call_arg_error ("stat", name); +} + +void +stat_warn (char const *name) +{ + call_arg_warn ("stat", name); +} + +void +truncate_error (char const *name) +{ + call_arg_error ("truncate", name); +} + +void +truncate_warn (char const *name) +{ + call_arg_warn ("truncate", name); +} + +void +unlink_error (char const *name) +{ + call_arg_error ("unlink", name); +} + +void +utime_error (char const *name) +{ + call_arg_error ("utime", name); +} + +void +waitpid_error (char const *name) +{ + call_arg_error ("waitpid", name); +} + +void +write_error (char const *name) +{ + call_arg_error ("write", name); +} + +void +write_error_details (char const *name, ssize_t status, size_t size) +{ + if (status < 0) + write_error (name); + else + ERROR ((0, 0, _("%s: Wrote only %lu of %lu bytes"), + name, (unsigned long) status, (unsigned long) record_size)); +} + +void +write_fatal (char const *name) +{ + call_arg_fatal ("write", 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 an unambiguous printable representation, allocated in slot N, + for NAME, suitable for diagnostics. */ +char const * +quote_n (int n, char const *name) +{ + return quotearg_n_style (n, locale_quoting_style, name); +} + +/* Return an unambiguous printable representation of NAME, suitable + for diagnostics. */ +char const * +quote (char const *name) +{ + return quote_n (0, name); +}