src/xheader.c

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