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