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      %%                       A '%' character. */
 229
 230 static char *
 231 xheader_format_name (struct tar_stat_info *st, const char *fmt, bool allow_n)
 232 {
 233   char *buf;
 234   size_t len = strlen (fmt);
 235   char *q;
 236   const char *p;
 237   char *dir = NULL;
 238   char *base = NULL;
 239   char pidbuf[UINTMAX_STRSIZE_BOUND];
 240   char const *pptr;
 241   char nbuf[UINTMAX_STRSIZE_BOUND];
 242   char const *nptr = NULL;
 243
 244   for (p = fmt; *p && (p = strchr (p, '%')); )
 245     {
 246       switch (p[1])
 247         {
 248         case '%':
 249           len--;
 250           break;
 251
 252         case 'd':
 253           if (st)
 254             {
 255               dir = safer_name_suffix (dir_name (st->orig_file_name),
 256                                        false, absolute_names_option);
 257               len += strlen (dir) - 1;
 258             }
 259           break;
 260
 261         case 'f':
 262           if (st)
 263             {
 264               base = base_name (st->orig_file_name);
 265               len += strlen (base) - 1;
 266             }
 267           break;
 268
 269         case 'p':
 270           pptr = umaxtostr (getpid (), pidbuf);
 271           len += pidbuf + sizeof pidbuf - 1 - pptr - 1;
 272           break;
 273
 274         case 'n':
 275           if (allow_n)
 276             {
 277               nptr = umaxtostr (global_header_count + 1, nbuf);
 278               len += nbuf + sizeof nbuf - 1 - nptr - 1;
 279             }
 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                 }
 320               /* else fall through */
 321
 322             default:
 323               *q++ = *p++;
 324               if (*p)
 325                 *q++ = *p++;
 326             }
 327         }
 328       else
 329         *q++ = *p++;
 330     }
 331
 332   /* Do not allow it to end in a slash */
 333   while (q > buf && ISSLASH (q[-1]))
 334     q--;
 335   *q = 0;
 336   return buf;
 337 }
 338
 339 char *
 340 xheader_xhdr_name (struct tar_stat_info *st)
 341 {
 342   if (!exthdr_name)
 343     assign_string (&exthdr_name, "%d/PaxHeaders.%p/%f");
 344   return xheader_format_name (st, exthdr_name, false);
 345 }
 346
 347 #define GLOBAL_HEADER_TEMPLATE "/GlobalHead.%p.%n"
 348
 349 char *
 350 xheader_ghdr_name (void)
 351 {
 352   if (!globexthdr_name)
 353     {
 354       size_t len;
 355       const char *tmp = getenv ("TMPDIR");
 356       if (!tmp)
 357         tmp = "/tmp";
 358       len = strlen (tmp) + sizeof (GLOBAL_HEADER_TEMPLATE); /* Includes nul */
 359       globexthdr_name = xmalloc (len);
 360       strcpy(globexthdr_name, tmp);
 361       strcat(globexthdr_name, GLOBAL_HEADER_TEMPLATE);
 362     }
 363
 364   return xheader_format_name (NULL, globexthdr_name, true);
 365 }
 366
 367 void
 368 xheader_write (char type, char *name, struct xheader *xhdr)
 369 {
 370   union block *header;
 371   size_t size;
 372   char *p;
 373
 374   size = xhdr->size;
 375   header = start_private_header (name, size);
 376   header->header.typeflag = type;
 377
 378   simple_finish_header (header);
 379
 380   p = xhdr->buffer;
 381
 382   do
 383     {
 384       size_t len;
 385
 386       header = find_next_block ();
 387       len = BLOCKSIZE;
 388       if (len > size)
 389         len = size;
 390       memcpy (header->buffer, p, len);
 391       if (len < BLOCKSIZE)
 392         memset (header->buffer + len, 0, BLOCKSIZE - len);
 393       p += len;
 394       size -= len;
 395       set_next_block_after (header);
 396     }
 397   while (size > 0);
 398   xheader_destroy (xhdr);
 399 }
 400
 401 void
 402 xheader_write_global (void)
 403 {
 404   char *name;
 405   struct keyword_list *kp;
 406
 407   if (!keyword_global_override_list)
 408     return;
 409
 410   extended_header_init ();
 411   for (kp = keyword_global_override_list; kp; kp = kp->next)
 412     code_string (kp->value, kp->pattern, &extended_header);
 413   xheader_finish (&extended_header);
 414   xheader_write (XGLTYPE, name = xheader_ghdr_name (),
 415                  &extended_header);
 416   free (name);
 417   global_header_count++;
 418 }
 419
 420 \f
 421 /* General Interface */
 422
 423 struct xhdr_tab
 424 {
 425   char const *keyword;
 426   void (*coder) (struct tar_stat_info const *, char const *,
 427                  struct xheader *, void const *data);
 428   void (*decoder) (struct tar_stat_info *, char const *, size_t);
 429   bool protect;
 430 };
 431
 432 /* This declaration must be extern, because ISO C99 section 6.9.2
 433    prohibits a tentative definition that has both internal linkage and
 434    incomplete type.  If we made it static, we'd have to declare its
 435    size which would be a maintenance pain; if we put its initializer
 436    here, we'd need a boatload of forward declarations, which would be
 437    even more of a pain.  */
 438 extern struct xhdr_tab const xhdr_tab[];
 439
 440 static struct xhdr_tab const *
 441 locate_handler (char const *keyword)
 442 {
 443   struct xhdr_tab const *p;
 444
 445   for (p = xhdr_tab; p->keyword; p++)
 446     if (strcmp (p->keyword, keyword) == 0)
 447       return p;
 448   return NULL;
 449 }
 450
 451 static bool
 452 xheader_protected_pattern_p (const char *pattern)
 453 {
 454   struct xhdr_tab const *p;
 455
 456   for (p = xhdr_tab; p->keyword; p++)
 457     if (p->protect && fnmatch (pattern, p->keyword, 0) == 0)
 458       return true;
 459   return false;
 460 }
 461
 462 static bool
 463 xheader_protected_keyword_p (const char *keyword)
 464 {
 465   struct xhdr_tab const *p;
 466
 467   for (p = xhdr_tab; p->keyword; p++)
 468     if (p->protect && strcmp (p->keyword, keyword) == 0)
 469       return true;
 470   return false;
 471 }
 472
 473 /* Decode a single extended header record, advancing *PTR to the next record.
 474    Return true on success, false otherwise.  */
 475 static bool
 476 decode_record (char **ptr,
 477                void (*handler) (void *, char const *, char const *, size_t),
 478                void *data)
 479 {
 480   char *start = *ptr;
 481   char *p = start;
 482   unsigned long int len;
 483   char *len_lim;
 484   char const *keyword;
 485   char *nextp;
 486   size_t len_max = extended_header.buffer + extended_header.size - start;
 487
 488   while (*p == ' ' || *p == '\t')
 489     p++;
 490
 491   if (! ISDIGIT (*p))
 492     {
 493       if (*p)
 494         ERROR ((0, 0, _("Malformed extended header: missing length")));
 495       return false;
 496     }
 497
 498   errno = 0;
 499   len = strtoul (p, &len_lim, 10);
 500
 501   if (len_max < len)
 502     {
 503       int len_len = len_lim - p;
 504       ERROR ((0, 0, _("Extended header length %*s is out of range"),
 505               len_len, p));
 506       return false;
 507     }
 508
 509   nextp = start + len;
 510
 511   for (p = len_lim; *p == ' ' || *p == '\t'; p++)
 512     continue;
 513   if (p == len_lim)
 514     {
 515       ERROR ((0, 0,
 516               _("Malformed extended header: missing blank after length")));
 517       return false;
 518     }
 519
 520   keyword = p;
 521   p = strchr (p, '=');
 522   if (! (p && p < nextp))
 523     {
 524       ERROR ((0, 0, _("Malformed extended header: missing equal sign")));
 525       return false;
 526     }
 527
 528   if (nextp[-1] != '\n')
 529     {
 530       ERROR ((0, 0, _("Malformed extended header: missing newline")));
 531       return false;
 532     }
 533
 534   *p = nextp[-1] = '\0';
 535   handler (data, keyword, p + 1, nextp - p - 2); /* '=' + trailing '\n' */
 536   *p = '=';
 537   nextp[-1] = '\n';
 538   *ptr = nextp;
 539   return true;
 540 }
 541
 542 static void
 543 run_override_list (struct keyword_list *kp, struct tar_stat_info *st)
 544 {
 545   for (; kp; kp = kp->next)
 546     {
 547       struct xhdr_tab const *t = locate_handler (kp->pattern);
 548       if (t)
 549         t->decoder (st, kp->value, strlen (kp->value));
 550     }
 551 }
 552
 553 static void
 554 decx (void *data, char const *keyword, char const *value, size_t size)
 555 {
 556   struct xhdr_tab const *t;
 557   struct tar_stat_info *st = data;
 558
 559   if (xheader_keyword_deleted_p (keyword)
 560       || xheader_keyword_override_p (keyword))
 561     return;
 562
 563   t = locate_handler (keyword);
 564   if (t)
 565     t->decoder (st, value, size);
 566   else
 567     ERROR((0, 0, _("Ignoring unknown extended header keyword `%s'"),
 568            keyword));
 569 }
 570
 571 void
 572 xheader_decode (struct tar_stat_info *st)
 573 {
 574   run_override_list (keyword_global_override_list, st);
 575   run_override_list (global_header_override_list, st);
 576
 577   if (extended_header.size)
 578     {
 579       char *p = extended_header.buffer + BLOCKSIZE;
 580       while (decode_record (&p, decx, st))
 581         continue;
 582     }
 583   run_override_list (keyword_override_list, st);
 584 }
 585
 586 static void
 587 decg (void *data, char const *keyword, char const *value,
 588       size_t size __attribute__((unused)))
 589 {
 590   struct keyword_list **kwl = data;
 591   xheader_list_append (kwl, keyword, value);
 592 }
 593
 594 void
 595 xheader_decode_global (void)
 596 {
 597   if (extended_header.size)
 598     {
 599       char *p = extended_header.buffer + BLOCKSIZE;
 600
 601       xheader_list_destroy (&global_header_override_list);
 602       while (decode_record (&p, decg, &global_header_override_list))
 603         continue;
 604     }
 605 }
 606
 607 static void
 608 extended_header_init (void)
 609 {
 610   if (!extended_header.stk)
 611     {
 612       extended_header.stk = xmalloc (sizeof *extended_header.stk);
 613       obstack_init (extended_header.stk);
 614     }
 615 }
 616
 617 void
 618 xheader_store (char const *keyword, struct tar_stat_info const *st, void *data)
 619 {
 620   struct xhdr_tab const *t;
 621
 622   if (extended_header.buffer)
 623     return;
 624   t = locate_handler (keyword);
 625   if (!t || !t->coder)
 626     return;
 627   if (xheader_keyword_deleted_p (keyword)
 628       || xheader_keyword_override_p (keyword))
 629     return;
 630   extended_header_init ();
 631   t->coder (st, keyword, &extended_header, data);
 632 }
 633
 634 void
 635 xheader_read (union block *p, size_t size)
 636 {
 637   size_t j = 0;
 638   size_t nblocks;
 639
 640   free (extended_header.buffer);
 641   size += BLOCKSIZE;
 642   extended_header.size = size;
 643   nblocks = (size + BLOCKSIZE - 1) / BLOCKSIZE;
 644   extended_header.buffer = xmalloc (size + 1);
 645   extended_header.buffer[size] = '\0';
 646
 647   do
 648     {
 649       size_t len = size;
 650
 651       if (len > BLOCKSIZE)
 652         len = BLOCKSIZE;
 653
 654       memcpy (&extended_header.buffer[j], p->buffer, len);
 655       set_next_block_after (p);
 656
 657       p = find_next_block ();
 658
 659       j += len;
 660       size -= len;
 661     }
 662   while (size > 0);
 663 }
 664
 665 static void
 666 xheader_print_n (struct xheader *xhdr, char const *keyword,
 667                  char const *value, size_t vsize)
 668 {
 669   size_t len = strlen (keyword) + vsize + 3; /* ' ' + '=' + '\n' */
 670   size_t p;
 671   size_t n = 0;
 672   char nbuf[UINTMAX_STRSIZE_BOUND];
 673   char const *np;
 674
 675   do
 676     {
 677       p = n;
 678       np = umaxtostr (len + p, nbuf);
 679       n = nbuf + sizeof nbuf - 1 - np;
 680     }
 681   while (n != p);
 682
 683   x_obstack_grow (xhdr, np, n);
 684   x_obstack_1grow (xhdr, ' ');
 685   x_obstack_grow (xhdr, keyword, strlen (keyword));
 686   x_obstack_1grow (xhdr, '=');
 687   x_obstack_grow (xhdr, value, vsize);
 688   x_obstack_1grow (xhdr, '\n');
 689 }
 690
 691 static void
 692 xheader_print (struct xheader *xhdr, char const *keyword, char const *value)
 693 {
 694   xheader_print_n (xhdr, keyword, value, strlen (value));
 695 }
 696
 697 void
 698 xheader_finish (struct xheader *xhdr)
 699 {
 700   struct keyword_list *kp;
 701
 702   for (kp = keyword_override_list; kp; kp = kp->next)
 703     code_string (kp->value, kp->pattern, xhdr);
 704
 705   xhdr->buffer = obstack_finish (xhdr->stk);
 706 }
 707
 708 void
 709 xheader_destroy (struct xheader *xhdr)
 710 {
 711   if (xhdr->stk)
 712     {
 713       obstack_free (xhdr->stk, NULL);
 714       free (xhdr->stk);
 715       xhdr->stk = NULL;
 716     }
 717   else
 718     free (xhdr->buffer);
 719   xhdr->buffer = 0;
 720   xhdr->size = 0;
 721 }
 722
 723 \f
 724 /* Buildable strings */
 725 static uintmax_t string_length;
 726
 727 void
 728 xheader_string_begin ()
 729 {
 730   string_length = 0;
 731 }
 732
 733 void
 734 xheader_string_add (char const *s)
 735 {
 736   if (extended_header.buffer)
 737     return;
 738   extended_header_init ();
 739   string_length += strlen (s);
 740   x_obstack_grow (&extended_header, s, strlen (s));
 741 }
 742
 743 void
 744 xheader_string_end (char const *keyword)
 745 {
 746   size_t len;
 747   size_t p;
 748   size_t n = 0;
 749   char nbuf[UINTMAX_STRSIZE_BOUND];
 750   char const *np;
 751   char *cp;
 752
 753   if (extended_header.buffer)
 754     return;
 755   extended_header_init ();
 756
 757   len = strlen (keyword) + string_length + 3; /* ' ' + '=' + '\n' */
 758
 759   do
 760     {
 761       p = n;
 762       np = umaxtostr (len + p, nbuf);
 763       n = nbuf + sizeof nbuf - 1 - np;
 764     }
 765   while (n != p);
 766
 767   p = strlen (keyword) + n + 2;
 768   x_obstack_blank (&extended_header, p);
 769   x_obstack_1grow (&extended_header, '\n');
 770   cp = obstack_next_free (extended_header.stk) - string_length - p - 1;
 771   memmove (cp + p, cp, string_length);
 772   cp = stpcpy (cp, np);
 773   *cp++ = ' ';
 774   cp = stpcpy (cp, keyword);
 775   *cp++ = '=';
 776 }
 777
 778 \f
 779 /* Implementations */
 780
 781 static void
 782 out_of_range_header (char const *keyword, char const *value,
 783                      uintmax_t minus_minval, uintmax_t maxval)
 784 {
 785   char minval_buf[UINTMAX_STRSIZE_BOUND + 1];
 786   char maxval_buf[UINTMAX_STRSIZE_BOUND];
 787   char *minval_string = umaxtostr (minus_minval, minval_buf + 1);
 788   char *maxval_string = umaxtostr (maxval, maxval_buf);
 789   if (minus_minval)
 790     *--minval_string = '-';
 791
 792   /* TRANSLATORS: The first %s is the pax extended header keyword
 793      (atime, gid, etc.).  */
 794   ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"),
 795           keyword, value, minval_string, maxval_string));
 796 }
 797
 798 static void
 799 code_string (char const *string, char const *keyword, struct xheader *xhdr)
 800 {
 801   char *outstr;
 802   if (!utf8_convert (true, string, &outstr))
 803     {
 804       /* FIXME: report error */
 805       outstr = xstrdup (string);
 806     }
 807   xheader_print (xhdr, keyword, outstr);
 808   free (outstr);
 809 }
 810
 811 static void
 812 decode_string (char **string, char const *arg)
 813 {
 814   if (*string)
 815     {
 816       free (*string);
 817       *string = NULL;
 818     }
 819   if (!utf8_convert (false, arg, string))
 820     {
 821       /* FIXME: report error and act accordingly to --pax invalid=UTF-8 */
 822       assign_string (string, arg);
 823     }
 824 }
 825
 826 static void
 827 code_time (struct timespec t, char const *keyword, struct xheader *xhdr)
 828 {
 829   char buf[TIMESPEC_STRSIZE_BOUND];
 830   xheader_print (xhdr, keyword, code_timespec (t, buf));
 831 }
 832
 833 static bool
 834 decode_time (struct timespec *ts, char const *arg, char const *keyword)
 835 {
 836   time_t s;
 837   unsigned long int ns = 0;
 838   char *p;
 839   char *arg_lim;
 840   bool negative = *arg == '-';
 841
 842   errno = 0;
 843
 844   if (ISDIGIT (arg[negative]))
 845     {
 846       if (negative)
 847         {
 848           intmax_t i = strtoimax (arg, &arg_lim, 10);
 849           if (TYPE_SIGNED (time_t) ? i < TYPE_MINIMUM (time_t) : i < 0)
 850             goto out_of_range;
 851           s = i;
 852         }
 853       else
 854         {
 855           uintmax_t i = strtoumax (arg, &arg_lim, 10);
 856           if (TYPE_MAXIMUM (time_t) < i)
 857             goto out_of_range;
 858           s = i;
 859         }
 860
 861       p = arg_lim;
 862
 863       if (errno == ERANGE)
 864         goto out_of_range;
 865
 866       if (*p == '.')
 867         {
 868           int digits = 0;
 869           bool trailing_nonzero = false;
 870
 871           while (ISDIGIT (*++p))
 872             if (digits < LOG10_BILLION)
 873               {
 874                 ns = 10 * ns + (*p - '0');
 875                 digits++;
 876               }
 877             else
 878               trailing_nonzero |= *p != '0';
 879
 880           while (digits++ < LOG10_BILLION)
 881             ns *= 10;
 882
 883           if (negative)
 884             {
 885               /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
 886                  I.e., truncate time stamps towards minus infinity while
 887                  converting them to internal form.  */
 888               ns += trailing_nonzero;
 889               if (ns != 0)
 890                 {
 891                   if (s == TYPE_MINIMUM (time_t))
 892                     goto out_of_range;
 893                   s--;
 894                   ns = BILLION - ns;
 895                 }
 896             }
 897         }
 898
 899       if (! *p)
 900         {
 901           ts->tv_sec = s;
 902           ts->tv_nsec = ns;
 903           return true;
 904         }
 905     }
 906
 907   ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
 908           keyword, arg));
 909   return false;
 910
 911  out_of_range:
 912   out_of_range_header (keyword, arg, - (uintmax_t) TYPE_MINIMUM (time_t),
 913                        TYPE_MAXIMUM (time_t));
 914   return false;
 915 }
 916
 917 static void
 918 code_num (uintmax_t value, char const *keyword, struct xheader *xhdr)
 919 {
 920   char sbuf[UINTMAX_STRSIZE_BOUND];
 921   xheader_print (xhdr, keyword, umaxtostr (value, sbuf));
 922 }
 923
 924 static bool
 925 decode_num (uintmax_t *num, char const *arg, uintmax_t maxval,
 926             char const *keyword)
 927 {
 928   uintmax_t u;
 929   char *arg_lim;
 930
 931   if (! (ISDIGIT (*arg)
 932          && (errno = 0, u = strtoumax (arg, &arg_lim, 10), !*arg_lim)))
 933     {
 934       ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
 935               keyword, arg));
 936       return false;
 937     }
 938
 939   if (! (u <= maxval && errno != ERANGE))
 940     {
 941       out_of_range_header (keyword, arg, 0, maxval);
 942       return false;
 943     }
 944
 945   *num = u;
 946   return true;
 947 }
 948
 949 static void
 950 dummy_coder (struct tar_stat_info const *st __attribute__ ((unused)),
 951              char const *keyword __attribute__ ((unused)),
 952              struct xheader *xhdr __attribute__ ((unused)),
 953              void const *data __attribute__ ((unused)))
 954 {
 955 }
 956
 957 static void
 958 dummy_decoder (struct tar_stat_info *st __attribute__ ((unused)),
 959                char const *arg __attribute__ ((unused)),
 960                size_t size __attribute__((unused)))
 961 {
 962 }
 963
 964 static void
 965 atime_coder (struct tar_stat_info const *st, char const *keyword,
 966              struct xheader *xhdr, void const *data __attribute__ ((unused)))
 967 {
 968   code_time (st->atime, keyword, xhdr);
 969 }
 970
 971 static void
 972 atime_decoder (struct tar_stat_info *st, char const *arg,
 973                size_t size __attribute__((unused)))
 974 {
 975   struct timespec ts;
 976   if (decode_time (&ts, arg, "atime"))
 977     st->atime = ts;
 978 }
 979
 980 static void
 981 gid_coder (struct tar_stat_info const *st, char const *keyword,
 982            struct xheader *xhdr, void const *data __attribute__ ((unused)))
 983 {
 984   code_num (st->stat.st_gid, keyword, xhdr);
 985 }
 986
 987 static void
 988 gid_decoder (struct tar_stat_info *st, char const *arg,
 989              size_t size __attribute__((unused)))
 990 {
 991   uintmax_t u;
 992   if (decode_num (&u, arg, TYPE_MAXIMUM (gid_t), "gid"))
 993     st->stat.st_gid = u;
 994 }
 995
 996 static void
 997 gname_coder (struct tar_stat_info const *st, char const *keyword,
 998              struct xheader *xhdr, void const *data __attribute__ ((unused)))
 999 {
1000   code_string (st->gname, keyword, xhdr);
1001 }
1002
1003 static void
1004 gname_decoder (struct tar_stat_info *st, char const *arg,
1005                size_t size __attribute__((unused)))
1006 {
1007   decode_string (&st->gname, arg);
1008 }
1009
1010 static void
1011 linkpath_coder (struct tar_stat_info const *st, char const *keyword,
1012                 struct xheader *xhdr, void const *data __attribute__ ((unused)))
1013 {
1014   code_string (st->link_name, keyword, xhdr);
1015 }
1016
1017 static void
1018 linkpath_decoder (struct tar_stat_info *st, char const *arg,
1019                   size_t size __attribute__((unused)))
1020 {
1021   decode_string (&st->link_name, arg);
1022 }
1023
1024 static void
1025 ctime_coder (struct tar_stat_info const *st, char const *keyword,
1026              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1027 {
1028   code_time (st->ctime, keyword, xhdr);
1029 }
1030
1031 static void
1032 ctime_decoder (struct tar_stat_info *st, char const *arg,
1033                size_t size __attribute__((unused)))
1034 {
1035   struct timespec ts;
1036   if (decode_time (&ts, arg, "ctime"))
1037     st->ctime = ts;
1038 }
1039
1040 static void
1041 mtime_coder (struct tar_stat_info const *st, char const *keyword,
1042              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1043 {
1044   code_time (st->mtime, keyword, xhdr);
1045 }
1046
1047 static void
1048 mtime_decoder (struct tar_stat_info *st, char const *arg,
1049                size_t size __attribute__((unused)))
1050 {
1051   struct timespec ts;
1052   if (decode_time (&ts, arg, "mtime"))
1053     st->mtime = ts;
1054 }
1055
1056 static void
1057 path_coder (struct tar_stat_info const *st, char const *keyword,
1058             struct xheader *xhdr, void const *data __attribute__ ((unused)))
1059 {
1060   code_string (st->file_name, keyword, xhdr);
1061 }
1062
1063 static void
1064 path_decoder (struct tar_stat_info *st, char const *arg,
1065               size_t size __attribute__((unused)))
1066 {
1067   decode_string (&st->orig_file_name, arg);
1068   decode_string (&st->file_name, arg);
1069   st->had_trailing_slash = strip_trailing_slashes (st->file_name);
1070 }
1071
1072 static void
1073 size_coder (struct tar_stat_info const *st, char const *keyword,
1074             struct xheader *xhdr, void const *data __attribute__ ((unused)))
1075 {
1076   code_num (st->stat.st_size, keyword, xhdr);
1077 }
1078
1079 static void
1080 size_decoder (struct tar_stat_info *st, char const *arg,
1081               size_t size __attribute__((unused)))
1082 {
1083   uintmax_t u;
1084   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), "size"))
1085     st->stat.st_size = u;
1086 }
1087
1088 static void
1089 uid_coder (struct tar_stat_info const *st, char const *keyword,
1090            struct xheader *xhdr, void const *data __attribute__ ((unused)))
1091 {
1092   code_num (st->stat.st_uid, keyword, xhdr);
1093 }
1094
1095 static void
1096 uid_decoder (struct tar_stat_info *st, char const *arg,
1097              size_t size __attribute__((unused)))
1098 {
1099   uintmax_t u;
1100   if (decode_num (&u, arg, TYPE_MAXIMUM (uid_t), "uid"))
1101     st->stat.st_uid = u;
1102 }
1103
1104 static void
1105 uname_coder (struct tar_stat_info const *st, char const *keyword,
1106              struct xheader *xhdr, void const *data __attribute__ ((unused)))
1107 {
1108   code_string (st->uname, keyword, xhdr);
1109 }
1110
1111 static void
1112 uname_decoder (struct tar_stat_info *st, char const *arg,
1113                size_t size __attribute__((unused)))
1114 {
1115   decode_string (&st->uname, arg);
1116 }
1117
1118 static void
1119 sparse_size_coder (struct tar_stat_info const *st, char const *keyword,
1120              struct xheader *xhdr, void const *data)
1121 {
1122   size_coder (st, keyword, xhdr, data);
1123 }
1124
1125 static void
1126 sparse_size_decoder (struct tar_stat_info *st, char const *arg,
1127                      size_t size __attribute__((unused)))
1128 {
1129   uintmax_t u;
1130   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), "GNU.sparse.size"))
1131     st->stat.st_size = u;
1132 }
1133
1134 static void
1135 sparse_numblocks_coder (struct tar_stat_info const *st, char const *keyword,
1136                         struct xheader *xhdr,
1137                         void const *data __attribute__ ((unused)))
1138 {
1139   code_num (st->sparse_map_avail, keyword, xhdr);
1140 }
1141
1142 static void
1143 sparse_numblocks_decoder (struct tar_stat_info *st, char const *arg,
1144                           size_t size __attribute__((unused)))
1145 {
1146   uintmax_t u;
1147   if (decode_num (&u, arg, SIZE_MAX, "GNU.sparse.numblocks"))
1148     {
1149       st->sparse_map_size = u;
1150       st->sparse_map = xcalloc (u, sizeof st->sparse_map[0]);
1151       st->sparse_map_avail = 0;
1152     }
1153 }
1154
1155 static void
1156 sparse_offset_coder (struct tar_stat_info const *st, char const *keyword,
1157                      struct xheader *xhdr, void const *data)
1158 {
1159   size_t const *pi = data;
1160   code_num (st->sparse_map[*pi].offset, keyword, xhdr);
1161 }
1162
1163 static void
1164 sparse_offset_decoder (struct tar_stat_info *st, char const *arg,
1165                        size_t size __attribute__((unused)))
1166 {
1167   uintmax_t u;
1168   if (decode_num (&u, arg, TYPE_MAXIMUM (off_t), "GNU.sparse.offset"))
1169     {
1170       if (st->sparse_map_avail < st->sparse_map_size)
1171         st->sparse_map[st->sparse_map_avail].offset = u;
1172       else
1173         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1174                 "GNU.sparse.offset", arg));
1175     }
1176 }
1177
1178 static void
1179 sparse_numbytes_coder (struct tar_stat_info const *st, char const *keyword,
1180                        struct xheader *xhdr, void const *data)
1181 {
1182   size_t const *pi = data;
1183   code_num (st->sparse_map[*pi].numbytes, keyword, xhdr);
1184 }
1185
1186 static void
1187 sparse_numbytes_decoder (struct tar_stat_info *st, char const *arg,
1188                          size_t size __attribute__((unused)))
1189 {
1190   uintmax_t u;
1191   if (decode_num (&u, arg, SIZE_MAX, "GNU.sparse.numbytes"))
1192     {
1193       if (st->sparse_map_avail < st->sparse_map_size)
1194         st->sparse_map[st->sparse_map_avail++].numbytes = u;
1195       else
1196         ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1197                 "GNU.sparse.numbytes", arg));
1198     }
1199 }
1200
1201 static void
1202 sparse_map_decoder (struct tar_stat_info *st, char const *arg,
1203                     size_t size __attribute__((unused)))
1204 {
1205   int offset = 1;
1206   static char *keyword = "GNU.sparse.map";
1207
1208   st->sparse_map_avail = 0;
1209   while (1)
1210     {
1211       uintmax_t u;
1212       char *delim;
1213       struct sp_array e;
1214
1215       if (!ISDIGIT (*arg))
1216         {
1217           ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"),
1218                   keyword, arg));
1219           return;
1220         }
1221
1222       errno = 0;
1223       u = strtoumax (arg, &delim, 10);
1224       if (offset)
1225         {
1226           e.offset = u;
1227           if (!(u == e.offset && errno != ERANGE))
1228             {
1229               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (off_t));
1230               return;
1231             }
1232         }
1233       else
1234         {
1235           e.numbytes = u;
1236           if (!(u == e.numbytes && errno != ERANGE))
1237             {
1238               out_of_range_header (keyword, arg, 0, TYPE_MAXIMUM (size_t));
1239               return;
1240             }
1241           if (st->sparse_map_avail < st->sparse_map_size)
1242             st->sparse_map[st->sparse_map_avail++] = e;
1243           else
1244             {
1245               ERROR ((0, 0, _("Malformed extended header: excess %s=%s"),
1246                       "GNU.sparse.numbytes", arg));
1247               return;
1248             }
1249         }
1250
1251       offset = !offset;
1252
1253       if (*delim == 0)
1254         break;
1255       else if (*delim != ',')
1256         {
1257           ERROR ((0, 0,
1258                   _("Malformed extended header: invalid %s: unexpected delimiter %c"),
1259                   keyword, *delim));
1260           return;
1261         }
1262
1263       arg = delim + 1;
1264     }
1265
1266   if (!offset)
1267     ERROR ((0, 0,
1268             _("Malformed extended header: invalid %s: odd number of values"),
1269             keyword));
1270 }
1271
1272 static void
1273 dumpdir_coder (struct tar_stat_info const *st, char const *keyword,
1274                struct xheader *xhdr, void const *data)
1275 {
1276   xheader_print_n (xhdr, keyword, data, dumpdir_size (data));
1277 }
1278
1279 static void
1280 dumpdir_decoder (struct tar_stat_info *st, char const *arg,
1281                  size_t size)
1282 {
1283   st->dumpdir = xmalloc (size);
1284   memcpy (st->dumpdir, arg, size);
1285 }
1286
1287 struct xhdr_tab const xhdr_tab[] = {
1288   { "atime",    atime_coder,    atime_decoder,    false },
1289   { "comment",  dummy_coder,    dummy_decoder,    false },
1290   { "charset",  dummy_coder,    dummy_decoder,    false },
1291   { "ctime",    ctime_coder,    ctime_decoder,    false },
1292   { "gid",      gid_coder,      gid_decoder,      false },
1293   { "gname",    gname_coder,    gname_decoder,    false },
1294   { "linkpath", linkpath_coder, linkpath_decoder, false },
1295   { "mtime",    mtime_coder,    mtime_decoder,    false },
1296   { "path",     path_coder,     path_decoder,     false },
1297   { "size",     size_coder,     size_decoder,     false },
1298   { "uid",      uid_coder,      uid_decoder,      false },
1299   { "uname",    uname_coder,    uname_decoder,    false },
1300
1301   /* Sparse file handling */
1302   { "GNU.sparse.size",       sparse_size_coder, sparse_size_decoder, true },
1303   { "GNU.sparse.numblocks",  sparse_numblocks_coder, sparse_numblocks_decoder,
1304     true },
1305   /* tar 1.14 - 1.15.1 keywords. Multiplse instances of these appeared in 'x'
1306      headers, and each of them was meaningful. It confilcted with POSIX specs,
1307      which requires that "when extended header records conflict, the last one
1308      given in the header shall take precedence." */
1309   { "GNU.sparse.offset",     sparse_offset_coder, sparse_offset_decoder,
1310     true },
1311   { "GNU.sparse.numbytes",   sparse_numbytes_coder, sparse_numbytes_decoder,
1312     true },
1313   /* tar >=1.16 keyword, introduced to remove the above-mentioned conflict. */
1314   { "GNU.sparse.map",        NULL /* Unused, see pax_dump_header() */,
1315     sparse_map_decoder, false },
1316
1317   { "GNU.dumpdir",           dumpdir_coder, dumpdir_decoder,
1318     true },
1319
1320 #if 0 /* GNU private keywords (not yet implemented) */
1321
1322   /* Keeps the tape/volume header. May be present only in the global headers.
1323      Equivalent to GNUTYPE_VOLHDR.  */
1324   { "GNU.volume.header", volume_header_coder, volume_header_decoder, false },
1325
1326   /* These may be present in a first global header of the archive.
1327      They provide the same functionality as GNUTYPE_MULTIVOL header.
1328      The GNU.volume.size keeps the real_s_sizeleft value, which is
1329      otherwise kept in the size field of a multivolume header.  The
1330      GNU.volume.offset keeps the offset of the start of this volume,
1331      otherwise kept in oldgnu_header.offset.  */
1332   { "GNU.volume.size", volume_size_coder, volume_size_decoder, false },
1333   { "GNU.volume.offset", volume_offset_coder, volume_offset_decoder, false },
1334 #endif
1335
1336   { NULL, NULL, NULL, false }
1337 };