Dogcows Code - chaz/tar/blob - src/xheader.c

   1 /* POSIX extended headers for tar.
   2
   3    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010 Free Software
   4    Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  14    Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation, Inc.,
  18    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  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 bool xheader_protected_pattern_p (char const *pattern);
  30 static bool xheader_protected_keyword_p (char const *keyword);
  31 static void xheader_set_single_keyword (char *) __attribute__ ((noreturn));
  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 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   uintmax_t u;
 170   char *p;
 171   time_t t = u = strtoumax (input, &p, 10);
 172   if (t != u || *p || errno == ERANGE)
 173     ERROR ((0, 0, _("Time stamp is out of allowed range")));
 174   else
 175     {
 176       *tval = t;
 177       assign_string (sval, input);
 178     }
 179 }
 180
 181 static void
 182 xheader_set_keyword_equal (char *kw, char *eq)
 183 {
 184   bool global = true;
 185   char *p = eq;
 186
 187   if (eq[-1] == ':')
 188     {
 189       p--;
 190       global = false;
 191     }
 192
 193   while (p > kw && isspace ((unsigned char) *p))
 194     p--;
 195
 196   *p = 0;
 197
 198   for (p = eq + 1; *p && isspace ((unsigned char) *p); p++)
 199     ;
 200
 201   if (strcmp (kw, "delete") == 0)
 202     {
 203       if (xheader_protected_pattern_p (p))
 204         USAGE_ERROR ((0, 0, _("Pattern %s cannot be used"), quote (p)));
 205       xheader_list_append (&keyword_pattern_list, p, NULL);
 206     }
 207   else if (strcmp (kw, "exthdr.name") == 0)
 208     assign_string (&exthdr_name, p);
 209   else if (strcmp (kw, "globexthdr.name") == 0)
 210     assign_string (&globexthdr_name, p);
 211   else if (strcmp (kw, "exthdr.mtime") == 0)
 212     assign_time_option (&exthdr_mtime_option, &exthdr_mtime, p);
 213   else if (strcmp (kw, "globexthdr.mtime") == 0)
 214     assign_time_option (&globexthdr_mtime_option, &globexthdr_mtime, p);
 215   else
 216     {
 217       if (xheader_protected_keyword_p (kw))
 218         USAGE_ERROR ((0, 0, _("Keyword %s cannot be overridden"), kw));
 219       if (global)
 220         xheader_list_append (&keyword_global_override_list, kw, p);
 221       else
 222         xheader_list_append (&keyword_override_list, kw, p);
 223     }
 224 }
 225
 226 void
 227 xheader_set_option (char *string)
 228 {
 229   char *token;
 230   for (token = strtok (string, ","); token; token = strtok (NULL, ","))
 231     {
 232       char *p = strchr (token, '=');
 233       if (!p)
 234         xheader_set_single_keyword (token);
 235       else
 236         xheader_set_keyword_equal (token, p);
 237     }
 238 }
 239
 240 /*
 241     string Includes:          Replaced By:
 242      %d                       The directory name of the file,
 243                               equivalent to the result of the
 244                               dirname utility on the translated
 245                               file name.
 246      %f                       The filename of the file, equivalent
 247                               to the result of the basename
 248                               utility on the translated file name.
 249      %p                       The process ID of the pax process.
 250      %n                       The value of the 3rd argument.
 251      %%                       A '%' character. */
 252
 253 char *
 254 xheader_format_name (struct tar_stat_info *st, const char *fmt, size_t n)
 255 {
 256   char *buf;
 257   size_t len = strlen (fmt);
 258   char *q;
 259   const char *p;
 260   char *dirp = NULL;
 261   char *dir = NULL;
 262   char *base = NULL;
 263   char pidbuf[UINTMAX_STRSIZE_BOUND];
 264   char const *pptr;
 265   char nbuf[UINTMAX_STRSIZE_BOUND];
 266   char const *nptr = NULL;
 267
 268   for (p = fmt; *p && (p = strchr (p, '%')); )
 269     {
 270       switch (p[1])
 271         {
 272         case '%':
 273           len--;
 274           break;
 275
 276         case 'd':
 277           if (st)
 278             {
 279               if (!dirp)
 280                 dirp = dir_name (st->orig_file_name);
 281               dir = safer_name_suffix (dirp, false, absolute_names_option);
 282               len += strlen (dir) - 2;
 283             }
 284           break;
 285
 286         case 'f':
 287           if (st)
 288             {
 289               base = last_component (st->orig_file_name);
 290               len += strlen (base) - 2;
 291             }
 292           break;
 293
 294         case 'p':
 295           pptr = umaxtostr (getpid (), pidbuf);
 296           len += pidbuf + sizeof pidbuf - 1 - pptr - 2;
 297           break;
 298
 299         case 'n':
 300           nptr = umaxtostr (n, nbuf);
 301           len += nbuf + sizeof nbuf - 1 - nptr - 2;
 302           break;
 303         }
 304       p++;
 305     }
 306
 307   buf = xmalloc (len + 1);
 308   for (q = buf, p = fmt; *p; )
 309     {
 310       if (*p == '%')
 311         {
 312           switch (p[1])
 313             {
 314             case '%':
 315               *q++ = *p++;
 316               p++;
 317               break;
 318
 319             case 'd':
 320               if (dir)
 321                 q = stpcpy (q, dir);
 322               p += 2;
 323               break;
 324
 325             case 'f':
 326               if (base)
 327                 q = stpcpy (q, base);
 328               p += 2;
 329               break;
 330
 331             case 'p':
 332               q = stpcpy (q, pptr);
 333               p += 2;
 334               break;
 335
 336             case 'n':
 337               if (nptr)
 338                 {
 339                   q = stpcpy (q, nptr);
 340                   p += 2;
 341                   break;
 342                 }
 343               /* else fall through */
 344
 345             default:
 346               *q++ = *p++;
 347               if (*p)
 348                 *q++ = *p++;
 349             }
 350         }
 351       else
 352         *q++ = *p++;
 353     }
 354
 355   free (dirp);
 356
 357   /* Do not allow it to end in a slash */
 358   while (q > buf && ISSLASH (q[-1]))
 359     q--;
 360   *q = 0;
 361   return buf;
 362 }
 363
 364 char *
 365 xheader_xhdr_name (struct tar_stat_info *st)
 366 {
 367   if (!exthdr_name)
 368     assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
 369   return xheader_format_name (st, exthdr_name, 0);
 370 }
 371
 372 #define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
 373
 374 char *
 375 xheader_ghdr_name (void)
 376 {
 377   if (!globexthdr_name)
 378     {
 379       size_t len;
 380       const char *tmp = getenv ("TMPDIR");
 381       if (!tmp)
 382         tmp = "/tmp";
 383       len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE); /* Includes nul */
 384       globexthdr_name = xmalloc (len);
 385       strcpy(globexthdr_name, tmp);
 386       strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
 387     }
 388
 389   return xheader_format_name (NULL, globexthdr_name, global_header_count + 1);
 390 }
 391
 392 void
 393 xheader_write (char type, char *name, time_t t, struct xheader *xhdr)
 394 {
 395   union block *header;
 396   size_t size;
 397   char *p;
 398
 399   size = xhdr->size;
 400   switch (type)
 401     {
 402     case XGLTYPE:
 403       if (globexthdr_mtime_option)
 404         t = globexthdr_mtime;
 405       break;
 406
 407     case XHDTYPE:
 408       if (exthdr_mtime_option)
 409         t = exthdr_mtime;
 410       break;
 411     }
 412   header = start_private_header (name, size, t);
 413   header->header.typeflag = type;
 414
 415   simple_finish_header (header);
 416
 417   p = xhdr->buffer;
 418
 419   do
 420     {
 421       size_t len;
 422
 423       header = find_next_block ();
 424       len = BLOCKSIZE;
 425       if (len > size)
 426         len = size;
 427       memcpy (header->buffer, p, len);
 428       if (len < BLOCKSIZE)
 429         memset (header->buffer + len, 0, BLOCKSIZE - len);
 430       p += len;
 431       size -= len;
 432       set_next_block_after (header);
 433     }
 434   while (size > 0);
 435   xheader_destroy (xhdr);
 436
 437   if (type == XGLTYPE)
 438     global_header_count++;
 439 }
 440
 441 void
 442 xheader_write_global (struct xheader *xhdr)
 443 {
 444   if (keyword_global_override_list)
 445     {
 446       struct keyword_list *kp;
 447
 448       xheader_init (xhdr);
 449       for (kp = keyword_global_override_list; kp; kp = kp->next)
 450         code_string (kp->value, kp->pattern, xhdr);
 451     }
 452   if (xhdr->stk)
 453     {
 454       char *name;
 455
 456       xheader_finish (xhdr);
 457       xheader_write (XGLTYPE, name = xheader_ghdr_name (), time (NULL), xhdr);
 458       free (name);
 459     }
 460 }
 461
 462 \f
 463 /* General Interface */
 464
 465 #define XHDR_PROTECTED 0x01
 466 #define XHDR_GLOBAL    0x02
 467
 468 struct xhdr_tab
 469 {
 470   char const *keyword;
 471   void (*coder) (struct tar_stat_info const *, char const *,
 472                  struct xheader *, void const *data);
 473   void (*decoder) (struct tar_stat_info *, char const *, char const *, size_t);
 474   int flags;
 475 };
 476
 477 /* This declaration must be extern, because ISO C99 section 6.9.2
 478    prohibits a tentative definition that has both internal linkage and
 479    incomplete type.  If we made it static, we'd have to declare its
 480    size which would be a maintenance pain; if we put its initializer
 481    here, we'd need a boatload of forward declarations, which would be
 482    even more of a pain.  */
 483 extern struct xhdr_tab const xhdr_tab[];
 484
 485 static struct xhdr_tab const *
 486 locate_handler (char const *keyword)
 487 {
 488   struct xhdr_tab const *p;
 489
 490   for (p = xhdr_tab; p->keyword; p++)
 491     if (strcmp (p->keyword, keyword) == 0)
 492       return p;
 493   return NULL;
 494 }
 495
 496 static bool
 497 xheader_protected_pattern_p (const char *pattern)
 498 {
 499   struct xhdr_tab const *p;
 500
 501   for (p = xhdr_tab; p->keyword; p++)
 502     if ((p->flags & XHDR_PROTECTED) && fnmatch (pattern, p->keyword, 0) == 0)
 503       return true;
 504   return false;
 505 }
 506
 507 static bool
 508 xheader_protected_keyword_p (const char *keyword)
 509 {
 510   struct xhdr_tab const *p;
 511
 512   for (p = xhdr_tab; p->keyword; p++)
 513     if ((p->flags & XHDR_PROTECTED) && strcmp (p->keyword, keyword) == 0)
 514       return true;
 515   return false;
 516 }
 517
 518 /* Decode a single extended header record, advancing *PTR to the next record.
 519    Return true on success, false otherwise.  */
 520 static bool
 521 decode_record (struct xheader *xhdr,
 522                char **ptr,
 523                void (*handler) (void *, char const *, char const *, size_t),
 524                void *data)
 525 {
 526   char *start = *ptr;
 527   char *p = start;
 528   uintmax_t u;
 529   size_t len;
 530   char *len_lim;
 531   char const *keyword;
 532   char *nextp;
 533   size_t len_max = xhdr->buffer + xhdr->size - start;
 534
 535   while (*p == ' ' || *p == '\t')
 536     p++;
 537
 538   if (! ISDIGIT (*p))
 539     {
 540       if (*p)
 541         ERROR ((0, 0, _("Malformed extended header: missing length")));
 542       return false;
 543     }
 544
 545   errno = 0;
 546   len = u = strtoumax (p, &len_lim, 10);
 547   if (len != u || errno == ERANGE)
 548     {
 549       ERROR ((0, 0, _("Extended header length is out of allowed range")));
 550       return false;
 551     }
 552
 553   if (len_max < len)
 554     {
 555       int len_len = len_lim - p;
 556       ERROR ((0, 0, _("Extended header length %*s is out of range"),
 557               len_len, p));
 558       return false;
 559     }
 560
 561   nextp = start + len;
 562
 563   for (p = len_lim; *p == ' ' || *p == '\t'; p++)
 564     continue;
 565   if (p == len_lim)
 566     {
 567       ERROR ((0, 0,
 568               _("Malformed extended header: missing blank after length")));
 569       return false;
 570     }
 571
 572   keyword = p;
 573   p = strchr (p, '=');
 574   if (! (p && p < nextp))
 575     {
 576       ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
 577       return false;
 578     }
 579
 580   if (nextp[-1] != '\n')
 581     {
 582       ERROR ((0, 0, _("Malformed extended header: missing newline")));
 583       return false;
 584     }
 585
 586   *p = nextp[-1] = '\0';
 587   handler (data, keyword, p + 1, nextp - p - 2); /* '=' + trailing '\n' */
 588   *p = '=';
 589   nextp[-1] = '\n';
 590   *ptr = nextp;
 591   return true;
 592 }
 593
 594 static void
 595 run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
 596 {
 597   for (; kp; kp = kp->next)
 598     {
 599       struct xhdr_tab const *t = locate_handler (kp->pattern);
 600       if (t)
 601         t->decoder (st, t->keyword, kp->value, strlen (kp->value));
 602     }
 603 }
 604
 605 static void
 606 decx (void *data, char const *keyword, char const *value, size_t size)
 607 {
 608   struct xhdr_tab const *t;
 609   struct tar_stat_info *st = data;
 610
 611   if (xheader_keyword_deleted_p (keyword)
 612       || xheader_keyword_override_p (keyword))
 613     return;
 614
 615   t = locate_handler (keyword);
 616   if (t)
 617     t->decoder (st, keyword, value, size);
 618   else
 619     WARNOPT (WARN_UNKNOWN_KEYWORD,
 620              (0, 0, _("Ignoring unknown extended header keyword `%s'"),
 621               keyword));
 622 }
 623
 624 void
 625 xheader_decode (struct tar_stat_info *st)
 626 {
 627   run_override_list (keyword_global_override_list, st);
 628   run_override_list (global_header_override_list, st);
 629
 630   if (st->xhdr.size)
 631     {
 632       char *p = st->xhdr.buffer + BLOCKSIZE;
 633       while (decode_record (&st->xhdr, &p, decx, st))
 634         continue;
 635     }
 636   run_override_list (keyword_override_list, st);
 637 }
 638
 639 static void
 640 decg (void *data, char const *keyword, char const *value,
 641       size_t size __attribute__((unused)))
 642 {
 643   struct keyword_list **kwl = data;
 644   struct xhdr_tab const *tab = locate_handler (keyword);
 645   if (tab && (tab->flags & XHDR_GLOBAL))
 646     tab->decoder (data, keyword, value, size);
 647   else
 648     xheader_list_append (kwl, keyword, value);
 649 }
 650
 651 void
 652 xheader_decode_global (struct xheader *xhdr)
 653 {
 654   if (xhdr->size)
 655     {
 656       char *p = xhdr->buffer + BLOCKSIZE;
 657
 658       xheader_list_destroy (&global_header_override_list);
 659       while (decode_record (xhdr, &p, decg, &global_header_override_list))
 660         continue;
 661     }
 662 }
 663
 664 void
 665 xheader_init (struct xheader *xhdr)
 666 {
 667   if (!xhdr->stk)
 668     {
 669       xhdr->stk = xmalloc (sizeof *xhdr->stk);
 670       obstack_init (xhdr->stk);
 671     }
 672 }
 673
 674 void
 675 xheader_store (char const *keyword, struct tar_stat_info *st,
 676                void const *data)
 677 {
 678   struct xhdr_tab const *t;
 679
 680   if (st->xhdr.buffer)
 681     return;
 682   t = locate_handler (keyword);
 683   if (!t || !t->coder)
 684     return;
 685   if (xheader_keyword_deleted_p (keyword)
 686       || xheader_keyword_override_p (keyword))
 687     return;
 688   xheader_init (&st->xhdr);
 689   t->coder (st, keyword, &st->xhdr, data);
 690 }
 691
 692 void
 693 xheader_read (struct xheader *xhdr, union block *p, size_t size)
 694 {
 695   size_t j = 0;
 696
 697   xheader_init (xhdr);
 698   size += BLOCKSIZE;
 699   xhdr->size = size;
 700   xhdr->buffer = xmalloc (size + 1);
 701   xhdr->buffer[size] = '\0';
 702
 703   do
 704     {
 705       size_t len = size;
 706
 707       if (len > BLOCKSIZE)
 708         len = BLOCKSIZE;
 709
 710       if (!p)
 711         FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
 712
 713       memcpy (&xhdr->buffer[j], p->buffer, len);
 714       set_next_block_after (p);
 715
 716       p = find_next_block ();
 717
 718       j += len;
 719       size -= len;
 720     }
 721   while (size > 0);
 722 }
 723
 724 static void
 725 xheader_print_n (struct xheader *xhdr, char const *keyword,
 726                  char const *value, size_t vsize)
 727 {
 728   size_t len = strlen (keyword) + vsize + 3; /* ' ' + '=' + '\n' */
 729   size_t p;
 730   size_t n = 0;
 731   char nbuf[UINTMAX_STRSIZE_BOUND];
 732   char const *np;
 733
 734   do
 735     {
 736       p = n;
 737       np = umaxtostr (len + p, nbuf);
 738       n = nbuf + sizeof nbuf - 1 - np;
 739     }
 740   while (n != p);
 741
 742   x_obstack_grow (xhdr, np, n);
 743   x_obstack_1grow (xhdr, ' ');
 744   x_obstack_grow (xhdr, keyword, strlen (keyword));
 745   x_obstack_1grow (xhdr, '=');
 746   x_obstack_grow (xhdr, value, vsize);
 747   x_obstack_1grow (xhdr, '\n');
 748 }
 749
 750 static void
 751 xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
 752 {
 753   xheader_print_n (xhdr, keyword, value, strlen (value));
 754 }
 755
 756 void
 757 xheader_finish (struct xheader *xhdr)
 758 {
 759   struct keyword_list *kp;
 760
 761   for (kp = keyword_override_list; kp; kp = kp->next)
 762     code_string (kp->value, kp->pattern, xhdr);
 763
 764   xhdr->buffer = obstack_finish (xhdr->stk);
 765 }
 766
 767 void
 768 xheader_destroy (struct xheader *xhdr)
 769 {
 770   if (xhdr->stk)
 771     {
 772       obstack_free (xhdr->stk, NULL);
 773       free (xhdr->stk);
 774       xhdr->stk = NULL;
 775     }
 776   else
 777     free (xhdr->buffer);
 778   xhdr->buffer = 0;
 779   xhdr->size = 0;
 780 }
 781
 782 \f
 783 /* Buildable strings */
 784
 785 void
 786 xheader_string_begin (struct xheader *xhdr)
 787 {
 788   xhdr->string_length = 0;
 789 }
 790
 791 void
 792 xheader_string_add (struct xheader *xhdr, char const *s)
 793 {
 794   if (xhdr->buffer)
 795     return;
 796   xheader_init (xhdr);
 797   xhdr->string_length += strlen (s);
 798   x_obstack_grow (xhdr, s, strlen (s));
 799 }
 800
 801 bool
 802 xheader_string_end (struct xheader *xhdr, char const *keyword)
 803 {
 804   uintmax_t len;
 805   uintmax_t p;
 806   uintmax_t n = 0;
 807   size_t size;
 808   char nbuf[UINTMAX_STRSIZE_BOUND];
 809   char const *np;
 810   char *cp;
 811
 812   if (xhdr->buffer)
 813     return false;
 814   xheader_init (xhdr);
 815
 816   len = strlen (keyword) + xhdr->string_length + 3; /* ' ' + '=' + '\n' */
 817
 818   do
 819     {
 820       p = n;
 821       np = umaxtostr (len + p, nbuf);
 822       n = nbuf + sizeof nbuf - 1 - np;
 823     }
 824   while (n != p);
 825
 826   p = strlen (keyword) + n + 2;
 827   size = p;
 828   if (size != p)
 829     {
 830       ERROR ((0, 0,
 831         _("Generated keyword/value pair is too long (keyword=%s, length=%s)"),
 832               keyword, nbuf));
 833       obstack_free (xhdr->stk, obstack_finish (xhdr->stk));
 834       return false;
 835     }
 836   x_obstack_blank (xhdr, p);
 837   x_obstack_1grow (xhdr, '\n');
 838   cp = obstack_next_free (xhdr->stk) - xhdr->string_length - p - 1;
 839   memmove (cp + p, cp, xhdr->string_length);
 840   cp = stpcpy (cp, np);
 841   *cp++ = ' ';
 842   cp = stpcpy (cp, keyword);
 843   *cp++ = '=';
 844   return true;
 845 }
 846
 847 \f
 848 /* Implementations */
 849
 850 static void
 851 out_of_range_header (char const *keyword, char const *value,
 852                      uintmax_t minus_minval, uintmax_t maxval)
 853 {
 854   char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 855   char maxval_buf[UINTMAX_STRSIZE_BOUND];
 856   char *minval_string = umaxtostr (minus_minval, minval_buf + 1);
 857   char *maxval_string = umaxtostr (maxval, maxval_buf);
 858   if (minus_minval)
 859     *--minval_string = '-';
 860
 861   /* TRANSLATORS: The first %s is the pax extended header keyword
 862      (atime, gid, etc.).  */
 863   ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
 864           keyword, value, minval_string, maxval_string));
 865 }
 866
 867 static void
 868 code_string (char const *string, char const *keyword, struct xheader *xhdr)
 869 {
 870   char *outstr;
 871   if (!utf8_convert (true, string, &outstr))
 872     {
 873       /* FIXME: report error */
 874       outstr = xstrdup (string);
 875     }
 876   xheader_print (xhdr, keyword, outstr);
 877   free (outstr);
 878 }
 879
 880 static void
 881 decode_string (char **string, char const *arg)
 882 {
 883   if (*string)
 884     {
 885       free (*string);
 886       *string = NULL;
 887     }
 888   if (!utf8_convert (false, arg, string))
 889     {
 890       /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
 891       assign_string (string, arg);
 892     }
 893 }
 894
 895 static void
 896 code_time (struct timespec t, char const *keyword, struct xheader *xhdr)
 897 {
 898   char buf[TIMESPEC_STRSIZE_BOUND];
 899   xheader_print (xhdr, keyword, code_timespec (t, buf));
 900 }
 901
 902 enum decode_time_status
 903   {
 904     decode_time_success,
 905     decode_time_range,
 906     decode_time_bad_header
 907   };
 908
 909 static enum decode_time_status
 910 _decode_time (struct timespec *ts, char const *arg, char const *keyword)
 911 {
 912   time_t s;
 913   unsigned long int ns = 0;
 914   char *p;
 915   char *arg_lim;
 916   bool negative = *arg == '-';
 917
 918   errno = 0;
 919
 920   if (ISDIGIT (arg[negative]))
 921     {
 922       if (negative)
 923         {
 924           intmax_t i = strtoimax (arg, &arg_lim, 10);
 925           if (TYPE_SIGNED (time_t) ? i < TYPE_MINIMUM (time_t) : i < 0)
 926             return decode_time_range;
 927           s = i;
 928         }
 929       else
 930         {
 931           uintmax_t i = strtoumax (arg, &arg_lim, 10);
 932           if (TYPE_MAXIMUM (time_t) < i)
 933             return decode_time_range;
 934           s = i;
 935         }
 936
 937       p = arg_lim;
 938
 939       if (errno == ERANGE)
 940         return decode_time_range;
 941
 942       if (*p == '.')
 943         {
 944           int digits = 0;
 945           bool trailing_nonzero = false;
 946
 947           while (ISDIGIT (*++p))
 948             if (digits < LOG10_BILLION)
 949               {
 950                 ns = 10 * ns + (*p - '0');
 951                 digits++;
 952               }
 953             else
 954               trailing_nonzero |= *p != '0';
 955
 956           while (digits++ < LOG10_BILLION)
 957             ns *= 10;
 958
 959           if (negative)
 960             {
 961               /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
 962                  I.e., truncate time stamps towards minus infinity while
 963                  converting them to internal form.  */
 964               ns += trailing_nonzero;
 965               if (ns != 0)
 966                 {
 967                   if (s == TYPE_MINIMUM (time_t))
 968                     return decode_time_range;
 969                   s--;
 970                   ns = BILLION - ns;
 971                 }
 972             }
 973         }
 974
 975       if (! *p)
 976         {
 977           ts->tv_sec = s;
 978           ts->tv_nsec = ns;
 979           return decode_time_success;
 980         }
 981     }
 982
 983   return decode_time_bad_header;
 984 }
 985
 986 static bool
 987 decode_time (struct timespec *ts, char const *arg, char const *keyword)
 988 {
 989   switch (_decode_time (ts, arg, keyword))
 990     {
 991     case decode_time_success:
 992       return true;
 993     case decode_time_bad_header:
 994       ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
 995               keyword, arg));
 996       return false;
 997     case decode_time_range:
 998       out_of_range_header (keyword, arg, - (uintmax_t) TYPE_MINIMUM (time_t),
 999                            TYPE_MAXIMUM (time_t));
1000       return false;
1001     }
1002   return true;
1003 }
1004
1005
1006
1007 static void
1008 code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
1009 {
1010   char sbuf[UINTMAX_STRSIZE_BOUND];
1011   xheader_print (xhdr, keyword, umaxtostr (value, sbuf));
1012 }
1013
1014 static bool
1015 decode_num (uintmax_t *num, char const *arg, uintmax_t maxval,
1016             char const *keyword)
1017 {
1018   uintmax_t u;
1019   char *arg_lim;
1020
1021   if (! (ISDIGIT (*arg)
1022          && (errno = 0, u = strtoumax (arg, &arg_lim, 10), !*arg_lim)))
1023     {
1024       ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1025               keyword, arg));
1026       return false;
1027     }
1028
1029   if (! (u <= maxval && errno != ERANGE))
1030     {
1031       out_of_range_header (keyword, arg, 0, maxval);
1032       return false;
1033     }
1034
1035   *num = u;
1036   return true;
1037 }
1038
1039 static void
1040 dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
1041              char const *keyword __attribute__ ((unused)),
1042              struct xheader *xhdr __attribute__ ((unused)),
1043              void const *data __attribute__ ((unused)))
1044 {
1045 }
1046
1047 static void
1048 dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
1049                char const *keyword __attribute__ ((unused)),
1050                char const *arg __attribute__ ((unused)),
1051                size_t size __attribute__((unused)))
1052 {
1053 }
1054
1055 static void
1056 atime_coder (struct tar_stat_info const *st, char const *keyword,
1057              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1058 {
1059   code_time (st->atime, keyword, xhdr);
1060 }
1061
1062 static void
1063 atime_decoder (struct tar_stat_info *st,
1064                char const *keyword,
1065                char const *arg,
1066                size_t size __attribute__((unused)))
1067 {
1068   struct timespec ts;
1069   if (decode_time (&ts, arg, keyword))
1070     st->atime = ts;
1071 }
1072
1073 static void
1074 gid_coder (struct tar_stat_info const *st, char const *keyword,
1075            struct xheader *xhdr, void const *data __attribute__ ((unused)))
1076 {
1077   code_num (st->stat.st_gid, keyword, xhdr);
1078 }
1079
1080 static void
1081 gid_decoder (struct tar_stat_info *st,
1082              char const *keyword,
1083              char const *arg,
1084              size_t size __attribute__((unused)))
1085 {
1086   uintmax_t u;
1087   if (decode_num (&u, arg, TYPE_MAXIMUM (gid_t), keyword))
1088     st->stat.st_gid = u;
1089 }
1090
1091 static void
1092 gname_coder (struct tar_stat_info const *st, char const *keyword,
1093              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1094 {
1095   code_string (st->gname, keyword, xhdr);
1096 }
1097
1098 static void
1099 gname_decoder (struct tar_stat_info *st,
1100                char const *keyword __attribute__((unused)),
1101                char const *arg,
1102                size_t size __attribute__((unused)))
1103 {
1104   decode_string (&st->gname, arg);
1105 }
1106
1107 static void
1108 linkpath_coder (struct tar_stat_info const *st, char const *keyword,
1109                 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1110 {
1111   code_string (st->link_name, keyword, xhdr);
1112 }
1113
1114 static void
1115 linkpath_decoder (struct tar_stat_info *st,
1116                   char const *keyword __attribute__((unused)),
1117                   char const *arg,
1118                   size_t size __attribute__((unused)))
1119 {
1120   decode_string (&st->link_name, arg);
1121 }
1122
1123 static void
1124 ctime_coder (struct tar_stat_info const *st, char const *keyword,
1125              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1126 {
1127   code_time (st->ctime, keyword, xhdr);
1128 }
1129
1130 static void
1131 ctime_decoder (struct tar_stat_info *st,
1132                char const *keyword,
1133                char const *arg,
1134                size_t size __attribute__((unused)))
1135 {
1136   struct timespec ts;
1137   if (decode_time (&ts, arg, keyword))
1138     st->ctime = ts;
1139 }
1140
1141 static void
1142 mtime_coder (struct tar_stat_info const *st, char const *keyword,
1143              struct xheader *xhdr, void const *data)
1144 {
1145   struct timespec const *mtime = data;
1146   code_time (mtime ? *mtime : st->mtime, keyword, xhdr);
1147 }
1148
1149 static void
1150 mtime_decoder (struct tar_stat_info *st,
1151                char const *keyword,
1152                char const *arg,
1153                size_t size __attribute__((unused)))
1154 {
1155   struct timespec ts;
1156   if (decode_time (&ts, arg, keyword))
1157     st->mtime = ts;
1158 }
1159
1160 static void
1161 path_coder (struct tar_stat_info const *st, char const *keyword,
1162             struct xheader *xhdr, void const *data __attribute__ ((unused)))
1163 {
1164   code_string (st->file_name, keyword, xhdr);
1165 }
1166
1167 static void
1168 path_decoder (struct tar_stat_info *st,
1169               char const *keyword __attribute__((unused)),
1170               char const *arg,
1171               size_t size __attribute__((unused)))
1172 {
1173   decode_string (&st->orig_file_name, arg);
1174   decode_string (&st->file_name, arg);
1175   st->had_trailing_slash = strip_trailing_slashes (st->file_name);
1176 }
1177
1178 static void
1179 size_coder (struct tar_stat_info const *st, char const *keyword,
1180             struct xheader *xhdr, void const *data __attribute__ ((unused)))
1181 {
1182   code_num (st->stat.st_size, keyword, xhdr);
1183 }
1184
1185 static void
1186 size_decoder (struct tar_stat_info *st,
1187               char const *keyword,
1188               char const *arg,
1189               size_t size __attribute__((unused)))
1190 {
1191   uintmax_t u;
1192   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1193     st->stat.st_size = u;
1194 }
1195
1196 static void
1197 uid_coder (struct tar_stat_info const *st, char const *keyword,
1198            struct xheader *xhdr, void const *data __attribute__ ((unused)))
1199 {
1200   code_num (st->stat.st_uid, keyword, xhdr);
1201 }
1202
1203 static void
1204 uid_decoder (struct tar_stat_info *st,
1205              char const *keyword,
1206              char const *arg,
1207              size_t size __attribute__((unused)))
1208 {
1209   uintmax_t u;
1210   if (decode_num (&u, arg, TYPE_MAXIMUM (uid_t), keyword))
1211     st->stat.st_uid = u;
1212 }
1213
1214 static void
1215 uname_coder (struct tar_stat_info const *st, char const *keyword,
1216              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1217 {
1218   code_string (st->uname, keyword, xhdr);
1219 }
1220
1221 static void
1222 uname_decoder (struct tar_stat_info *st,
1223                char const *keyword __attribute__((unused)),
1224                char const *arg,
1225                size_t size __attribute__((unused)))
1226 {
1227   decode_string (&st->uname, arg);
1228 }
1229
1230 static void
1231 sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
1232              struct xheader *xhdr, void const *data)
1233 {
1234   size_coder (st, keyword, xhdr, data);
1235 }
1236
1237 static void
1238 sparse_size_decoder (struct tar_stat_info *st,
1239                      char const *keyword,
1240                      char const *arg,
1241                      size_t size __attribute__((unused)))
1242 {
1243   uintmax_t u;
1244   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1245     st->stat.st_size = u;
1246 }
1247
1248 static void
1249 sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
1250                         struct xheader *xhdr,
1251                         void const *data __attribute__ ((unused)))
1252 {
1253   code_num (st->sparse_map_avail, keyword, xhdr);
1254 }
1255
1256 static void
1257 sparse_numblocks_decoder (struct tar_stat_info *st,
1258                           char const *keyword,
1259                           char const *arg,
1260                           size_t size __attribute__((unused)))
1261 {
1262   uintmax_t u;
1263   if (decode_num (&u, arg, SIZE_MAX, keyword))
1264     {
1265       st->sparse_map_size = u;
1266       st->sparse_map = xcalloc (u, sizeof st->sparse_map[0]);
1267       st->sparse_map_avail = 0;
1268     }
1269 }
1270
1271 static void
1272 sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
1273                      struct xheader *xhdr, void const *data)
1274 {
1275   size_t const *pi = data;
1276   code_num (st->sparse_map[*pi].offset, keyword, xhdr);
1277 }
1278
1279 static void
1280 sparse_offset_decoder (struct tar_stat_info *st,
1281                        char const *keyword,
1282                        char const *arg,
1283                        size_t size __attribute__((unused)))
1284 {
1285   uintmax_t u;
1286   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
1287     {
1288       if (st->sparse_map_avail < st->sparse_map_size)
1289         st->sparse_map[st->sparse_map_avail].offset = u;
1290       else
1291         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1292                 "GNU.sparse.offset", arg));
1293     }
1294 }
1295
1296 static void
1297 sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
1298                        struct xheader *xhdr, void const *data)
1299 {
1300   size_t const *pi = data;
1301   code_num (st->sparse_map[*pi].numbytes, keyword, xhdr);
1302 }
1303
1304 static void
1305 sparse_numbytes_decoder (struct tar_stat_info *st,
1306                          char const *keyword,
1307                          char const *arg,
1308                          size_t size __attribute__((unused)))
1309 {
1310   uintmax_t u;
1311   if (decode_num (&u, arg, SIZE_MAX, keyword))
1312     {
1313       if (st->sparse_map_avail < st->sparse_map_size)
1314         st->sparse_map[st->sparse_map_avail++].numbytes = u;
1315       else
1316         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1317                 keyword, arg));
1318     }
1319 }
1320
1321 static void
1322 sparse_map_decoder (struct tar_stat_info *st,
1323                     char const *keyword,
1324                     char const *arg,
1325                     size_t size __attribute__((unused)))
1326 {
1327   int offset = 1;
1328
1329   st->sparse_map_avail = 0;
1330   while (1)
1331     {
1332       uintmax_t u;
1333       char *delim;
1334       struct sp_array e;
1335
1336       if (!ISDIGIT (*arg))
1337         {
1338           ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1339                   keyword, arg));
1340           return;
1341         }
1342
1343       errno = 0;
1344       u = strtoumax (arg, &delim, 10);
1345       if (offset)
1346         {
1347           e.offset = u;
1348           if (!(u == e.offset && errno != ERANGE))
1349             {
1350               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1351               return;
1352             }
1353         }
1354       else
1355         {
1356           e.numbytes = u;
1357           if (!(u == e.numbytes && errno != ERANGE))
1358             {
1359               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (size_t));
1360               return;
1361             }
1362           if (st->sparse_map_avail < st->sparse_map_size)
1363             st->sparse_map[st->sparse_map_avail++] = e;
1364           else
1365             {
1366               ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1367                       keyword, arg));
1368               return;
1369             }
1370         }
1371
1372       offset = !offset;
1373
1374       if (*delim == 0)
1375         break;
1376       else if (*delim != ',')
1377         {
1378           ERROR ((0, 0,
1379                   _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1380                   keyword, *delim));
1381           return;
1382         }
1383
1384       arg = delim + 1;
1385     }
1386
1387   if (!offset)
1388     ERROR ((0, 0,
1389             _("Malformed extended header: invalid %s: odd number of values"),
1390             keyword));
1391 }
1392
1393 static void
1394 dumpdir_coder (struct tar_stat_info const *st, char const *keyword,
1395                struct xheader *xhdr, void const *data)
1396 {
1397   xheader_print_n (xhdr, keyword, data, dumpdir_size (data));
1398 }
1399
1400 static void
1401 dumpdir_decoder (struct tar_stat_info *st,
1402                  char const *keyword __attribute__((unused)),
1403                  char const *arg,
1404                  size_t size)
1405 {
1406   st->dumpdir = xmalloc (size);
1407   memcpy (st->dumpdir, arg, size);
1408 }
1409
1410 static void
1411 volume_label_coder (struct tar_stat_info const *st, char const *keyword,
1412                     struct xheader *xhdr, void const *data)
1413 {
1414   code_string (data, keyword, xhdr);
1415 }
1416
1417 static void
1418 volume_label_decoder (struct tar_stat_info *st,
1419                       char const *keyword __attribute__((unused)),
1420                       char const *arg,
1421                       size_t size __attribute__((unused)))
1422 {
1423   decode_string (&volume_label, arg);
1424 }
1425
1426 static void
1427 volume_size_coder (struct tar_stat_info const *st, char const *keyword,
1428                    struct xheader *xhdr, void const *data)
1429 {
1430   off_t const *v = data;
1431   code_num (*v, keyword, xhdr);
1432 }
1433
1434 static void
1435 volume_size_decoder (struct tar_stat_info *st,
1436                      char const *keyword,
1437                      char const *arg, size_t size)
1438 {
1439   uintmax_t u;
1440   if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1441     continued_file_size = u;
1442 }
1443
1444 /* FIXME: Merge with volume_size_coder */
1445 static void
1446 volume_offset_coder (struct tar_stat_info const *st, char const *keyword,
1447                      struct xheader *xhdr, void const *data)
1448 {
1449   off_t const *v = data;
1450   code_num (*v, keyword, xhdr);
1451 }
1452
1453 static void
1454 volume_offset_decoder (struct tar_stat_info *st,
1455                        char const *keyword,
1456                        char const *arg, size_t size)
1457 {
1458   uintmax_t u;
1459   if (decode_num (&u, arg, TYPE_MAXIMUM (uintmax_t), keyword))
1460     continued_file_offset = u;
1461 }
1462
1463 static void
1464 volume_filename_decoder (struct tar_stat_info *st,
1465                          char const *keyword __attribute__((unused)),
1466                          char const *arg,
1467                          size_t size __attribute__((unused)))
1468 {
1469   decode_string (&continued_file_name, arg);
1470 }
1471
1472 static void
1473 sparse_major_coder (struct tar_stat_info const *st, char const *keyword,
1474                     struct xheader *xhdr, void const *data)
1475 {
1476   code_num (st->sparse_major, keyword, xhdr);
1477 }
1478
1479 static void
1480 sparse_major_decoder (struct tar_stat_info *st,
1481                       char const *keyword,
1482                       char const *arg,
1483                       size_t size)
1484 {
1485   uintmax_t u;
1486   if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1487     st->sparse_major = u;
1488 }
1489
1490 static void
1491 sparse_minor_coder (struct tar_stat_info const *st, char const *keyword,
1492                       struct xheader *xhdr, void const *data)
1493 {
1494   code_num (st->sparse_minor, keyword, xhdr);
1495 }
1496
1497 static void
1498 sparse_minor_decoder (struct tar_stat_info *st,
1499                       char const *keyword,
1500                       char const *arg,
1501                       size_t size)
1502 {
1503   uintmax_t u;
1504   if (decode_num (&u, arg, TYPE_MAXIMUM (unsigned), keyword))
1505     st->sparse_minor = u;
1506 }
1507
1508 struct xhdr_tab const xhdr_tab[] = {
1509   { "atime",    atime_coder,    atime_decoder,    0 },
1510   { "comment",  dummy_coder,    dummy_decoder,    0 },
1511   { "charset",  dummy_coder,    dummy_decoder,    0 },
1512   { "ctime",    ctime_coder,    ctime_decoder,    0 },
1513   { "gid",      gid_coder,      gid_decoder,      0 },
1514   { "gname",    gname_coder,    gname_decoder,    0 },
1515   { "linkpath", linkpath_coder, linkpath_decoder, 0 },
1516   { "mtime",    mtime_coder,    mtime_decoder,    0 },
1517   { "path",     path_coder,     path_decoder,     0 },
1518   { "size",     size_coder,     size_decoder,     0 },
1519   { "uid",      uid_coder,      uid_decoder,      0 },
1520   { "uname",    uname_coder,    uname_decoder,    0 },
1521
1522   /* Sparse file handling */
1523   { "GNU.sparse.name",       path_coder, path_decoder,
1524     XHDR_PROTECTED },
1525   { "GNU.sparse.major",      sparse_major_coder, sparse_major_decoder,
1526     XHDR_PROTECTED },
1527   { "GNU.sparse.minor",      sparse_minor_coder, sparse_minor_decoder,
1528     XHDR_PROTECTED },
1529   { "GNU.sparse.realsize",   sparse_size_coder, sparse_size_decoder,
1530     XHDR_PROTECTED },
1531   { "GNU.sparse.numblocks",  sparse_numblocks_coder, sparse_numblocks_decoder,
1532     XHDR_PROTECTED },
1533
1534   /* tar 1.14 - 1.15.90 keywords. */
1535   { "GNU.sparse.size",       sparse_size_coder, sparse_size_decoder,
1536     XHDR_PROTECTED },
1537   /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
1538      headers, and each of them was meaningful. It confilcted with POSIX specs,
1539      which requires that "when extended header records conflict, the last one
1540      given in the header shall take precedence." */
1541   { "GNU.sparse.offset",     sparse_offset_coder, sparse_offset_decoder,
1542     XHDR_PROTECTED },
1543   { "GNU.sparse.numbytes",   sparse_numbytes_coder, sparse_numbytes_decoder,
1544     XHDR_PROTECTED },
1545   /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
1546   { "GNU.sparse.map",        NULL /* Unused, see pax_dump_header() */,
1547     sparse_map_decoder, 0 },
1548
1549   { "GNU.dumpdir",           dumpdir_coder, dumpdir_decoder,
1550     XHDR_PROTECTED },
1551
1552   /* Keeps the tape/volume label. May be present only in the global headers.
1553      Equivalent to GNUTYPE_VOLHDR.  */
1554   { "GNU.volume.label", volume_label_coder, volume_label_decoder,
1555     XHDR_PROTECTED | XHDR_GLOBAL },
1556
1557   /* These may be present in a first global header of the archive.
1558      They provide the same functionality as GNUTYPE_MULTIVOL header.
1559      The GNU.volume.size keeps the real_s_sizeleft value, which is
1560      otherwise kept in the size field of a multivolume header.  The
1561      GNU.volume.offset keeps the offset of the start of this volume,
1562      otherwise kept in oldgnu_header.offset.  */
1563   { "GNU.volume.filename", volume_label_coder, volume_filename_decoder,
1564     XHDR_PROTECTED | XHDR_GLOBAL },
1565   { "GNU.volume.size", volume_size_coder, volume_size_decoder,
1566     XHDR_PROTECTED | XHDR_GLOBAL },
1567   { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder,
1568     XHDR_PROTECTED | XHDR_GLOBAL },
1569
1570   { NULL, NULL, NULL, 0 }
1571 };