1 /*- 2 * Copyright (c) 2004 Tim Kientzle 3 * Copyright (c) 2011-2012 Michihiro NAKAJIMA 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include "archive_platform.h" 28 __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_zip.c 201102 2009-12-28 03:11:36Z kientzle $"); 29 30 #ifdef HAVE_ERRNO_H 31 #include <errno.h> 32 #endif 33 #ifdef HAVE_STDLIB_H 34 #include <stdlib.h> 35 #endif 36 #ifdef HAVE_ZLIB_H 37 #include <zlib.h> 38 #endif 39 40 #include "archive.h" 41 #include "archive_endian.h" 42 #include "archive_entry.h" 43 #include "archive_entry_locale.h" 44 #include "archive_private.h" 45 #include "archive_rb.h" 46 #include "archive_read_private.h" 47 48 #ifndef HAVE_ZLIB_H 49 #include "archive_crc32.h" 50 #endif 51 52 struct zip_entry { 53 struct archive_rb_node node; 54 int64_t local_header_offset; 55 int64_t compressed_size; 56 int64_t uncompressed_size; 57 int64_t gid; 58 int64_t uid; 59 struct archive_entry *entry; 60 time_t mtime; 61 time_t atime; 62 time_t ctime; 63 uint32_t crc32; 64 uint16_t mode; 65 uint16_t flags; 66 char compression; 67 char system; 68 }; 69 70 struct zip { 71 /* Structural information about the archive. */ 72 int64_t central_directory_offset; 73 size_t central_directory_size; 74 size_t central_directory_entries; 75 char have_central_directory; 76 int64_t offset; 77 78 /* List of entries (seekable Zip only) */ 79 size_t entries_remaining; 80 struct zip_entry *zip_entries; 81 struct zip_entry *entry; 82 struct archive_rb_tree tree; 83 84 size_t unconsumed; 85 86 /* entry_bytes_remaining is the number of bytes we expect. */ 87 int64_t entry_bytes_remaining; 88 89 /* These count the number of bytes actually read for the entry. */ 90 int64_t entry_compressed_bytes_read; 91 int64_t entry_uncompressed_bytes_read; 92 93 /* Running CRC32 of the decompressed data */ 94 unsigned long entry_crc32; 95 96 /* Flags to mark progress of decompression. */ 97 char decompress_init; 98 char end_of_entry; 99 100 ssize_t filename_length; 101 ssize_t extra_length; 102 103 unsigned char *uncompressed_buffer; 104 size_t uncompressed_buffer_size; 105 #ifdef HAVE_ZLIB_H 106 z_stream stream; 107 char stream_valid; 108 #endif 109 110 struct archive_string extra; 111 struct archive_string_conv *sconv; 112 struct archive_string_conv *sconv_default; 113 struct archive_string_conv *sconv_utf8; 114 int init_default_conversion; 115 char format_name[64]; 116 }; 117 118 #define ZIP_LENGTH_AT_END 8 119 #define ZIP_ENCRYPTED (1<<0) 120 #define ZIP_STRONG_ENCRYPTED (1<<6) 121 #define ZIP_UTF8_NAME (1<<11) 122 123 static int archive_read_format_zip_streamable_bid(struct archive_read *, int); 124 static int archive_read_format_zip_seekable_bid(struct archive_read *, int); 125 static int archive_read_format_zip_options(struct archive_read *, 126 const char *, const char *); 127 static int archive_read_format_zip_cleanup(struct archive_read *); 128 static int archive_read_format_zip_read_data(struct archive_read *, 129 const void **, size_t *, int64_t *); 130 static int archive_read_format_zip_read_data_skip(struct archive_read *a); 131 static int archive_read_format_zip_seekable_read_header(struct archive_read *, 132 struct archive_entry *); 133 static int archive_read_format_zip_streamable_read_header(struct archive_read *, 134 struct archive_entry *); 135 #ifdef HAVE_ZLIB_H 136 static int zip_read_data_deflate(struct archive_read *a, const void **buff, 137 size_t *size, int64_t *offset); 138 #endif 139 static int zip_read_data_none(struct archive_read *a, const void **buff, 140 size_t *size, int64_t *offset); 141 static int zip_read_local_file_header(struct archive_read *a, 142 struct archive_entry *entry, struct zip *); 143 static time_t zip_time(const char *); 144 static const char *compression_name(int compression); 145 static void process_extra(const char *, size_t, struct zip_entry *); 146 147 int archive_read_support_format_zip_streamable(struct archive *); 148 int archive_read_support_format_zip_seekable(struct archive *); 149 150 int 151 archive_read_support_format_zip_streamable(struct archive *_a) 152 { 153 struct archive_read *a = (struct archive_read *)_a; 154 struct zip *zip; 155 int r; 156 157 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 158 ARCHIVE_STATE_NEW, "archive_read_support_format_zip"); 159 160 zip = (struct zip *)malloc(sizeof(*zip)); 161 if (zip == NULL) { 162 archive_set_error(&a->archive, ENOMEM, 163 "Can't allocate zip data"); 164 return (ARCHIVE_FATAL); 165 } 166 memset(zip, 0, sizeof(*zip)); 167 168 r = __archive_read_register_format(a, 169 zip, 170 "zip", 171 archive_read_format_zip_streamable_bid, 172 archive_read_format_zip_options, 173 archive_read_format_zip_streamable_read_header, 174 archive_read_format_zip_read_data, 175 archive_read_format_zip_read_data_skip, 176 archive_read_format_zip_cleanup); 177 178 if (r != ARCHIVE_OK) 179 free(zip); 180 return (ARCHIVE_OK); 181 } 182 183 int 184 archive_read_support_format_zip_seekable(struct archive *_a) 185 { 186 struct archive_read *a = (struct archive_read *)_a; 187 struct zip *zip; 188 int r; 189 190 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 191 ARCHIVE_STATE_NEW, "archive_read_support_format_zip_seekable"); 192 193 zip = (struct zip *)malloc(sizeof(*zip)); 194 if (zip == NULL) { 195 archive_set_error(&a->archive, ENOMEM, 196 "Can't allocate zip data"); 197 return (ARCHIVE_FATAL); 198 } 199 memset(zip, 0, sizeof(*zip)); 200 201 r = __archive_read_register_format(a, 202 zip, 203 "zip", 204 archive_read_format_zip_seekable_bid, 205 archive_read_format_zip_options, 206 archive_read_format_zip_seekable_read_header, 207 archive_read_format_zip_read_data, 208 archive_read_format_zip_read_data_skip, 209 archive_read_format_zip_cleanup); 210 211 if (r != ARCHIVE_OK) 212 free(zip); 213 return (ARCHIVE_OK); 214 } 215 216 int 217 archive_read_support_format_zip(struct archive *a) 218 { 219 int r; 220 r = archive_read_support_format_zip_streamable(a); 221 if (r != ARCHIVE_OK) 222 return r; 223 return (archive_read_support_format_zip_seekable(a)); 224 } 225 226 /* 227 * TODO: This is a performance sink because it forces the read core to 228 * drop buffered data from the start of file, which will then have to 229 * be re-read again if this bidder loses. 230 * 231 * We workaround this a little by passing in the best bid so far so 232 * that later bidders can do nothing if they know they'll never 233 * outbid. But we can certainly do better... 234 */ 235 static int 236 archive_read_format_zip_seekable_bid(struct archive_read *a, int best_bid) 237 { 238 struct zip *zip = (struct zip *)a->format->data; 239 int64_t filesize; 240 const char *p; 241 242 /* If someone has already bid more than 32, then avoid 243 trashing the look-ahead buffers with a seek. */ 244 if (best_bid > 32) 245 return (-1); 246 247 filesize = __archive_read_seek(a, -22, SEEK_END); 248 /* If we can't seek, then we can't bid. */ 249 if (filesize <= 0) 250 return 0; 251 252 /* TODO: More robust search for end of central directory record. */ 253 if ((p = __archive_read_ahead(a, 22, NULL)) == NULL) 254 return 0; 255 /* First four bytes are signature for end of central directory 256 record. Four zero bytes ensure this isn't a multi-volume 257 Zip file (which we don't yet support). */ 258 if (memcmp(p, "PK\005\006\000\000\000\000", 8) != 0) 259 return 0; 260 261 /* Since we've already done the hard work of finding the 262 end of central directory record, let's save the important 263 information. */ 264 zip->central_directory_entries = archive_le16dec(p + 10); 265 zip->central_directory_size = archive_le32dec(p + 12); 266 zip->central_directory_offset = archive_le32dec(p + 16); 267 268 /* Just one volume, so central dir must all be on this volume. */ 269 if (zip->central_directory_entries != archive_le16dec(p + 8)) 270 return 0; 271 /* Central directory can't extend beyond end of this file. */ 272 if (zip->central_directory_offset + (int64_t)zip->central_directory_size > filesize) 273 return 0; 274 275 /* This is just a tiny bit higher than the maximum returned by 276 the streaming Zip bidder. This ensures that the more accurate 277 seeking Zip parser wins whenever seek is available. */ 278 return 32; 279 } 280 281 static int 282 cmp_node(const struct archive_rb_node *n1, const struct archive_rb_node *n2) 283 { 284 const struct zip_entry *e1 = (const struct zip_entry *)n1; 285 const struct zip_entry *e2 = (const struct zip_entry *)n2; 286 287 return ((int)(e2->local_header_offset - e1->local_header_offset)); 288 } 289 290 static int 291 cmp_key(const struct archive_rb_node *n, const void *key) 292 { 293 /* This function won't be called */ 294 (void)n; /* UNUSED */ 295 (void)key; /* UNUSED */ 296 return 1; 297 } 298 299 static int 300 slurp_central_directory(struct archive_read *a, struct zip *zip) 301 { 302 unsigned i; 303 static const struct archive_rb_tree_ops rb_ops = { 304 &cmp_node, &cmp_key 305 }; 306 307 __archive_read_seek(a, zip->central_directory_offset, SEEK_SET); 308 zip->offset = zip->central_directory_offset; 309 __archive_rb_tree_init(&zip->tree, &rb_ops); 310 311 zip->zip_entries = calloc(zip->central_directory_entries, 312 sizeof(struct zip_entry)); 313 for (i = 0; i < zip->central_directory_entries; ++i) { 314 struct zip_entry *zip_entry = &zip->zip_entries[i]; 315 size_t filename_length, extra_length, comment_length; 316 uint32_t external_attributes; 317 const char *p; 318 319 if ((p = __archive_read_ahead(a, 46, NULL)) == NULL) 320 return ARCHIVE_FATAL; 321 if (memcmp(p, "PK\001\002", 4) != 0) { 322 archive_set_error(&a->archive, 323 -1, "Invalid central directory signature"); 324 return ARCHIVE_FATAL; 325 } 326 zip->have_central_directory = 1; 327 /* version = p[4]; */ 328 zip_entry->system = p[5]; 329 /* version_required = archive_le16dec(p + 6); */ 330 zip_entry->flags = archive_le16dec(p + 8); 331 zip_entry->compression = (char)archive_le16dec(p + 10); 332 zip_entry->mtime = zip_time(p + 12); 333 zip_entry->crc32 = archive_le32dec(p + 16); 334 zip_entry->compressed_size = archive_le32dec(p + 20); 335 zip_entry->uncompressed_size = archive_le32dec(p + 24); 336 filename_length = archive_le16dec(p + 28); 337 extra_length = archive_le16dec(p + 30); 338 comment_length = archive_le16dec(p + 32); 339 /* disk_start = archive_le16dec(p + 34); */ /* Better be zero. */ 340 /* internal_attributes = archive_le16dec(p + 36); */ /* text bit */ 341 external_attributes = archive_le32dec(p + 38); 342 zip_entry->local_header_offset = archive_le32dec(p + 42); 343 344 /* If we can't guess the mode, leave it zero here; 345 when we read the local file header we might get 346 more information. */ 347 zip_entry->mode = 0; 348 if (zip_entry->system == 3) { 349 zip_entry->mode = external_attributes >> 16; 350 } 351 /* Register an entry to RB tree to sort it by file offset. */ 352 __archive_rb_tree_insert_node(&zip->tree, &zip_entry->node); 353 354 /* We don't read the filename until we get to the 355 local file header. Reading it here would speed up 356 table-of-contents operations (removing the need to 357 find and read local file header to get the 358 filename) at the cost of requiring a lot of extra 359 space. */ 360 /* We don't read the extra block here. We assume it 361 will be duplicated at the local file header. */ 362 __archive_read_consume(a, 363 46 + filename_length + extra_length + comment_length); 364 } 365 366 return ARCHIVE_OK; 367 } 368 369 static int64_t 370 zip_read_consume(struct archive_read *a, int64_t bytes) 371 { 372 struct zip *zip = (struct zip *)a->format->data; 373 int64_t skip; 374 375 skip = __archive_read_consume(a, bytes); 376 if (skip > 0) 377 zip->offset += skip; 378 return (skip); 379 } 380 381 static int 382 archive_read_format_zip_seekable_read_header(struct archive_read *a, 383 struct archive_entry *entry) 384 { 385 struct zip *zip = (struct zip *)a->format->data; 386 int r, ret = ARCHIVE_OK; 387 388 a->archive.archive_format = ARCHIVE_FORMAT_ZIP; 389 if (a->archive.archive_format_name == NULL) 390 a->archive.archive_format_name = "ZIP"; 391 392 if (zip->zip_entries == NULL) { 393 r = slurp_central_directory(a, zip); 394 zip->entries_remaining = zip->central_directory_entries; 395 if (r != ARCHIVE_OK) 396 return r; 397 /* Get first entry whose local header offset is lower than 398 * other entries in the archive file. */ 399 zip->entry = 400 (struct zip_entry *)ARCHIVE_RB_TREE_MIN(&zip->tree); 401 } else if (zip->entry != NULL) { 402 /* Get next entry in local header offset order. */ 403 zip->entry = (struct zip_entry *)__archive_rb_tree_iterate( 404 &zip->tree, &zip->entry->node, ARCHIVE_RB_DIR_RIGHT); 405 } 406 407 if (zip->entries_remaining <= 0 || zip->entry == NULL) 408 return ARCHIVE_EOF; 409 --zip->entries_remaining; 410 411 if (zip->offset != zip->entry->local_header_offset) { 412 __archive_read_seek(a, zip->entry->local_header_offset, 413 SEEK_SET); 414 zip->offset = zip->entry->local_header_offset; 415 } 416 zip->unconsumed = 0; 417 r = zip_read_local_file_header(a, entry, zip); 418 if (r != ARCHIVE_OK) 419 return r; 420 if ((zip->entry->mode & AE_IFMT) == AE_IFLNK) { 421 const void *p; 422 struct archive_string_conv *sconv; 423 size_t linkname_length = (size_t)archive_entry_size(entry); 424 425 archive_entry_set_size(entry, 0); 426 p = __archive_read_ahead(a, linkname_length, NULL); 427 if (p == NULL) { 428 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 429 "Truncated Zip file"); 430 return ARCHIVE_FATAL; 431 } 432 433 sconv = zip->sconv; 434 if (sconv == NULL && (zip->entry->flags & ZIP_UTF8_NAME)) 435 sconv = zip->sconv_utf8; 436 if (sconv == NULL) 437 sconv = zip->sconv_default; 438 if (archive_entry_copy_symlink_l(entry, p, linkname_length, 439 sconv) != 0) { 440 if (errno != ENOMEM && sconv == zip->sconv_utf8 && 441 (zip->entry->flags & ZIP_UTF8_NAME)) 442 archive_entry_copy_symlink_l(entry, p, 443 linkname_length, NULL); 444 if (errno == ENOMEM) { 445 archive_set_error(&a->archive, ENOMEM, 446 "Can't allocate memory for Symlink"); 447 return (ARCHIVE_FATAL); 448 } 449 /* 450 * Since there is no character-set regulation for 451 * symlink name, do not report the conversion error 452 * in an automatic conversion. 453 */ 454 if (sconv != zip->sconv_utf8 || 455 (zip->entry->flags & ZIP_UTF8_NAME) == 0) { 456 archive_set_error(&a->archive, 457 ARCHIVE_ERRNO_FILE_FORMAT, 458 "Symlink cannot be converted " 459 "from %s to current locale.", 460 archive_string_conversion_charset_name( 461 sconv)); 462 ret = ARCHIVE_WARN; 463 } 464 } 465 } 466 return (ret); 467 } 468 469 static int 470 archive_read_format_zip_streamable_bid(struct archive_read *a, int best_bid) 471 { 472 const char *p; 473 474 (void)best_bid; /* UNUSED */ 475 476 if ((p = __archive_read_ahead(a, 4, NULL)) == NULL) 477 return (-1); 478 479 /* 480 * Bid of 30 here is: 16 bits for "PK", 481 * next 16-bit field has four options (-2 bits). 482 * 16 + 16-2 = 30. 483 */ 484 if (p[0] == 'P' && p[1] == 'K') { 485 if ((p[2] == '\001' && p[3] == '\002') 486 || (p[2] == '\003' && p[3] == '\004') 487 || (p[2] == '\005' && p[3] == '\006') 488 || (p[2] == '\007' && p[3] == '\010') 489 || (p[2] == '0' && p[3] == '0')) 490 return (30); 491 } 492 493 /* TODO: It's worth looking ahead a little bit for a valid 494 * PK signature. In particular, that would make it possible 495 * to read some UUEncoded SFX files or SFX files coming from 496 * a network socket. */ 497 498 return (0); 499 } 500 501 static int 502 archive_read_format_zip_options(struct archive_read *a, 503 const char *key, const char *val) 504 { 505 struct zip *zip; 506 int ret = ARCHIVE_FAILED; 507 508 zip = (struct zip *)(a->format->data); 509 if (strcmp(key, "compat-2x") == 0) { 510 /* Handle filnames as libarchive 2.x */ 511 zip->init_default_conversion = (val != NULL) ? 1 : 0; 512 return (ARCHIVE_OK); 513 } else if (strcmp(key, "hdrcharset") == 0) { 514 if (val == NULL || val[0] == 0) 515 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 516 "zip: hdrcharset option needs a character-set name"); 517 else { 518 zip->sconv = archive_string_conversion_from_charset( 519 &a->archive, val, 0); 520 if (zip->sconv != NULL) { 521 if (strcmp(val, "UTF-8") == 0) 522 zip->sconv_utf8 = zip->sconv; 523 ret = ARCHIVE_OK; 524 } else 525 ret = ARCHIVE_FATAL; 526 } 527 return (ret); 528 } 529 530 /* Note: The "warn" return is just to inform the options 531 * supervisor that we didn't handle it. It will generate 532 * a suitable error if no one used this option. */ 533 return (ARCHIVE_WARN); 534 } 535 536 static int 537 archive_read_format_zip_streamable_read_header(struct archive_read *a, 538 struct archive_entry *entry) 539 { 540 struct zip *zip; 541 542 a->archive.archive_format = ARCHIVE_FORMAT_ZIP; 543 if (a->archive.archive_format_name == NULL) 544 a->archive.archive_format_name = "ZIP"; 545 546 zip = (struct zip *)(a->format->data); 547 548 /* Make sure we have a zip_entry structure to use. */ 549 if (zip->zip_entries == NULL) { 550 zip->zip_entries = malloc(sizeof(struct zip_entry)); 551 if (zip->zip_entries == NULL) { 552 archive_set_error(&a->archive, ENOMEM, "Out of memory"); 553 return ARCHIVE_FATAL; 554 } 555 } 556 zip->entry = zip->zip_entries; 557 memset(zip->entry, 0, sizeof(struct zip_entry)); 558 559 /* Search ahead for the next local file header. */ 560 zip_read_consume(a, zip->unconsumed); 561 zip->unconsumed = 0; 562 for (;;) { 563 int64_t skipped = 0; 564 const char *p, *end; 565 ssize_t bytes; 566 567 p = __archive_read_ahead(a, 4, &bytes); 568 if (p == NULL) 569 return (ARCHIVE_FATAL); 570 end = p + bytes; 571 572 while (p + 4 <= end) { 573 if (p[0] == 'P' && p[1] == 'K') { 574 if (p[2] == '\001' && p[3] == '\002') 575 /* Beginning of central directory. */ 576 return (ARCHIVE_EOF); 577 578 if (p[2] == '\003' && p[3] == '\004') { 579 /* Regular file entry. */ 580 zip_read_consume(a, skipped); 581 return zip_read_local_file_header(a, entry, zip); 582 } 583 584 if (p[2] == '\005' && p[3] == '\006') 585 /* End of central directory. */ 586 return (ARCHIVE_EOF); 587 } 588 ++p; 589 ++skipped; 590 } 591 zip_read_consume(a, skipped); 592 } 593 } 594 595 /* 596 * Assumes file pointer is at beginning of local file header. 597 */ 598 static int 599 zip_read_local_file_header(struct archive_read *a, struct archive_entry *entry, 600 struct zip *zip) 601 { 602 const char *p; 603 const void *h; 604 const wchar_t *wp; 605 const char *cp; 606 size_t len, filename_length, extra_length; 607 struct archive_string_conv *sconv; 608 struct zip_entry *zip_entry = zip->entry; 609 uint32_t local_crc32; 610 int64_t compressed_size, uncompressed_size; 611 int ret = ARCHIVE_OK; 612 char version; 613 614 zip->decompress_init = 0; 615 zip->end_of_entry = 0; 616 zip->entry_uncompressed_bytes_read = 0; 617 zip->entry_compressed_bytes_read = 0; 618 zip->entry_crc32 = crc32(0, NULL, 0); 619 620 /* Setup default conversion. */ 621 if (zip->sconv == NULL && !zip->init_default_conversion) { 622 zip->sconv_default = 623 archive_string_default_conversion_for_read(&(a->archive)); 624 zip->init_default_conversion = 1; 625 } 626 627 if ((p = __archive_read_ahead(a, 30, NULL)) == NULL) { 628 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 629 "Truncated ZIP file header"); 630 return (ARCHIVE_FATAL); 631 } 632 633 if (memcmp(p, "PK\003\004", 4) != 0) { 634 archive_set_error(&a->archive, -1, "Damaged Zip archive"); 635 return ARCHIVE_FATAL; 636 } 637 version = p[4]; 638 zip_entry->system = p[5]; 639 zip_entry->flags = archive_le16dec(p + 6); 640 zip_entry->compression = (char)archive_le16dec(p + 8); 641 zip_entry->mtime = zip_time(p + 10); 642 local_crc32 = archive_le32dec(p + 14); 643 compressed_size = archive_le32dec(p + 18); 644 uncompressed_size = archive_le32dec(p + 22); 645 filename_length = archive_le16dec(p + 26); 646 extra_length = archive_le16dec(p + 28); 647 648 zip_read_consume(a, 30); 649 650 if (zip->have_central_directory) { 651 /* If we read the central dir entry, we must have size information 652 as well, so ignore the length-at-end flag. */ 653 zip_entry->flags &= ~ZIP_LENGTH_AT_END; 654 /* If we have values from both the local file header 655 and the central directory, warn about mismatches 656 which might indicate a damaged file. But some 657 writers always put zero in the local header; don't 658 bother warning about that. */ 659 if (local_crc32 != 0 && local_crc32 != zip_entry->crc32) { 660 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 661 "Inconsistent CRC32 values"); 662 ret = ARCHIVE_WARN; 663 } 664 if (compressed_size != 0 665 && compressed_size != zip_entry->compressed_size) { 666 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 667 "Inconsistent compressed size"); 668 ret = ARCHIVE_WARN; 669 } 670 if (uncompressed_size != 0 671 && uncompressed_size != zip_entry->uncompressed_size) { 672 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 673 "Inconsistent uncompressed size"); 674 ret = ARCHIVE_WARN; 675 } 676 } else { 677 /* If we don't have the CD info, use whatever we do have. */ 678 zip_entry->crc32 = local_crc32; 679 zip_entry->compressed_size = compressed_size; 680 zip_entry->uncompressed_size = uncompressed_size; 681 } 682 683 /* Read the filename. */ 684 if ((h = __archive_read_ahead(a, filename_length, NULL)) == NULL) { 685 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 686 "Truncated ZIP file header"); 687 return (ARCHIVE_FATAL); 688 } 689 if (zip_entry->flags & ZIP_UTF8_NAME) { 690 /* The filename is stored to be UTF-8. */ 691 if (zip->sconv_utf8 == NULL) { 692 zip->sconv_utf8 = 693 archive_string_conversion_from_charset( 694 &a->archive, "UTF-8", 1); 695 if (zip->sconv_utf8 == NULL) 696 return (ARCHIVE_FATAL); 697 } 698 sconv = zip->sconv_utf8; 699 } else if (zip->sconv != NULL) 700 sconv = zip->sconv; 701 else 702 sconv = zip->sconv_default; 703 704 if (archive_entry_copy_pathname_l(entry, 705 h, filename_length, sconv) != 0) { 706 if (errno == ENOMEM) { 707 archive_set_error(&a->archive, ENOMEM, 708 "Can't allocate memory for Pathname"); 709 return (ARCHIVE_FATAL); 710 } 711 archive_set_error(&a->archive, 712 ARCHIVE_ERRNO_FILE_FORMAT, 713 "Pathname cannot be converted " 714 "from %s to current locale.", 715 archive_string_conversion_charset_name(sconv)); 716 ret = ARCHIVE_WARN; 717 } 718 zip_read_consume(a, filename_length); 719 720 if (zip_entry->mode == 0) { 721 /* Especially in streaming mode, we can end up 722 here without having seen any mode information. 723 Guess from the filename. */ 724 wp = archive_entry_pathname_w(entry); 725 if (wp != NULL) { 726 len = wcslen(wp); 727 if (len > 0 && wp[len - 1] == L'/') 728 zip_entry->mode = AE_IFDIR | 0777; 729 else 730 zip_entry->mode = AE_IFREG | 0666; 731 } else { 732 cp = archive_entry_pathname(entry); 733 len = (cp != NULL)?strlen(cp):0; 734 if (len > 0 && cp[len - 1] == '/') 735 zip_entry->mode = AE_IFDIR | 0777; 736 else 737 zip_entry->mode = AE_IFREG | 0666; 738 } 739 } 740 741 /* Read the extra data. */ 742 if ((h = __archive_read_ahead(a, extra_length, NULL)) == NULL) { 743 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 744 "Truncated ZIP file header"); 745 return (ARCHIVE_FATAL); 746 } 747 process_extra(h, extra_length, zip_entry); 748 zip_read_consume(a, extra_length); 749 750 /* Populate some additional entry fields: */ 751 archive_entry_set_mode(entry, zip_entry->mode); 752 archive_entry_set_uid(entry, zip_entry->uid); 753 archive_entry_set_gid(entry, zip_entry->gid); 754 archive_entry_set_mtime(entry, zip_entry->mtime, 0); 755 archive_entry_set_ctime(entry, zip_entry->ctime, 0); 756 archive_entry_set_atime(entry, zip_entry->atime, 0); 757 /* Set the size only if it's meaningful. */ 758 if (0 == (zip_entry->flags & ZIP_LENGTH_AT_END)) 759 archive_entry_set_size(entry, zip_entry->uncompressed_size); 760 761 zip->entry_bytes_remaining = zip_entry->compressed_size; 762 763 /* If there's no body, force read_data() to return EOF immediately. */ 764 if (0 == (zip_entry->flags & ZIP_LENGTH_AT_END) 765 && zip->entry_bytes_remaining < 1) 766 zip->end_of_entry = 1; 767 768 /* Set up a more descriptive format name. */ 769 sprintf(zip->format_name, "ZIP %d.%d (%s)", 770 version / 10, version % 10, 771 compression_name(zip->entry->compression)); 772 a->archive.archive_format_name = zip->format_name; 773 774 return (ret); 775 } 776 777 static const char * 778 compression_name(int compression) 779 { 780 static const char *compression_names[] = { 781 "uncompressed", 782 "shrinking", 783 "reduced-1", 784 "reduced-2", 785 "reduced-3", 786 "reduced-4", 787 "imploded", 788 "reserved", 789 "deflation" 790 }; 791 792 if (0 <= compression && compression < 793 (int)(sizeof(compression_names)/sizeof(compression_names[0]))) 794 return compression_names[compression]; 795 else 796 return "??"; 797 } 798 799 /* Convert an MSDOS-style date/time into Unix-style time. */ 800 static time_t 801 zip_time(const char *p) 802 { 803 int msTime, msDate; 804 struct tm ts; 805 806 msTime = (0xff & (unsigned)p[0]) + 256 * (0xff & (unsigned)p[1]); 807 msDate = (0xff & (unsigned)p[2]) + 256 * (0xff & (unsigned)p[3]); 808 809 memset(&ts, 0, sizeof(ts)); 810 ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */ 811 ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */ 812 ts.tm_mday = msDate & 0x1f; /* Day of month. */ 813 ts.tm_hour = (msTime >> 11) & 0x1f; 814 ts.tm_min = (msTime >> 5) & 0x3f; 815 ts.tm_sec = (msTime << 1) & 0x3e; 816 ts.tm_isdst = -1; 817 return mktime(&ts); 818 } 819 820 static int 821 archive_read_format_zip_read_data(struct archive_read *a, 822 const void **buff, size_t *size, int64_t *offset) 823 { 824 int r; 825 struct zip *zip = (struct zip *)(a->format->data); 826 827 *offset = zip->entry_uncompressed_bytes_read; 828 *size = 0; 829 *buff = NULL; 830 831 /* If we hit end-of-entry last time, return ARCHIVE_EOF. */ 832 if (zip->end_of_entry) 833 return (ARCHIVE_EOF); 834 835 /* Return EOF immediately if this is a non-regular file. */ 836 if (AE_IFREG != (zip->entry->mode & AE_IFMT)) 837 return (ARCHIVE_EOF); 838 839 if (zip->entry->flags & (ZIP_ENCRYPTED | ZIP_STRONG_ENCRYPTED)) { 840 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 841 "Encrypted file is unsupported"); 842 return (ARCHIVE_FAILED); 843 } 844 845 zip_read_consume(a, zip->unconsumed); 846 zip->unconsumed = 0; 847 848 switch(zip->entry->compression) { 849 case 0: /* No compression. */ 850 r = zip_read_data_none(a, buff, size, offset); 851 break; 852 #ifdef HAVE_ZLIB_H 853 case 8: /* Deflate compression. */ 854 r = zip_read_data_deflate(a, buff, size, offset); 855 break; 856 #endif 857 default: /* Unsupported compression. */ 858 /* Return a warning. */ 859 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 860 "Unsupported ZIP compression method (%s)", 861 compression_name(zip->entry->compression)); 862 /* We can't decompress this entry, but we will 863 * be able to skip() it and try the next entry. */ 864 return (ARCHIVE_FAILED); 865 break; 866 } 867 if (r != ARCHIVE_OK) 868 return (r); 869 /* Update checksum */ 870 if (*size) 871 zip->entry_crc32 = crc32(zip->entry_crc32, *buff, *size); 872 /* If we hit the end, swallow any end-of-data marker. */ 873 if (zip->end_of_entry) { 874 /* Check file size, CRC against these values. */ 875 if (zip->entry->compressed_size != zip->entry_compressed_bytes_read) { 876 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 877 "ZIP compressed data is wrong size (read %jd, expected %jd)", 878 (intmax_t)zip->entry_compressed_bytes_read, 879 (intmax_t)zip->entry->compressed_size); 880 return (ARCHIVE_WARN); 881 } 882 /* Size field only stores the lower 32 bits of the actual 883 * size. */ 884 if ((zip->entry->uncompressed_size & UINT32_MAX) 885 != (zip->entry_uncompressed_bytes_read & UINT32_MAX)) { 886 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 887 "ZIP uncompressed data is wrong size (read %jd, expected %jd)", 888 (intmax_t)zip->entry_uncompressed_bytes_read, 889 (intmax_t)zip->entry->uncompressed_size); 890 return (ARCHIVE_WARN); 891 } 892 /* Check computed CRC against header */ 893 if (zip->entry->crc32 != zip->entry_crc32) { 894 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 895 "ZIP bad CRC: 0x%lx should be 0x%lx", 896 (unsigned long)zip->entry_crc32, 897 (unsigned long)zip->entry->crc32); 898 return (ARCHIVE_WARN); 899 } 900 } 901 902 return (ARCHIVE_OK); 903 } 904 905 /* 906 * Read "uncompressed" data. There are three cases: 907 * 1) We know the size of the data. This is always true for the 908 * seeking reader (we've examined the Central Directory already). 909 * 2) ZIP_LENGTH_AT_END was set, but only the CRC was deferred. 910 * Info-ZIP seems to do this; we know the size but have to grab 911 * the CRC from the data descriptor afterwards. 912 * 3) We're streaming and ZIP_LENGTH_AT_END was specified and 913 * we have no size information. In this case, we can do pretty 914 * well by watching for the data descriptor record. The data 915 * descriptor is 16 bytes and includes a computed CRC that should 916 * provide a strong check. 917 * 918 * TODO: Technically, the PK\007\010 signature is optional. 919 * In the original spec, the data descriptor contained CRC 920 * and size fields but had no leading signature. In practice, 921 * newer writers seem to provide the signature pretty consistently, 922 * but we might need to do something more complex here if 923 * we want to handle older archives that lack that signature. 924 * 925 * Returns ARCHIVE_OK if successful, ARCHIVE_FATAL otherwise, sets 926 * zip->end_of_entry if it consumes all of the data. 927 */ 928 static int 929 zip_read_data_none(struct archive_read *a, const void **_buff, 930 size_t *size, int64_t *offset) 931 { 932 struct zip *zip; 933 const char *buff; 934 ssize_t bytes_avail; 935 936 (void)offset; /* UNUSED */ 937 938 zip = (struct zip *)(a->format->data); 939 940 if (zip->entry->flags & ZIP_LENGTH_AT_END) { 941 const char *p; 942 943 /* Grab at least 16 bytes. */ 944 buff = __archive_read_ahead(a, 16, &bytes_avail); 945 if (bytes_avail < 16) { 946 /* Zip archives have end-of-archive markers 947 that are longer than this, so a failure to get at 948 least 16 bytes really does indicate a truncated 949 file. */ 950 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 951 "Truncated ZIP file data"); 952 return (ARCHIVE_FATAL); 953 } 954 /* Check for a complete PK\007\010 signature. */ 955 p = buff; 956 if (p[0] == 'P' && p[1] == 'K' 957 && p[2] == '\007' && p[3] == '\010' 958 && archive_le32dec(p + 4) == zip->entry_crc32 959 && archive_le32dec(p + 8) == zip->entry_compressed_bytes_read 960 && archive_le32dec(p + 12) == zip->entry_uncompressed_bytes_read) { 961 zip->entry->crc32 = archive_le32dec(p + 4); 962 zip->entry->compressed_size = archive_le32dec(p + 8); 963 zip->entry->uncompressed_size = archive_le32dec(p + 12); 964 zip->end_of_entry = 1; 965 zip->unconsumed = 16; 966 return (ARCHIVE_OK); 967 } 968 /* If not at EOF, ensure we consume at least one byte. */ 969 ++p; 970 971 /* Scan forward until we see where a PK\007\010 signature might be. */ 972 /* Return bytes up until that point. On the next call, the code 973 above will verify the data descriptor. */ 974 while (p < buff + bytes_avail - 4) { 975 if (p[3] == 'P') { p += 3; } 976 else if (p[3] == 'K') { p += 2; } 977 else if (p[3] == '\007') { p += 1; } 978 else if (p[3] == '\010' && p[2] == '\007' 979 && p[1] == 'K' && p[0] == 'P') { 980 break; 981 } else { p += 4; } 982 } 983 bytes_avail = p - buff; 984 } else { 985 if (zip->entry_bytes_remaining == 0) { 986 zip->end_of_entry = 1; 987 return (ARCHIVE_OK); 988 } 989 /* Grab a bunch of bytes. */ 990 buff = __archive_read_ahead(a, 1, &bytes_avail); 991 if (bytes_avail <= 0) { 992 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 993 "Truncated ZIP file data"); 994 return (ARCHIVE_FATAL); 995 } 996 if (bytes_avail > zip->entry_bytes_remaining) 997 bytes_avail = (ssize_t)zip->entry_bytes_remaining; 998 } 999 *size = bytes_avail; 1000 zip->entry_bytes_remaining -= bytes_avail; 1001 zip->entry_uncompressed_bytes_read += bytes_avail; 1002 zip->entry_compressed_bytes_read += bytes_avail; 1003 zip->unconsumed += bytes_avail; 1004 *_buff = buff; 1005 return (ARCHIVE_OK); 1006 } 1007 1008 #ifdef HAVE_ZLIB_H 1009 static int 1010 zip_read_data_deflate(struct archive_read *a, const void **buff, 1011 size_t *size, int64_t *offset) 1012 { 1013 struct zip *zip; 1014 ssize_t bytes_avail; 1015 const void *compressed_buff; 1016 int r; 1017 1018 (void)offset; /* UNUSED */ 1019 1020 zip = (struct zip *)(a->format->data); 1021 1022 /* If the buffer hasn't been allocated, allocate it now. */ 1023 if (zip->uncompressed_buffer == NULL) { 1024 zip->uncompressed_buffer_size = 256 * 1024; 1025 zip->uncompressed_buffer 1026 = (unsigned char *)malloc(zip->uncompressed_buffer_size); 1027 if (zip->uncompressed_buffer == NULL) { 1028 archive_set_error(&a->archive, ENOMEM, 1029 "No memory for ZIP decompression"); 1030 return (ARCHIVE_FATAL); 1031 } 1032 } 1033 1034 /* If we haven't yet read any data, initialize the decompressor. */ 1035 if (!zip->decompress_init) { 1036 if (zip->stream_valid) 1037 r = inflateReset(&zip->stream); 1038 else 1039 r = inflateInit2(&zip->stream, 1040 -15 /* Don't check for zlib header */); 1041 if (r != Z_OK) { 1042 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1043 "Can't initialize ZIP decompression."); 1044 return (ARCHIVE_FATAL); 1045 } 1046 /* Stream structure has been set up. */ 1047 zip->stream_valid = 1; 1048 /* We've initialized decompression for this stream. */ 1049 zip->decompress_init = 1; 1050 } 1051 1052 /* 1053 * Note: '1' here is a performance optimization. 1054 * Recall that the decompression layer returns a count of 1055 * available bytes; asking for more than that forces the 1056 * decompressor to combine reads by copying data. 1057 */ 1058 compressed_buff = __archive_read_ahead(a, 1, &bytes_avail); 1059 if (0 == (zip->entry->flags & ZIP_LENGTH_AT_END) 1060 && bytes_avail > zip->entry_bytes_remaining) { 1061 bytes_avail = (ssize_t)zip->entry_bytes_remaining; 1062 } 1063 if (bytes_avail <= 0) { 1064 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1065 "Truncated ZIP file body"); 1066 return (ARCHIVE_FATAL); 1067 } 1068 1069 /* 1070 * A bug in zlib.h: stream.next_in should be marked 'const' 1071 * but isn't (the library never alters data through the 1072 * next_in pointer, only reads it). The result: this ugly 1073 * cast to remove 'const'. 1074 */ 1075 zip->stream.next_in = (Bytef *)(uintptr_t)(const void *)compressed_buff; 1076 zip->stream.avail_in = bytes_avail; 1077 zip->stream.total_in = 0; 1078 zip->stream.next_out = zip->uncompressed_buffer; 1079 zip->stream.avail_out = zip->uncompressed_buffer_size; 1080 zip->stream.total_out = 0; 1081 1082 r = inflate(&zip->stream, 0); 1083 switch (r) { 1084 case Z_OK: 1085 break; 1086 case Z_STREAM_END: 1087 zip->end_of_entry = 1; 1088 break; 1089 case Z_MEM_ERROR: 1090 archive_set_error(&a->archive, ENOMEM, 1091 "Out of memory for ZIP decompression"); 1092 return (ARCHIVE_FATAL); 1093 default: 1094 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 1095 "ZIP decompression failed (%d)", r); 1096 return (ARCHIVE_FATAL); 1097 } 1098 1099 /* Consume as much as the compressor actually used. */ 1100 bytes_avail = zip->stream.total_in; 1101 zip_read_consume(a, bytes_avail); 1102 zip->entry_bytes_remaining -= bytes_avail; 1103 zip->entry_compressed_bytes_read += bytes_avail; 1104 1105 *size = zip->stream.total_out; 1106 zip->entry_uncompressed_bytes_read += zip->stream.total_out; 1107 *buff = zip->uncompressed_buffer; 1108 1109 if (zip->end_of_entry && (zip->entry->flags & ZIP_LENGTH_AT_END)) { 1110 const char *p; 1111 1112 if (NULL == (p = __archive_read_ahead(a, 16, NULL))) { 1113 archive_set_error(&a->archive, 1114 ARCHIVE_ERRNO_FILE_FORMAT, 1115 "Truncated ZIP end-of-file record"); 1116 return (ARCHIVE_FATAL); 1117 } 1118 /* Consume the optional PK\007\010 marker. */ 1119 if (p[0] == 'P' && p[1] == 'K' && p[2] == '\007' && p[3] == '\010') { 1120 zip->entry->crc32 = archive_le32dec(p + 4); 1121 zip->entry->compressed_size = archive_le32dec(p + 8); 1122 zip->entry->uncompressed_size = archive_le32dec(p + 12); 1123 zip->unconsumed = 16; 1124 } 1125 } 1126 1127 return (ARCHIVE_OK); 1128 } 1129 #endif 1130 1131 static int 1132 archive_read_format_zip_read_data_skip(struct archive_read *a) 1133 { 1134 struct zip *zip; 1135 1136 zip = (struct zip *)(a->format->data); 1137 1138 /* If we've already read to end of data, we're done. */ 1139 if (zip->end_of_entry) 1140 return (ARCHIVE_OK); 1141 1142 /* So we know we're streaming... */ 1143 if (0 == (zip->entry->flags & ZIP_LENGTH_AT_END)) { 1144 /* We know the compressed length, so we can just skip. */ 1145 int64_t bytes_skipped = zip_read_consume(a, 1146 zip->entry_bytes_remaining + zip->unconsumed); 1147 if (bytes_skipped < 0) 1148 return (ARCHIVE_FATAL); 1149 zip->unconsumed = 0; 1150 return (ARCHIVE_OK); 1151 } 1152 1153 /* We're streaming and we don't know the length. */ 1154 /* If the body is compressed and we know the format, we can 1155 * find an exact end-of-entry by decompressing it. */ 1156 switch (zip->entry->compression) { 1157 #ifdef HAVE_ZLIB_H 1158 case 8: /* Deflate compression. */ 1159 while (!zip->end_of_entry) { 1160 int64_t offset = 0; 1161 const void *buff = NULL; 1162 size_t size = 0; 1163 int r; 1164 r = zip_read_data_deflate(a, &buff, &size, &offset); 1165 if (r != ARCHIVE_OK) 1166 return (r); 1167 } 1168 return ARCHIVE_OK; 1169 #endif 1170 default: /* Uncompressed or unknown. */ 1171 /* Scan for a PK\007\010 signature. */ 1172 zip_read_consume(a, zip->unconsumed); 1173 zip->unconsumed = 0; 1174 for (;;) { 1175 const char *p, *buff; 1176 ssize_t bytes_avail; 1177 buff = __archive_read_ahead(a, 16, &bytes_avail); 1178 if (bytes_avail < 16) { 1179 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1180 "Truncated ZIP file data"); 1181 return (ARCHIVE_FATAL); 1182 } 1183 p = buff; 1184 while (p <= buff + bytes_avail - 16) { 1185 if (p[3] == 'P') { p += 3; } 1186 else if (p[3] == 'K') { p += 2; } 1187 else if (p[3] == '\007') { p += 1; } 1188 else if (p[3] == '\010' && p[2] == '\007' 1189 && p[1] == 'K' && p[0] == 'P') { 1190 zip_read_consume(a, p - buff + 16); 1191 return ARCHIVE_OK; 1192 } else { p += 4; } 1193 } 1194 zip_read_consume(a, p - buff); 1195 } 1196 } 1197 } 1198 1199 static int 1200 archive_read_format_zip_cleanup(struct archive_read *a) 1201 { 1202 struct zip *zip; 1203 1204 zip = (struct zip *)(a->format->data); 1205 #ifdef HAVE_ZLIB_H 1206 if (zip->stream_valid) 1207 inflateEnd(&zip->stream); 1208 #endif 1209 free(zip->zip_entries); 1210 free(zip->uncompressed_buffer); 1211 archive_string_free(&(zip->extra)); 1212 free(zip); 1213 (a->format->data) = NULL; 1214 return (ARCHIVE_OK); 1215 } 1216 1217 /* 1218 * The extra data is stored as a list of 1219 * id1+size1+data1 + id2+size2+data2 ... 1220 * triplets. id and size are 2 bytes each. 1221 */ 1222 static void 1223 process_extra(const char *p, size_t extra_length, struct zip_entry* zip_entry) 1224 { 1225 unsigned offset = 0; 1226 1227 while (offset < extra_length - 4) 1228 { 1229 unsigned short headerid = archive_le16dec(p + offset); 1230 unsigned short datasize = archive_le16dec(p + offset + 2); 1231 offset += 4; 1232 if (offset + datasize > extra_length) 1233 break; 1234 #ifdef DEBUG 1235 fprintf(stderr, "Header id 0x%x, length %d\n", 1236 headerid, datasize); 1237 #endif 1238 switch (headerid) { 1239 case 0x0001: 1240 /* Zip64 extended information extra field. */ 1241 if (datasize >= 8) 1242 zip_entry->uncompressed_size = 1243 archive_le64dec(p + offset); 1244 if (datasize >= 16) 1245 zip_entry->compressed_size = 1246 archive_le64dec(p + offset + 8); 1247 break; 1248 case 0x5455: 1249 { 1250 /* Extended time field "UT". */ 1251 int flags = p[offset]; 1252 offset++; 1253 datasize--; 1254 /* Flag bits indicate which dates are present. */ 1255 if (flags & 0x01) 1256 { 1257 #ifdef DEBUG 1258 fprintf(stderr, "mtime: %lld -> %d\n", 1259 (long long)zip_entry->mtime, 1260 archive_le32dec(p + offset)); 1261 #endif 1262 if (datasize < 4) 1263 break; 1264 zip_entry->mtime = archive_le32dec(p + offset); 1265 offset += 4; 1266 datasize -= 4; 1267 } 1268 if (flags & 0x02) 1269 { 1270 if (datasize < 4) 1271 break; 1272 zip_entry->atime = archive_le32dec(p + offset); 1273 offset += 4; 1274 datasize -= 4; 1275 } 1276 if (flags & 0x04) 1277 { 1278 if (datasize < 4) 1279 break; 1280 zip_entry->ctime = archive_le32dec(p + offset); 1281 offset += 4; 1282 datasize -= 4; 1283 } 1284 break; 1285 } 1286 case 0x5855: 1287 { 1288 /* Info-ZIP Unix Extra Field (old version) "UX". */ 1289 if (datasize >= 8) { 1290 zip_entry->atime = archive_le32dec(p + offset); 1291 zip_entry->mtime = archive_le32dec(p + offset + 4); 1292 } 1293 if (datasize >= 12) { 1294 zip_entry->uid = archive_le16dec(p + offset + 8); 1295 zip_entry->gid = archive_le16dec(p + offset + 10); 1296 } 1297 break; 1298 } 1299 case 0x7855: 1300 /* Info-ZIP Unix Extra Field (type 2) "Ux". */ 1301 #ifdef DEBUG 1302 fprintf(stderr, "uid %d gid %d\n", 1303 archive_le16dec(p + offset), 1304 archive_le16dec(p + offset + 2)); 1305 #endif 1306 if (datasize >= 2) 1307 zip_entry->uid = archive_le16dec(p + offset); 1308 if (datasize >= 4) 1309 zip_entry->gid = archive_le16dec(p + offset + 2); 1310 break; 1311 case 0x7875: 1312 { 1313 /* Info-Zip Unix Extra Field (type 3) "ux". */ 1314 int uidsize = 0, gidsize = 0; 1315 1316 if (datasize >= 1 && p[offset] == 1) {/* version=1 */ 1317 if (datasize >= 4) { 1318 /* get a uid size. */ 1319 uidsize = p[offset+1]; 1320 if (uidsize == 2) 1321 zip_entry->uid = archive_le16dec( 1322 p + offset + 2); 1323 else if (uidsize == 4 && datasize >= 6) 1324 zip_entry->uid = archive_le32dec( 1325 p + offset + 2); 1326 } 1327 if (datasize >= (2 + uidsize + 3)) { 1328 /* get a gid size. */ 1329 gidsize = p[offset+2+uidsize]; 1330 if (gidsize == 2) 1331 zip_entry->gid = archive_le16dec( 1332 p+offset+2+uidsize+1); 1333 else if (gidsize == 4 && 1334 datasize >= (2 + uidsize + 5)) 1335 zip_entry->gid = archive_le32dec( 1336 p+offset+2+uidsize+1); 1337 } 1338 } 1339 break; 1340 } 1341 default: 1342 break; 1343 } 1344 offset += datasize; 1345 } 1346 #ifdef DEBUG 1347 if (offset != extra_length) 1348 { 1349 fprintf(stderr, 1350 "Extra data field contents do not match reported size!\n"); 1351 } 1352 #endif 1353 } 1354