src/vfs/tar/tar-xheader.c

   1 /*
   2    Virtual File System: GNU Tar file system.
   3
   4    Copyright (C) 1995-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Andrew Borodin <aborodin@vmail.ru>, 2023
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /**
  27  * \file
  28  * \brief Source: Virtual File System: GNU Tar file system
  29  */
  30
  31 #include <config.h>
  32
  33 #include <ctype.h>              /* isdigit() */
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include "lib/global.h"
  38 #include "lib/util.h"           /* MC_PTR_FREE */
  39
  40 #include "tar-internal.h"
  41
  42 /*** global variables ****************************************************************************/
  43
  44 /*** file scope macro definitions ****************************************************************/
  45
  46 #define XHDR_PROTECTED 0x01
  47 #define XHDR_GLOBAL    0x02
  48
  49 /*** file scope type declarations ****************************************************************/
  50
  51 /* General Interface */
  52
  53 /* Since tar VFS is read-only, inplement decodes only */
  54 /* *INDENT-OFF* */
  55 struct xhdr_tab
  56 {
  57     const char *keyword;
  58     gboolean (*decoder) (struct tar_stat_info * st, const char *keyword, const char *arg, size_t size);
  59     int flags;
  60 };
  61 /* *INDENT-ON* */
  62
  63 /* Keyword options */
  64 struct keyword_item
  65 {
  66     char *pattern;
  67     char *value;
  68 };
  69
  70 enum decode_record_status
  71 {
  72     decode_record_ok,
  73     decode_record_finish,
  74     decode_record_fail
  75 };
  76
  77 /*** forward declarations (file scope functions) *************************************************/
  78
  79 static gboolean dummy_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  80                                size_t size);
  81 static gboolean atime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  82                                size_t size);
  83 static gboolean gid_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  84                              size_t size);
  85 #if 0
  86 static gboolean gname_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  87                                size_t size);
  88 #endif
  89 static gboolean linkpath_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  90                                   size_t size);
  91 static gboolean mtime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  92                                size_t size);
  93 static gboolean ctime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  94                                size_t size);
  95 static gboolean path_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  96                               size_t size);
  97 static gboolean size_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
  98                               size_t size);
  99 static gboolean uid_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 100                              size_t size);
 101 #if 0
 102 static gboolean uname_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 103                                size_t size);
 104 #endif
 105 static gboolean sparse_path_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 106                                      size_t size);
 107 static gboolean sparse_major_decoder (struct tar_stat_info *st, const char *keyword,
 108                                       const char *arg, size_t size);
 109 static gboolean sparse_minor_decoder (struct tar_stat_info *st, const char *keyword,
 110                                       const char *arg, size_t size);
 111 static gboolean sparse_size_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 112                                      size_t size);
 113 static gboolean sparse_numblocks_decoder (struct tar_stat_info *st, const char *keyword,
 114                                           const char *arg, size_t size);
 115 static gboolean sparse_offset_decoder (struct tar_stat_info *st, const char *keyword,
 116                                        const char *arg, size_t size);
 117 static gboolean sparse_numbytes_decoder (struct tar_stat_info *st, const char *keyword,
 118                                          const char *arg, size_t size);
 119 static gboolean sparse_map_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 120                                     size_t size);
 121 static gboolean dumpdir_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 122                                  size_t size);
 123
 124 /*** file scope variables ************************************************************************/
 125
 126 enum
 127 {
 128     BILLION = 1000000000,
 129     LOG10_BILLION = 9
 130 };
 131
 132 /* *INDENT-OFF* */
 133 static struct xhdr_tab xhdr_tab[] =
 134 {
 135     { "atime",                atime_decoder,            0  },
 136     { "comment",              dummy_decoder,            0  },
 137     { "charset",              dummy_decoder,            0  },
 138     { "ctime",                ctime_decoder,            0  },
 139     { "gid",                  gid_decoder,              0  },
 140 #if 0
 141     { "gname",                gname_decoder,            0  },
 142 #endif
 143     { "linkpath",             linkpath_decoder,         0  },
 144     { "mtime",                mtime_decoder,            0  },
 145     { "path",                 path_decoder,             0  },
 146     { "size",                 size_decoder,             0  },
 147     { "uid",                  uid_decoder,              0  },
 148 #if 0
 149     { "uname",                uname_decoder,            0  },
 150 #endif
 151
 152     /* Sparse file handling */
 153     { "GNU.sparse.name",      sparse_path_decoder,      XHDR_PROTECTED },
 154     { "GNU.sparse.major",     sparse_major_decoder,     XHDR_PROTECTED },
 155     { "GNU.sparse.minor",     sparse_minor_decoder,     XHDR_PROTECTED },
 156     { "GNU.sparse.realsize",  sparse_size_decoder,      XHDR_PROTECTED },
 157     { "GNU.sparse.numblocks", sparse_numblocks_decoder, XHDR_PROTECTED },
 158
 159     { "GNU.sparse.size",      sparse_size_decoder,      XHDR_PROTECTED },
 160     /* tar 1.14 - 1.15.1 keywords. Multiple instances of these appeared in 'x'
 161        headers, and each of them was meaningful. It confilcted with POSIX specs,
 162        which requires that "when extended header records conflict, the last one
 163        given in the header shall take precedence." */
 164     { "GNU.sparse.offset",    sparse_offset_decoder,    XHDR_PROTECTED },
 165     { "GNU.sparse.numbytes",  sparse_numbytes_decoder,  XHDR_PROTECTED },
 166     /* tar 1.15.90 keyword, introduced to remove the above-mentioned conflict. */
 167     { "GNU.sparse.map",       sparse_map_decoder,       0 },
 168
 169     { "GNU.dumpdir",          dumpdir_decoder,          XHDR_PROTECTED },
 170
 171     { NULL,                   NULL,                     0 }
 172 };
 173 /* *INDENT-ON* */
 174
 175 /* List of keyword/value pairs decoded from the last 'g' type header */
 176 static GSList *global_header_override_list = NULL;
 177
 178 /* --------------------------------------------------------------------------------------------- */
 179 /*** file scope functions ************************************************************************/
 180 /* --------------------------------------------------------------------------------------------- */
 181
 182 static struct xhdr_tab *
 183 locate_handler (const char *keyword)
 184 {
 185     struct xhdr_tab *p;
 186
 187     for (p = xhdr_tab; p->keyword != NULL; p++)
 188         if (strcmp (p->keyword, keyword) == 0)
 189             return p;
 190
 191     return NULL;
 192 }
 193
 194 /* --------------------------------------------------------------------------------------------- */
 195
 196 static gboolean
 197 keyword_item_run (gpointer data, gpointer user_data)
 198 {
 199     struct keyword_item *kp = (struct keyword_item *) data;
 200     struct tar_stat_info *st = (struct tar_stat_info *) user_data;
 201     struct xhdr_tab const *t;
 202
 203     t = locate_handler (kp->pattern);
 204     if (t != NULL)
 205         return t->decoder (st, t->keyword, kp->value, strlen (kp->value));
 206
 207     return TRUE;                /* FIXME */
 208 }
 209
 210 /* --------------------------------------------------------------------------------------------- */
 211
 212 static void
 213 keyword_item_free (gpointer data)
 214 {
 215     struct keyword_item *kp = (struct keyword_item *) data;
 216
 217     g_free (kp->pattern);
 218     g_free (kp->value);
 219     g_free (kp);
 220 }
 221
 222 /* --------------------------------------------------------------------------------------------- */
 223
 224 static void
 225 xheader_list_append (GSList **root, const char *kw, const char *value)
 226 {
 227     struct keyword_item *kp;
 228
 229     kp = g_new (struct keyword_item, 1);
 230     kp->pattern = g_strdup (kw);
 231     kp->value = g_strdup (value);
 232     *root = g_slist_prepend (*root, kp);
 233 }
 234
 235 /* --------------------------------------------------------------------------------------------- */
 236
 237 static inline void
 238 xheader_list_destroy (GSList **root)
 239 {
 240     g_slist_free_full (*root, keyword_item_free);
 241     *root = NULL;
 242 }
 243
 244 /* --------------------------------------------------------------------------------------------- */
 245
 246 static inline void
 247 run_override_list (GSList *kp, struct tar_stat_info *st)
 248 {
 249     g_slist_foreach (kp, (GFunc) keyword_item_run, st);
 250 }
 251
 252 /* --------------------------------------------------------------------------------------------- */
 253
 254 static struct timespec
 255 decode_timespec (const char *arg, char **arg_lim, gboolean parse_fraction)
 256 {
 257     int ns = -1;
 258     gboolean overflow;
 259     time_t s;
 260     char const *p = *arg_lim;
 261     struct timespec r;
 262
 263     s = stoint (arg, arg_lim, &overflow, TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t));
 264
 265     if (p != arg)
 266     {
 267         ns = 0;
 268
 269         if (parse_fraction && *p == '.')
 270         {
 271             int digits = 0;
 272             gboolean trailing_nonzero = FALSE;
 273
 274             while (isdigit (*++p))
 275                 if (digits < LOG10_BILLION)
 276                 {
 277                     digits++;
 278                     ns = 10 * ns + (*p - '0');
 279                 }
 280                 else if (*p != '0')
 281                     trailing_nonzero = TRUE;
 282
 283             *arg_lim = (char *) p;
 284
 285             while (digits < LOG10_BILLION)
 286             {
 287                 digits++;
 288                 ns *= 10;
 289             }
 290
 291             if (*arg == '-')
 292             {
 293                 /* Convert "-1.10000000000001" to s == -2, ns == 89999999.
 294                    I.e., truncate time stamps towards minus infinity while
 295                    converting them to internal form.  */
 296                 if (trailing_nonzero)
 297                     ns++;
 298                 if (ns != 0)
 299                     ns = ckd_sub (&s, s, 1) ? -1 : BILLION - ns;
 300             }
 301         }
 302
 303         if (overflow)
 304             ns = -1;
 305     }
 306
 307     r.tv_sec = s;
 308     r.tv_nsec = ns;
 309     return r;
 310 }
 311
 312 /* --------------------------------------------------------------------------------------------- */
 313
 314 static gboolean
 315 decode_time (struct timespec *ts, const char *arg, const char *keyword)
 316 {
 317     char *arg_lim;
 318     struct timespec t;
 319
 320     (void) keyword;
 321
 322     t = decode_timespec (arg, &arg_lim, TRUE);
 323
 324     if (t.tv_nsec < 0)
 325         /* Malformed extended header */
 326         return FALSE;
 327
 328     if (*arg_lim != '\0')
 329         /* Malformed extended header */
 330         return FALSE;
 331
 332     *ts = t;
 333
 334     return TRUE;
 335 }
 336
 337 /* --------------------------------------------------------------------------------------------- */
 338
 339 static gboolean
 340 decode_signed_num (intmax_t *num, const char *arg, intmax_t minval, uintmax_t maxval,
 341                    const char *keyword)
 342 {
 343     char *arg_lim;
 344     gboolean overflow;
 345     intmax_t u;
 346
 347     (void) keyword;
 348
 349     u = stoint (arg, &arg_lim, &overflow, minval, maxval);
 350
 351     if (arg_lim == arg || *arg_lim != '\0')
 352         return FALSE;           /* malformed extended header */
 353
 354     if (overflow)
 355         return FALSE;           /* out of range */
 356
 357     *num = u;
 358     return TRUE;
 359 }
 360
 361 /* --------------------------------------------------------------------------------------------- */
 362
 363 static gboolean
 364 decode_num (uintmax_t *num, const char *arg, uintmax_t maxval, const char *keyword)
 365 {
 366     intmax_t i;
 367
 368     if (!decode_signed_num (&i, arg, 0, maxval, keyword))
 369         return FALSE;
 370
 371     *num = i;
 372     return TRUE;
 373 }
 374
 375 /* --------------------------------------------------------------------------------------------- */
 376
 377 static gboolean
 378 raw_path_decoder (struct tar_stat_info *st, const char *arg)
 379 {
 380     if (*arg != '\0')
 381     {
 382         tar_assign_string_dup (&st->orig_file_name, arg);
 383         tar_assign_string_dup (&st->file_name, arg);
 384     }
 385
 386     return TRUE;
 387 }
 388
 389 /* --------------------------------------------------------------------------------------------- */
 390
 391 static gboolean
 392 dummy_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 393 {
 394     (void) st;
 395     (void) keyword;
 396     (void) arg;
 397     (void) size;
 398
 399     return TRUE;
 400 }
 401
 402 /* --------------------------------------------------------------------------------------------- */
 403
 404 static gboolean
 405 atime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 406 {
 407     struct timespec ts;
 408
 409     (void) size;
 410
 411     if (!decode_time (&ts, arg, keyword))
 412         return FALSE;
 413
 414     st->atime = ts;
 415     return TRUE;
 416 }
 417
 418 /* --------------------------------------------------------------------------------------------- */
 419
 420 static gboolean
 421 gid_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 422 {
 423     intmax_t u;
 424
 425     (void) size;
 426
 427     if (!decode_signed_num (&u, arg, TYPE_MINIMUM (gid_t), TYPE_MINIMUM (gid_t), keyword))
 428         return FALSE;
 429
 430     st->stat.st_gid = u;
 431     return TRUE;
 432 }
 433
 434 /* --------------------------------------------------------------------------------------------- */
 435
 436 #if 0
 437 static gboolean
 438 gname_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 439 {
 440     (void) keyword;
 441     (void) size;
 442
 443     tar_assign_string_dup (&st->gname, arg);
 444     return TRUE;
 445 }
 446 #endif
 447
 448 /* --------------------------------------------------------------------------------------------- */
 449
 450 static gboolean
 451 linkpath_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 452 {
 453     (void) keyword;
 454     (void) size;
 455
 456     tar_assign_string_dup (&st->link_name, arg);
 457     return TRUE;
 458 }
 459
 460 /* --------------------------------------------------------------------------------------------- */
 461
 462 static gboolean
 463 ctime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 464 {
 465     struct timespec ts;
 466
 467     (void) size;
 468
 469     if (!decode_time (&ts, arg, keyword))
 470         return FALSE;
 471
 472     st->ctime = ts;
 473     return TRUE;
 474 }
 475
 476 /* --------------------------------------------------------------------------------------------- */
 477
 478 static gboolean
 479 mtime_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 480 {
 481     struct timespec ts;
 482
 483     (void) size;
 484
 485     if (!decode_time (&ts, arg, keyword))
 486         return FALSE;
 487
 488     st->mtime = ts;
 489     return TRUE;
 490 }
 491
 492 /* --------------------------------------------------------------------------------------------- */
 493
 494 static gboolean
 495 path_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 496 {
 497     (void) keyword;
 498     (void) size;
 499
 500     if (!st->sparse_name_done)
 501         return raw_path_decoder (st, arg);
 502
 503     return TRUE;                /* FIXME */
 504 }
 505
 506 /* --------------------------------------------------------------------------------------------- */
 507
 508 static gboolean
 509 size_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 510 {
 511     uintmax_t u;
 512
 513     (void) size;
 514
 515     if (!decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
 516         return FALSE;
 517
 518     st->stat.st_size = u;
 519     return TRUE;
 520 }
 521
 522 /* --------------------------------------------------------------------------------------------- */
 523
 524 static gboolean
 525 uid_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 526 {
 527     intmax_t u;
 528
 529     (void) size;
 530
 531     if (!decode_signed_num (&u, arg, TYPE_MINIMUM (uid_t), TYPE_MAXIMUM (uid_t), keyword))
 532         return FALSE;
 533
 534     st->stat.st_uid = u;
 535     return TRUE;
 536 }
 537
 538 /* --------------------------------------------------------------------------------------------- */
 539
 540 #if 0
 541 static gboolean
 542 uname_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 543 {
 544     (void) keyword;
 545     (void) size;
 546
 547     tar_assign_string_dup (&st->uname, arg);
 548     return TRUE;
 549 }
 550 #endif
 551
 552 /* --------------------------------------------------------------------------------------------- */
 553
 554 static gboolean
 555 dumpdir_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 556 {
 557     (void) keyword;
 558
 559 #if GLIB_CHECK_VERSION (2, 68, 0)
 560     st->dumpdir = g_memdup2 (arg, size);
 561 #else
 562     st->dumpdir = g_memdup (arg, size);
 563 #endif
 564     return TRUE;
 565 }
 566
 567 /* --------------------------------------------------------------------------------------------- */
 568
 569 /**
 570  * Decodes a single extended header record, advancing @ptr to the next record.
 571  *
 572  * @param p pointer to extended header record
 573  * @param st stat info
 574  *
 575  * @return decode_record_ok or decode_record_finish on success, decode_record_fail otherwize
 576  */
 577 static enum decode_record_status
 578 decode_record (struct xheader *xhdr, char **ptr,
 579                gboolean (*handler) (void *data, const char *keyword, const char *value,
 580                                     size_t size), void *data)
 581 {
 582     char *start = *ptr;
 583     char *p = start;
 584     idx_t len;
 585     char *len_lim;
 586     const char *keyword;
 587     char *nextp;
 588     idx_t len_max;
 589     gboolean ret;
 590
 591     len_max = xhdr->buffer + xhdr->size - start;
 592
 593     while (*p == ' ' || *p == '\t')
 594         p++;
 595
 596     len = stoint (p, &len_lim, NULL, 0, IDX_MAX);
 597
 598     if (len_lim == p)
 599         /* Is the length missing? */
 600         return (*p != '\0' ? decode_record_fail : decode_record_finish);
 601
 602     if (len_max < len)
 603         return decode_record_fail;
 604
 605     nextp = start + len;
 606
 607     for (p = len_lim; *p == ' ' || *p == '\t'; p++)
 608         ;
 609
 610     if (p == len_lim)
 611         return decode_record_fail;
 612
 613     keyword = p;
 614     p = strchr (p, '=');
 615     if (!(p != NULL && p < nextp))
 616         return decode_record_fail;
 617
 618     if (nextp[-1] != '\n')
 619         return decode_record_fail;
 620
 621     *p = nextp[-1] = '\0';
 622     ret = handler (data, keyword, p + 1, nextp - p - 2);        /* '=' + trailing '\n' */
 623     *p = '=';
 624     nextp[-1] = '\n';
 625     *ptr = nextp;
 626
 627     return (ret ? decode_record_ok : decode_record_fail);
 628 }
 629
 630 /* --------------------------------------------------------------------------------------------- */
 631
 632 static gboolean
 633 decg (void *data, const char *keyword, const char *value, size_t size)
 634 {
 635     GSList **kwl = (GSList **) data;
 636     struct xhdr_tab const *tab;
 637
 638     (void) size;
 639
 640     tab = locate_handler (keyword);
 641     if (tab != NULL && (tab->flags & XHDR_GLOBAL) != 0)
 642     {
 643         if (!tab->decoder (data, keyword, value, size))
 644             return FALSE;
 645     }
 646     else
 647         xheader_list_append (kwl, keyword, value);
 648
 649     return TRUE;
 650 }
 651
 652 /* --------------------------------------------------------------------------------------------- */
 653
 654 static gboolean
 655 decx (void *data, const char *keyword, const char *value, size_t size)
 656 {
 657     struct keyword_item kp = {
 658         .pattern = (char *) keyword,
 659         .value = (char *) value
 660     };
 661
 662     (void) size;
 663
 664     return keyword_item_run (&kp, data);
 665 }
 666
 667 /* --------------------------------------------------------------------------------------------- */
 668
 669 static gboolean
 670 sparse_path_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 671 {
 672     (void) keyword;
 673     (void) size;
 674
 675     st->sparse_name_done = TRUE;
 676     return raw_path_decoder (st, arg);
 677 }
 678
 679 /* --------------------------------------------------------------------------------------------- */
 680
 681 static gboolean
 682 sparse_major_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 683 {
 684     uintmax_t u;
 685
 686     (void) size;
 687
 688     if (!decode_num (&u, arg, INTMAX_MAX, keyword))
 689         return FALSE;
 690
 691     st->sparse_major = u;
 692     return TRUE;
 693 }
 694
 695 /* --------------------------------------------------------------------------------------------- */
 696
 697 static gboolean
 698 sparse_minor_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 699 {
 700     uintmax_t u;
 701
 702     (void) size;
 703
 704     if (!decode_num (&u, arg, INTMAX_MAX, keyword))
 705         return FALSE;
 706
 707     st->sparse_minor = u;
 708     return TRUE;
 709 }
 710
 711 /* --------------------------------------------------------------------------------------------- */
 712
 713 static gboolean
 714 sparse_size_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 715 {
 716     uintmax_t u;
 717
 718     (void) size;
 719
 720     if (!decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
 721         return FALSE;
 722
 723     st->real_size_set = TRUE;
 724     st->real_size = u;
 725     return TRUE;
 726 }
 727
 728 /* --------------------------------------------------------------------------------------------- */
 729
 730 static gboolean
 731 sparse_numblocks_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 732                           size_t size)
 733 {
 734     uintmax_t u;
 735
 736     (void) size;
 737
 738     if (!decode_num (&u, arg, SIZE_MAX, keyword))
 739         return FALSE;
 740
 741     if (st->sparse_map == NULL)
 742         st->sparse_map = g_array_sized_new (FALSE, FALSE, sizeof (struct sp_array), u);
 743     else
 744         g_array_set_size (st->sparse_map, u);
 745
 746     return TRUE;
 747 }
 748
 749 /* --------------------------------------------------------------------------------------------- */
 750
 751 static gboolean
 752 sparse_offset_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 753 {
 754     uintmax_t u;
 755     struct sp_array *s;
 756
 757     (void) size;
 758
 759     if (!decode_num (&u, arg, TYPE_MAXIMUM (off_t), keyword))
 760         return FALSE;
 761
 762     s = &g_array_index (st->sparse_map, struct sp_array, st->sparse_map->len - 1);
 763     s->offset = u;
 764     return TRUE;
 765 }
 766
 767 /* --------------------------------------------------------------------------------------------- */
 768
 769 static gboolean
 770 sparse_numbytes_decoder (struct tar_stat_info *st, const char *keyword, const char *arg,
 771                          size_t size)
 772 {
 773     uintmax_t u;
 774     struct sp_array s;
 775
 776     (void) size;
 777
 778     if (!decode_num (&u, arg, SIZE_MAX, keyword))
 779         return FALSE;
 780
 781     s.offset = 0;
 782     s.numbytes = u;
 783     g_array_append_val (st->sparse_map, s);
 784     return TRUE;
 785 }
 786
 787 /* --------------------------------------------------------------------------------------------- */
 788
 789 static gboolean
 790 sparse_map_decoder (struct tar_stat_info *st, const char *keyword, const char *arg, size_t size)
 791 {
 792     gboolean offset = TRUE;
 793     struct sp_array e;
 794
 795     (void) keyword;
 796     (void) size;
 797
 798     if (st->sparse_map != NULL)
 799         g_array_set_size (st->sparse_map, 0);
 800
 801     while (TRUE)
 802     {
 803         off_t u;
 804         char *delim;
 805         gboolean overflow;
 806
 807         u = stoint (arg, &delim, &overflow, 0, TYPE_MAXIMUM (off_t));
 808
 809         if (delim == arg)
 810         {
 811             /* malformed extended header */
 812             return FALSE;
 813         }
 814
 815         if (offset)
 816         {
 817             e.offset = u;
 818             if (overflow)
 819             {
 820                 /* out of range */
 821                 return FALSE;
 822             }
 823         }
 824         else
 825         {
 826             e.numbytes = u;
 827             if (overflow)
 828             {
 829                 /* out of range */
 830                 return FALSE;
 831             }
 832
 833             g_array_append_val (st->sparse_map, e);
 834         }
 835
 836         offset = !offset;
 837
 838         if (*delim == '\0')
 839             break;
 840         if (*delim != ',')
 841         {
 842             /* malformed extended header */
 843             return FALSE;
 844         }
 845
 846         arg = delim + 1;
 847     }
 848
 849     if (!offset)
 850     {
 851         /* malformed extended header */
 852         return FALSE;
 853     }
 854
 855     return TRUE;
 856 }
 857
 858 /* --------------------------------------------------------------------------------------------- */
 859 /*** public functions ****************************************************************************/
 860 /* --------------------------------------------------------------------------------------------- */
 861
 862 /**
 863  * Decodes an extended header.
 864  *
 865  * @param st stat info
 866  *
 867  * @return TRUE on success, FALSE otherwize
 868  */
 869 gboolean
 870 tar_xheader_decode (struct tar_stat_info *st)
 871 {
 872     char *p;
 873     enum decode_record_status status;
 874
 875     run_override_list (global_header_override_list, st);
 876
 877     p = st->xhdr.buffer + BLOCKSIZE;
 878
 879     while ((status = decode_record (&st->xhdr, &p, decx, st)) == decode_record_ok)
 880         ;
 881
 882     if (status == decode_record_fail)
 883         return FALSE;
 884
 885     /* The archived (effective) file size is always set directly in tar header
 886        field, possibly overridden by "size" extended header - in both cases,
 887        result is now decoded in st->stat.st_size */
 888     st->archive_file_size = st->stat.st_size;
 889
 890     /* The real file size (given by stat()) may be redefined for sparse
 891        files in "GNU.sparse.realsize" extended header */
 892     if (st->real_size_set)
 893         st->stat.st_size = st->real_size;
 894
 895     return TRUE;
 896 }
 897
 898 /* --------------------------------------------------------------------------------------------- */
 899
 900 gboolean
 901 tar_xheader_read (tar_super_t *archive, struct xheader *xhdr, union block *p, off_t size)
 902 {
 903     size_t j = 0;
 904     size_t size_plus_1;
 905
 906     size = MAX (0, size);
 907     if (ckd_add (&size_plus_1, size, BLOCKSIZE + 1))
 908         return FALSE;
 909     size = size_plus_1 - 1;
 910     xhdr->size = size;
 911     xhdr->buffer = g_malloc (size_plus_1);
 912     xhdr->buffer[size] = '\0';
 913
 914     do
 915     {
 916         size_t len;
 917
 918         if (p == NULL)
 919             return FALSE;       /* Unexpected EOF in archive */
 920
 921         len = MIN (size, BLOCKSIZE);
 922
 923         memcpy (xhdr->buffer + j, p->buffer, len);
 924         tar_set_next_block_after (p);
 925         p = tar_find_next_block (archive);
 926
 927         j += len;
 928         size -= len;
 929     }
 930     while (size > 0);
 931
 932     return TRUE;
 933 }
 934
 935 /* --------------------------------------------------------------------------------------------- */
 936
 937 gboolean
 938 tar_xheader_decode_global (struct xheader *xhdr)
 939 {
 940     char *p;
 941     gboolean ret;
 942
 943     p = xhdr->buffer + BLOCKSIZE;
 944
 945     xheader_list_destroy (&global_header_override_list);
 946
 947     while ((ret = decode_record (xhdr, &p, decg, &global_header_override_list)) == decode_record_ok)
 948         ;
 949
 950     return (ret == decode_record_finish);
 951 }
 952
 953 /* --------------------------------------------------------------------------------------------- */
 954
 955 void
 956 tar_xheader_destroy (struct xheader *xhdr)
 957 {
 958     MC_PTR_FREE (xhdr->buffer);
 959     xhdr->size = 0;
 960 }
 961
 962 /* --------------------------------------------------------------------------------------------- */