diff options
Diffstat (limited to 'src/xheader.c')
| -rw-r--r-- | src/xheader.c | 1516 |
1 files changed, 1516 insertions, 0 deletions
diff --git a/src/xheader.c b/src/xheader.c new file mode 100644 index 0000000..aed2eb0 --- /dev/null +++ b/src/xheader.c @@ -0,0 +1,1516 @@ +/* POSIX extended headers for tar. + + Copyright (C) 2003, 2004, 2005, 2006, 2007 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 + Free Software Foundation; either version 2, or (at your option) any later + version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General + Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + +#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)); + +/* Used by xheader_finish() */ +static void code_string (char const *string, char const *keyword, + struct xheader *xhdr); + +/* Number of global headers written so far. */ +static size_t global_header_count; +/* FIXME: Possibly it should be reset after changing the volume. + POSIX %n specification says that it is expanded to the sequence + number of current global header in *the* archive. However, for + multi-volume archives this will yield duplicate header names + in different volumes, which I'd like to avoid. The best way + to solve this would be to use per-archive header count as required + by POSIX *and* set globexthdr.name to, say, + $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n. + + However it should wait until buffer.c is finally rewritten */ + + +/* Interface functions to obstacks */ + +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; +} + + +/* Keyword options */ + +struct keyword_list +{ + struct keyword_list *next; + char *pattern; + char *value; +}; + + +/* List of keyword patterns set by delete= option */ +static struct keyword_list *keyword_pattern_list; + +/* List of keyword/value pairs set by `keyword=value' option */ +static struct keyword_list *keyword_global_override_list; + +/* List of keyword/value pairs set by `keyword:=value' option */ +static struct keyword_list *keyword_override_list; + +/* List of keyword/value pairs decoded from the last 'g' type header */ +static struct keyword_list *global_header_override_list; + +/* Template for the name field of an 'x' type header */ +static char *exthdr_name; + +/* Template for the name field of a 'g' type header */ +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); + } +} + +/* + string Includes: Replaced By: + %d The directory name of the file, + equivalent to the result of the + dirname utility on the translated + file name. + %f The filename of the file, equivalent + to the result of the basename + utility on the translated file name. + %p The process ID of the pax process. + %n The value of the 3rd argument. + %% A '%' character. */ + +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; + } + /* else fall through */ + + default: + *q++ = *p++; + if (*p) + *q++ = *p++; + } + } + else + *q++ = *p++; + } + + free (dirp); + + /* Do not allow it to end in a slash */ + 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); /* Includes nul */ + 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); +} + + +/* General Interface */ + +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; +}; + +/* This declaration must be extern, because ISO C99 section 6.9.2 + prohibits a tentative definition that has both internal linkage and + incomplete type. If we made it static, we'd have to declare its + size which would be a maintenance pain; if we put its initializer + here, we'd need a boatload of forward declarations, which would be + even more of a pain. */ +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; +} + +/* Decode a single extended header record, advancing *PTR to the next record. + Return true on success, false otherwise. */ +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); /* '=' + trailing '\n' */ + *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; /* ' ' + '=' + '\n' */ + 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; +} + + +/* Buildable strings */ + +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; /* ' ' + '=' + '\n' */ + + 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; +} + + +/* Implementations */ + +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 = '-'; + + /* TRANSLATORS: The first %s is the pax extended header keyword + (atime, gid, etc.). */ + 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)) + { + /* FIXME: report error */ + 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)) + { + /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */ + 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) + { + /* Convert "-1.10000000000001" to s == -2, ns == 89999999. + I.e., truncate time stamps towards minus infinity while + converting them to internal form. */ + 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; +} + +/* FIXME: Merge with volume_size_coder */ +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 }, + + /* Sparse file handling */ + { "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 }, + + /* tar 1.14 - 1.15.90 keywords. */ + { "GNU.sparse.size", sparse_size_coder, sparse_size_decoder, true }, + /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x' + headers, and each of them was meaningful. It confilcted with POSIX specs, + which requires that "when extended header records conflict, the last one + given in the header shall take precedence." */ + { "GNU.sparse.offset", sparse_offset_coder, sparse_offset_decoder, + true }, + { "GNU.sparse.numbytes", sparse_numbytes_coder, sparse_numbytes_decoder, + true }, + /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */ + { "GNU.sparse.map", NULL /* Unused, see pax_dump_header() */, + sparse_map_decoder, false }, + + { "GNU.dumpdir", dumpdir_coder, dumpdir_decoder, + true }, + + /* Keeps the tape/volume label. May be present only in the global headers. + Equivalent to GNUTYPE_VOLHDR. */ + { "GNU.volume.label", volume_label_coder, volume_label_decoder, true }, + + /* These may be present in a first global header of the archive. + They provide the same functionality as GNUTYPE_MULTIVOL header. + The GNU.volume.size keeps the real_s_sizeleft value, which is + otherwise kept in the size field of a multivolume header. The + GNU.volume.offset keeps the offset of the start of this volume, + otherwise kept in oldgnu_header.offset. */ + { "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 } +}; |