GNU tar 1.12
This commit is contained in:
Paul Eggert
715
src/incremen.c
Normal file
715
src/incremen.c
Normal file
@@ -0,0 +1,715 @@
|
||||
/* GNU dump extensions to tar.
|
||||
Copyright (C) 1988, 92, 93, 94, 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 <time.h>
|
||||
time_t time ();
|
||||
|
||||
#define ISDIGIT(Char) (ISASCII (Char) && isdigit (Char))
|
||||
#define ISSPACE(Char) (ISASCII (Char) && isspace (Char))
|
||||
|
||||
#include "common.h"
|
||||
|
||||
/* Variable sized generic character buffers. */
|
||||
|
||||
struct accumulator
|
||||
{
|
||||
int allocated;
|
||||
int length;
|
||||
char *pointer;
|
||||
};
|
||||
|
||||
/* Amount of space guaranteed just after a reallocation. */
|
||||
#define ACCUMULATOR_SLACK 50
|
||||
|
||||
/*---------------------------------------------------------.
|
||||
| Return the accumulated data from an ACCUMULATOR buffer. |
|
||||
`---------------------------------------------------------*/
|
||||
|
||||
static char *
|
||||
get_accumulator (struct accumulator *accumulator)
|
||||
{
|
||||
return accumulator->pointer;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------.
|
||||
| Allocate and return a new accumulator buffer. |
|
||||
`-----------------------------------------------*/
|
||||
|
||||
static struct accumulator *
|
||||
new_accumulator (void)
|
||||
{
|
||||
struct accumulator *accumulator
|
||||
= (struct accumulator *) xmalloc (sizeof (struct accumulator));
|
||||
|
||||
accumulator->allocated = ACCUMULATOR_SLACK;
|
||||
accumulator->pointer = (char *) xmalloc (ACCUMULATOR_SLACK);
|
||||
accumulator->length = 0;
|
||||
return accumulator;
|
||||
}
|
||||
|
||||
/*-----------------------------------.
|
||||
| Deallocate an ACCUMULATOR buffer. |
|
||||
`-----------------------------------*/
|
||||
|
||||
static void
|
||||
delete_accumulator (struct accumulator *accumulator)
|
||||
{
|
||||
free (accumulator->pointer);
|
||||
free (accumulator);
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------.
|
||||
| At the end of an ACCUMULATOR buffer, add a DATA block of SIZE bytes. |
|
||||
`----------------------------------------------------------------------*/
|
||||
|
||||
static void
|
||||
add_to_accumulator (struct accumulator *accumulator,
|
||||
const char *data, int size)
|
||||
{
|
||||
if (accumulator->length + size > accumulator->allocated)
|
||||
{
|
||||
accumulator->allocated = accumulator->length + size + ACCUMULATOR_SLACK;
|
||||
accumulator->pointer = (char *)
|
||||
xrealloc (accumulator->pointer, (size_t) accumulator->allocated);
|
||||
}
|
||||
memcpy (accumulator->pointer + accumulator->length, data, (size_t) size);
|
||||
accumulator->length += size;
|
||||
}
|
||||
|
||||
/* Incremental dump specialities. */
|
||||
|
||||
/* Current time. */
|
||||
static time_t time_now;
|
||||
|
||||
/* List of directory names. */
|
||||
struct directory
|
||||
{
|
||||
struct directory *next; /* next entry in list */
|
||||
const char *name; /* path name of directory */
|
||||
int device_number; /* device number for directory */
|
||||
int inode_number; /* inode number for directory */
|
||||
int allnew;
|
||||
const char *dir_text;
|
||||
};
|
||||
static struct directory *directory_list = NULL;
|
||||
|
||||
/*-------------------------------------------------------------------.
|
||||
| Create and link a new directory entry for directory NAME, having a |
|
||||
| DEVICE_NUMBER and a INODE_NUMBER, with some TEXT. |
|
||||
`-------------------------------------------------------------------*/
|
||||
|
||||
static void
|
||||
note_directory (char *name, dev_t device_number, ino_t inode_number,
|
||||
const char *text)
|
||||
{
|
||||
struct directory *directory
|
||||
= (struct directory *) xmalloc (sizeof (struct directory));
|
||||
|
||||
directory->next = directory_list;
|
||||
directory_list = directory;
|
||||
|
||||
directory->device_number = device_number;
|
||||
directory->inode_number = inode_number;
|
||||
directory->name = xstrdup (name);
|
||||
directory->dir_text = text;
|
||||
directory->allnew = 0;
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------.
|
||||
| Return a directory entry for a given path NAME, or NULL if none found. |
|
||||
`------------------------------------------------------------------------*/
|
||||
|
||||
static struct directory *
|
||||
find_directory (char *name)
|
||||
{
|
||||
struct directory *directory;
|
||||
|
||||
for (directory = directory_list;
|
||||
directory;
|
||||
directory = directory->next)
|
||||
{
|
||||
if (!strcmp (directory->name, name))
|
||||
return directory;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
static int
|
||||
compare_dirents (const voidstar first, const voidstar second)
|
||||
{
|
||||
return strcmp ((*(char *const *) first) + 1,
|
||||
(*(char *const *) second) + 1);
|
||||
}
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
char *
|
||||
get_directory_contents (char *path, int device)
|
||||
{
|
||||
struct accumulator *accumulator;
|
||||
|
||||
/* Recursively scan the given PATH. */
|
||||
|
||||
{
|
||||
DIR *dirp = opendir (path); /* for scanning directory */
|
||||
struct dirent *entry; /* directory entry being scanned */
|
||||
char *name_buffer; /* directory, `/', and directory member */
|
||||
int name_buffer_size; /* allocated size of name_buffer, minus 2 */
|
||||
int name_length; /* used length in name_buffer */
|
||||
struct directory *directory; /* for checking if already already seen */
|
||||
int all_children;
|
||||
|
||||
if (dirp == NULL)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot open directory %s"), path));
|
||||
return NULL;
|
||||
}
|
||||
errno = 0; /* FIXME: errno should be read-only */
|
||||
|
||||
name_buffer_size = strlen (path) + NAME_FIELD_SIZE;
|
||||
name_buffer = xmalloc ((size_t) (name_buffer_size + 2));
|
||||
strcpy (name_buffer, path);
|
||||
if (path[strlen (path) - 1] != '/')
|
||||
strcat (name_buffer, "/");
|
||||
name_length = strlen (name_buffer);
|
||||
|
||||
directory = find_directory (path);
|
||||
all_children = directory ? directory->allnew : 0;
|
||||
|
||||
accumulator = new_accumulator ();
|
||||
|
||||
while (entry = readdir (dirp), entry)
|
||||
{
|
||||
struct stat stat_data;
|
||||
|
||||
/* Skip `.' and `..'. */
|
||||
|
||||
if (is_dot_or_dotdot (entry->d_name))
|
||||
continue;
|
||||
|
||||
if ((int) NAMLEN (entry) + name_length >= name_buffer_size)
|
||||
{
|
||||
while ((int) NAMLEN (entry) + name_length >= name_buffer_size)
|
||||
name_buffer_size += NAME_FIELD_SIZE;
|
||||
name_buffer = (char *)
|
||||
xrealloc (name_buffer, (size_t) (name_buffer_size + 2));
|
||||
}
|
||||
strcpy (name_buffer + name_length, entry->d_name);
|
||||
|
||||
if (dereference_option
|
||||
#ifdef AIX
|
||||
? statx (name_buffer, &stat_data, STATSIZE, STX_HIDDEN)
|
||||
: statx (name_buffer, &stat_data, STATSIZE, STX_HIDDEN | STX_LINK)
|
||||
#else
|
||||
? stat (name_buffer, &stat_data)
|
||||
: lstat (name_buffer, &stat_data)
|
||||
#endif
|
||||
)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot stat %s"), name_buffer));
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((one_file_system_option && device != stat_data.st_dev)
|
||||
|| (exclude_option && check_exclude (name_buffer)))
|
||||
add_to_accumulator (accumulator, "N", 1);
|
||||
|
||||
#ifdef AIX
|
||||
else if (S_ISHIDDEN (stat_data.st_mode))
|
||||
{
|
||||
add_to_accumulator (accumulator, "D", 1);
|
||||
strcat (entry->d_name, "A");
|
||||
entry->d_namlen++;
|
||||
}
|
||||
#endif
|
||||
|
||||
else if (S_ISDIR (stat_data.st_mode))
|
||||
{
|
||||
if (directory = find_directory (name_buffer), directory)
|
||||
{
|
||||
/* Devices having the high bit set are NFS devices, which are
|
||||
attributed somewhat randomly in automounting situations.
|
||||
For avoiding spurious incremental redumping of directories,
|
||||
we have to plainly consider all NFS devices as equal,
|
||||
relying on the i-node only to establish differences. */
|
||||
|
||||
/* FIXME: G<>ran Uddeborg <goeran@uddeborg.pp.se> says, on
|
||||
1996-09-20, that SunOS 5/Solaris 2 uses unsigned long for
|
||||
the device number type. */
|
||||
|
||||
if ((((short) directory->device_number >= 0
|
||||
|| (short) stat_data.st_dev >= 0)
|
||||
&& directory->device_number != stat_data.st_dev)
|
||||
|| directory->inode_number != stat_data.st_ino)
|
||||
{
|
||||
if (verbose_option)
|
||||
WARN ((0, 0, _("Directory %s has been renamed"),
|
||||
name_buffer));
|
||||
directory->allnew = 1;
|
||||
directory->device_number = stat_data.st_dev;
|
||||
directory->inode_number = stat_data.st_ino;
|
||||
}
|
||||
directory->dir_text = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
if (verbose_option)
|
||||
WARN ((0, 0, _("Directory %s is new"), name_buffer));
|
||||
note_directory (name_buffer, stat_data.st_dev, stat_data.st_ino,
|
||||
"");
|
||||
directory = find_directory (name_buffer);
|
||||
directory->allnew = 1;
|
||||
}
|
||||
if (all_children && directory)
|
||||
directory->allnew = 1;
|
||||
|
||||
add_to_accumulator (accumulator, "D", 1);
|
||||
}
|
||||
|
||||
else
|
||||
if (!all_children
|
||||
&& stat_data.st_mtime < newer_mtime_option
|
||||
&& (!after_date_option
|
||||
|| stat_data.st_ctime < newer_ctime_option))
|
||||
add_to_accumulator (accumulator, "N", 1);
|
||||
else
|
||||
add_to_accumulator (accumulator, "Y", 1);
|
||||
|
||||
add_to_accumulator (accumulator,
|
||||
entry->d_name, (int) (NAMLEN (entry) + 1));
|
||||
}
|
||||
add_to_accumulator (accumulator, "\000\000", 2);
|
||||
|
||||
free (name_buffer);
|
||||
closedir (dirp);
|
||||
}
|
||||
|
||||
/* Sort the contents of the directory, now that we have it all. */
|
||||
|
||||
{
|
||||
char *pointer = get_accumulator (accumulator);
|
||||
size_t counter;
|
||||
char *cursor;
|
||||
char *buffer;
|
||||
char **array;
|
||||
char **array_cursor;
|
||||
|
||||
counter = 0;
|
||||
for (cursor = pointer; *cursor; cursor += strlen (cursor) + 1)
|
||||
counter++;
|
||||
|
||||
if (counter == 0)
|
||||
{
|
||||
delete_accumulator (accumulator);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
array = (char **) xmalloc (sizeof (char *) * (counter + 1));
|
||||
|
||||
array_cursor = array;
|
||||
for (cursor = pointer; *cursor; cursor += strlen (cursor) + 1)
|
||||
*array_cursor++ = cursor;
|
||||
*array_cursor = NULL;
|
||||
|
||||
qsort ((voidstar) array, counter, sizeof (char *), compare_dirents);
|
||||
|
||||
buffer = (char *) xmalloc ((size_t) (cursor - pointer + 2));
|
||||
|
||||
cursor = buffer;
|
||||
for (array_cursor = array; *array_cursor; array_cursor++)
|
||||
{
|
||||
char *string = *array_cursor;
|
||||
|
||||
while ((*cursor++ = *string++))
|
||||
continue;
|
||||
}
|
||||
*cursor = '\0';
|
||||
|
||||
delete_accumulator (accumulator);
|
||||
free (array);
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------.
|
||||
| Add all the files in PATH, which is a directory, to the namelist. If |
|
||||
| any of the files is a directory, recurse on the subdirectory. |
|
||||
`----------------------------------------------------------------------*/
|
||||
|
||||
static void
|
||||
add_hierarchy_to_namelist (char *path, int device)
|
||||
{
|
||||
char *buffer = get_directory_contents (path, device);
|
||||
|
||||
{
|
||||
struct name *name;
|
||||
|
||||
for (name = namelist; name; name = name->next)
|
||||
if (strcmp (name->name, path) == 0)
|
||||
break;
|
||||
if (name)
|
||||
name->dir_contents = buffer ? buffer : "\0\0\0\0";
|
||||
}
|
||||
|
||||
if (buffer)
|
||||
{
|
||||
int name_length = strlen (path);
|
||||
int allocated_length = (name_length >= NAME_FIELD_SIZE
|
||||
? name_length + NAME_FIELD_SIZE
|
||||
: NAME_FIELD_SIZE);
|
||||
char *name_buffer = xmalloc ((size_t) (allocated_length + 1));
|
||||
/* FIXME: + 2 above? */
|
||||
char *string;
|
||||
int string_length;
|
||||
|
||||
strcpy (name_buffer, path);
|
||||
if (name_buffer[name_length - 1] != '/')
|
||||
{
|
||||
name_buffer[name_length++] = '/';
|
||||
name_buffer[name_length] = '\0';
|
||||
}
|
||||
|
||||
for (string = buffer; *string; string += string_length + 1)
|
||||
{
|
||||
string_length = strlen (string);
|
||||
if (*string == 'D')
|
||||
{
|
||||
if (name_length + string_length >= allocated_length)
|
||||
{
|
||||
while (name_length + string_length >= allocated_length)
|
||||
allocated_length += NAME_FIELD_SIZE;
|
||||
name_buffer = (char *)
|
||||
xrealloc (name_buffer, (size_t) (allocated_length + 1));
|
||||
}
|
||||
strcpy (name_buffer + name_length, string + 1);
|
||||
addname (name_buffer);
|
||||
add_hierarchy_to_namelist (name_buffer, device);
|
||||
}
|
||||
}
|
||||
|
||||
free (name_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
static void
|
||||
read_directory_file (void)
|
||||
{
|
||||
dev_t device_number;
|
||||
ino_t inode_number;
|
||||
char *strp;
|
||||
FILE *fp;
|
||||
char buf[512];
|
||||
static char *path = NULL;
|
||||
|
||||
if (path == NULL)
|
||||
path = xmalloc (PATH_MAX);
|
||||
time (&time_now);
|
||||
if (listed_incremental_option[0] != '/')
|
||||
{
|
||||
#if HAVE_GETCWD
|
||||
if (!getcwd (path, PATH_MAX))
|
||||
FATAL_ERROR ((0, 0, _("Could not get current directory")));
|
||||
#else
|
||||
char *getwd ();
|
||||
|
||||
if (!getwd (path))
|
||||
FATAL_ERROR ((0, 0, _("Could not get current directory: %s"), path));
|
||||
#endif
|
||||
|
||||
if (strlen (path) + 1 + strlen (listed_incremental_option) + 1 > PATH_MAX)
|
||||
ERROR ((TAREXIT_FAILURE, 0, _("File name %s/%s too long"),
|
||||
path, listed_incremental_option));
|
||||
|
||||
strcat (path, "/");
|
||||
strcat (path, listed_incremental_option);
|
||||
listed_incremental_option = path;
|
||||
}
|
||||
fp = fopen (listed_incremental_option, "r");
|
||||
if (fp == 0 && errno != ENOENT)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot open %s"), listed_incremental_option));
|
||||
return;
|
||||
}
|
||||
if (!fp)
|
||||
return;
|
||||
fgets (buf, sizeof (buf), fp);
|
||||
|
||||
/* FIXME: Using after_date_option as a first time flag looks fairly
|
||||
dubious to me! So, using -N with incremental might be buggy just
|
||||
because of the next few lines. I saw a few unexplained, almost harsh
|
||||
advices, from other GNU people, about *not* using -N with incremental
|
||||
dumps, and here might lie (part of) the reason. */
|
||||
if (!after_date_option)
|
||||
{
|
||||
newer_mtime_option = atol (buf);
|
||||
after_date_option = 1;
|
||||
}
|
||||
|
||||
while (fgets (buf, sizeof (buf), fp))
|
||||
{
|
||||
strp = &buf[strlen (buf)];
|
||||
if (strp[-1] == '\n')
|
||||
strp[-1] = '\0';
|
||||
/* FIXME: For files ending with an incomplete line, maybe a NUL might
|
||||
be missing, here... */
|
||||
|
||||
strp = buf;
|
||||
device_number = atol (strp);
|
||||
while (ISDIGIT (*strp))
|
||||
strp++;
|
||||
inode_number = atol (strp);
|
||||
while (ISSPACE (*strp))
|
||||
strp++;
|
||||
while (ISDIGIT (*strp))
|
||||
strp++;
|
||||
strp++;
|
||||
unquote_string (strp);
|
||||
note_directory (strp, device_number, inode_number, NULL);
|
||||
}
|
||||
if (fclose (fp) == EOF)
|
||||
ERROR ((0, errno, "%s", listed_incremental_option));
|
||||
}
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
void
|
||||
write_dir_file (void)
|
||||
{
|
||||
FILE *fp;
|
||||
struct directory *directory;
|
||||
char *str;
|
||||
|
||||
fp = fopen (listed_incremental_option, "w");
|
||||
if (fp == 0)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot write to %s"), listed_incremental_option));
|
||||
return;
|
||||
}
|
||||
fprintf (fp, "%lu\n", time_now);
|
||||
for (directory = directory_list; directory; directory = directory->next)
|
||||
{
|
||||
if (!directory->dir_text)
|
||||
continue;
|
||||
str = quote_copy_string (directory->name);
|
||||
if (str)
|
||||
{
|
||||
fprintf (fp, "%u %u %s\n", directory->device_number,
|
||||
directory->inode_number, str);
|
||||
free (str);
|
||||
}
|
||||
else
|
||||
fprintf (fp, "%u %u %s\n", directory->device_number,
|
||||
directory->inode_number, directory->name);
|
||||
}
|
||||
if (fclose (fp) == EOF)
|
||||
ERROR ((0, errno, "%s", listed_incremental_option));
|
||||
}
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
static int
|
||||
compare_names (char *param1, char *param2)
|
||||
{
|
||||
struct name *n1 = (struct name *) param1;
|
||||
struct name *n2 = (struct name *) param2;
|
||||
|
||||
if (n1->found)
|
||||
return n2->found ? strcmp (n1->name, n2->name) : -1;
|
||||
|
||||
if (n2->found)
|
||||
return 1;
|
||||
|
||||
return strcmp (n1->name, n2->name);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------.
|
||||
| Collect all the names from argv[] (or whatever), then expand them into a |
|
||||
| directory tree, and put all the directories at the beginning. |
|
||||
`-------------------------------------------------------------------------*/
|
||||
|
||||
void
|
||||
collect_and_sort_names (void)
|
||||
{
|
||||
struct name *name;
|
||||
struct name *next_name;
|
||||
int num_names;
|
||||
struct stat statbuf;
|
||||
|
||||
name_gather ();
|
||||
|
||||
if (listed_incremental_option)
|
||||
read_directory_file ();
|
||||
|
||||
if (!namelist)
|
||||
addname (".");
|
||||
|
||||
for (name = namelist; name; name = next_name)
|
||||
{
|
||||
next_name = name->next;
|
||||
if (name->found || name->dir_contents)
|
||||
continue;
|
||||
if (name->regexp) /* FIXME: just skip regexps for now */
|
||||
continue;
|
||||
if (name->change_dir)
|
||||
if (chdir (name->change_dir) < 0)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot chdir to %s"), name->change_dir));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
#ifdef AIX
|
||||
statx (name->name, &statbuf, STATSIZE, STX_HIDDEN | STX_LINK)
|
||||
#else
|
||||
lstat (name->name, &statbuf) < 0
|
||||
#endif
|
||||
)
|
||||
{
|
||||
ERROR ((0, errno, _("Cannot stat %s"), name->name));
|
||||
continue;
|
||||
}
|
||||
if (S_ISDIR (statbuf.st_mode))
|
||||
{
|
||||
name->found = 1;
|
||||
add_hierarchy_to_namelist (name->name, statbuf.st_dev);
|
||||
}
|
||||
}
|
||||
|
||||
num_names = 0;
|
||||
for (name = namelist; name; name = name->next)
|
||||
num_names++;
|
||||
namelist = (struct name *)
|
||||
merge_sort ((voidstar) namelist, num_names,
|
||||
(char *) (&(namelist->next)) - (char *) namelist,
|
||||
compare_names);
|
||||
|
||||
for (name = namelist; name; name = name->next)
|
||||
name->found = 0;
|
||||
|
||||
if (listed_incremental_option)
|
||||
write_dir_file ();
|
||||
}
|
||||
|
||||
/* Restoration of incremental dumps. */
|
||||
|
||||
/*---.
|
||||
| ? |
|
||||
`---*/
|
||||
|
||||
void
|
||||
gnu_restore (int skipcrud)
|
||||
{
|
||||
char *current_dir;
|
||||
char *archive_dir;
|
||||
struct accumulator *accumulator;
|
||||
char *p;
|
||||
DIR *dirp;
|
||||
struct dirent *d;
|
||||
char *cur, *arc;
|
||||
long size, copied;
|
||||
union block *data_block;
|
||||
char *to;
|
||||
|
||||
#define CURRENT_FILE_NAME (skipcrud + current_file_name)
|
||||
|
||||
dirp = opendir (CURRENT_FILE_NAME);
|
||||
|
||||
if (!dirp)
|
||||
{
|
||||
/* The directory doesn't exist now. It'll be created. In any
|
||||
case, we don't have to delete any files out of it. */
|
||||
|
||||
skip_file ((long) current_stat.st_size);
|
||||
return;
|
||||
}
|
||||
|
||||
accumulator = new_accumulator ();
|
||||
while (d = readdir (dirp), d)
|
||||
{
|
||||
if (is_dot_or_dotdot (d->d_name))
|
||||
continue;
|
||||
|
||||
add_to_accumulator (accumulator, d->d_name, (int) (NAMLEN (d) + 1));
|
||||
}
|
||||
closedir (dirp);
|
||||
add_to_accumulator (accumulator, "", 1);
|
||||
|
||||
current_dir = get_accumulator (accumulator);
|
||||
archive_dir = (char *) xmalloc ((size_t) current_stat.st_size);
|
||||
to = archive_dir;
|
||||
for (size = current_stat.st_size; size > 0; size -= copied)
|
||||
{
|
||||
data_block = find_next_block ();
|
||||
if (!data_block)
|
||||
{
|
||||
ERROR ((0, 0, _("Unexpected EOF in archive")));
|
||||
break; /* FIXME: What happens then? */
|
||||
}
|
||||
copied = available_space_after (data_block);
|
||||
if (copied > size)
|
||||
copied = size;
|
||||
memcpy (to, data_block->buffer, (size_t) copied);
|
||||
to += copied;
|
||||
set_next_block_after ((union block *)
|
||||
(data_block->buffer + copied - 1));
|
||||
}
|
||||
|
||||
for (cur = current_dir; *cur; cur += strlen (cur) + 1)
|
||||
{
|
||||
for (arc = archive_dir; *arc; arc += strlen (arc) + 1)
|
||||
{
|
||||
arc++;
|
||||
if (!strcmp (arc, cur))
|
||||
break;
|
||||
}
|
||||
if (*arc == '\0')
|
||||
{
|
||||
p = new_name (CURRENT_FILE_NAME, cur);
|
||||
if (interactive_option && !confirm ("delete", p))
|
||||
{
|
||||
free (p);
|
||||
continue;
|
||||
}
|
||||
if (verbose_option)
|
||||
fprintf (stdlis, _("%s: Deleting %s\n"), program_name, p);
|
||||
if (!remove_any_file (p, 1))
|
||||
ERROR ((0, errno, _("Error while deleting %s"), p));
|
||||
free (p);
|
||||
}
|
||||
|
||||
}
|
||||
delete_accumulator (accumulator);
|
||||
free (archive_dir);
|
||||
|
||||
#undef CURRENT_FILE_NAME
|
||||
}
|
||||
Reference in New Issue
Block a user