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

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