2 * Copyright (c) 2009 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
25 #include "archive_platform.h"
26 __FBSDID("$FreeBSD$");
34 #if HAVE_LIBXML_XMLREADER_H
35 #include <libxml/xmlreader.h>
54 #include "archive_crypto_private.h"
55 #include "archive_endian.h"
56 #include "archive_entry.h"
57 #include "archive_entry_locale.h"
58 #include "archive_private.h"
59 #include "archive_read_private.h"
61 #if (!defined(HAVE_LIBXML_XMLREADER_H) && \
62 !defined(HAVE_BSDXML_H) && !defined(HAVE_EXPAT_H)) ||\
63 !defined(HAVE_ZLIB_H) || \
64 !defined(ARCHIVE_HAS_MD5) || !defined(ARCHIVE_HAS_SHA1)
66 * xar needs several external libraries.
67 * o libxml2 or expat --- XML parser
68 * o openssl or MD5/SHA1 hash function
74 archive_read_support_format_xar(struct archive *_a)
76 struct archive_read *a = (struct archive_read *)_a;
77 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
78 ARCHIVE_STATE_NEW, "archive_read_support_format_xar");
80 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
81 "Xar not supported on this platform");
82 return (ARCHIVE_WARN);
85 #else /* Support xar format */
88 /* #define DEBUG_PRINT_TOC 1 */
90 #define PRINT_TOC(d, outbytes) do { \
91 unsigned char *x = (unsigned char *)(uintptr_t)d; \
92 unsigned char c = x[outbytes-1]; \
93 x[outbytes - 1] = 0; \
94 fprintf(stderr, "%s", x); \
95 fprintf(stderr, "%c", c); \
96 x[outbytes - 1] = c; \
99 #define PRINT_TOC(d, outbytes)
102 #define HEADER_MAGIC 0x78617221
103 #define HEADER_SIZE 28
104 #define HEADER_VERSION 1
111 #define MAX_SUM_SIZE 20
124 unsigned char val[MAX_SUM_SIZE];
129 #ifdef ARCHIVE_HAS_MD5
130 archive_md5_ctx md5ctx;
132 #ifdef ARCHIVE_HAS_SHA1
133 archive_sha1_ctx sha1ctx;
139 struct archive_string name;
144 enum enctype encoding;
145 struct chksumval a_sum;
146 struct chksumval e_sum;
147 struct archive_string fstype;
151 struct xar_file *next;
152 struct xar_file *hdnext;
153 struct xar_file *parent;
157 #define HAS_DATA 0x00001
158 #define HAS_PATHNAME 0x00002
159 #define HAS_SYMLINK 0x00004
160 #define HAS_TIME 0x00008
161 #define HAS_UID 0x00010
162 #define HAS_GID 0x00020
163 #define HAS_MODE 0x00040
164 #define HAS_TYPE 0x00080
165 #define HAS_DEV 0x00100
166 #define HAS_DEVMAJOR 0x00200
167 #define HAS_DEVMINOR 0x00400
168 #define HAS_INO 0x00800
169 #define HAS_FFLAGS 0x01000
170 #define HAS_XATTR 0x02000
171 #define HAS_ACL 0x04000
177 enum enctype encoding;
178 struct chksumval a_sum;
179 struct chksumval e_sum;
180 struct archive_string pathname;
181 struct archive_string symlink;
185 struct archive_string uname;
187 struct archive_string gname;
194 struct archive_string fflags_text;
197 struct archive_string hardlink;
198 struct xattr *xattr_list;
206 struct xar_file *files;
210 struct xar_file **files;
229 FILE_DATA_A_CHECKSUM,
230 FILE_DATA_E_CHECKSUM,
260 FILE_ACL_APPLEEXTENDED,
261 /* BSD file flags. */
263 FILE_FLAGS_USER_NODUMP,
264 FILE_FLAGS_USER_IMMUTABLE,
265 FILE_FLAGS_USER_APPEND,
266 FILE_FLAGS_USER_OPAQUE,
267 FILE_FLAGS_USER_NOUNLINK,
268 FILE_FLAGS_SYS_ARCHIVED,
269 FILE_FLAGS_SYS_IMMUTABLE,
270 FILE_FLAGS_SYS_APPEND,
271 FILE_FLAGS_SYS_NOUNLINK,
272 FILE_FLAGS_SYS_SNAPSHOT,
273 /* Linux file flags. */
275 FILE_EXT2_SecureDeletion,
278 FILE_EXT2_Synchronous,
280 FILE_EXT2_AppendOnly,
285 FILE_EXT2_NoCompBlock,
288 FILE_EXT2_HashIndexed,
299 struct unknown_tag *next;
300 struct archive_string name;
304 uint64_t offset; /* Current position in the file. */
308 #define OUTBUFF_SIZE (1024 * 64)
309 unsigned char *outbuff;
311 enum xmlstatus xmlsts;
312 enum xmlstatus xmlsts_unknown;
313 struct unknown_tag *unknowntags;
319 uint64_t toc_remaining;
321 uint64_t toc_chksum_offset;
322 uint64_t toc_chksum_size;
327 enum enctype rd_encoding;
330 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
334 #if HAVE_LZMA_H && HAVE_LIBLZMA
335 lzma_stream lzstream;
337 #elif HAVE_LZMADEC_H && HAVE_LIBLZMADEC
338 lzmadec_stream lzstream;
344 struct chksumwork a_sumwrk;
345 struct chksumwork e_sumwrk;
347 struct xar_file *file; /* current reading file. */
348 struct xattr *xattr; /* current reading extended attribute. */
349 struct heap_queue file_queue;
350 struct xar_file *hdlink_orgs;
351 struct hdlink *hdlink_list;
354 uint64_t entry_total;
355 uint64_t entry_remaining;
356 size_t entry_unconsumed;
358 enum enctype entry_encoding;
359 struct chksumval entry_a_sum;
360 struct chksumval entry_e_sum;
362 struct archive_string_conv *sconv;
366 struct xmlattr *next;
371 struct xmlattr_list {
372 struct xmlattr *first;
373 struct xmlattr **last;
376 static int xar_bid(struct archive_read *, int);
377 static int xar_read_header(struct archive_read *,
378 struct archive_entry *);
379 static int xar_read_data(struct archive_read *,
380 const void **, size_t *, int64_t *);
381 static int xar_read_data_skip(struct archive_read *);
382 static int xar_cleanup(struct archive_read *);
383 static int move_reading_point(struct archive_read *, uint64_t);
384 static int rd_contents_init(struct archive_read *,
385 enum enctype, int, int);
386 static int rd_contents(struct archive_read *, const void **,
387 size_t *, size_t *, uint64_t);
388 static uint64_t atol10(const char *, size_t);
389 static int64_t atol8(const char *, size_t);
390 static size_t atohex(unsigned char *, size_t, const char *, size_t);
391 static time_t parse_time(const char *p, size_t n);
392 static int heap_add_entry(struct archive_read *a,
393 struct heap_queue *, struct xar_file *);
394 static struct xar_file *heap_get_entry(struct heap_queue *);
395 static int add_link(struct archive_read *,
396 struct xar *, struct xar_file *);
397 static void checksum_init(struct archive_read *, int, int);
398 static void checksum_update(struct archive_read *, const void *,
399 size_t, const void *, size_t);
400 static int checksum_final(struct archive_read *, const void *,
401 size_t, const void *, size_t);
402 static int decompression_init(struct archive_read *, enum enctype);
403 static int decompress(struct archive_read *, const void **,
404 size_t *, const void *, size_t *);
405 static int decompression_cleanup(struct archive_read *);
406 static void xmlattr_cleanup(struct xmlattr_list *);
407 static int file_new(struct archive_read *,
408 struct xar *, struct xmlattr_list *);
409 static void file_free(struct xar_file *);
410 static int xattr_new(struct archive_read *,
411 struct xar *, struct xmlattr_list *);
412 static void xattr_free(struct xattr *);
413 static int getencoding(struct xmlattr_list *);
414 static int getsumalgorithm(struct xmlattr_list *);
415 static int unknowntag_start(struct archive_read *,
416 struct xar *, const char *);
417 static void unknowntag_end(struct xar *, const char *);
418 static int xml_start(struct archive_read *,
419 const char *, struct xmlattr_list *);
420 static void xml_end(void *, const char *);
421 static void xml_data(void *, const char *, int);
422 static int xml_parse_file_flags(struct xar *, const char *);
423 static int xml_parse_file_ext2(struct xar *, const char *);
424 #if defined(HAVE_LIBXML_XMLREADER_H)
425 static int xml2_xmlattr_setup(struct archive_read *,
426 struct xmlattr_list *, xmlTextReaderPtr);
427 static int xml2_read_cb(void *, char *, int);
428 static int xml2_close_cb(void *);
429 static void xml2_error_hdr(void *, const char *, xmlParserSeverities,
430 xmlTextReaderLocatorPtr);
431 static int xml2_read_toc(struct archive_read *);
432 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
433 struct expat_userData {
435 struct archive_read *archive;
437 static int expat_xmlattr_setup(struct archive_read *,
438 struct xmlattr_list *, const XML_Char **);
439 static void expat_start_cb(void *, const XML_Char *, const XML_Char **);
440 static void expat_end_cb(void *, const XML_Char *);
441 static void expat_data_cb(void *, const XML_Char *, int);
442 static int expat_read_toc(struct archive_read *);
446 archive_read_support_format_xar(struct archive *_a)
449 struct archive_read *a = (struct archive_read *)_a;
452 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
453 ARCHIVE_STATE_NEW, "archive_read_support_format_xar");
455 xar = (struct xar *)calloc(1, sizeof(*xar));
457 archive_set_error(&a->archive, ENOMEM,
458 "Can't allocate xar data");
459 return (ARCHIVE_FATAL);
462 r = __archive_read_register_format(a,
478 xar_bid(struct archive_read *a, int best_bid)
480 const unsigned char *b;
483 (void)best_bid; /* UNUSED */
485 b = __archive_read_ahead(a, HEADER_SIZE, NULL);
493 if (archive_be32dec(b) != HEADER_MAGIC)
499 if (archive_be16dec(b+4) != HEADER_SIZE)
503 * Verify header version
505 if (archive_be16dec(b+6) != HEADER_VERSION)
509 * Verify type of checksum
511 switch (archive_be32dec(b+24)) {
525 read_toc(struct archive_read *a)
528 struct xar_file *file;
529 const unsigned char *b;
530 uint64_t toc_compressed_size;
531 uint64_t toc_uncompressed_size;
532 uint32_t toc_chksum_alg;
536 xar = (struct xar *)(a->format->data);
541 b = __archive_read_ahead(a, HEADER_SIZE, &bytes);
544 if (bytes < HEADER_SIZE) {
545 archive_set_error(&a->archive,
546 ARCHIVE_ERRNO_FILE_FORMAT,
547 "Truncated archive header");
548 return (ARCHIVE_FATAL);
551 if (archive_be32dec(b) != HEADER_MAGIC) {
552 archive_set_error(&a->archive,
553 ARCHIVE_ERRNO_FILE_FORMAT,
554 "Invalid header magic");
555 return (ARCHIVE_FATAL);
557 if (archive_be16dec(b+6) != HEADER_VERSION) {
558 archive_set_error(&a->archive,
559 ARCHIVE_ERRNO_FILE_FORMAT,
560 "Unsupported header version(%d)",
561 archive_be16dec(b+6));
562 return (ARCHIVE_FATAL);
564 toc_compressed_size = archive_be64dec(b+8);
565 xar->toc_remaining = toc_compressed_size;
566 toc_uncompressed_size = archive_be64dec(b+16);
567 toc_chksum_alg = archive_be32dec(b+24);
568 __archive_read_consume(a, HEADER_SIZE);
569 xar->offset += HEADER_SIZE;
573 * Read TOC(Table of Contents).
575 /* Initialize reading contents. */
576 r = move_reading_point(a, HEADER_SIZE);
579 r = rd_contents_init(a, GZIP, toc_chksum_alg, CKSUM_NONE);
583 #ifdef HAVE_LIBXML_XMLREADER_H
584 r = xml2_read_toc(a);
585 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
586 r = expat_read_toc(a);
591 /* Set 'The HEAP' base. */
592 xar->h_base = xar->offset;
593 if (xar->toc_total != toc_uncompressed_size) {
594 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
595 "TOC uncompressed size error");
596 return (ARCHIVE_FATAL);
602 if (toc_chksum_alg != CKSUM_NONE) {
603 r = move_reading_point(a, xar->toc_chksum_offset);
606 b = __archive_read_ahead(a,
607 (size_t)xar->toc_chksum_size, &bytes);
610 if ((uint64_t)bytes < xar->toc_chksum_size) {
611 archive_set_error(&a->archive,
612 ARCHIVE_ERRNO_FILE_FORMAT,
613 "Truncated archive file");
614 return (ARCHIVE_FATAL);
616 r = checksum_final(a, b,
617 (size_t)xar->toc_chksum_size, NULL, 0);
618 __archive_read_consume(a, xar->toc_chksum_size);
619 xar->offset += xar->toc_chksum_size;
621 return (ARCHIVE_FATAL);
625 * Connect hardlinked files.
627 for (file = xar->hdlink_orgs; file != NULL; file = file->hdnext) {
628 struct hdlink **hdlink;
630 for (hdlink = &(xar->hdlink_list); *hdlink != NULL;
631 hdlink = &((*hdlink)->next)) {
632 if ((*hdlink)->id == file->id) {
633 struct hdlink *hltmp;
635 int nlink = (*hdlink)->cnt + 1;
638 for (f2 = (*hdlink)->files; f2 != NULL;
642 &(f2->hardlink), &(file->pathname));
644 /* Remove resolved files from hdlist_list. */
646 *hdlink = hltmp->next;
652 a->archive.archive_format = ARCHIVE_FORMAT_XAR;
653 a->archive.archive_format_name = "xar";
659 xar_read_header(struct archive_read *a, struct archive_entry *entry)
662 struct xar_file *file;
666 xar = (struct xar *)(a->format->data);
669 if (xar->offset == 0) {
670 /* Create a character conversion object. */
671 if (xar->sconv == NULL) {
672 xar->sconv = archive_string_conversion_from_charset(
673 &(a->archive), "UTF-8", 1);
674 if (xar->sconv == NULL)
675 return (ARCHIVE_FATAL);
685 file = xar->file = heap_get_entry(&(xar->file_queue));
687 xar->end_of_file = 1;
688 return (ARCHIVE_EOF);
690 if ((file->mode & AE_IFMT) != AE_IFDIR)
692 if (file->has != (HAS_PATHNAME | HAS_TYPE))
695 * If a file type is a directory and it does not have
696 * any metadata, do not export.
700 archive_entry_set_atime(entry, file->atime, 0);
701 archive_entry_set_ctime(entry, file->ctime, 0);
702 archive_entry_set_mtime(entry, file->mtime, 0);
703 archive_entry_set_gid(entry, file->gid);
704 if (file->gname.length > 0 &&
705 archive_entry_copy_gname_l(entry, file->gname.s,
706 archive_strlen(&(file->gname)), xar->sconv) != 0) {
707 if (errno == ENOMEM) {
708 archive_set_error(&a->archive, ENOMEM,
709 "Can't allocate memory for Gname");
710 return (ARCHIVE_FATAL);
712 archive_set_error(&a->archive,
713 ARCHIVE_ERRNO_FILE_FORMAT,
714 "Gname cannot be converted from %s to current locale.",
715 archive_string_conversion_charset_name(xar->sconv));
718 archive_entry_set_uid(entry, file->uid);
719 if (file->uname.length > 0 &&
720 archive_entry_copy_uname_l(entry, file->uname.s,
721 archive_strlen(&(file->uname)), xar->sconv) != 0) {
722 if (errno == ENOMEM) {
723 archive_set_error(&a->archive, ENOMEM,
724 "Can't allocate memory for Uname");
725 return (ARCHIVE_FATAL);
727 archive_set_error(&a->archive,
728 ARCHIVE_ERRNO_FILE_FORMAT,
729 "Uname cannot be converted from %s to current locale.",
730 archive_string_conversion_charset_name(xar->sconv));
733 archive_entry_set_mode(entry, file->mode);
734 if (archive_entry_copy_pathname_l(entry, file->pathname.s,
735 archive_strlen(&(file->pathname)), xar->sconv) != 0) {
736 if (errno == ENOMEM) {
737 archive_set_error(&a->archive, ENOMEM,
738 "Can't allocate memory for Pathname");
739 return (ARCHIVE_FATAL);
741 archive_set_error(&a->archive,
742 ARCHIVE_ERRNO_FILE_FORMAT,
743 "Pathname cannot be converted from %s to current locale.",
744 archive_string_conversion_charset_name(xar->sconv));
749 if (file->symlink.length > 0 &&
750 archive_entry_copy_symlink_l(entry, file->symlink.s,
751 archive_strlen(&(file->symlink)), xar->sconv) != 0) {
752 if (errno == ENOMEM) {
753 archive_set_error(&a->archive, ENOMEM,
754 "Can't allocate memory for Linkname");
755 return (ARCHIVE_FATAL);
757 archive_set_error(&a->archive,
758 ARCHIVE_ERRNO_FILE_FORMAT,
759 "Linkname cannot be converted from %s to current locale.",
760 archive_string_conversion_charset_name(xar->sconv));
763 /* Set proper nlink. */
764 if ((file->mode & AE_IFMT) == AE_IFDIR)
765 archive_entry_set_nlink(entry, file->subdirs + 2);
767 archive_entry_set_nlink(entry, file->nlink);
768 archive_entry_set_size(entry, file->size);
769 if (archive_strlen(&(file->hardlink)) > 0)
770 archive_entry_set_hardlink(entry, file->hardlink.s);
771 archive_entry_set_ino64(entry, file->ino64);
772 if (file->has & HAS_DEV)
773 archive_entry_set_dev(entry, file->dev);
774 if (file->has & HAS_DEVMAJOR)
775 archive_entry_set_devmajor(entry, file->devmajor);
776 if (file->has & HAS_DEVMINOR)
777 archive_entry_set_devminor(entry, file->devminor);
778 if (archive_strlen(&(file->fflags_text)) > 0)
779 archive_entry_copy_fflags_text(entry, file->fflags_text.s);
782 xar->entry_total = 0;
783 xar->entry_remaining = file->length;
784 xar->entry_size = file->size;
785 xar->entry_encoding = file->encoding;
786 xar->entry_a_sum = file->a_sum;
787 xar->entry_e_sum = file->e_sum;
789 * Read extended attributes.
791 xattr = file->xattr_list;
792 while (xattr != NULL) {
794 size_t outbytes, used;
796 r = move_reading_point(a, xattr->offset);
799 r = rd_contents_init(a, xattr->encoding,
800 xattr->a_sum.alg, xattr->e_sum.alg);
804 r = rd_contents(a, &d, &outbytes, &used, xattr->length);
807 if (outbytes != xattr->size) {
808 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
809 "Decompressed size error");
813 r = checksum_final(a,
814 xattr->a_sum.val, xattr->a_sum.len,
815 xattr->e_sum.val, xattr->e_sum.len);
818 archive_entry_xattr_add_entry(entry,
819 xattr->name.s, d, outbytes);
822 if (r != ARCHIVE_OK) {
827 if (xar->entry_remaining > 0)
828 /* Move reading point to the beginning of current
830 r = move_reading_point(a, file->offset);
839 xar_read_data(struct archive_read *a,
840 const void **buff, size_t *size, int64_t *offset)
846 xar = (struct xar *)(a->format->data);
848 if (xar->entry_unconsumed) {
849 __archive_read_consume(a, xar->entry_unconsumed);
850 xar->entry_unconsumed = 0;
853 if (xar->end_of_file || xar->entry_remaining <= 0) {
855 goto abort_read_data;
858 if (xar->entry_init) {
859 r = rd_contents_init(a, xar->entry_encoding,
860 xar->entry_a_sum.alg, xar->entry_e_sum.alg);
861 if (r != ARCHIVE_OK) {
862 xar->entry_remaining = 0;
869 r = rd_contents(a, buff, size, &used, xar->entry_remaining);
871 goto abort_read_data;
873 *offset = xar->entry_total;
874 xar->entry_total += *size;
877 xar->entry_remaining -= used;
878 xar->entry_unconsumed = used;
880 if (xar->entry_remaining == 0) {
881 if (xar->entry_total != xar->entry_size) {
882 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
883 "Decompressed size error");
885 goto abort_read_data;
887 r = checksum_final(a,
888 xar->entry_a_sum.val, xar->entry_a_sum.len,
889 xar->entry_e_sum.val, xar->entry_e_sum.len);
891 goto abort_read_data;
898 *offset = xar->total;
903 xar_read_data_skip(struct archive_read *a)
906 int64_t bytes_skipped;
908 xar = (struct xar *)(a->format->data);
909 if (xar->end_of_file)
910 return (ARCHIVE_EOF);
911 bytes_skipped = __archive_read_consume(a, xar->entry_remaining +
912 xar->entry_unconsumed);
913 if (bytes_skipped < 0)
914 return (ARCHIVE_FATAL);
915 xar->offset += bytes_skipped;
916 xar->entry_unconsumed = 0;
921 xar_cleanup(struct archive_read *a)
924 struct hdlink *hdlink;
928 xar = (struct xar *)(a->format->data);
929 r = decompression_cleanup(a);
930 hdlink = xar->hdlink_list;
931 while (hdlink != NULL) {
932 struct hdlink *next = hdlink->next;
937 for (i = 0; i < xar->file_queue.used; i++)
938 file_free(xar->file_queue.files[i]);
939 while (xar->unknowntags != NULL) {
940 struct unknown_tag *tag;
942 tag = xar->unknowntags;
943 xar->unknowntags = tag->next;
944 archive_string_free(&(tag->name));
949 a->format->data = NULL;
954 move_reading_point(struct archive_read *a, uint64_t offset)
958 xar = (struct xar *)(a->format->data);
959 if (xar->offset - xar->h_base != offset) {
960 /* Seek forward to the start of file contents. */
963 step = offset - (xar->offset - xar->h_base);
965 step = __archive_read_consume(a, step);
970 archive_set_error(&(a->archive),
973 return (ARCHIVE_FAILED);
980 rd_contents_init(struct archive_read *a, enum enctype encoding,
981 int a_sum_alg, int e_sum_alg)
985 /* Init decompress library. */
986 if ((r = decompression_init(a, encoding)) != ARCHIVE_OK)
988 /* Init checksum library. */
989 checksum_init(a, a_sum_alg, e_sum_alg);
994 rd_contents(struct archive_read *a, const void **buff, size_t *size,
995 size_t *used, uint64_t remaining)
997 const unsigned char *b;
1000 /* Get whatever bytes are immediately available. */
1001 b = __archive_read_ahead(a, 1, &bytes);
1003 return ((int)bytes);
1005 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1006 "Truncated archive file");
1007 return (ARCHIVE_FATAL);
1009 if ((uint64_t)bytes > remaining)
1010 bytes = (ssize_t)remaining;
1013 * Decompress contents of file.
1016 if (decompress(a, buff, size, b, used) != ARCHIVE_OK)
1017 return (ARCHIVE_FATAL);
1020 * Update checksum of a compressed data and a extracted data.
1022 checksum_update(a, b, *used, *buff, *size);
1024 return (ARCHIVE_OK);
1028 * Note that this implementation does not (and should not!) obey
1029 * locale settings; you cannot simply substitute strtol here, since
1030 * it does obey locale.
1034 atol10(const char *p, size_t char_cnt)
1041 while (digit >= 0 && digit < 10 && char_cnt-- > 0) {
1042 l = (l * 10) + digit;
1049 atol8(const char *p, size_t char_cnt)
1055 while (char_cnt-- > 0) {
1056 if (*p >= '0' && *p <= '7')
1068 atohex(unsigned char *b, size_t bsize, const char *p, size_t psize)
1070 size_t fbsize = bsize;
1072 while (bsize && psize > 1) {
1075 if (p[0] >= 'a' && p[0] <= 'z')
1076 x = (p[0] - 'a' + 0x0a) << 4;
1077 else if (p[0] >= 'A' && p[0] <= 'Z')
1078 x = (p[0] - 'A' + 0x0a) << 4;
1079 else if (p[0] >= '0' && p[0] <= '9')
1080 x = (p[0] - '0') << 4;
1083 if (p[1] >= 'a' && p[1] <= 'z')
1084 x |= p[1] - 'a' + 0x0a;
1085 else if (p[1] >= 'A' && p[1] <= 'Z')
1086 x |= p[1] - 'A' + 0x0a;
1087 else if (p[1] >= '0' && p[1] <= '9')
1097 return (fbsize - bsize);
1101 time_from_tm(struct tm *t)
1104 /* Use platform timegm() if available. */
1106 #elif HAVE__MKGMTIME64
1107 return (_mkgmtime64(t));
1109 /* Else use direct calculation using POSIX assumptions. */
1110 /* First, fix up tm_yday based on the year/month/day. */
1112 /* Then we can compute timegm() from first principles. */
1113 return (t->tm_sec + t->tm_min * 60 + t->tm_hour * 3600
1114 + t->tm_yday * 86400 + (t->tm_year - 70) * 31536000
1115 + ((t->tm_year - 69) / 4) * 86400 -
1116 ((t->tm_year - 1) / 100) * 86400
1117 + ((t->tm_year + 299) / 400) * 86400);
1122 parse_time(const char *p, size_t n)
1128 memset(&tm, 0, sizeof(tm));
1131 data = atol10(p, 4);
1134 tm.tm_year = (int)data - 1900;
1138 data = atol10(p, 2);
1139 if (data < 1 || data > 12)
1141 tm.tm_mon = (int)data -1;
1145 data = atol10(p, 2);
1146 if (data < 1 || data > 31)
1148 tm.tm_mday = (int)data;
1152 data = atol10(p, 2);
1153 if (data < 0 || data > 23)
1155 tm.tm_hour = (int)data;
1159 data = atol10(p, 2);
1160 if (data < 0 || data > 59)
1162 tm.tm_min = (int)data;
1166 data = atol10(p, 2);
1167 if (data < 0 || data > 60)
1169 tm.tm_sec = (int)data;
1176 t = time_from_tm(&tm);
1182 heap_add_entry(struct archive_read *a,
1183 struct heap_queue *heap, struct xar_file *file)
1185 uint64_t file_id, parent_id;
1188 /* Expand our pending files list as necessary. */
1189 if (heap->used >= heap->allocated) {
1190 struct xar_file **new_pending_files;
1191 int new_size = heap->allocated * 2;
1193 if (heap->allocated < 1024)
1195 /* Overflow might keep us from growing the list. */
1196 if (new_size <= heap->allocated) {
1197 archive_set_error(&a->archive,
1198 ENOMEM, "Out of memory");
1199 return (ARCHIVE_FATAL);
1201 new_pending_files = (struct xar_file **)
1202 malloc(new_size * sizeof(new_pending_files[0]));
1203 if (new_pending_files == NULL) {
1204 archive_set_error(&a->archive,
1205 ENOMEM, "Out of memory");
1206 return (ARCHIVE_FATAL);
1208 memcpy(new_pending_files, heap->files,
1209 heap->allocated * sizeof(new_pending_files[0]));
1210 if (heap->files != NULL)
1212 heap->files = new_pending_files;
1213 heap->allocated = new_size;
1219 * Start with hole at end, walk it up tree to find insertion point.
1221 hole = heap->used++;
1223 parent = (hole - 1)/2;
1224 parent_id = heap->files[parent]->id;
1225 if (file_id >= parent_id) {
1226 heap->files[hole] = file;
1227 return (ARCHIVE_OK);
1229 /* Move parent into hole <==> move hole up tree. */
1230 heap->files[hole] = heap->files[parent];
1233 heap->files[0] = file;
1235 return (ARCHIVE_OK);
1238 static struct xar_file *
1239 heap_get_entry(struct heap_queue *heap)
1241 uint64_t a_id, b_id, c_id;
1243 struct xar_file *r, *tmp;
1249 * The first file in the list is the earliest; we'll return this.
1254 * Move the last item in the heap to the root of the tree
1256 heap->files[0] = heap->files[--(heap->used)];
1259 * Rebalance the heap.
1261 a = 0; /* Starting element and its heap key */
1262 a_id = heap->files[a]->id;
1264 b = a + a + 1; /* First child */
1265 if (b >= heap->used)
1267 b_id = heap->files[b]->id;
1268 c = b + 1; /* Use second child if it is smaller. */
1269 if (c < heap->used) {
1270 c_id = heap->files[c]->id;
1278 tmp = heap->files[a];
1279 heap->files[a] = heap->files[b];
1280 heap->files[b] = tmp;
1286 add_link(struct archive_read *a, struct xar *xar, struct xar_file *file)
1288 struct hdlink *hdlink;
1290 for (hdlink = xar->hdlink_list; hdlink != NULL; hdlink = hdlink->next) {
1291 if (hdlink->id == file->link) {
1292 file->hdnext = hdlink->files;
1294 hdlink->files = file;
1295 return (ARCHIVE_OK);
1298 hdlink = malloc(sizeof(*hdlink));
1299 if (hdlink == NULL) {
1300 archive_set_error(&a->archive, ENOMEM, "Out of memory");
1301 return (ARCHIVE_FATAL);
1303 file->hdnext = NULL;
1304 hdlink->id = file->link;
1306 hdlink->files = file;
1307 hdlink->next = xar->hdlink_list;
1308 xar->hdlink_list = hdlink;
1309 return (ARCHIVE_OK);
1313 _checksum_init(struct chksumwork *sumwrk, int sum_alg)
1315 sumwrk->alg = sum_alg;
1320 archive_sha1_init(&(sumwrk->sha1ctx));
1323 archive_md5_init(&(sumwrk->md5ctx));
1329 _checksum_update(struct chksumwork *sumwrk, const void *buff, size_t size)
1332 switch (sumwrk->alg) {
1336 archive_sha1_update(&(sumwrk->sha1ctx), buff, size);
1339 archive_md5_update(&(sumwrk->md5ctx), buff, size);
1345 _checksum_final(struct chksumwork *sumwrk, const void *val, size_t len)
1347 unsigned char sum[MAX_SUM_SIZE];
1350 switch (sumwrk->alg) {
1354 archive_sha1_final(&(sumwrk->sha1ctx), sum);
1355 if (len != SHA1_SIZE ||
1356 memcmp(val, sum, SHA1_SIZE) != 0)
1360 archive_md5_final(&(sumwrk->md5ctx), sum);
1361 if (len != MD5_SIZE ||
1362 memcmp(val, sum, MD5_SIZE) != 0)
1370 checksum_init(struct archive_read *a, int a_sum_alg, int e_sum_alg)
1374 xar = (struct xar *)(a->format->data);
1375 _checksum_init(&(xar->a_sumwrk), a_sum_alg);
1376 _checksum_init(&(xar->e_sumwrk), e_sum_alg);
1380 checksum_update(struct archive_read *a, const void *abuff, size_t asize,
1381 const void *ebuff, size_t esize)
1385 xar = (struct xar *)(a->format->data);
1386 _checksum_update(&(xar->a_sumwrk), abuff, asize);
1387 _checksum_update(&(xar->e_sumwrk), ebuff, esize);
1391 checksum_final(struct archive_read *a, const void *a_sum_val,
1392 size_t a_sum_len, const void *e_sum_val, size_t e_sum_len)
1397 xar = (struct xar *)(a->format->data);
1398 r = _checksum_final(&(xar->a_sumwrk), a_sum_val, a_sum_len);
1399 if (r == ARCHIVE_OK)
1400 r = _checksum_final(&(xar->e_sumwrk), e_sum_val, e_sum_len);
1401 if (r != ARCHIVE_OK)
1402 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
1408 decompression_init(struct archive_read *a, enum enctype encoding)
1414 xar = (struct xar *)(a->format->data);
1415 xar->rd_encoding = encoding;
1420 if (xar->stream_valid)
1421 r = inflateReset(&(xar->stream));
1423 r = inflateInit(&(xar->stream));
1425 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1426 "Couldn't initialize zlib stream.");
1427 return (ARCHIVE_FATAL);
1429 xar->stream_valid = 1;
1430 xar->stream.total_in = 0;
1431 xar->stream.total_out = 0;
1433 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1435 if (xar->bzstream_valid) {
1436 BZ2_bzDecompressEnd(&(xar->bzstream));
1437 xar->bzstream_valid = 0;
1439 r = BZ2_bzDecompressInit(&(xar->bzstream), 0, 0);
1440 if (r == BZ_MEM_ERROR)
1441 r = BZ2_bzDecompressInit(&(xar->bzstream), 0, 1);
1443 int err = ARCHIVE_ERRNO_MISC;
1446 case BZ_PARAM_ERROR:
1447 detail = "invalid setup parameter";
1451 detail = "out of memory";
1453 case BZ_CONFIG_ERROR:
1454 detail = "mis-compiled library";
1457 archive_set_error(&a->archive, err,
1458 "Internal error initializing decompressor: %s",
1459 detail == NULL ? "??" : detail);
1460 xar->bzstream_valid = 0;
1461 return (ARCHIVE_FATAL);
1463 xar->bzstream_valid = 1;
1464 xar->bzstream.total_in_lo32 = 0;
1465 xar->bzstream.total_in_hi32 = 0;
1466 xar->bzstream.total_out_lo32 = 0;
1467 xar->bzstream.total_out_hi32 = 0;
1470 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1471 #if LZMA_VERSION_MAJOR >= 5
1472 /* Effectively disable the limiter. */
1473 #define LZMA_MEMLIMIT UINT64_MAX
1475 /* NOTE: This needs to check memory size which running system has. */
1476 #define LZMA_MEMLIMIT (1U << 30)
1480 if (xar->lzstream_valid) {
1481 lzma_end(&(xar->lzstream));
1482 xar->lzstream_valid = 0;
1484 if (xar->entry_encoding == XZ)
1485 r = lzma_stream_decoder(&(xar->lzstream),
1486 LZMA_MEMLIMIT,/* memlimit */
1489 r = lzma_alone_decoder(&(xar->lzstream),
1490 LZMA_MEMLIMIT);/* memlimit */
1493 case LZMA_MEM_ERROR:
1494 archive_set_error(&a->archive,
1496 "Internal error initializing "
1497 "compression library: "
1498 "Cannot allocate memory");
1500 case LZMA_OPTIONS_ERROR:
1501 archive_set_error(&a->archive,
1503 "Internal error initializing "
1504 "compression library: "
1505 "Invalid or unsupported options");
1508 archive_set_error(&a->archive,
1510 "Internal error initializing "
1514 return (ARCHIVE_FATAL);
1516 xar->lzstream_valid = 1;
1517 xar->lzstream.total_in = 0;
1518 xar->lzstream.total_out = 0;
1520 #elif defined(HAVE_LZMADEC_H) && defined(HAVE_LIBLZMADEC)
1522 if (xar->lzstream_valid)
1523 lzmadec_end(&(xar->lzstream));
1524 r = lzmadec_init(&(xar->lzstream));
1525 if (r != LZMADEC_OK) {
1527 case LZMADEC_HEADER_ERROR:
1528 archive_set_error(&a->archive,
1530 "Internal error initializing "
1531 "compression library: "
1534 case LZMADEC_MEM_ERROR:
1535 archive_set_error(&a->archive,
1537 "Internal error initializing "
1538 "compression library: "
1542 return (ARCHIVE_FATAL);
1544 xar->lzstream_valid = 1;
1545 xar->lzstream.total_in = 0;
1546 xar->lzstream.total_out = 0;
1550 * Unsupported compression.
1553 #if !defined(HAVE_BZLIB_H) || !defined(BZ_CONFIG_ERROR)
1556 #if !defined(HAVE_LZMA_H) || !defined(HAVE_LIBLZMA)
1557 #if !defined(HAVE_LZMADEC_H) || !defined(HAVE_LIBLZMADEC)
1562 switch (xar->entry_encoding) {
1563 case BZIP2: detail = "bzip2"; break;
1564 case LZMA: detail = "lzma"; break;
1565 case XZ: detail = "xz"; break;
1566 default: detail = "??"; break;
1568 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1569 "%s compression not supported on this platform",
1571 return (ARCHIVE_FAILED);
1573 return (ARCHIVE_OK);
1577 decompress(struct archive_read *a, const void **buff, size_t *outbytes,
1578 const void *b, size_t *used)
1582 size_t avail_in, avail_out;
1585 xar = (struct xar *)(a->format->data);
1587 outbuff = (void *)(uintptr_t)*buff;
1588 if (outbuff == NULL) {
1589 if (xar->outbuff == NULL) {
1590 xar->outbuff = malloc(OUTBUFF_SIZE);
1591 if (xar->outbuff == NULL) {
1592 archive_set_error(&a->archive, ENOMEM,
1593 "Couldn't allocate memory for out buffer");
1594 return (ARCHIVE_FATAL);
1597 outbuff = xar->outbuff;
1599 avail_out = OUTBUFF_SIZE;
1601 avail_out = *outbytes;
1602 switch (xar->rd_encoding) {
1604 xar->stream.next_in = (Bytef *)(uintptr_t)b;
1605 xar->stream.avail_in = avail_in;
1606 xar->stream.next_out = (unsigned char *)outbuff;
1607 xar->stream.avail_out = avail_out;
1608 r = inflate(&(xar->stream), 0);
1610 case Z_OK: /* Decompressor made some progress.*/
1611 case Z_STREAM_END: /* Found end of stream. */
1614 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1615 "File decompression failed (%d)", r);
1616 return (ARCHIVE_FATAL);
1618 *used = avail_in - xar->stream.avail_in;
1619 *outbytes = avail_out - xar->stream.avail_out;
1621 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1623 xar->bzstream.next_in = (char *)(uintptr_t)b;
1624 xar->bzstream.avail_in = avail_in;
1625 xar->bzstream.next_out = (char *)outbuff;
1626 xar->bzstream.avail_out = avail_out;
1627 r = BZ2_bzDecompress(&(xar->bzstream));
1629 case BZ_STREAM_END: /* Found end of stream. */
1630 switch (BZ2_bzDecompressEnd(&(xar->bzstream))) {
1634 archive_set_error(&(a->archive),
1636 "Failed to clean up decompressor");
1637 return (ARCHIVE_FATAL);
1639 xar->bzstream_valid = 0;
1641 case BZ_OK: /* Decompressor made some progress. */
1644 archive_set_error(&(a->archive),
1646 "bzip decompression failed");
1647 return (ARCHIVE_FATAL);
1649 *used = avail_in - xar->bzstream.avail_in;
1650 *outbytes = avail_out - xar->bzstream.avail_out;
1653 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1656 xar->lzstream.next_in = b;
1657 xar->lzstream.avail_in = avail_in;
1658 xar->lzstream.next_out = (unsigned char *)outbuff;
1659 xar->lzstream.avail_out = avail_out;
1660 r = lzma_code(&(xar->lzstream), LZMA_RUN);
1662 case LZMA_STREAM_END: /* Found end of stream. */
1663 lzma_end(&(xar->lzstream));
1664 xar->lzstream_valid = 0;
1666 case LZMA_OK: /* Decompressor made some progress. */
1669 archive_set_error(&(a->archive),
1671 "%s decompression failed(%d)",
1672 (xar->entry_encoding == XZ)?"xz":"lzma",
1674 return (ARCHIVE_FATAL);
1676 *used = avail_in - xar->lzstream.avail_in;
1677 *outbytes = avail_out - xar->lzstream.avail_out;
1679 #elif defined(HAVE_LZMADEC_H) && defined(HAVE_LIBLZMADEC)
1681 xar->lzstream.next_in = (unsigned char *)(uintptr_t)b;
1682 xar->lzstream.avail_in = avail_in;
1683 xar->lzstream.next_out = (unsigned char *)outbuff;
1684 xar->lzstream.avail_out = avail_out;
1685 r = lzmadec_decode(&(xar->lzstream), 0);
1687 case LZMADEC_STREAM_END: /* Found end of stream. */
1688 switch (lzmadec_end(&(xar->lzstream))) {
1692 archive_set_error(&(a->archive),
1694 "Failed to clean up lzmadec decompressor");
1695 return (ARCHIVE_FATAL);
1697 xar->lzstream_valid = 0;
1699 case LZMADEC_OK: /* Decompressor made some progress. */
1702 archive_set_error(&(a->archive),
1704 "lzmadec decompression failed(%d)",
1706 return (ARCHIVE_FATAL);
1708 *used = avail_in - xar->lzstream.avail_in;
1709 *outbytes = avail_out - xar->lzstream.avail_out;
1712 #if !defined(HAVE_BZLIB_H) || !defined(BZ_CONFIG_ERROR)
1715 #if !defined(HAVE_LZMA_H) || !defined(HAVE_LIBLZMA)
1716 #if !defined(HAVE_LZMADEC_H) || !defined(HAVE_LIBLZMADEC)
1723 if (outbuff == xar->outbuff) {
1726 *outbytes = avail_in;
1728 if (avail_out > avail_in)
1729 avail_out = avail_in;
1730 memcpy(outbuff, b, avail_out);
1732 *outbytes = avail_out;
1736 return (ARCHIVE_OK);
1740 decompression_cleanup(struct archive_read *a)
1745 xar = (struct xar *)(a->format->data);
1747 if (xar->stream_valid) {
1748 if (inflateEnd(&(xar->stream)) != Z_OK) {
1749 archive_set_error(&a->archive,
1751 "Failed to clean up zlib decompressor");
1755 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1756 if (xar->bzstream_valid) {
1757 if (BZ2_bzDecompressEnd(&(xar->bzstream)) != BZ_OK) {
1758 archive_set_error(&a->archive,
1760 "Failed to clean up bzip2 decompressor");
1765 #if defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1766 if (xar->lzstream_valid)
1767 lzma_end(&(xar->lzstream));
1768 #elif defined(HAVE_LZMA_H) && defined(HAVE_LIBLZMA)
1769 if (xar->lzstream_valid) {
1770 if (lzmadec_end(&(xar->lzstream)) != LZMADEC_OK) {
1771 archive_set_error(&a->archive,
1773 "Failed to clean up lzmadec decompressor");
1782 xmlattr_cleanup(struct xmlattr_list *list)
1784 struct xmlattr *attr, *next;
1787 while (attr != NULL) {
1795 list->last = &(list->first);
1799 file_new(struct archive_read *a, struct xar *xar, struct xmlattr_list *list)
1801 struct xar_file *file;
1802 struct xmlattr *attr;
1804 file = calloc(1, sizeof(*file));
1806 archive_set_error(&a->archive, ENOMEM, "Out of memory");
1807 return (ARCHIVE_FATAL);
1809 file->parent = xar->file;
1810 file->mode = 0777 | AE_IFREG;
1811 file->atime = time(NULL);
1812 file->mtime = time(NULL);
1815 for (attr = list->first; attr != NULL; attr = attr->next) {
1816 if (strcmp(attr->name, "id") == 0)
1817 file->id = atol10(attr->value, strlen(attr->value));
1820 if (heap_add_entry(a, &(xar->file_queue), file) != ARCHIVE_OK)
1821 return (ARCHIVE_FATAL);
1822 return (ARCHIVE_OK);
1826 file_free(struct xar_file *file)
1828 struct xattr *xattr;
1830 archive_string_free(&(file->pathname));
1831 archive_string_free(&(file->symlink));
1832 archive_string_free(&(file->uname));
1833 archive_string_free(&(file->gname));
1834 archive_string_free(&(file->hardlink));
1835 xattr = file->xattr_list;
1836 while (xattr != NULL) {
1848 xattr_new(struct archive_read *a, struct xar *xar, struct xmlattr_list *list)
1850 struct xattr *xattr, **nx;
1851 struct xmlattr *attr;
1853 xattr = calloc(1, sizeof(*xattr));
1854 if (xattr == NULL) {
1855 archive_set_error(&a->archive, ENOMEM, "Out of memory");
1856 return (ARCHIVE_FATAL);
1859 for (attr = list->first; attr != NULL; attr = attr->next) {
1860 if (strcmp(attr->name, "id") == 0)
1861 xattr->id = atol10(attr->value, strlen(attr->value));
1863 /* Chain to xattr list. */
1864 for (nx = &(xar->file->xattr_list);
1865 *nx != NULL; nx = &((*nx)->next)) {
1866 if (xattr->id < (*nx)->id)
1872 return (ARCHIVE_OK);
1876 xattr_free(struct xattr *xattr)
1878 archive_string_free(&(xattr->name));
1883 getencoding(struct xmlattr_list *list)
1885 struct xmlattr *attr;
1886 enum enctype encoding = NONE;
1888 for (attr = list->first; attr != NULL; attr = attr->next) {
1889 if (strcmp(attr->name, "style") == 0) {
1890 if (strcmp(attr->value, "application/octet-stream") == 0)
1892 else if (strcmp(attr->value, "application/x-gzip") == 0)
1894 else if (strcmp(attr->value, "application/x-bzip2") == 0)
1896 else if (strcmp(attr->value, "application/x-lzma") == 0)
1898 else if (strcmp(attr->value, "application/x-xz") == 0)
1906 getsumalgorithm(struct xmlattr_list *list)
1908 struct xmlattr *attr;
1909 int alg = CKSUM_NONE;
1911 for (attr = list->first; attr != NULL; attr = attr->next) {
1912 if (strcmp(attr->name, "style") == 0) {
1913 const char *v = attr->value;
1914 if ((v[0] == 'S' || v[0] == 's') &&
1915 (v[1] == 'H' || v[1] == 'h') &&
1916 (v[2] == 'A' || v[2] == 'a') &&
1917 v[3] == '1' && v[4] == '\0')
1919 if ((v[0] == 'M' || v[0] == 'm') &&
1920 (v[1] == 'D' || v[1] == 'd') &&
1921 v[2] == '5' && v[3] == '\0')
1929 unknowntag_start(struct archive_read *a, struct xar *xar, const char *name)
1931 struct unknown_tag *tag;
1934 fprintf(stderr, "unknowntag_start:%s\n", name);
1936 tag = malloc(sizeof(*tag));
1938 archive_set_error(&a->archive, ENOMEM, "Out of memory");
1939 return (ARCHIVE_FATAL);
1941 tag->next = xar->unknowntags;
1942 archive_string_init(&(tag->name));
1943 archive_strcpy(&(tag->name), name);
1944 if (xar->unknowntags == NULL) {
1945 xar->xmlsts_unknown = xar->xmlsts;
1946 xar->xmlsts = UNKNOWN;
1948 xar->unknowntags = tag;
1949 return (ARCHIVE_OK);
1953 unknowntag_end(struct xar *xar, const char *name)
1955 struct unknown_tag *tag;
1958 fprintf(stderr, "unknowntag_end:%s\n", name);
1960 tag = xar->unknowntags;
1961 if (tag == NULL || name == NULL)
1963 if (strcmp(tag->name.s, name) == 0) {
1964 xar->unknowntags = tag->next;
1965 archive_string_free(&(tag->name));
1967 if (xar->unknowntags == NULL)
1968 xar->xmlsts = xar->xmlsts_unknown;
1973 xml_start(struct archive_read *a, const char *name, struct xmlattr_list *list)
1976 struct xmlattr *attr;
1978 xar = (struct xar *)(a->format->data);
1981 fprintf(stderr, "xml_sta:[%s]\n", name);
1982 for (attr = list->first; attr != NULL; attr = attr->next)
1983 fprintf(stderr, " attr:\"%s\"=\"%s\"\n",
1984 attr->name, attr->value);
1986 xar->base64text = 0;
1987 switch (xar->xmlsts) {
1989 if (strcmp(name, "xar") == 0)
1992 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
1993 return (ARCHIVE_FATAL);
1996 if (strcmp(name, "toc") == 0)
1999 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2000 return (ARCHIVE_FATAL);
2003 if (strcmp(name, "creation-time") == 0)
2004 xar->xmlsts = TOC_CREATION_TIME;
2005 else if (strcmp(name, "checksum") == 0)
2006 xar->xmlsts = TOC_CHECKSUM;
2007 else if (strcmp(name, "file") == 0) {
2008 if (file_new(a, xar, list) != ARCHIVE_OK)
2009 return (ARCHIVE_FATAL);
2010 xar->xmlsts = TOC_FILE;
2013 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2014 return (ARCHIVE_FATAL);
2017 if (strcmp(name, "offset") == 0)
2018 xar->xmlsts = TOC_CHECKSUM_OFFSET;
2019 else if (strcmp(name, "size") == 0)
2020 xar->xmlsts = TOC_CHECKSUM_SIZE;
2022 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2023 return (ARCHIVE_FATAL);
2026 if (strcmp(name, "file") == 0) {
2027 if (file_new(a, xar, list) != ARCHIVE_OK)
2028 return (ARCHIVE_FATAL);
2030 else if (strcmp(name, "data") == 0)
2031 xar->xmlsts = FILE_DATA;
2032 else if (strcmp(name, "ea") == 0) {
2033 if (xattr_new(a, xar, list) != ARCHIVE_OK)
2034 return (ARCHIVE_FATAL);
2035 xar->xmlsts = FILE_EA;
2037 else if (strcmp(name, "ctime") == 0)
2038 xar->xmlsts = FILE_CTIME;
2039 else if (strcmp(name, "mtime") == 0)
2040 xar->xmlsts = FILE_MTIME;
2041 else if (strcmp(name, "atime") == 0)
2042 xar->xmlsts = FILE_ATIME;
2043 else if (strcmp(name, "group") == 0)
2044 xar->xmlsts = FILE_GROUP;
2045 else if (strcmp(name, "gid") == 0)
2046 xar->xmlsts = FILE_GID;
2047 else if (strcmp(name, "user") == 0)
2048 xar->xmlsts = FILE_USER;
2049 else if (strcmp(name, "uid") == 0)
2050 xar->xmlsts = FILE_UID;
2051 else if (strcmp(name, "mode") == 0)
2052 xar->xmlsts = FILE_MODE;
2053 else if (strcmp(name, "device") == 0)
2054 xar->xmlsts = FILE_DEVICE;
2055 else if (strcmp(name, "deviceno") == 0)
2056 xar->xmlsts = FILE_DEVICENO;
2057 else if (strcmp(name, "inode") == 0)
2058 xar->xmlsts = FILE_INODE;
2059 else if (strcmp(name, "link") == 0)
2060 xar->xmlsts = FILE_LINK;
2061 else if (strcmp(name, "type") == 0) {
2062 xar->xmlsts = FILE_TYPE;
2063 for (attr = list->first; attr != NULL;
2064 attr = attr->next) {
2065 if (strcmp(attr->name, "link") != 0)
2067 if (strcmp(attr->value, "original") == 0) {
2068 xar->file->hdnext = xar->hdlink_orgs;
2069 xar->hdlink_orgs = xar->file;
2071 xar->file->link = (unsigned)atol10(attr->value,
2072 strlen(attr->value));
2073 if (xar->file->link > 0)
2074 if (add_link(a, xar, xar->file) != ARCHIVE_OK) {
2075 return (ARCHIVE_FATAL);
2080 else if (strcmp(name, "name") == 0) {
2081 xar->xmlsts = FILE_NAME;
2082 for (attr = list->first; attr != NULL;
2083 attr = attr->next) {
2084 if (strcmp(attr->name, "enctype") == 0 &&
2085 strcmp(attr->value, "base64") == 0)
2086 xar->base64text = 1;
2089 else if (strcmp(name, "acl") == 0)
2090 xar->xmlsts = FILE_ACL;
2091 else if (strcmp(name, "flags") == 0)
2092 xar->xmlsts = FILE_FLAGS;
2093 else if (strcmp(name, "ext2") == 0)
2094 xar->xmlsts = FILE_EXT2;
2096 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2097 return (ARCHIVE_FATAL);
2100 if (strcmp(name, "length") == 0)
2101 xar->xmlsts = FILE_DATA_LENGTH;
2102 else if (strcmp(name, "offset") == 0)
2103 xar->xmlsts = FILE_DATA_OFFSET;
2104 else if (strcmp(name, "size") == 0)
2105 xar->xmlsts = FILE_DATA_SIZE;
2106 else if (strcmp(name, "encoding") == 0) {
2107 xar->xmlsts = FILE_DATA_ENCODING;
2108 xar->file->encoding = getencoding(list);
2110 else if (strcmp(name, "archived-checksum") == 0) {
2111 xar->xmlsts = FILE_DATA_A_CHECKSUM;
2112 xar->file->a_sum.alg = getsumalgorithm(list);
2114 else if (strcmp(name, "extracted-checksum") == 0) {
2115 xar->xmlsts = FILE_DATA_E_CHECKSUM;
2116 xar->file->e_sum.alg = getsumalgorithm(list);
2118 else if (strcmp(name, "content") == 0)
2119 xar->xmlsts = FILE_DATA_CONTENT;
2121 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2122 return (ARCHIVE_FATAL);
2125 if (strcmp(name, "major") == 0)
2126 xar->xmlsts = FILE_DEVICE_MAJOR;
2127 else if (strcmp(name, "minor") == 0)
2128 xar->xmlsts = FILE_DEVICE_MINOR;
2130 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2131 return (ARCHIVE_FATAL);
2133 case FILE_DATA_CONTENT:
2134 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2135 return (ARCHIVE_FATAL);
2138 if (strcmp(name, "length") == 0)
2139 xar->xmlsts = FILE_EA_LENGTH;
2140 else if (strcmp(name, "offset") == 0)
2141 xar->xmlsts = FILE_EA_OFFSET;
2142 else if (strcmp(name, "size") == 0)
2143 xar->xmlsts = FILE_EA_SIZE;
2144 else if (strcmp(name, "encoding") == 0) {
2145 xar->xmlsts = FILE_EA_ENCODING;
2146 xar->xattr->encoding = getencoding(list);
2147 } else if (strcmp(name, "archived-checksum") == 0)
2148 xar->xmlsts = FILE_EA_A_CHECKSUM;
2149 else if (strcmp(name, "extracted-checksum") == 0)
2150 xar->xmlsts = FILE_EA_E_CHECKSUM;
2151 else if (strcmp(name, "name") == 0)
2152 xar->xmlsts = FILE_EA_NAME;
2153 else if (strcmp(name, "fstype") == 0)
2154 xar->xmlsts = FILE_EA_FSTYPE;
2156 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2157 return (ARCHIVE_FATAL);
2160 if (strcmp(name, "appleextended") == 0)
2161 xar->xmlsts = FILE_ACL_APPLEEXTENDED;
2162 if (strcmp(name, "default") == 0)
2163 xar->xmlsts = FILE_ACL_DEFAULT;
2164 else if (strcmp(name, "access") == 0)
2165 xar->xmlsts = FILE_ACL_ACCESS;
2167 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2168 return (ARCHIVE_FATAL);
2171 if (!xml_parse_file_flags(xar, name))
2172 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2173 return (ARCHIVE_FATAL);
2176 if (!xml_parse_file_ext2(xar, name))
2177 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2178 return (ARCHIVE_FATAL);
2180 case TOC_CREATION_TIME:
2181 case TOC_CHECKSUM_OFFSET:
2182 case TOC_CHECKSUM_SIZE:
2183 case FILE_DATA_LENGTH:
2184 case FILE_DATA_OFFSET:
2185 case FILE_DATA_SIZE:
2186 case FILE_DATA_ENCODING:
2187 case FILE_DATA_A_CHECKSUM:
2188 case FILE_DATA_E_CHECKSUM:
2189 case FILE_EA_LENGTH:
2190 case FILE_EA_OFFSET:
2192 case FILE_EA_ENCODING:
2193 case FILE_EA_A_CHECKSUM:
2194 case FILE_EA_E_CHECKSUM:
2196 case FILE_EA_FSTYPE:
2205 case FILE_DEVICE_MAJOR:
2206 case FILE_DEVICE_MINOR:
2212 case FILE_ACL_DEFAULT:
2213 case FILE_ACL_ACCESS:
2214 case FILE_ACL_APPLEEXTENDED:
2215 case FILE_FLAGS_USER_NODUMP:
2216 case FILE_FLAGS_USER_IMMUTABLE:
2217 case FILE_FLAGS_USER_APPEND:
2218 case FILE_FLAGS_USER_OPAQUE:
2219 case FILE_FLAGS_USER_NOUNLINK:
2220 case FILE_FLAGS_SYS_ARCHIVED:
2221 case FILE_FLAGS_SYS_IMMUTABLE:
2222 case FILE_FLAGS_SYS_APPEND:
2223 case FILE_FLAGS_SYS_NOUNLINK:
2224 case FILE_FLAGS_SYS_SNAPSHOT:
2225 case FILE_EXT2_SecureDeletion:
2226 case FILE_EXT2_Undelete:
2227 case FILE_EXT2_Compress:
2228 case FILE_EXT2_Synchronous:
2229 case FILE_EXT2_Immutable:
2230 case FILE_EXT2_AppendOnly:
2231 case FILE_EXT2_NoDump:
2232 case FILE_EXT2_NoAtime:
2233 case FILE_EXT2_CompDirty:
2234 case FILE_EXT2_CompBlock:
2235 case FILE_EXT2_NoCompBlock:
2236 case FILE_EXT2_CompError:
2237 case FILE_EXT2_BTree:
2238 case FILE_EXT2_HashIndexed:
2239 case FILE_EXT2_iMagic:
2240 case FILE_EXT2_Journaled:
2241 case FILE_EXT2_NoTail:
2242 case FILE_EXT2_DirSync:
2243 case FILE_EXT2_TopDir:
2244 case FILE_EXT2_Reserved:
2246 if (unknowntag_start(a, xar, name) != ARCHIVE_OK)
2247 return (ARCHIVE_FATAL);
2250 return (ARCHIVE_OK);
2254 xml_end(void *userData, const char *name)
2256 struct archive_read *a;
2259 a = (struct archive_read *)userData;
2260 xar = (struct xar *)(a->format->data);
2263 fprintf(stderr, "xml_end:[%s]\n", name);
2265 switch (xar->xmlsts) {
2269 if (strcmp(name, "xar") == 0)
2273 if (strcmp(name, "toc") == 0)
2276 case TOC_CREATION_TIME:
2277 if (strcmp(name, "creation-time") == 0)
2281 if (strcmp(name, "checksum") == 0)
2284 case TOC_CHECKSUM_OFFSET:
2285 if (strcmp(name, "offset") == 0)
2286 xar->xmlsts = TOC_CHECKSUM;
2288 case TOC_CHECKSUM_SIZE:
2289 if (strcmp(name, "size") == 0)
2290 xar->xmlsts = TOC_CHECKSUM;
2293 if (strcmp(name, "file") == 0) {
2294 if (xar->file->parent != NULL &&
2295 ((xar->file->mode & AE_IFMT) == AE_IFDIR))
2296 xar->file->parent->subdirs++;
2297 xar->file = xar->file->parent;
2298 if (xar->file == NULL)
2303 if (strcmp(name, "data") == 0)
2304 xar->xmlsts = TOC_FILE;
2306 case FILE_DATA_LENGTH:
2307 if (strcmp(name, "length") == 0)
2308 xar->xmlsts = FILE_DATA;
2310 case FILE_DATA_OFFSET:
2311 if (strcmp(name, "offset") == 0)
2312 xar->xmlsts = FILE_DATA;
2314 case FILE_DATA_SIZE:
2315 if (strcmp(name, "size") == 0)
2316 xar->xmlsts = FILE_DATA;
2318 case FILE_DATA_ENCODING:
2319 if (strcmp(name, "encoding") == 0)
2320 xar->xmlsts = FILE_DATA;
2322 case FILE_DATA_A_CHECKSUM:
2323 if (strcmp(name, "archived-checksum") == 0)
2324 xar->xmlsts = FILE_DATA;
2326 case FILE_DATA_E_CHECKSUM:
2327 if (strcmp(name, "extracted-checksum") == 0)
2328 xar->xmlsts = FILE_DATA;
2330 case FILE_DATA_CONTENT:
2331 if (strcmp(name, "content") == 0)
2332 xar->xmlsts = FILE_DATA;
2335 if (strcmp(name, "ea") == 0) {
2336 xar->xmlsts = TOC_FILE;
2340 case FILE_EA_LENGTH:
2341 if (strcmp(name, "length") == 0)
2342 xar->xmlsts = FILE_EA;
2344 case FILE_EA_OFFSET:
2345 if (strcmp(name, "offset") == 0)
2346 xar->xmlsts = FILE_EA;
2349 if (strcmp(name, "size") == 0)
2350 xar->xmlsts = FILE_EA;
2352 case FILE_EA_ENCODING:
2353 if (strcmp(name, "encoding") == 0)
2354 xar->xmlsts = FILE_EA;
2356 case FILE_EA_A_CHECKSUM:
2357 if (strcmp(name, "archived-checksum") == 0)
2358 xar->xmlsts = FILE_EA;
2360 case FILE_EA_E_CHECKSUM:
2361 if (strcmp(name, "extracted-checksum") == 0)
2362 xar->xmlsts = FILE_EA;
2365 if (strcmp(name, "name") == 0)
2366 xar->xmlsts = FILE_EA;
2368 case FILE_EA_FSTYPE:
2369 if (strcmp(name, "fstype") == 0)
2370 xar->xmlsts = FILE_EA;
2373 if (strcmp(name, "ctime") == 0)
2374 xar->xmlsts = TOC_FILE;
2377 if (strcmp(name, "mtime") == 0)
2378 xar->xmlsts = TOC_FILE;
2381 if (strcmp(name, "atime") == 0)
2382 xar->xmlsts = TOC_FILE;
2385 if (strcmp(name, "group") == 0)
2386 xar->xmlsts = TOC_FILE;
2389 if (strcmp(name, "gid") == 0)
2390 xar->xmlsts = TOC_FILE;
2393 if (strcmp(name, "user") == 0)
2394 xar->xmlsts = TOC_FILE;
2397 if (strcmp(name, "uid") == 0)
2398 xar->xmlsts = TOC_FILE;
2401 if (strcmp(name, "mode") == 0)
2402 xar->xmlsts = TOC_FILE;
2405 if (strcmp(name, "device") == 0)
2406 xar->xmlsts = TOC_FILE;
2408 case FILE_DEVICE_MAJOR:
2409 if (strcmp(name, "major") == 0)
2410 xar->xmlsts = FILE_DEVICE;
2412 case FILE_DEVICE_MINOR:
2413 if (strcmp(name, "minor") == 0)
2414 xar->xmlsts = FILE_DEVICE;
2417 if (strcmp(name, "deviceno") == 0)
2418 xar->xmlsts = TOC_FILE;
2421 if (strcmp(name, "inode") == 0)
2422 xar->xmlsts = TOC_FILE;
2425 if (strcmp(name, "link") == 0)
2426 xar->xmlsts = TOC_FILE;
2429 if (strcmp(name, "type") == 0)
2430 xar->xmlsts = TOC_FILE;
2433 if (strcmp(name, "name") == 0)
2434 xar->xmlsts = TOC_FILE;
2437 if (strcmp(name, "acl") == 0)
2438 xar->xmlsts = TOC_FILE;
2440 case FILE_ACL_DEFAULT:
2441 if (strcmp(name, "default") == 0)
2442 xar->xmlsts = FILE_ACL;
2444 case FILE_ACL_ACCESS:
2445 if (strcmp(name, "access") == 0)
2446 xar->xmlsts = FILE_ACL;
2448 case FILE_ACL_APPLEEXTENDED:
2449 if (strcmp(name, "appleextended") == 0)
2450 xar->xmlsts = FILE_ACL;
2453 if (strcmp(name, "flags") == 0)
2454 xar->xmlsts = TOC_FILE;
2456 case FILE_FLAGS_USER_NODUMP:
2457 if (strcmp(name, "UserNoDump") == 0)
2458 xar->xmlsts = FILE_FLAGS;
2460 case FILE_FLAGS_USER_IMMUTABLE:
2461 if (strcmp(name, "UserImmutable") == 0)
2462 xar->xmlsts = FILE_FLAGS;
2464 case FILE_FLAGS_USER_APPEND:
2465 if (strcmp(name, "UserAppend") == 0)
2466 xar->xmlsts = FILE_FLAGS;
2468 case FILE_FLAGS_USER_OPAQUE:
2469 if (strcmp(name, "UserOpaque") == 0)
2470 xar->xmlsts = FILE_FLAGS;
2472 case FILE_FLAGS_USER_NOUNLINK:
2473 if (strcmp(name, "UserNoUnlink") == 0)
2474 xar->xmlsts = FILE_FLAGS;
2476 case FILE_FLAGS_SYS_ARCHIVED:
2477 if (strcmp(name, "SystemArchived") == 0)
2478 xar->xmlsts = FILE_FLAGS;
2480 case FILE_FLAGS_SYS_IMMUTABLE:
2481 if (strcmp(name, "SystemImmutable") == 0)
2482 xar->xmlsts = FILE_FLAGS;
2484 case FILE_FLAGS_SYS_APPEND:
2485 if (strcmp(name, "SystemAppend") == 0)
2486 xar->xmlsts = FILE_FLAGS;
2488 case FILE_FLAGS_SYS_NOUNLINK:
2489 if (strcmp(name, "SystemNoUnlink") == 0)
2490 xar->xmlsts = FILE_FLAGS;
2492 case FILE_FLAGS_SYS_SNAPSHOT:
2493 if (strcmp(name, "SystemSnapshot") == 0)
2494 xar->xmlsts = FILE_FLAGS;
2497 if (strcmp(name, "ext2") == 0)
2498 xar->xmlsts = TOC_FILE;
2500 case FILE_EXT2_SecureDeletion:
2501 if (strcmp(name, "SecureDeletion") == 0)
2502 xar->xmlsts = FILE_EXT2;
2504 case FILE_EXT2_Undelete:
2505 if (strcmp(name, "Undelete") == 0)
2506 xar->xmlsts = FILE_EXT2;
2508 case FILE_EXT2_Compress:
2509 if (strcmp(name, "Compress") == 0)
2510 xar->xmlsts = FILE_EXT2;
2512 case FILE_EXT2_Synchronous:
2513 if (strcmp(name, "Synchronous") == 0)
2514 xar->xmlsts = FILE_EXT2;
2516 case FILE_EXT2_Immutable:
2517 if (strcmp(name, "Immutable") == 0)
2518 xar->xmlsts = FILE_EXT2;
2520 case FILE_EXT2_AppendOnly:
2521 if (strcmp(name, "AppendOnly") == 0)
2522 xar->xmlsts = FILE_EXT2;
2524 case FILE_EXT2_NoDump:
2525 if (strcmp(name, "NoDump") == 0)
2526 xar->xmlsts = FILE_EXT2;
2528 case FILE_EXT2_NoAtime:
2529 if (strcmp(name, "NoAtime") == 0)
2530 xar->xmlsts = FILE_EXT2;
2532 case FILE_EXT2_CompDirty:
2533 if (strcmp(name, "CompDirty") == 0)
2534 xar->xmlsts = FILE_EXT2;
2536 case FILE_EXT2_CompBlock:
2537 if (strcmp(name, "CompBlock") == 0)
2538 xar->xmlsts = FILE_EXT2;
2540 case FILE_EXT2_NoCompBlock:
2541 if (strcmp(name, "NoCompBlock") == 0)
2542 xar->xmlsts = FILE_EXT2;
2544 case FILE_EXT2_CompError:
2545 if (strcmp(name, "CompError") == 0)
2546 xar->xmlsts = FILE_EXT2;
2548 case FILE_EXT2_BTree:
2549 if (strcmp(name, "BTree") == 0)
2550 xar->xmlsts = FILE_EXT2;
2552 case FILE_EXT2_HashIndexed:
2553 if (strcmp(name, "HashIndexed") == 0)
2554 xar->xmlsts = FILE_EXT2;
2556 case FILE_EXT2_iMagic:
2557 if (strcmp(name, "iMagic") == 0)
2558 xar->xmlsts = FILE_EXT2;
2560 case FILE_EXT2_Journaled:
2561 if (strcmp(name, "Journaled") == 0)
2562 xar->xmlsts = FILE_EXT2;
2564 case FILE_EXT2_NoTail:
2565 if (strcmp(name, "NoTail") == 0)
2566 xar->xmlsts = FILE_EXT2;
2568 case FILE_EXT2_DirSync:
2569 if (strcmp(name, "DirSync") == 0)
2570 xar->xmlsts = FILE_EXT2;
2572 case FILE_EXT2_TopDir:
2573 if (strcmp(name, "TopDir") == 0)
2574 xar->xmlsts = FILE_EXT2;
2576 case FILE_EXT2_Reserved:
2577 if (strcmp(name, "Reserved") == 0)
2578 xar->xmlsts = FILE_EXT2;
2581 unknowntag_end(xar, name);
2586 static const int base64[256] = {
2587 -1, -1, -1, -1, -1, -1, -1, -1,
2588 -1, -1, -1, -1, -1, -1, -1, -1, /* 00 - 0F */
2589 -1, -1, -1, -1, -1, -1, -1, -1,
2590 -1, -1, -1, -1, -1, -1, -1, -1, /* 10 - 1F */
2591 -1, -1, -1, -1, -1, -1, -1, -1,
2592 -1, -1, -1, 62, -1, -1, -1, 63, /* 20 - 2F */
2593 52, 53, 54, 55, 56, 57, 58, 59,
2594 60, 61, -1, -1, -1, -1, -1, -1, /* 30 - 3F */
2595 -1, 0, 1, 2, 3, 4, 5, 6,
2596 7, 8, 9, 10, 11, 12, 13, 14, /* 40 - 4F */
2597 15, 16, 17, 18, 19, 20, 21, 22,
2598 23, 24, 25, -1, -1, -1, -1, -1, /* 50 - 5F */
2599 -1, 26, 27, 28, 29, 30, 31, 32,
2600 33, 34, 35, 36, 37, 38, 39, 40, /* 60 - 6F */
2601 41, 42, 43, 44, 45, 46, 47, 48,
2602 49, 50, 51, -1, -1, -1, -1, -1, /* 70 - 7F */
2603 -1, -1, -1, -1, -1, -1, -1, -1,
2604 -1, -1, -1, -1, -1, -1, -1, -1, /* 80 - 8F */
2605 -1, -1, -1, -1, -1, -1, -1, -1,
2606 -1, -1, -1, -1, -1, -1, -1, -1, /* 90 - 9F */
2607 -1, -1, -1, -1, -1, -1, -1, -1,
2608 -1, -1, -1, -1, -1, -1, -1, -1, /* A0 - AF */
2609 -1, -1, -1, -1, -1, -1, -1, -1,
2610 -1, -1, -1, -1, -1, -1, -1, -1, /* B0 - BF */
2611 -1, -1, -1, -1, -1, -1, -1, -1,
2612 -1, -1, -1, -1, -1, -1, -1, -1, /* C0 - CF */
2613 -1, -1, -1, -1, -1, -1, -1, -1,
2614 -1, -1, -1, -1, -1, -1, -1, -1, /* D0 - DF */
2615 -1, -1, -1, -1, -1, -1, -1, -1,
2616 -1, -1, -1, -1, -1, -1, -1, -1, /* E0 - EF */
2617 -1, -1, -1, -1, -1, -1, -1, -1,
2618 -1, -1, -1, -1, -1, -1, -1, -1, /* F0 - FF */
2622 strappend_base64(struct xar *xar,
2623 struct archive_string *as, const char *s, size_t l)
2625 unsigned char buff[256];
2627 const unsigned char *b;
2630 (void)xar; /* UNUSED */
2633 b = (const unsigned char *)s;
2638 if (base64[b[0]] < 0 || base64[b[1]] < 0)
2640 n = base64[*b++] << 18;
2641 n |= base64[*b++] << 12;
2649 n |= base64[*b++] << 6;
2650 *out++ = (n >> 8) & 0xFF;
2662 if (len+3 >= sizeof(buff)) {
2663 archive_strncat(as, (const char *)buff, len);
2669 archive_strncat(as, (const char *)buff, len);
2673 xml_data(void *userData, const char *s, int len)
2675 struct archive_read *a;
2678 a = (struct archive_read *)userData;
2679 xar = (struct xar *)(a->format->data);
2684 if (len > sizeof(buff)-1)
2685 len = sizeof(buff)-1;
2686 memcpy(buff, s, len);
2688 fprintf(stderr, "\tlen=%d:\"%s\"\n", len, buff);
2691 switch (xar->xmlsts) {
2692 case TOC_CHECKSUM_OFFSET:
2693 xar->toc_chksum_offset = atol10(s, len);
2695 case TOC_CHECKSUM_SIZE:
2696 xar->toc_chksum_size = atol10(s, len);
2701 if (xar->file == NULL)
2704 switch (xar->xmlsts) {
2706 if (xar->file->parent != NULL) {
2707 archive_string_concat(&(xar->file->pathname),
2708 &(xar->file->parent->pathname));
2709 archive_strappend_char(&(xar->file->pathname), '/');
2711 xar->file->has |= HAS_PATHNAME;
2712 if (xar->base64text) {
2713 strappend_base64(xar,
2714 &(xar->file->pathname), s, len);
2716 archive_strncat(&(xar->file->pathname), s, len);
2719 xar->file->has |= HAS_SYMLINK;
2720 archive_strncpy(&(xar->file->symlink), s, len);
2723 if (strncmp("file", s, len) == 0 ||
2724 strncmp("hardlink", s, len) == 0)
2726 (xar->file->mode & ~AE_IFMT) | AE_IFREG;
2727 if (strncmp("directory", s, len) == 0)
2729 (xar->file->mode & ~AE_IFMT) | AE_IFDIR;
2730 if (strncmp("symlink", s, len) == 0)
2732 (xar->file->mode & ~AE_IFMT) | AE_IFLNK;
2733 if (strncmp("character special", s, len) == 0)
2735 (xar->file->mode & ~AE_IFMT) | AE_IFCHR;
2736 if (strncmp("block special", s, len) == 0)
2738 (xar->file->mode & ~AE_IFMT) | AE_IFBLK;
2739 if (strncmp("socket", s, len) == 0)
2741 (xar->file->mode & ~AE_IFMT) | AE_IFSOCK;
2742 if (strncmp("fifo", s, len) == 0)
2744 (xar->file->mode & ~AE_IFMT) | AE_IFIFO;
2745 xar->file->has |= HAS_TYPE;
2748 xar->file->has |= HAS_INO;
2749 xar->file->ino64 = atol10(s, len);
2751 case FILE_DEVICE_MAJOR:
2752 xar->file->has |= HAS_DEVMAJOR;
2753 xar->file->devmajor = (dev_t)atol10(s, len);
2755 case FILE_DEVICE_MINOR:
2756 xar->file->has |= HAS_DEVMINOR;
2757 xar->file->devminor = (dev_t)atol10(s, len);
2760 xar->file->has |= HAS_DEV;
2761 xar->file->dev = (dev_t)atol10(s, len);
2764 xar->file->has |= HAS_MODE;
2766 (xar->file->mode & AE_IFMT) |
2767 ((mode_t)(atol8(s, len)) & ~AE_IFMT);
2770 xar->file->has |= HAS_GID;
2771 archive_strncpy(&(xar->file->gname), s, len);
2774 xar->file->has |= HAS_GID;
2775 xar->file->gid = atol10(s, len);
2778 xar->file->has |= HAS_UID;
2779 archive_strncpy(&(xar->file->uname), s, len);
2782 xar->file->has |= HAS_UID;
2783 xar->file->uid = atol10(s, len);
2786 xar->file->has |= HAS_TIME;
2787 xar->file->ctime = parse_time(s, len);
2790 xar->file->has |= HAS_TIME;
2791 xar->file->mtime = parse_time(s, len);
2794 xar->file->has |= HAS_TIME;
2795 xar->file->atime = parse_time(s, len);
2797 case FILE_DATA_LENGTH:
2798 xar->file->has |= HAS_DATA;
2799 xar->file->length = atol10(s, len);
2801 case FILE_DATA_OFFSET:
2802 xar->file->has |= HAS_DATA;
2803 xar->file->offset = atol10(s, len);
2805 case FILE_DATA_SIZE:
2806 xar->file->has |= HAS_DATA;
2807 xar->file->size = atol10(s, len);
2809 case FILE_DATA_A_CHECKSUM:
2810 xar->file->a_sum.len = atohex(xar->file->a_sum.val,
2811 sizeof(xar->file->a_sum.val), s, len);
2813 case FILE_DATA_E_CHECKSUM:
2814 xar->file->e_sum.len = atohex(xar->file->e_sum.val,
2815 sizeof(xar->file->e_sum.val), s, len);
2817 case FILE_EA_LENGTH:
2818 xar->file->has |= HAS_XATTR;
2819 xar->xattr->length = atol10(s, len);
2821 case FILE_EA_OFFSET:
2822 xar->file->has |= HAS_XATTR;
2823 xar->xattr->offset = atol10(s, len);
2826 xar->file->has |= HAS_XATTR;
2827 xar->xattr->size = atol10(s, len);
2829 case FILE_EA_A_CHECKSUM:
2830 xar->file->has |= HAS_XATTR;
2831 xar->xattr->a_sum.len = atohex(xar->xattr->a_sum.val,
2832 sizeof(xar->xattr->a_sum.val), s, len);
2834 case FILE_EA_E_CHECKSUM:
2835 xar->file->has |= HAS_XATTR;
2836 xar->xattr->e_sum.len = atohex(xar->xattr->e_sum.val,
2837 sizeof(xar->xattr->e_sum.val), s, len);
2840 xar->file->has |= HAS_XATTR;
2841 archive_strncpy(&(xar->xattr->name), s, len);
2843 case FILE_EA_FSTYPE:
2844 xar->file->has |= HAS_XATTR;
2845 archive_strncpy(&(xar->xattr->fstype), s, len);
2848 case FILE_ACL_DEFAULT:
2849 case FILE_ACL_ACCESS:
2850 case FILE_ACL_APPLEEXTENDED:
2851 xar->file->has |= HAS_ACL;
2857 case TOC_CREATION_TIME:
2859 case TOC_CHECKSUM_OFFSET:
2860 case TOC_CHECKSUM_SIZE:
2863 case FILE_DATA_ENCODING:
2864 case FILE_DATA_CONTENT:
2867 case FILE_EA_ENCODING:
2870 case FILE_FLAGS_USER_NODUMP:
2871 case FILE_FLAGS_USER_IMMUTABLE:
2872 case FILE_FLAGS_USER_APPEND:
2873 case FILE_FLAGS_USER_OPAQUE:
2874 case FILE_FLAGS_USER_NOUNLINK:
2875 case FILE_FLAGS_SYS_ARCHIVED:
2876 case FILE_FLAGS_SYS_IMMUTABLE:
2877 case FILE_FLAGS_SYS_APPEND:
2878 case FILE_FLAGS_SYS_NOUNLINK:
2879 case FILE_FLAGS_SYS_SNAPSHOT:
2881 case FILE_EXT2_SecureDeletion:
2882 case FILE_EXT2_Undelete:
2883 case FILE_EXT2_Compress:
2884 case FILE_EXT2_Synchronous:
2885 case FILE_EXT2_Immutable:
2886 case FILE_EXT2_AppendOnly:
2887 case FILE_EXT2_NoDump:
2888 case FILE_EXT2_NoAtime:
2889 case FILE_EXT2_CompDirty:
2890 case FILE_EXT2_CompBlock:
2891 case FILE_EXT2_NoCompBlock:
2892 case FILE_EXT2_CompError:
2893 case FILE_EXT2_BTree:
2894 case FILE_EXT2_HashIndexed:
2895 case FILE_EXT2_iMagic:
2896 case FILE_EXT2_Journaled:
2897 case FILE_EXT2_NoTail:
2898 case FILE_EXT2_DirSync:
2899 case FILE_EXT2_TopDir:
2900 case FILE_EXT2_Reserved:
2910 xml_parse_file_flags(struct xar *xar, const char *name)
2912 const char *flag = NULL;
2914 if (strcmp(name, "UserNoDump") == 0) {
2915 xar->xmlsts = FILE_FLAGS_USER_NODUMP;
2918 else if (strcmp(name, "UserImmutable") == 0) {
2919 xar->xmlsts = FILE_FLAGS_USER_IMMUTABLE;
2920 flag = "uimmutable";
2922 else if (strcmp(name, "UserAppend") == 0) {
2923 xar->xmlsts = FILE_FLAGS_USER_APPEND;
2926 else if (strcmp(name, "UserOpaque") == 0) {
2927 xar->xmlsts = FILE_FLAGS_USER_OPAQUE;
2930 else if (strcmp(name, "UserNoUnlink") == 0) {
2931 xar->xmlsts = FILE_FLAGS_USER_NOUNLINK;
2934 else if (strcmp(name, "SystemArchived") == 0) {
2935 xar->xmlsts = FILE_FLAGS_SYS_ARCHIVED;
2938 else if (strcmp(name, "SystemImmutable") == 0) {
2939 xar->xmlsts = FILE_FLAGS_SYS_IMMUTABLE;
2940 flag = "simmutable";
2942 else if (strcmp(name, "SystemAppend") == 0) {
2943 xar->xmlsts = FILE_FLAGS_SYS_APPEND;
2946 else if (strcmp(name, "SystemNoUnlink") == 0) {
2947 xar->xmlsts = FILE_FLAGS_SYS_NOUNLINK;
2950 else if (strcmp(name, "SystemSnapshot") == 0) {
2951 xar->xmlsts = FILE_FLAGS_SYS_SNAPSHOT;
2957 xar->file->has |= HAS_FFLAGS;
2958 if (archive_strlen(&(xar->file->fflags_text)) > 0)
2959 archive_strappend_char(&(xar->file->fflags_text), ',');
2960 archive_strcat(&(xar->file->fflags_text), flag);
2968 xml_parse_file_ext2(struct xar *xar, const char *name)
2970 const char *flag = NULL;
2972 if (strcmp(name, "SecureDeletion") == 0) {
2973 xar->xmlsts = FILE_EXT2_SecureDeletion;
2974 flag = "securedeletion";
2976 else if (strcmp(name, "Undelete") == 0) {
2977 xar->xmlsts = FILE_EXT2_Undelete;
2980 else if (strcmp(name, "Compress") == 0) {
2981 xar->xmlsts = FILE_EXT2_Compress;
2984 else if (strcmp(name, "Synchronous") == 0) {
2985 xar->xmlsts = FILE_EXT2_Synchronous;
2988 else if (strcmp(name, "Immutable") == 0) {
2989 xar->xmlsts = FILE_EXT2_Immutable;
2990 flag = "simmutable";
2992 else if (strcmp(name, "AppendOnly") == 0) {
2993 xar->xmlsts = FILE_EXT2_AppendOnly;
2996 else if (strcmp(name, "NoDump") == 0) {
2997 xar->xmlsts = FILE_EXT2_NoDump;
3000 else if (strcmp(name, "NoAtime") == 0) {
3001 xar->xmlsts = FILE_EXT2_NoAtime;
3004 else if (strcmp(name, "CompDirty") == 0) {
3005 xar->xmlsts = FILE_EXT2_CompDirty;
3008 else if (strcmp(name, "CompBlock") == 0) {
3009 xar->xmlsts = FILE_EXT2_CompBlock;
3012 else if (strcmp(name, "NoCompBlock") == 0) {
3013 xar->xmlsts = FILE_EXT2_NoCompBlock;
3014 flag = "nocomprblk";
3016 else if (strcmp(name, "CompError") == 0) {
3017 xar->xmlsts = FILE_EXT2_CompError;
3020 else if (strcmp(name, "BTree") == 0) {
3021 xar->xmlsts = FILE_EXT2_BTree;
3024 else if (strcmp(name, "HashIndexed") == 0) {
3025 xar->xmlsts = FILE_EXT2_HashIndexed;
3028 else if (strcmp(name, "iMagic") == 0) {
3029 xar->xmlsts = FILE_EXT2_iMagic;
3032 else if (strcmp(name, "Journaled") == 0) {
3033 xar->xmlsts = FILE_EXT2_Journaled;
3036 else if (strcmp(name, "NoTail") == 0) {
3037 xar->xmlsts = FILE_EXT2_NoTail;
3040 else if (strcmp(name, "DirSync") == 0) {
3041 xar->xmlsts = FILE_EXT2_DirSync;
3044 else if (strcmp(name, "TopDir") == 0) {
3045 xar->xmlsts = FILE_EXT2_TopDir;
3048 else if (strcmp(name, "Reserved") == 0) {
3049 xar->xmlsts = FILE_EXT2_Reserved;
3055 if (archive_strlen(&(xar->file->fflags_text)) > 0)
3056 archive_strappend_char(&(xar->file->fflags_text), ',');
3057 archive_strcat(&(xar->file->fflags_text), flag);
3061 #ifdef HAVE_LIBXML_XMLREADER_H
3064 xml2_xmlattr_setup(struct archive_read *a,
3065 struct xmlattr_list *list, xmlTextReaderPtr reader)
3067 struct xmlattr *attr;
3071 list->last = &(list->first);
3072 r = xmlTextReaderMoveToFirstAttribute(reader);
3074 attr = malloc(sizeof*(attr));
3076 archive_set_error(&a->archive, ENOMEM, "Out of memory");
3077 return (ARCHIVE_FATAL);
3079 attr->name = strdup(
3080 (const char *)xmlTextReaderConstLocalName(reader));
3081 if (attr->name == NULL) {
3083 archive_set_error(&a->archive, ENOMEM, "Out of memory");
3084 return (ARCHIVE_FATAL);
3086 attr->value = strdup(
3087 (const char *)xmlTextReaderConstValue(reader));
3088 if (attr->value == NULL) {
3091 archive_set_error(&a->archive, ENOMEM, "Out of memory");
3092 return (ARCHIVE_FATAL);
3096 list->last = &(attr->next);
3097 r = xmlTextReaderMoveToNextAttribute(reader);
3103 xml2_read_cb(void *context, char *buffer, int len)
3105 struct archive_read *a;
3112 a = (struct archive_read *)context;
3113 xar = (struct xar *)(a->format->data);
3115 if (xar->toc_remaining <= 0)
3119 r = rd_contents(a, &d, &outbytes, &used, xar->toc_remaining);
3120 if (r != ARCHIVE_OK)
3122 __archive_read_consume(a, used);
3123 xar->toc_remaining -= used;
3124 xar->offset += used;
3125 xar->toc_total += outbytes;
3126 PRINT_TOC(buffer, len);
3128 return ((int)outbytes);
3132 xml2_close_cb(void *context)
3135 (void)context; /* UNUSED */
3140 xml2_error_hdr(void *arg, const char *msg, xmlParserSeverities severity,
3141 xmlTextReaderLocatorPtr locator)
3143 struct archive_read *a;
3145 (void)locator; /* UNUSED */
3146 a = (struct archive_read *)arg;
3148 case XML_PARSER_SEVERITY_VALIDITY_WARNING:
3149 case XML_PARSER_SEVERITY_WARNING:
3150 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3151 "XML Parsing error: %s", msg);
3153 case XML_PARSER_SEVERITY_VALIDITY_ERROR:
3154 case XML_PARSER_SEVERITY_ERROR:
3155 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3156 "XML Parsing error: %s", msg);
3162 xml2_read_toc(struct archive_read *a)
3164 xmlTextReaderPtr reader;
3165 struct xmlattr_list list;
3168 reader = xmlReaderForIO(xml2_read_cb, xml2_close_cb, a, NULL, NULL, 0);
3169 if (reader == NULL) {
3170 archive_set_error(&a->archive, ENOMEM,
3171 "Couldn't allocate memory for xml parser");
3172 return (ARCHIVE_FATAL);
3174 xmlTextReaderSetErrorHandler(reader, xml2_error_hdr, a);
3176 while ((r = xmlTextReaderRead(reader)) == 1) {
3177 const char *name, *value;
3180 type = xmlTextReaderNodeType(reader);
3181 name = (const char *)xmlTextReaderConstLocalName(reader);
3183 case XML_READER_TYPE_ELEMENT:
3184 empty = xmlTextReaderIsEmptyElement(reader);
3185 r = xml2_xmlattr_setup(a, &list, reader);
3186 if (r != ARCHIVE_OK)
3188 r = xml_start(a, name, &list);
3189 xmlattr_cleanup(&list);
3190 if (r != ARCHIVE_OK)
3195 case XML_READER_TYPE_END_ELEMENT:
3198 case XML_READER_TYPE_TEXT:
3199 value = (const char *)xmlTextReaderConstValue(reader);
3200 xml_data(a, value, strlen(value));
3202 case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
3209 xmlFreeTextReader(reader);
3212 return ((r == 0)?ARCHIVE_OK:ARCHIVE_FATAL);
3215 #elif defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H)
3218 expat_xmlattr_setup(struct archive_read *a,
3219 struct xmlattr_list *list, const XML_Char **atts)
3221 struct xmlattr *attr;
3225 list->last = &(list->first);
3227 return (ARCHIVE_OK);
3228 while (atts[0] != NULL && atts[1] != NULL) {
3229 attr = malloc(sizeof*(attr));
3230 name = strdup(atts[0]);
3231 value = strdup(atts[1]);
3232 if (attr == NULL || name == NULL || value == NULL) {
3233 archive_set_error(&a->archive, ENOMEM, "Out of memory");
3234 return (ARCHIVE_FATAL);
3237 attr->value = value;
3240 list->last = &(attr->next);
3243 return (ARCHIVE_OK);
3247 expat_start_cb(void *userData, const XML_Char *name, const XML_Char **atts)
3249 struct expat_userData *ud = (struct expat_userData *)userData;
3250 struct archive_read *a = ud->archive;
3251 struct xmlattr_list list;
3254 r = expat_xmlattr_setup(a, &list, atts);
3255 if (r == ARCHIVE_OK)
3256 r = xml_start(a, (const char *)name, &list);
3257 xmlattr_cleanup(&list);
3262 expat_end_cb(void *userData, const XML_Char *name)
3264 struct expat_userData *ud = (struct expat_userData *)userData;
3266 xml_end(ud->archive, (const char *)name);
3270 expat_data_cb(void *userData, const XML_Char *s, int len)
3272 struct expat_userData *ud = (struct expat_userData *)userData;
3274 xml_data(ud->archive, s, len);
3278 expat_read_toc(struct archive_read *a)
3282 struct expat_userData ud;
3284 ud.state = ARCHIVE_OK;
3287 xar = (struct xar *)(a->format->data);
3289 /* Initialize XML Parser library. */
3290 parser = XML_ParserCreate(NULL);
3291 if (parser == NULL) {
3292 archive_set_error(&a->archive, ENOMEM,
3293 "Couldn't allocate memory for xml parser");
3294 return (ARCHIVE_FATAL);
3296 XML_SetUserData(parser, &ud);
3297 XML_SetElementHandler(parser, expat_start_cb, expat_end_cb);
3298 XML_SetCharacterDataHandler(parser, expat_data_cb);
3301 while (xar->toc_remaining && ud.state == ARCHIVE_OK) {
3309 r = rd_contents(a, &d, &outbytes, &used, xar->toc_remaining);
3310 if (r != ARCHIVE_OK)
3312 xar->toc_remaining -= used;
3313 xar->offset += used;
3314 xar->toc_total += outbytes;
3315 PRINT_TOC(d, outbytes);
3317 xr = XML_Parse(parser, d, outbytes, xar->toc_remaining == 0);
3318 __archive_read_consume(a, used);
3319 if (xr == XML_STATUS_ERROR) {
3320 XML_ParserFree(parser);
3321 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3322 "XML Parsing failed");
3323 return (ARCHIVE_FATAL);
3326 XML_ParserFree(parser);
3329 #endif /* defined(HAVE_BSDXML_H) || defined(HAVE_EXPAT_H) */
3331 #endif /* Support xar format */