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