#include "system.h"
#include <getline.h>
#include <hash.h>
#include <quotearg.h>
#include "common.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
#include <obstack.h>
enum children {NO_CHILDREN, CHANGED_CHILDREN, ALL_CHILDREN};
struct directory
{
dev_t device_number;
ino_t inode_number;
enum children children;
bool nfs;
bool found;
char name[1];
};
static Hash_table *directory_table;
#if HAVE_ST_FSTYPE_STRING
static char const nfs_string[] = "nfs";
# define NFS_FILE_STAT(st) (strcmp ((st).st_fstype, nfs_string) == 0)
#else
# define ST_DEV_MSB(st) (~ (dev_t) 0 << (sizeof (st).st_dev * CHAR_BIT - 1))
# define NFS_FILE_STAT(st) (((st).st_dev & ST_DEV_MSB (st)) != 0)
#endif
static unsigned
hash_directory (void const *entry, unsigned n_buckets)
{
struct directory const *directory = entry;
return hash_string (directory->name, n_buckets);
}
static bool
compare_directories (void const *entry1, void const *entry2)
{
struct directory const *directory1 = entry1;
struct directory const *directory2 = entry2;
return strcmp (directory1->name, directory2->name) == 0;
}
static struct directory *
note_directory (char const *name, dev_t dev, ino_t ino, bool nfs, bool found)
{
size_t size = offsetof (struct directory, name) + strlen (name) + 1;
struct directory *directory = xmalloc (size);
directory->device_number = dev;
directory->inode_number = ino;
directory->children = CHANGED_CHILDREN;
directory->nfs = nfs;
directory->found = found;
strcpy (directory->name, name);
if (! ((directory_table
|| (directory_table = hash_initialize (0, 0, hash_directory,
compare_directories, 0)))
&& hash_insert (directory_table, directory)))
xalloc_die ();
return directory;
}
static struct directory *
find_directory (char *name)
{
if (! directory_table)
return 0;
else
{
size_t size = offsetof (struct directory, name) + strlen (name) + 1;
struct directory *dir = alloca (size);
strcpy (dir->name, name);
return hash_lookup (directory_table, dir);
}
}
static int
compare_dirents (const void *first, const void *second)
{
return strcmp ((*(char *const *) first) + 1,
(*(char *const *) second) + 1);
}
static void
scan_path (struct obstack *stk, char *path, dev_t device)
{
char *dirp = savedir (path);
char const *entry;
size_t entrylen;
char *name_buffer;
size_t name_buffer_size;
size_t name_length;
struct directory *directory;
enum children children;
if (! dirp)
{
savedir_error (path);
}
errno = 0;
name_buffer_size = strlen (path) + NAME_FIELD_SIZE;
name_buffer = xmalloc (name_buffer_size + 2);
strcpy (name_buffer, path);
if (! ISSLASH (path[strlen (path) - 1]))
strcat (name_buffer, "/");
name_length = strlen (name_buffer);
directory = find_directory (path);
children = directory ? directory->children : CHANGED_CHILDREN;
if (dirp && children != NO_CHILDREN)
for (entry = dirp;
(entrylen = strlen (entry)) != 0;
entry += entrylen + 1)
{
if (name_buffer_size <= entrylen + name_length)
{
do
name_buffer_size += NAME_FIELD_SIZE;
while (name_buffer_size <= entrylen + name_length);
name_buffer = xrealloc (name_buffer, name_buffer_size + 2);
}
strcpy (name_buffer + name_length, entry);
if (excluded_name (name_buffer))
obstack_1grow (stk, 'N');
else
{
struct stat stat_data;
if (deref_stat (dereference_option, name_buffer, &stat_data))
{
stat_diag (name_buffer);
continue;
}
if (S_ISDIR (stat_data.st_mode))
{
bool nfs = NFS_FILE_STAT (stat_data);
if ((directory = find_directory (name_buffer)) != NULL)
{
if (! (((directory->nfs & nfs)
|| directory->device_number == stat_data.st_dev)
&& directory->inode_number == stat_data.st_ino))
{
if (verbose_option)
WARN ((0, 0, _("%s: Directory has been renamed"),
quotearg_colon (name_buffer)));
directory->children = ALL_CHILDREN;
directory->nfs = nfs;
directory->device_number = stat_data.st_dev;
directory->inode_number = stat_data.st_ino;
}
directory->found = 1;
}
else
{
if (verbose_option)
WARN ((0, 0, _("%s: Directory is new"),
quotearg_colon (name_buffer)));
directory = note_directory (name_buffer,
stat_data.st_dev,
stat_data.st_ino, nfs, 1);
directory->children =
((listed_incremental_option
|| OLDER_STAT_TIME (stat_data, m)
|| (after_date_option
&& OLDER_STAT_TIME (stat_data, c)))
? ALL_CHILDREN
: CHANGED_CHILDREN);
}
if (one_file_system_option && device != stat_data.st_dev)
directory->children = NO_CHILDREN;
else if (children == ALL_CHILDREN)
directory->children = ALL_CHILDREN;
obstack_1grow (stk, 'D');
}
else if (one_file_system_option && device != stat_data.st_dev)
obstack_1grow (stk, 'N');
#ifdef S_ISHIDDEN
else if (S_ISHIDDEN (stat_data.st_mode))
{
obstack_1grow (stk, 'D');
obstack_grow (stk, entry, entrylen);
obstack_grow (stk, "A", 2);
continue;
}
#endif
else
if (children == CHANGED_CHILDREN
&& OLDER_STAT_TIME (stat_data, m)
&& (!after_date_option || OLDER_STAT_TIME (stat_data, c)))
obstack_1grow (stk, 'N');
else
obstack_1grow (stk, 'Y');
}
obstack_grow (stk, entry, entrylen + 1);
}
obstack_grow (stk, "\000\000", 2);
free (name_buffer);
if (dirp)
free (dirp);
}
static char *
sort_obstack (struct obstack *stk)
{
char *pointer = obstack_finish (stk);
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)
return NULL;
array = obstack_alloc (stk, sizeof (char *) * (counter + 1));
array_cursor = array;
for (cursor = pointer; *cursor; cursor += strlen (cursor) + 1)
*array_cursor++ = cursor;
*array_cursor = 0;
qsort (array, counter, sizeof (char *), compare_dirents);
buffer = xmalloc (cursor - pointer + 2);
cursor = buffer;
for (array_cursor = array; *array_cursor; array_cursor++)
{
char *string = *array_cursor;
while ((*cursor++ = *string++))
continue;
}
*cursor = '\0';
return buffer;
}
char *
get_directory_contents (char *path, dev_t device)
{
struct obstack stk;
char *buffer;
obstack_init (&stk);
scan_path (&stk, path, device);
buffer = sort_obstack (&stk);
obstack_free (&stk, NULL);
return buffer;
}
static FILE *listed_incremental_stream;
void
read_directory_file (void)
{
int fd;
FILE *fp;
char *buf = 0;
size_t bufsize;
fd = open (listed_incremental_option, O_RDWR | O_CREAT, MODE_RW);
if (fd < 0)
{
open_error (listed_incremental_option);
return;
}
fp = fdopen (fd, "r+");
if (! fp)
{
open_error (listed_incremental_option);
close (fd);
return;
}
listed_incremental_stream = fp;
if (0 < getline (&buf, &bufsize, fp))
{
char *ebuf;
int n;
long lineno = 1;
unsigned long u = (errno = 0, strtoul (buf, &ebuf, 10));
time_t t = u;
if (buf == ebuf || (u == 0 && errno == EINVAL))
ERROR ((0, 0, "%s:1: %s", quotearg_colon (listed_incremental_option),
_("Invalid time stamp")));
else if (t != u || (u == -1 && errno == ERANGE))
ERROR ((0, 0, "%s:1: %s", quotearg_colon (listed_incremental_option),
_("Time stamp out of range")));
else
{
newer_mtime_option.tv_sec = t;
newer_mtime_option.tv_nsec = 0;
}
while (0 < (n = getline (&buf, &bufsize, fp)))
{
dev_t dev;
ino_t ino;
bool nfs = buf[0] == '+';
char *strp = buf + nfs;
lineno++;
if (buf[n - 1] == '\n')
buf[n - 1] = '\0';
errno = 0;
dev = u = strtoul (strp, &ebuf, 10);
if (strp == ebuf || (u == 0 && errno == EINVAL))
ERROR ((0, 0, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid device number")));
else if (dev != u || (u == -1 && errno == ERANGE))
ERROR ((0, 0, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Device number out of range")));
strp = ebuf;
errno = 0;
ino = u = strtoul (strp, &ebuf, 10);
if (strp == ebuf || (u == 0 && errno == EINVAL))
ERROR ((0, 0, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid inode number")));
else if (ino != u || (u == -1 && errno == ERANGE))
ERROR ((0, 0, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Inode number out of range")));
strp = ebuf;
strp++;
unquote_string (strp);
note_directory (strp, dev, ino, nfs, 0);
}
}
if (ferror (fp))
read_error (listed_incremental_option);
if (buf)
free (buf);
}
static bool
write_directory_file_entry (void *entry, void *data)
{
struct directory const *directory = entry;
FILE *fp = data;
if (directory->found)
{
int e;
char *str = quote_copy_string (directory->name);
fprintf (fp, "+%lu %lu %s\n" + ! directory->nfs,
(unsigned long) directory->device_number,
(unsigned long) directory->inode_number,
str ? str : directory->name);
e = errno;
if (str)
free (str);
errno = e;
}
return ! ferror (fp);
}
void
write_directory_file (void)
{
FILE *fp = listed_incremental_stream;
if (! fp)
return;
if (fseek (fp, 0L, SEEK_SET) != 0)
seek_error (listed_incremental_option);
if (sys_truncate (fileno (fp)) != 0)
truncate_error (listed_incremental_option);
fprintf (fp, "%lu\n", (unsigned long) start_time);
if (! ferror (fp) && directory_table)
hash_do_for_each (directory_table, write_directory_file_entry, fp);
if (ferror (fp))
write_error (listed_incremental_option);
if (fclose (fp) != 0)
close_error (listed_incremental_option);
}
void
gnu_restore (char const *directory_name)
{
char *archive_dir;
char *current_dir;
char *cur, *arc;
size_t size;
size_t copied;
union block *data_block;
char *to;
current_dir = savedir (directory_name);
if (!current_dir)
{
skip_member ();
return;
}
size = current_stat_info.stat.st_size;
if (size != current_stat_info.stat.st_size)
xalloc_die ();
archive_dir = xmalloc (size);
to = archive_dir;
for (; size > 0; size -= copied)
{
data_block = find_next_block ();
if (!data_block)
{
ERROR ((0, 0, _("Unexpected EOF in archive")));
break;
}
copied = available_space_after (data_block);
if (copied > size)
copied = size;
memcpy (to, data_block->buffer, 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')
{
char *p = new_name (directory_name, cur);
if (! interactive_option || confirm ("delete", p))
{
if (verbose_option)
fprintf (stdlis, _("%s: Deleting %s\n"),
program_name, quote (p));
if (! remove_any_file (p, 1))
{
int e = errno;
ERROR ((0, e, _("%s: Cannot remove"), quotearg_colon (p)));
}
}
free (p);
}
}
free (current_dir);
free (archive_dir);
}