src/xheader.c

   1 /* POSIX extended headers for tar.
   2
   3    Copyright (C) 2003-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GNU tar.
   6
   7    GNU tar is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    GNU tar is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include <system.h>
  21
  22 #include <fnmatch.h>
  23 #include <hash.h>
  24 #include <inttostr.h>
  25 #include <quotearg.h>
  26
  27 #include "common.h"
  28
  29 static void xheader_init (struct xheader *xhdr);
  30 static bool xheader_protected_pattern_p (char const *pattern);
  31 static bool xheader_protected_keyword_p (char const *keyword);
  32
  33 /* Used by xheader_finish() */
  34 static void code_string (char const *string, char const *keyword,
  35                          struct xheader *xhdr);
  36
  37 /* Number of global headers written so far. */
  38 static size_t global_header_count;
  39 /* FIXME: Possibly it should be reset after changing the volume.
  40    POSIX %n specification says that it is expanded to the sequence
  41    number of current global header in *the* archive. However, for
  42    multi-volume archives this will yield duplicate header names
  43    in different volumes, which I'd like to avoid. The best way
  44    to solve this would be to use per-archive header count as required
  45    by POSIX *and* set globexthdr.name to, say,
  46    $TMPDIR/GlobalHead.%p.$NUMVOLUME.%n.
  47
  48    However it should wait until buffer.c is finally rewritten */
  49
  50 \f
  51 /* Interface functions to obstacks */
  52
  53 static void
  54 x_obstack_grow (struct xheader *xhdr, const char *ptr, size_t length)
  55 {
  56   obstack_grow (xhdr->stk, ptr, length);
  57   xhdr->size += length;
  58 }
  59
  60 static void
  61 x_obstack_1grow (struct xheader *xhdr, char c)
  62 {
  63   obstack_1grow (xhdr->stk, c);
  64   xhdr->size++;
  65 }
  66
  67 static void
  68 x_obstack_blank (struct xheader *xhdr, size_t length)
  69 {
  70   obstack_blank (xhdr->stk, length);
  71   xhdr->size += length;
  72 }
  73
  74 \f
  75 /* Keyword options */
  76
  77 struct keyword_list
  78 {
  79   struct keyword_list *next;
  80   char *pattern;
  81   char *value;
  82 };
  83
  84
  85 /* List of keyword patterns set by delete= option */
  86 static struct keyword_list *keyword_pattern_list;
  87
  88 /* List of keyword/value pairs set by 'keyword=value' option */
  89 static struct keyword_list *keyword_global_override_list;
  90
  91 /* List of keyword/value pairs set by 'keyword:=value' option */
  92 static struct keyword_list *keyword_override_list;
  93
  94 /* List of keyword/value pairs decoded from the last 'g' type header */
  95 static struct keyword_list *global_header_override_list;
  96
  97 /* Template for the name field of an 'x' type header */
  98 static char *exthdr_name;
  99
 100 static char *exthdr_mtime_option;
 101 static time_t exthdr_mtime;
 102
 103 /* Template for the name field of a 'g' type header */
 104 static char *globexthdr_name;
 105
 106 static char *globexthdr_mtime_option;
 107 static time_t globexthdr_mtime;
 108
 109 bool
 110 xheader_keyword_deleted_p (const char *kw)
 111 {
 112   struct keyword_list *kp;
 113
 114   for (kp = keyword_pattern_list; kp; kp = kp->next)
 115     if (fnmatch (kp->pattern, kw, 0) == 0)
 116       return true;
 117   return false;
 118 }
 119
 120 static bool
 121 xheader_keyword_override_p (const char *keyword)
 122 {
 123   struct keyword_list *kp;
 124
 125   for (kp = keyword_override_list; kp; kp = kp->next)
 126     if (strcmp (kp->pattern, keyword) == 0)
 127       return true;
 128   return false;
 129 }
 130
 131 static void
 132 xheader_list_append (struct keyword_list **root, char const *kw,
 133                      char const *value)
 134 {
 135   struct keyword_list *kp = xmalloc (sizeof *kp);
 136   kp->pattern = xstrdup (kw);
 137   kp->value = value ? xstrdup (value) : NULL;
 138   kp->next = *root;
 139   *root = kp;
 140 }
 141
 142 static void
 143 xheader_list_destroy (struct keyword_list **root)
 144 {
 145   if (root)
 146     {
 147       struct keyword_list *kw = *root;
 148       while (kw)
 149         {
 150           struct keyword_list *next = kw->next;
 151           free (kw->pattern);
 152           free (kw->value);
 153           free (kw);
 154           kw = next;
 155         }
 156       *root = NULL;
 157     }
 158 }
 159
 160 static _Noreturn void
 161 xheader_set_single_keyword (char *kw)
 162 {
 163   USAGE_ERROR ((0, 0, _("Keyword %s is unknown or not yet implemented"), kw));
 164 }
 165
 166 static void
 167 assign_time_option (char **sval, time_t *tval, const char *input)
 168 {
 169   char *p;
 170   struct timespec t = decode_timespec (input, &p, false);
 171   if (! valid_timespec (t) || *p)
 172     ERROR ((0, 0, _("Time stamp is out of allowed range")));
 173   else
 174     {
 175       *tval = t.tv_sec;
 176       assign_string (sval, input);
 177     }
 178 }
 179
 180 static void
 181 xheader_set_keyword_equal (char *kw, char *eq)
 182 {
 183   bool global = true;
 184   char *p = eq;
 185
 186   if (eq == kw)
 187     USAGE_ERROR ((0, 0, _("Malformed pax option: %s"), quote (kw)));
 188
 189   if (eq[-1] == ':')
 190     {
 191       p--;
 192       global = false;
 193     }
 194
 195   while (p > kw && isspace ((unsigned char) *p))
 196     p--;
 197
 198   *p = 0;
 199
 200   for (p = eq + 1; *p && isspace ((unsigned char) *p); p++)
 201     ;
 202
 203   if (strcmp (kw, "delete") == 0)
 204     {
 205       if (xheader_protected_pattern_p (p))
 206         USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), quote (p)));
 207       xheader_list_append (&keyword_pattern_list, p, NULL);
 208     }
 209   else if (strcmp (kw, "exthdr.name") == 0)
 210     assign_string (&exthdr_name, p);
 211   else if (strcmp (kw, "globexthdr.name") == 0)
 212     assign_string (&globexthdr_name, p);
 213   else if (strcmp (kw, "exthdr.mtime") == 0)
 214     assign_time_option (&exthdr_mtime_option, &exthdr_mtime, p);
 215   else if (strcmp (kw, "globexthdr.mtime") == 0)
 216     assign_time_option (&globexthdr_mtime_option, &globexthdr_mtime, p);
 217   else
 218     {
 219       if (xheader_protected_keyword_p (kw))
 220         USAGE_ERROR ((0, 0, _("Keyword %s cannot be overridden"), kw));
 221       if (global)
 222         xheader_list_append (&keyword_global_override_list, kw, p);
 223       else
 224         xheader_list_append (&keyword_override_list, kw, p);
 225     }
 226 }
 227
 228 void
 229 xheader_set_option (char *string)
 230 {
 231   char *token;
 232   for (token = strtok (string, ","); token; token = strtok (NULL, ","))
 233     {
 234       char *p = strchr (token, '=');
 235       if (!p)
 236         xheader_set_single_keyword (token);
 237       else
 238         xheader_set_keyword_equal (token, p);
 239     }
 240 }
 241
 242 /*
 243     string Includes:          Replaced By:
 244      %d                       The directory name of the file,
 245                               equivalent to the result of the
 246                               dirname utility on the translated
 247                               file name.
 248      %f                       The filename of the file, equivalent
 249                               to the result of the basename
 250                               utility on the translated file name.
 251      %p                       The process ID of the pax process.
 252      %n                       The value of the 3rd argument.
 253      %%                       A '%' character. */
 254
 255 char *
 256 xheader_format_name (struct tar_stat_info *st, const char *fmt, size_t n)
 257 {
 258   char *buf;
 259   size_t len;
 260   char *q;
 261   const char *p;
 262   char *dirp = NULL;
 263   char *dir = NULL;
 264   char *base = NULL;
 265   char pidbuf[UINTMAX_STRSIZE_BOUND];
 266   char const *pptr = NULL;
 267   char nbuf[UINTMAX_STRSIZE_BOUND];
 268   char const *nptr = NULL;
 269
 270   len = 0;
 271   for (p = fmt; *p; p++)
 272     {
 273       if (*p == '%' && p[1])
 274         {
 275           switch (*++p)
 276             {
 277             case '%':
 278               len++;
 279               break;
 280
 281             case 'd':
 282               if (st)
 283                 {
 284                   if (!dirp)
 285                     dirp = dir_name (st->orig_file_name);
 286                   dir = safer_name_suffix (dirp, false, absolute_names_option);
 287                   len += strlen (dir);
 288                 }
 289               break;
 290
 291             case 'f':
 292               if (st)
 293                 {
 294                   base = last_component (st->orig_file_name);
 295                   len += strlen (base);
 296                 }
 297               break;
 298
 299             case 'p':
 300               pptr = umaxtostr (getpid (), pidbuf);
 301               len += pidbuf + sizeof pidbuf - 1 - pptr;
 302               break;
 303
 304             case 'n':
 305               nptr = umaxtostr (n, nbuf);
 306               len += nbuf + sizeof nbuf - 1 - nptr;
 307               break;
 308
 309             default:
 310               len += 2;
 311             }
 312         }
 313       else
 314         len++;
 315     }
 316
 317   buf = xmalloc (len + 1);
 318   for (q = buf, p = fmt; *p; )
 319     {
 320       if (*p == '%')
 321         {
 322           switch (p[1])
 323             {
 324             case '%':
 325               *q++ = *p++;
 326               p++;
 327               break;
 328
 329             case 'd':
 330               if (dir)
 331                 q = stpcpy (q, dir);
 332               p += 2;
 333               break;
 334
 335             case 'f':
 336               if (base)
 337                 q = stpcpy (q, base);
 338               p += 2;
 339               break;
 340
 341             case 'p':
 342               q = stpcpy (q, pptr);
 343               p += 2;
 344               break;
 345
 346             case 'n':
 347               q = stpcpy (q, nptr);
 348               p += 2;
 349               break;
 350
 351
 352             default:
 353               *q++ = *p++;
 354               if (*p)
 355                 *q++ = *p++;
 356             }
 357         }
 358       else
 359         *q++ = *p++;
 360     }
 361
 362   free (dirp);
 363
 364   /* Do not allow it to end in a slash */
 365   while (q > buf && ISSLASH (q[-1]))
 366     q--;
 367   *q = 0;
 368   return buf;
 369 }
 370
 371 /* Table of templates for the names of POSIX extended headers.
 372    Indexed by the the type of the header (per-file or global)
 373    and POSIX compliance mode (0 or q depending on whether
 374    POSIXLY_CORRECT environment variable is set. */
 375 static const char *header_template[][2] = {
 376   /* Individual header templates: */
 377   { "%d/PaxHeaders/%f", "%d/PaxHeaders.%p/%f" },
 378   /* Global header templates: */
 379   { "/GlobalHead.%n", "/GlobalHead.%p.%n" }
 380 };
 381 /* Indices to the above table */
 382 enum {
 383   pax_file_header,
 384   pax_global_header
 385 };
 386 /* Return the name for the POSIX extended header T */
 387 #define HEADER_TEMPLATE(t) header_template[t][posixly_correct]
 388
 389 char *
 390 xheader_xhdr_name (struct tar_stat_info *st)
 391 {
 392   if (!exthdr_name)
 393     assign_string (&exthdr_name, HEADER_TEMPLATE (pax_file_header));
 394   return xheader_format_name (st, exthdr_name, 0);
 395 }
 396
 397 char *
 398 xheader_ghdr_name (void)
 399 {
 400   if (!globexthdr_name)
 401     {
 402       size_t len;
 403       const char *global_header_template = HEADER_TEMPLATE (pax_global_header);
 404       const char *tmp = getenv ("TMPDIR");
 405       if (!tmp)
 406         tmp = "/tmp";
 407       len = strlen (tmp) + strlen (global_header_template) + 1;
 408       globexthdr_name = xmalloc (len);
 409       strcpy(globexthdr_name, tmp);
 410       strcat(globexthdr_name, global_header_template);
 411     }
 412
 413   return xheader_format_name (NULL, globexthdr_name, global_header_count + 1);
 414 }
 415
 416 void
 417 xheader_write (char type, char *name, time_t t, struct xheader *xhdr)
 418 {
 419   union block *header;
 420   size_t size;
 421   char *p;
 422
 423   size = xhdr->size;
 424   switch (type)
 425     {
 426     case XGLTYPE:
 427       if (globexthdr_mtime_option)
 428         t = globexthdr_mtime;
 429       break;
 430
 431     case XHDTYPE:
 432       if (exthdr_mtime_option)
 433         t = exthdr_mtime;
 434       break;
 435     }
 436   header = start_private_header (name, size, t);
 437   header->header.typeflag = type;
 438
 439   simple_finish_header (header);
 440
 441   p = xhdr->buffer;
 442
 443   do
 444     {
 445       size_t len;
 446
 447       header = find_next_block ();
 448       len = BLOCKSIZE;
 449       if (len > size)
 450         len = size;
 451       memcpy (header->buffer, p, len);
 452       if (len < BLOCKSIZE)
 453         memset (header->buffer + len, 0, BLOCKSIZE - len);
 454       p += len;
 455       size -= len;
 456       set_next_block_after (header);
 457     }
 458   while (size > 0);
 459   xheader_destroy (xhdr);
 460
 461   if (type == XGLTYPE)
 462     global_header_count++;
 463 }
 464
 465 void
 466 xheader_write_global (struct xheader *xhdr)
 467 {
 468   if (keyword_global_override_list)
 469     {
 470       struct keyword_list *kp;
 471
 472       xheader_init (xhdr);
 473       for (kp = keyword_global_override_list; kp; kp = kp->next)
 474         code_string (kp->value, kp->pattern, xhdr);
 475     }
 476   if (xhdr->stk)
 477     {
 478       char *name;
 479
 480       xheader_finish (xhdr);
 481       name = xheader_ghdr_name ();
 482       xheader_write (XGLTYPE, name, start_time.tv_sec, xhdr);
 483       free (name);
 484     }
 485 }
 486
 487 /* Forbid modifications of the global extended header */
 488 void
 489 xheader_forbid_global (void)
 490 {
 491   if (keyword_global_override_list)
 492     USAGE_ERROR ((0, 0, _("can't update global extended header record")));
 493 }
 494
 495 /* This is reversal function for xattr_encode_keyword.  See comment for
 496    xattr_encode_keyword() for more info. */
 497 static void
 498 xattr_decode_keyword (char *keyword)
 499 {
 500   char *kpr, *kpl; /* keyword pointer left/right */
 501   kpr = kpl = keyword;
 502
 503   for (;;)
 504     {
 505       if (*kpr == '%')
 506         {
 507           if (kpr[1] == '3' && kpr[2] == 'D')
 508             {
 509               *kpl = '=';
 510               kpr += 3;
 511               kpl ++;
 512               continue;
 513             }
 514           else if (kpr[1] == '2' && kpr[2] == '5')
 515             {
 516               *kpl = '%';
 517               kpr += 3;
 518               kpl ++;
 519               continue;
 520             }
 521         }
 522
 523       *kpl = *kpr;
 524
 525       if (*kpr == 0)
 526         break;
 527
 528       kpr++;
 529       kpl++;
 530     }
 531 }
 532 \f
 533 /* General Interface */
 534
 535 #define XHDR_PROTECTED 0x01
 536 #define XHDR_GLOBAL    0x02
 537
 538 struct xhdr_tab
 539 {
 540   char const *keyword;
 541   void (*coder) (struct tar_stat_info const *, char const *,
 542                  struct xheader *, void const *data);
 543   void (*decoder) (struct tar_stat_info *, char const *, char const *, size_t);
 544   int flags;
 545   bool prefix; /* select handler comparing prefix only */
 546 };
 547
 548 /* This declaration must be extern, because ISO C99 section 6.9.2
 549    prohibits a tentative definition that has both internal linkage and
 550    incomplete type.  If we made it static, we'd have to declare its
 551    size which would be a maintenance pain; if we put its initializer
 552    here, we'd need a boatload of forward declarations, which would be
 553    even more of a pain.  */
 554 extern struct xhdr_tab const xhdr_tab[];
 555
 556 static struct xhdr_tab const *
 557 locate_handler (char const *keyword)
 558 {
 559   struct xhdr_tab const *p;
 560   for (p = xhdr_tab; p->keyword; p++)
 561     if (p->prefix)
 562       {
 563         size_t kwlen = strlen (p->keyword);
 564         if (keyword[kwlen] == '.' && strncmp (p->keyword, keyword, kwlen) == 0)
 565           return p;
 566       }
 567     else
 568       {
 569         if (strcmp (p->keyword, keyword) == 0)
 570           return p;
 571       }
 572
 573   return NULL;
 574 }
 575
 576 static bool
 577 xheader_protected_pattern_p (const char *pattern)
 578 {
 579   struct xhdr_tab const *p;
 580
 581   for (p = xhdr_tab; p->keyword; p++)
 582     if (!p->prefix && (p->flags & XHDR_PROTECTED)
 583         && fnmatch (pattern, p->keyword, 0) == 0)
 584       return true;
 585   return false;
 586 }
 587
 588 static bool
 589 xheader_protected_keyword_p (const char *keyword)
 590 {
 591   struct xhdr_tab const *p;
 592
 593   for (p = xhdr_tab; p->keyword; p++)
 594     if (!p->prefix && (p->flags & XHDR_PROTECTED)
 595         && strcmp (p->keyword, keyword) == 0)
 596       return true;
 597   return false;
 598 }
 599
 600 /* Decode a single extended header record, advancing *PTR to the next record.
 601    Return true on success, false otherwise.  */
 602 static bool
 603 decode_record (struct xheader *xhdr,
 604                char **ptr,
 605                void (*handler) (void *, char const *, char const *, size_t),
 606                void *data)
 607 {
 608   char *start = *ptr;
 609   char *p = start;
 610   size_t len;
 611   char *len_lim;
 612   char const *keyword;
 613   char *nextp;
 614   size_t len_max = xhdr->buffer + xhdr->size - start;
 615
 616   while (*p == ' ' || *p == '\t')
 617     p++;
 618
 619   if (! ISDIGIT (*p))
 620     {
 621       if (*p)
 622         ERROR ((0, 0, _("Malformed extended header: missing length")));
 623       return false;
 624     }
 625
 626   len = strtoumax (p, &len_lim, 10);
 627
 628   if (len_max < len)
 629     {
 630       int len_len = len_lim - p;
 631       ERROR ((0, 0, _("Extended header length %.*s is out of range"),
 632               len_len, p));
 633       return false;
 634     }
 635
 636   nextp = start + len;
 637
 638   for (p = len_lim; *p == ' ' || *p == '\t'; p++)
 639     continue;
 640   if (p == len_lim)
 641     {
 642       ERROR ((0, 0,
 643               _("Malformed extended header: missing blank after length")));
 644       return false;
 645     }
 646
 647   keyword = p;
 648   p = strchr (p, '=');
 649   if (! (p && p < nextp))
 650     {
 651       ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
 652       return false;
 653     }
 654
 655   if (nextp[-1] != '\n')
 656     {
 657       ERROR ((0, 0, _("Malformed extended header: missing newline")));
 658       return false;
 659     }
 660
 661   *p = nextp[-1] = '\0';
 662   handler (data, keyword, p + 1, nextp - p - 2); /* '=' + trailing '\n' */
 663   *p = '=';
 664   nextp[-1] = '\n';
 665   *ptr = nextp;
 666   return true;
 667 }
 668
 669 static void
 670 run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
 671 {
 672   for (; kp; kp = kp->next)
 673     {
 674       struct xhdr_tab const *t = locate_handler (kp->pattern);
 675       if (t)
 676         t->decoder (st, t->keyword, kp->value, strlen (kp->value));
 677     }
 678 }
 679
 680 static void
 681 decx (void *data, char const *keyword, char const *value, size_t size)
 682 {
 683   struct xhdr_tab const *t;
 684   struct tar_stat_info *st = data;
 685
 686   if (xheader_keyword_deleted_p (keyword)
 687       || xheader_keyword_override_p (keyword))
 688     return;
 689
 690   t = locate_handler (keyword);
 691   if (t)
 692     t->decoder (st, keyword, value, size);
 693   else
 694     WARNOPT (WARN_UNKNOWN_KEYWORD,
 695              (0, 0, _("Ignoring unknown extended header keyword '%s'"),
 696               keyword));
 697 }
 698
 699 void
 700 xheader_decode (struct tar_stat_info *st)
 701 {
 702   run_override_list (keyword_global_override_list, st);
 703   run_override_list (global_header_override_list, st);
 704
 705   if (st->xhdr.size)
 706     {
 707       char *p = st->xhdr.buffer + BLOCKSIZE;
 708       while (decode_record (&st->xhdr, &p, decx, st))
 709         continue;
 710     }
 711   run_override_list (keyword_override_list, st);
 712
 713   /* The archived (effective) file size is always set directly in tar header
 714      field, possibly overridden by "size" extended header - in both cases,
 715      result is now decoded in st->stat.st_size */
 716   st->archive_file_size = st->stat.st_size;
 717
 718   /* The real file size (given by stat()) may be redefined for sparse
 719      files in "GNU.sparse.realsize" extended header */
 720   if (st->real_size_set)
 721     st->stat.st_size = st->real_size;
 722 }
 723
 724 static void
 725 decg (void *data, char const *keyword, char const *value,
 726       size_t size MAYBE_UNUSED)
 727 {
 728   struct keyword_list **kwl = data;
 729   struct xhdr_tab const *tab = locate_handler (keyword);
 730   if (tab && (tab->flags & XHDR_GLOBAL))
 731     tab->decoder (data, keyword, value, size);
 732   else
 733     xheader_list_append (kwl, keyword, value);
 734 }
 735
 736 void
 737 xheader_decode_global (struct xheader *xhdr)
 738 {
 739   if (xhdr->size)
 740     {
 741       char *p = xhdr->buffer + BLOCKSIZE;
 742
 743       xheader_list_destroy (&global_header_override_list);
 744       while (decode_record (xhdr, &p, decg, &global_header_override_list))
 745         continue;
 746     }
 747 }
 748
 749 static void
 750 xheader_init (struct xheader *xhdr)
 751 {
 752   if (!xhdr->stk)
 753     {
 754       xhdr->stk = xmalloc (sizeof *xhdr->stk);
 755       obstack_init (xhdr->stk);
 756     }
 757 }
 758
 759 void
 760 xheader_store (char const *keyword, struct tar_stat_info *st,
 761                void const *data)
 762 {
 763   struct xhdr_tab const *t;
 764
 765   if (st->xhdr.buffer)
 766     return;
 767   t = locate_handler (keyword);
 768   if (!t || !t->coder)
 769     return;
 770   if (xheader_keyword_deleted_p (keyword))
 771     return;
 772   xheader_init (&st->xhdr);
 773   if (!xheader_keyword_override_p (keyword))
 774     t->coder (st, keyword, &st->xhdr, data);
 775 }
 776
 777 void
 778 xheader_read (struct xheader *xhdr, union block *p, off_t size)
 779 {
 780   size_t j = 0;
 781
 782   if (size < 0)
 783     size = 0; /* Already diagnosed.  */
 784
 785   if (SIZE_MAX - BLOCKSIZE <= size)
 786     xalloc_die ();
 787
 788   size += BLOCKSIZE;
 789   xhdr->size = size;
 790   xhdr->buffer = xmalloc (size + 1);
 791   xhdr->buffer[size] = '\0';
 792
 793   do
 794     {
 795       size_t len = size;
 796
 797       if (len > BLOCKSIZE)
 798         len = BLOCKSIZE;
 799
 800       if (!p)
 801         FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
 802
 803       memcpy (&xhdr->buffer[j], p->buffer, len);
 804       set_next_block_after (p);
 805
 806       p = find_next_block ();
 807
 808       j += len;
 809       size -= len;
 810     }
 811   while (size > 0);
 812 }
 813
 814 /* xattr_encode_keyword() substitutes '=' ~~> '%3D' and '%' ~~> '%25'
 815    in extended attribute keywords.  This is needed because the '=' character
 816    has special purpose in extended attribute header - it splits keyword and
 817    value part of header.  If there was the '=' occurrence allowed inside
 818    keyword, there would be no unambiguous way how to decode this extended
 819    attribute.
 820
 821    (http://lists.gnu.org/archive/html/bug-tar/2012-10/msg00017.html)
 822  */
 823 static char *
 824 xattr_encode_keyword(const char *keyword)
 825 {
 826   static char *encode_buffer = NULL;
 827   static size_t encode_buffer_size = 0;
 828   size_t bp; /* keyword/buffer pointers */
 829
 830   if (!encode_buffer)
 831     {
 832       encode_buffer_size = 256;
 833       encode_buffer = xmalloc (encode_buffer_size);
 834     }
 835   else
 836     *encode_buffer = 0;
 837
 838   for (bp = 0; *keyword != 0; ++bp, ++keyword)
 839     {
 840       char c = *keyword;
 841
 842       if (bp + 3 /* enough for URL encoding also.. */ >= encode_buffer_size)
 843         {
 844           encode_buffer = x2realloc (encode_buffer, &encode_buffer_size);
 845         }
 846
 847       if (c == '%')
 848         {
 849           strcpy (encode_buffer + bp, "%25");
 850           bp += 2;
 851         }
 852       else if (c == '=')
 853         {
 854           strcpy (encode_buffer + bp, "%3D");
 855           bp += 2;
 856         }
 857       else
 858         encode_buffer[bp] = c;
 859     }
 860
 861   encode_buffer[bp] = 0;
 862
 863   return encode_buffer;
 864 }
 865
 866 static void
 867 xheader_print_n (struct xheader *xhdr, char const *keyword,
 868                  char const *value, size_t vsize)
 869 {
 870   size_t p;
 871   size_t n = 0;
 872   char nbuf[UINTMAX_STRSIZE_BOUND];
 873   char const *np;
 874   size_t len, klen;
 875
 876   keyword = xattr_encode_keyword (keyword);
 877   klen = strlen (keyword);
 878   len = klen + vsize + 3; /* ' ' + '=' + '\n' */
 879
 880   do
 881     {
 882       p = n;
 883       np = umaxtostr (len + p, nbuf);
 884       n = nbuf + sizeof nbuf - 1 - np;
 885     }
 886   while (n != p);
 887
 888   x_obstack_grow (xhdr, np, n);
 889   x_obstack_1grow (xhdr, ' ');
 890   x_obstack_grow (xhdr, keyword, klen);
 891   x_obstack_1grow (xhdr, '=');
 892   x_obstack_grow (xhdr, value, vsize);
 893   x_obstack_1grow (xhdr, '\n');
 894 }
 895
 896 static void
 897 xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
 898 {
 899   xheader_print_n (xhdr, keyword, value, strlen (value));
 900 }
 901
 902 void
 903 xheader_finish (struct xheader *xhdr)
 904 {
 905   struct keyword_list *kp;
 906
 907   for (kp = keyword_override_list; kp; kp = kp->next)
 908     code_string (kp->value, kp->pattern, xhdr);
 909
 910   xhdr->buffer = obstack_finish (xhdr->stk);
 911 }
 912
 913 void
 914 xheader_destroy (struct xheader *xhdr)
 915 {
 916   if (xhdr->stk)
 917     {
 918       obstack_free (xhdr->stk, NULL);
 919       free (xhdr->stk);
 920       xhdr->stk = NULL;
 921     }
 922   else
 923     free (xhdr->buffer);
 924   xhdr->buffer = 0;
 925   xhdr->size = 0;
 926 }
 927
 928 \f
 929 /* Buildable strings */
 930
 931 void
 932 xheader_string_begin (struct xheader *xhdr)
 933 {
 934   xhdr->string_length = 0;
 935 }
 936
 937 void
 938 xheader_string_add (struct xheader *xhdr, char const *s)
 939 {
 940   if (xhdr->buffer)
 941     return;
 942   xheader_init (xhdr);
 943   xhdr->string_length += strlen (s);
 944   x_obstack_grow (xhdr, s, strlen (s));
 945 }
 946
 947 bool
 948 xheader_string_end (struct xheader *xhdr, char const *keyword)
 949 {
 950   uintmax_t len;
 951   uintmax_t p;
 952   uintmax_t n = 0;
 953   size_t size;
 954   char nbuf[UINTMAX_STRSIZE_BOUND];
 955   char const *np;
 956   char *cp;
 957
 958   if (xhdr->buffer)
 959     return false;
 960   xheader_init (xhdr);
 961
 962   len = strlen (keyword) + xhdr->string_length + 3; /* ' ' + '=' + '\n' */
 963
 964   do
 965     {
 966       p = n;
 967       np = umaxtostr (len + p, nbuf);
 968       n = nbuf + sizeof nbuf - 1 - np;
 969     }
 970   while (n != p);
 971
 972   p = strlen (keyword) + n + 2;
 973   size = p;
 974   if (size != p)
 975     {
 976       ERROR ((0, 0,
 977         _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
 978               keyword, nbuf));
 979       obstack_free (xhdr->stk, obstack_finish (xhdr->stk));
 980       return false;
 981     }
 982   x_obstack_blank (xhdr, p);
 983   x_obstack_1grow (xhdr, '\n');
 984   cp = (char*) obstack_next_free (xhdr->stk) - xhdr->string_length - p - 1;
 985   memmove (cp + p, cp, xhdr->string_length);
 986   cp = stpcpy (cp, np);
 987   *cp++ = ' ';
 988   cp = stpcpy (cp, keyword);
 989   *cp++ = '=';
 990   return true;
 991 }
 992
 993 \f
 994 /* Implementations */
 995
 996 static void
 997 out_of_range_header (char const *keyword, char const *value,
 998                      intmax_t minval, uintmax_t maxval)
 999 {
1000   char minval_buf[INT_BUFSIZE_BOUND (intmax_t)];
1001   char maxval_buf[UINTMAX_STRSIZE_BOUND];
1002   char *minval_string = imaxtostr (minval, minval_buf);
1003   char *maxval_string = umaxtostr (maxval, maxval_buf);
1004
1005   /* TRANSLATORS: The first %s is the pax extended header keyword
1006      (atime, gid, etc.).  */
1007   ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
1008           keyword, value, minval_string, maxval_string));
1009 }
1010
1011 static void
1012 code_string (char const *string, char const *keyword, struct xheader *xhdr)
1013 {
1014   char *outstr;
1015   if (!utf8_convert (true, string, &outstr))
1016     {
1017       /* FIXME: report error */
1018       outstr = xstrdup (string);
1019     }
1020   xheader_print (xhdr, keyword, outstr);
1021   free (outstr);
1022 }
1023
1024 static void
1025 decode_string (char **string, char const *arg)
1026 {
1027   if (*string)
1028     {
1029       free (*string);
1030       *string = NULL;
1031     }
1032   if (!utf8_convert (false, arg, string))
1033     {
1034       /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
1035       assign_string (string, arg);
1036     }
1037 }
1038
1039 static void
1040 code_time (struct timespec t, char const *keyword, struct xheader *xhdr)
1041 {
1042   char buf[TIMESPEC_STRSIZE_BOUND];
1043   xheader_print (xhdr, keyword, code_timespec (t, buf));
1044 }
1045
1046 static bool
1047 decode_time (struct timespec *ts, char const *arg, char const *keyword)
1048 {
1049   char *arg_lim;
1050   struct timespec t = decode_timespec (arg, &arg_lim, true);
1051
1052   if (! valid_timespec (t))
1053     {
1054       if (arg < arg_lim && !*arg_lim)
1055         out_of_range_header (keyword, arg, TYPE_MINIMUM (time_t),
1056                              TYPE_MAXIMUM (time_t));
1057       else
1058         ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1059                 keyword, arg));
1060       return false;
1061     }
1062
1063   *ts = t;
1064   return true;
1065 }
1066
1067 static void
1068 code_signed_num (uintmax_t value, char const *keyword,
1069                  intmax_t minval, uintmax_t maxval, struct xheader *xhdr)
1070 {
1071   char sbuf[SYSINT_BUFSIZE];
1072   xheader_print (xhdr, keyword, sysinttostr (value, minval, maxval, sbuf));
1073 }
1074
1075 static void
1076 code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
1077 {
1078   code_signed_num (value, keyword, 0, UINTMAX_MAX, xhdr);
1079 }
1080
1081 static bool
1082 decode_signed_num (intmax_t *num, char const *arg,
1083                    intmax_t minval, uintmax_t maxval,
1084                    char const *keyword)
1085 {
1086   char *arg_lim;
1087   intmax_t u = strtosysint (arg, &arg_lim, minval, maxval);
1088
1089   if (errno == EINVAL || *arg_lim)
1090     {
1091       ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1092               keyword, arg));
1093       return false;
1094     }
1095
1096   if (errno == ERANGE)
1097     {
1098       out_of_range_header (keyword, arg, minval, maxval);
1099       return false;
1100     }
1101
1102   *num = u;
1103   return true;
1104 }
1105
1106 static bool
1107 decode_num (uintmax_t *num, char const *arg, uintmax_t maxval,
1108             char const *keyword)
1109 {
1110   intmax_t i;
1111   if (! decode_signed_num (&i, arg, 0, maxval, keyword))
1112     return false;
1113   *num = i;
1114   return true;
1115 }
1116
1117 static void
1118 dummy_coder (struct tar_stat_info const *st MAYBE_UNUSED,
1119              char const *keyword MAYBE_UNUSED,
1120              struct xheader *xhdr MAYBE_UNUSED,
1121              void const *data MAYBE_UNUSED)
1122 {
1123 }
1124
1125 static void
1126 dummy_decoder (struct tar_stat_info *st MAYBE_UNUSED,
1127                char const *keyword MAYBE_UNUSED,
1128                char const *arg MAYBE_UNUSED,
1129                size_t size MAYBE_UNUSED)
1130 {
1131 }
1132
1133 static void
1134 atime_coder (struct tar_stat_info const *st, char const *keyword,
1135              struct xheader *xhdr, void const *data MAYBE_UNUSED)
1136 {
1137   code_time (st->atime, keyword, xhdr);
1138 }
1139
1140 static void
1141 atime_decoder (struct tar_stat_info *st,
1142                char const *keyword,
1143                char const *arg,
1144                size_t size MAYBE_UNUSED)
1145 {
1146   struct timespec ts;
1147   if (decode_time (&ts, arg, keyword))
1148     st->atime = ts;
1149 }
1150
1151 static void
1152 gid_coder (struct tar_stat_info const *st, char const *keyword,
1153            struct xheader *xhdr, void const *data MAYBE_UNUSED)
1154 {
1155   code_signed_num (st->stat.st_gid, keyword,
1156                    TYPE_MINIMUM (gid_t), TYPE_MAXIMUM (gid_t), xhdr);
1157 }
1158
1159 static void
1160 gid_decoder (struct tar_stat_info *st,
1161              char const *keyword,
1162              char const *arg,
1163              size_t size MAYBE_UNUSED)
1164 {
1165   intmax_t u;
1166   if (decode_signed_num (&u, arg, TYPE_MINIMUM (gid_t),
1167                          TYPE_MAXIMUM (gid_t), keyword))
1168     st->stat.st_gid = u;
1169 }
1170
1171 static void
1172 gname_coder (struct tar_stat_info const *st, char const *keyword,
1173              struct xheader *xhdr, void const *data MAYBE_UNUSED)
1174 {
1175   code_string (st->gname, keyword, xhdr);
1176 }
1177
1178 static void
1179 gname_decoder (struct tar_stat_info *st,
1180                char const *keyword MAYBE_UNUSED,
1181                char const *arg,
1182                size_t size MAYBE_UNUSED)
1183 {
1184   decode_string (&st->gname, arg);
1185 }
1186
1187 static void
1188 linkpath_coder (struct tar_stat_info const *st, char const *keyword,
1189                 struct xheader *xhdr, void const *data MAYBE_UNUSED)
1190 {
1191   code_string (st->link_name, keyword, xhdr);
1192 }
1193
1194 static void
1195 linkpath_decoder (struct tar_stat_info *st,
1196                   char const *keyword MAYBE_UNUSED,
1197                   char const *arg,
1198                   size_t size MAYBE_UNUSED)
1199 {
1200   decode_string (&st->link_name, arg);
1201 }
1202
1203 static void
1204 ctime_coder (struct tar_stat_info const *st, char const *keyword,
1205              struct xheader *xhdr, void const *data MAYBE_UNUSED)
1206 {
1207   code_time (st->ctime, keyword, xhdr);
1208 }
1209
1210 static void
1211 ctime_decoder (struct tar_stat_info *st,
1212                char const *keyword,
1213                char const *arg,
1214                size_t size MAYBE_UNUSED)
1215 {
1216   struct timespec ts;
1217   if (decode_time (&ts, arg, keyword))
1218     st->ctime = ts;
1219 }
1220
1221 static void
1222 mtime_coder (struct tar_stat_info const *st, char const *keyword,
1223              struct xheader *xhdr, void const *data)
1224 {
1225   struct timespec const *mtime = data;
1226   code_time (mtime ? *mtime : st->mtime, keyword, xhdr);
1227 }
1228
1229 static void
1230 mtime_decoder (struct tar_stat_info *st,
1231                char const *keyword,
1232                char const *arg,
1233                size_t size MAYBE_UNUSED)
1234 {
1235   struct timespec ts;
1236   if (decode_time (&ts, arg, keyword))
1237     st->mtime = ts;
1238 }
1239
1240 static void
1241 path_coder (struct tar_stat_info const *st, char const *keyword,
1242             struct xheader *xhdr, void const *data MAYBE_UNUSED)
1243 {
1244   code_string (st->file_name, keyword, xhdr);
1245 }
1246
1247 static void
1248 raw_path_decoder (struct tar_stat_info *st, char const *arg)
1249 {
1250   decode_string (&st->orig_file_name, arg);
1251   decode_string (&st->file_name, arg);
1252   st->had_trailing_slash = strip_trailing_slashes (st->file_name);
1253 }
1254
1255
1256 static void
1257 path_decoder (struct tar_stat_info *st,
1258               char const *keyword MAYBE_UNUSED,
1259               char const *arg,
1260               size_t size MAYBE_UNUSED)
1261 {
1262   if (! st->sparse_name_done)
1263     raw_path_decoder (st, arg);
1264 }
1265
1266 static void
1267 sparse_path_decoder (struct tar_stat_info *st,
1268                      char const *keyword MAYBE_UNUSED,
1269                      char const *arg,
1270                      size_t size MAYBE_UNUSED)
1271 {
1272   st->sparse_name_done = true;
1273   raw_path_decoder (st, arg);
1274 }
1275
1276 static void
1277 size_coder (struct tar_stat_info const *st, char const *keyword,
1278             struct xheader *xhdr, void const *data MAYBE_UNUSED)
1279 {
1280   code_num (st->stat.st_size, keyword, xhdr);
1281 }
1282
1283 static void
1284 size_decoder (struct tar_stat_info *st,
1285               char const *keyword,
1286               char const *arg,
1287               size_t size MAYBE_UNUSED)
1288 {
1289   uintmax_t u;
1290   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1291     st->stat.st_size = u;
1292 }
1293
1294 static void
1295 uid_coder (struct tar_stat_info const *st, char const *keyword,
1296            struct xheader *xhdr, void const *data MAYBE_UNUSED)
1297 {
1298   code_signed_num (st->stat.st_uid, keyword,
1299                    TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t), xhdr);
1300 }
1301
1302 static void
1303 uid_decoder (struct tar_stat_info *st,
1304              char const *keyword,
1305              char const *arg,
1306              size_t size MAYBE_UNUSED)
1307 {
1308   intmax_t u;
1309   if (decode_signed_num (&u, arg, TYPE_MINIMUM (uid_t),
1310                          TYPE_MAXIMUM (uid_t), keyword))
1311     st->stat.st_uid = u;
1312 }
1313
1314 static void
1315 uname_coder (struct tar_stat_info const *st, char const *keyword,
1316              struct xheader *xhdr, void const *data MAYBE_UNUSED)
1317 {
1318   code_string (st->uname, keyword, xhdr);
1319 }
1320
1321 static void
1322 uname_decoder (struct tar_stat_info *st,
1323                char const *keyword MAYBE_UNUSED,
1324                char const *arg,
1325                size_t size MAYBE_UNUSED)
1326 {
1327   decode_string (&st->uname, arg);
1328 }
1329
1330 static void
1331 sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
1332              struct xheader *xhdr, void const *data)
1333 {
1334   size_coder (st, keyword, xhdr, data);
1335 }
1336
1337 static void
1338 sparse_size_decoder (struct tar_stat_info *st,
1339                      char const *keyword,
1340                      char const *arg,
1341                      size_t size MAYBE_UNUSED)
1342 {
1343   uintmax_t u;
1344   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1345     {
1346       st->real_size_set = true;
1347       st->real_size = u;
1348     }
1349 }
1350
1351 static void
1352 sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
1353                         struct xheader *xhdr,
1354                         void const *data MAYBE_UNUSED)
1355 {
1356   code_num (st->sparse_map_avail, keyword, xhdr);
1357 }
1358
1359 static void
1360 sparse_numblocks_decoder (struct tar_stat_info *st,
1361                           char const *keyword,
1362                           char const *arg,
1363                           size_t size MAYBE_UNUSED)
1364 {
1365   uintmax_t u;
1366   if (decode_num (&u, arg, SIZE_MAX, keyword))
1367     {
1368       st->sparse_map_size = u;
1369       st->sparse_map = xcalloc (u, sizeof st->sparse_map[0]);
1370       st->sparse_map_avail = 0;
1371     }
1372 }
1373
1374 static void
1375 sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
1376                      struct xheader *xhdr, void const *data)
1377 {
1378   size_t const *pi = data;
1379   code_num (st->sparse_map[*pi].offset, keyword, xhdr);
1380 }
1381
1382 static void
1383 sparse_offset_decoder (struct tar_stat_info *st,
1384                        char const *keyword,
1385                        char const *arg,
1386                        size_t size MAYBE_UNUSED)
1387 {
1388   uintmax_t u;
1389   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1390     {
1391       if (st->sparse_map_avail < st->sparse_map_size)
1392         st->sparse_map[st->sparse_map_avail].offset = u;
1393       else
1394         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1395                 "GNU.sparse.offset", arg));
1396     }
1397 }
1398
1399 static void
1400 sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
1401                        struct xheader *xhdr, void const *data)
1402 {
1403   size_t const *pi = data;
1404   code_num (st->sparse_map[*pi].numbytes, keyword, xhdr);
1405 }
1406
1407 static void
1408 sparse_numbytes_decoder (struct tar_stat_info *st,
1409                          char const *keyword,
1410                          char const *arg,
1411                          size_t size MAYBE_UNUSED)
1412 {
1413   uintmax_t u;
1414   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1415     {
1416       if (st->sparse_map_avail < st->sparse_map_size)
1417         st->sparse_map[st->sparse_map_avail++].numbytes = u;
1418       else
1419         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1420                 keyword, arg));
1421     }
1422 }
1423
1424 static void
1425 sparse_map_decoder (struct tar_stat_info *st,
1426                     char const *keyword,
1427                     char const *arg,
1428                     size_t size MAYBE_UNUSED)
1429 {
1430   int offset = 1;
1431   struct sp_array e;
1432
1433   st->sparse_map_avail = 0;
1434   while (1)
1435     {
1436       intmax_t u;
1437       char *delim;
1438
1439       if (!ISDIGIT (*arg))
1440         {
1441           ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1442                   keyword, arg));
1443           return;
1444         }
1445
1446       errno = 0;
1447       u = strtoimax (arg, &delim, 10);
1448       if (TYPE_MAXIMUM (off_t) < u)
1449         {
1450           u = TYPE_MAXIMUM (off_t);
1451           errno = ERANGE;
1452         }
1453       if (offset)
1454         {
1455           e.offset = u;
1456           if (errno == ERANGE)
1457             {
1458               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1459               return;
1460             }
1461         }
1462       else
1463         {
1464           e.numbytes = u;
1465           if (errno == ERANGE)
1466             {
1467               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1468               return;
1469             }
1470           if (st->sparse_map_avail < st->sparse_map_size)
1471             st->sparse_map[st->sparse_map_avail++] = e;
1472           else
1473             {
1474               ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1475                       keyword, arg));
1476               return;
1477             }
1478         }
1479
1480       offset = !offset;
1481
1482       if (*delim == 0)
1483         break;
1484       else if (*delim != ',')
1485         {
1486           ERROR ((0, 0,
1487                   _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1488                   keyword, *delim));
1489           return;
1490         }
1491
1492       arg = delim + 1;
1493     }
1494
1495   if (!offset)
1496     ERROR ((0, 0,
1497             _("Malformed extended header: invalid %s: odd number of values"),
1498             keyword));
1499 }
1500
1501 static void
1502 dumpdir_coder (struct tar_stat_info const *st, char const *keyword,
1503                struct xheader *xhdr, void const *data)
1504 {
1505   xheader_print_n (xhdr, keyword, data, dumpdir_size (data));
1506 }
1507
1508 static void
1509 dumpdir_decoder (struct tar_stat_info *st,
1510                  char const *keyword MAYBE_UNUSED,
1511                  char const *arg,
1512                  size_t size)
1513 {
1514   st->dumpdir = xmalloc (size);
1515   memcpy (st->dumpdir, arg, size);
1516 }
1517
1518 static void
1519 volume_label_coder (struct tar_stat_info const *st, char const *keyword,
1520                     struct xheader *xhdr, void const *data)
1521 {
1522   code_string (data, keyword, xhdr);
1523 }
1524
1525 static void
1526 volume_label_decoder (struct tar_stat_info *st,
1527                       char const *keyword MAYBE_UNUSED,
1528                       char const *arg,
1529                       size_t size MAYBE_UNUSED)
1530 {
1531   decode_string (&volume_label, arg);
1532 }
1533
1534 static void
1535 volume_size_coder (struct tar_stat_info const *st, char const *keyword,
1536                    struct xheader *xhdr, void const *data)
1537 {
1538   off_t const *v = data;
1539   code_num (*v, keyword, xhdr);
1540 }
1541
1542 static void
1543 volume_size_decoder (struct tar_stat_info *st,
1544                      char const *keyword,
1545                      char const *arg, size_t size)
1546 {
1547   uintmax_t u;
1548   if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1549     continued_file_size = u;
1550 }
1551
1552 /* FIXME: Merge with volume_size_coder */
1553 static void
1554 volume_offset_coder (struct tar_stat_info const *st, char const *keyword,
1555                      struct xheader *xhdr, void const *data)
1556 {
1557   off_t const *v = data;
1558   code_num (*v, keyword, xhdr);
1559 }
1560
1561 static void
1562 volume_offset_decoder (struct tar_stat_info *st,
1563                        char const *keyword,
1564                        char const *arg, size_t size)
1565 {
1566   uintmax_t u;
1567   if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1568     continued_file_offset = u;
1569 }
1570
1571 static void
1572 volume_filename_decoder (struct tar_stat_info *st,
1573                          char const *keyword MAYBE_UNUSED,
1574                          char const *arg,
1575                          size_t size MAYBE_UNUSED)
1576 {
1577   decode_string (&continued_file_name, arg);
1578 }
1579
1580 static void
1581 xattr_selinux_coder (struct tar_stat_info const *st, char const *keyword,
1582                      struct xheader *xhdr, void const *data)
1583 {
1584   code_string (st->cntx_name, keyword, xhdr);
1585 }
1586
1587 static void
1588 xattr_selinux_decoder (struct tar_stat_info *st,
1589                        char const *keyword, char const *arg, size_t size)
1590 {
1591   decode_string (&st->cntx_name, arg);
1592 }
1593
1594 static void
1595 xattr_acls_a_coder (struct tar_stat_info const *st , char const *keyword,
1596                     struct xheader *xhdr, void const *data)
1597 {
1598   xheader_print_n (xhdr, keyword, st->acls_a_ptr, st->acls_a_len);
1599 }
1600
1601 static void
1602 xattr_acls_a_decoder (struct tar_stat_info *st,
1603                       char const *keyword, char const *arg, size_t size)
1604 {
1605   st->acls_a_ptr = xmemdup (arg, size + 1);
1606   st->acls_a_len = size;
1607 }
1608
1609 static void
1610 xattr_acls_d_coder (struct tar_stat_info const *st , char const *keyword,
1611                     struct xheader *xhdr, void const *data)
1612 {
1613   xheader_print_n (xhdr, keyword, st->acls_d_ptr, st->acls_d_len);
1614 }
1615
1616 static void
1617 xattr_acls_d_decoder (struct tar_stat_info *st,
1618                       char const *keyword, char const *arg, size_t size)
1619 {
1620   st->acls_d_ptr = xmemdup (arg, size + 1);
1621   st->acls_d_len = size;
1622 }
1623
1624 static void
1625 xattr_coder (struct tar_stat_info const *st, char const *keyword,
1626              struct xheader *xhdr, void const *data)
1627 {
1628   size_t n = *(size_t *)data;
1629   xheader_print_n (xhdr, keyword,
1630                    st->xattr_map.xm_map[n].xval_ptr,
1631                    st->xattr_map.xm_map[n].xval_len);
1632 }
1633
1634 static void
1635 xattr_decoder (struct tar_stat_info *st,
1636                char const *keyword, char const *arg, size_t size)
1637 {
1638   char *xkey;
1639
1640   /* copy keyword */
1641   xkey = xstrdup (keyword);
1642
1643   xattr_decode_keyword (xkey);
1644
1645   xattr_map_add (&st->xattr_map, xkey, arg, size);
1646
1647   free (xkey);
1648 }
1649
1650 static void
1651 sparse_major_coder (struct tar_stat_info const *st, char const *keyword,
1652                     struct xheader *xhdr, void const *data)
1653 {
1654   code_num (st->sparse_major, keyword, xhdr);
1655 }
1656
1657 static void
1658 sparse_major_decoder (struct tar_stat_info *st,
1659                       char const *keyword,
1660                       char const *arg,
1661                       size_t size)
1662 {
1663   uintmax_t u;
1664   if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1665     st->sparse_major = u;
1666 }
1667
1668 static void
1669 sparse_minor_coder (struct tar_stat_info const *st, char const *keyword,
1670                       struct xheader *xhdr, void const *data)
1671 {
1672   code_num (st->sparse_minor, keyword, xhdr);
1673 }
1674
1675 static void
1676 sparse_minor_decoder (struct tar_stat_info *st,
1677                       char const *keyword,
1678                       char const *arg,
1679                       size_t size)
1680 {
1681   uintmax_t u;
1682   if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1683     st->sparse_minor = u;
1684 }
1685
1686 struct xhdr_tab const xhdr_tab[] = {
1687   { "atime",    atime_coder,    atime_decoder,    0, false },
1688   { "comment",  dummy_coder,    dummy_decoder,    0, false },
1689   { "charset",  dummy_coder,    dummy_decoder,    0, false },
1690   { "ctime",    ctime_coder,    ctime_decoder,    0, false },
1691   { "gid",      gid_coder,      gid_decoder,      0, false },
1692   { "gname",    gname_coder,    gname_decoder,    0, false },
1693   { "linkpath", linkpath_coder, linkpath_decoder, 0, false },
1694   { "mtime",    mtime_coder,    mtime_decoder,    0, false },
1695   { "path",     path_coder,     path_decoder,     0, false },
1696   { "size",     size_coder,     size_decoder,     0, false },
1697   { "uid",      uid_coder,      uid_decoder,      0, false },
1698   { "uname",    uname_coder,    uname_decoder,    0, false },
1699
1700   /* Sparse file handling */
1701   { "GNU.sparse.name",       path_coder, sparse_path_decoder,
1702     XHDR_PROTECTED, false },
1703   { "GNU.sparse.major",      sparse_major_coder, sparse_major_decoder,
1704     XHDR_PROTECTED, false },
1705   { "GNU.sparse.minor",      sparse_minor_coder, sparse_minor_decoder,
1706     XHDR_PROTECTED, false },
1707   { "GNU.sparse.realsize",   sparse_size_coder, sparse_size_decoder,
1708     XHDR_PROTECTED, false },
1709   { "GNU.sparse.numblocks",  sparse_numblocks_coder, sparse_numblocks_decoder,
1710     XHDR_PROTECTED, false },
1711
1712   /* tar 1.14 - 1.15.90 keywords. */
1713   { "GNU.sparse.size",       sparse_size_coder, sparse_size_decoder,
1714     XHDR_PROTECTED, false },
1715   /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1716      headers, and each of them was meaningful. It confilcted with POSIX specs,
1717      which requires that "when extended header records conflict, the last one
1718      given in the header shall take precedence." */
1719   { "GNU.sparse.offset",     sparse_offset_coder, sparse_offset_decoder,
1720     XHDR_PROTECTED, false },
1721   { "GNU.sparse.numbytes",   sparse_numbytes_coder, sparse_numbytes_decoder,
1722     XHDR_PROTECTED, false },
1723   /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1724   { "GNU.sparse.map",        NULL /* Unused, see pax_dump_header() */,
1725     sparse_map_decoder, 0, false },
1726
1727   { "GNU.dumpdir",           dumpdir_coder, dumpdir_decoder,
1728     XHDR_PROTECTED, false },
1729
1730   /* Keeps the tape/volume label. May be present only in the global headers.
1731      Equivalent to GNUTYPE_VOLHDR.  */
1732   { "GNU.volume.label", volume_label_coder, volume_label_decoder,
1733     XHDR_PROTECTED | XHDR_GLOBAL, false },
1734
1735   /* These may be present in a first global header of the archive.
1736      They provide the same functionality as GNUTYPE_MULTIVOL header.
1737      The GNU.volume.size keeps the real_s_sizeleft value, which is
1738      otherwise kept in the size field of a multivolume header.  The
1739      GNU.volume.offset keeps the offset of the start of this volume,
1740      otherwise kept in oldgnu_header.offset.  */
1741   { "GNU.volume.filename", volume_label_coder, volume_filename_decoder,
1742     XHDR_PROTECTED | XHDR_GLOBAL, false },
1743   { "GNU.volume.size", volume_size_coder, volume_size_decoder,
1744     XHDR_PROTECTED | XHDR_GLOBAL, false },
1745   { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder,
1746     XHDR_PROTECTED | XHDR_GLOBAL, false },
1747
1748   /* We get the SELinux value from filecon, so add a namespace for SELinux
1749      instead of storing it in SCHILY.xattr.* (which would be RAW). */
1750   { "RHT.security.selinux",
1751     xattr_selinux_coder, xattr_selinux_decoder, 0, false },
1752
1753   /* ACLs, use the star format... */
1754   { "SCHILY.acl.access",
1755     xattr_acls_a_coder, xattr_acls_a_decoder, 0, false },
1756
1757   { "SCHILY.acl.default",
1758     xattr_acls_d_coder, xattr_acls_d_decoder, 0, false },
1759
1760   /* We are storing all extended attributes using this rule even if some of them
1761      were stored by some previous rule (duplicates) -- we just have to make sure
1762      they are restored *only once* during extraction later on. */
1763   { "SCHILY.xattr", xattr_coder, xattr_decoder, 0, true },
1764
1765   { NULL, NULL, NULL, 0, false }
1766 };