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