/* GNU dump extensions to tar.
Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
- 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2003, 2004, 2005, 2006, 2007, 2008 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
#define DIR_SET_FLAG(d,f) (d)->flags |= (f)
#define DIR_CLEAR_FLAG(d,f) (d)->flags &= ~(f)
+struct dumpdir /* Dump directory listing */
+{
+ char *contents; /* Actual contents */
+ size_t total; /* Total number of elements */
+ size_t elc; /* Number of D/N/Y elements. */
+ char **elv; /* Array of D/N/Y elements */
+};
+
/* Directory attributes. */
struct directory
{
+ struct directory *next;
struct timespec mtime; /* Modification time */
dev_t device_number; /* device number for directory */
ino_t inode_number; /* inode number for directory */
- char *contents; /* Directory contents */
- char *icontents; /* Initial contents if the directory was
+ struct dumpdir *dump; /* Directory contents */
+ struct dumpdir *idump; /* Initial contents if the directory was
rescanned */
enum children children; /* What to save under this directory */
unsigned flags; /* See DIRF_ macros above */
the original directory structure */
const char *tagfile; /* Tag file, if the directory falls under
exclusion_tag_under */
- char name[1]; /* file name of directory */
+ char *name; /* file name of directory */
};
+struct dumpdir *
+dumpdir_create0 (const char *contents, const char *cmask)
+{
+ struct dumpdir *dump;
+ size_t i, total, ctsize, len;
+ const char *p;
+
+ for (i = 0, total = 0, ctsize = 1, p = contents; *p; total++, p += len)
+ {
+ len = strlen (p) + 1;
+ ctsize += len;
+ if (!cmask || strchr (cmask, *p))
+ i++;
+ }
+ dump = xmalloc (sizeof (*dump) + ctsize);
+ dump->contents = (char*)(dump + 1);
+ memcpy (dump->contents, contents, ctsize);
+ dump->total = total;
+ dump->elc = i;
+ dump->elv = xcalloc (i + 1, sizeof (dump->elv[0]));
+
+ for (i = 0, p = dump->contents; *p; p += strlen (p) + 1)
+ {
+ if (!cmask || strchr (cmask, *p))
+ dump->elv[i++] = p + 1;
+ }
+ dump->elv[i] = NULL;
+ return dump;
+}
+
+struct dumpdir *
+dumpdir_create (const char *contents)
+{
+ return dumpdir_create0 (contents, "YND");
+}
+
+void
+dumpdir_free (struct dumpdir *dump)
+{
+ free (dump->elv);
+ free (dump);
+}
+
+static int
+compare_dirnames (const void *first, const void *second)
+{
+ char const *const *name1 = first;
+ char const *const *name2 = second;
+ return strcmp (*name1, *name2);
+}
+
+/* Locate NAME in the dumpdir array DUMP.
+ Return pointer to the slot in DUMP->contents, or NULL if not found */
+char *
+dumpdir_locate (struct dumpdir *dump, const char *name)
+{
+ char **ptr;
+ if (!dump)
+ return NULL;
+
+ ptr = bsearch (&name, dump->elv, dump->elc, sizeof (dump->elv[0]),
+ compare_dirnames);
+ return ptr ? *ptr - 1: NULL;
+}
+
+struct dumpdir_iter
+{
+ struct dumpdir *dump; /* Dumpdir being iterated */
+ int all; /* Iterate over all entries, not only D/N/Y */
+ size_t next; /* Index of the next element */
+};
+
+char *
+dumpdir_next (struct dumpdir_iter *itr)
+{
+ size_t cur = itr->next;
+ char *ret = NULL;
+
+ if (itr->all)
+ {
+ ret = itr->dump->contents + cur;
+ if (*ret == 0)
+ return NULL;
+ itr->next += strlen (ret) + 1;
+ }
+ else if (cur < itr->dump->elc)
+ {
+ ret = itr->dump->elv[cur] - 1;
+ itr->next++;
+ }
+
+ return ret;
+}
+
+char *
+dumpdir_first (struct dumpdir *dump, int all, struct dumpdir_iter **pitr)
+{
+ struct dumpdir_iter *itr = xmalloc (sizeof (*itr));
+ itr->dump = dump;
+ itr->all = all;
+ itr->next = 0;
+ *pitr = itr;
+ return dumpdir_next (itr);
+}
+
+/* Return size in bytes of the dumpdir array P */
+size_t
+dumpdir_size (const char *p)
+{
+ size_t totsize = 0;
+
+ while (*p)
+ {
+ size_t size = strlen (p) + 1;
+ totsize += size;
+ p += size;
+ }
+ return totsize + 1;
+}
+
+\f
+static struct directory *dirhead, *dirtail;
static Hash_table *directory_table;
static Hash_table *directory_meta_table;
make_directory (const char *name)
{
size_t namelen = strlen (name);
- size_t size = offsetof (struct directory, name) + namelen + 1;
- struct directory *directory = xmalloc (size);
- directory->contents = directory->icontents = NULL;
+ struct directory *directory = xmalloc (sizeof (*directory));
+ directory->next = NULL;
+ directory->dump = directory->idump = NULL;
directory->orig = NULL;
directory->flags = false;
- strcpy (directory->name, name);
- if (ISSLASH (directory->name[namelen-1]))
- directory->name[namelen-1] = 0;
+ if (namelen && ISSLASH (name[namelen - 1]))
+ namelen--;
+ directory->name = xmalloc (namelen + 1);
+ memcpy (directory->name, name, namelen);
+ directory->name[namelen] = 0;
directory->tagfile = NULL;
return directory;
}
+static void
+free_directory (struct directory *dir)
+{
+ free (dir->name);
+ free (dir);
+}
+
+static struct directory *
+attach_directory (const char *name)
+{
+ struct directory *dir = make_directory (name);
+ if (dirtail)
+ dirtail->next = dir;
+ else
+ dirhead = dir;
+ dirtail = dir;
+}
+
+\f
+static void
+replace_prefix (char **pname, const char *samp, size_t slen,
+ const char *repl, size_t rlen)
+{
+ char *name = *pname;
+ size_t nlen = strlen (name);
+ if (nlen > slen && memcmp (name, samp, slen) == 0 && ISSLASH (name[slen]))
+ {
+ if (rlen > slen)
+ {
+ name = xrealloc (name, nlen - slen + rlen + 1);
+ *pname = name;
+ }
+ memmove (name + rlen, name + slen, nlen - slen + 1);
+ memcpy (name, repl, rlen);
+ }
+}
+
+void
+dirlist_replace_prefix (const char *pref, const char *repl)
+{
+ struct directory *dp;
+ size_t pref_len = strlen (pref);
+ size_t repl_len = strlen (repl);
+ for (dp = dirhead; dp; dp = dp->next)
+ replace_prefix (&dp->name, pref, pref_len, repl, repl_len);
+}
+
/* Create and link a new directory entry for directory NAME, having a
device number DEV and an inode number INO, with NFS indicating
whether it is an NFS device and FOUND indicating whether we have
found that the directory exists. */
static struct directory *
note_directory (char const *name, struct timespec mtime,
- dev_t dev, ino_t ino, bool nfs, bool found, char *contents)
+ dev_t dev, ino_t ino, bool nfs, bool found,
+ const char *contents)
{
- struct directory *directory = make_directory (name);
+ struct directory *directory = attach_directory (name);
directory->mtime = mtime;
directory->device_number = dev;
if (found)
DIR_SET_FLAG (directory, DIRF_FOUND);
if (contents)
- {
- size_t size = dumpdir_size (contents);
- directory->contents = xmalloc (size);
- memcpy (directory->contents, contents, size);
- }
+ directory->dump = dumpdir_create (contents);
else
- directory->contents = NULL;
+ directory->dump = NULL;
if (! ((directory_table
|| (directory_table = hash_initialize (0, 0,
{
struct directory *dir = make_directory (name);
struct directory *ret = hash_lookup (directory_table, dir);
- free (dir);
+ free_directory (dir);
return ret;
}
}
dir->device_number = dev;
dir->inode_number = ino;
ret = hash_lookup (directory_meta_table, dir);
- free (dir);
+ free_directory (dir);
return ret;
}
}
directories, consider all NFS devices as equal,
relying on the i-node to establish differences. */
- if (! (((DIR_IS_NFS (directory) & nfs)
+ if (! ((!check_device_option
+ || (DIR_IS_NFS (directory) && nfs)
|| directory->device_number == stat_data->st_dev)
&& directory->inode_number == stat_data->st_ino))
{
stat_data->st_ino);
if (d)
{
- if (verbose_option)
- WARN ((0, 0, _("%s: Directory has been renamed from %s"),
- quotearg_colon (name_buffer),
- quote_n (1, d->name)));
- directory->orig = d;
- DIR_SET_FLAG (directory, DIRF_RENAMED);
+ if (strcmp (d->name, name_buffer))
+ {
+ if (verbose_option)
+ WARN ((0, 0, _("%s: Directory has been renamed from %s"),
+ quotearg_colon (name_buffer),
+ quote_n (1, d->name)));
+ directory->orig = d;
+ DIR_SET_FLAG (directory, DIRF_RENAMED);
+ dirlist_replace_prefix (d->name, name_buffer);
+ }
directory->children = CHANGED_CHILDREN;
}
else
if (d)
{
- if (verbose)
- WARN ((0, 0, _("%s: Directory has been renamed from %s"),
- quotearg_colon (name_buffer),
- quote_n (1, d->name)));
- directory->orig = d;
- DIR_SET_FLAG (directory, DIRF_RENAMED);
+ if (strcmp (d->name, name_buffer))
+ {
+ if (verbose)
+ WARN ((0, 0, _("%s: Directory has been renamed from %s"),
+ quotearg_colon (name_buffer),
+ quote_n (1, d->name)));
+ directory->orig = d;
+ DIR_SET_FLAG (directory, DIRF_RENAMED);
+ dirlist_replace_prefix (d->name, name_buffer);
+ }
directory->children = CHANGED_CHILDREN;
}
else
{
const char *tag_file_name;
-
+
switch (check_exclusion_tags (name_buffer, &tag_file_name))
{
case exclusion_tag_all:
_("contents not dumped"));
directory->children = NO_CHILDREN;
break;
-
+
case exclusion_tag_under:
exclusion_tag_warning (name_buffer, tag_file_name,
_("contents not dumped"));
directory->tagfile = tag_file_name;
break;
-
+
case exclusion_tag_none:
break;
}
return directory;
}
-/* Locate NAME in the dumpdir array DUMP.
- Return pointer to the slot in the array, or NULL if not found */
-const char *
-dumpdir_locate (const char *dump, const char *name)
-{
- if (dump)
- while (*dump)
- {
- /* Ignore 'R' (rename) and 'X' (tempname) entries, since they break
- alphabetical ordering.
- They normally do not occur in dumpdirs from the snapshot files,
- but this function is also used by purge_directory, which operates
- on a dumpdir from the archive, hence the need for this test. */
- if (!strchr ("RX", *dump))
- {
- int rc = strcmp (dump + 1, name);
- if (rc == 0)
- return dump;
- if (rc > 1)
- break;
- }
- dump += strlen (dump) + 1;
- }
- return NULL;
-}
-
-/* Return size in bytes of the dumpdir array P */
-size_t
-dumpdir_size (const char *p)
-{
- size_t totsize = 0;
-
- while (*p)
- {
- size_t size = strlen (p) + 1;
- totsize += size;
- p += size;
- }
- return totsize + 1;
-}
-
-static int
-compare_dirnames (const void *first, const void *second)
-{
- char const *const *name1 = first;
- char const *const *name2 = second;
- return strcmp (*name1, *name2);
-}
-
/* Compare dumpdir array from DIRECTORY with directory listing DIR and
build a new dumpdir template.
DIR must be returned by a previous call to savedir().
- File names in DIRECTORY->contents must be sorted
+ File names in DIRECTORY->dump->contents must be sorted
alphabetically.
- DIRECTORY->contents is replaced with the created template. Each entry is
+ DIRECTORY->dump is replaced with the created template. Each entry is
prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
void
const char *p;
char const **array;
char *new_dump, *new_dump_ptr;
- const char *dump;
+ struct dumpdir *dump;
if (directory->children == ALL_CHILDREN)
dump = NULL;
else if (DIR_IS_RENAMED (directory))
- dump = directory->orig->icontents ?
- directory->orig->icontents : directory->orig->contents;
+ dump = directory->orig->idump ?
+ directory->orig->idump : directory->orig->dump;
else
- dump = directory->contents;
+ dump = directory->dump;
/* Count the size of DIR and the number of elements it contains */
dirsize = 0;
{
if (directory->tagfile)
*new_dump_ptr = strcmp (directory->tagfile, array[i]) == 0 ?
- ' ' : 'I';
+ ' ' : 'I';
else
*new_dump_ptr = ' ';
new_dump_ptr++;
- dump = loc + strlen (loc) + 1;
}
else if (directory->tagfile)
*new_dump_ptr++ = strcmp (directory->tagfile, array[i]) == 0 ?
;
}
*new_dump_ptr = 0;
- directory->icontents = directory->contents;
- directory->contents = new_dump;
+ directory->idump = directory->dump;
+ directory->dump = dumpdir_create0 (new_dump, NULL);
free (array);
}
/* Recursively scan the given directory. */
-static char *
+static const char *
scan_directory (char *dir, dev_t device)
{
char *dirp = savedir (dir); /* for scanning directory */
size_t name_length; /* used length in name_buffer */
struct stat stat_data;
struct directory *directory;
-
+
if (! dirp)
savedir_error (dir);
directory = procdir (name_buffer, &stat_data, device, NO_CHILDREN, false,
NULL);
-
+
if (dirp && directory->children != NO_CHILDREN)
{
- char *entry; /* directory entry being scanned */
+ char *entry; /* directory entry being scanned */
size_t entrylen; /* length of directory entry */
+ dumpdir_iter_t itr;
makedumpdir (directory, dirp);
- for (entry = directory->contents;
- (entrylen = strlen (entry)) != 0;
- entry += entrylen + 1)
+ for (entry = dumpdir_first (directory->dump, 1, &itr);
+ entry;
+ entry = dumpdir_next (itr))
{
+ entrylen = strlen (entry);
if (name_buffer_size <= entrylen - 1 + name_length)
{
do
*entry = 'Y';
}
}
+ free (itr);
}
free (name_buffer);
if (dirp)
free (dirp);
- return directory->contents;
+ return directory->dump ? directory->dump->contents : NULL;
}
-char *
+const char *
get_directory_contents (char *dir, dev_t device)
{
return scan_directory (dir, device);
obstack_grow (stk, s, strlen (s) + 1);
}
-static bool
-rename_handler (void *data, void *proc_data)
+static void
+store_rename (struct directory *dir, struct obstack *stk)
{
- struct directory *dir = data;
- struct obstack *stk = proc_data;
-
if (DIR_IS_RENAMED (dir))
{
struct directory *prev, *p;
obstack_code_rename (stk, "", prev->name);
}
}
- return true;
}
const char *
{
struct obstack stk;
size_t size;
-
- if (directory_table == NULL)
+ struct directory *dp;
+
+ if (dirhead == NULL)
return dump;
obstack_init (&stk);
else
size = 0;
- hash_do_for_each (directory_table, rename_handler, &stk);
+ for (dp = dirhead; dp; dp = dp->next)
+ store_rename (dp, &stk);
+
if (obstack_object_size (&stk) != size)
{
obstack_1grow (&stk, 0);
fwrite (s, strlen (s) + 1, 1, fp);
fwrite (directory->name, strlen (directory->name) + 1, 1, fp);
- if (directory->contents)
+ if (directory->dump)
{
- char *p;
- for (p = directory->contents; *p; p += strlen (p) + 1)
- {
- if (strchr ("YND", *p))
- fwrite (p, strlen (p) + 1, 1, fp);
- }
+ const char *p;
+ dumpdir_iter_t itr;
+
+ for (p = dumpdir_first (directory->dump, 0, &itr);
+ p;
+ p = dumpdir_next (itr))
+ fwrite (p, strlen (p) + 1, 1, fp);
+ free (itr);
}
fwrite ("\0\0", 2, 1, fp);
}
char *current_dir;
char *cur, *arc, *p;
char *temp_stub = NULL;
+ struct dumpdir *dump;
if (!is_dumpdir (¤t_stat_info))
return false;
This is an extra safety precaution. Besides, it might be
necessary to extract from archives created with tar versions
prior to 1.19. */
-
+
if (*src)
src = safer_name_suffix (src, false, absolute_names_option);
if (*dst)
dst = safer_name_suffix (dst, false, absolute_names_option);
-
+
if (*src == 0)
src = temp_stub;
else if (*dst == 0)
free (temp_stub);
/* Process deletes */
+ dump = dumpdir_create (current_stat_info.dumpdir);
p = NULL;
for (cur = current_dir; *cur; cur += strlen (cur) + 1)
{
continue;
}
- if (!(entry = dumpdir_locate (current_stat_info.dumpdir, cur))
+ if (!(entry = dumpdir_locate (dump, cur))
|| (*entry == 'D' && !S_ISDIR (st.st_mode))
|| (*entry == 'Y' && S_ISDIR (st.st_mode)))
{
}
}
free (p);
-
+ dumpdir_free (dump);
+
free (current_dir);
return true;
}
projects / chaz / tar / blobdiff