contrib/libarchive/libarchive/archive_read_support_format_xar.c

   1 /*-
   2  * Copyright (c) 2009 Michihiro NAKAJIMA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "archive_platform.h"
  26 __FBSDID("$FreeBSD$");
  27
  28 #ifdef HAVE_ERRNO_H
  29 #include <errno.h>
  30 #endif
  31 #include <stdio.h>
  32 #ifdef HAVE_STDLIB_H
  33 #include <stdlib.h>
  34 #endif
  35 #if HAVE_LIBXML_XMLREADER_H
  36 #include <libxml/xmlreader.h>
  37 #elif HAVE_BSDXML_H
  38 #include <bsdxml.h>
  39 #elif HAVE_EXPAT_H
  40 #include <expat.h>
  41 #endif
  42 #ifdef HAVE_BZLIB_H
  43 #include <bzlib.h>
  44 #endif
  45 #if HAVE_LZMA_H
  46 #include <lzma.h>
  47 #elif HAVE_LZMADEC_H
  48 #include <lzmadec.h>
  49 #endif
  50 #ifdef HAVE_ZLIB_H
  51 #include <zlib.h>
  52 #endif
  53
  54 #include "archive.h"
  55 #include "archive_endian.h"
  56 #include "archive_entry.h"
  57 #include "archive_hash.h"
  58 #include "archive_private.h"
  59 #include "archive_read_private.h"
  60
  61 #if (!defined(HAVE_LIBXML_XMLREADER_H) && \
  62      !defined(HAVE_BSDXML_H) && !defined(HAVE_EXPAT_H)) ||\
  63         !defined(HAVE_ZLIB_H) || \
  64         !defined(ARCHIVE_HAS_MD5) || !defined(ARCHIVE_HAS_SHA1)
  65 /*
  66  * xar needs several external libraries.
  67  *   o libxml2 or expat --- XML parser
  68  *   o openssl or MD5/SHA1 hash function
  69  *   o zlib
  70  *   o bzlib2 (option)
  71  *   o liblzma (option)
  72  */
  73 int
  74 archive_read_support_format_xar(struct archive *_a)
  75 {
  76         struct archive_read *a = (struct archive_read *)_a;
  77
  78         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
  79             "Xar not supported on this platform");
  80         return (ARCHIVE_WARN);
  81 }
  82
  83 #else   /* Support xar format */
  84
  85 //#define DEBUG 1
  86 //#define DEBUG_PRINT_TOC 1
  87 #if DEBUG_PRINT_TOC
  88 #define PRINT_TOC(d, outbytes)  do {                            \
  89         unsigned char *x = (unsigned char *)(uintptr_t)d;       \
  90         unsigned char c = x[outbytes-1];                        \
  91         x[outbytes - 1] = 0;                                    \
  92         fprintf(stderr, "%s", x);                               \
  93         fprintf(stderr, "%c", c);                               \
  94         x[outbytes - 1] = c;                                    \
  95 } while (0)
  96 #else
  97 #define PRINT_TOC(d, outbytes)
  98 #endif
  99
 100 #define HEADER_MAGIC    0x78617221
 101 #define HEADER_SIZE     28
 102 #define HEADER_VERSION  1
 103 #define CKSUM_NONE      0
 104 #define CKSUM_SHA1      1
 105 #define CKSUM_MD5       2
 106
 107 #define MD5_SIZE        16
 108 #define SHA1_SIZE       20
 109 #define MAX_SUM_SIZE    20
 110
 111 enum enctype {
 112         NONE,
 113         GZIP,
 114         BZIP2,
 115         LZMA,
 116         XZ,
 117 };
 118
 119 struct chksumval {
 120         int                      alg;
 121         size_t                   len;
 122         unsigned char            val[MAX_SUM_SIZE];
 123 };
 124
 125 struct chksumwork {
 126         int                      alg;
 127 #ifdef ARCHIVE_HAS_MD5
 128         archive_md5_ctx          md5ctx;
 129 #endif
 130 #ifdef ARCHIVE_HAS_SHA1
 131         archive_sha1_ctx         sha1ctx;
 132 #endif
 133 };
 134
 135 struct xattr {
 136         struct xattr            *next;
 137         struct archive_string    name;
 138         uint64_t                 id;
 139         uint64_t                 length;
 140         uint64_t                 offset;
 141         uint64_t                 size;
 142         enum enctype             encoding;
 143         struct chksumval         a_sum;
 144         struct chksumval         e_sum;
 145         struct archive_string    fstype;
 146 };
 147
 148 struct xar_file {
 149         struct xar_file         *next;
 150         struct xar_file         *hdnext;
 151         struct xar_file         *parent;
 152         int                      subdirs;
 153
 154         unsigned int             has;
 155 #define HAS_DATA                0x00001
 156 #define HAS_PATHNAME            0x00002
 157 #define HAS_SYMLINK             0x00004
 158 #define HAS_TIME                0x00008
 159 #define HAS_UID                 0x00010
 160 #define HAS_GID                 0x00020
 161 #define HAS_MODE                0x00040
 162 #define HAS_TYPE                0x00080
 163 #define HAS_DEV                 0x00100
 164 #define HAS_DEVMAJOR            0x00200
 165 #define HAS_DEVMINOR            0x00400
 166 #define HAS_INO                 0x00800
 167 #define HAS_FFLAGS              0x01000
 168 #define HAS_XATTR               0x02000
 169 #define HAS_ACL                 0x04000
 170
 171         uint64_t                 id;
 172         uint64_t                 length;
 173         uint64_t                 offset;
 174         uint64_t                 size;
 175         enum enctype             encoding;
 176         struct chksumval         a_sum;
 177         struct chksumval         e_sum;
 178         struct archive_string    pathname;
 179         struct archive_string    symlink;
 180         time_t                   ctime;
 181         time_t                   mtime;
 182         time_t                   atime;
 183         struct archive_string    uname;
 184         uid_t                    uid;
 185         struct archive_string    gname;
 186         gid_t                    gid;
 187         mode_t                   mode;
 188         dev_t                    dev;
 189         dev_t                    devmajor;
 190         dev_t                    devminor;
 191         int64_t                  ino64;
 192         struct archive_string    fflags_text;
 193         unsigned int             link;
 194         unsigned int             nlink;
 195         struct archive_string    hardlink;
 196         struct xattr            *xattr_list;
 197 };
 198
 199 struct hdlink {
 200         struct hdlink            *next;
 201
 202         unsigned int             id;
 203         int                      cnt;
 204         struct xar_file          *files;
 205 };
 206
 207 struct heap_queue {
 208         struct xar_file         **files;
 209         int                      allocated;
 210         int                      used;
 211 };
 212
 213 enum xmlstatus {
 214         INIT,
 215         XAR,
 216         TOC,
 217         TOC_CREATION_TIME,
 218         TOC_CHECKSUM,
 219         TOC_CHECKSUM_OFFSET,
 220         TOC_CHECKSUM_SIZE,
 221         TOC_FILE,
 222         FILE_DATA,
 223         FILE_DATA_LENGTH,
 224         FILE_DATA_OFFSET,
 225         FILE_DATA_SIZE,
 226         FILE_DATA_ENCODING,
 227         FILE_DATA_A_CHECKSUM,
 228         FILE_DATA_E_CHECKSUM,
 229         FILE_DATA_CONTENT,
 230         FILE_EA,
 231         FILE_EA_LENGTH,
 232         FILE_EA_OFFSET,
 233         FILE_EA_SIZE,
 234         FILE_EA_ENCODING,
 235         FILE_EA_A_CHECKSUM,
 236         FILE_EA_E_CHECKSUM,
 237         FILE_EA_NAME,
 238         FILE_EA_FSTYPE,
 239         FILE_CTIME,
 240         FILE_MTIME,
 241         FILE_ATIME,
 242         FILE_GROUP,
 243         FILE_GID,
 244         FILE_USER,
 245         FILE_UID,
 246         FILE_MODE,
 247         FILE_DEVICE,
 248         FILE_DEVICE_MAJOR,
 249         FILE_DEVICE_MINOR,
 250         FILE_DEVICENO,
 251         FILE_INODE,
 252         FILE_LINK,
 253         FILE_TYPE,
 254         FILE_NAME,
 255         FILE_ACL,
 256         FILE_ACL_DEFAULT,
 257         FILE_ACL_ACCESS,
 258         FILE_ACL_APPLEEXTENDED,
 259         /* BSD file flags. */
 260         FILE_FLAGS,
 261         FILE_FLAGS_USER_NODUMP,
 262         FILE_FLAGS_USER_IMMUTABLE,
 263         FILE_FLAGS_USER_APPEND,
 264         FILE_FLAGS_USER_OPAQUE,
 265         FILE_FLAGS_USER_NOUNLINK,
 266         FILE_FLAGS_SYS_ARCHIVED,
 267         FILE_FLAGS_SYS_IMMUTABLE,
 268         FILE_FLAGS_SYS_APPEND,
 269         FILE_FLAGS_SYS_NOUNLINK,
 270         FILE_FLAGS_SYS_SNAPSHOT,
 271         /* Linux file flags. */
 272         FILE_EXT2,
 273         FILE_EXT2_SecureDeletion,
 274         FILE_EXT2_Undelete,
 275         FILE_EXT2_Compress,
 276         FILE_EXT2_Synchronous,
 277         FILE_EXT2_Immutable,
 278         FILE_EXT2_AppendOnly,
 279         FILE_EXT2_NoDump,
 280         FILE_EXT2_NoAtime,
 281         FILE_EXT2_CompDirty,
 282         FILE_EXT2_CompBlock,
 283         FILE_EXT2_NoCompBlock,
 284         FILE_EXT2_CompError,
 285         FILE_EXT2_BTree,
 286         FILE_EXT2_HashIndexed,
 287         FILE_EXT2_iMagic,
 288         FILE_EXT2_Journaled,
 289         FILE_EXT2_NoTail,
 290         FILE_EXT2_DirSync,
 291         FILE_EXT2_TopDir,
 292         FILE_EXT2_Reserved,
 293         UNKNOWN,
 294 };
 295
 296 struct unknown_tag {
 297         struct unknown_tag      *next;
 298         struct archive_string    name;
 299 };
 300
 301 struct xar {
 302         uint64_t                 offset; /* Current position in the file. */
 303         int64_t                  total;
 304         uint64_t                 h_base;
 305         int                      end_of_file;
 306         unsigned char            buff[1024*32];
 307
 308         enum xmlstatus           xmlsts;
 309         enum xmlstatus           xmlsts_unknown;
 310         struct unknown_tag      *unknowntags;
 311         int                      base64text;
 312
 313         /*
 314          * TOC
 315          */
 316         uint64_t                 toc_remaining;
 317         uint64_t                 toc_total;
 318         uint64_t                 toc_chksum_offset;
 319         uint64_t                 toc_chksum_size;
 320
 321         /*
 322          * For Decoding data.
 323          */
 324         enum enctype             rd_encoding;
 325         z_stream                 stream;
 326         int                      stream_valid;
 327 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 328         bz_stream                bzstream;
 329         int                      bzstream_valid;
 330 #endif
 331 #if HAVE_LZMA_H && HAVE_LIBLZMA
 332         lzma_stream              lzstream;
 333         int                      lzstream_valid;
 334 #elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
 335         lzmadec_stream           lzstream;
 336         int                      lzstream_valid;
 337 #endif
 338         /*
 339          * For Checksum data.
 340          */
 341         struct chksumwork        a_sumwrk;
 342         struct chksumwork        e_sumwrk;
 343
 344         struct xar_file         *file;  /* current reading file. */
 345         struct xattr            *xattr; /* current reading extended attribute. */
 346         struct heap_queue        file_queue;
 347         struct xar_file         *hdlink_orgs;
 348         struct hdlink           *hdlink_list;
 349
 350         int                      entry_init;
 351         uint64_t                 entry_total;
 352         uint64_t                 entry_remaining;
 353         uint64_t                 entry_size;
 354         enum enctype             entry_encoding;
 355         struct chksumval         entry_a_sum;
 356         struct chksumval         entry_e_sum;
 357 };
 358
 359 struct xmlattr {
 360         struct xmlattr  *next;
 361         char            *name;
 362         char            *value;
 363 };
 364
 365 struct xmlattr_list {
 366         struct xmlattr  *first;
 367         struct xmlattr  **last;
 368 };
 369
 370 static int      xar_bid(struct archive_read *);
 371 static int      xar_read_header(struct archive_read *,
 372                     struct archive_entry *);
 373 static int      xar_read_data(struct archive_read *,
 374                     const void **, size_t *, off_t *);
 375 static int      xar_read_data_skip(struct archive_read *);
 376 static int      xar_cleanup(struct archive_read *);
 377 static int      move_reading_point(struct archive_read *, uint64_t);
 378 static int      rd_contents_init(struct archive_read *,
 379                     enum enctype, int, int);
 380 static int      rd_contents(struct archive_read *, const void **,
 381                     size_t *, size_t *, uint64_t);
 382 static uint64_t atol10(const char *, size_t);
 383 static int64_t  atol8(const char *, size_t);
 384 static size_t   atohex(unsigned char *, size_t, const char *, size_t);
 385 static time_t   parse_time(const char *p, size_t n);
 386 static void     heap_add_entry(struct heap_queue *, struct xar_file *);
 387 static struct xar_file *heap_get_entry(struct heap_queue *);
 388 static void     add_link(struct xar *, struct xar_file *);
 389 static void     checksum_init(struct archive_read *, int, int);
 390 static void     checksum_update(struct archive_read *, const void *,
 391                     size_t, const void *, size_t);
 392 static int      checksum_final(struct archive_read *, const void *,
 393                     size_t, const void *, size_t);
 394 static int      decompression_init(struct archive_read *, enum enctype);
 395 static int      decompress(struct archive_read *, const void **,
 396                     size_t *, const void *, size_t *);
 397 static int      decompression_cleanup(struct archive_read *);
 398 static void     xmlattr_cleanup(struct xmlattr_list *);
 399 static void     file_new(struct xar *, struct xmlattr_list *);
 400 static void     file_free(struct xar_file *);
 401 static void     xattr_new(struct xar *, struct xmlattr_list *);
 402 static void     xattr_free(struct xattr *);
 403 static int      getencoding(struct xmlattr_list *);
 404 static int      getsumalgorithm(struct xmlattr_list *);
 405 static void     unknowntag_start(struct xar *, const char *);
 406 static void     unknowntag_end(struct xar *, const char *);
 407 static void     xml_start(void *, const char *, struct xmlattr_list *);
 408 static void     xml_end(void *, const char *);
 409 static void     xml_data(void *, const char *, int);
 410 static int      xml_parse_file_flags(struct xar *, const char *);
 411 static int      xml_parse_file_ext2(struct xar *, const char *);
 412 #if defined(HAVE_LIBXML_XMLREADER_H)
 413 static int      xml2_xmlattr_setup(struct xmlattr_list *, xmlTextReaderPtr);
 414 static int      xml2_read_cb(void *, char *, int);
 415 static int      xml2_close_cb(void *);
 416 static void     xml2_error_hdr(void *, const char *, xmlParserSeverities,
 417                     xmlTextReaderLocatorPtr);
 418 static int      xml2_read_toc(struct archive_read *);
 419 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
 420 static void     expat_xmlattr_setup(struct xmlattr_list *, const XML_Char **);
 421 static void     expat_start_cb(void *, const XML_Char *, const XML_Char **);
 422 static void     expat_end_cb(void *, const XML_Char *);
 423 static void     expat_data_cb(void *, const XML_Char *, int);
 424 static int      expat_read_toc(struct archive_read *);
 425 #endif
 426
 427 int
 428 archive_read_support_format_xar(struct archive *_a)
 429 {
 430         struct xar *xar;
 431         struct archive_read *a = (struct archive_read *)_a;
 432         int r;
 433
 434         xar = (struct xar *)calloc(1, sizeof(*xar));
 435         if (xar == NULL) {
 436                 archive_set_error(&a->archive, ENOMEM,
 437                     "Can't allocate xar data");
 438                 return (ARCHIVE_FATAL);
 439         }
 440
 441         r = __archive_read_register_format(a,
 442             xar,
 443             "xar",
 444             xar_bid,
 445             NULL,
 446             xar_read_header,
 447             xar_read_data,
 448             xar_read_data_skip,
 449             xar_cleanup);
 450         if (r != ARCHIVE_OK)
 451                 free(xar);
 452         return (r);
 453 }
 454
 455 static int
 456 xar_bid(struct archive_read *a)
 457 {
 458         const unsigned char *b;
 459         int bid;
 460
 461         b = __archive_read_ahead(a, HEADER_SIZE, NULL);
 462         if (b == NULL)
 463                 return (-1);
 464
 465         bid = 0;
 466         /*
 467          * Verify magic code
 468          */
 469         if (archive_be32dec(b) != HEADER_MAGIC)
 470                 return (0);
 471         bid += 32;
 472         /*
 473          * Verify header size
 474          */
 475         if (archive_be16dec(b+4) != HEADER_SIZE)
 476                 return (0);
 477         bid += 16;
 478         /*
 479          * Verify header version
 480          */
 481         if (archive_be16dec(b+6) != HEADER_VERSION)
 482                 return (0);
 483         bid += 16;
 484         /*
 485          * Verify type of checksum
 486          */
 487         switch (archive_be32dec(b+24)) {
 488         case CKSUM_NONE:
 489         case CKSUM_SHA1:
 490         case CKSUM_MD5:
 491                 bid += 32;
 492                 break;
 493         default:
 494                 return (0);
 495         }
 496
 497         return (bid);
 498 }
 499
 500 static int
 501 read_toc(struct archive_read *a)
 502 {
 503         struct xar *xar;
 504         struct xar_file *file;
 505         const unsigned char *b;
 506         uint64_t toc_compressed_size;
 507         uint64_t toc_uncompressed_size;
 508         uint32_t toc_chksum_alg;
 509         ssize_t bytes;
 510         int r;
 511
 512         xar = (struct xar *)(a->format->data);
 513
 514         /*
 515          * Read xar header.
 516          */
 517         b = __archive_read_ahead(a, HEADER_SIZE, &bytes);
 518         if (bytes < 0)
 519                 return ((int)bytes);
 520         if (bytes < HEADER_SIZE) {
 521                 archive_set_error(&a->archive,
 522                     ARCHIVE_ERRNO_FILE_FORMAT,
 523                     "Truncated archive header");
 524                 return (ARCHIVE_FATAL);
 525         }
 526
 527         if (archive_be32dec(b) != HEADER_MAGIC) {
 528                 archive_set_error(&a->archive,
 529                     ARCHIVE_ERRNO_FILE_FORMAT,
 530                     "Invalid header magic");
 531                 return (ARCHIVE_FATAL);
 532         }
 533         if (archive_be16dec(b+6) != HEADER_VERSION) {
 534                 archive_set_error(&a->archive,
 535                     ARCHIVE_ERRNO_FILE_FORMAT,
 536                     "Unsupported header version(%d)",
 537                     archive_be16dec(b+6));
 538                 return (ARCHIVE_FATAL);
 539         }
 540         toc_compressed_size = archive_be64dec(b+8);
 541         xar->toc_remaining = toc_compressed_size;
 542         toc_uncompressed_size = archive_be64dec(b+16);
 543         toc_chksum_alg = archive_be32dec(b+24);
 544         __archive_read_consume(a, HEADER_SIZE);
 545         xar->offset += HEADER_SIZE;
 546         xar->toc_total = 0;
 547
 548         /*
 549          * Read TOC(Table of Contents).
 550          */
 551         /* Initialize reading contents. */
 552         r = move_reading_point(a, HEADER_SIZE);
 553         if (r != ARCHIVE_OK)
 554                 return (r);
 555         r = rd_contents_init(a, GZIP, toc_chksum_alg, CKSUM_NONE);
 556         if (r != ARCHIVE_OK)
 557                 return (r);
 558
 559 #ifdef HAVE_LIBXML_XMLREADER_H
 560         r = xml2_read_toc(a);
 561 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
 562         r = expat_read_toc(a);
 563 #endif
 564         if (r != ARCHIVE_OK)
 565                 return (r);
 566
 567         /* Set 'The HEAP' base. */
 568         xar->h_base = xar->offset;
 569         if (xar->toc_total != toc_uncompressed_size) {
 570                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 571                     "TOC uncompressed size error");
 572                 return (ARCHIVE_FATAL);
 573         }
 574
 575         /*
 576          * Checksum TOC
 577          */
 578         if (toc_chksum_alg != CKSUM_NONE) {
 579                 r = move_reading_point(a, xar->toc_chksum_offset);
 580                 if (r != ARCHIVE_OK)
 581                         return (r);
 582                 b = __archive_read_ahead(a, xar->toc_chksum_size, &bytes);
 583                 if (bytes < 0)
 584                         return ((int)bytes);
 585                 if ((uint64_t)bytes < xar->toc_chksum_size) {
 586                         archive_set_error(&a->archive,
 587                             ARCHIVE_ERRNO_FILE_FORMAT,
 588                             "Truncated archive file");
 589                         return (ARCHIVE_FATAL);
 590                 }
 591                 r = checksum_final(a, b, xar->toc_chksum_size, NULL, 0);
 592                 __archive_read_consume(a, xar->toc_chksum_size);
 593                 xar->offset += xar->toc_chksum_size;
 594                 if (r != ARCHIVE_OK)
 595                         return (ARCHIVE_FATAL);
 596         }
 597
 598         /*
 599          * Connect hardlinked files.
 600          */
 601         for (file = xar->hdlink_orgs; file != NULL; file = file->hdnext) {
 602                 struct hdlink **hdlink;
 603
 604                 for (hdlink = &(xar->hdlink_list); *hdlink != NULL;
 605                     hdlink = &((*hdlink)->next)) {
 606                         if ((*hdlink)->id == file->id) {
 607                                 struct hdlink *hltmp;
 608                                 struct xar_file *f2;
 609                                 int nlink = (*hdlink)->cnt + 1;
 610
 611                                 file->nlink = nlink;
 612                                 for (f2 = (*hdlink)->files; f2 != NULL;
 613                                     f2 = f2->hdnext) {
 614                                         f2->nlink = nlink;
 615                                         archive_string_copy(
 616                                             &(f2->hardlink), &(file->pathname));
 617                                 }
 618                                 /* Remove resolved files from hdlist_list. */
 619                                 hltmp = *hdlink;
 620                                 *hdlink = hltmp->next;
 621                                 free(hltmp);
 622                                 break;
 623                         }
 624                 }
 625         }
 626         a->archive.archive_format = ARCHIVE_FORMAT_XAR;
 627         a->archive.archive_format_name = "xar";
 628
 629         return (ARCHIVE_OK);
 630 }
 631
 632 static int
 633 xar_read_header(struct archive_read *a, struct archive_entry *entry)
 634 {
 635         struct xar *xar;
 636         struct xar_file *file;
 637         struct xattr *xattr;
 638         int r;
 639
 640         xar = (struct xar *)(a->format->data);
 641
 642         if (xar->offset == 0) {
 643                 /* Read TOC. */
 644                 r = read_toc(a);
 645                 if (r != ARCHIVE_OK)
 646                         return (r);
 647         }
 648
 649         for (;;) {
 650                 file = xar->file = heap_get_entry(&(xar->file_queue));
 651                 if (file == NULL) {
 652                         xar->end_of_file = 1;
 653                         return (ARCHIVE_EOF);
 654                 }
 655                 if ((file->mode & AE_IFMT) != AE_IFDIR)
 656                         break;
 657                 if (file->has != (HAS_PATHNAME | HAS_TYPE))
 658                         break;
 659                 /*
 660                  * If a file type is a directory and it does not have
 661                  * any metadata, do not export.
 662                  */
 663                 file_free(file);
 664         }
 665         archive_entry_set_atime(entry, file->atime, 0);
 666         archive_entry_set_ctime(entry, file->ctime, 0);
 667         archive_entry_set_mtime(entry, file->mtime, 0);
 668         archive_entry_set_gid(entry, file->gid);
 669         if (file->gname.length > 0)
 670                 archive_entry_update_gname_utf8(entry, file->gname.s);
 671         archive_entry_set_uid(entry, file->uid);
 672         if (file->uname.length > 0)
 673                 archive_entry_update_uname_utf8(entry, file->uname.s);
 674         archive_entry_set_mode(entry, file->mode);
 675         archive_entry_update_pathname_utf8(entry, file->pathname.s);
 676         if (file->symlink.length > 0)
 677                 archive_entry_update_symlink_utf8(entry, file->symlink.s);
 678         /* Set proper nlink. */
 679         if ((file->mode & AE_IFMT) == AE_IFDIR)
 680                 archive_entry_set_nlink(entry, file->subdirs + 2);
 681         else
 682                 archive_entry_set_nlink(entry, file->nlink);
 683         archive_entry_set_size(entry, file->size);
 684         if (archive_strlen(&(file->hardlink)) > 0)
 685                 archive_entry_update_hardlink_utf8(entry,
 686                         file->hardlink.s);
 687         archive_entry_set_ino64(entry, file->ino64);
 688         if (file->has & HAS_DEV)
 689                 archive_entry_set_dev(entry, file->dev);
 690         if (file->has & HAS_DEVMAJOR)
 691                 archive_entry_set_devmajor(entry, file->devmajor);
 692         if (file->has & HAS_DEVMINOR)
 693                 archive_entry_set_devminor(entry, file->devminor);
 694         if (archive_strlen(&(file->fflags_text)) > 0)
 695                 archive_entry_copy_fflags_text(entry, file->fflags_text.s);
 696
 697         xar->entry_init = 1;
 698         xar->entry_total = 0;
 699         xar->entry_remaining = file->length;
 700         xar->entry_size = file->size;
 701         xar->entry_encoding = file->encoding;
 702         xar->entry_a_sum = file->a_sum;
 703         xar->entry_e_sum = file->e_sum;
 704         /*
 705          * Read extended attributes.
 706          */
 707         r = ARCHIVE_OK;
 708         xattr = file->xattr_list;
 709         while (xattr != NULL) {
 710                 const void *d;
 711                 size_t outbytes, used;
 712
 713                 r = move_reading_point(a, xattr->offset);
 714                 if (r != ARCHIVE_OK)
 715                         break;
 716                 r = rd_contents_init(a, xattr->encoding,
 717                     xattr->a_sum.alg, xattr->e_sum.alg);
 718                 if (r != ARCHIVE_OK)
 719                         break;
 720                 d = NULL;
 721                 r = rd_contents(a, &d, &outbytes, &used, xattr->length);
 722                 if (r != ARCHIVE_OK)
 723                         break;
 724                 if (outbytes != xattr->size) {
 725                         archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
 726                             "Decompressed size error");
 727                         r = ARCHIVE_FATAL;
 728                         break;
 729                 }
 730                 r = checksum_final(a,
 731                     xattr->a_sum.val, xattr->a_sum.len,
 732                     xattr->e_sum.val, xattr->e_sum.len);
 733                 if (r != ARCHIVE_OK)
 734                         break;
 735                 archive_entry_xattr_add_entry(entry,
 736                     xattr->name.s, d, outbytes);
 737                 xattr = xattr->next;
 738         }
 739         if (r != ARCHIVE_OK) {
 740                 file_free(file);
 741                 return (r);
 742         }
 743
 744         if (xar->entry_remaining > 0)
 745                 /* Move reading point to the beginning of current
 746                  * file contents. */
 747                 r = move_reading_point(a, file->offset);
 748         else
 749                 r = ARCHIVE_OK;
 750
 751         file_free(file);
 752         return (r);
 753 }
 754
 755 static int
 756 xar_read_data(struct archive_read *a,
 757     const void **buff, size_t *size, off_t *offset)
 758 {
 759         struct xar *xar;
 760         size_t used;
 761         int r;
 762
 763         xar = (struct xar *)(a->format->data);
 764         if (xar->end_of_file || xar->entry_remaining <= 0) {
 765                 r = ARCHIVE_EOF;
 766                 goto abort_read_data;
 767         }
 768
 769         if (xar->entry_init) {
 770                 r = rd_contents_init(a, xar->entry_encoding,
 771                     xar->entry_a_sum.alg, xar->entry_e_sum.alg);
 772                 if (r != ARCHIVE_OK) {
 773                         xar->entry_remaining = 0;
 774                         return (r);
 775                 }
 776                 xar->entry_init = 0;
 777         }
 778
 779         *buff = NULL;
 780         r = rd_contents(a, buff, size, &used, xar->entry_remaining);
 781         if (r != ARCHIVE_OK)
 782                 goto abort_read_data;
 783
 784         *offset = xar->entry_total;
 785         xar->entry_total += *size;
 786         xar->total += *size;
 787         xar->offset += used;
 788         xar->entry_remaining -= used;
 789         __archive_read_consume(a, used);
 790
 791         if (xar->entry_remaining == 0) {
 792                 if (xar->entry_total != xar->entry_size) {
 793                         archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
 794                             "Decompressed size error");
 795                         r = ARCHIVE_FATAL;
 796                         goto abort_read_data;
 797                 }
 798                 r = checksum_final(a,
 799                     xar->entry_a_sum.val, xar->entry_a_sum.len,
 800                     xar->entry_e_sum.val, xar->entry_e_sum.len);
 801                 if (r != ARCHIVE_OK)
 802                         goto abort_read_data;
 803         }
 804
 805         return (ARCHIVE_OK);
 806 abort_read_data:
 807         *buff = NULL;
 808         *size = 0;
 809         *offset = xar->total;
 810         return (r);
 811 }
 812
 813 static int
 814 xar_read_data_skip(struct archive_read *a)
 815 {
 816         struct xar *xar;
 817         int64_t bytes_skipped;
 818
 819         xar = (struct xar *)(a->format->data);
 820         if (xar->end_of_file)
 821                 return (ARCHIVE_EOF);
 822         bytes_skipped = __archive_read_skip(a, xar->entry_remaining);
 823         if (bytes_skipped < 0)
 824                 return (ARCHIVE_FATAL);
 825         xar->offset += bytes_skipped;
 826         return (ARCHIVE_OK);
 827 }
 828
 829 static int
 830 xar_cleanup(struct archive_read *a)
 831 {
 832         struct xar *xar;
 833         struct hdlink *hdlink;
 834         int i;
 835         int r;
 836
 837         xar = (struct xar *)(a->format->data);
 838         r = decompression_cleanup(a);
 839         hdlink = xar->hdlink_list;
 840         while (hdlink != NULL) {
 841                 struct hdlink *next = hdlink->next;
 842
 843                 free(hdlink);
 844                 hdlink = next;
 845         }
 846         for (i = 0; i < xar->file_queue.used; i++)
 847                 file_free(xar->file_queue.files[i]);
 848         while (xar->unknowntags != NULL) {
 849                 struct unknown_tag *tag;
 850
 851                 tag = xar->unknowntags;
 852                 xar->unknowntags = tag->next;
 853                 archive_string_free(&(tag->name));
 854                 free(tag);
 855         }
 856         free(xar);
 857         a->format->data = NULL;
 858         return (r);
 859 }
 860
 861 static int
 862 move_reading_point(struct archive_read *a, uint64_t offset)
 863 {
 864         struct xar *xar;
 865
 866         xar = (struct xar *)(a->format->data);
 867         if (xar->offset - xar->h_base != offset) {
 868                 /* Seek forward to the start of file contents. */
 869                 int64_t step;
 870
 871                 step = offset - (xar->offset - xar->h_base);
 872                 if (step > 0) {
 873                         step = __archive_read_skip(a, step);
 874                         if (step < 0)
 875                                 return ((int)step);
 876                         xar->offset += step;
 877                 } else {
 878                         archive_set_error(&(a->archive),
 879                             ARCHIVE_ERRNO_MISC,
 880                             "Cannot seek.");
 881                         return (ARCHIVE_FAILED);
 882                 }
 883         }
 884         return (ARCHIVE_OK);
 885 }
 886
 887 static int
 888 rd_contents_init(struct archive_read *a, enum enctype encoding,
 889     int a_sum_alg, int e_sum_alg)
 890 {
 891         int r;
 892
 893         /* Init decompress library. */
 894         if ((r = decompression_init(a, encoding)) != ARCHIVE_OK)
 895                 return (r);
 896         /* Init checksum library. */
 897         checksum_init(a, a_sum_alg, e_sum_alg);
 898         return (ARCHIVE_OK);
 899 }
 900
 901 static int
 902 rd_contents(struct archive_read *a, const void **buff, size_t *size,
 903     size_t *used, uint64_t remaining)
 904 {
 905         const unsigned char *b;
 906         ssize_t bytes;
 907
 908         /* Get whatever bytes are immediately available. */
 909         b = __archive_read_ahead(a, 1, &bytes);
 910         if (bytes < 0)
 911                 return ((int)bytes);
 912         if (bytes == 0) {
 913                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 914                     "Truncated archive file");
 915                 return (ARCHIVE_FATAL);
 916         }
 917         if ((uint64_t)bytes > remaining)
 918                 bytes = (ssize_t)remaining;
 919
 920         /*
 921          * Decompress contents of file.
 922          */
 923         *used = bytes;
 924         if (decompress(a, buff, size, b, used) != ARCHIVE_OK)
 925                 return (ARCHIVE_FATAL);
 926
 927         /*
 928          * Update checksum of a compressed data and a extracted data.
 929          */
 930         checksum_update(a, b, *used, *buff, *size);
 931
 932         return (ARCHIVE_OK);
 933 }
 934
 935 /*
 936  * Note that this implementation does not (and should not!) obey
 937  * locale settings; you cannot simply substitute strtol here, since
 938  * it does obey locale.
 939  */
 940
 941 static uint64_t
 942 atol10(const char *p, size_t char_cnt)
 943 {
 944         uint64_t l;
 945         int digit;
 946
 947         l = 0;
 948         digit = *p - '0';
 949         while (digit >= 0 && digit < 10  && char_cnt-- > 0) {
 950                 l = (l * 10) + digit;
 951                 digit = *++p - '0';
 952         }
 953         return (l);
 954 }
 955
 956 static int64_t
 957 atol8(const char *p, size_t char_cnt)
 958 {
 959         int64_t l;
 960         int digit;
 961
 962         l = 0;
 963         while (char_cnt-- > 0) {
 964                 if (*p >= '0' && *p <= '7')
 965                         digit = *p - '0';
 966                 else
 967                         break;
 968                 p++;
 969                 l <<= 3;
 970                 l |= digit;
 971         }
 972         return (l);
 973 }
 974
 975 static size_t
 976 atohex(unsigned char *b, size_t bsize, const char *p, size_t psize)
 977 {
 978         size_t fbsize = bsize;
 979
 980         while (bsize && psize > 1) {
 981                 unsigned char x;
 982
 983                 if (p[0] >= 'a' && p[0] <= 'z')
 984                         x = (p[0] - 'a' + 0x0a) << 4;
 985                 else if (p[0] >= 'A' && p[0] <= 'Z')
 986                         x = (p[0] - 'A' + 0x0a) << 4;
 987                 else if (p[0] >= '0' && p[0] <= '9')
 988                         x = (p[0] - '0') << 4;
 989                 else
 990                         return (-1);
 991                 if (p[1] >= 'a' && p[1] <= 'z')
 992                         x |= p[1] - 'a' + 0x0a;
 993                 else if (p[1] >= 'A' && p[1] <= 'Z')
 994                         x |= p[1] - 'A' + 0x0a;
 995                 else if (p[1] >= '0' && p[1] <= '9')
 996                         x |= p[1] - '0';
 997                 else
 998                         return (-1);
 999
1000                 *b++ = x;
1001                 bsize--;
1002                 p += 2;
1003                 psize -= 2;
1004         }
1005         return (fbsize - bsize);
1006 }
1007
1008 static time_t
1009 time_from_tm(struct tm *t)
1010 {
1011 #if HAVE_TIMEGM
1012         /* Use platform timegm() if available. */
1013         return (timegm(t));
1014 #else
1015         /* Else use direct calculation using POSIX assumptions. */
1016         /* First, fix up tm_yday based on the year/month/day. */
1017         mktime(t);
1018         /* Then we can compute timegm() from first principles. */
1019         return (t->tm_sec + t->tm_min * 60 + t->tm_hour * 3600
1020             + t->tm_yday * 86400 + (t->tm_year - 70) * 31536000
1021             + ((t->tm_year - 69) / 4) * 86400 -
1022             ((t->tm_year - 1) / 100) * 86400
1023             + ((t->tm_year + 299) / 400) * 86400);
1024 #endif
1025 }
1026
1027 static time_t
1028 parse_time(const char *p, size_t n)
1029 {
1030         struct tm tm;
1031         time_t t = 0;
1032         int64_t data;
1033
1034         memset(&tm, 0, sizeof(tm));
1035         if (n != 20)
1036                 return (t);
1037         data = atol10(p, 4);
1038         if (data < 1900)
1039                 return (t);
1040         tm.tm_year = (int)data - 1900;
1041         p += 4;
1042         if (*p++ != '-')
1043                 return (t);
1044         data = atol10(p, 2);
1045         if (data < 1 || data > 12)
1046                 return (t);
1047         tm.tm_mon = (int)data -1;
1048         p += 2;
1049         if (*p++ != '-')
1050                 return (t);
1051         data = atol10(p, 2);
1052         if (data < 1 || data > 31)
1053                 return (t);
1054         tm.tm_mday = (int)data;
1055         p += 2;
1056         if (*p++ != 'T')
1057                 return (t);
1058         data = atol10(p, 2);
1059         if (data < 0 || data > 23)
1060                 return (t);
1061         tm.tm_hour = (int)data;
1062         p += 2;
1063         if (*p++ != ':')
1064                 return (t);
1065         data = atol10(p, 2);
1066         if (data < 0 || data > 59)
1067                 return (t);
1068         tm.tm_min = (int)data;
1069         p += 2;
1070         if (*p++ != ':')
1071                 return (t);
1072         data = atol10(p, 2);
1073         if (data < 0 || data > 60)
1074                 return (t);
1075         tm.tm_sec = (int)data;
1076 #if 0
1077         p += 2;
1078         if (*p != 'Z')
1079                 return (t);
1080 #endif
1081
1082         t = time_from_tm(&tm);
1083
1084         return (t);
1085 }
1086
1087 static void
1088 heap_add_entry(struct heap_queue *heap, struct xar_file *file)
1089 {
1090         uint64_t file_id, parent_id;
1091         int hole, parent;
1092
1093         /* Expand our pending files list as necessary. */
1094         if (heap->used >= heap->allocated) {
1095                 struct xar_file **new_pending_files;
1096                 int new_size = heap->allocated * 2;
1097
1098                 if (heap->allocated < 1024)
1099                         new_size = 1024;
1100                 /* Overflow might keep us from growing the list. */
1101                 if (new_size <= heap->allocated)
1102                         __archive_errx(1, "Out of memory");
1103                 new_pending_files = (struct xar_file **)
1104                     malloc(new_size * sizeof(new_pending_files[0]));
1105                 if (new_pending_files == NULL)
1106                         __archive_errx(1, "Out of memory");
1107                 memcpy(new_pending_files, heap->files,
1108                     heap->allocated * sizeof(new_pending_files[0]));
1109                 if (heap->files != NULL)
1110                         free(heap->files);
1111                 heap->files = new_pending_files;
1112                 heap->allocated = new_size;
1113         }
1114
1115         file_id = file->id;
1116
1117         /*
1118          * Start with hole at end, walk it up tree to find insertion point.
1119          */
1120         hole = heap->used++;
1121         while (hole > 0) {
1122                 parent = (hole - 1)/2;
1123                 parent_id = heap->files[parent]->id;
1124                 if (file_id >= parent_id) {
1125                         heap->files[hole] = file;
1126                         return;
1127                 }
1128                 // Move parent into hole <==> move hole up tree.
1129                 heap->files[hole] = heap->files[parent];
1130                 hole = parent;
1131         }
1132         heap->files[0] = file;
1133 }
1134
1135 static struct xar_file *
1136 heap_get_entry(struct heap_queue *heap)
1137 {
1138         uint64_t a_id, b_id, c_id;
1139         int a, b, c;
1140         struct xar_file *r, *tmp;
1141
1142         if (heap->used < 1)
1143                 return (NULL);
1144
1145         /*
1146          * The first file in the list is the earliest; we'll return this.
1147          */
1148         r = heap->files[0];
1149
1150         /*
1151          * Move the last item in the heap to the root of the tree
1152          */
1153         heap->files[0] = heap->files[--(heap->used)];
1154
1155         /*
1156          * Rebalance the heap.
1157          */
1158         a = 0; // Starting element and its heap key
1159         a_id = heap->files[a]->id;
1160         for (;;) {
1161                 b = a + a + 1; // First child
1162                 if (b >= heap->used)
1163                         return (r);
1164                 b_id = heap->files[b]->id;
1165                 c = b + 1; // Use second child if it is smaller.
1166                 if (c < heap->used) {
1167                         c_id = heap->files[c]->id;
1168                         if (c_id < b_id) {
1169                                 b = c;
1170                                 b_id = c_id;
1171                         }
1172                 }
1173                 if (a_id <= b_id)
1174                         return (r);
1175                 tmp = heap->files[a];
1176                 heap->files[a] = heap->files[b];
1177                 heap->files[b] = tmp;
1178                 a = b;
1179         }
1180 }
1181
1182 static void
1183 add_link(struct xar *xar, struct xar_file *file)
1184 {
1185         struct hdlink *hdlink;
1186
1187         for (hdlink = xar->hdlink_list; hdlink != NULL; hdlink = hdlink->next) {
1188                 if (hdlink->id == file->link) {
1189                         file->hdnext = hdlink->files;
1190                         hdlink->cnt++;
1191                         hdlink->files = file;
1192                         return;
1193                 }
1194         }
1195         hdlink = malloc(sizeof(*hdlink));
1196         if (hdlink == NULL)
1197                 __archive_errx(1, "No memory for add_link()");
1198         file->hdnext = NULL;
1199         hdlink->id = file->link;
1200         hdlink->cnt = 1;
1201         hdlink->files = file;
1202         hdlink->next = xar->hdlink_list;
1203         xar->hdlink_list = hdlink;
1204 }
1205
1206 static void
1207 _checksum_init(struct chksumwork *sumwrk, int sum_alg)
1208 {
1209         sumwrk->alg = sum_alg;
1210         switch (sum_alg) {
1211         case CKSUM_NONE:
1212                 break;
1213         case CKSUM_SHA1:
1214                 archive_sha1_init(&(sumwrk->sha1ctx));
1215                 break;
1216         case CKSUM_MD5:
1217                 archive_md5_init(&(sumwrk->md5ctx));
1218                 break;
1219         }
1220 }
1221
1222 static void
1223 _checksum_update(struct chksumwork *sumwrk, const void *buff, size_t size)
1224 {
1225
1226         switch (sumwrk->alg) {
1227         case CKSUM_NONE:
1228                 break;
1229         case CKSUM_SHA1:
1230                 archive_sha1_update(&(sumwrk->sha1ctx), buff, size);
1231                 break;
1232         case CKSUM_MD5:
1233                 archive_md5_update(&(sumwrk->md5ctx), buff, size);
1234                 break;
1235         }
1236 }
1237
1238 static int
1239 _checksum_final(struct chksumwork *sumwrk, const void *val, size_t len)
1240 {
1241         unsigned char sum[MAX_SUM_SIZE];
1242         int r = ARCHIVE_OK;
1243
1244         switch (sumwrk->alg) {
1245         case CKSUM_NONE:
1246                 break;
1247         case CKSUM_SHA1:
1248                 archive_sha1_final(&(sumwrk->sha1ctx), sum);
1249                 if (len != SHA1_SIZE ||
1250                     memcmp(val, sum, SHA1_SIZE) != 0)
1251                         r = ARCHIVE_FAILED;
1252                 break;
1253         case CKSUM_MD5:
1254                 archive_md5_final(&(sumwrk->md5ctx), sum);
1255                 if (len != MD5_SIZE ||
1256                     memcmp(val, sum, MD5_SIZE) != 0)
1257                         r = ARCHIVE_FAILED;
1258                 break;
1259         }
1260         return (r);
1261 }
1262
1263 static void
1264 checksum_init(struct archive_read *a, int a_sum_alg, int e_sum_alg)
1265 {
1266         struct xar *xar;
1267
1268         xar = (struct xar *)(a->format->data);
1269         _checksum_init(&(xar->a_sumwrk), a_sum_alg);
1270         _checksum_init(&(xar->e_sumwrk), e_sum_alg);
1271 }
1272
1273 static void
1274 checksum_update(struct archive_read *a, const void *abuff, size_t asize,
1275     const void *ebuff, size_t esize)
1276 {
1277         struct xar *xar;
1278
1279         xar = (struct xar *)(a->format->data);
1280         _checksum_update(&(xar->a_sumwrk), abuff, asize);
1281         _checksum_update(&(xar->e_sumwrk), ebuff, esize);
1282 }
1283
1284 static int
1285 checksum_final(struct archive_read *a, const void *a_sum_val,
1286     size_t a_sum_len, const void *e_sum_val, size_t e_sum_len)
1287 {
1288         struct xar *xar;
1289         int r;
1290
1291         xar = (struct xar *)(a->format->data);
1292         r = _checksum_final(&(xar->a_sumwrk), a_sum_val, a_sum_len);
1293         if (r == ARCHIVE_OK)
1294                 r = _checksum_final(&(xar->e_sumwrk), e_sum_val, e_sum_len);
1295         if (r != ARCHIVE_OK)
1296                 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
1297                     "Sumcheck error");
1298         return (r);
1299 }
1300
1301 static int
1302 decompression_init(struct archive_read *a, enum enctype encoding)
1303 {
1304         struct xar *xar;
1305         const char *detail;
1306         int r;
1307
1308         xar = (struct xar *)(a->format->data);
1309         xar->rd_encoding = encoding;
1310         switch (encoding) {
1311         case NONE:
1312                 break;
1313         case GZIP:
1314                 if (xar->stream_valid)
1315                         r = inflateReset(&(xar->stream));
1316                 else
1317                         r = inflateInit(&(xar->stream));
1318                 if (r != Z_OK) {
1319                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1320                             "Couldn't initialize zlib stream.");
1321                         return (ARCHIVE_FATAL);
1322                 }
1323                 xar->stream_valid = 1;
1324                 xar->stream.total_in = 0;
1325                 xar->stream.total_out = 0;
1326                 break;
1327 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1328         case BZIP2:
1329                 if (xar->bzstream_valid) {
1330                         BZ2_bzDecompressEnd(&(xar->bzstream));
1331                         xar->bzstream_valid = 0;
1332                 }
1333                 r = BZ2_bzDecompressInit(&(xar->bzstream), 0, 0);
1334                 if (r == BZ_MEM_ERROR)
1335                         r = BZ2_bzDecompressInit(&(xar->bzstream), 0, 1);
1336                 if (r != BZ_OK) {
1337                         int err = ARCHIVE_ERRNO_MISC;
1338                         detail = NULL;
1339                         switch (r) {
1340                         case BZ_PARAM_ERROR:
1341                                 detail = "invalid setup parameter";
1342                                 break;
1343                         case BZ_MEM_ERROR:
1344                                 err = ENOMEM;
1345                                 detail = "out of memory";
1346                                 break;
1347                         case BZ_CONFIG_ERROR:
1348                                 detail = "mis-compiled library";
1349                                 break;
1350                         }
1351                         archive_set_error(&a->archive, err,
1352                             "Internal error initializing decompressor: %s",
1353                             detail == NULL ? "??" : detail);
1354                         xar->bzstream_valid = 0;
1355                         return (ARCHIVE_FATAL);
1356                 }
1357                 xar->bzstream_valid = 1;
1358                 xar->bzstream.total_in_lo32 = 0;
1359                 xar->bzstream.total_in_hi32 = 0;
1360                 xar->bzstream.total_out_lo32 = 0;
1361                 xar->bzstream.total_out_hi32 = 0;
1362                 break;
1363 #endif
1364 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1365         case XZ:
1366         case LZMA:
1367                 if (xar->lzstream_valid) {
1368                         lzma_end(&(xar->lzstream));
1369                         xar->lzstream_valid = 0;
1370                 }
1371                 if (xar->entry_encoding == XZ)
1372                         r = lzma_stream_decoder(&(xar->lzstream),
1373                             (1U << 30),/* memlimit */
1374                             LZMA_CONCATENATED);
1375                 else
1376                         r = lzma_alone_decoder(&(xar->lzstream),
1377                             (1U << 30));/* memlimit */
1378                 if (r != LZMA_OK) {
1379                         switch (r) {
1380                         case LZMA_MEM_ERROR:
1381                                 archive_set_error(&a->archive,
1382                                     ENOMEM,
1383                                     "Internal error initializing "
1384                                     "compression library: "
1385                                     "Cannot allocate memory");
1386                                 break;
1387                         case LZMA_OPTIONS_ERROR:
1388                                 archive_set_error(&a->archive,
1389                                     ARCHIVE_ERRNO_MISC,
1390                                     "Internal error initializing "
1391                                     "compression library: "
1392                                     "Invalid or unsupported options");
1393                                 break;
1394                         default:
1395                                 archive_set_error(&a->archive,
1396                                     ARCHIVE_ERRNO_MISC,
1397                                     "Internal error initializing "
1398                                     "lzma library");
1399                                 break;
1400                         }
1401                         return (ARCHIVE_FATAL);
1402                 }
1403                 xar->lzstream_valid = 1;
1404                 xar->lzstream.total_in = 0;
1405                 xar->lzstream.total_out = 0;
1406                 break;
1407 #elif defined(HAVE_LZMADEC_H) && defined(HAVE_LIBLZMADEC)
1408         case LZMA:
1409                 if (xar->lzstream_valid)
1410                         lzmadec_end(&(xar->lzstream));
1411                 r = lzmadec_init(&(xar->lzstream));
1412                 if (r != LZMADEC_OK) {
1413                         switch (r) {
1414                         case LZMADEC_HEADER_ERROR:
1415                                 archive_set_error(&a->archive,
1416                                     ARCHIVE_ERRNO_MISC,
1417                                     "Internal error initializing "
1418                                     "compression library: "
1419                                     "invalid header");
1420                                 break;
1421                         case LZMADEC_MEM_ERROR:
1422                                 archive_set_error(&a->archive,
1423                                     ENOMEM,
1424                                     "Internal error initializing "
1425                                     "compression library: "
1426                                     "out of memory");
1427                                 break;
1428                         }
1429                         return (ARCHIVE_FATAL);
1430                 }
1431                 xar->lzstream_valid = 1;
1432                 xar->lzstream.total_in = 0;
1433                 xar->lzstream.total_out = 0;
1434                 break;
1435 #endif
1436         /*
1437          * Unsupported compression.
1438          */
1439         default:
1440 #if !defined(HAVE_BZLIB_H) || !defined(BZ_CONFIG_ERROR)
1441         case BZIP2:
1442 #endif
1443 #if !defined(HAVE_LZMA_H) || !defined(HAVE_LIBLZMA)
1444 #if !defined(HAVE_LZMADEC_H) || !defined(HAVE_LIBLZMADEC)
1445         case LZMA:
1446 #endif
1447         case XZ:
1448 #endif
1449                 switch (xar->entry_encoding) {
1450                 case BZIP2: detail = "bzip2"; break;
1451                 case LZMA: detail = "lzma"; break;
1452                 case XZ: detail = "xz"; break;
1453                 default: detail = "??"; break;
1454                 }
1455                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1456                     "%s compression not supported on this platform",
1457                     detail);
1458                 return (ARCHIVE_FAILED);
1459         }
1460         return (ARCHIVE_OK);
1461 }
1462
1463 static int
1464 decompress(struct archive_read *a, const void **buff, size_t *outbytes,
1465     const void *b, size_t *used)
1466 {
1467         struct xar *xar;
1468         void *outbuff;
1469         size_t avail_in, avail_out;
1470         int r;
1471
1472         xar = (struct xar *)(a->format->data);
1473         avail_in = *used;
1474         outbuff = (void *)(uintptr_t)*buff;
1475         if (outbuff == NULL) {
1476                 outbuff = xar->buff;
1477                 *buff = outbuff;
1478                 avail_out = sizeof(xar->buff);
1479         } else
1480                 avail_out = *outbytes;
1481         switch (xar->rd_encoding) {
1482         case GZIP:
1483                 xar->stream.next_in = (Bytef *)(uintptr_t)b;
1484                 xar->stream.avail_in = avail_in;
1485                 xar->stream.next_out = (unsigned char *)outbuff;
1486                 xar->stream.avail_out = avail_out;
1487                 r = inflate(&(xar->stream), 0);
1488                 switch (r) {
1489                 case Z_OK: /* Decompressor made some progress.*/
1490                 case Z_STREAM_END: /* Found end of stream. */
1491                         break;
1492                 default:
1493                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1494                             "File decompression failed (%d)", r);
1495                         return (ARCHIVE_FATAL);
1496                 }
1497                 *used = avail_in - xar->stream.avail_in;
1498                 *outbytes = avail_out - xar->stream.avail_out;
1499                 break;
1500 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1501         case BZIP2:
1502                 xar->bzstream.next_in = (char *)(uintptr_t)b;
1503                 xar->bzstream.avail_in = avail_in;
1504                 xar->bzstream.next_out = (char *)outbuff;
1505                 xar->bzstream.avail_out = avail_out;
1506                 r = BZ2_bzDecompress(&(xar->bzstream));
1507                 switch (r) {
1508                 case BZ_STREAM_END: /* Found end of stream. */
1509                         switch (BZ2_bzDecompressEnd(&(xar->bzstream))) {
1510                         case BZ_OK:
1511                                 break;
1512                         default:
1513                                 archive_set_error(&(a->archive),
1514                                     ARCHIVE_ERRNO_MISC,
1515                                     "Failed to clean up decompressor");
1516                                 return (ARCHIVE_FATAL);
1517                         }
1518                         xar->bzstream_valid = 0;
1519                         /* FALLTHROUGH */
1520                 case BZ_OK: /* Decompressor made some progress. */
1521                         break;
1522                 default:
1523                         archive_set_error(&(a->archive),
1524                             ARCHIVE_ERRNO_MISC,
1525                             "bzip decompression failed");
1526                         return (ARCHIVE_FATAL);
1527                 }
1528                 *used = avail_in - xar->bzstream.avail_in;
1529                 *outbytes = avail_out - xar->bzstream.avail_out;
1530                 break;
1531 #endif
1532 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1533         case LZMA:
1534         case XZ:
1535                 xar->lzstream.next_in = b;
1536                 xar->lzstream.avail_in = avail_in;
1537                 xar->lzstream.next_out = (unsigned char *)outbuff;
1538                 xar->lzstream.avail_out = avail_out;
1539                 r = lzma_code(&(xar->lzstream), LZMA_RUN);
1540                 switch (r) {
1541                 case LZMA_STREAM_END: /* Found end of stream. */
1542                         lzma_end(&(xar->lzstream));
1543                         xar->lzstream_valid = 0;
1544                         /* FALLTHROUGH */
1545                 case LZMA_OK: /* Decompressor made some progress. */
1546                         break;
1547                 default:
1548                         archive_set_error(&(a->archive),
1549                             ARCHIVE_ERRNO_MISC,
1550                             "%s decompression failed(%d)",
1551                             (xar->entry_encoding == XZ)?"xz":"lzma",
1552                             r);
1553                         return (ARCHIVE_FATAL);
1554                 }
1555                 *used = avail_in - xar->lzstream.avail_in;
1556                 *outbytes = avail_out - xar->lzstream.avail_out;
1557                 break;
1558 #elif defined(HAVE_LZMADEC_H) && defined(HAVE_LIBLZMADEC)
1559         case LZMA:
1560                 xar->lzstream.next_in = (unsigned char *)(uintptr_t)b;
1561                 xar->lzstream.avail_in = avail_in;
1562                 xar->lzstream.next_out = (unsigned char *)outbuff;
1563                 xar->lzstream.avail_out = avail_out;
1564                 r = lzmadec_decode(&(xar->lzstream), 0);
1565                 switch (r) {
1566                 case LZMADEC_STREAM_END: /* Found end of stream. */
1567                         switch (lzmadec_end(&(xar->lzstream))) {
1568                         case LZMADEC_OK:
1569                                 break;
1570                         default:
1571                                 archive_set_error(&(a->archive),
1572                                     ARCHIVE_ERRNO_MISC,
1573                                     "Failed to clean up lzmadec decompressor");
1574                                 return (ARCHIVE_FATAL);
1575                         }
1576                         xar->lzstream_valid = 0;
1577                         /* FALLTHROUGH */
1578                 case LZMADEC_OK: /* Decompressor made some progress. */
1579                         break;
1580                 default:
1581                         archive_set_error(&(a->archive),
1582                             ARCHIVE_ERRNO_MISC,
1583                             "lzmadec decompression failed(%d)",
1584                             r);
1585                         return (ARCHIVE_FATAL);
1586                 }
1587                 *used = avail_in - xar->lzstream.avail_in;
1588                 *outbytes = avail_out - xar->lzstream.avail_out;
1589                 break;
1590 #endif
1591 #if !defined(HAVE_BZLIB_H) || !defined(BZ_CONFIG_ERROR)
1592         case BZIP2:
1593 #endif
1594 #if !defined(HAVE_LZMA_H) || !defined(HAVE_LIBLZMA)
1595 #if !defined(HAVE_LZMADEC_H) || !defined(HAVE_LIBLZMADEC)
1596         case LZMA:
1597 #endif
1598         case XZ:
1599 #endif
1600         case NONE:
1601         default:
1602                 if (outbuff == xar->buff) {
1603                         *buff = b;
1604                         *used = avail_in;
1605                         *outbytes = avail_in;
1606                 } else {
1607                         if (avail_out > avail_in)
1608                                 avail_out = avail_in;
1609                         memcpy(outbuff, b, avail_out);
1610                         *used = avail_out;
1611                         *outbytes = avail_out;
1612                 }
1613                 break;
1614         }
1615         return (ARCHIVE_OK);
1616 }
1617
1618 static int
1619 decompression_cleanup(struct archive_read *a)
1620 {
1621         struct xar *xar;
1622         int r;
1623
1624         xar = (struct xar *)(a->format->data);
1625         r = ARCHIVE_OK;
1626         if (xar->stream_valid) {
1627                 if (inflateEnd(&(xar->stream)) != Z_OK) {
1628                         archive_set_error(&a->archive,
1629                             ARCHIVE_ERRNO_MISC,
1630                             "Failed to clean up zlib decompressor");
1631                         r = ARCHIVE_FATAL;
1632                 }
1633         }
1634 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1635         if (xar->bzstream_valid) {
1636                 if (BZ2_bzDecompressEnd(&(xar->bzstream)) != BZ_OK) {
1637                         archive_set_error(&a->archive,
1638                             ARCHIVE_ERRNO_MISC,
1639                             "Failed to clean up bzip2 decompressor");
1640                         r = ARCHIVE_FATAL;
1641                 }
1642         }
1643 #endif
1644 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1645         if (xar->lzstream_valid)
1646                 lzma_end(&(xar->lzstream));
1647 #elif defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1648         if (xar->lzstream_valid) {
1649                 if (lzmadec_end(&(xar->lzstream)) != LZMADEC_OK) {
1650                         archive_set_error(&a->archive,
1651                             ARCHIVE_ERRNO_MISC,
1652                             "Failed to clean up lzmadec decompressor");
1653                         r = ARCHIVE_FATAL;
1654                 }
1655         }
1656 #endif
1657         return (r);
1658 }
1659
1660 static void
1661 xmlattr_cleanup(struct xmlattr_list *list)
1662 {
1663         struct xmlattr *attr, *next;
1664
1665         attr = list->first;
1666         while (attr != NULL) {
1667                 next = attr->next;
1668                 free(attr->name);
1669                 free(attr->value);
1670                 free(attr);
1671                 attr = next;
1672         }
1673         list->first = NULL;
1674         list->last = &(list->first);
1675 }
1676
1677 static void
1678 file_new(struct xar *xar, struct xmlattr_list *list)
1679 {
1680         struct xar_file *file;
1681         struct xmlattr *attr;
1682
1683         file = calloc(1, sizeof(*file));
1684         if (file == NULL)
1685                 __archive_errx(1, "Out of memory");
1686         file->parent = xar->file;
1687         file->mode = 0777 | AE_IFREG;
1688         file->atime = time(NULL);
1689         file->mtime = time(NULL);
1690         xar->file = file;
1691         xar->xattr = NULL;
1692         for (attr = list->first; attr != NULL; attr = attr->next) {
1693                 if (strcmp(attr->name, "id") == 0)
1694                         file->id = atol10(attr->value, strlen(attr->value));
1695         }
1696         file->nlink = 1;
1697         heap_add_entry(&(xar->file_queue), file);
1698 }
1699
1700 static void
1701 file_free(struct xar_file *file)
1702 {
1703         struct xattr *xattr;
1704
1705         archive_string_free(&(file->pathname));
1706         archive_string_free(&(file->symlink));
1707         archive_string_free(&(file->uname));
1708         archive_string_free(&(file->gname));
1709         archive_string_free(&(file->hardlink));
1710         xattr = file->xattr_list;
1711         while (xattr != NULL) {
1712                 struct xattr *next;
1713
1714                 next = xattr->next;
1715                 xattr_free(xattr);
1716                 xattr = next;
1717         }
1718
1719         free(file);
1720 }
1721
1722 static void
1723 xattr_new(struct xar *xar, struct xmlattr_list *list)
1724 {
1725         struct xattr *xattr, **nx;
1726         struct xmlattr *attr;
1727
1728         xattr = calloc(1, sizeof(*xattr));
1729         if (xattr == NULL)
1730                 __archive_errx(1, "Out of memory");
1731         xar->xattr = xattr;
1732         for (attr = list->first; attr != NULL; attr = attr->next) {
1733                 if (strcmp(attr->name, "id") == 0)
1734                         xattr->id = atol10(attr->value, strlen(attr->value));
1735         }
1736         /* Chain to xattr list. */
1737         for (nx = &(xar->file->xattr_list);
1738             *nx != NULL; nx = &((*nx)->next)) {
1739                 if (xattr->id < (*nx)->id)
1740                         break;
1741         }
1742         xattr->next = *nx;
1743         *nx = xattr;
1744 }
1745
1746 static void
1747 xattr_free(struct xattr *xattr)
1748 {
1749         archive_string_free(&(xattr->name));
1750         free(xattr);
1751 }
1752
1753 static int
1754 getencoding(struct xmlattr_list *list)
1755 {
1756         struct xmlattr *attr;
1757         enum enctype encoding = NONE;
1758
1759         for (attr = list->first; attr != NULL; attr = attr->next) {
1760                 if (strcmp(attr->name, "style") == 0) {
1761                         if (strcmp(attr->value, "application/octet-stream") == 0)
1762                                 encoding = NONE;
1763                         else if (strcmp(attr->value, "application/x-gzip") == 0)
1764                                 encoding = GZIP;
1765                         else if (strcmp(attr->value, "application/x-bzip2") == 0)
1766                                 encoding = BZIP2;
1767                         else if (strcmp(attr->value, "application/x-lzma") == 0)
1768                                 encoding = LZMA;
1769                         else if (strcmp(attr->value, "application/x-xz") == 0)
1770                                 encoding = XZ;
1771                 }
1772         }
1773         return (encoding);
1774 }
1775
1776 static int
1777 getsumalgorithm(struct xmlattr_list *list)
1778 {
1779         struct xmlattr *attr;
1780         int alg = CKSUM_NONE;
1781
1782         for (attr = list->first; attr != NULL; attr = attr->next) {
1783                 if (strcmp(attr->name, "style") == 0) {
1784                         const char *v = attr->value;
1785                         if ((v[0] == 'S' || v[0] == 's') &&
1786                             (v[1] == 'H' || v[1] == 'h') &&
1787                             (v[2] == 'A' || v[2] == 'a') &&
1788                             v[3] == '1' && v[4] == '\0')
1789                                 alg = CKSUM_SHA1;
1790                         if ((v[0] == 'M' || v[0] == 'm') &&
1791                             (v[1] == 'D' || v[1] == 'd') &&
1792                             v[2] == '5' && v[3] == '\0')
1793                                 alg = CKSUM_MD5;
1794                 }
1795         }
1796         return (alg);
1797 }
1798
1799 static void
1800 unknowntag_start(struct xar *xar, const char *name)
1801 {
1802         struct unknown_tag *tag;
1803
1804 #if DEBUG
1805         fprintf(stderr, "unknowntag_start:%s\n", name);
1806 #endif
1807         tag = malloc(sizeof(*tag));
1808         if (tag == NULL)
1809                 __archive_errx(1, "Out of memory");
1810         tag->next = xar->unknowntags;
1811         archive_string_init(&(tag->name));
1812         archive_strcpy(&(tag->name), name);
1813         if (xar->unknowntags == NULL) {
1814                 xar->xmlsts_unknown = xar->xmlsts;
1815                 xar->xmlsts = UNKNOWN;
1816         }
1817         xar->unknowntags = tag;
1818 }
1819
1820 static void
1821 unknowntag_end(struct xar *xar, const char *name)
1822 {
1823         struct unknown_tag *tag;
1824
1825 #if DEBUG
1826         fprintf(stderr, "unknowntag_end:%s\n", name);
1827 #endif
1828         tag = xar->unknowntags;
1829         if (tag == NULL || name == NULL)
1830                 return;
1831         if (strcmp(tag->name.s, name) == 0) {
1832                 xar->unknowntags = tag->next;
1833                 archive_string_free(&(tag->name));
1834                 free(tag);
1835                 if (xar->unknowntags == NULL)
1836                         xar->xmlsts = xar->xmlsts_unknown;
1837         }
1838 }
1839
1840 static void
1841 xml_start(void *userData, const char *name, struct xmlattr_list *list)
1842 {
1843         struct archive_read *a;
1844         struct xar *xar;
1845         struct xmlattr *attr;
1846
1847         a = (struct archive_read *)userData;
1848         xar = (struct xar *)(a->format->data);
1849
1850 #if DEBUG
1851         fprintf(stderr, "xml_sta:[%s]\n", name);
1852         for (attr = list->first; attr != NULL; attr = attr->next)
1853                 fprintf(stderr, "    attr:\"%s\"=\"%s\"\n",
1854                     attr->name, attr->value);
1855 #endif
1856         xar->base64text = 0;
1857         switch (xar->xmlsts) {
1858         case INIT:
1859                 if (strcmp(name, "xar") == 0)
1860                         xar->xmlsts = XAR;
1861                 else
1862                         unknowntag_start(xar, name);
1863                 break;
1864         case XAR:
1865                 if (strcmp(name, "toc") == 0)
1866                         xar->xmlsts = TOC;
1867                 else
1868                         unknowntag_start(xar, name);
1869                 break;
1870         case TOC:
1871                 if (strcmp(name, "creation-time") == 0)
1872                         xar->xmlsts = TOC_CREATION_TIME;
1873                 else if (strcmp(name, "checksum") == 0)
1874                         xar->xmlsts = TOC_CHECKSUM;
1875                 else if (strcmp(name, "file") == 0) {
1876                         file_new(xar, list);
1877                         xar->xmlsts = TOC_FILE;
1878                 }
1879                 else
1880                         unknowntag_start(xar, name);
1881                 break;
1882         case TOC_CHECKSUM:
1883                 if (strcmp(name, "offset") == 0)
1884                         xar->xmlsts = TOC_CHECKSUM_OFFSET;
1885                 else if (strcmp(name, "size") == 0)
1886                         xar->xmlsts = TOC_CHECKSUM_SIZE;
1887                 else
1888                         unknowntag_start(xar, name);
1889                 break;
1890         case TOC_FILE:
1891                 if (strcmp(name, "file") == 0) {
1892                         file_new(xar, list);
1893                 }
1894                 else if (strcmp(name, "data") == 0)
1895                         xar->xmlsts = FILE_DATA;
1896                 else if (strcmp(name, "ea") == 0) {
1897                         xattr_new(xar, list);
1898                         xar->xmlsts = FILE_EA;
1899                 }
1900                 else if (strcmp(name, "ctime") == 0)
1901                         xar->xmlsts = FILE_CTIME;
1902                 else if (strcmp(name, "mtime") == 0)
1903                         xar->xmlsts = FILE_MTIME;
1904                 else if (strcmp(name, "atime") == 0)
1905                         xar->xmlsts = FILE_ATIME;
1906                 else if (strcmp(name, "group") == 0)
1907                         xar->xmlsts = FILE_GROUP;
1908                 else if (strcmp(name, "gid") == 0)
1909                         xar->xmlsts = FILE_GID;
1910                 else if (strcmp(name, "user") == 0)
1911                         xar->xmlsts = FILE_USER;
1912                 else if (strcmp(name, "uid") == 0)
1913                         xar->xmlsts = FILE_UID;
1914                 else if (strcmp(name, "mode") == 0)
1915                         xar->xmlsts = FILE_MODE;
1916                 else if (strcmp(name, "device") == 0)
1917                         xar->xmlsts = FILE_DEVICE;
1918                 else if (strcmp(name, "deviceno") == 0)
1919                         xar->xmlsts = FILE_DEVICENO;
1920                 else if (strcmp(name, "inode") == 0)
1921                         xar->xmlsts = FILE_INODE;
1922                 else if (strcmp(name, "link") == 0)
1923                         xar->xmlsts = FILE_LINK;
1924                 else if (strcmp(name, "type") == 0) {
1925                         xar->xmlsts = FILE_TYPE;
1926                         for (attr = list->first; attr != NULL;
1927                             attr = attr->next) {
1928                                 if (strcmp(attr->name, "link") != 0)
1929                                         continue;
1930                                 if (strcmp(attr->value, "original") == 0) {
1931                                         xar->file->hdnext = xar->hdlink_orgs;
1932                                         xar->hdlink_orgs = xar->file;
1933                                 } else {
1934                                         xar->file->link = atol10(attr->value,
1935                                             strlen(attr->value));
1936                                         if (xar->file->link > 0)
1937                                                 add_link(xar, xar->file);
1938                                 }
1939                         }
1940                 }
1941                 else if (strcmp(name, "name") == 0) {
1942                         xar->xmlsts = FILE_NAME;
1943                         for (attr = list->first; attr != NULL;
1944                             attr = attr->next) {
1945                                 if (strcmp(attr->name, "enctype") == 0 &&
1946                                     strcmp(attr->value, "base64") == 0)
1947                                         xar->base64text = 1;
1948                         }
1949                 }
1950                 else if (strcmp(name, "acl") == 0)
1951                         xar->xmlsts = FILE_ACL;
1952                 else if (strcmp(name, "flags") == 0)
1953                         xar->xmlsts = FILE_FLAGS;
1954                 else if (strcmp(name, "ext2") == 0)
1955                         xar->xmlsts = FILE_EXT2;
1956                 else
1957                         unknowntag_start(xar, name);
1958                 break;
1959         case FILE_DATA:
1960                 if (strcmp(name, "length") == 0)
1961                         xar->xmlsts = FILE_DATA_LENGTH;
1962                 else if (strcmp(name, "offset") == 0)
1963                         xar->xmlsts = FILE_DATA_OFFSET;
1964                 else if (strcmp(name, "size") == 0)
1965                         xar->xmlsts = FILE_DATA_SIZE;
1966                 else if (strcmp(name, "encoding") == 0) {
1967                         xar->xmlsts = FILE_DATA_ENCODING;
1968                         xar->file->encoding = getencoding(list);
1969                 }
1970                 else if (strcmp(name, "archived-checksum") == 0) {
1971                         xar->xmlsts = FILE_DATA_A_CHECKSUM;
1972                         xar->file->a_sum.alg = getsumalgorithm(list);
1973                 }
1974                 else if (strcmp(name, "extracted-checksum") == 0) {
1975                         xar->xmlsts = FILE_DATA_E_CHECKSUM;
1976                         xar->file->e_sum.alg = getsumalgorithm(list);
1977                 }
1978                 else if (strcmp(name, "content") == 0)
1979                         xar->xmlsts = FILE_DATA_CONTENT;
1980                 else
1981                         unknowntag_start(xar, name);
1982                 break;
1983         case FILE_DEVICE:
1984                 if (strcmp(name, "major") == 0)
1985                         xar->xmlsts = FILE_DEVICE_MAJOR;
1986                 else if (strcmp(name, "minor") == 0)
1987                         xar->xmlsts = FILE_DEVICE_MINOR;
1988                 else
1989                         unknowntag_start(xar, name);
1990                 break;
1991         case FILE_DATA_CONTENT:
1992                 unknowntag_start(xar, name);
1993                 break;
1994         case FILE_EA:
1995                 if (strcmp(name, "length") == 0)
1996                         xar->xmlsts = FILE_EA_LENGTH;
1997                 else if (strcmp(name, "offset") == 0)
1998                         xar->xmlsts = FILE_EA_OFFSET;
1999                 else if (strcmp(name, "size") == 0)
2000                         xar->xmlsts = FILE_EA_SIZE;
2001                 else if (strcmp(name, "encoding") == 0) {
2002                         xar->xmlsts = FILE_EA_ENCODING;
2003                         xar->xattr->encoding = getencoding(list);
2004                 } else if (strcmp(name, "archived-checksum") == 0)
2005                         xar->xmlsts = FILE_EA_A_CHECKSUM;
2006                 else if (strcmp(name, "extracted-checksum") == 0)
2007                         xar->xmlsts = FILE_EA_E_CHECKSUM;
2008                 else if (strcmp(name, "name") == 0)
2009                         xar->xmlsts = FILE_EA_NAME;
2010                 else if (strcmp(name, "fstype") == 0)
2011                         xar->xmlsts = FILE_EA_FSTYPE;
2012                 else
2013                         unknowntag_start(xar, name);
2014                 break;
2015         case FILE_ACL:
2016                 if (strcmp(name, "appleextended") == 0)
2017                         xar->xmlsts = FILE_ACL_APPLEEXTENDED;
2018                 if (strcmp(name, "default") == 0)
2019                         xar->xmlsts = FILE_ACL_DEFAULT;
2020                 else if (strcmp(name, "access") == 0)
2021                         xar->xmlsts = FILE_ACL_ACCESS;
2022                 else
2023                         unknowntag_start(xar, name);
2024                 break;
2025         case FILE_FLAGS:
2026                 if (!xml_parse_file_flags(xar, name))
2027                         unknowntag_start(xar, name);
2028                 break;
2029         case FILE_EXT2:
2030                 if (!xml_parse_file_ext2(xar, name))
2031                         unknowntag_start(xar, name);
2032                 break;
2033         case TOC_CREATION_TIME:
2034         case TOC_CHECKSUM_OFFSET:
2035         case TOC_CHECKSUM_SIZE:
2036         case FILE_DATA_LENGTH:
2037         case FILE_DATA_OFFSET:
2038         case FILE_DATA_SIZE:
2039         case FILE_DATA_ENCODING:
2040         case FILE_DATA_A_CHECKSUM:
2041         case FILE_DATA_E_CHECKSUM:
2042         case FILE_EA_LENGTH:
2043         case FILE_EA_OFFSET:
2044         case FILE_EA_SIZE:
2045         case FILE_EA_ENCODING:
2046         case FILE_EA_A_CHECKSUM:
2047         case FILE_EA_E_CHECKSUM:
2048         case FILE_EA_NAME:
2049         case FILE_EA_FSTYPE:
2050         case FILE_CTIME:
2051         case FILE_MTIME:
2052         case FILE_ATIME:
2053         case FILE_GROUP:
2054         case FILE_GID:
2055         case FILE_USER:
2056         case FILE_UID:
2057         case FILE_INODE:
2058         case FILE_DEVICE_MAJOR:
2059         case FILE_DEVICE_MINOR:
2060         case FILE_DEVICENO:
2061         case FILE_MODE:
2062         case FILE_TYPE:
2063         case FILE_LINK:
2064         case FILE_NAME:
2065         case FILE_ACL_DEFAULT:
2066         case FILE_ACL_ACCESS:
2067         case FILE_ACL_APPLEEXTENDED:
2068         case FILE_FLAGS_USER_NODUMP:
2069         case FILE_FLAGS_USER_IMMUTABLE:
2070         case FILE_FLAGS_USER_APPEND:
2071         case FILE_FLAGS_USER_OPAQUE:
2072         case FILE_FLAGS_USER_NOUNLINK:
2073         case FILE_FLAGS_SYS_ARCHIVED:
2074         case FILE_FLAGS_SYS_IMMUTABLE:
2075         case FILE_FLAGS_SYS_APPEND:
2076         case FILE_FLAGS_SYS_NOUNLINK:
2077         case FILE_FLAGS_SYS_SNAPSHOT:
2078         case FILE_EXT2_SecureDeletion:
2079         case FILE_EXT2_Undelete:
2080         case FILE_EXT2_Compress:
2081         case FILE_EXT2_Synchronous:
2082         case FILE_EXT2_Immutable:
2083         case FILE_EXT2_AppendOnly:
2084         case FILE_EXT2_NoDump:
2085         case FILE_EXT2_NoAtime:
2086         case FILE_EXT2_CompDirty:
2087         case FILE_EXT2_CompBlock:
2088         case FILE_EXT2_NoCompBlock:
2089         case FILE_EXT2_CompError:
2090         case FILE_EXT2_BTree:
2091         case FILE_EXT2_HashIndexed:
2092         case FILE_EXT2_iMagic:
2093         case FILE_EXT2_Journaled:
2094         case FILE_EXT2_NoTail:
2095         case FILE_EXT2_DirSync:
2096         case FILE_EXT2_TopDir:
2097         case FILE_EXT2_Reserved:
2098         case UNKNOWN:
2099                 unknowntag_start(xar, name);
2100                 break;
2101         }
2102 }
2103
2104 static void
2105 xml_end(void *userData, const char *name)
2106 {
2107         struct archive_read *a;
2108         struct xar *xar;
2109
2110         a = (struct archive_read *)userData;
2111         xar = (struct xar *)(a->format->data);
2112
2113 #if DEBUG
2114         fprintf(stderr, "xml_end:[%s]\n", name);
2115 #endif
2116         switch (xar->xmlsts) {
2117         case INIT:
2118                 break;
2119         case XAR:
2120                 if (strcmp(name, "xar") == 0)
2121                         xar->xmlsts = INIT;
2122                 break;
2123         case TOC:
2124                 if (strcmp(name, "toc") == 0)
2125                         xar->xmlsts = XAR;
2126                 break;
2127         case TOC_CREATION_TIME:
2128                 if (strcmp(name, "creation-time") == 0)
2129                         xar->xmlsts = TOC;
2130                 break;
2131         case TOC_CHECKSUM:
2132                 if (strcmp(name, "checksum") == 0)
2133                         xar->xmlsts = TOC;
2134                 break;
2135         case TOC_CHECKSUM_OFFSET:
2136                 if (strcmp(name, "offset") == 0)
2137                         xar->xmlsts = TOC_CHECKSUM;
2138                 break;
2139         case TOC_CHECKSUM_SIZE:
2140                 if (strcmp(name, "size") == 0)
2141                         xar->xmlsts = TOC_CHECKSUM;
2142                 break;
2143         case TOC_FILE:
2144                 if (strcmp(name, "file") == 0) {
2145                         if (xar->file->parent != NULL &&
2146                             ((xar->file->mode & AE_IFMT) == AE_IFDIR))
2147                                 xar->file->parent->subdirs++;
2148                         xar->file = xar->file->parent;
2149                         if (xar->file == NULL)
2150                                 xar->xmlsts = TOC;
2151                 }
2152                 break;
2153         case FILE_DATA:
2154                 if (strcmp(name, "data") == 0)
2155                         xar->xmlsts = TOC_FILE;
2156                 break;
2157         case FILE_DATA_LENGTH:
2158                 if (strcmp(name, "length") == 0)
2159                         xar->xmlsts = FILE_DATA;
2160                 break;
2161         case FILE_DATA_OFFSET:
2162                 if (strcmp(name, "offset") == 0)
2163                         xar->xmlsts = FILE_DATA;
2164                 break;
2165         case FILE_DATA_SIZE:
2166                 if (strcmp(name, "size") == 0)
2167                         xar->xmlsts = FILE_DATA;
2168                 break;
2169         case FILE_DATA_ENCODING:
2170                 if (strcmp(name, "encoding") == 0)
2171                         xar->xmlsts = FILE_DATA;
2172                 break;
2173         case FILE_DATA_A_CHECKSUM:
2174                 if (strcmp(name, "archived-checksum") == 0)
2175                         xar->xmlsts = FILE_DATA;
2176                 break;
2177         case FILE_DATA_E_CHECKSUM:
2178                 if (strcmp(name, "extracted-checksum") == 0)
2179                         xar->xmlsts = FILE_DATA;
2180                 break;
2181         case FILE_DATA_CONTENT:
2182                 if (strcmp(name, "content") == 0)
2183                         xar->xmlsts = FILE_DATA;
2184                 break;
2185         case FILE_EA:
2186                 if (strcmp(name, "ea") == 0) {
2187                         xar->xmlsts = TOC_FILE;
2188                         xar->xattr = NULL;
2189                 }
2190                 break;
2191         case FILE_EA_LENGTH:
2192                 if (strcmp(name, "length") == 0)
2193                         xar->xmlsts = FILE_EA;
2194                 break;
2195         case FILE_EA_OFFSET:
2196                 if (strcmp(name, "offset") == 0)
2197                         xar->xmlsts = FILE_EA;
2198                 break;
2199         case FILE_EA_SIZE:
2200                 if (strcmp(name, "size") == 0)
2201                         xar->xmlsts = FILE_EA;
2202                 break;
2203         case FILE_EA_ENCODING:
2204                 if (strcmp(name, "encoding") == 0)
2205                         xar->xmlsts = FILE_EA;
2206                 break;
2207         case FILE_EA_A_CHECKSUM:
2208                 if (strcmp(name, "archived-checksum") == 0)
2209                         xar->xmlsts = FILE_EA;
2210                 break;
2211         case FILE_EA_E_CHECKSUM:
2212                 if (strcmp(name, "extracted-checksum") == 0)
2213                         xar->xmlsts = FILE_EA;
2214                 break;
2215         case FILE_EA_NAME:
2216                 if (strcmp(name, "name") == 0)
2217                         xar->xmlsts = FILE_EA;
2218                 break;
2219         case FILE_EA_FSTYPE:
2220                 if (strcmp(name, "fstype") == 0)
2221                         xar->xmlsts = FILE_EA;
2222                 break;
2223         case FILE_CTIME:
2224                 if (strcmp(name, "ctime") == 0)
2225                         xar->xmlsts = TOC_FILE;
2226                 break;
2227         case FILE_MTIME:
2228                 if (strcmp(name, "mtime") == 0)
2229                         xar->xmlsts = TOC_FILE;
2230                 break;
2231         case FILE_ATIME:
2232                 if (strcmp(name, "atime") == 0)
2233                         xar->xmlsts = TOC_FILE;
2234                 break;
2235         case FILE_GROUP:
2236                 if (strcmp(name, "group") == 0)
2237                         xar->xmlsts = TOC_FILE;
2238                 break;
2239         case FILE_GID:
2240                 if (strcmp(name, "gid") == 0)
2241                         xar->xmlsts = TOC_FILE;
2242                 break;
2243         case FILE_USER:
2244                 if (strcmp(name, "user") == 0)
2245                         xar->xmlsts = TOC_FILE;
2246                 break;
2247         case FILE_UID:
2248                 if (strcmp(name, "uid") == 0)
2249                         xar->xmlsts = TOC_FILE;
2250                 break;
2251         case FILE_MODE:
2252                 if (strcmp(name, "mode") == 0)
2253                         xar->xmlsts = TOC_FILE;
2254                 break;
2255         case FILE_DEVICE:
2256                 if (strcmp(name, "device") == 0)
2257                         xar->xmlsts = TOC_FILE;
2258                 break;
2259         case FILE_DEVICE_MAJOR:
2260                 if (strcmp(name, "major") == 0)
2261                         xar->xmlsts = FILE_DEVICE;
2262                 break;
2263         case FILE_DEVICE_MINOR:
2264                 if (strcmp(name, "minor") == 0)
2265                         xar->xmlsts = FILE_DEVICE;
2266                 break;
2267         case FILE_DEVICENO:
2268                 if (strcmp(name, "deviceno") == 0)
2269                         xar->xmlsts = TOC_FILE;
2270                 break;
2271         case FILE_INODE:
2272                 if (strcmp(name, "inode") == 0)
2273                         xar->xmlsts = TOC_FILE;
2274                 break;
2275         case FILE_LINK:
2276                 if (strcmp(name, "link") == 0)
2277                         xar->xmlsts = TOC_FILE;
2278                 break;
2279         case FILE_TYPE:
2280                 if (strcmp(name, "type") == 0)
2281                         xar->xmlsts = TOC_FILE;
2282                 break;
2283         case FILE_NAME:
2284                 if (strcmp(name, "name") == 0)
2285                         xar->xmlsts = TOC_FILE;
2286                 break;
2287         case FILE_ACL:
2288                 if (strcmp(name, "acl") == 0)
2289                         xar->xmlsts = TOC_FILE;
2290                 break;
2291         case FILE_ACL_DEFAULT:
2292                 if (strcmp(name, "default") == 0)
2293                         xar->xmlsts = FILE_ACL;
2294                 break;
2295         case FILE_ACL_ACCESS:
2296                 if (strcmp(name, "access") == 0)
2297                         xar->xmlsts = FILE_ACL;
2298                 break;
2299         case FILE_ACL_APPLEEXTENDED:
2300                 if (strcmp(name, "appleextended") == 0)
2301                         xar->xmlsts = FILE_ACL;
2302                 break;
2303         case FILE_FLAGS:
2304                 if (strcmp(name, "flags") == 0)
2305                         xar->xmlsts = TOC_FILE;
2306                 break;
2307         case FILE_FLAGS_USER_NODUMP:
2308                 if (strcmp(name, "UserNoDump") == 0)
2309                         xar->xmlsts = FILE_FLAGS;
2310                 break;
2311         case FILE_FLAGS_USER_IMMUTABLE:
2312                 if (strcmp(name, "UserImmutable") == 0)
2313                         xar->xmlsts = FILE_FLAGS;
2314                 break;
2315         case FILE_FLAGS_USER_APPEND:
2316                 if (strcmp(name, "UserAppend") == 0)
2317                         xar->xmlsts = FILE_FLAGS;
2318                 break;
2319         case FILE_FLAGS_USER_OPAQUE:
2320                 if (strcmp(name, "UserOpaque") == 0)
2321                         xar->xmlsts = FILE_FLAGS;
2322                 break;
2323         case FILE_FLAGS_USER_NOUNLINK:
2324                 if (strcmp(name, "UserNoUnlink") == 0)
2325                         xar->xmlsts = FILE_FLAGS;
2326                 break;
2327         case FILE_FLAGS_SYS_ARCHIVED:
2328                 if (strcmp(name, "SystemArchived") == 0)
2329                         xar->xmlsts = FILE_FLAGS;
2330                 break;
2331         case FILE_FLAGS_SYS_IMMUTABLE:
2332                 if (strcmp(name, "SystemImmutable") == 0)
2333                         xar->xmlsts = FILE_FLAGS;
2334                 break;
2335         case FILE_FLAGS_SYS_APPEND:
2336                 if (strcmp(name, "SystemAppend") == 0)
2337                         xar->xmlsts = FILE_FLAGS;
2338                 break;
2339         case FILE_FLAGS_SYS_NOUNLINK:
2340                 if (strcmp(name, "SystemNoUnlink") == 0)
2341                         xar->xmlsts = FILE_FLAGS;
2342                 break;
2343         case FILE_FLAGS_SYS_SNAPSHOT:
2344                 if (strcmp(name, "SystemSnapshot") == 0)
2345                         xar->xmlsts = FILE_FLAGS;
2346                 break;
2347         case FILE_EXT2:
2348                 if (strcmp(name, "ext2") == 0)
2349                         xar->xmlsts = TOC_FILE;
2350                 break;
2351         case FILE_EXT2_SecureDeletion:
2352                 if (strcmp(name, "SecureDeletion") == 0)
2353                         xar->xmlsts = FILE_EXT2;
2354                 break;
2355         case FILE_EXT2_Undelete:
2356                 if (strcmp(name, "Undelete") == 0)
2357                         xar->xmlsts = FILE_EXT2;
2358                 break;
2359         case FILE_EXT2_Compress:
2360                 if (strcmp(name, "Compress") == 0)
2361                         xar->xmlsts = FILE_EXT2;
2362                 break;
2363         case FILE_EXT2_Synchronous:
2364                 if (strcmp(name, "Synchronous") == 0)
2365                         xar->xmlsts = FILE_EXT2;
2366                 break;
2367         case FILE_EXT2_Immutable:
2368                 if (strcmp(name, "Immutable") == 0)
2369                         xar->xmlsts = FILE_EXT2;
2370                 break;
2371         case FILE_EXT2_AppendOnly:
2372                 if (strcmp(name, "AppendOnly") == 0)
2373                         xar->xmlsts = FILE_EXT2;
2374                 break;
2375         case FILE_EXT2_NoDump:
2376                 if (strcmp(name, "NoDump") == 0)
2377                         xar->xmlsts = FILE_EXT2;
2378                 break;
2379         case FILE_EXT2_NoAtime:
2380                 if (strcmp(name, "NoAtime") == 0)
2381                         xar->xmlsts = FILE_EXT2;
2382                 break;
2383         case FILE_EXT2_CompDirty:
2384                 if (strcmp(name, "CompDirty") == 0)
2385                         xar->xmlsts = FILE_EXT2;
2386                 break;
2387         case FILE_EXT2_CompBlock:
2388                 if (strcmp(name, "CompBlock") == 0)
2389                         xar->xmlsts = FILE_EXT2;
2390                 break;
2391         case FILE_EXT2_NoCompBlock:
2392                 if (strcmp(name, "NoCompBlock") == 0)
2393                         xar->xmlsts = FILE_EXT2;
2394                 break;
2395         case FILE_EXT2_CompError:
2396                 if (strcmp(name, "CompError") == 0)
2397                         xar->xmlsts = FILE_EXT2;
2398                 break;
2399         case FILE_EXT2_BTree:
2400                 if (strcmp(name, "BTree") == 0)
2401                         xar->xmlsts = FILE_EXT2;
2402                 break;
2403         case FILE_EXT2_HashIndexed:
2404                 if (strcmp(name, "HashIndexed") == 0)
2405                         xar->xmlsts = FILE_EXT2;
2406                 break;
2407         case FILE_EXT2_iMagic:
2408                 if (strcmp(name, "iMagic") == 0)
2409                         xar->xmlsts = FILE_EXT2;
2410                 break;
2411         case FILE_EXT2_Journaled:
2412                 if (strcmp(name, "Journaled") == 0)
2413                         xar->xmlsts = FILE_EXT2;
2414                 break;
2415         case FILE_EXT2_NoTail:
2416                 if (strcmp(name, "NoTail") == 0)
2417                         xar->xmlsts = FILE_EXT2;
2418                 break;
2419         case FILE_EXT2_DirSync:
2420                 if (strcmp(name, "DirSync") == 0)
2421                         xar->xmlsts = FILE_EXT2;
2422                 break;
2423         case FILE_EXT2_TopDir:
2424                 if (strcmp(name, "TopDir") == 0)
2425                         xar->xmlsts = FILE_EXT2;
2426                 break;
2427         case FILE_EXT2_Reserved:
2428                 if (strcmp(name, "Reserved") == 0)
2429                         xar->xmlsts = FILE_EXT2;
2430                 break;
2431         case UNKNOWN:
2432                 unknowntag_end(xar, name);
2433                 break;
2434         }
2435 }
2436
2437 static const int base64[256] = {
2438         -1, -1, -1, -1, -1, -1, -1, -1,
2439         -1, -1, -1, -1, -1, -1, -1, -1, /* 00 - 0F */
2440         -1, -1, -1, -1, -1, -1, -1, -1,
2441         -1, -1, -1, -1, -1, -1, -1, -1, /* 10 - 1F */
2442         -1, -1, -1, -1, -1, -1, -1, -1,
2443         -1, -1, -1, 62, -1, -1, -1, 63, /* 20 - 2F */
2444         52, 53, 54, 55, 56, 57, 58, 59,
2445         60, 61, -1, -1, -1, -1, -1, -1, /* 30 - 3F */
2446         -1,  0,  1,  2,  3,  4,  5,  6,
2447          7,  8,  9, 10, 11, 12, 13, 14, /* 40 - 4F */
2448         15, 16, 17, 18, 19, 20, 21, 22,
2449         23, 24, 25, -1, -1, -1, -1, -1, /* 50 - 5F */
2450         -1, 26, 27, 28, 29, 30, 31, 32,
2451         33, 34, 35, 36, 37, 38, 39, 40, /* 60 - 6F */
2452         41, 42, 43, 44, 45, 46, 47, 48,
2453         49, 50, 51, -1, -1, -1, -1, -1, /* 70 - 7F */
2454         -1, -1, -1, -1, -1, -1, -1, -1,
2455         -1, -1, -1, -1, -1, -1, -1, -1, /* 80 - 8F */
2456         -1, -1, -1, -1, -1, -1, -1, -1,
2457         -1, -1, -1, -1, -1, -1, -1, -1, /* 90 - 9F */
2458         -1, -1, -1, -1, -1, -1, -1, -1,
2459         -1, -1, -1, -1, -1, -1, -1, -1, /* A0 - AF */
2460         -1, -1, -1, -1, -1, -1, -1, -1,
2461         -1, -1, -1, -1, -1, -1, -1, -1, /* B0 - BF */
2462         -1, -1, -1, -1, -1, -1, -1, -1,
2463         -1, -1, -1, -1, -1, -1, -1, -1, /* C0 - CF */
2464         -1, -1, -1, -1, -1, -1, -1, -1,
2465         -1, -1, -1, -1, -1, -1, -1, -1, /* D0 - DF */
2466         -1, -1, -1, -1, -1, -1, -1, -1,
2467         -1, -1, -1, -1, -1, -1, -1, -1, /* E0 - EF */
2468         -1, -1, -1, -1, -1, -1, -1, -1,
2469         -1, -1, -1, -1, -1, -1, -1, -1, /* F0 - FF */
2470 };
2471
2472 static void
2473 strappend_base64(struct archive_string *as, const char *s, size_t l)
2474 {
2475         unsigned char buff[256];
2476         unsigned char *out;
2477         const unsigned char *b;
2478         size_t len;
2479
2480         len = 0;
2481         out = buff;
2482         b = (const unsigned char *)s;
2483         while (l > 0) {
2484                 int n = 0;
2485
2486                 if (l > 0) {
2487                         if (base64[b[0]] < 0 || base64[b[1]] < 0)
2488                                 break;
2489                         n = base64[*b++] << 18;
2490                         n |= base64[*b++] << 12;
2491                         *out++ = n >> 16;
2492                         len++;
2493                         l -= 2;
2494                 }
2495                 if (l > 0) {
2496                         if (base64[*b] < 0)
2497                                 break;
2498                         n |= base64[*b++] << 6;
2499                         *out++ = (n >> 8) & 0xFF;
2500                         len++;
2501                         --l;
2502                 }
2503                 if (l > 0) {
2504                         if (base64[*b] < 0)
2505                                 break;
2506                         n |= base64[*b++];
2507                         *out++ = n & 0xFF;
2508                         len++;
2509                         --l;
2510                 }
2511                 if (len+3 >= sizeof(buff)) {
2512                         archive_strncat(as, (const char *)buff, len);
2513                         len = 0;
2514                         out = buff;
2515                 }
2516         }
2517         if (len > 0)
2518                 archive_strncat(as, (const char *)buff, len);
2519 }
2520
2521 static void
2522 xml_data(void *userData, const char *s, int len)
2523 {
2524         struct archive_read *a;
2525         struct xar *xar;
2526
2527         a = (struct archive_read *)userData;
2528         xar = (struct xar *)(a->format->data);
2529
2530 #if DEBUG
2531         {
2532                 char buff[1024];
2533                 if (len > sizeof(buff)-1)
2534                         len = sizeof(buff)-1;
2535                 memcpy(buff, s, len);
2536                 buff[len] = 0;
2537                 fprintf(stderr, "\tlen=%d:\"%s\"\n", len, buff);
2538         }
2539 #endif
2540         switch (xar->xmlsts) {
2541         case TOC_CHECKSUM_OFFSET:
2542                 xar->toc_chksum_offset = atol10(s, len);
2543                 break;
2544         case TOC_CHECKSUM_SIZE:
2545                 xar->toc_chksum_size = atol10(s, len);
2546                 break;
2547         default:
2548                 break;
2549         }
2550         if (xar->file == NULL)
2551                 return;
2552
2553         switch (xar->xmlsts) {
2554         case FILE_NAME:
2555                 if (xar->file->parent != NULL) {
2556                         archive_string_concat(&(xar->file->pathname),
2557                             &(xar->file->parent->pathname));
2558                         archive_strappend_char(&(xar->file->pathname), '/');
2559                 }
2560                 xar->file->has |= HAS_PATHNAME;
2561                 if (xar->base64text)
2562                         strappend_base64(&(xar->file->pathname), s, len);
2563                 else
2564                         archive_strncat(&(xar->file->pathname), s, len);
2565                 break;
2566         case FILE_LINK:
2567                 xar->file->has |= HAS_SYMLINK;
2568                 archive_strncpy(&(xar->file->symlink), s, len);
2569                 break;
2570         case FILE_TYPE:
2571                 if (strncmp("file", s, len) == 0 ||
2572                     strncmp("hardlink", s, len) == 0)
2573                         xar->file->mode =
2574                             (xar->file->mode & ~AE_IFMT) | AE_IFREG;
2575                 if (strncmp("directory", s, len) == 0)
2576                         xar->file->mode =
2577                             (xar->file->mode & ~AE_IFMT) | AE_IFDIR;
2578                 if (strncmp("symlink", s, len) == 0)
2579                         xar->file->mode =
2580                             (xar->file->mode & ~AE_IFMT) | AE_IFLNK;
2581                 if (strncmp("character special", s, len) == 0)
2582                         xar->file->mode =
2583                             (xar->file->mode & ~AE_IFMT) | AE_IFCHR;
2584                 if (strncmp("block special", s, len) == 0)
2585                         xar->file->mode =
2586                             (xar->file->mode & ~AE_IFMT) | AE_IFBLK;
2587                 if (strncmp("socket", s, len) == 0)
2588                         xar->file->mode =
2589                             (xar->file->mode & ~AE_IFMT) | AE_IFSOCK;
2590                 if (strncmp("fifo", s, len) == 0)
2591                         xar->file->mode =
2592                             (xar->file->mode & ~AE_IFMT) | AE_IFIFO;
2593                 xar->file->has |= HAS_TYPE;
2594                 break;
2595         case FILE_INODE:
2596                 xar->file->has |= HAS_INO;
2597                 xar->file->ino64 = atol10(s, len);
2598                 break;
2599         case FILE_DEVICE_MAJOR:
2600                 xar->file->has |= HAS_DEVMAJOR;
2601                 xar->file->devmajor = (dev_t)atol10(s, len);
2602                 break;
2603         case FILE_DEVICE_MINOR:
2604                 xar->file->has |= HAS_DEVMINOR;
2605                 xar->file->devminor = (dev_t)atol10(s, len);
2606                 break;
2607         case FILE_DEVICENO:
2608                 xar->file->has |= HAS_DEV;
2609                 xar->file->dev = (dev_t)atol10(s, len);
2610                 break;
2611         case FILE_MODE:
2612                 xar->file->has |= HAS_MODE;
2613                 xar->file->mode =
2614                     (xar->file->mode & AE_IFMT) |
2615                     (atol8(s, len) & ~AE_IFMT);
2616                 break;
2617         case FILE_GROUP:
2618                 xar->file->has |= HAS_GID;
2619                 archive_strncpy(&(xar->file->gname), s, len);
2620                 break;
2621         case FILE_GID:
2622                 xar->file->has |= HAS_GID;
2623                 xar->file->gid = atol10(s, len);
2624                 break;
2625         case FILE_USER:
2626                 xar->file->has |= HAS_UID;
2627                 archive_strncpy(&(xar->file->uname), s, len);
2628                 break;
2629         case FILE_UID:
2630                 xar->file->has |= HAS_UID;
2631                 xar->file->uid = atol10(s, len);
2632                 break;
2633         case FILE_CTIME:
2634                 xar->file->has |= HAS_TIME;
2635                 xar->file->ctime = parse_time(s, len);
2636                 break;
2637         case FILE_MTIME:
2638                 xar->file->has |= HAS_TIME;
2639                 xar->file->mtime = parse_time(s, len);
2640                 break;
2641         case FILE_ATIME:
2642                 xar->file->has |= HAS_TIME;
2643                 xar->file->atime = parse_time(s, len);
2644                 break;
2645         case FILE_DATA_LENGTH:
2646                 xar->file->has |= HAS_DATA;
2647                 xar->file->length = atol10(s, len);
2648                 break;
2649         case FILE_DATA_OFFSET:
2650                 xar->file->has |= HAS_DATA;
2651                 xar->file->offset = atol10(s, len);
2652                 break;
2653         case FILE_DATA_SIZE:
2654                 xar->file->has |= HAS_DATA;
2655                 xar->file->size = atol10(s, len);
2656                 break;
2657         case FILE_DATA_A_CHECKSUM:
2658                 xar->file->a_sum.len = atohex(xar->file->a_sum.val,
2659                     sizeof(xar->file->a_sum.val), s, len);
2660                 break;
2661         case FILE_DATA_E_CHECKSUM:
2662                 xar->file->e_sum.len = atohex(xar->file->e_sum.val,
2663                     sizeof(xar->file->e_sum.val), s, len);
2664                 break;
2665         case FILE_EA_LENGTH:
2666                 xar->file->has |= HAS_XATTR;
2667                 xar->xattr->length = atol10(s, len);
2668                 break;
2669         case FILE_EA_OFFSET:
2670                 xar->file->has |= HAS_XATTR;
2671                 xar->xattr->offset = atol10(s, len);
2672                 break;
2673         case FILE_EA_SIZE:
2674                 xar->file->has |= HAS_XATTR;
2675                 xar->xattr->size = atol10(s, len);
2676                 break;
2677         case FILE_EA_A_CHECKSUM:
2678                 xar->file->has |= HAS_XATTR;
2679                 xar->xattr->a_sum.len = atohex(xar->xattr->a_sum.val,
2680                     sizeof(xar->xattr->a_sum.val), s, len);
2681                 break;
2682         case FILE_EA_E_CHECKSUM:
2683                 xar->file->has |= HAS_XATTR;
2684                 xar->xattr->e_sum.len = atohex(xar->xattr->e_sum.val,
2685                     sizeof(xar->xattr->e_sum.val), s, len);
2686                 break;
2687         case FILE_EA_NAME:
2688                 xar->file->has |= HAS_XATTR;
2689                 archive_strncpy(&(xar->xattr->name), s, len);
2690                 break;
2691         case FILE_EA_FSTYPE:
2692                 xar->file->has |= HAS_XATTR;
2693                 archive_strncpy(&(xar->xattr->fstype), s, len);
2694                 break;
2695                 break;
2696         case FILE_ACL_DEFAULT:
2697         case FILE_ACL_ACCESS:
2698         case FILE_ACL_APPLEEXTENDED:
2699                 xar->file->has |= HAS_ACL;
2700                 /* TODO */
2701                 break;
2702         case INIT:
2703         case XAR:
2704         case TOC:
2705         case TOC_CREATION_TIME:
2706         case TOC_CHECKSUM:
2707         case TOC_CHECKSUM_OFFSET:
2708         case TOC_CHECKSUM_SIZE:
2709         case TOC_FILE:
2710         case FILE_DATA:
2711         case FILE_DATA_ENCODING:
2712         case FILE_DATA_CONTENT:
2713         case FILE_DEVICE:
2714         case FILE_EA:
2715         case FILE_EA_ENCODING:
2716         case FILE_ACL:
2717         case FILE_FLAGS:
2718         case FILE_FLAGS_USER_NODUMP:
2719         case FILE_FLAGS_USER_IMMUTABLE:
2720         case FILE_FLAGS_USER_APPEND:
2721         case FILE_FLAGS_USER_OPAQUE:
2722         case FILE_FLAGS_USER_NOUNLINK:
2723         case FILE_FLAGS_SYS_ARCHIVED:
2724         case FILE_FLAGS_SYS_IMMUTABLE:
2725         case FILE_FLAGS_SYS_APPEND:
2726         case FILE_FLAGS_SYS_NOUNLINK:
2727         case FILE_FLAGS_SYS_SNAPSHOT:
2728         case FILE_EXT2:
2729         case FILE_EXT2_SecureDeletion:
2730         case FILE_EXT2_Undelete:
2731         case FILE_EXT2_Compress:
2732         case FILE_EXT2_Synchronous:
2733         case FILE_EXT2_Immutable:
2734         case FILE_EXT2_AppendOnly:
2735         case FILE_EXT2_NoDump:
2736         case FILE_EXT2_NoAtime:
2737         case FILE_EXT2_CompDirty:
2738         case FILE_EXT2_CompBlock:
2739         case FILE_EXT2_NoCompBlock:
2740         case FILE_EXT2_CompError:
2741         case FILE_EXT2_BTree:
2742         case FILE_EXT2_HashIndexed:
2743         case FILE_EXT2_iMagic:
2744         case FILE_EXT2_Journaled:
2745         case FILE_EXT2_NoTail:
2746         case FILE_EXT2_DirSync:
2747         case FILE_EXT2_TopDir:
2748         case FILE_EXT2_Reserved:
2749         case UNKNOWN:
2750                 break;
2751         }
2752 }
2753
2754 /*
2755  * BSD file flags.
2756  */
2757 static int
2758 xml_parse_file_flags(struct xar *xar, const char *name)
2759 {
2760         const char *flag = NULL;
2761
2762         if (strcmp(name, "UserNoDump") == 0) {
2763                 xar->xmlsts = FILE_FLAGS_USER_NODUMP;
2764                 flag = "nodump";
2765         }
2766         else if (strcmp(name, "UserImmutable") == 0) {
2767                 xar->xmlsts = FILE_FLAGS_USER_IMMUTABLE;
2768                 flag = "uimmutable";
2769         }
2770         else if (strcmp(name, "UserAppend") == 0) {
2771                 xar->xmlsts = FILE_FLAGS_USER_APPEND;
2772                 flag = "uappend";
2773         }
2774         else if (strcmp(name, "UserOpaque") == 0) {
2775                 xar->xmlsts = FILE_FLAGS_USER_OPAQUE;
2776                 flag = "opaque";
2777         }
2778         else if (strcmp(name, "UserNoUnlink") == 0) {
2779                 xar->xmlsts = FILE_FLAGS_USER_NOUNLINK;
2780                 flag = "nouunlink";
2781         }
2782         else if (strcmp(name, "SystemArchived") == 0) {
2783                 xar->xmlsts = FILE_FLAGS_SYS_ARCHIVED;
2784                 flag = "archived";
2785         }
2786         else if (strcmp(name, "SystemImmutable") == 0) {
2787                 xar->xmlsts = FILE_FLAGS_SYS_IMMUTABLE;
2788                 flag = "simmutable";
2789         }
2790         else if (strcmp(name, "SystemAppend") == 0) {
2791                 xar->xmlsts = FILE_FLAGS_SYS_APPEND;
2792                 flag = "sappend";
2793         }
2794         else if (strcmp(name, "SystemNoUnlink") == 0) {
2795                 xar->xmlsts = FILE_FLAGS_SYS_NOUNLINK;
2796                 flag = "nosunlink";
2797         }
2798         else if (strcmp(name, "SystemSnapshot") == 0) {
2799                 xar->xmlsts = FILE_FLAGS_SYS_SNAPSHOT;
2800                 flag = "snapshot";
2801         }
2802
2803         if (flag == NULL)
2804                 return (0);
2805         xar->file->has |= HAS_FFLAGS;
2806         if (archive_strlen(&(xar->file->fflags_text)) > 0)
2807                 archive_strappend_char(&(xar->file->fflags_text), ',');
2808         archive_strcat(&(xar->file->fflags_text), flag);
2809         return (1);
2810 }
2811
2812 /*
2813  * Linux file flags.
2814  */
2815 static int
2816 xml_parse_file_ext2(struct xar *xar, const char *name)
2817 {
2818         const char *flag = NULL;
2819
2820         if (strcmp(name, "SecureDeletion") == 0) {
2821                 xar->xmlsts = FILE_EXT2_SecureDeletion;
2822                 flag = "securedeletion";
2823         }
2824         else if (strcmp(name, "Undelete") == 0) {
2825                 xar->xmlsts = FILE_EXT2_Undelete;
2826                 flag = "nouunlink";
2827         }
2828         else if (strcmp(name, "Compress") == 0) {
2829                 xar->xmlsts = FILE_EXT2_Compress;
2830                 flag = "compress";
2831         }
2832         else if (strcmp(name, "Synchronous") == 0) {
2833                 xar->xmlsts = FILE_EXT2_Synchronous;
2834                 flag = "sync";
2835         }
2836         else if (strcmp(name, "Immutable") == 0) {
2837                 xar->xmlsts = FILE_EXT2_Immutable;
2838                 flag = "simmutable";
2839         }
2840         else if (strcmp(name, "AppendOnly") == 0) {
2841                 xar->xmlsts = FILE_EXT2_AppendOnly;
2842                 flag = "sappend";
2843         }
2844         else if (strcmp(name, "NoDump") == 0) {
2845                 xar->xmlsts = FILE_EXT2_NoDump;
2846                 flag = "nodump";
2847         }
2848         else if (strcmp(name, "NoAtime") == 0) {
2849                 xar->xmlsts = FILE_EXT2_NoAtime;
2850                 flag = "noatime";
2851         }
2852         else if (strcmp(name, "CompDirty") == 0) {
2853                 xar->xmlsts = FILE_EXT2_CompDirty;
2854                 flag = "compdirty";
2855         }
2856         else if (strcmp(name, "CompBlock") == 0) {
2857                 xar->xmlsts = FILE_EXT2_CompBlock;
2858                 flag = "comprblk";
2859         }
2860         else if (strcmp(name, "NoCompBlock") == 0) {
2861                 xar->xmlsts = FILE_EXT2_NoCompBlock;
2862                 flag = "nocomprblk";
2863         }
2864         else if (strcmp(name, "CompError") == 0) {
2865                 xar->xmlsts = FILE_EXT2_CompError;
2866                 flag = "comperr";
2867         }
2868         else if (strcmp(name, "BTree") == 0) {
2869                 xar->xmlsts = FILE_EXT2_BTree;
2870                 flag = "btree";
2871         }
2872         else if (strcmp(name, "HashIndexed") == 0) {
2873                 xar->xmlsts = FILE_EXT2_HashIndexed;
2874                 flag = "hashidx";
2875         }
2876         else if (strcmp(name, "iMagic") == 0) {
2877                 xar->xmlsts = FILE_EXT2_iMagic;
2878                 flag = "imagic";
2879         }
2880         else if (strcmp(name, "Journaled") == 0) {
2881                 xar->xmlsts = FILE_EXT2_Journaled;
2882                 flag = "journal";
2883         }
2884         else if (strcmp(name, "NoTail") == 0) {
2885                 xar->xmlsts = FILE_EXT2_NoTail;
2886                 flag = "notail";
2887         }
2888         else if (strcmp(name, "DirSync") == 0) {
2889                 xar->xmlsts = FILE_EXT2_DirSync;
2890                 flag = "dirsync";
2891         }
2892         else if (strcmp(name, "TopDir") == 0) {
2893                 xar->xmlsts = FILE_EXT2_TopDir;
2894                 flag = "topdir";
2895         }
2896         else if (strcmp(name, "Reserved") == 0) {
2897                 xar->xmlsts = FILE_EXT2_Reserved;
2898                 flag = "reserved";
2899         }
2900
2901         if (flag == NULL)
2902                 return (0);
2903         if (archive_strlen(&(xar->file->fflags_text)) > 0)
2904                 archive_strappend_char(&(xar->file->fflags_text), ',');
2905         archive_strcat(&(xar->file->fflags_text), flag);
2906         return (1);
2907 }
2908
2909 #ifdef HAVE_LIBXML_XMLREADER_H
2910
2911 static int
2912 xml2_xmlattr_setup(struct xmlattr_list *list, xmlTextReaderPtr reader)
2913 {
2914         struct xmlattr *attr;
2915         int r;
2916
2917         list->first = NULL;
2918         list->last = &(list->first);
2919         r = xmlTextReaderMoveToFirstAttribute(reader);
2920         while (r == 1) {
2921                 attr = malloc(sizeof*(attr));
2922                 if (attr == NULL)
2923                         __archive_errx(1, "Out of memory");
2924                 attr->name = strdup(
2925                     (const char *)xmlTextReaderConstLocalName(reader));
2926                 if (attr->name == NULL)
2927                         __archive_errx(1, "Out of memory");
2928                 attr->value = strdup(
2929                     (const char *)xmlTextReaderConstValue(reader));
2930                 if (attr->value == NULL)
2931                         __archive_errx(1, "Out of memory");
2932                 attr->next = NULL;
2933                 *list->last = attr;
2934                 list->last = &(attr->next);
2935                 r = xmlTextReaderMoveToNextAttribute(reader);
2936         }
2937         return (r);
2938 }
2939
2940 static int
2941 xml2_read_cb(void *context, char *buffer, int len)
2942 {
2943         struct archive_read *a;
2944         struct xar *xar;
2945         const void *d;
2946         size_t outbytes;
2947         size_t used;
2948         int r;
2949
2950         a = (struct archive_read *)context;
2951         xar = (struct xar *)(a->format->data);
2952
2953         if (xar->toc_remaining <= 0)
2954                 return (0);
2955         d = buffer;
2956         outbytes = len;
2957         r = rd_contents(a, &d, &outbytes, &used, xar->toc_remaining);
2958         if (r != ARCHIVE_OK)
2959                 return (r);
2960         __archive_read_consume(a, used);
2961         xar->toc_remaining -= used;
2962         xar->offset += used;
2963         xar->toc_total += outbytes;
2964         PRINT_TOC(buffer, len);
2965
2966         return ((int)outbytes);
2967 }
2968
2969 static int
2970 xml2_close_cb(void *context)
2971 {
2972
2973         (void)context; /* UNUSED */
2974         return (0);
2975 }
2976
2977 static void
2978 xml2_error_hdr(void *arg, const char *msg, xmlParserSeverities severity,
2979     xmlTextReaderLocatorPtr locator)
2980 {
2981         struct archive_read *a;
2982
2983         (void)locator; /* UNUSED */
2984         a = (struct archive_read *)arg;
2985         switch (severity) {
2986         case XML_PARSER_SEVERITY_VALIDITY_WARNING:
2987         case XML_PARSER_SEVERITY_WARNING:
2988                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2989                     "XML Parsing error: %s", msg);
2990                 break;
2991         case XML_PARSER_SEVERITY_VALIDITY_ERROR:
2992         case XML_PARSER_SEVERITY_ERROR:
2993                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2994                     "XML Parsing error: %s", msg);
2995                 break;
2996         }
2997 }
2998
2999 static int
3000 xml2_read_toc(struct archive_read *a)
3001 {
3002         xmlTextReaderPtr reader;
3003         struct xmlattr_list list;
3004         int r;
3005
3006         reader = xmlReaderForIO(xml2_read_cb, xml2_close_cb, a, NULL, NULL, 0);
3007         if (reader == NULL) {
3008                 archive_set_error(&a->archive, ENOMEM,
3009                     "Couldn't allocate memory for xml parser");
3010                 return (ARCHIVE_FATAL);
3011         }
3012         xmlTextReaderSetErrorHandler(reader, xml2_error_hdr, a);
3013
3014         while ((r = xmlTextReaderRead(reader)) == 1) {
3015                 const char *name, *value;
3016                 int type, empty;
3017
3018                 type = xmlTextReaderNodeType(reader);
3019                 name = (const char *)xmlTextReaderConstLocalName(reader);
3020                 switch (type) {
3021                 case XML_READER_TYPE_ELEMENT:
3022                         empty = xmlTextReaderIsEmptyElement(reader);
3023                         r = xml2_xmlattr_setup(&list, reader);
3024                         if (r == 0) {
3025                                 xml_start(a, name, &list);
3026                                 xmlattr_cleanup(&list);
3027                                 if (empty)
3028                                         xml_end(a, name);
3029                         }
3030                         break;
3031                 case XML_READER_TYPE_END_ELEMENT:
3032                         xml_end(a, name);
3033                         break;
3034                 case XML_READER_TYPE_TEXT:
3035                         value = (const char *)xmlTextReaderConstValue(reader);
3036                         xml_data(a, value, strlen(value));
3037                         break;
3038                 case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
3039                 default:
3040                         break;
3041                 }
3042                 if (r < 0)
3043                         break;
3044         }
3045         xmlFreeTextReader(reader);
3046         xmlCleanupParser();
3047
3048         return ((r == 0)?ARCHIVE_OK:ARCHIVE_FATAL);
3049 }
3050
3051 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
3052
3053 static void
3054 expat_xmlattr_setup(struct xmlattr_list *list, const XML_Char **atts)
3055 {
3056         struct xmlattr *attr;
3057
3058         list->first = NULL;
3059         list->last = &(list->first);
3060         if (atts == NULL)
3061                 return;
3062         while (atts[0] != NULL && atts[1] != NULL) {
3063                 attr = malloc(sizeof*(attr));
3064                 if (attr == NULL)
3065                         __archive_errx(1, "Out of memory");
3066                 attr->name = strdup(atts[0]);
3067                 if (attr->name == NULL)
3068                         __archive_errx(1, "Out of memory");
3069                 attr->value = strdup(atts[1]);
3070                 if (attr->value == NULL)
3071                         __archive_errx(1, "Out of memory");
3072                 attr->next = NULL;
3073                 *list->last = attr;
3074                 list->last = &(attr->next);
3075                 atts += 2;
3076         }
3077 }
3078
3079 static void
3080 expat_start_cb(void *userData, const XML_Char *name, const XML_Char **atts)
3081 {
3082         struct xmlattr_list list;
3083
3084         expat_xmlattr_setup(&list, atts);
3085         xml_start(userData, (const char *)name, &list);
3086         xmlattr_cleanup(&list);
3087 }
3088
3089 static void
3090 expat_end_cb(void *userData, const XML_Char *name)
3091 {
3092         xml_end(userData, (const char *)name);
3093 }
3094
3095 static void
3096 expat_data_cb(void *userData, const XML_Char *s, int len)
3097 {
3098         xml_data(userData, s, len);
3099 }
3100
3101 static int
3102 expat_read_toc(struct archive_read *a)
3103 {
3104         struct xar *xar;
3105         XML_Parser parser;
3106
3107         xar = (struct xar *)(a->format->data);
3108
3109         /* Initialize XML Parser library. */
3110         parser = XML_ParserCreate(NULL);
3111         if (parser == NULL) {
3112                 archive_set_error(&a->archive, ENOMEM,
3113                     "Couldn't allocate memory for xml parser");
3114                 return (ARCHIVE_FATAL);
3115         }
3116         XML_SetUserData(parser, a);
3117         XML_SetElementHandler(parser, expat_start_cb, expat_end_cb);
3118         XML_SetCharacterDataHandler(parser, expat_data_cb);
3119         xar->xmlsts = INIT;
3120
3121         while (xar->toc_remaining) {
3122                 enum XML_Status xr;
3123                 const void *d;
3124                 size_t outbytes;
3125                 size_t used;
3126                 int r;
3127
3128                 d = NULL;
3129                 r = rd_contents(a, &d, &outbytes, &used, xar->toc_remaining);
3130                 if (r != ARCHIVE_OK)
3131                         return (r);
3132                 __archive_read_consume(a, used);
3133                 xar->toc_remaining -= used;
3134                 xar->offset += used;
3135                 xar->toc_total += outbytes;
3136                 PRINT_TOC(d, outbytes);
3137
3138                 xr = XML_Parse(parser, d, outbytes, xar->toc_remaining == 0);
3139                 if (xr == XML_STATUS_ERROR) {
3140                         XML_ParserFree(parser);
3141                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3142                             "XML Parsing failed");
3143                         return (ARCHIVE_FATAL);
3144                 }
3145         }
3146         XML_ParserFree(parser);
3147         return (ARCHIVE_OK);
3148 }
3149 #endif /* defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H) */
3150
3151 #endif /* Support xar format */