482 lines
12 KiB
C
482 lines
12 KiB
C
/* 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);
|
||
}
|
||
}
|