GNU tar 1.12
This commit is contained in:
Paul Eggert
481
src/misc.c
Normal file
481
src/misc.c
Normal file
@@ -0,0 +1,481 @@
|
||||
/* Miscellaneous functions, not really specific to GNU tar.
|
||||
Copyright (C) 1988, 92, 94, 95, 96, 97 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
|
||||
Free Software Foundation; either version 2, or (at your option) any later
|
||||
version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
||||
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.,
|
||||
59 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"
|
||||
|
||||
/* 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. |
|
||||
`-------------------------------------------------------------------------*/
|
||||
|
||||
void
|
||||
assign_string (char **string, const char *value)
|
||||
{
|
||||
if (*string)
|
||||
free (*string);
|
||||
*string = value ? xstrdup (value) : NULL;
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------.
|
||||
| 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. |
|
||||
`------------------------------------------------------------------------*/
|
||||
|
||||
char *
|
||||
quote_copy_string (const char *string)
|
||||
{
|
||||
const char *source = string;
|
||||
char *destination = NULL;
|
||||
char *buffer = NULL;
|
||||
int copying = 0;
|
||||
|
||||
while (*source)
|
||||
{
|
||||
int character = (unsigned char) *source++;
|
||||
|
||||
if (character == '\\')
|
||||
{
|
||||
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++ = '\\';
|
||||
*destination++ = '\\';
|
||||
}
|
||||
else if (ISPRINT (character))
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (copying)
|
||||
{
|
||||
*destination = '\0';
|
||||
return buffer;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------.
|
||||
| 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)
|
||||
{
|
||||
int result = 1;
|
||||
char *source = string;
|
||||
char *destination = string;
|
||||
|
||||
while (*source)
|
||||
if (*source == '\\')
|
||||
switch (*++source)
|
||||
{
|
||||
case '\\':
|
||||
*destination++ = '\\';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case 'n':
|
||||
*destination++ = '\n';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case 't':
|
||||
*destination++ = '\t';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case 'f':
|
||||
*destination++ = '\f';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case 'b':
|
||||
*destination++ = '\b';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case 'r':
|
||||
*destination++ = '\r';
|
||||
source++;
|
||||
break;
|
||||
|
||||
case '?':
|
||||
*destination++ = 0177;
|
||||
source++;
|
||||
break;
|
||||
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
{
|
||||
int value = *source++ - '0';
|
||||
|
||||
if (*source < '0' || *source > '7')
|
||||
{
|
||||
*destination++ = value;
|
||||
break;
|
||||
}
|
||||
value = value * 8 + *source++ - '0';
|
||||
if (*source < '0' || *source > '7')
|
||||
{
|
||||
*destination++ = value;
|
||||
break;
|
||||
}
|
||||
value = value * 8 + *source++ - '0';
|
||||
*destination++ = value;
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
result = 0;
|
||||
*destination++ = '\\';
|
||||
if (*source)
|
||||
*destination++ = *source++;
|
||||
break;
|
||||
}
|
||||
else if (source != destination)
|
||||
*destination++ = *source++;
|
||||
else
|
||||
source++, destination++;
|
||||
|
||||
if (source != destination)
|
||||
*destination = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Sorting lists. */
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
char *
|
||||
merge_sort (char *list, int length, int offset, int (*compare) (char *, char *))
|
||||
{
|
||||
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 ((*compare) (list, SUCCESSOR (list)) > 0)
|
||||
{
|
||||
result = SUCCESSOR (list);
|
||||
SUCCESSOR (result) = list;
|
||||
SUCCESSOR (list) = NULL;
|
||||
return result;
|
||||
}
|
||||
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;
|
||||
|
||||
#undef SUCCESSOR
|
||||
}
|
||||
|
||||
/* 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. |
|
||||
`------------------------------------------------------------------------*/
|
||||
|
||||
/* 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. */
|
||||
|
||||
int
|
||||
is_dot_or_dotdot (const char *p)
|
||||
{
|
||||
return (p[0] == '\0'
|
||||
|| (p[0] == '.' && (p[1] == '\0'
|
||||
|| (p[1] == '.' && p[2] == '\0'))));
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------.
|
||||
| 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). |
|
||||
`-------------------------------------------------------------------------*/
|
||||
|
||||
int
|
||||
remove_any_file (const char *path, int recurse)
|
||||
{
|
||||
struct stat stat_buffer;
|
||||
|
||||
if (lstat (path, &stat_buffer) < 0)
|
||||
return 0;
|
||||
|
||||
if (S_ISDIR (stat_buffer.st_mode))
|
||||
if (recurse)
|
||||
{
|
||||
DIR *dirp = opendir (path);
|
||||
struct dirent *dp;
|
||||
|
||||
if (dirp == NULL)
|
||||
return 0;
|
||||
|
||||
while (dp = readdir (dirp), dp && !is_dot_or_dotdot (dp->d_name))
|
||||
{
|
||||
char *path_buffer = new_name (path, dp->d_name);
|
||||
|
||||
if (!remove_any_file (path_buffer, 1))
|
||||
{
|
||||
int saved_errno = errno;
|
||||
|
||||
free (path_buffer);
|
||||
closedir (dirp);
|
||||
errno = saved_errno; /* FIXME: errno should be read-only */
|
||||
return 0;
|
||||
}
|
||||
free (path_buffer);
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
return unlink (path) >= 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)
|
||||
{
|
||||
struct stat file_stat;
|
||||
|
||||
/* Check if we really need to backup the file. */
|
||||
|
||||
if (archive && _remdev (path))
|
||||
return 1;
|
||||
|
||||
if (stat (path, &file_stat))
|
||||
{
|
||||
if (errno == ENOENT)
|
||||
return 1;
|
||||
|
||||
ERROR ((0, errno, "%s", path));
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (S_ISDIR (file_stat.st_mode))
|
||||
return 1;
|
||||
|
||||
#ifdef S_ISBLK
|
||||
if (archive && S_ISBLK (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);
|
||||
|
||||
/* 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"));
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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. |
|
||||
`-----------------------------------------------------------------------*/
|
||||
|
||||
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));
|
||||
if (verbose_option)
|
||||
fprintf (stdlis, _("Renaming `%s' back to `%s'\n"),
|
||||
after_backup_name, before_backup_name);
|
||||
assign_string (&after_backup_name, NULL);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user