#include <system.h>
#include <fnmatch.h>
#include <hash.h>
#include <inttostr.h>
#include <quotearg.h>
#include "common.h"
#include <fnmatch.h>
static bool xheader_protected_pattern_p (char const *pattern);
static bool xheader_protected_keyword_p (char const *keyword);
static void xheader_set_single_keyword (char *) __attribute__ ((noreturn));
static void code_string (char const *string, char const *keyword,
struct xheader *xhdr);
static size_t global_header_count;
static void
x_obstack_grow (struct xheader *xhdr, const char *ptr, size_t length)
{
obstack_grow (xhdr->stk, ptr, length);
xhdr->size += length;
}
static void
x_obstack_1grow (struct xheader *xhdr, char c)
{
obstack_1grow (xhdr->stk, c);
xhdr->size++;
}
static void
x_obstack_blank (struct xheader *xhdr, size_t length)
{
obstack_blank (xhdr->stk, length);
xhdr->size += length;
}
struct keyword_list
{
struct keyword_list *next;
char *pattern;
char *value;
};
static struct keyword_list *keyword_pattern_list;
static struct keyword_list *keyword_global_override_list;
static struct keyword_list *keyword_override_list;
static struct keyword_list *global_header_override_list;
static char *exthdr_name;
static char *globexthdr_name;
bool
xheader_keyword_deleted_p (const char *kw)
{
struct keyword_list *kp;
for (kp = keyword_pattern_list; kp; kp = kp->next)
if (fnmatch (kp->pattern, kw, 0) == 0)
return true;
return false;
}
static bool
xheader_keyword_override_p (const char *keyword)
{
struct keyword_list *kp;
for (kp = keyword_override_list; kp; kp = kp->next)
if (strcmp (kp->pattern, keyword) == 0)
return true;
return false;
}
static void
xheader_list_append (struct keyword_list **root, char const *kw,
char const *value)
{
struct keyword_list *kp = xmalloc (sizeof *kp);
kp->pattern = xstrdup (kw);
kp->value = value ? xstrdup (value) : NULL;
kp->next = *root;
*root = kp;
}
static void
xheader_list_destroy (struct keyword_list **root)
{
if (root)
{
struct keyword_list *kw = *root;
while (kw)
{
struct keyword_list *next = kw->next;
free (kw->pattern);
free (kw->value);
free (kw);
kw = next;
}
*root = NULL;
}
}
static void
xheader_set_single_keyword (char *kw)
{
USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet implemented"), kw));
}
static void
xheader_set_keyword_equal (char *kw, char *eq)
{
bool global = true;
char *p = eq;
if (eq[-1] == ':')
{
p--;
global = false;
}
while (p > kw && isspace (*p))
p--;
*p = 0;
for (p = eq + 1; *p && isspace (*p); p++)
;
if (strcmp (kw, "delete") == 0)
{
if (xheader_protected_pattern_p (p))
USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), quote (p)));
xheader_list_append (&keyword_pattern_list, p, NULL);
}
else if (strcmp (kw, "exthdr.name") == 0)
assign_string (&exthdr_name, p);
else if (strcmp (kw, "globexthdr.name") == 0)
assign_string (&globexthdr_name, p);
else
{
if (xheader_protected_keyword_p (kw))
USAGE_ERROR ((0, 0, _("Keyword %s cannot be overridden"), kw));
if (global)
xheader_list_append (&keyword_global_override_list, kw, p);
else
xheader_list_append (&keyword_override_list, kw, p);
}
}
void
xheader_set_option (char *string)
{
char *token;
for (token = strtok (string, ","); token; token = strtok (NULL, ","))
{
char *p = strchr (token, '=');
if (!p)
xheader_set_single_keyword (token);
else
xheader_set_keyword_equal (token, p);
}
}
char *
xheader_format_name (struct tar_stat_info *st, const char *fmt, size_t n)
{
char *buf;
size_t len = strlen (fmt);
char *q;
const char *p;
char *dirp = NULL;
char *dir = NULL;
char *base = NULL;
char pidbuf[UINTMAX_STRSIZE_BOUND];
char const *pptr;
char nbuf[UINTMAX_STRSIZE_BOUND];
char const *nptr = NULL;
for (p = fmt; *p && (p = strchr (p, '%')); )
{
switch (p[1])
{
case '%':
len--;
break;
case 'd':
if (st)
{
if (!dirp)
dirp = dir_name (st->orig_file_name);
dir = safer_name_suffix (dirp, false, absolute_names_option);
len += strlen (dir) - 2;
}
break;
case 'f':
if (st)
{
base = last_component (st->orig_file_name);
len += strlen (base) - 2;
}
break;
case 'p':
pptr = umaxtostr (getpid (), pidbuf);
len += pidbuf + sizeof pidbuf - 1 - pptr - 2;
break;
case 'n':
nptr = umaxtostr (n, nbuf);
len += nbuf + sizeof nbuf - 1 - nptr - 2;
break;
}
p++;
}
buf = xmalloc (len + 1);
for (q = buf, p = fmt; *p; )
{
if (*p == '%')
{
switch (p[1])
{
case '%':
*q++ = *p++;
p++;
break;
case 'd':
if (dir)
q = stpcpy (q, dir);
p += 2;
break;
case 'f':
if (base)
q = stpcpy (q, base);
p += 2;
break;
case 'p':
q = stpcpy (q, pptr);
p += 2;
break;
case 'n':
if (nptr)
{
q = stpcpy (q, nptr);
p += 2;
break;
}
default:
*q++ = *p++;
if (*p)
*q++ = *p++;
}
}
else
*q++ = *p++;
}
free (dirp);
while (q > buf && ISSLASH (q[-1]))
q--;
*q = 0;
return buf;
}
char *
xheader_xhdr_name (struct tar_stat_info *st)
{
if (!exthdr_name)
assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
return xheader_format_name (st, exthdr_name, 0);
}
#define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
char *
xheader_ghdr_name (void)
{
if (!globexthdr_name)
{
size_t len;
const char *tmp = getenv ("TMPDIR");
if (!tmp)
tmp = "/tmp";
len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE);
globexthdr_name = xmalloc (len);
strcpy(globexthdr_name, tmp);
strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
}
return xheader_format_name (NULL, globexthdr_name, global_header_count + 1);
}
void
xheader_write (char type, char *name, struct xheader *xhdr)
{
union block *header;
size_t size;
char *p;
size = xhdr->size;
header = start_private_header (name, size);
header->header.typeflag = type;
simple_finish_header (header);
p = xhdr->buffer;
do
{
size_t len;
header = find_next_block ();
len = BLOCKSIZE;
if (len > size)
len = size;
memcpy (header->buffer, p, len);
if (len < BLOCKSIZE)
memset (header->buffer + len, 0, BLOCKSIZE - len);
p += len;
size -= len;
set_next_block_after (header);
}
while (size > 0);
xheader_destroy (xhdr);
if (type == XGLTYPE)
global_header_count++;
}
void
xheader_write_global (struct xheader *xhdr)
{
char *name;
struct keyword_list *kp;
if (!keyword_global_override_list)
return;
xheader_init (xhdr);
for (kp = keyword_global_override_list; kp; kp = kp->next)
code_string (kp->value, kp->pattern, xhdr);
xheader_finish (xhdr);
xheader_write (XGLTYPE, name = xheader_ghdr_name (), xhdr);
free (name);
}
struct xhdr_tab
{
char const *keyword;
void (*coder) (struct tar_stat_info const *, char const *,
struct xheader *, void const *data);
void (*decoder) (struct tar_stat_info *, char const *, char const *, size_t);
bool protect;
};
extern struct xhdr_tab const xhdr_tab[];
static struct xhdr_tab const *
locate_handler (char const *keyword)
{
struct xhdr_tab const *p;
for (p = xhdr_tab; p->keyword; p++)
if (strcmp (p->keyword, keyword) == 0)
return p;
return NULL;
}
static bool
xheader_protected_pattern_p (const char *pattern)
{
struct xhdr_tab const *p;
for (p = xhdr_tab; p->keyword; p++)
if (p->protect && fnmatch (pattern, p->keyword, 0) == 0)
return true;
return false;
}
static bool
xheader_protected_keyword_p (const char *keyword)
{
struct xhdr_tab const *p;
for (p = xhdr_tab; p->keyword; p++)
if (p->protect && strcmp (p->keyword, keyword) == 0)
return true;
return false;
}
static bool
decode_record (struct xheader *xhdr,
char **ptr,
void (*handler) (void *, char const *, char const *, size_t),
void *data)
{
char *start = *ptr;
char *p = start;
uintmax_t u;
size_t len;
char *len_lim;
char const *keyword;
char *nextp;
size_t len_max = xhdr->buffer + xhdr->size - start;
while (*p == ' ' || *p == '\t')
p++;
if (! ISDIGIT (*p))
{
if (*p)
ERROR ((0, 0, _("Malformed extended header: missing length")));
return false;
}
errno = 0;
len = u = strtoumax (p, &len_lim, 10);
if (len != u || errno == ERANGE)
{
ERROR ((0, 0, _("Extended header length is out of allowed range")));
return false;
}
if (len_max < len)
{
int len_len = len_lim - p;
ERROR ((0, 0, _("Extended header length %*s is out of range"),
len_len, p));
return false;
}
nextp = start + len;
for (p = len_lim; *p == ' ' || *p == '\t'; p++)
continue;
if (p == len_lim)
{
ERROR ((0, 0,
_("Malformed extended header: missing blank after length")));
return false;
}
keyword = p;
p = strchr (p, '=');
if (! (p && p < nextp))
{
ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
return false;
}
if (nextp[-1] != '\n')
{
ERROR ((0, 0, _("Malformed extended header: missing newline")));
return false;
}
*p = nextp[-1] = '\0';
handler (data, keyword, p + 1, nextp - p - 2);
*p = '=';
nextp[-1] = '\n';
*ptr = nextp;
return true;
}
static void
run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
{
for (; kp; kp = kp->next)
{
struct xhdr_tab const *t = locate_handler (kp->pattern);
if (t)
t->decoder (st, t->keyword, kp->value, strlen (kp->value));
}
}
static void
decx (void *data, char const *keyword, char const *value, size_t size)
{
struct xhdr_tab const *t;
struct tar_stat_info *st = data;
if (xheader_keyword_deleted_p (keyword)
|| xheader_keyword_override_p (keyword))
return;
t = locate_handler (keyword);
if (t)
t->decoder (st, keyword, value, size);
else
WARN((0, 0, _("Ignoring unknown extended header keyword `%s'"),
keyword));
}
void
xheader_decode (struct tar_stat_info *st)
{
run_override_list (keyword_global_override_list, st);
run_override_list (global_header_override_list, st);
if (st->xhdr.size)
{
char *p = st->xhdr.buffer + BLOCKSIZE;
while (decode_record (&st->xhdr, &p, decx, st))
continue;
}
run_override_list (keyword_override_list, st);
}
static void
decg (void *data, char const *keyword, char const *value,
size_t size __attribute__((unused)))
{
struct keyword_list **kwl = data;
xheader_list_append (kwl, keyword, value);
}
void
xheader_decode_global (struct xheader *xhdr)
{
if (xhdr->size)
{
char *p = xhdr->buffer + BLOCKSIZE;
xheader_list_destroy (&global_header_override_list);
while (decode_record (xhdr, &p, decg, &global_header_override_list))
continue;
}
}
void
xheader_init (struct xheader *xhdr)
{
if (!xhdr->stk)
{
xhdr->stk = xmalloc (sizeof *xhdr->stk);
obstack_init (xhdr->stk);
}
}
void
xheader_store (char const *keyword, struct tar_stat_info *st,
void const *data)
{
struct xhdr_tab const *t;
if (st->xhdr.buffer)
return;
t = locate_handler (keyword);
if (!t || !t->coder)
return;
if (xheader_keyword_deleted_p (keyword)
|| xheader_keyword_override_p (keyword))
return;
xheader_init (&st->xhdr);
t->coder (st, keyword, &st->xhdr, data);
}
void
xheader_read (struct xheader *xhdr, union block *p, size_t size)
{
size_t j = 0;
xheader_init (xhdr);
size += BLOCKSIZE;
xhdr->size = size;
xhdr->buffer = xmalloc (size + 1);
xhdr->buffer[size] = '\0';
do
{
size_t len = size;
if (len > BLOCKSIZE)
len = BLOCKSIZE;
memcpy (&xhdr->buffer[j], p->buffer, len);
set_next_block_after (p);
p = find_next_block ();
j += len;
size -= len;
}
while (size > 0);
}
static void
xheader_print_n (struct xheader *xhdr, char const *keyword,
char const *value, size_t vsize)
{
size_t len = strlen (keyword) + vsize + 3;
size_t p;
size_t n = 0;
char nbuf[UINTMAX_STRSIZE_BOUND];
char const *np;
do
{
p = n;
np = umaxtostr (len + p, nbuf);
n = nbuf + sizeof nbuf - 1 - np;
}
while (n != p);
x_obstack_grow (xhdr, np, n);
x_obstack_1grow (xhdr, ' ');
x_obstack_grow (xhdr, keyword, strlen (keyword));
x_obstack_1grow (xhdr, '=');
x_obstack_grow (xhdr, value, vsize);
x_obstack_1grow (xhdr, '\n');
}
static void
xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
{
xheader_print_n (xhdr, keyword, value, strlen (value));
}
void
xheader_finish (struct xheader *xhdr)
{
struct keyword_list *kp;
for (kp = keyword_override_list; kp; kp = kp->next)
code_string (kp->value, kp->pattern, xhdr);
xhdr->buffer = obstack_finish (xhdr->stk);
}
void
xheader_destroy (struct xheader *xhdr)
{
if (xhdr->stk)
{
obstack_free (xhdr->stk, NULL);
free (xhdr->stk);
xhdr->stk = NULL;
}
else
free (xhdr->buffer);
xhdr->buffer = 0;
xhdr->size = 0;
}
void
xheader_string_begin (struct xheader *xhdr)
{
xhdr->string_length = 0;
}
void
xheader_string_add (struct xheader *xhdr, char const *s)
{
if (xhdr->buffer)
return;
xheader_init (xhdr);
xhdr->string_length += strlen (s);
x_obstack_grow (xhdr, s, strlen (s));
}
bool
xheader_string_end (struct xheader *xhdr, char const *keyword)
{
uintmax_t len;
uintmax_t p;
uintmax_t n = 0;
size_t size;
char nbuf[UINTMAX_STRSIZE_BOUND];
char const *np;
char *cp;
if (xhdr->buffer)
return false;
xheader_init (xhdr);
len = strlen (keyword) + xhdr->string_length + 3;
do
{
p = n;
np = umaxtostr (len + p, nbuf);
n = nbuf + sizeof nbuf - 1 - np;
}
while (n != p);
p = strlen (keyword) + n + 2;
size = p;
if (size != p)
{
ERROR ((0, 0,
_("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
keyword, nbuf));
obstack_free (xhdr->stk, obstack_finish (xhdr->stk));
return false;
}
x_obstack_blank (xhdr, p);
x_obstack_1grow (xhdr, '\n');
cp = obstack_next_free (xhdr->stk) - xhdr->string_length - p - 1;
memmove (cp + p, cp, xhdr->string_length);
cp = stpcpy (cp, np);
*cp++ = ' ';
cp = stpcpy (cp, keyword);
*cp++ = '=';
return true;
}
static void
out_of_range_header (char const *keyword, char const *value,
uintmax_t minus_minval, uintmax_t maxval)
{
char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
char maxval_buf[UINTMAX_STRSIZE_BOUND];
char *minval_string = umaxtostr (minus_minval, minval_buf + 1);
char *maxval_string = umaxtostr (maxval, maxval_buf);
if (minus_minval)
*--minval_string = '-';
ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
keyword, value, minval_string, maxval_string));
}
static void
code_string (char const *string, char const *keyword, struct xheader *xhdr)
{
char *outstr;
if (!utf8_convert (true, string, &outstr))
{
outstr = xstrdup (string);
}
xheader_print (xhdr, keyword, outstr);
free (outstr);
}
static void
decode_string (char **string, char const *arg)
{
if (*string)
{
free (*string);
*string = NULL;
}
if (!utf8_convert (false, arg, string))
{
assign_string (string, arg);
}
}
static void
code_time (struct timespec t, char const *keyword, struct xheader *xhdr)
{
char buf[TIMESPEC_STRSIZE_BOUND];
xheader_print (xhdr, keyword, code_timespec (t, buf));
}
enum decode_time_status
{
decode_time_success,
decode_time_range,
decode_time_bad_header
};
static enum decode_time_status
_decode_time (struct timespec *ts, char const *arg, char const *keyword)
{
time_t s;
unsigned long int ns = 0;
char *p;
char *arg_lim;
bool negative = *arg == '-';
errno = 0;
if (ISDIGIT (arg[negative]))
{
if (negative)
{
intmax_t i = strtoimax (arg, &arg_lim, 10);
if (TYPE_SIGNED (time_t) ? i < TYPE_MINIMUM (time_t) : i < 0)
return decode_time_range;
s = i;
}
else
{
uintmax_t i = strtoumax (arg, &arg_lim, 10);
if (TYPE_MAXIMUM (time_t) < i)
return decode_time_range;
s = i;
}
p = arg_lim;
if (errno == ERANGE)
return decode_time_range;
if (*p == '.')
{
int digits = 0;
bool trailing_nonzero = false;
while (ISDIGIT (*++p))
if (digits < LOG10_BILLION)
{
ns = 10 * ns + (*p - '0');
digits++;
}
else
trailing_nonzero |= *p != '0';
while (digits++ < LOG10_BILLION)
ns *= 10;
if (negative)
{
ns += trailing_nonzero;
if (ns != 0)
{
if (s == TYPE_MINIMUM (time_t))
return decode_time_range;
s--;
ns = BILLION - ns;
}
}
}
if (! *p)
{
ts->tv_sec = s;
ts->tv_nsec = ns;
return decode_time_success;
}
}
return decode_time_bad_header;
}
static bool
decode_time (struct timespec *ts, char const *arg, char const *keyword)
{
switch (_decode_time (ts, arg, keyword))
{
case decode_time_success:
return true;
case decode_time_bad_header:
ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
keyword, arg));
return false;
case decode_time_range:
out_of_range_header (keyword, arg, - (uintmax_t) TYPE_MINIMUM (time_t),
TYPE_MAXIMUM (time_t));
return false;
}
return true;
}
static void
code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
{
char sbuf[UINTMAX_STRSIZE_BOUND];
xheader_print (xhdr, keyword, umaxtostr (value, sbuf));
}
static bool
decode_num (uintmax_t *num, char const *arg, uintmax_t maxval,
char const *keyword)
{
uintmax_t u;
char *arg_lim;
if (! (ISDIGIT (*arg)
&& (errno = 0, u = strtoumax (arg, &arg_lim, 10), !*arg_lim)))
{
ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
keyword, arg));
return false;
}
if (! (u <= maxval && errno != ERANGE))
{
out_of_range_header (keyword, arg, 0, maxval);
return false;
}
*num = u;
return true;
}
static void
dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
char const *keyword __attribute__ ((unused)),
struct xheader *xhdr __attribute__ ((unused)),
void const *data __attribute__ ((unused)))
{
}
static void
dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
char const *keyword __attribute__ ((unused)),
char const *arg __attribute__ ((unused)),
size_t size __attribute__((unused)))
{
}
static void
atime_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_time (st->atime, keyword, xhdr);
}
static void
atime_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
struct timespec ts;
if (decode_time (&ts, arg, keyword))
st->atime = ts;
}
static void
gid_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_num (st->stat.st_gid, keyword, xhdr);
}
static void
gid_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (gid_t), keyword))
st->stat.st_gid = u;
}
static void
gname_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_string (st->gname, keyword, xhdr);
}
static void
gname_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&st->gname, arg);
}
static void
linkpath_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_string (st->link_name, keyword, xhdr);
}
static void
linkpath_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&st->link_name, arg);
}
static void
ctime_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_time (st->ctime, keyword, xhdr);
}
static void
ctime_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
struct timespec ts;
if (decode_time (&ts, arg, keyword))
st->ctime = ts;
}
static void
mtime_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
struct timespec const *mtime = data;
code_time (mtime ? *mtime : st->mtime, keyword, xhdr);
}
static void
mtime_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
struct timespec ts;
if (decode_time (&ts, arg, keyword))
st->mtime = ts;
}
static void
path_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_string (st->file_name, keyword, xhdr);
}
static void
path_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&st->orig_file_name, arg);
decode_string (&st->file_name, arg);
st->had_trailing_slash = strip_trailing_slashes (st->file_name);
}
static void
size_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_num (st->stat.st_size, keyword, xhdr);
}
static void
size_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
st->stat.st_size = u;
}
static void
uid_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_num (st->stat.st_uid, keyword, xhdr);
}
static void
uid_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (uid_t), keyword))
st->stat.st_uid = u;
}
static void
uname_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data __attribute__ ((unused)))
{
code_string (st->uname, keyword, xhdr);
}
static void
uname_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&st->uname, arg);
}
static void
sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
size_coder (st, keyword, xhdr, data);
}
static void
sparse_size_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
st->stat.st_size = u;
}
static void
sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr,
void const *data __attribute__ ((unused)))
{
code_num (st->sparse_map_avail, keyword, xhdr);
}
static void
sparse_numblocks_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, SIZE_MAX, keyword))
{
st->sparse_map_size = u;
st->sparse_map = xcalloc (u, sizeof st->sparse_map[0]);
st->sparse_map_avail = 0;
}
}
static void
sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
size_t const *pi = data;
code_num (st->sparse_map[*pi].offset, keyword, xhdr);
}
static void
sparse_offset_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
{
if (st->sparse_map_avail < st->sparse_map_size)
st->sparse_map[st->sparse_map_avail].offset = u;
else
ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
"GNU.sparse.offset", arg));
}
}
static void
sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
size_t const *pi = data;
code_num (st->sparse_map[*pi].numbytes, keyword, xhdr);
}
static void
sparse_numbytes_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
uintmax_t u;
if (decode_num (&u, arg, SIZE_MAX, keyword))
{
if (st->sparse_map_avail < st->sparse_map_size)
st->sparse_map[st->sparse_map_avail++].numbytes = u;
else
ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
keyword, arg));
}
}
static void
sparse_map_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size __attribute__((unused)))
{
int offset = 1;
st->sparse_map_avail = 0;
while (1)
{
uintmax_t u;
char *delim;
struct sp_array e;
if (!ISDIGIT (*arg))
{
ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
keyword, arg));
return;
}
errno = 0;
u = strtoumax (arg, &delim, 10);
if (offset)
{
e.offset = u;
if (!(u == e.offset && errno != ERANGE))
{
out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
return;
}
}
else
{
e.numbytes = u;
if (!(u == e.numbytes && errno != ERANGE))
{
out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (size_t));
return;
}
if (st->sparse_map_avail < st->sparse_map_size)
st->sparse_map[st->sparse_map_avail++] = e;
else
{
ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
keyword, arg));
return;
}
}
offset = !offset;
if (*delim == 0)
break;
else if (*delim != ',')
{
ERROR ((0, 0,
_("Malformed extended header: invalid %s: unexpected delimiter %c"),
keyword, *delim));
return;
}
arg = delim + 1;
}
if (!offset)
ERROR ((0, 0,
_("Malformed extended header: invalid %s: odd number of values"),
keyword));
}
static void
dumpdir_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
xheader_print_n (xhdr, keyword, data, dumpdir_size (data));
}
static void
dumpdir_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size)
{
st->dumpdir = xmalloc (size);
memcpy (st->dumpdir, arg, size);
}
static void
volume_label_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
code_string (data, keyword, xhdr);
}
static void
volume_label_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&volume_label, arg);
}
static void
volume_size_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
off_t const *v = data;
code_num (*v, keyword, xhdr);
}
static void
volume_size_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg, size_t size)
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
continued_file_size = u;
}
static void
volume_offset_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
off_t const *v = data;
code_num (*v, keyword, xhdr);
}
static void
volume_offset_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg, size_t size)
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
continued_file_offset = u;
}
static void
volume_filename_decoder (struct tar_stat_info *st,
char const *keyword __attribute__((unused)),
char const *arg,
size_t size __attribute__((unused)))
{
decode_string (&continued_file_name, arg);
}
static void
sparse_major_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
code_num (st->sparse_major, keyword, xhdr);
}
static void
sparse_major_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size)
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
st->sparse_major = u;
}
static void
sparse_minor_coder (struct tar_stat_info const *st, char const *keyword,
struct xheader *xhdr, void const *data)
{
code_num (st->sparse_minor, keyword, xhdr);
}
static void
sparse_minor_decoder (struct tar_stat_info *st,
char const *keyword,
char const *arg,
size_t size)
{
uintmax_t u;
if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
st->sparse_minor = u;
}
struct xhdr_tab const xhdr_tab[] = {
{ "atime", atime_coder, atime_decoder, false },
{ "comment", dummy_coder, dummy_decoder, false },
{ "charset", dummy_coder, dummy_decoder, false },
{ "ctime", ctime_coder, ctime_decoder, false },
{ "gid", gid_coder, gid_decoder, false },
{ "gname", gname_coder, gname_decoder, false },
{ "linkpath", linkpath_coder, linkpath_decoder, false },
{ "mtime", mtime_coder, mtime_decoder, false },
{ "path", path_coder, path_decoder, false },
{ "size", size_coder, size_decoder, false },
{ "uid", uid_coder, uid_decoder, false },
{ "uname", uname_coder, uname_decoder, false },
{ "GNU.sparse.name", path_coder, path_decoder,
true },
{ "GNU.sparse.major", sparse_major_coder, sparse_major_decoder,
true },
{ "GNU.sparse.minor", sparse_minor_coder, sparse_minor_decoder,
true },
{ "GNU.sparse.realsize", sparse_size_coder, sparse_size_decoder,
true },
{ "GNU.sparse.numblocks", sparse_numblocks_coder, sparse_numblocks_decoder,
true },
{ "GNU.sparse.size", sparse_size_coder, sparse_size_decoder, true },
{ "GNU.sparse.offset", sparse_offset_coder, sparse_offset_decoder,
true },
{ "GNU.sparse.numbytes", sparse_numbytes_coder, sparse_numbytes_decoder,
true },
{ "GNU.sparse.map", NULL ,
sparse_map_decoder, false },
{ "GNU.dumpdir", dumpdir_coder, dumpdir_decoder,
true },
{ "GNU.volume.label", volume_label_coder, volume_label_decoder, true },
{ "GNU.volume.filename", volume_label_coder, volume_filename_decoder,
true },
{ "GNU.volume.size", volume_size_coder, volume_size_decoder, true },
{ "GNU.volume.offset", volume_offset_coder, volume_offset_decoder, true },
{ NULL, NULL, NULL, false }
};