#include "system.h"
#if !MSDOS
# include <pwd.h>
# include <grp.h>
#endif
#if HAVE_UTIME_H
# include <utime.h>
#else
struct utimbuf
{
long actime;
long modtime;
};
#endif
#include <quotearg.h>
#include "common.h"
#include <hash.h>
#ifndef MSDOS
extern dev_t ar_dev;
extern ino_t ar_ino;
#endif
struct link
{
dev_t dev;
ino_t ino;
char name[1];
};
#define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
: (uintmax_t) -1)
static void
to_octal (uintmax_t value, char *where, size_t size)
{
uintmax_t v = value;
size_t i = size;
do
{
where[--i] = '0' + (v & ((1 << LG_8) - 1));
v >>= LG_8;
}
while (i);
}
static void
to_base256 (int negative, uintmax_t value, char *where, size_t size)
{
uintmax_t v = value;
uintmax_t propagated_sign_bits =
((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
size_t i = size;
do
{
where[--i] = v & ((1 << LG_256) - 1);
v = propagated_sign_bits | (v >> LG_256);
}
while (i);
}
static void
to_chars (int negative, uintmax_t value, size_t valsize,
uintmax_t (*substitute) PARAMS ((int *)),
char *where, size_t size, const char *type)
{
int base256_allowed = (archive_format == GNU_FORMAT
|| archive_format == OLDGNU_FORMAT);
if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
{
where[size - 1] = '\0';
to_octal (value, where, size - 1);
}
else if (((negative ? -1 - value : value)
<= MAX_VAL_WITH_DIGITS (size - 1, LG_256))
&& base256_allowed)
{
where[0] = negative ? -1 : 1 << (LG_256 - 1);
to_base256 (negative, value, where + 1, size - 1);
}
else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
{
static int warned_once;
if (! warned_once)
{
warned_once = 1;
WARN ((0, 0, _("Generating negative octal headers")));
}
where[size - 1] = '\0';
to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
where, size - 1);
}
else
{
uintmax_t maxval = (base256_allowed
? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
: MAX_VAL_WITH_DIGITS (size - 1, LG_8));
char valbuf[UINTMAX_STRSIZE_BOUND + 1];
char maxbuf[UINTMAX_STRSIZE_BOUND];
char minbuf[UINTMAX_STRSIZE_BOUND + 1];
char const *minval_string;
char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
char const *value_string;
if (base256_allowed)
{
uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
char *p = STRINGIFY_BIGINT (m, minbuf + 1);
*--p = '-';
minval_string = p;
}
else
minval_string = "0";
if (negative)
{
char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
*--p = '-';
value_string = p;
}
else
value_string = STRINGIFY_BIGINT (value, valbuf);
if (substitute)
{
int negsub;
uintmax_t sub = substitute (&negsub) & maxval;
uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
char subbuf[UINTMAX_STRSIZE_BOUND + 1];
char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
if (negsub)
*--sub_string = '-';
WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
value_string, type, minval_string, maxval_string,
sub_string));
to_chars (negsub, s, valsize, 0, where, size, type);
}
else
ERROR ((0, 0, _("value %s out of %s range %s..%s"),
value_string, type, minval_string, maxval_string));
}
}
static uintmax_t
gid_substitute (int *negative)
{
gid_t r;
#ifdef GID_NOBODY
r = GID_NOBODY;
#else
static gid_t gid_nobody;
if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
gid_nobody = -2;
r = gid_nobody;
#endif
*negative = r < 0;
return r;
}
void
gid_to_chars (gid_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
}
void
major_to_chars (major_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
}
void
minor_to_chars (minor_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
}
void
mode_to_chars (mode_t v, char *p, size_t s)
{
int negative;
uintmax_t u;
if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
&& S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
&& S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
&& S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
&& archive_format != POSIX_FORMAT
&& archive_format != GNU_FORMAT)
{
negative = v < 0;
u = v;
}
else
{
negative = 0;
u = ((v & S_ISUID ? TSUID : 0)
| (v & S_ISGID ? TSGID : 0)
| (v & S_ISVTX ? TSVTX : 0)
| (v & S_IRUSR ? TUREAD : 0)
| (v & S_IWUSR ? TUWRITE : 0)
| (v & S_IXUSR ? TUEXEC : 0)
| (v & S_IRGRP ? TGREAD : 0)
| (v & S_IWGRP ? TGWRITE : 0)
| (v & S_IXGRP ? TGEXEC : 0)
| (v & S_IROTH ? TOREAD : 0)
| (v & S_IWOTH ? TOWRITE : 0)
| (v & S_IXOTH ? TOEXEC : 0));
}
to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
}
void
off_to_chars (off_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
}
void
size_to_chars (size_t v, char *p, size_t s)
{
to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
}
void
time_to_chars (time_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
}
static uintmax_t
uid_substitute (int *negative)
{
uid_t r;
#ifdef UID_NOBODY
r = UID_NOBODY;
#else
static uid_t uid_nobody;
if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
uid_nobody = -2;
r = uid_nobody;
#endif
*negative = r < 0;
return r;
}
void
uid_to_chars (uid_t v, char *p, size_t s)
{
to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
}
void
uintmax_to_chars (uintmax_t v, char *p, size_t s)
{
to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
}
static void
clear_buffer (char *buffer)
{
memset (buffer, 0, BLOCKSIZE);
}
void
write_eot (void)
{
union block *pointer = find_next_block ();
memset (pointer->buffer, 0, BLOCKSIZE);
set_next_block_after (pointer);
pointer = find_next_block ();
memset (pointer->buffer, 0, available_space_after (pointer));
set_next_block_after (pointer);
}
static union block *start_header PARAMS ((const char *, struct stat *));
static void
write_long (const char *p, char type)
{
size_t size = strlen (p) + 1;
size_t bufsize;
union block *header;
struct stat foo;
memset (&foo, 0, sizeof foo);
foo.st_size = size;
header = start_header ("././@LongLink", &foo);
header->header.typeflag = type;
finish_header (header);
header = find_next_block ();
bufsize = available_space_after (header);
while (bufsize < size)
{
memcpy (header->buffer, p, bufsize);
p += bufsize;
size -= bufsize;
set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
header = find_next_block ();
bufsize = available_space_after (header);
}
memcpy (header->buffer, p, size);
memset (header->buffer + size, 0, bufsize - size);
set_next_block_after (header + (size - 1) / BLOCKSIZE);
}
static char const *
relativize (char const *name)
{
if (! absolute_names_option)
{
{
static int warned_once;
if (! warned_once && contains_dot_dot (name))
{
warned_once = 1;
WARN ((0, 0, _("Member names contain `..'")));
}
}
{
size_t prefix_len = FILESYSTEM_PREFIX_LEN (name);
while (ISSLASH (name[prefix_len]))
prefix_len++;
if (prefix_len)
{
static int warned_once;
if (!warned_once)
{
warned_once = 1;
WARN ((0, 0, _("Removing leading `%.*s' from member names"),
(int) prefix_len, name));
}
name += prefix_len;
}
}
}
return name;
}
static union block *
start_header (const char *name, struct stat *st)
{
union block *header;
name = relativize (name);
if (sizeof header->header.name <= strlen (name))
write_long (name, GNUTYPE_LONGNAME);
header = find_next_block ();
memset (header->buffer, 0, sizeof (union block));
assign_string (¤t_file_name, name);
strncpy (header->header.name, name, NAME_FIELD_SIZE);
header->header.name[NAME_FIELD_SIZE - 1] = '\0';
if (owner_option != (uid_t) -1)
st->st_uid = owner_option;
if (group_option != (gid_t) -1)
st->st_gid = group_option;
if (mode_option)
st->st_mode = ((st->st_mode & ~MODE_ALL)
| mode_adjust (st->st_mode, mode_option));
if (archive_format == V7_FORMAT)
MODE_TO_CHARS (st->st_mode & MODE_ALL, header->header.mode);
else
MODE_TO_CHARS (st->st_mode, header->header.mode);
UID_TO_CHARS (st->st_uid, header->header.uid);
GID_TO_CHARS (st->st_gid, header->header.gid);
OFF_TO_CHARS (st->st_size, header->header.size);
TIME_TO_CHARS (st->st_mtime, header->header.mtime);
if (incremental_option)
if (archive_format == OLDGNU_FORMAT)
{
TIME_TO_CHARS (st->st_atime, header->oldgnu_header.atime);
TIME_TO_CHARS (st->st_ctime, header->oldgnu_header.ctime);
}
header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
switch (archive_format)
{
case V7_FORMAT:
break;
case OLDGNU_FORMAT:
strcpy (header->header.magic, OLDGNU_MAGIC);
break;
case POSIX_FORMAT:
case GNU_FORMAT:
strncpy (header->header.magic, TMAGIC, TMAGLEN);
strncpy (header->header.version, TVERSION, TVERSLEN);
break;
default:
abort ();
}
if (archive_format == V7_FORMAT || numeric_owner_option)
{
}
else
{
uid_to_uname (st->st_uid, header->header.uname);
gid_to_gname (st->st_gid, header->header.gname);
}
return header;
}
void
finish_header (union block *header)
{
size_t i;
int sum;
char *p;
memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
sum = 0;
p = header->buffer;
for (i = sizeof *header; i-- != 0; )
sum += 0xFF & *p++;
uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
if (verbose_option
&& header->header.typeflag != GNUTYPE_LONGLINK
&& header->header.typeflag != GNUTYPE_LONGNAME)
{
current_header = header;
current_format = archive_format;
print_header ();
}
set_next_block_after (header);
}
static int
zero_block_p (char *buffer)
{
int counter;
for (counter = 0; counter < BLOCKSIZE; counter++)
if (buffer[counter] != '\0')
return 0;
return 1;
}
static void
init_sparsearray (void)
{
sp_array_size = 10;
sparsearray = xmalloc (sp_array_size * sizeof (struct sp_array));
}
static off_t
find_new_file_size (int sparses)
{
int i;
off_t s = 0;
for (i = 0; i < sparses; i++)
s += sparsearray[i].numbytes;
return s;
}
static int
deal_with_sparse (char *name, union block *header)
{
size_t numbytes = 0;
off_t offset = 0;
int file;
int sparses = 0;
ssize_t count;
char buffer[BLOCKSIZE];
if (archive_format == OLDGNU_FORMAT)
header->oldgnu_header.isextended = 0;
if (file = open (name, O_RDONLY), file < 0)
return 0;
init_sparsearray ();
clear_buffer (buffer);
for (;;)
{
if (sp_array_size <= sparses)
{
sparsearray =
xrealloc (sparsearray,
2 * sp_array_size * sizeof (struct sp_array));
sp_array_size *= 2;
}
count = safe_read (file, buffer, sizeof buffer);
if (count <= 0)
break;
if (count == sizeof buffer)
if (zero_block_p (buffer))
{
if (numbytes)
{
sparsearray[sparses++].numbytes = numbytes;
numbytes = 0;
}
}
else
{
if (!numbytes)
sparsearray[sparses].offset = offset;
numbytes += count;
}
else
if (!zero_block_p (buffer))
{
if (!numbytes)
sparsearray[sparses].offset = offset;
numbytes += count;
}
else
if (numbytes)
numbytes += count;
offset += count;
clear_buffer (buffer);
}
if (numbytes)
sparsearray[sparses++].numbytes = numbytes;
else
{
sparsearray[sparses].offset = offset - 1;
sparsearray[sparses++].numbytes = 1;
}
return close (file) == 0 && 0 <= count ? sparses : 0;
}
static int
finish_sparse_file (int file, off_t *sizeleft, off_t fullsize, char *name)
{
union block *start;
size_t bufsize;
int sparses = 0;
ssize_t count;
while (*sizeleft > 0)
{
start = find_next_block ();
memset (start->buffer, 0, BLOCKSIZE);
bufsize = sparsearray[sparses].numbytes;
if (! bufsize)
abort ();
if (lseek (file, sparsearray[sparses++].offset, SEEK_SET) < 0)
{
(ignore_failed_read_option ? seek_warn_details : seek_error_details)
(name, sparsearray[sparses - 1].offset);
break;
}
while (bufsize > BLOCKSIZE)
{
count = safe_read (file, start->buffer, BLOCKSIZE);
if (count < 0)
{
(ignore_failed_read_option
? read_warn_details
: read_error_details)
(name, fullsize - *sizeleft, bufsize);
return 1;
}
bufsize -= count;
*sizeleft -= count;
set_next_block_after (start);
start = find_next_block ();
memset (start->buffer, 0, BLOCKSIZE);
}
{
char buffer[BLOCKSIZE];
clear_buffer (buffer);
count = safe_read (file, buffer, bufsize);
memcpy (start->buffer, buffer, BLOCKSIZE);
}
if (count < 0)
{
(ignore_failed_read_option
? read_warn_details
: read_error_details)
(name, fullsize - *sizeleft, bufsize);
return 1;
}
*sizeleft -= count;
set_next_block_after (start);
}
free (sparsearray);
#if 0
set_next_block_after (start + (count - 1) / BLOCKSIZE);
#endif
return 0;
}
void
create_archive (void)
{
char *p;
open_archive (ACCESS_WRITE);
if (incremental_option)
{
size_t buffer_size = 1000;
char *buffer = xmalloc (buffer_size);
const char *q;
collect_and_sort_names ();
while (p = name_from_list (), p)
if (!excluded_name (p))
dump_file (p, -1, (dev_t) 0);
blank_name_list ();
while (p = name_from_list (), p)
if (!excluded_name (p))
{
size_t plen = strlen (p);
if (buffer_size <= plen)
{
while ((buffer_size *= 2) <= plen)
continue;
buffer = xrealloc (buffer, buffer_size);
}
memcpy (buffer, p, plen);
if (! ISSLASH (buffer[plen - 1]))
buffer[plen++] = '/';
q = gnu_list_name->dir_contents;
if (q)
while (*q)
{
size_t qlen = strlen (q);
if (*q == 'Y')
{
if (buffer_size < plen + qlen)
{
while ((buffer_size *=2 ) < plen + qlen)
continue;
buffer = xrealloc (buffer, buffer_size);
}
strcpy (buffer + plen, q + 1);
dump_file (buffer, -1, (dev_t) 0);
}
q += qlen + 1;
}
}
free (buffer);
}
else
{
while (p = name_next (1), p)
if (!excluded_name (p))
dump_file (p, 1, (dev_t) 0);
}
write_eot ();
close_archive ();
if (listed_incremental_option)
write_directory_file ();
}
static unsigned
hash_link (void const *entry, unsigned n_buckets)
{
struct link const *link = entry;
return (uintmax_t) (link->dev ^ link->ino) % n_buckets;
}
static bool
compare_links (void const *entry1, void const *entry2)
{
struct link const *link1 = entry1;
struct link const *link2 = entry2;
return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
}
void
dump_file (char *p, int top_level, dev_t parent_device)
{
union block *header;
char type;
union block *exhdr;
char save_typeflag;
time_t original_ctime;
struct utimbuf restore_times;
if (interactive_option && !confirm ("add", p))
return;
if (deref_stat (dereference_option, p, ¤t_stat) != 0)
{
if (ignore_failed_read_option)
stat_warn (p);
else
stat_error (p);
return;
}
original_ctime = current_stat.st_ctime;
restore_times.actime = current_stat.st_atime;
restore_times.modtime = current_stat.st_mtime;
#ifdef S_ISHIDDEN
if (S_ISHIDDEN (current_stat.st_mode))
{
char *new = (char *) alloca (strlen (p) + 2);
if (new)
{
strcpy (new, p);
strcat (new, "@");
p = new;
}
}
#endif
if ((0 < top_level || !incremental_option)
&& !S_ISDIR (current_stat.st_mode)
&& current_stat.st_mtime < newer_mtime_option
&& (!after_date_option || current_stat.st_ctime < newer_ctime_option))
{
if (0 < top_level)
WARN ((0, 0, _("%s: file is unchanged; not dumped"),
quotearg_colon (p)));
return;
}
#if !MSDOS
if (ar_dev && current_stat.st_dev == ar_dev && current_stat.st_ino == ar_ino)
{
WARN ((0, 0, _("%s: file is the archive; not dumped"),
quotearg_colon (p)));
return;
}
#endif
if (S_ISDIR (current_stat.st_mode))
{
char *directory;
char const *entry;
size_t entrylen;
char *namebuf;
size_t buflen;
size_t len;
dev_t our_device = current_stat.st_dev;
errno = 0;
directory = savedir (p);
if (! directory)
{
if (ignore_failed_read_option)
savedir_warn (p);
else
savedir_error (p);
return;
}
len = strlen (p);
buflen = len + NAME_FIELD_SIZE;
namebuf = xmalloc (buflen + 1);
memcpy (namebuf, p, len);
while (len >= 1 && ISSLASH (namebuf[len - 1]))
len--;
namebuf[len++] = '/';
namebuf[len] = '\0';
if (! is_avoided_name (namebuf))
{
current_stat.st_size = 0;
header = start_header (namebuf, ¤t_stat);
if (incremental_option)
header->header.typeflag = GNUTYPE_DUMPDIR;
else
header->header.typeflag = DIRTYPE;
if (!incremental_option)
finish_header (header);
}
if (incremental_option && gnu_list_name->dir_contents)
{
off_t sizeleft;
off_t totsize;
size_t bufsize;
union block *start;
ssize_t count;
const char *buffer, *p_buffer;
buffer = gnu_list_name->dir_contents;
totsize = 0;
for (p_buffer = buffer; p_buffer && *p_buffer;)
{
size_t tmp;
tmp = strlen (p_buffer) + 1;
totsize += tmp;
p_buffer += tmp;
}
totsize++;
OFF_TO_CHARS (totsize, header->header.size);
finish_header (header);
p_buffer = buffer;
sizeleft = totsize;
while (sizeleft > 0)
{
if (multi_volume_option)
{
assign_string (&save_name, p);
save_sizeleft = sizeleft;
save_totsize = totsize;
}
start = find_next_block ();
bufsize = available_space_after (start);
if (sizeleft < bufsize)
{
bufsize = sizeleft;
count = bufsize % BLOCKSIZE;
if (count)
memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
}
memcpy (start->buffer, p_buffer, bufsize);
sizeleft -= bufsize;
p_buffer += bufsize;
set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
}
if (multi_volume_option)
assign_string (&save_name, 0);
goto finish_dir;
}
if (! recursion_option)
goto finish_dir;
if (one_file_system_option && !top_level
&& parent_device != current_stat.st_dev)
{
if (verbose_option)
WARN ((0, 0,
_("%s: file is on a different filesystem; not dumped"),
quotearg_colon (p)));
goto finish_dir;
}
for (entry = directory;
(entrylen = strlen (entry)) != 0;
entry += entrylen + 1)
{
if (buflen <= len + entrylen)
{
buflen = len + entrylen;
namebuf = xrealloc (namebuf, buflen + 1);
}
strcpy (namebuf + len, entry);
if (!excluded_name (namebuf))
dump_file (namebuf, 0, our_device);
}
finish_dir:
free (directory);
free (namebuf);
if (atime_preserve_option)
utime (p, &restore_times);
return;
}
else if (is_avoided_name (p))
return;
else
{
if (1 < current_stat.st_nlink)
{
static Hash_table *link_table;
struct link *lp = xmalloc (offsetof (struct link, name)
+ strlen (p) + 1);
struct link *dup;
lp->ino = current_stat.st_ino;
lp->dev = current_stat.st_dev;
strcpy (lp->name, p);
if (! ((link_table
|| (link_table = hash_initialize (0, 0, hash_link,
compare_links, 0)))
&& (dup = hash_insert (link_table, lp))))
xalloc_die ();
if (dup != lp)
{
char const *link_name = relativize (dup->name);
free (lp);
if (NAME_FIELD_SIZE <= strlen (link_name))
write_long (link_name, GNUTYPE_LONGLINK);
assign_string (¤t_link_name, link_name);
current_stat.st_size = 0;
header = start_header (p, ¤t_stat);
strncpy (header->header.linkname, link_name, NAME_FIELD_SIZE);
header->header.linkname[NAME_FIELD_SIZE - 1] = 0;
header->header.typeflag = LNKTYPE;
finish_header (header);
if (remove_files_option && unlink (p) != 0)
unlink_error (p);
return;
}
}
if (S_ISREG (current_stat.st_mode)
|| S_ISCTG (current_stat.st_mode))
{
int f;
size_t bufsize;
ssize_t count;
off_t sizeleft;
union block *start;
int header_moved;
char isextended = 0;
int sparses = 0;
header_moved = 0;
if (sparse_option)
{
if (ST_NBLOCKS (current_stat)
< (current_stat.st_size / ST_NBLOCKSIZE
+ (current_stat.st_size % ST_NBLOCKSIZE != 0)))
{
int counter;
header = start_header (p, ¤t_stat);
header->header.typeflag = GNUTYPE_SPARSE;
header_moved = 1;
sparses = deal_with_sparse (p, header);
if (SPARSES_IN_OLDGNU_HEADER < sparses)
header->oldgnu_header.isextended = 1;
OFF_TO_CHARS (current_stat.st_size,
header->oldgnu_header.realsize);
current_stat.st_size = find_new_file_size (sparses);
OFF_TO_CHARS (current_stat.st_size, header->header.size);
for (counter = 0;
counter < sparses && counter < SPARSES_IN_OLDGNU_HEADER;
counter++)
{
OFF_TO_CHARS (sparsearray[counter].offset,
header->oldgnu_header.sp[counter].offset);
SIZE_TO_CHARS (sparsearray[counter].numbytes,
header->oldgnu_header.sp[counter].numbytes);
}
}
}
sizeleft = current_stat.st_size;
if (dev_null_output
|| (sizeleft == 0
&& MODE_R == (MODE_R & current_stat.st_mode)))
f = -1;
else
{
f = open (p, O_RDONLY | O_BINARY);
if (f < 0)
{
if (! top_level && errno == ENOENT)
WARN ((0, 0, _("%s: File removed before we read it"),
quotearg_colon (p)));
else
(ignore_failed_read_option ? open_warn : open_error) (p);
return;
}
}
if (!header_moved)
header = start_header (p, ¤t_stat);
if (archive_format != V7_FORMAT && S_ISCTG (current_stat.st_mode))
header->header.typeflag = CONTTYPE;
isextended = header->oldgnu_header.isextended;
save_typeflag = header->header.typeflag;
finish_header (header);
if (isextended)
{
int sparses_emitted = SPARSES_IN_OLDGNU_HEADER;
for (;;)
{
int i;
exhdr = find_next_block ();
memset (exhdr->buffer, 0, BLOCKSIZE);
for (i = 0;
(i < SPARSES_IN_SPARSE_HEADER
&& sparses_emitted + i < sparses);
i++)
{
SIZE_TO_CHARS (sparsearray[sparses_emitted + i].numbytes,
exhdr->sparse_header.sp[i].numbytes);
OFF_TO_CHARS (sparsearray[sparses_emitted + i].offset,
exhdr->sparse_header.sp[i].offset);
}
set_next_block_after (exhdr);
sparses_emitted += i;
if (sparses == sparses_emitted)
break;
exhdr->sparse_header.isextended = 1;
}
}
if (save_typeflag == GNUTYPE_SPARSE)
{
if (f < 0
|| finish_sparse_file (f, &sizeleft,
current_stat.st_size, p))
goto padit;
}
else
while (sizeleft > 0)
{
if (multi_volume_option)
{
assign_string (&save_name, p);
save_sizeleft = sizeleft;
save_totsize = current_stat.st_size;
}
start = find_next_block ();
bufsize = available_space_after (start);
if (sizeleft < bufsize)
{
bufsize = sizeleft;
count = bufsize % BLOCKSIZE;
if (count)
memset (start->buffer + sizeleft, 0, BLOCKSIZE - count);
}
if (f < 0)
count = bufsize;
else
count = safe_read (f, start->buffer, bufsize);
if (count < 0)
{
(ignore_failed_read_option
? read_warn_details
: read_error_details)
(p, current_stat.st_size - sizeleft, bufsize);
goto padit;
}
sizeleft -= bufsize;
set_next_block_after (start + (bufsize - 1) / BLOCKSIZE);
if (count != bufsize)
{
char buf[UINTMAX_STRSIZE_BOUND];
memset (start->buffer + count, 0, bufsize - count);
WARN ((0, 0,
_("%s: File shrank by %s bytes; padding with zeros"),
quotearg_colon (p),
STRINGIFY_BIGINT (sizeleft, buf)));
if (! ignore_failed_read_option)
exit_status = TAREXIT_FAILURE;
goto padit;
}
}
if (multi_volume_option)
assign_string (&save_name, 0);
if (f >= 0)
{
struct stat final_stat;
if (fstat (f, &final_stat) != 0)
{
if (ignore_failed_read_option)
stat_warn (p);
else
stat_error (p);
}
else if (final_stat.st_ctime != original_ctime)
{
char const *qp = quotearg_colon (p);
WARN ((0, 0, _("%s: file changed as we read it"), qp));
if (! ignore_failed_read_option)
exit_status = TAREXIT_FAILURE;
}
if (close (f) != 0)
{
if (ignore_failed_read_option)
close_warn (p);
else
close_error (p);
}
if (atime_preserve_option)
utime (p, &restore_times);
}
if (remove_files_option)
{
if (unlink (p) == -1)
unlink_error (p);
}
return;
padit:
while (sizeleft > 0)
{
save_sizeleft = sizeleft;
start = find_next_block ();
memset (start->buffer, 0, BLOCKSIZE);
set_next_block_after (start);
sizeleft -= BLOCKSIZE;
}
if (multi_volume_option)
assign_string (&save_name, 0);
if (f >= 0)
{
close (f);
if (atime_preserve_option)
utime (p, &restore_times);
}
return;
}
#ifdef HAVE_READLINK
else if (S_ISLNK (current_stat.st_mode))
{
char *buffer;
int size;
size_t linklen = current_stat.st_size;
if (linklen != current_stat.st_size || linklen + 1 == 0)
xalloc_die ();
buffer = (char *) alloca (linklen + 1);
size = readlink (p, buffer, linklen + 1);
if (size < 0)
{
if (ignore_failed_read_option)
readlink_warn (p);
else
readlink_error (p);
return;
}
buffer[size] = '\0';
if (size >= NAME_FIELD_SIZE)
write_long (buffer, GNUTYPE_LONGLINK);
assign_string (¤t_link_name, buffer);
current_stat.st_size = 0;
header = start_header (p, ¤t_stat);
strncpy (header->header.linkname, buffer, NAME_FIELD_SIZE);
header->header.linkname[NAME_FIELD_SIZE - 1] = '\0';
header->header.typeflag = SYMTYPE;
finish_header (header);
if (remove_files_option)
{
if (unlink (p) == -1)
unlink_error (p);
}
return;
}
#endif
else if (S_ISCHR (current_stat.st_mode))
type = CHRTYPE;
else if (S_ISBLK (current_stat.st_mode))
type = BLKTYPE;
else if (S_ISFIFO (current_stat.st_mode))
type = FIFOTYPE;
else if (S_ISSOCK (current_stat.st_mode))
{
WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
return;
}
else if (S_ISDOOR (current_stat.st_mode))
{
WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
return;
}
else
goto unknown;
}
if (archive_format == V7_FORMAT)
goto unknown;
current_stat.st_size = 0;
header = start_header (p, ¤t_stat);
header->header.typeflag = type;
if (type != FIFOTYPE)
{
MAJOR_TO_CHARS (major (current_stat.st_rdev), header->header.devmajor);
MINOR_TO_CHARS (minor (current_stat.st_rdev), header->header.devminor);
}
finish_header (header);
if (remove_files_option)
{
if (unlink (p) == -1)
unlink_error (p);
}
return;
unknown:
WARN ((0, 0, _("%s: Unknown file type; file ignored"),
quotearg_colon (p)));
if (! ignore_failed_read_option)
exit_status = TAREXIT_FAILURE;
}