#define DIR_IS_INITED(d) ((d)->flags & DIRF_INIT)
#define DIR_IS_NFS(d) ((d)->flags & DIRF_NFS)
#define DIR_IS_FOUND(d) ((d)->flags & DIRF_FOUND)
-#define DIR_IS_NEW(d) ((d)->flags & DIRF_NEW)
+/* #define DIR_IS_NEW(d) ((d)->flags & DIRF_NEW) FIXME: not used */
#define DIR_IS_RENAMED(d) ((d)->flags & DIRF_RENAMED)
#define DIR_SET_FLAG(d,f) (d)->flags |= (f)
char *name; /* file name of directory */
};
-struct dumpdir *
+static struct dumpdir *
dumpdir_create0 (const char *contents, const char *cmask)
{
struct dumpdir *dump;
size_t i, total, ctsize, len;
char *p;
const char *q;
-
+
for (i = 0, total = 0, ctsize = 1, q = contents; *q; total++, q += len)
{
len = strlen (q) + 1;
return dump;
}
-struct dumpdir *
+static struct dumpdir *
dumpdir_create (const char *contents)
{
return dumpdir_create0 (contents, "YND");
}
-void
+static void
dumpdir_free (struct dumpdir *dump)
{
free (dump->elv);
/* Locate NAME in the dumpdir array DUMP.
Return pointer to the slot in DUMP->contents, or NULL if not found */
-char *
+static char *
dumpdir_locate (struct dumpdir *dump, const char *name)
{
char **ptr;
struct dumpdir_iter
{
struct dumpdir *dump; /* Dumpdir being iterated */
- int all; /* Iterate over all entries, not only D/N/Y */
+ int all; /* Iterate over all entries, not only D/N/Y */
size_t next; /* Index of the next element */
};
-char *
+static char *
dumpdir_next (struct dumpdir_iter *itr)
{
size_t cur = itr->next;
char *ret = NULL;
-
+
if (itr->all)
{
ret = itr->dump->contents + cur;
return ret;
}
-char *
+static char *
dumpdir_first (struct dumpdir *dump, int all, struct dumpdir_iter **pitr)
{
struct dumpdir_iter *itr = xmalloc (sizeof (*itr));
directory->dump = directory->idump = NULL;
directory->orig = NULL;
directory->flags = false;
- if (namelen && ISSLASH (name[namelen - 1]))
+ if (namelen > 1 && ISSLASH (name[namelen - 1]))
namelen--;
directory->name = xmalloc (namelen + 1);
memcpy (directory->name, name, namelen);
dirtail = dir;
return dir;
}
-
+
\f
-void
+static void
dirlist_replace_prefix (const char *pref, const char *repl)
{
struct directory *dp;
replace_prefix (&dp->name, pref, pref_len, repl, repl_len);
}
+void
+clear_directory_table (void)
+{
+ struct directory *dp;
+
+ if (directory_table)
+ hash_clear (directory_table);
+ if (directory_meta_table)
+ hash_clear (directory_meta_table);
+ for (dp = dirhead; dp; )
+ {
+ struct directory *next = dp->next;
+ free_directory (dp);
+ dp = next;
+ }
+ dirhead = dirtail = NULL;
+}
+
/* 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
if (! ((directory_table
|| (directory_table = hash_initialize (0, 0,
hash_directory_canonical_name,
- compare_directory_canonical_names, 0)))
+ compare_directory_canonical_names,
+ 0)))
&& hash_insert (directory_table, directory)))
xalloc_die ();
}
void
-update_parent_directory (const char *name)
+update_parent_directory (struct tar_stat_info *parent)
{
- struct directory *directory;
- char *p;
-
- p = dir_name (name);
- directory = find_directory (p);
+ struct directory *directory = find_directory (parent->orig_file_name);
if (directory)
{
struct stat st;
- if (deref_stat (dereference_option, p, &st) != 0)
- {
- if (errno != ENOENT)
- stat_diag (directory->name);
- /* else: should have been already reported */
- }
+ if (fstat (parent->fd, &st) != 0)
+ stat_diag (directory->name);
else
directory->mtime = get_stat_mtime (&st);
}
- free (p);
}
#define PD_FORCE_CHILDREN 0x10
#define PD_CHILDREN(f) ((f) & 3)
static struct directory *
-procdir (const char *name_buffer, struct stat *stat_data,
- dev_t device,
+procdir (const char *name_buffer, struct tar_stat_info *st,
int flag,
char *entry)
{
struct directory *directory;
+ struct stat *stat_data = &st->stat;
bool nfs = NFS_FILE_STAT (*stat_data);
+ bool perhaps_renamed = false;
if ((directory = find_directory (name_buffer)) != NULL)
{
*entry = 'N';
return directory;
}
-
+
/* With NFS, the same file can have two different devices
if an NFS directory is mounted in multiple locations,
which is relatively common when automounting.
To avoid spurious incremental redumping of
directories, consider all NFS devices as equal,
relying on the i-node to establish differences. */
-
+
if (! ((!check_device_option
|| (DIR_IS_NFS (directory) && nfs)
|| directory->device_number == stat_data->st_dev)
}
else
{
- WARNOPT (WARN_RENAME_DIRECTORY,
- (0, 0, _("%s: Directory has been renamed"),
- quotearg_colon (name_buffer)));
+ perhaps_renamed = true;
directory->children = ALL_CHILDREN;
directory->device_number = stat_data->st_dev;
directory->inode_number = stat_data->st_ino;
}
else
directory->children = CHANGED_CHILDREN;
-
+
DIR_SET_FLAG (directory, DIRF_FOUND);
}
else
{
struct directory *d = find_directory_meta (stat_data->st_dev,
stat_data->st_ino);
-
+
directory = note_directory (name_buffer,
- get_stat_mtime(stat_data),
+ get_stat_mtime (stat_data),
stat_data->st_dev,
stat_data->st_ino,
nfs,
}
}
- /* If the directory is on another device and --one-file-system was given,
- omit it... */
- if (one_file_system_option && device != stat_data->st_dev
- /* ... except if it was explicitely given in the command line */
- && !is_individual_file (name_buffer))
- /* FIXME:
- WARNOPT (WARN_XDEV,
- (0, 0,
- _("%s: directory is on a different filesystem; not dumped"),
- quotearg_colon (directory->name)));
- */
- directory->children = NO_CHILDREN;
+ if (one_file_system_option && st->parent
+ && stat_data->st_dev != st->parent->stat.st_dev)
+ {
+ WARNOPT (WARN_XDEV,
+ (0, 0,
+ _("%s: directory is on a different filesystem; not dumped"),
+ quotearg_colon (directory->name)));
+ directory->children = NO_CHILDREN;
+ /* If there is any dumpdir info in that directory, remove it */
+ if (directory->dump)
+ {
+ dumpdir_free (directory->dump);
+ directory->dump = NULL;
+ }
+ perhaps_renamed = false;
+ }
+
else if (flag & PD_FORCE_CHILDREN)
{
directory->children = PD_CHILDREN(flag);
if (directory->children == NO_CHILDREN)
*entry = 'N';
}
-
+
+ if (perhaps_renamed)
+ WARNOPT (WARN_RENAME_DIRECTORY,
+ (0, 0, _("%s: Directory has been renamed"),
+ quotearg_colon (name_buffer)));
+
DIR_SET_FLAG (directory, DIRF_INIT);
if (directory->children != NO_CHILDREN)
{
const char *tag_file_name;
- switch (check_exclusion_tags (name_buffer, &tag_file_name))
+ switch (check_exclusion_tags (st, &tag_file_name))
{
case exclusion_tag_all:
/* This warning can be duplicated by code in dump_file0, but only
_("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;
}
DIRECTORY->dump is replaced with the created template. Each entry is
prefixed with ' ' if it was present in DUMP and with 'Y' otherwise. */
-void
+static void
makedumpdir (struct directory *directory, const char *dir)
{
size_t i,
free (array);
}
-/* Recursively scan the given directory DIR.
- DEVICE is the device number where DIR resides (for --one-file-system).
- If CMDLINE is true, the directory name was explicitly listed in the
- command line.
- Unless *PDIR is NULL, store there a pointer to the struct directory
- describing DIR. */
+/* Recursively scan the directory identified by ST. */
struct directory *
-scan_directory (char *dir, dev_t device, bool cmdline)
+scan_directory (struct tar_stat_info *st)
{
- char *dirp = savedir (dir); /* for scanning directory */
+ char const *dir = st->orig_file_name;
+ char *dirp = get_directory_entries (st);
+ dev_t device = st->stat.st_dev;
+ bool cmdline = ! st->parent;
namebuf_t nbuf;
char *tmp;
- struct stat stat_data;
struct directory *directory;
char ch;
-
+
if (! dirp)
savedir_error (dir);
tmp = xstrdup (dir);
zap_slashes (tmp);
-
- if (deref_stat (dereference_option, tmp, &stat_data))
- {
- dir_removed_diag (tmp, cmdline, stat_diag);
- free (tmp);
- free (dirp);
- return NULL;
- }
- directory = procdir (tmp, &stat_data, device,
+ directory = procdir (tmp, st,
(cmdline ? PD_FORCE_INIT : 0),
&ch);
-
+
free (tmp);
nbuf = namebuf_create (dir);
if (dirp && directory->children != NO_CHILDREN)
{
char *entry; /* directory entry being scanned */
- dumpdir_iter_t itr;
+ struct dumpdir_iter *itr;
makedumpdir (directory, dirp);
*entry = 'N';
else
{
- if (deref_stat (dereference_option, full_name, &stat_data))
+ int fd = st->fd;
+ void (*diag) (char const *) = 0;
+ struct tar_stat_info stsub;
+ tar_stat_init (&stsub);
+
+ if (fd < 0)
{
- file_removed_diag (full_name, false, stat_diag);
- *entry = 'N';
- continue;
+ errno = - fd;
+ diag = open_diag;
+ }
+ else if (fstatat (fd, entry + 1, &stsub.stat, fstatat_flags) != 0)
+ diag = stat_diag;
+ else if (S_ISDIR (stsub.stat.st_mode))
+ {
+ int subfd = subfile_open (st, entry + 1, open_read_flags);
+ if (subfd < 0)
+ diag = open_diag;
+ else
+ {
+ stsub.fd = subfd;
+ if (fstat (subfd, &stsub.stat) != 0)
+ diag = stat_diag;
+ }
}
- if (S_ISDIR (stat_data.st_mode))
+ if (diag)
+ {
+ file_removed_diag (full_name, false, diag);
+ *entry = 'N';
+ }
+ else if (S_ISDIR (stsub.stat.st_mode))
{
int pd_flag = 0;
if (!recursion_option)
else if (directory->children == ALL_CHILDREN)
pd_flag |= PD_FORCE_CHILDREN | ALL_CHILDREN;
*entry = 'D';
- procdir (full_name, &stat_data, device, pd_flag, entry);
- }
- else if (one_file_system_option && device != stat_data.st_dev)
+ stsub.parent = st;
+ procdir (full_name, &stsub, pd_flag, entry);
+ restore_parent_fd (&stsub);
+ }
+ else if (one_file_system_option && device != stsub.stat.st_dev)
*entry = 'N';
-
else if (*entry == 'Y')
/* New entry, skip further checks */;
-
/* FIXME: if (S_ISHIDDEN (stat_data.st_mode))?? */
-
- else if (OLDER_STAT_TIME (stat_data, m)
+ else if (OLDER_STAT_TIME (stsub.stat, m)
&& (!after_date_option
- || OLDER_STAT_TIME (stat_data, c)))
+ || OLDER_STAT_TIME (stsub.stat, c)))
*entry = 'N';
else
*entry = 'Y';
+
+ tar_stat_destroy (&stsub);
}
}
free (itr);
namebuf_free (nbuf);
- if (dirp)
- free (dirp);
+ free (dirp);
return directory;
}
return ret ? ret : "\0\0\0\0";
}
-void
-name_fill_directory (struct name *name, dev_t device, bool cmdline)
-{
- name->directory = scan_directory (name->name, device, cmdline);
-}
-
\f
static void
-obstack_code_rename (struct obstack *stk, char *from, char *to)
+obstack_code_rename (struct obstack *stk, char const *from, char const *to)
{
- char *s;
+ char const *s;
s = from[0] == 0 ? from :
safer_name_suffix (from, false, absolute_names_option);
are ignored when hit by this function next time.
If the chain forms a cycle, prev points to the entry DIR is renamed
from. In this case it still retains DIRF_RENAMED flag, which will be
- cleared in the `else' branch below */
+ cleared in the 'else' branch below */
for (prev = dir; prev && prev->orig != dir; prev = prev->orig)
DIR_CLEAR_FLAG (prev, DIRF_RENAMED);
size_t size;
struct directory *dp;
const char *dump;
-
+
if (dirhead == NULL)
return;
for (dp = dirhead; dp; dp = dp->next)
store_rename (dp, &stk);
- if (obstack_object_size (&stk) != size)
+ /* FIXME: Is this the right thing to do when DIR is null? */
+ if (dir && obstack_object_size (&stk) != size)
{
obstack_1grow (&stk, 0);
dumpdir_free (dir->dump);
{
int n;
uintmax_t u;
- time_t sec;
- long int nsec;
char *buf = NULL;
size_t bufsize = 0;
char *ebuf;
bufsize = strlen (buf) + 1;
}
- sec = TYPE_MINIMUM (time_t);
- nsec = -1;
- errno = 0;
- u = strtoumax (buf, &ebuf, 10);
- if (!errno && TYPE_MAXIMUM (time_t) < u)
- errno = ERANGE;
- if (errno || buf == ebuf)
+ newer_mtime_option = decode_timespec (buf, &ebuf, false);
+
+ if (! valid_timespec (newer_mtime_option))
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option),
lineno,
_("Invalid time stamp")));
else
{
- sec = u;
-
if (version == 1 && *ebuf)
{
char const *buf_ns = ebuf + 1;
quotearg_colon (listed_incremental_option),
lineno,
_("Invalid time stamp")));
- sec = TYPE_MINIMUM (time_t);
+ newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
+ newer_mtime_option.tv_nsec = -1;
}
else
- nsec = u;
- }
- else
- {
- /* pre-1 incremental format does not contain nanoseconds */
- nsec = 0;
+ newer_mtime_option.tv_nsec = u;
}
}
- newer_mtime_option.tv_sec = sec;
- newer_mtime_option.tv_nsec = nsec;
-
while (0 < (n = getline (&buf, &bufsize, listed_incremental_stream)))
{
if (version == 1)
{
- errno = 0;
- u = strtoumax (strp, &ebuf, 10);
- if (!errno && TYPE_MAXIMUM (time_t) < u)
- errno = ERANGE;
- if (errno || strp == ebuf || *ebuf != ' ')
- {
- ERROR ((0, errno, "%s:%ld: %s",
- quotearg_colon (listed_incremental_option), lineno,
- _("Invalid modification time (seconds)")));
- sec = (time_t) -1;
- }
- else
- sec = u;
+ mtime = decode_timespec (strp, &ebuf, false);
strp = ebuf;
+ if (!valid_timespec (mtime) || *strp != ' ')
+ ERROR ((0, errno, "%s:%ld: %s",
+ quotearg_colon (listed_incremental_option), lineno,
+ _("Invalid modification time")));
errno = 0;
u = strtoumax (strp, &ebuf, 10);
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid modification time (nanoseconds)")));
- nsec = -1;
+ mtime.tv_nsec = -1;
}
else
- nsec = u;
- mtime.tv_sec = sec;
- mtime.tv_nsec = nsec;
+ mtime.tv_nsec = u;
strp = ebuf;
}
else
- memset (&mtime, 0, sizeof mtime);
+ mtime.tv_sec = mtime.tv_nsec = 0;
- errno = 0;
- u = strtoumax (strp, &ebuf, 10);
- if (!errno && TYPE_MAXIMUM (dev_t) < u)
- errno = ERANGE;
- if (errno || strp == ebuf || *ebuf != ' ')
- {
- ERROR ((0, errno, "%s:%ld: %s",
- quotearg_colon (listed_incremental_option), lineno,
- _("Invalid device number")));
- dev = (dev_t) -1;
- }
- else
- dev = u;
+ dev = strtosysint (strp, &ebuf,
+ TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t));
strp = ebuf;
+ if (errno || *strp != ' ')
+ ERROR ((0, errno, "%s:%ld: %s",
+ quotearg_colon (listed_incremental_option), lineno,
+ _("Invalid device number")));
- errno = 0;
- u = strtoumax (strp, &ebuf, 10);
- if (!errno && TYPE_MAXIMUM (ino_t) < u)
- errno = ERANGE;
- if (errno || strp == ebuf || *ebuf != ' ')
- {
- ERROR ((0, errno, "%s:%ld: %s",
- quotearg_colon (listed_incremental_option), lineno,
- _("Invalid inode number")));
- ino = (ino_t) -1;
- }
- else
- ino = u;
+ ino = strtosysint (strp, &ebuf,
+ TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t));
strp = ebuf;
+ if (errno || *strp != ' ')
+ ERROR ((0, errno, "%s:%ld: %s",
+ quotearg_colon (listed_incremental_option), lineno,
+ _("Invalid inode number")));
strp++;
unquote_string (strp);
/* Read incremental snapshot format 2 */
static void
-read_incr_db_2 ()
+read_incr_db_2 (void)
{
uintmax_t u;
struct obstack stk;
which is necessary to recreate absolute file names. */
name_from_list ();
blank_name_list ();
-
+
if (0 < getline (&buf, &bufsize, listed_incremental_stream))
{
char *ebuf;
if (ferror (listed_incremental_stream))
read_error (listed_incremental_option);
- if (buf)
- free (buf);
+ free (buf);
}
/* Output incremental data for the directory ENTRY to the file DATA.
if (DIR_IS_FOUND (directory))
{
- char buf[UINTMAX_STRSIZE_BOUND];
- char *s;
+ char buf[max (SYSINT_BUFSIZE, INT_BUFSIZE_BOUND (intmax_t))];
+ char const *s;
s = DIR_IS_NFS (directory) ? "1" : "0";
fwrite (s, 2, 1, fp);
- s = (TYPE_SIGNED (time_t)
- ? imaxtostr (directory->mtime.tv_sec, buf)
- : umaxtostr (directory->mtime.tv_sec, buf));
+ s = sysinttostr (directory->mtime.tv_sec, TYPE_MINIMUM (time_t),
+ TYPE_MAXIMUM (time_t), buf);
fwrite (s, strlen (s) + 1, 1, fp);
- s = umaxtostr (directory->mtime.tv_nsec, buf);
+ s = imaxtostr (directory->mtime.tv_nsec, buf);
fwrite (s, strlen (s) + 1, 1, fp);
- s = umaxtostr (directory->device_number, buf);
+ s = sysinttostr (directory->device_number,
+ TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t), buf);
fwrite (s, strlen (s) + 1, 1, fp);
- s = umaxtostr (directory->inode_number, buf);
+ s = sysinttostr (directory->inode_number,
+ TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t), buf);
fwrite (s, strlen (s) + 1, 1, fp);
fwrite (directory->name, strlen (directory->name) + 1, 1, fp);
if (directory->dump)
{
const char *p;
- dumpdir_iter_t itr;
+ struct dumpdir_iter *itr;
for (p = dumpdir_first (directory->dump, 0, &itr);
p;
if (! fp)
return;
- if (fseek (fp, 0L, SEEK_SET) != 0)
+ if (fseeko (fp, 0L, SEEK_SET) != 0)
seek_error (listed_incremental_option);
if (sys_truncate (fileno (fp)) != 0)
truncate_error (listed_incremental_option);
to = archive_dir;
set_next_block_after (current_header);
- mv_begin (stat_info);
+ mv_begin_read (stat_info);
for (; size > 0; size -= copied)
{
{
const char *entry;
struct stat st;
- if (p)
- free (p);
+ free (p);
p = new_name (directory_name, cur);
- if (deref_stat (false, p, &st))
+ if (deref_stat (p, &st) != 0)
{
if (errno != ENOENT) /* FIXME: Maybe keep a list of renamed
dirs and check it here? */
}
free (p);
dumpdir_free (dump);
-
+
free (current_dir);
return true;
}
projects / chaz / tar / blobdiff