contrib/libarchive/libarchive/archive_read_support_format_7zip.c

   1 /*-
   2  * Copyright (c) 2011 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
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 #ifdef HAVE_ERRNO_H
  30 #include <errno.h>
  31 #endif
  32 #ifdef HAVE_STDLIB_H
  33 #include <stdlib.h>
  34 #endif
  35 #ifdef HAVE_BZLIB_H
  36 #include <bzlib.h>
  37 #endif
  38 #ifdef HAVE_LZMA_H
  39 #include <lzma.h>
  40 #endif
  41 #ifdef HAVE_ZLIB_H
  42 #include <zlib.h>
  43 #endif
  44
  45 #include "archive.h"
  46 #include "archive_entry.h"
  47 #include "archive_entry_locale.h"
  48 #include "archive_ppmd7_private.h"
  49 #include "archive_private.h"
  50 #include "archive_read_private.h"
  51 #include "archive_endian.h"
  52
  53 #ifndef HAVE_ZLIB_H
  54 #include "archive_crc32.h"
  55 #endif
  56
  57 #define _7ZIP_SIGNATURE "7z\xBC\xAF\x27\x1C"
  58 #define SFX_MIN_ADDR    0x27000
  59 #define SFX_MAX_ADDR    0x60000
  60
  61
  62 /*
  63  * Codec ID
  64  */
  65 #define _7Z_COPY        0
  66 #define _7Z_LZMA        0x030101
  67 #define _7Z_LZMA2       0x21
  68 #define _7Z_DEFLATE     0x040108
  69 #define _7Z_BZ2         0x040202
  70 #define _7Z_PPMD        0x030401
  71 #define _7Z_DELTA       0x03
  72 #define _7Z_CRYPTO      0x06F10701
  73 #define _7Z_X86         0x03030103
  74 #define _7Z_X86_BCJ2    0x0303011B
  75 #define _7Z_POWERPC     0x03030205
  76 #define _7Z_IA64        0x03030401
  77 #define _7Z_ARM         0x03030501
  78 #define _7Z_ARMTHUMB    0x03030701
  79 #define _7Z_SPARC       0x03030805
  80
  81 /*
  82  * 7-Zip header property IDs.
  83  */
  84 #define kEnd                    0x00
  85 #define kHeader                 0x01
  86 #define kArchiveProperties      0x02
  87 #define kAdditionalStreamsInfo  0x03
  88 #define kMainStreamsInfo        0x04
  89 #define kFilesInfo              0x05
  90 #define kPackInfo               0x06
  91 #define kUnPackInfo             0x07
  92 #define kSubStreamsInfo         0x08
  93 #define kSize                   0x09
  94 #define kCRC                    0x0A
  95 #define kFolder                 0x0B
  96 #define kCodersUnPackSize       0x0C
  97 #define kNumUnPackStream        0x0D
  98 #define kEmptyStream            0x0E
  99 #define kEmptyFile              0x0F
 100 #define kAnti                   0x10
 101 #define kName                   0x11
 102 #define kCTime                  0x12
 103 #define kATime                  0x13
 104 #define kMTime                  0x14
 105 #define kAttributes             0x15
 106 #define kEncodedHeader          0x17
 107
 108 struct _7z_digests {
 109         unsigned char   *defineds;
 110         uint32_t        *digests;
 111 };
 112
 113
 114 struct _7z_folder {
 115         uint64_t                 numCoders;
 116         struct _7z_coder {
 117                 unsigned long    codec;
 118                 uint64_t         numInStreams;
 119                 uint64_t         numOutStreams;
 120                 uint64_t         propertiesSize;
 121                 unsigned char   *properties;
 122         } *coders;
 123         uint64_t                 numBindPairs;
 124         struct {
 125                 uint64_t         inIndex;
 126                 uint64_t         outIndex;
 127         } *bindPairs;
 128         uint64_t                 numPackedStreams;
 129         uint64_t                *packedStreams;
 130         uint64_t                 numInStreams;
 131         uint64_t                 numOutStreams;
 132         uint64_t                *unPackSize;
 133         unsigned char            digest_defined;
 134         uint32_t                 digest;
 135         uint64_t                 numUnpackStreams;
 136         uint32_t                 packIndex;
 137         /* Unoperated bytes. */
 138         uint64_t                 skipped_bytes;
 139 };
 140
 141 struct _7z_coders_info {
 142         uint64_t                 numFolders;
 143         struct _7z_folder       *folders;
 144         uint64_t                 dataStreamIndex;
 145 };
 146
 147 struct _7z_pack_info {
 148         uint64_t                 pos;
 149         uint64_t                 numPackStreams;
 150         uint64_t                *sizes;
 151         struct _7z_digests       digest;
 152         /* Calculated from pos and numPackStreams. */
 153         uint64_t                *positions;
 154 };
 155
 156 struct _7z_substream_info {
 157         size_t                   unpack_streams;
 158         uint64_t                *unpackSizes;
 159         unsigned char           *digestsDefined;
 160         uint32_t                *digests;
 161 };
 162
 163 struct _7z_stream_info {
 164         struct _7z_pack_info     pi;
 165         struct _7z_coders_info   ci;
 166         struct _7z_substream_info ss;
 167 };
 168
 169 struct _7z_header_info {
 170         uint64_t                 dataIndex;
 171
 172         unsigned char           *emptyStreamBools;
 173         unsigned char           *emptyFileBools;
 174         unsigned char           *antiBools;
 175         unsigned char           *attrBools;
 176 };
 177
 178 struct _7zip_entry {
 179         size_t                   name_len;
 180         unsigned char           *utf16name;
 181 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
 182         const wchar_t           *wname;
 183 #endif
 184         uint32_t                 folderIndex;
 185         uint32_t                 ssIndex;
 186         unsigned                 flg;
 187 #define MTIME_IS_SET    (1<<0)
 188 #define ATIME_IS_SET    (1<<1)
 189 #define CTIME_IS_SET    (1<<2)
 190 #define CRC32_IS_SET    (1<<3)
 191 #define HAS_STREAM      (1<<4)
 192
 193         time_t                   mtime;
 194         time_t                   atime;
 195         time_t                   ctime;
 196         long                     mtime_ns;
 197         long                     atime_ns;
 198         long                     ctime_ns;
 199         uint32_t                 mode;
 200         uint32_t                 attr;
 201 };
 202
 203 struct _7zip {
 204         /* Structural information about the archive. */
 205         struct _7z_stream_info   si;
 206
 207         int                      header_is_being_read;
 208         int                      header_is_encoded;
 209         uint64_t                 header_bytes_remaining;
 210         unsigned long            header_crc32;
 211         /* Header offset to check that reading pointes of the file contens
 212          * will not exceed the header. */
 213         uint64_t                 header_offset;
 214         /* Base offset of the archive file for a seek in case reading SFX. */
 215         uint64_t                 seek_base;
 216
 217         /* List of entries */
 218         size_t                   entries_remaining;
 219         uint64_t                 numFiles;
 220         struct _7zip_entry      *entries;
 221         struct _7zip_entry      *entry;
 222         unsigned char           *entry_names;
 223
 224         /* entry_bytes_remaining is the number of bytes we expect. */
 225         int64_t                  entry_offset;
 226         uint64_t                 entry_bytes_remaining;
 227
 228         /* Running CRC32 of the decompressed data */
 229         unsigned long            entry_crc32;
 230
 231         /* Flags to mark progress of decompression. */
 232         char                     end_of_entry;
 233
 234         /* Uncompressed buffer control.  */
 235 #define UBUFF_SIZE      (64 * 1024)
 236         unsigned char           *uncompressed_buffer;
 237         unsigned char           *uncompressed_buffer_pointer;
 238         size_t                   uncompressed_buffer_size;
 239         size_t                   uncompressed_buffer_bytes_remaining;
 240
 241         /* Offset of the compressed data. */
 242         int64_t                  stream_offset;
 243
 244         /*
 245          * Decompressing control data.
 246          */
 247         unsigned                 folder_index;
 248         uint64_t                 folder_outbytes_remaining;
 249         unsigned                 pack_stream_index;
 250         unsigned                 pack_stream_remaining;
 251         uint64_t                 pack_stream_inbytes_remaining;
 252         size_t                   pack_stream_bytes_unconsumed;
 253
 254         /* The codec information of a folder. */
 255         unsigned long            codec;
 256         unsigned long            codec2;
 257
 258         /*
 259          * Decompressor controllers.
 260          */
 261         /* Decording LZMA1 and LZMA2 data. */
 262 #ifdef HAVE_LZMA_H
 263         lzma_stream              lzstream;
 264         int                      lzstream_valid;
 265 #endif
 266         /* Decording bzip2 data. */
 267 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 268         bz_stream                bzstream;
 269         int                      bzstream_valid;
 270 #endif
 271         /* Decording deflate data. */
 272 #ifdef HAVE_ZLIB_H
 273         z_stream                 stream;
 274         int                      stream_valid;
 275 #endif
 276         /* Decording PPMd data. */
 277         int                      ppmd7_stat;
 278         CPpmd7                   ppmd7_context;
 279         CPpmd7z_RangeDec         range_dec;
 280         IByteIn                  bytein;
 281         struct {
 282                 const unsigned char     *next_in;
 283                 int64_t                  avail_in;
 284                 int64_t                  total_in;
 285                 unsigned char           *next_out;
 286                 int64_t                  avail_out;
 287                 int64_t                  total_out;
 288                 int                      overconsumed;
 289         } ppstream;
 290         int                      ppmd7_valid;
 291
 292         /* Decoding BCJ and BCJ2 data. */
 293         uint32_t                 bcj_state;
 294         size_t                   odd_bcj_size;
 295         unsigned char            odd_bcj[4];
 296         /* Decoding BCJ data. */
 297         size_t                   bcj_prevPosT;
 298         uint32_t                 bcj_prevMask;
 299         uint32_t                 bcj_ip;
 300
 301         /* Decoding BCJ2 data. */
 302         size_t                   main_stream_bytes_remaining;
 303         unsigned char           *sub_stream_buff[3];
 304         size_t                   sub_stream_size[3];
 305         size_t                   sub_stream_bytes_remaining[3];
 306         unsigned char           *tmp_stream_buff;
 307         size_t                   tmp_stream_buff_size;
 308         size_t                   tmp_stream_bytes_avail;
 309         size_t                   tmp_stream_bytes_remaining;
 310 #ifdef _LZMA_PROB32
 311 #define CProb uint32_t
 312 #else
 313 #define CProb uint16_t
 314 #endif
 315         CProb                    bcj2_p[256 + 2];
 316         uint8_t                  bcj2_prevByte;
 317         uint32_t                 bcj2_range;
 318         uint32_t                 bcj2_code;
 319         uint64_t                 bcj2_outPos;
 320
 321         /* Filename character-set conversion data. */
 322         struct archive_string_conv *sconv;
 323
 324         char                     format_name[64];
 325 };
 326
 327 static int      archive_read_format_7zip_bid(struct archive_read *, int);
 328 static int      archive_read_format_7zip_cleanup(struct archive_read *);
 329 static int      archive_read_format_7zip_read_data(struct archive_read *,
 330                     const void **, size_t *, int64_t *);
 331 static int      archive_read_format_7zip_read_data_skip(struct archive_read *);
 332 static int      archive_read_format_7zip_read_header(struct archive_read *,
 333                     struct archive_entry *);
 334 static int      check_7zip_header_in_sfx(const char *);
 335 static unsigned long decode_codec_id(const unsigned char *, size_t);
 336 static int      decode_encoded_header_info(struct archive_read *,
 337                     struct _7z_stream_info *);
 338 static int      decompress(struct archive_read *, struct _7zip *,
 339                     void *, size_t *, const void *, size_t *);
 340 static ssize_t  extract_pack_stream(struct archive_read *, size_t);
 341 static void     fileTimeToUtc(uint64_t, time_t *, long *);
 342 static uint64_t folder_uncompressed_size(struct _7z_folder *);
 343 static void     free_CodersInfo(struct _7z_coders_info *);
 344 static void     free_Digest(struct _7z_digests *);
 345 static void     free_Folder(struct _7z_folder *);
 346 static void     free_Header(struct _7z_header_info *);
 347 static void     free_PackInfo(struct _7z_pack_info *);
 348 static void     free_StreamsInfo(struct _7z_stream_info *);
 349 static void     free_SubStreamsInfo(struct _7z_substream_info *);
 350 static int      free_decompression(struct archive_read *, struct _7zip *);
 351 static ssize_t  get_uncompressed_data(struct archive_read *, const void **,
 352                     size_t, size_t);
 353 static const unsigned char * header_bytes(struct archive_read *, size_t);
 354 static int      init_decompression(struct archive_read *, struct _7zip *,
 355                     const struct _7z_coder *, const struct _7z_coder *);
 356 static int      parse_7zip_uint64(struct archive_read *, uint64_t *);
 357 static int      read_Bools(struct archive_read *, unsigned char *, size_t);
 358 static int      read_CodersInfo(struct archive_read *,
 359                     struct _7z_coders_info *);
 360 static int      read_Digests(struct archive_read *, struct _7z_digests *,
 361                     size_t);
 362 static int      read_Folder(struct archive_read *, struct _7z_folder *);
 363 static int      read_Header(struct archive_read *, struct _7z_header_info *,
 364                     int);
 365 static int      read_PackInfo(struct archive_read *, struct _7z_pack_info *);
 366 static int      read_StreamsInfo(struct archive_read *,
 367                     struct _7z_stream_info *);
 368 static int      read_SubStreamsInfo(struct archive_read *,
 369                     struct _7z_substream_info *, struct _7z_folder *, size_t);
 370 static int      read_Times(struct archive_read *, struct _7z_header_info *,
 371                     int);
 372 static void     read_consume(struct archive_read *);
 373 static ssize_t  read_stream(struct archive_read *, const void **, size_t,
 374                     size_t);
 375 static int      seek_pack(struct archive_read *);
 376 static int64_t  skip_stream(struct archive_read *, size_t);
 377 static int      skip_sfx(struct archive_read *, ssize_t);
 378 static int      slurp_central_directory(struct archive_read *, struct _7zip *,
 379                     struct _7z_header_info *);
 380 static int      setup_decode_folder(struct archive_read *, struct _7z_folder *,
 381                     int);
 382 static void     x86_Init(struct _7zip *);
 383 static size_t   x86_Convert(struct _7zip *, uint8_t *, size_t);
 384 static ssize_t          Bcj2_Decode(struct _7zip *, uint8_t *, size_t);
 385
 386
 387 int
 388 archive_read_support_format_7zip(struct archive *_a)
 389 {
 390         struct archive_read *a = (struct archive_read *)_a;
 391         struct _7zip *zip;
 392         int r;
 393
 394         archive_check_magic(_a, ARCHIVE_READ_MAGIC,
 395             ARCHIVE_STATE_NEW, "archive_read_support_format_7zip");
 396
 397         zip = calloc(1, sizeof(*zip));
 398         if (zip == NULL) {
 399                 archive_set_error(&a->archive, ENOMEM,
 400                     "Can't allocate 7zip data");
 401                 return (ARCHIVE_FATAL);
 402         }
 403
 404         r = __archive_read_register_format(a,
 405             zip,
 406             "7zip",
 407             archive_read_format_7zip_bid,
 408             NULL,
 409             archive_read_format_7zip_read_header,
 410             archive_read_format_7zip_read_data,
 411             archive_read_format_7zip_read_data_skip,
 412             archive_read_format_7zip_cleanup);
 413
 414         if (r != ARCHIVE_OK)
 415                 free(zip);
 416         return (ARCHIVE_OK);
 417 }
 418
 419 static int
 420 archive_read_format_7zip_bid(struct archive_read *a, int best_bid)
 421 {
 422         const char *p;
 423
 424         /* If someone has already bid more than 32, then avoid
 425            trashing the look-ahead buffers with a seek. */
 426         if (best_bid > 32)
 427                 return (-1);
 428
 429         if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
 430                 return (0);
 431
 432         /* If first six bytes are the 7-Zip signature,
 433          * return the bid right now. */
 434         if (memcmp(p, _7ZIP_SIGNATURE, 6) == 0)
 435                 return (48);
 436
 437         /*
 438          * It may a 7-Zip SFX archive file. If first two bytes are
 439          * 'M' and 'Z' available on Windows or first four bytes are
 440          * "\x7F\x45LF" available on posix like system, seek the 7-Zip
 441          * signature. Although we will perform a seek when reading
 442          * a header, what we do not use __archive_read_seek() here is
 443          * due to a bidding performance.
 444          */
 445         if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
 446                 ssize_t offset = SFX_MIN_ADDR;
 447                 ssize_t window = 4096;
 448                 ssize_t bytes_avail;
 449                 while (offset + window <= (SFX_MAX_ADDR)) {
 450                         const char *buff = __archive_read_ahead(a,
 451                                         offset + window, &bytes_avail);
 452                         if (buff == NULL) {
 453                                 /* Remaining bytes are less than window. */
 454                                 window >>= 1;
 455                                 if (window < 0x40)
 456                                         return (0);
 457                                 continue;
 458                         }
 459                         p = buff + offset;
 460                         while (p + 32 < buff + bytes_avail) {
 461                                 int step = check_7zip_header_in_sfx(p);
 462                                 if (step == 0)
 463                                         return (48);
 464                                 p += step;
 465                         }
 466                         offset = p - buff;
 467                 }
 468         }
 469         return (0);
 470 }
 471
 472 static int
 473 check_7zip_header_in_sfx(const char *p)
 474 {
 475         switch ((unsigned char)p[5]) {
 476         case 0x1C:
 477                 if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0)
 478                         return (6);
 479                 /*
 480                  * Test the CRC because its extraction code has 7-Zip
 481                  * Magic Code, so we should do this in order not to
 482                  * make a mis-detection.
 483                  */
 484                 if (crc32(0, (const unsigned char *)p + 12, 20)
 485                         != archive_le32dec(p + 8))
 486                         return (6);
 487                 /* Hit the header! */
 488                 return (0);
 489         case 0x37: return (5);
 490         case 0x7A: return (4);
 491         case 0xBC: return (3);
 492         case 0xAF: return (2);
 493         case 0x27: return (1);
 494         default: return (6);
 495         }
 496 }
 497
 498 static int
 499 skip_sfx(struct archive_read *a, ssize_t bytes_avail)
 500 {
 501         const void *h;
 502         const char *p, *q;
 503         size_t skip, offset;
 504         ssize_t bytes, window;
 505
 506         /*
 507          * If bytes_avail > SFX_MIN_ADDR we do not have to call
 508          * __archive_read_seek() at this time since we have
 509          * alredy had enough data.
 510          */
 511         if (bytes_avail > SFX_MIN_ADDR)
 512                 __archive_read_consume(a, SFX_MIN_ADDR);
 513         else if (__archive_read_seek(a, SFX_MIN_ADDR, SEEK_SET) < 0)
 514                 return (ARCHIVE_FATAL);
 515
 516         offset = 0;
 517         window = 1;
 518         while (offset + window <= SFX_MAX_ADDR - SFX_MIN_ADDR) {
 519                 h = __archive_read_ahead(a, window, &bytes);
 520                 if (h == NULL) {
 521                         /* Remaining bytes are less than window. */
 522                         window >>= 1;
 523                         if (window < 0x40)
 524                                 goto fatal;
 525                         continue;
 526                 }
 527                 if (bytes < 6) {
 528                         /* This case might happen when window == 1. */
 529                         window = 4096;
 530                         continue;
 531                 }
 532                 p = (const char *)h;
 533                 q = p + bytes;
 534
 535                 /*
 536                  * Scan ahead until we find something that looks
 537                  * like the 7-Zip header.
 538                  */
 539                 while (p + 32 < q) {
 540                         int step = check_7zip_header_in_sfx(p);
 541                         if (step == 0) {
 542                                 struct _7zip *zip =
 543                                     (struct _7zip *)a->format->data;
 544                                 skip = p - (const char *)h;
 545                                 __archive_read_consume(a, skip);
 546                                 zip->seek_base = SFX_MIN_ADDR + offset + skip;
 547                                 return (ARCHIVE_OK);
 548                         }
 549                         p += step;
 550                 }
 551                 skip = p - (const char *)h;
 552                 __archive_read_consume(a, skip);
 553                 offset += skip;
 554                 if (window == 1)
 555                         window = 4096;
 556         }
 557 fatal:
 558         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
 559             "Couldn't find out 7-Zip header");
 560         return (ARCHIVE_FATAL);
 561 }
 562
 563 static int
 564 archive_read_format_7zip_read_header(struct archive_read *a,
 565         struct archive_entry *entry)
 566 {
 567         struct _7zip *zip = (struct _7zip *)a->format->data;
 568         struct _7zip_entry *zip_entry;
 569         int r, ret = ARCHIVE_OK;
 570
 571         a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;
 572         if (a->archive.archive_format_name == NULL)
 573                 a->archive.archive_format_name = "7-Zip";
 574
 575         if (zip->entries == NULL) {
 576                 struct _7z_header_info header;
 577
 578                 memset(&header, 0, sizeof(header));
 579                 r = slurp_central_directory(a, zip, &header);
 580                 free_Header(&header);
 581                 if (r != ARCHIVE_OK)
 582                         return (r);
 583                 zip->entries_remaining = (size_t)zip->numFiles;
 584                 zip->entry = zip->entries;
 585         } else {
 586                 ++zip->entry;
 587         }
 588         zip_entry = zip->entry;
 589
 590         if (zip->entries_remaining <= 0)
 591                 return ARCHIVE_EOF;
 592         --zip->entries_remaining;
 593
 594         zip->entry_offset = 0;
 595         zip->end_of_entry = 0;
 596         zip->entry_crc32 = crc32(0, NULL, 0);
 597
 598         /* Setup a string conversion for a filename. */
 599         if (zip->sconv == NULL) {
 600                 zip->sconv = archive_string_conversion_from_charset(
 601                     &a->archive, "UTF-16LE", 1);
 602                 if (zip->sconv == NULL)
 603                         return (ARCHIVE_FATAL);
 604         }
 605
 606         if (archive_entry_copy_pathname_l(entry,
 607             (const char *)zip_entry->utf16name,
 608             zip_entry->name_len, zip->sconv) != 0) {
 609                 if (errno == ENOMEM) {
 610                         archive_set_error(&a->archive, ENOMEM,
 611                             "Can't allocate memory for Pathname");
 612                         return (ARCHIVE_FATAL);
 613                 }
 614                 archive_set_error(&a->archive,
 615                     ARCHIVE_ERRNO_FILE_FORMAT,
 616                     "Pathname cannot be converted "
 617                     "from %s to current locale.",
 618                     archive_string_conversion_charset_name(zip->sconv));
 619                 ret = ARCHIVE_WARN;
 620         }
 621
 622         /* Populate some additional entry fields: */
 623         archive_entry_set_mode(entry, zip_entry->mode);
 624         if (zip_entry->flg & MTIME_IS_SET)
 625                 archive_entry_set_mtime(entry, zip_entry->mtime,
 626                         zip_entry->mtime_ns);
 627         if (zip_entry->flg & CTIME_IS_SET)
 628                 archive_entry_set_ctime(entry, zip_entry->ctime,
 629                     zip_entry->ctime_ns);
 630         if (zip_entry->flg & ATIME_IS_SET)
 631                 archive_entry_set_atime(entry, zip_entry->atime,
 632                     zip_entry->atime_ns);
 633         if (zip_entry->ssIndex != (uint32_t)-1) {
 634                 zip->entry_bytes_remaining =
 635                     zip->si.ss.unpackSizes[zip_entry->ssIndex];
 636                 archive_entry_set_size(entry, zip->entry_bytes_remaining);
 637         } else {
 638                 zip->entry_bytes_remaining = 0;
 639                 archive_entry_set_size(entry, 0);
 640         }
 641
 642         /* If there's no body, force read_data() to return EOF immediately. */
 643         if (zip->entry_bytes_remaining < 1)
 644                 zip->end_of_entry = 1;
 645
 646         if ((zip_entry->mode & AE_IFMT) == AE_IFLNK) {
 647                 unsigned char *symname = NULL;
 648                 size_t symsize = 0;
 649
 650                 /*
 651                  * Symbolic-name is recorded as its contents. We have to
 652                  * read the contents at this time.
 653                  */
 654                 while (zip->entry_bytes_remaining > 0) {
 655                         const void *buff;
 656                         unsigned char *mem;
 657                         size_t size;
 658                         int64_t offset;
 659
 660                         r = archive_read_format_7zip_read_data(a, &buff,
 661                                 &size, &offset);
 662                         if (r < ARCHIVE_WARN) {
 663                                 free(symname);
 664                                 return (r);
 665                         }
 666                         mem = realloc(symname, symsize + size + 1);
 667                         if (mem == NULL) {
 668                                 free(symname);
 669                                 archive_set_error(&a->archive, ENOMEM,
 670                                     "Can't allocate memory for Symname");
 671                                 return (ARCHIVE_FATAL);
 672                         }
 673                         symname = mem;
 674                         memcpy(symname+symsize, buff, size);
 675                         symsize += size;
 676                 }
 677                 if (symsize == 0) {
 678                         /* If there is no synname, handle it as a regular
 679                          * file. */
 680                         zip_entry->mode &= ~AE_IFMT;
 681                         zip_entry->mode |= AE_IFREG;
 682                         archive_entry_set_mode(entry, zip_entry->mode);
 683                 } else {
 684                         symname[symsize] = '\0';
 685                         archive_entry_copy_symlink(entry,
 686                             (const char *)symname);
 687                         free(symname);
 688                 }
 689                 archive_entry_set_size(entry, 0);
 690         }
 691
 692         /* Set up a more descriptive format name. */
 693         sprintf(zip->format_name, "7-Zip");
 694         a->archive.archive_format_name = zip->format_name;
 695
 696         return (ret);
 697 }
 698
 699 static int
 700 archive_read_format_7zip_read_data(struct archive_read *a,
 701     const void **buff, size_t *size, int64_t *offset)
 702 {
 703         struct _7zip *zip;
 704         ssize_t bytes;
 705         int ret = ARCHIVE_OK;
 706
 707         zip = (struct _7zip *)(a->format->data);
 708
 709         if (zip->pack_stream_bytes_unconsumed)
 710                 read_consume(a);
 711
 712         /*
 713          * If we hit end-of-entry last time, clean up and return
 714          * ARCHIVE_EOF this time.
 715          */
 716         if (zip->end_of_entry) {
 717                 *offset = zip->entry_offset;
 718                 *size = 0;
 719                 *buff = NULL;
 720                 return (ARCHIVE_EOF);
 721         }
 722
 723         bytes = read_stream(a, buff,
 724                 (size_t)zip->entry_bytes_remaining, 0);
 725         if (bytes < 0)
 726                 return ((int)bytes);
 727         if (bytes == 0) {
 728                 archive_set_error(&a->archive,
 729                     ARCHIVE_ERRNO_FILE_FORMAT,
 730                     "Truncated 7-Zip file body");
 731                 return (ARCHIVE_FATAL);
 732         }
 733         zip->entry_bytes_remaining -= bytes;
 734         if (zip->entry_bytes_remaining == 0)
 735                 zip->end_of_entry = 1;
 736
 737         /* Update checksum */
 738         if ((zip->entry->flg & CRC32_IS_SET) && bytes)
 739                 zip->entry_crc32 = crc32(zip->entry_crc32, *buff, bytes);
 740
 741         /* If we hit the end, swallow any end-of-data marker. */
 742         if (zip->end_of_entry) {
 743                 /* Check computed CRC against file contents. */
 744                 if ((zip->entry->flg & CRC32_IS_SET) &&
 745                         zip->si.ss.digests[zip->entry->ssIndex] !=
 746                     zip->entry_crc32) {
 747                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
 748                             "7-Zip bad CRC: 0x%lx should be 0x%lx",
 749                             (unsigned long)zip->entry_crc32,
 750                             (unsigned long)zip->si.ss.digests[
 751                                         zip->entry->ssIndex]);
 752                         ret = ARCHIVE_WARN;
 753                 }
 754         }
 755
 756         *size = bytes;
 757         *offset = zip->entry_offset;
 758         zip->entry_offset += bytes;
 759
 760         return (ret);
 761 }
 762
 763 static int
 764 archive_read_format_7zip_read_data_skip(struct archive_read *a)
 765 {
 766         struct _7zip *zip;
 767         int64_t bytes_skipped;
 768
 769         zip = (struct _7zip *)(a->format->data);
 770
 771         if (zip->pack_stream_bytes_unconsumed)
 772                 read_consume(a);
 773
 774         /* If we've already read to end of data, we're done. */
 775         if (zip->end_of_entry)
 776                 return (ARCHIVE_OK);
 777
 778         /*
 779          * If the length is at the beginning, we can skip the
 780          * compressed data much more quickly.
 781          */
 782         bytes_skipped = skip_stream(a, (size_t)zip->entry_bytes_remaining);
 783         if (bytes_skipped < 0)
 784                 return (ARCHIVE_FATAL);
 785         zip->entry_bytes_remaining = 0;
 786
 787         /* This entry is finished and done. */
 788         zip->end_of_entry = 1;
 789         return (ARCHIVE_OK);
 790 }
 791
 792 static int
 793 archive_read_format_7zip_cleanup(struct archive_read *a)
 794 {
 795         struct _7zip *zip;
 796
 797         zip = (struct _7zip *)(a->format->data);
 798         free_StreamsInfo(&(zip->si));
 799         free(zip->entries);
 800         free(zip->entry_names);
 801         free_decompression(a, zip);
 802         free(zip->uncompressed_buffer);
 803         free(zip->sub_stream_buff[0]);
 804         free(zip->sub_stream_buff[1]);
 805         free(zip->sub_stream_buff[2]);
 806         free(zip->tmp_stream_buff);
 807         free(zip);
 808         (a->format->data) = NULL;
 809         return (ARCHIVE_OK);
 810 }
 811
 812 static void
 813 read_consume(struct archive_read *a)
 814 {
 815         struct _7zip *zip = (struct _7zip *)a->format->data;
 816
 817         if (zip->pack_stream_bytes_unconsumed) {
 818                 __archive_read_consume(a, zip->pack_stream_bytes_unconsumed);
 819                 zip->stream_offset += zip->pack_stream_bytes_unconsumed;
 820                 zip->pack_stream_bytes_unconsumed = 0;
 821         }
 822 }
 823
 824 #ifdef HAVE_LZMA_H
 825
 826 /*
 827  * Set an error code and choose an error message for liblzma.
 828  */
 829 static void
 830 set_error(struct archive_read *a, int ret)
 831 {
 832
 833         switch (ret) {
 834         case LZMA_STREAM_END: /* Found end of stream. */
 835         case LZMA_OK: /* Decompressor made some progress. */
 836                 break;
 837         case LZMA_MEM_ERROR:
 838                 archive_set_error(&a->archive, ENOMEM,
 839                     "Lzma library error: Cannot allocate memory");
 840                 break;
 841         case LZMA_MEMLIMIT_ERROR:
 842                 archive_set_error(&a->archive, ENOMEM,
 843                     "Lzma library error: Out of memory");
 844                 break;
 845         case LZMA_FORMAT_ERROR:
 846                 archive_set_error(&a->archive,
 847                     ARCHIVE_ERRNO_MISC,
 848                     "Lzma library error: format not recognized");
 849                 break;
 850         case LZMA_OPTIONS_ERROR:
 851                 archive_set_error(&a->archive,
 852                     ARCHIVE_ERRNO_MISC,
 853                     "Lzma library error: Invalid options");
 854                 break;
 855         case LZMA_DATA_ERROR:
 856                 archive_set_error(&a->archive,
 857                     ARCHIVE_ERRNO_MISC,
 858                     "Lzma library error: Corrupted input data");
 859                 break;
 860         case LZMA_BUF_ERROR:
 861                 archive_set_error(&a->archive,
 862                     ARCHIVE_ERRNO_MISC,
 863                     "Lzma library error:  No progress is possible");
 864                 break;
 865         default:
 866                 /* Return an error. */
 867                 archive_set_error(&a->archive,
 868                     ARCHIVE_ERRNO_MISC,
 869                     "Lzma decompression failed:  Unknown error");
 870                 break;
 871         }
 872 }
 873
 874 #endif
 875
 876 static unsigned long
 877 decode_codec_id(const unsigned char *codecId, size_t id_size)
 878 {
 879         unsigned i;
 880         unsigned long id = 0;
 881
 882         for (i = 0; i < id_size; i++) {
 883                 id <<= 8;
 884                 id += codecId[i];
 885         }
 886         return (id);
 887 }
 888
 889 static void *
 890 ppmd_alloc(void *p, size_t size)
 891 {
 892         (void)p;
 893         return malloc(size);
 894 }
 895 static void
 896 ppmd_free(void *p, void *address)
 897 {
 898         (void)p;
 899         free(address);
 900 }
 901 static Byte
 902 ppmd_read(void *p)
 903 {
 904         struct archive_read *a = ((IByteIn*)p)->a;
 905         struct _7zip *zip = (struct _7zip *)(a->format->data);
 906         Byte b;
 907
 908         if (zip->ppstream.avail_in == 0) {
 909                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
 910                     "Truncated RAR file data");
 911                 zip->ppstream.overconsumed = 1;
 912                 return (0);
 913         }
 914         b = *zip->ppstream.next_in++;
 915         zip->ppstream.avail_in--;
 916         zip->ppstream.total_in++;
 917         return (b);
 918 }
 919
 920 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free };
 921
 922 static int
 923 init_decompression(struct archive_read *a, struct _7zip *zip,
 924     const struct _7z_coder *coder1, const struct _7z_coder *coder2)
 925 {
 926         int r;
 927
 928         zip->codec = coder1->codec;
 929         zip->codec2 = -1;
 930
 931         switch (zip->codec) {
 932         case _7Z_COPY:
 933         case _7Z_BZ2:
 934         case _7Z_DEFLATE:
 935         case _7Z_PPMD:
 936                 if (coder2 != NULL) {
 937                         if (coder2->codec != _7Z_X86 &&
 938                             coder2->codec != _7Z_X86_BCJ2) {
 939                                 archive_set_error(&a->archive,
 940                                     ARCHIVE_ERRNO_MISC,
 941                                     "Unsupported filter %lx for %lx",
 942                                     coder2->codec, coder1->codec);
 943                                 return (ARCHIVE_FAILED);
 944                         }
 945                         zip->codec2 = coder2->codec;
 946                         zip->bcj_state = 0;
 947                         if (coder2->codec == _7Z_X86)
 948                                 x86_Init(zip);
 949                 }
 950                 break;
 951         default:
 952                 break;
 953         }
 954
 955         switch (zip->codec) {
 956         case _7Z_COPY:
 957                 break;
 958
 959         case _7Z_LZMA: case _7Z_LZMA2:
 960 #ifdef HAVE_LZMA_H
 961 #if LZMA_VERSION_MAJOR >= 5
 962 /* Effectively disable the limiter. */
 963 #define LZMA_MEMLIMIT   UINT64_MAX
 964 #else
 965 /* NOTE: This needs to check memory size which running system has. */
 966 #define LZMA_MEMLIMIT   (1U << 30)
 967 #endif
 968         {
 969                 lzma_options_delta delta_opt;
 970                 lzma_filter filters[LZMA_FILTERS_MAX];
 971 #if LZMA_VERSION < 50000030
 972                 lzma_filter *ff;
 973 #endif
 974                 int fi = 0;
 975
 976                 if (zip->lzstream_valid) {
 977                         lzma_end(&(zip->lzstream));
 978                         zip->lzstream_valid = 0;
 979                 }
 980
 981                 /*
 982                  * NOTE: liblzma incompletely handle the BCJ+LZMA compressed
 983                  * data made by 7-Zip because 7-Zip does not add End-Of-
 984                  * Payload Marker(EOPM) at the end of LZMA compressed data,
 985                  * and so liblzma cannot know the end of the compressed data
 986                  * without EOPM. So consequently liblzma will not return last
 987                  * three or four bytes of uncompressed data because
 988                  * LZMA_FILTER_X86 filter does not handle input data if its
 989                  * data size is less than five bytes. If liblzma detect EOPM
 990                  * or know the uncompressed data size, liblzma will flush out
 991                  * the remaining that three or four bytes of uncompressed
 992                  * data. That is why we have to use our converting program
 993                  * for BCJ+LZMA. If we were able to tell the uncompressed
 994                  * size to liblzma when using lzma_raw_decoder() liblzma
 995                  * could correctly deal with BCJ+LZMA. But unfortunately
 996                  * there is no way to do that.
 997                  * Discussion about this can be found at XZ Utils forum.
 998                  */
 999                 if (coder2 != NULL) {
1000                         zip->codec2 = coder2->codec;
1001
1002                         filters[fi].options = NULL;
1003                         switch (zip->codec2) {
1004                         case _7Z_X86:
1005                                 if (zip->codec == _7Z_LZMA2) {
1006                                         filters[fi].id = LZMA_FILTER_X86;
1007                                         fi++;
1008                                 } else
1009                                         /* Use our filter. */
1010                                         x86_Init(zip);
1011                                 break;
1012                         case _7Z_X86_BCJ2:
1013                                 /* Use our filter. */
1014                                 zip->bcj_state = 0;
1015                                 break;
1016                         case _7Z_DELTA:
1017                                 filters[fi].id = LZMA_FILTER_DELTA;
1018                                 memset(&delta_opt, 0, sizeof(delta_opt));
1019                                 delta_opt.type = LZMA_DELTA_TYPE_BYTE;
1020                                 delta_opt.dist = 1;
1021                                 filters[fi].options = &delta_opt;
1022                                 fi++;
1023                                 break;
1024                         /* Following filters have not been tested yet. */
1025                         case _7Z_POWERPC:
1026                                 filters[fi].id = LZMA_FILTER_POWERPC;
1027                                 fi++;
1028                                 break;
1029                         case _7Z_IA64:
1030                                 filters[fi].id = LZMA_FILTER_IA64;
1031                                 fi++;
1032                                 break;
1033                         case _7Z_ARM:
1034                                 filters[fi].id = LZMA_FILTER_ARM;
1035                                 fi++;
1036                                 break;
1037                         case _7Z_ARMTHUMB:
1038                                 filters[fi].id = LZMA_FILTER_ARMTHUMB;
1039                                 fi++;
1040                                 break;
1041                         case _7Z_SPARC:
1042                                 filters[fi].id = LZMA_FILTER_SPARC;
1043                                 fi++;
1044                                 break;
1045                         default:
1046                                 archive_set_error(&a->archive,
1047                                     ARCHIVE_ERRNO_MISC,
1048                                     "Unexpected codec ID: %lX", zip->codec2);
1049                                 return (ARCHIVE_FAILED);
1050                         }
1051                 }
1052
1053                 if (zip->codec == _7Z_LZMA2)
1054                         filters[fi].id = LZMA_FILTER_LZMA2;
1055                 else
1056                         filters[fi].id = LZMA_FILTER_LZMA1;
1057                 filters[fi].options = NULL;
1058 #if LZMA_VERSION < 50000030
1059                 ff = &filters[fi];
1060 #endif
1061                 r = lzma_properties_decode(&filters[fi], NULL,
1062                     coder1->properties, (size_t)coder1->propertiesSize);
1063                 if (r != LZMA_OK) {
1064                         set_error(a, r);
1065                         return (ARCHIVE_FAILED);
1066                 }
1067                 fi++;
1068
1069                 filters[fi].id = LZMA_VLI_UNKNOWN;
1070                 filters[fi].options = NULL;
1071                 r = lzma_raw_decoder(&(zip->lzstream), filters);
1072 #if LZMA_VERSION < 50000030
1073                 free(ff->options);
1074 #endif
1075                 if (r != LZMA_OK) {
1076                         set_error(a, r);
1077                         return (ARCHIVE_FAILED);
1078                 }
1079                 zip->lzstream_valid = 1;
1080                 zip->lzstream.total_in = 0;
1081                 zip->lzstream.total_out = 0;
1082                 break;
1083         }
1084 #else
1085                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1086                     "LZMA codec is unsupported");
1087                 return (ARCHIVE_FAILED);
1088 #endif
1089         case _7Z_BZ2:
1090 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1091                 if (zip->bzstream_valid) {
1092                         BZ2_bzDecompressEnd(&(zip->bzstream));
1093                         zip->bzstream_valid = 0;
1094                 }
1095                 r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 0);
1096                 if (r == BZ_MEM_ERROR)
1097                         r = BZ2_bzDecompressInit(&(zip->bzstream), 0, 1);
1098                 if (r != BZ_OK) {
1099                         int err = ARCHIVE_ERRNO_MISC;
1100                         const char *detail = NULL;
1101                         switch (r) {
1102                         case BZ_PARAM_ERROR:
1103                                 detail = "invalid setup parameter";
1104                                 break;
1105                         case BZ_MEM_ERROR:
1106                                 err = ENOMEM;
1107                                 detail = "out of memory";
1108                                 break;
1109                         case BZ_CONFIG_ERROR:
1110                                 detail = "mis-compiled library";
1111                                 break;
1112                         }
1113                         archive_set_error(&a->archive, err,
1114                             "Internal error initializing decompressor: %s",
1115                             detail == NULL ? "??" : detail);
1116                         zip->bzstream_valid = 0;
1117                         return (ARCHIVE_FAILED);
1118                 }
1119                 zip->bzstream_valid = 1;
1120                 zip->bzstream.total_in_lo32 = 0;
1121                 zip->bzstream.total_in_hi32 = 0;
1122                 zip->bzstream.total_out_lo32 = 0;
1123                 zip->bzstream.total_out_hi32 = 0;
1124                 break;
1125 #else
1126                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1127                     "BZ2 codec is unsupported");
1128                 return (ARCHIVE_FAILED);
1129 #endif
1130         case _7Z_DEFLATE:
1131 #ifdef HAVE_ZLIB_H
1132                 if (zip->stream_valid)
1133                         r = inflateReset(&(zip->stream));
1134                 else
1135                         r = inflateInit2(&(zip->stream),
1136                             -15 /* Don't check for zlib header */);
1137                 if (r != Z_OK) {
1138                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1139                             "Couldn't initialize zlib stream.");
1140                         return (ARCHIVE_FAILED);
1141                 }
1142                 zip->stream_valid = 1;
1143                 zip->stream.total_in = 0;
1144                 zip->stream.total_out = 0;
1145                 break;
1146 #else
1147                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1148                     "DEFLATE codec is unsupported");
1149                 return (ARCHIVE_FAILED);
1150 #endif
1151         case _7Z_PPMD:
1152         {
1153                 unsigned order;
1154                 uint32_t msize;
1155
1156                 if (zip->ppmd7_valid) {
1157                         __archive_ppmd7_functions.Ppmd7_Free(
1158                             &zip->ppmd7_context, &g_szalloc);
1159                         zip->ppmd7_valid = 0;
1160                 }
1161
1162                 if (coder1->propertiesSize < 5) {
1163                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1164                             "Malformed PPMd parameter");
1165                         return (ARCHIVE_FAILED);
1166                 }
1167                 order = coder1->properties[0];
1168                 msize = archive_le32dec(&(coder1->properties[1]));
1169                 if (order < PPMD7_MIN_ORDER || order > PPMD7_MAX_ORDER ||
1170                     msize < PPMD7_MIN_MEM_SIZE || msize > PPMD7_MAX_MEM_SIZE) {
1171                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1172                             "Malformed PPMd parameter");
1173                         return (ARCHIVE_FAILED);
1174                 }
1175                 __archive_ppmd7_functions.Ppmd7_Construct(&zip->ppmd7_context);
1176                 r = __archive_ppmd7_functions.Ppmd7_Alloc(
1177                         &zip->ppmd7_context, msize, &g_szalloc);
1178                 if (r == 0) {
1179                         archive_set_error(&a->archive, ENOMEM,
1180                             "Coludn't allocate memory for PPMd");
1181                         return (ARCHIVE_FATAL);
1182                 }
1183                 __archive_ppmd7_functions.Ppmd7_Init(
1184                         &zip->ppmd7_context, order);
1185                 __archive_ppmd7_functions.Ppmd7z_RangeDec_CreateVTable(
1186                         &zip->range_dec);
1187                 zip->ppmd7_valid = 1;
1188                 zip->ppmd7_stat = 0;
1189                 zip->ppstream.overconsumed = 0;
1190                 zip->ppstream.total_in = 0;
1191                 zip->ppstream.total_out = 0;
1192                 break;
1193         }
1194         case _7Z_X86:
1195         case _7Z_X86_BCJ2:
1196         case _7Z_POWERPC:
1197         case _7Z_IA64:
1198         case _7Z_ARM:
1199         case _7Z_ARMTHUMB:
1200         case _7Z_SPARC:
1201         case _7Z_DELTA:
1202                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1203                     "Unexpected codec ID: %lX", zip->codec);
1204                 return (ARCHIVE_FAILED);
1205         default:
1206                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1207                     "Unknown codec ID: %lX", zip->codec);
1208                 return (ARCHIVE_FAILED);
1209         }
1210
1211         return (ARCHIVE_OK);
1212 }
1213
1214 static int
1215 decompress(struct archive_read *a, struct _7zip *zip,
1216     void *buff, size_t *outbytes, const void *b, size_t *used)
1217 {
1218         const uint8_t *t_next_in;
1219         uint8_t *t_next_out;
1220         size_t o_avail_in, o_avail_out;
1221         size_t t_avail_in, t_avail_out;
1222         uint8_t *bcj2_next_out;
1223         size_t bcj2_avail_out;
1224         int r, ret = ARCHIVE_OK;
1225
1226         t_avail_in = o_avail_in = *used;
1227         t_avail_out = o_avail_out = *outbytes;
1228         t_next_in = b;
1229         t_next_out = buff;
1230
1231         if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1232                 int i;
1233
1234                 /* Do not copy out the BCJ remaining bytes when the output
1235                  * buffer size is less than five bytes. */
1236                 if (o_avail_in != 0 && t_avail_out < 5 && zip->odd_bcj_size) {
1237                         *used = 0;
1238                         *outbytes = 0;
1239                         return (ret);
1240                 }
1241                 for (i = 0; zip->odd_bcj_size > 0 && t_avail_out; i++) {
1242                         *t_next_out++ = zip->odd_bcj[i];
1243                         t_avail_out--;
1244                         zip->odd_bcj_size--;
1245                 }
1246                 if (o_avail_in == 0 || t_avail_out == 0) {
1247                         *used = o_avail_in - t_avail_in;
1248                         *outbytes = o_avail_out - t_avail_out;
1249                         if (o_avail_in == 0)
1250                                 ret = ARCHIVE_EOF;
1251                         return (ret);
1252                 }
1253         }
1254
1255         bcj2_next_out = t_next_out;
1256         bcj2_avail_out = t_avail_out;
1257         if (zip->codec2 == _7Z_X86_BCJ2) {
1258                 /*
1259                  * Decord a remaining decompressed main stream for BCJ2.
1260                  */
1261                 if (zip->tmp_stream_bytes_remaining) {
1262                         ssize_t bytes;
1263                         size_t remaining = zip->tmp_stream_bytes_remaining;
1264                         bytes = Bcj2_Decode(zip, t_next_out, t_avail_out);
1265                         if (bytes < 0) {
1266                                 archive_set_error(&(a->archive),
1267                                     ARCHIVE_ERRNO_MISC,
1268                                     "BCJ2 conversion Failed");
1269                                 return (ARCHIVE_FAILED);
1270                         }
1271                         zip->main_stream_bytes_remaining -=
1272                             remaining - zip->tmp_stream_bytes_remaining;
1273                         t_avail_out -= bytes;
1274                         if (o_avail_in == 0 || t_avail_out == 0) {
1275                                 *used = 0;
1276                                 *outbytes = o_avail_out - t_avail_out;
1277                                 if (o_avail_in == 0 &&
1278                                     zip->tmp_stream_bytes_remaining)
1279                                         ret = ARCHIVE_EOF;
1280                                 return (ret);
1281                         }
1282                         t_next_out += bytes;
1283                         bcj2_next_out = t_next_out;
1284                         bcj2_avail_out = t_avail_out;
1285                 }
1286                 t_next_out = zip->tmp_stream_buff;
1287                 t_avail_out = zip->tmp_stream_buff_size;
1288         }
1289
1290         switch (zip->codec) {
1291         case _7Z_COPY:
1292         {
1293                 size_t bytes =
1294                     (t_avail_in > t_avail_out)?t_avail_out:t_avail_in;
1295
1296                 memcpy(t_next_out, t_next_in, bytes);
1297                 t_avail_in -= bytes;
1298                 t_avail_out -= bytes;
1299                 if (o_avail_in == 0)
1300                         ret = ARCHIVE_EOF;
1301                 break;
1302         }
1303 #ifdef HAVE_LZMA_H
1304         case _7Z_LZMA: case _7Z_LZMA2:
1305                 zip->lzstream.next_in = t_next_in;
1306                 zip->lzstream.avail_in = t_avail_in;
1307                 zip->lzstream.next_out = t_next_out;
1308                 zip->lzstream.avail_out = t_avail_out;
1309
1310                 r = lzma_code(&(zip->lzstream), LZMA_RUN);
1311                 switch (r) {
1312                 case LZMA_STREAM_END: /* Found end of stream. */
1313                         lzma_end(&(zip->lzstream));
1314                         zip->lzstream_valid = 0;
1315                         ret = ARCHIVE_EOF;
1316                         break;
1317                 case LZMA_OK: /* Decompressor made some progress. */
1318                         break;
1319                 default:
1320                         archive_set_error(&(a->archive),
1321                             ARCHIVE_ERRNO_MISC,
1322                                 "Decompression failed(%d)",
1323                             r);
1324                         return (ARCHIVE_FAILED);
1325                 }
1326                 t_avail_in = zip->lzstream.avail_in;
1327                 t_avail_out = zip->lzstream.avail_out;
1328                 break;
1329 #endif
1330 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1331         case _7Z_BZ2:
1332                 zip->bzstream.next_in = (char *)(uintptr_t)t_next_in;
1333                 zip->bzstream.avail_in = t_avail_in;
1334                 zip->bzstream.next_out = (char *)(uintptr_t)t_next_out;
1335                 zip->bzstream.avail_out = t_avail_out;
1336                 r = BZ2_bzDecompress(&(zip->bzstream));
1337                 switch (r) {
1338                 case BZ_STREAM_END: /* Found end of stream. */
1339                         switch (BZ2_bzDecompressEnd(&(zip->bzstream))) {
1340                         case BZ_OK:
1341                                 break;
1342                         default:
1343                                 archive_set_error(&(a->archive),
1344                                     ARCHIVE_ERRNO_MISC,
1345                                     "Failed to clean up decompressor");
1346                                 return (ARCHIVE_FAILED);
1347                         }
1348                         zip->bzstream_valid = 0;
1349                         ret = ARCHIVE_EOF;
1350                         break;
1351                 case BZ_OK: /* Decompressor made some progress. */
1352                         break;
1353                 default:
1354                         archive_set_error(&(a->archive),
1355                             ARCHIVE_ERRNO_MISC,
1356                             "bzip decompression failed");
1357                         return (ARCHIVE_FAILED);
1358                 }
1359                 t_avail_in = zip->bzstream.avail_in;
1360                 t_avail_out = zip->bzstream.avail_out;
1361                 break;
1362 #endif
1363 #ifdef HAVE_ZLIB_H
1364         case _7Z_DEFLATE:
1365                 zip->stream.next_in = (Bytef *)(uintptr_t)t_next_in;
1366                 zip->stream.avail_in = t_avail_in;
1367                 zip->stream.next_out = t_next_out;
1368                 zip->stream.avail_out = t_avail_out;
1369                 r = inflate(&(zip->stream), 0);
1370                 switch (r) {
1371                 case Z_STREAM_END: /* Found end of stream. */
1372                         ret = ARCHIVE_EOF;
1373                         break;
1374                 case Z_OK: /* Decompressor made some progress.*/
1375                         break;
1376                 default:
1377                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1378                             "File decompression failed (%d)", r);
1379                         return (ARCHIVE_FAILED);
1380                 }
1381                 t_avail_in = zip->stream.avail_in;
1382                 t_avail_out = zip->stream.avail_out;
1383                 break;
1384 #endif
1385         case _7Z_PPMD:
1386         {
1387                 uint64_t flush_bytes;
1388
1389                 if (!zip->ppmd7_valid || zip->ppmd7_stat < 0 ||
1390                     t_avail_out <= 0) {
1391                         archive_set_error(&(a->archive),
1392                             ARCHIVE_ERRNO_MISC,
1393                             "Decompression internal error");
1394                         return (ARCHIVE_FAILED);
1395                 }
1396                 zip->ppstream.next_in = t_next_in;
1397                 zip->ppstream.avail_in = t_avail_in;
1398                 zip->ppstream.next_out = t_next_out;
1399                 zip->ppstream.avail_out = t_avail_out;
1400                 if (zip->ppmd7_stat == 0) {
1401                         zip->bytein.a = a;
1402                         zip->bytein.Read = &ppmd_read;
1403                         zip->range_dec.Stream = &zip->bytein;
1404                         r = __archive_ppmd7_functions.Ppmd7z_RangeDec_Init(
1405                                 &(zip->range_dec));
1406                         if (r == 0) {
1407                                 zip->ppmd7_stat = -1;
1408                                 archive_set_error(&a->archive,
1409                                     ARCHIVE_ERRNO_MISC,
1410                                     "Failed to initialize PPMd range decorder");
1411                                 return (ARCHIVE_FAILED);
1412                         }
1413                         if (zip->ppstream.overconsumed) {
1414                                 zip->ppmd7_stat = -1;
1415                                 return (ARCHIVE_FAILED);
1416                         }
1417                         zip->ppmd7_stat = 1;
1418                 }
1419
1420                 if (t_avail_in == 0)
1421                         /* XXX Flush out remaining decoded data XXX */
1422                         flush_bytes = zip->folder_outbytes_remaining;
1423                 else
1424                         flush_bytes = 0;
1425
1426                 do {
1427                         int sym;
1428
1429                         sym = __archive_ppmd7_functions.Ppmd7_DecodeSymbol(
1430                                 &(zip->ppmd7_context), &(zip->range_dec.p));
1431                         if (sym < 0) {
1432                                 zip->ppmd7_stat = -1;
1433                                 archive_set_error(&a->archive,
1434                                     ARCHIVE_ERRNO_FILE_FORMAT,
1435                                     "Failed to decode PPMd");
1436                                 return (ARCHIVE_FAILED);
1437                         }
1438                         if (zip->ppstream.overconsumed) {
1439                                 zip->ppmd7_stat = -1;
1440                                 return (ARCHIVE_FAILED);
1441                         }
1442                         *zip->ppstream.next_out++ = (unsigned char)sym;
1443                         zip->ppstream.avail_out--;
1444                         zip->ppstream.total_out++;
1445                         if (flush_bytes)
1446                                 flush_bytes--;
1447                 } while (zip->ppstream.avail_out &&
1448                         (zip->ppstream.avail_in || flush_bytes));
1449
1450                 t_avail_in = (size_t)zip->ppstream.avail_in;
1451                 t_avail_out = (size_t)zip->ppstream.avail_out;
1452                 break;
1453         }
1454         default:
1455                 archive_set_error(&(a->archive), ARCHIVE_ERRNO_MISC,
1456                     "Decompression internal error");
1457                 return (ARCHIVE_FAILED);
1458         }
1459         if (ret != ARCHIVE_OK && ret != ARCHIVE_EOF)
1460                 return (ret);
1461
1462         *used = o_avail_in - t_avail_in;
1463         *outbytes = o_avail_out - t_avail_out;
1464
1465         /*
1466          * Decord BCJ.
1467          */
1468         if (zip->codec != _7Z_LZMA2 && zip->codec2 == _7Z_X86) {
1469                 size_t l = x86_Convert(zip, buff, *outbytes);
1470                 zip->odd_bcj_size = *outbytes - l;
1471                 if (zip->odd_bcj_size > 0 && zip->odd_bcj_size <= 4 &&
1472                     o_avail_in && ret != ARCHIVE_EOF) {
1473                         memcpy(zip->odd_bcj, ((unsigned char *)buff) + l,
1474                             zip->odd_bcj_size);
1475                         *outbytes = l;
1476                 } else
1477                         zip->odd_bcj_size = 0;
1478         }
1479
1480         /*
1481          * Decord BCJ2 with a decompressed main stream.
1482          */
1483         if (zip->codec2 == _7Z_X86_BCJ2) {
1484                 ssize_t bytes;
1485
1486                 zip->tmp_stream_bytes_avail =
1487                     zip->tmp_stream_buff_size - t_avail_out;
1488                 if (zip->tmp_stream_bytes_avail >
1489                       zip->main_stream_bytes_remaining)
1490                         zip->tmp_stream_bytes_avail =
1491                             zip->main_stream_bytes_remaining;
1492                 zip->tmp_stream_bytes_remaining = zip->tmp_stream_bytes_avail;
1493                 bytes = Bcj2_Decode(zip, bcj2_next_out, bcj2_avail_out);
1494                 if (bytes < 0) {
1495                         archive_set_error(&(a->archive),
1496                             ARCHIVE_ERRNO_MISC, "BCJ2 conversion Failed");
1497                         return (ARCHIVE_FAILED);
1498                 }
1499                 zip->main_stream_bytes_remaining -=
1500                     zip->tmp_stream_bytes_avail
1501                       - zip->tmp_stream_bytes_remaining;
1502                 bcj2_avail_out -= bytes;
1503                 *outbytes = o_avail_out - bcj2_avail_out;
1504         }
1505
1506         return (ret);
1507 }
1508
1509 static int
1510 free_decompression(struct archive_read *a, struct _7zip *zip)
1511 {
1512         int r = ARCHIVE_OK;
1513
1514 #if !defined(HAVE_ZLIB_H) &&\
1515         !(defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR))
1516         (void)a;/* UNUSED */
1517 #endif
1518 #ifdef HAVE_LZMA_H
1519         if (zip->lzstream_valid)
1520                 lzma_end(&(zip->lzstream));
1521 #endif
1522 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1523         if (zip->bzstream_valid) {
1524                 if (BZ2_bzDecompressEnd(&(zip->bzstream)) != BZ_OK) {
1525                         archive_set_error(&a->archive,
1526                             ARCHIVE_ERRNO_MISC,
1527                             "Failed to clean up bzip2 decompressor");
1528                         r = ARCHIVE_FATAL;
1529                 }
1530                 zip->bzstream_valid = 0;
1531         }
1532 #endif
1533 #ifdef HAVE_ZLIB_H
1534         if (zip->stream_valid) {
1535                 if (inflateEnd(&(zip->stream)) != Z_OK) {
1536                         archive_set_error(&a->archive,
1537                             ARCHIVE_ERRNO_MISC,
1538                             "Failed to clean up zlib decompressor");
1539                         r = ARCHIVE_FATAL;
1540                 }
1541                 zip->stream_valid = 0;
1542         }
1543 #endif
1544         if (zip->ppmd7_valid) {
1545                 __archive_ppmd7_functions.Ppmd7_Free(
1546                         &zip->ppmd7_context, &g_szalloc);
1547                 zip->ppmd7_valid = 0;
1548         }
1549         return (r);
1550 }
1551
1552 static int
1553 parse_7zip_uint64(struct archive_read *a, uint64_t *val)
1554 {
1555         const unsigned char *p;
1556         unsigned char avail, mask;
1557         int i;
1558
1559         if ((p = header_bytes(a, 1)) == NULL)
1560                 return (-1);
1561         avail = *p;
1562         mask = 0x80;
1563         *val = 0;
1564         for (i = 0; i < 8; i++) {
1565                 if (avail & mask) {
1566                         if ((p = header_bytes(a, 1)) == NULL)
1567                                 return (-1);
1568                         *val |= ((uint64_t)*p) << (8 * i);
1569                         mask >>= 1;
1570                         continue;
1571                 }
1572                 *val += (avail & (mask -1)) << (8 * i);
1573                 break;
1574         }
1575         return (0);
1576 }
1577
1578 static int
1579 read_Bools(struct archive_read *a, unsigned char *data, size_t num)
1580 {
1581         const unsigned char *p;
1582         unsigned i, mask = 0, avail = 0;
1583
1584         for (i = 0; i < num; i++) {
1585                 if (mask == 0) {
1586                         if ((p = header_bytes(a, 1)) == NULL)
1587                                 return (-1);
1588                         avail = *p;
1589                         mask = 0x80;
1590                 }
1591                 data[i] = (avail & mask)?1:0;
1592                 mask >>= 1;
1593         }
1594         return (0);
1595 }
1596
1597 static void
1598 free_Digest(struct _7z_digests *d)
1599 {
1600         free(d->defineds);
1601         free(d->digests);
1602 }
1603
1604 static int
1605 read_Digests(struct archive_read *a, struct _7z_digests *d, size_t num)
1606 {
1607         const unsigned char *p;
1608         unsigned i;
1609
1610         memset(d, 0, sizeof(*d));
1611
1612
1613         d->defineds = malloc(num);
1614         if (d->defineds == NULL)
1615                 return (-1);
1616         /*
1617          * Read Bools.
1618          */
1619         if ((p = header_bytes(a, 1)) == NULL)
1620                 return (-1);
1621         if (*p == 0) {
1622                 if (read_Bools(a, d->defineds, num) < 0)
1623                         return (-1);
1624         } else
1625                 /* All are defined */
1626                 memset(d->defineds, 1, num);
1627
1628         d->digests = calloc(num, sizeof(*d->digests));
1629         if (d->digests == NULL)
1630                 return (-1);
1631         for (i = 0; i < num; i++) {
1632                 if (d->defineds[i]) {
1633                         if ((p = header_bytes(a, 4)) == NULL)
1634                                 return (-1);
1635                         d->digests[i] = archive_le32dec(p);
1636                 }
1637         }
1638
1639         return (0);
1640 }
1641
1642 static void
1643 free_PackInfo(struct _7z_pack_info *pi)
1644 {
1645         free(pi->sizes);
1646         free(pi->positions);
1647         free_Digest(&(pi->digest));
1648 }
1649
1650 static int
1651 read_PackInfo(struct archive_read *a, struct _7z_pack_info *pi)
1652 {
1653         const unsigned char *p;
1654         unsigned i;
1655
1656         memset(pi, 0, sizeof(*pi));
1657
1658         /*
1659          * Read PackPos.
1660          */
1661         if (parse_7zip_uint64(a, &(pi->pos)) < 0)
1662                 return (-1);
1663
1664         /*
1665          * Read NumPackStreams.
1666          */
1667         if (parse_7zip_uint64(a, &(pi->numPackStreams)) < 0)
1668                 return (-1);
1669         if (pi->numPackStreams == 0)
1670                 return (-1);
1671         if (1000000 < pi->numPackStreams)
1672                 return (-1);
1673
1674         /*
1675          * Read PackSizes[num]
1676          */
1677         if ((p = header_bytes(a, 1)) == NULL)
1678                 return (-1);
1679         if (*p == kEnd)
1680                 /* PackSizes[num] are not present. */
1681                 return (0);
1682         if (*p != kSize)
1683                 return (-1);
1684         pi->sizes = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1685         pi->positions = calloc((size_t)pi->numPackStreams, sizeof(uint64_t));
1686         if (pi->sizes == NULL || pi->positions == NULL)
1687                 return (-1);
1688
1689         for (i = 0; i < pi->numPackStreams; i++) {
1690                 if (parse_7zip_uint64(a, &(pi->sizes[i])) < 0)
1691                         return (-1);
1692         }
1693
1694         /*
1695          * Read PackStreamDigests[num]
1696          */
1697         if ((p = header_bytes(a, 1)) == NULL)
1698                 return (-1);
1699         if (*p == kEnd) {
1700                 /* PackStreamDigests[num] are not present. */
1701                 pi->digest.defineds =
1702                     calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.defineds));
1703                 pi->digest.digests =
1704                     calloc((size_t)pi->numPackStreams, sizeof(*pi->digest.digests));
1705                 if (pi->digest.defineds == NULL || pi->digest.digests == NULL)
1706                         return (-1);
1707                 return (0);
1708         }
1709
1710         if (*p != kSize)
1711                 return (-1);
1712
1713         if (read_Digests(a, &(pi->digest), (size_t)pi->numPackStreams) < 0)
1714                 return (-1);
1715
1716         /*
1717          *  Must be marked by kEnd.
1718          */
1719         if ((p = header_bytes(a, 1)) == NULL)
1720                 return (-1);
1721         if (*p != kEnd)
1722                 return (-1);
1723         return (0);
1724 }
1725
1726 static void
1727 free_Folder(struct _7z_folder *f)
1728 {
1729         unsigned i;
1730
1731         if (f->coders) {
1732                 for (i = 0; i< f->numCoders; i++) {
1733                         free(f->coders[i].properties);
1734                 }
1735                 free(f->coders);
1736         }
1737         free(f->bindPairs);
1738         free(f->packedStreams);
1739         free(f->unPackSize);
1740 }
1741
1742 static int
1743 read_Folder(struct archive_read *a, struct _7z_folder *f)
1744 {
1745         struct _7zip *zip = (struct _7zip *)a->format->data;
1746         const unsigned char *p;
1747         uint64_t numInStreamsTotal = 0;
1748         uint64_t numOutStreamsTotal = 0;
1749         unsigned i;
1750
1751         memset(f, 0, sizeof(*f));
1752
1753         /*
1754          * Read NumCoders.
1755          */
1756         if (parse_7zip_uint64(a, &(f->numCoders)) < 0)
1757                 return (-1);
1758         if (f->numCoders > 4)
1759                 /* Too many coders. */
1760                 return (-1);
1761
1762         f->coders = calloc((size_t)f->numCoders, sizeof(*f->coders));
1763         if (f->coders == NULL)
1764                 return (-1);
1765         for (i = 0; i< f->numCoders; i++) {
1766                 size_t codec_size;
1767                 int simple, attr;
1768
1769                 if ((p = header_bytes(a, 1)) == NULL)
1770                         return (-1);
1771                 /*
1772                  * 0:3 CodecIdSize
1773                  * 4:  0 - IsSimple
1774                  *     1 - Is not Simple
1775                  * 5:  0 - No Attributes
1776                  *     1 - There are Attributes;
1777                  * 7:  Must be zero.
1778                  */
1779                 codec_size = *p & 0xf;
1780                 simple = (*p & 0x10)?0:1;
1781                 attr = *p & 0x20;
1782                 if (*p & 0x80)
1783                         return (-1);/* Not supported. */
1784
1785                 /*
1786                  * Read Decompression Method IDs.
1787                  */
1788                 if ((p = header_bytes(a, codec_size)) == NULL)
1789                         return (-1);
1790
1791                 f->coders[i].codec = decode_codec_id(p, codec_size);
1792
1793                 if (simple) {
1794                         f->coders[i].numInStreams = 1;
1795                         f->coders[i].numOutStreams = 1;
1796                 } else {
1797                         if (parse_7zip_uint64(
1798                             a, &(f->coders[i].numInStreams)) < 0)
1799                                 return (-1);
1800                         if (1000000 < f->coders[i].numInStreams)
1801                                 return (-1);
1802                         if (parse_7zip_uint64(
1803                             a, &(f->coders[i].numOutStreams)) < 0)
1804                                 return (-1);
1805                         if (1000000 < f->coders[i].numOutStreams)
1806                                 return (-1);
1807                 }
1808
1809                 if (attr) {
1810                         if (parse_7zip_uint64(
1811                             a, &(f->coders[i].propertiesSize)) < 0)
1812                                 return (-1);
1813                         if ((p = header_bytes(
1814                             a, (size_t)f->coders[i].propertiesSize)) == NULL)
1815                                 return (-1);
1816                         f->coders[i].properties =
1817                             malloc((size_t)f->coders[i].propertiesSize);
1818                         if (f->coders[i].properties == NULL)
1819                                 return (-1);
1820                         memcpy(f->coders[i].properties, p,
1821                             (size_t)f->coders[i].propertiesSize);
1822                 }
1823
1824                 numInStreamsTotal += f->coders[i].numInStreams;
1825                 numOutStreamsTotal += f->coders[i].numOutStreams;
1826         }
1827
1828         if (numOutStreamsTotal == 0 ||
1829             numInStreamsTotal < numOutStreamsTotal-1)
1830                 return (-1);
1831
1832         f->numBindPairs = numOutStreamsTotal - 1;
1833         if (zip->header_bytes_remaining < f->numBindPairs)
1834                         return (-1);
1835         if (f->numBindPairs > 0) {
1836                 f->bindPairs =
1837                         calloc((size_t)f->numBindPairs, sizeof(*f->bindPairs));
1838                 if (f->bindPairs == NULL)
1839                         return (-1);
1840         } else
1841                 f->bindPairs = NULL;
1842         for (i = 0; i < f->numBindPairs; i++) {
1843                 if (parse_7zip_uint64(a, &(f->bindPairs[i].inIndex)) < 0)
1844                         return (-1);
1845                 if (1000000 < f->bindPairs[i].inIndex)
1846                         return (-1);
1847                 if (parse_7zip_uint64(a, &(f->bindPairs[i].outIndex)) < 0)
1848                         return (-1);
1849                 if (1000000 < f->bindPairs[i].outIndex)
1850                         return (-1);
1851         }
1852
1853         f->numPackedStreams = numInStreamsTotal - f->numBindPairs;
1854         f->packedStreams =
1855             calloc((size_t)f->numPackedStreams, sizeof(*f->packedStreams));
1856         if (f->packedStreams == NULL)
1857                 return (-1);
1858         if (f->numPackedStreams == 1) {
1859                 for (i = 0; i < numInStreamsTotal; i++) {
1860                         unsigned j;
1861                         for (j = 0; j < f->numBindPairs; j++) {
1862                                 if (f->bindPairs[j].inIndex == i)
1863                                         break;
1864                         }
1865                         if (j == f->numBindPairs)
1866                                 break;
1867                 }
1868                 if (i == numInStreamsTotal)
1869                         return (-1);
1870                 f->packedStreams[0] = i;
1871         } else {
1872                 for (i = 0; i < f->numPackedStreams; i++) {
1873                         if (parse_7zip_uint64(a, &(f->packedStreams[i])) < 0)
1874                                 return (-1);
1875                         if (1000000 < f->packedStreams[i])
1876                                 return (-1);
1877                 }
1878         }
1879         f->numInStreams = numInStreamsTotal;
1880         f->numOutStreams = numOutStreamsTotal;
1881
1882         return (0);
1883 }
1884
1885 static void
1886 free_CodersInfo(struct _7z_coders_info *ci)
1887 {
1888         unsigned i;
1889
1890         if (ci->folders) {
1891                 for (i = 0; i < ci->numFolders; i++)
1892                         free_Folder(&(ci->folders[i]));
1893                 free(ci->folders);
1894         }
1895 }
1896
1897 static int
1898 read_CodersInfo(struct archive_read *a, struct _7z_coders_info *ci)
1899 {
1900         const unsigned char *p;
1901         struct _7z_digests digest;
1902         unsigned i;
1903
1904         memset(ci, 0, sizeof(*ci));
1905         memset(&digest, 0, sizeof(digest));
1906
1907         if ((p = header_bytes(a, 1)) == NULL)
1908                 goto failed;
1909         if (*p != kFolder)
1910                 goto failed;
1911
1912         /*
1913          * Read NumFolders.
1914          */
1915         if (parse_7zip_uint64(a, &(ci->numFolders)) < 0)
1916                 goto failed;
1917         if (1000000 < ci->numFolders)
1918                         return (-1);
1919
1920         /*
1921          * Read External.
1922          */
1923         if ((p = header_bytes(a, 1)) == NULL)
1924                 goto failed;
1925         switch (*p) {
1926         case 0:
1927                 ci->folders =
1928                         calloc((size_t)ci->numFolders, sizeof(*ci->folders));
1929                 if (ci->folders == NULL)
1930                         return (-1);
1931                 for (i = 0; i < ci->numFolders; i++) {
1932                         if (read_Folder(a, &(ci->folders[i])) < 0)
1933                                 goto failed;
1934                 }
1935                 break;
1936         case 1:
1937                 if (parse_7zip_uint64(a, &(ci->dataStreamIndex)) < 0)
1938                         return (-1);
1939                 if (1000000 < ci->dataStreamIndex)
1940                         return (-1);
1941                 break;
1942         }
1943
1944         if ((p = header_bytes(a, 1)) == NULL)
1945                 goto failed;
1946         if (*p != kCodersUnPackSize)
1947                 goto failed;
1948
1949         for (i = 0; i < ci->numFolders; i++) {
1950                 struct _7z_folder *folder = &(ci->folders[i]);
1951                 unsigned j;
1952
1953                 folder->unPackSize =
1954                     calloc((size_t)folder->numOutStreams, sizeof(*folder->unPackSize));
1955                 if (folder->unPackSize == NULL)
1956                         goto failed;
1957                 for (j = 0; j < folder->numOutStreams; j++) {
1958                         if (parse_7zip_uint64(a, &(folder->unPackSize[j])) < 0)
1959                                 goto failed;
1960                 }
1961         }
1962
1963         /*
1964          * Read CRCs.
1965          */
1966         if ((p = header_bytes(a, 1)) == NULL)
1967                 goto failed;
1968         if (*p == kEnd)
1969                 return (0);
1970         if (*p != kCRC)
1971                 goto failed;
1972         if (read_Digests(a, &digest, (size_t)ci->numFolders) < 0)
1973                 goto failed;
1974         for (i = 0; i < ci->numFolders; i++) {
1975                 ci->folders[i].digest_defined = digest.defineds[i];
1976                 ci->folders[i].digest = digest.digests[i];
1977         }
1978
1979         /*
1980          *  Must be kEnd.
1981          */
1982         if ((p = header_bytes(a, 1)) == NULL)
1983                 goto failed;
1984         if (*p != kEnd)
1985                 goto failed;
1986         free_Digest(&digest);
1987         return (0);
1988 failed:
1989         free_Digest(&digest);
1990         return (-1);
1991 }
1992
1993 static uint64_t
1994 folder_uncompressed_size(struct _7z_folder *f)
1995 {
1996         int n = (int)f->numOutStreams;
1997         unsigned pairs = (unsigned)f->numBindPairs;
1998
1999         while (--n >= 0) {
2000                 unsigned i;
2001                 for (i = 0; i < pairs; i++) {
2002                         if (f->bindPairs[i].outIndex == (uint64_t)n)
2003                                 break;
2004                 }
2005                 if (i >= pairs)
2006                         return (f->unPackSize[n]);
2007         }
2008         return (0);
2009 }
2010
2011 static void
2012 free_SubStreamsInfo(struct _7z_substream_info *ss)
2013 {
2014         free(ss->unpackSizes);
2015         free(ss->digestsDefined);
2016         free(ss->digests);
2017 }
2018
2019 static int
2020 read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
2021     struct _7z_folder *f, size_t numFolders)
2022 {
2023         const unsigned char *p;
2024         uint64_t *usizes;
2025         size_t unpack_streams;
2026         int type;
2027         unsigned i;
2028         uint32_t numDigests;
2029
2030         memset(ss, 0, sizeof(*ss));
2031
2032         for (i = 0; i < numFolders; i++)
2033                 f[i].numUnpackStreams = 1;
2034
2035         if ((p = header_bytes(a, 1)) == NULL)
2036                 return (-1);
2037         type = *p;
2038
2039         if (type == kNumUnPackStream) {
2040                 unpack_streams = 0;
2041                 for (i = 0; i < numFolders; i++) {
2042                         if (parse_7zip_uint64(a, &(f[i].numUnpackStreams)) < 0)
2043                                 return (-1);
2044                         if (1000000 < f[i].numUnpackStreams)
2045                                 return (-1);
2046                         unpack_streams += (size_t)f[i].numUnpackStreams;
2047                 }
2048                 if ((p = header_bytes(a, 1)) == NULL)
2049                         return (-1);
2050                 type = *p;
2051         } else
2052                 unpack_streams = numFolders;
2053
2054         ss->unpack_streams = unpack_streams;
2055         if (unpack_streams) {
2056                 ss->unpackSizes = calloc(unpack_streams,
2057                     sizeof(*ss->unpackSizes));
2058                 ss->digestsDefined = calloc(unpack_streams,
2059                     sizeof(*ss->digestsDefined));
2060                 ss->digests = calloc(unpack_streams,
2061                     sizeof(*ss->digests));
2062                 if (ss->unpackSizes == NULL || ss->digestsDefined == NULL ||
2063                     ss->digests == NULL)
2064                         return (-1);
2065         }
2066
2067         usizes = ss->unpackSizes;
2068         for (i = 0; i < numFolders; i++) {
2069                 unsigned pack;
2070                 uint64_t sum;
2071
2072                 if (f[i].numUnpackStreams == 0)
2073                         continue;
2074
2075                 sum = 0;
2076                 if (type == kSize) {
2077                         for (pack = 1; pack < f[i].numUnpackStreams; pack++) {
2078                                 if (parse_7zip_uint64(a, usizes) < 0)
2079                                         return (-1);
2080                                 sum += *usizes++;
2081                         }
2082                 }
2083                 *usizes++ = folder_uncompressed_size(&f[i]) - sum;
2084         }
2085
2086         if (type == kSize) {
2087                 if ((p = header_bytes(a, 1)) == NULL)
2088                         return (-1);
2089                 type = *p;
2090         }
2091
2092         for (i = 0; i < unpack_streams; i++) {
2093                 ss->digestsDefined[i] = 0;
2094                 ss->digests[i] = 0;
2095         }
2096
2097         numDigests = 0;
2098         for (i = 0; i < numFolders; i++) {
2099                 if (f[i].numUnpackStreams != 1 || !f[i].digest_defined)
2100                         numDigests += (uint32_t)f[i].numUnpackStreams;
2101         }
2102
2103         if (type == kCRC) {
2104                 struct _7z_digests tmpDigests;
2105                 unsigned char *digestsDefined = ss->digestsDefined;
2106                 uint32_t * digests = ss->digests;
2107                 int di = 0;
2108
2109                 memset(&tmpDigests, 0, sizeof(tmpDigests));
2110                 if (read_Digests(a, &(tmpDigests), numDigests) < 0) {
2111                         free_Digest(&tmpDigests);
2112                         return (-1);
2113                 }
2114                 for (i = 0; i < numFolders; i++) {
2115                         if (f[i].numUnpackStreams == 1 && f[i].digest_defined) {
2116                                 *digestsDefined++ = 1;
2117                                 *digests++ = f[i].digest;
2118                         } else {
2119                                 unsigned j;
2120
2121                                 for (j = 0; j < f[i].numUnpackStreams;
2122                                     j++, di++) {
2123                                         *digestsDefined++ =
2124                                             tmpDigests.defineds[di];
2125                                         *digests++ =
2126                                             tmpDigests.digests[di];
2127                                 }
2128                         }
2129                 }
2130                 free_Digest(&tmpDigests);
2131                 if ((p = header_bytes(a, 1)) == NULL)
2132                         return (-1);
2133                 type = *p;
2134         }
2135
2136         /*
2137          *  Must be kEnd.
2138          */
2139         if (type != kEnd)
2140                 return (-1);
2141         return (0);
2142 }
2143
2144 static void
2145 free_StreamsInfo(struct _7z_stream_info *si)
2146 {
2147         free_PackInfo(&(si->pi));
2148         free_CodersInfo(&(si->ci));
2149         free_SubStreamsInfo(&(si->ss));
2150 }
2151
2152 static int
2153 read_StreamsInfo(struct archive_read *a, struct _7z_stream_info *si)
2154 {
2155         struct _7zip *zip = (struct _7zip *)a->format->data;
2156         const unsigned char *p;
2157         unsigned i;
2158
2159         memset(si, 0, sizeof(*si));
2160
2161         if ((p = header_bytes(a, 1)) == NULL)
2162                 return (-1);
2163         if (*p == kPackInfo) {
2164                 uint64_t packPos;
2165
2166                 if (read_PackInfo(a, &(si->pi)) < 0)
2167                         return (-1);
2168
2169                 if (si->pi.positions == NULL || si->pi.sizes == NULL)
2170                         return (-1);
2171                 /*
2172                  * Calculate packed stream positions.
2173                  */
2174                 packPos = si->pi.pos;
2175                 for (i = 0; i < si->pi.numPackStreams; i++) {
2176                         si->pi.positions[i] = packPos;
2177                         packPos += si->pi.sizes[i];
2178                         if (packPos > zip->header_offset)
2179                                 return (-1);
2180                 }
2181                 if ((p = header_bytes(a, 1)) == NULL)
2182                         return (-1);
2183         }
2184         if (*p == kUnPackInfo) {
2185                 uint32_t packIndex;
2186                 struct _7z_folder *f;
2187
2188                 if (read_CodersInfo(a, &(si->ci)) < 0)
2189                         return (-1);
2190
2191                 /*
2192                  * Calculate packed stream indexes.
2193                  */
2194                 packIndex = 0;
2195                 f = si->ci.folders;
2196                 for (i = 0; i < si->ci.numFolders; i++) {
2197                         f[i].packIndex = packIndex;
2198                         packIndex += (uint32_t)f[i].numPackedStreams;
2199                         if (packIndex > si->pi.numPackStreams)
2200                                 return (-1);
2201                 }
2202                 if ((p = header_bytes(a, 1)) == NULL)
2203                         return (-1);
2204         }
2205
2206         if (*p == kSubStreamsInfo) {
2207                 if (read_SubStreamsInfo(a, &(si->ss),
2208                     si->ci.folders, (size_t)si->ci.numFolders) < 0)
2209                         return (-1);
2210                 if ((p = header_bytes(a, 1)) == NULL)
2211                         return (-1);
2212         }
2213
2214         /*
2215          *  Must be kEnd.
2216          */
2217         if (*p != kEnd)
2218                 return (-1);
2219         return (0);
2220 }
2221
2222 static void
2223 free_Header(struct _7z_header_info *h)
2224 {
2225         free(h->emptyStreamBools);
2226         free(h->emptyFileBools);
2227         free(h->antiBools);
2228         free(h->attrBools);
2229 }
2230
2231 static int
2232 read_Header(struct archive_read *a, struct _7z_header_info *h,
2233     int check_header_id)
2234 {
2235         struct _7zip *zip = (struct _7zip *)a->format->data;
2236         const unsigned char *p;
2237         struct _7z_folder *folders;
2238         struct _7z_stream_info *si = &(zip->si);
2239         struct _7zip_entry *entries;
2240         uint32_t folderIndex, indexInFolder;
2241         unsigned i;
2242         int eindex, empty_streams, sindex;
2243
2244         if (check_header_id) {
2245                 /*
2246                  * Read Header.
2247                  */
2248                 if ((p = header_bytes(a, 1)) == NULL)
2249                         return (-1);
2250                 if (*p != kHeader)
2251                         return (-1);
2252         }
2253
2254         /*
2255          * Read ArchiveProperties.
2256          */
2257         if ((p = header_bytes(a, 1)) == NULL)
2258                 return (-1);
2259         if (*p == kArchiveProperties) {
2260                 for (;;) {
2261                         uint64_t size;
2262                         if ((p = header_bytes(a, 1)) == NULL)
2263                                 return (-1);
2264                         if (*p == 0)
2265                                 break;
2266                         if (parse_7zip_uint64(a, &size) < 0)
2267                                 return (-1);
2268                 }
2269                 if ((p = header_bytes(a, 1)) == NULL)
2270                         return (-1);
2271         }
2272
2273         /*
2274          * Read MainStreamsInfo.
2275          */
2276         if (*p == kMainStreamsInfo) {
2277                 if (read_StreamsInfo(a, &(zip->si)) < 0)
2278                         return (-1);
2279                 if ((p = header_bytes(a, 1)) == NULL)
2280                         return (-1);
2281         }
2282         if (*p == kEnd)
2283                 return (0);
2284
2285         /*
2286          * Read FilesInfo.
2287          */
2288         if (*p != kFilesInfo)
2289                 return (-1);
2290
2291         if (parse_7zip_uint64(a, &(zip->numFiles)) < 0)
2292                 return (-1);
2293         if (1000000 < zip->numFiles)
2294                         return (-1);
2295
2296         zip->entries = calloc((size_t)zip->numFiles, sizeof(*zip->entries));
2297         if (zip->entries == NULL)
2298                 return (-1);
2299         entries = zip->entries;
2300
2301         empty_streams = 0;
2302         for (;;) {
2303                 int type;
2304                 uint64_t size;
2305                 size_t ll;
2306
2307                 if ((p = header_bytes(a, 1)) == NULL)
2308                         return (-1);
2309                 type = *p;
2310                 if (type == kEnd)
2311                         break;
2312
2313                 if (parse_7zip_uint64(a, &size) < 0)
2314                         return (-1);
2315                 if (zip->header_bytes_remaining < size)
2316                         return (-1);
2317                 ll = (size_t)size;
2318
2319                 switch (type) {
2320                 case kEmptyStream:
2321                         h->emptyStreamBools = calloc((size_t)zip->numFiles,
2322                             sizeof(*h->emptyStreamBools));
2323                         if (h->emptyStreamBools == NULL)
2324                                 return (-1);
2325                         if (read_Bools(
2326                             a, h->emptyStreamBools, (size_t)zip->numFiles) < 0)
2327                                 return (-1);
2328                         empty_streams = 0;
2329                         for (i = 0; i < zip->numFiles; i++) {
2330                                 if (h->emptyStreamBools[i])
2331                                         empty_streams++;
2332                         }
2333                         break;
2334                 case kEmptyFile:
2335                         if (empty_streams <= 0) {
2336                                 /* Unexcepted sequence. Skip this. */
2337                                 if (header_bytes(a, ll) == NULL)
2338                                         return (-1);
2339                                 break;
2340                         }
2341                         h->emptyFileBools = calloc(empty_streams,
2342                             sizeof(*h->emptyFileBools));
2343                         if (h->emptyFileBools == NULL)
2344                                 return (-1);
2345                         if (read_Bools(a, h->emptyFileBools, empty_streams) < 0)
2346                                 return (-1);
2347                         break;
2348                 case kAnti:
2349                         if (empty_streams <= 0) {
2350                                 /* Unexcepted sequence. Skip this. */
2351                                 if (header_bytes(a, ll) == NULL)
2352                                         return (-1);
2353                                 break;
2354                         }
2355                         h->antiBools = calloc(empty_streams,
2356                             sizeof(*h->antiBools));
2357                         if (h->antiBools == NULL)
2358                                 return (-1);
2359                         if (read_Bools(a, h->antiBools, empty_streams) < 0)
2360                                 return (-1);
2361                         break;
2362                 case kCTime:
2363                 case kATime:
2364                 case kMTime:
2365                         if (read_Times(a, h, type) < 0)
2366                                 return (-1);
2367                         break;
2368                 case kName:
2369                 {
2370                         unsigned char *np;
2371                         size_t nl, nb;
2372
2373                         /* Skip one byte. */
2374                         if ((p = header_bytes(a, 1)) == NULL)
2375                                 return (-1);
2376                         ll--;
2377
2378                         if ((ll & 1) || ll < zip->numFiles * 4)
2379                                 return (-1);
2380
2381                         zip->entry_names = malloc(ll);
2382                         if (zip->entry_names == NULL)
2383                                 return (-1);
2384                         np = zip->entry_names;
2385                         nb = ll;
2386                         /*
2387                          * Copy whole file names.
2388                          * NOTE: This loop prevents from expanding
2389                          * the uncompressed buffer in order not to
2390                          * use extra memory resource.
2391                          */
2392                         while (nb) {
2393                                 size_t b;
2394                                 if (nb > UBUFF_SIZE)
2395                                         b = UBUFF_SIZE;
2396                                 else
2397                                         b = nb;
2398                                 if ((p = header_bytes(a, b)) == NULL)
2399                                         return (-1);
2400                                 memcpy(np, p, b);
2401                                 np += b;
2402                                 nb -= b;
2403                         }
2404                         np = zip->entry_names;
2405                         nl = ll;
2406
2407                         for (i = 0; i < zip->numFiles; i++) {
2408                                 entries[i].utf16name = np;
2409 #if defined(_WIN32) && !defined(__CYGWIN__) && defined(_DEBUG)
2410                                 entries[i].wname = (wchar_t *)np;
2411 #endif
2412
2413                                 /* Find a terminator. */
2414                                 while (nl >= 2 && (np[0] || np[1])) {
2415                                         np += 2;
2416                                         nl -= 2;
2417                                 }
2418                                 if (nl < 2)
2419                                         return (-1);/* Terminator not found */
2420                                 entries[i].name_len = np - entries[i].utf16name;
2421                                 np += 2;
2422                                 nl -= 2;
2423                         }
2424                         break;
2425                 }
2426                 case kAttributes:
2427                 {
2428                         int allAreDefined;
2429
2430                         if ((p = header_bytes(a, 2)) == NULL)
2431                                 return (-1);
2432                         allAreDefined = *p;
2433                         h->attrBools = calloc((size_t)zip->numFiles,
2434                             sizeof(*h->attrBools));
2435                         if (h->attrBools == NULL)
2436                                 return (-1);
2437                         if (allAreDefined)
2438                                 memset(h->attrBools, 1, (size_t)zip->numFiles);
2439                         else {
2440                                 if (read_Bools(a, h->attrBools,
2441                                       (size_t)zip->numFiles) < 0)
2442                                         return (-1);
2443                         }
2444                         for (i = 0; i < zip->numFiles; i++) {
2445                                 if (h->attrBools[i]) {
2446                                         if ((p = header_bytes(a, 4)) == NULL)
2447                                                 return (-1);
2448                                         entries[i].attr = archive_le32dec(p);
2449                                 }
2450                         }
2451                         break;
2452                 }
2453                 default:
2454                         if (header_bytes(a, ll) == NULL)
2455                                 return (-1);
2456                         break;
2457                 }
2458         }
2459
2460         /*
2461          * Set up entry's attributes.
2462          */
2463         folders = si->ci.folders;
2464         eindex = sindex = 0;
2465         folderIndex = indexInFolder = 0;
2466         for (i = 0; i < zip->numFiles; i++) {
2467                 if (h->emptyStreamBools == NULL || h->emptyStreamBools[i] == 0)
2468                         entries[i].flg |= HAS_STREAM;
2469                 /* The high 16 bits of attributes is a posix file mode. */
2470                 entries[i].mode = entries[i].attr >> 16;
2471                 if (entries[i].flg & HAS_STREAM) {
2472                         if ((size_t)sindex >= si->ss.unpack_streams)
2473                                 return (-1);
2474                         if (entries[i].mode == 0)
2475                                 entries[i].mode = AE_IFREG | 0666;
2476                         if (si->ss.digestsDefined[sindex])
2477                                 entries[i].flg |= CRC32_IS_SET;
2478                         entries[i].ssIndex = sindex;
2479                         sindex++;
2480                 } else {
2481                         int dir;
2482                         if (h->emptyFileBools == NULL)
2483                                 dir = 1;
2484                         else {
2485                                 if (h->emptyFileBools[eindex])
2486                                         dir = 0;
2487                                 else
2488                                         dir = 1;
2489                                 eindex++;
2490                         }
2491                         if (entries[i].mode == 0) {
2492                                 if (dir)
2493                                         entries[i].mode = AE_IFDIR | 0777;
2494                                 else
2495                                         entries[i].mode = AE_IFREG | 0666;
2496                         } else if (dir &&
2497                             (entries[i].mode & AE_IFMT) != AE_IFDIR) {
2498                                 entries[i].mode &= ~AE_IFMT;
2499                                 entries[i].mode |= AE_IFDIR;
2500                         }
2501                         if ((entries[i].mode & AE_IFMT) == AE_IFDIR &&
2502                             entries[i].name_len >= 2 &&
2503                             (entries[i].utf16name[entries[i].name_len-2] != '/' ||
2504                              entries[i].utf16name[entries[i].name_len-1] != 0)) {
2505                                 entries[i].utf16name[entries[i].name_len] = '/';
2506                                 entries[i].utf16name[entries[i].name_len+1] = 0;
2507                                 entries[i].name_len += 2;
2508                         }
2509                         entries[i].ssIndex = -1;
2510                 }
2511                 if (entries[i].attr & 0x01)
2512                         entries[i].mode &= ~0222;/* Read only. */
2513
2514                 if ((entries[i].flg & HAS_STREAM) == 0 && indexInFolder == 0) {
2515                         /*
2516                          * The entry is an empty file or a directory file,
2517                          * those both have no contents.
2518                          */
2519                         entries[i].folderIndex = -1;
2520                         continue;
2521                 }
2522                 if (indexInFolder == 0) {
2523                         for (;;) {
2524                                 if (folderIndex >= si->ci.numFolders)
2525                                         return (-1);
2526                                 if (folders[folderIndex].numUnpackStreams)
2527                                         break;
2528                                 folderIndex++;
2529                         }
2530                 }
2531                 entries[i].folderIndex = folderIndex;
2532                 if ((entries[i].flg & HAS_STREAM) == 0)
2533                         continue;
2534                 indexInFolder++;
2535                 if (indexInFolder >= folders[folderIndex].numUnpackStreams) {
2536                         folderIndex++;
2537                         indexInFolder = 0;
2538                 }
2539         }
2540
2541         return (0);
2542 }
2543
2544 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
2545 static void
2546 fileTimeToUtc(uint64_t fileTime, time_t *timep, long *ns)
2547 {
2548
2549         if (fileTime >= EPOC_TIME) {
2550                 fileTime -= EPOC_TIME;
2551                 /* milli seconds base */
2552                 *timep = (time_t)(fileTime / 10000000);
2553                 /* nano seconds base */
2554                 *ns = (long)(fileTime % 10000000) * 100;
2555         } else {
2556                 *timep = 0;
2557                 *ns = 0;
2558         }
2559 }
2560
2561 static int
2562 read_Times(struct archive_read *a, struct _7z_header_info *h, int type)
2563 {
2564         struct _7zip *zip = (struct _7zip *)a->format->data;
2565         const unsigned char *p;
2566         struct _7zip_entry *entries = zip->entries;
2567         unsigned char *timeBools;
2568         int allAreDefined;
2569         unsigned i;
2570
2571         timeBools = calloc((size_t)zip->numFiles, sizeof(*timeBools));
2572         if (timeBools == NULL)
2573                 return (-1);
2574
2575         /* Read allAreDefined. */
2576         if ((p = header_bytes(a, 1)) == NULL)
2577                 goto failed;
2578         allAreDefined = *p;
2579         if (allAreDefined)
2580                 memset(timeBools, 1, (size_t)zip->numFiles);
2581         else {
2582                 if (read_Bools(a, timeBools, (size_t)zip->numFiles) < 0)
2583                         goto failed;
2584         }
2585
2586         /* Read external. */
2587         if ((p = header_bytes(a, 1)) == NULL)
2588                 goto failed;
2589         if (*p) {
2590                 if (parse_7zip_uint64(a, &(h->dataIndex)) < 0)
2591                         goto failed;
2592                 if (1000000 < h->dataIndex)
2593                         goto failed;
2594         }
2595
2596         for (i = 0; i < zip->numFiles; i++) {
2597                 if (!timeBools[i])
2598                         continue;
2599                 if ((p = header_bytes(a, 8)) == NULL)
2600                         goto failed;
2601                 switch (type) {
2602                 case kCTime:
2603                         fileTimeToUtc(archive_le64dec(p),
2604                             &(entries[i].ctime),
2605                             &(entries[i].ctime_ns));
2606                         entries[i].flg |= CTIME_IS_SET;
2607                         break;
2608                 case kATime:
2609                         fileTimeToUtc(archive_le64dec(p),
2610                             &(entries[i].atime),
2611                             &(entries[i].atime_ns));
2612                         entries[i].flg |= ATIME_IS_SET;
2613                         break;
2614                 case kMTime:
2615                         fileTimeToUtc(archive_le64dec(p),
2616                             &(entries[i].mtime),
2617                             &(entries[i].mtime_ns));
2618                         entries[i].flg |= MTIME_IS_SET;
2619                         break;
2620                 }
2621         }
2622
2623         free(timeBools);
2624         return (0);
2625 failed:
2626         free(timeBools);
2627         return (-1);
2628 }
2629
2630 static int
2631 decode_encoded_header_info(struct archive_read *a, struct _7z_stream_info *si)
2632 {
2633         struct _7zip *zip = (struct _7zip *)a->format->data;
2634
2635         errno = 0;
2636         if (read_StreamsInfo(a, si) < 0) {
2637                 if (errno == ENOMEM)
2638                         archive_set_error(&a->archive, -1,
2639                             "Couldn't allocate memory");
2640                 else
2641                         archive_set_error(&a->archive, -1,
2642                             "Malformed 7-Zip archive");
2643                 return (ARCHIVE_FATAL);
2644         }
2645
2646         if (si->pi.numPackStreams == 0 || si->ci.numFolders == 0) {
2647                 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2648                 return (ARCHIVE_FATAL);
2649         }
2650
2651         if (zip->header_offset < si->pi.pos + si->pi.sizes[0] ||
2652             (int64_t)(si->pi.pos + si->pi.sizes[0]) < 0 ||
2653             si->pi.sizes[0] == 0 || (int64_t)si->pi.pos < 0) {
2654                 archive_set_error(&a->archive, -1, "Malformed Header offset");
2655                 return (ARCHIVE_FATAL);
2656         }
2657
2658         return (ARCHIVE_OK);
2659 }
2660
2661 static const unsigned char *
2662 header_bytes(struct archive_read *a, size_t rbytes)
2663 {
2664         struct _7zip *zip = (struct _7zip *)a->format->data;
2665         const unsigned char *p;
2666
2667         if (zip->header_bytes_remaining < rbytes)
2668                 return (NULL);
2669         if (zip->pack_stream_bytes_unconsumed)
2670                 read_consume(a);
2671
2672         if (zip->header_is_encoded == 0) {
2673                 p = __archive_read_ahead(a, rbytes, NULL);
2674                 if (p == NULL)
2675                         return (NULL);
2676                 zip->header_bytes_remaining -= rbytes;
2677                 zip->pack_stream_bytes_unconsumed = rbytes;
2678         } else {
2679                 const void *buff;
2680                 ssize_t bytes;
2681
2682                 bytes = read_stream(a, &buff, rbytes, rbytes);
2683                 if (bytes <= 0)
2684                         return (NULL);
2685                 zip->header_bytes_remaining -= bytes;
2686                 p = buff;
2687         }
2688
2689         /* Update checksum */
2690         zip->header_crc32 = crc32(zip->header_crc32, p, rbytes);
2691         return (p);
2692 }
2693
2694 static int
2695 slurp_central_directory(struct archive_read *a, struct _7zip *zip,
2696     struct _7z_header_info *header)
2697 {
2698         const unsigned char *p;
2699         uint64_t next_header_offset;
2700         uint64_t next_header_size;
2701         uint32_t next_header_crc;
2702         ssize_t bytes_avail;
2703         int check_header_crc, r;
2704
2705         if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2706                 return (ARCHIVE_FATAL);
2707
2708         if ((p[0] == 'M' && p[1] == 'Z') || memcmp(p, "\x7F\x45LF", 4) == 0) {
2709                 /* This is an executable ? Must be self-extracting... */
2710                 r = skip_sfx(a, bytes_avail);
2711                 if (r < ARCHIVE_WARN)
2712                         return (r);
2713                 if ((p = __archive_read_ahead(a, 32, &bytes_avail)) == NULL)
2714                         return (ARCHIVE_FATAL);
2715         }
2716         zip->seek_base += 32;
2717
2718         if (memcmp(p, _7ZIP_SIGNATURE, 6) != 0) {
2719                 archive_set_error(&a->archive, -1, "Not 7-Zip archive file");
2720                 return (ARCHIVE_FATAL);
2721         }
2722
2723         /* CRC check. */
2724         if (crc32(0, (const unsigned char *)p + 12, 20)
2725             != archive_le32dec(p + 8)) {
2726                 archive_set_error(&a->archive, -1, "Header CRC error");
2727                 return (ARCHIVE_FATAL);
2728         }
2729
2730         next_header_offset = archive_le64dec(p + 12);
2731         next_header_size = archive_le64dec(p + 20);
2732         next_header_crc = archive_le32dec(p + 28);
2733
2734         if (next_header_size == 0)
2735                 /* There is no entry in an archive file. */
2736                 return (ARCHIVE_EOF);
2737
2738         if (((int64_t)next_header_offset) < 0) {
2739                 archive_set_error(&a->archive, -1, "Malformed 7-Zip archive");
2740                 return (ARCHIVE_FATAL);
2741         }
2742         __archive_read_consume(a, 32);
2743         if (next_header_offset != 0) {
2744                 if (bytes_avail >= (ssize_t)next_header_offset)
2745                         __archive_read_consume(a, next_header_offset);
2746                 else if (__archive_read_seek(a,
2747                     next_header_offset + zip->seek_base, SEEK_SET) < 0)
2748                         return (ARCHIVE_FATAL);
2749         }
2750         zip->stream_offset = next_header_offset;
2751         zip->header_offset = next_header_offset;
2752         zip->header_bytes_remaining = next_header_size;
2753         zip->header_crc32 = 0;
2754         zip->header_is_encoded = 0;
2755         zip->header_is_being_read = 1;
2756         check_header_crc = 1;
2757
2758         if ((p = header_bytes(a, 1)) == NULL) {
2759                 archive_set_error(&a->archive,
2760                     ARCHIVE_ERRNO_FILE_FORMAT,
2761                     "Truncated 7-Zip file body");
2762                 return (ARCHIVE_FATAL);
2763         }
2764         /* Parse ArchiveProperties. */
2765         switch (p[0]) {
2766         case kEncodedHeader:
2767                 /*
2768                  * The archive has an encoded header and we have to decode it
2769                  * in order to parse the header correctly.
2770                  */
2771                 r = decode_encoded_header_info(a, &(zip->si));
2772
2773                 /* Check the EncodedHeader CRC.*/
2774                 if (r == 0 && zip->header_crc32 != next_header_crc) {
2775                         archive_set_error(&a->archive, -1,
2776                             "Damaged 7-Zip archive");
2777                         r = -1;
2778                 }
2779                 if (r == 0) {
2780                         if (zip->si.ci.folders[0].digest_defined)
2781                                 next_header_crc = zip->si.ci.folders[0].digest;
2782                         else
2783                                 check_header_crc = 0;
2784                         if (zip->pack_stream_bytes_unconsumed)
2785                                 read_consume(a);
2786                         r = setup_decode_folder(a, zip->si.ci.folders, 1);
2787                         if (r == 0) {
2788                                 zip->header_bytes_remaining =
2789                                         zip->folder_outbytes_remaining;
2790                                 r = seek_pack(a);
2791                         }
2792                 }
2793                 /* Clean up StreamsInfo. */
2794                 free_StreamsInfo(&(zip->si));
2795                 memset(&(zip->si), 0, sizeof(zip->si));
2796                 if (r < 0)
2797                         return (ARCHIVE_FATAL);
2798                 zip->header_is_encoded = 1;
2799                 zip->header_crc32 = 0;
2800                 /* FALL THROUGH */
2801         case kHeader:
2802                 /*
2803                  * Parse the header.
2804                  */
2805                 errno = 0;
2806                 r = read_Header(a, header, zip->header_is_encoded);
2807                 if (r < 0) {
2808                         if (errno == ENOMEM)
2809                                 archive_set_error(&a->archive, -1,
2810                                     "Couldn't allocate memory");
2811                         else
2812                                 archive_set_error(&a->archive, -1,
2813                                     "Damaged 7-Zip archive");
2814                         return (ARCHIVE_FATAL);
2815                 }
2816
2817                 /*
2818                  *  Must be kEnd.
2819                  */
2820                 if ((p = header_bytes(a, 1)) == NULL ||*p != kEnd) {
2821                         archive_set_error(&a->archive, -1,
2822                             "Malformed 7-Zip archive");
2823                         return (ARCHIVE_FATAL);
2824                 }
2825
2826                 /* Check the Header CRC.*/
2827                 if (check_header_crc && zip->header_crc32 != next_header_crc) {
2828                         archive_set_error(&a->archive, -1,
2829                             "Malformed 7-Zip archive");
2830                         return (ARCHIVE_FATAL);
2831                 }
2832                 break;
2833         default:
2834                 archive_set_error(&a->archive, -1,
2835                     "Unexpected Property ID = %X", p[0]);
2836                 return (ARCHIVE_FATAL);
2837         }
2838
2839         /* Clean up variables be used for decoding the archive header */
2840         zip->pack_stream_remaining = 0;
2841         zip->pack_stream_index = 0;
2842         zip->folder_outbytes_remaining = 0;
2843         zip->uncompressed_buffer_bytes_remaining = 0;
2844         zip->pack_stream_bytes_unconsumed = 0;
2845         zip->header_is_being_read = 0;
2846
2847         return (ARCHIVE_OK);
2848 }
2849
2850 static ssize_t
2851 get_uncompressed_data(struct archive_read *a, const void **buff, size_t size,
2852     size_t minimum)
2853 {
2854         struct _7zip *zip = (struct _7zip *)a->format->data;
2855         ssize_t bytes_avail;
2856
2857         if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
2858                 /* Copy mode. */
2859
2860                 /*
2861                  * Note: '1' here is a performance optimization.
2862                  * Recall that the decompression layer returns a count of
2863                  * available bytes; asking for more than that forces the
2864                  * decompressor to combine reads by copying data.
2865                  */
2866                 *buff = __archive_read_ahead(a, 1, &bytes_avail);
2867                 if (bytes_avail <= 0) {
2868                         archive_set_error(&a->archive,
2869                             ARCHIVE_ERRNO_FILE_FORMAT,
2870                             "Truncated 7-Zip file data");
2871                         return (ARCHIVE_FATAL);
2872                 }
2873                 if ((size_t)bytes_avail >
2874                     zip->uncompressed_buffer_bytes_remaining)
2875                         bytes_avail = (ssize_t)
2876                             zip->uncompressed_buffer_bytes_remaining;
2877                 if ((size_t)bytes_avail > size)
2878                         bytes_avail = (ssize_t)size;
2879
2880                 zip->pack_stream_bytes_unconsumed = bytes_avail;
2881         } else if (zip->uncompressed_buffer_pointer == NULL) {
2882                 /* Decompression has failed. */
2883                 archive_set_error(&(a->archive),
2884                     ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
2885                 return (ARCHIVE_FATAL);
2886         } else {
2887                 /* Packed mode. */
2888                 if (minimum > zip->uncompressed_buffer_bytes_remaining) {
2889                         /*
2890                          * If remaining uncompressed data size is less than
2891                          * the minimum size, fill the buffer up to the
2892                          * minimum size.
2893                          */
2894                         if (extract_pack_stream(a, minimum) < 0)
2895                                 return (ARCHIVE_FATAL);
2896                 }
2897                 if (size > zip->uncompressed_buffer_bytes_remaining)
2898                         bytes_avail = (ssize_t)
2899                             zip->uncompressed_buffer_bytes_remaining;
2900                 else
2901                         bytes_avail = (ssize_t)size;
2902                 *buff = zip->uncompressed_buffer_pointer;
2903                 zip->uncompressed_buffer_pointer += bytes_avail;
2904         }
2905         zip->uncompressed_buffer_bytes_remaining -= bytes_avail;
2906         return (bytes_avail);
2907 }
2908
2909 static ssize_t
2910 extract_pack_stream(struct archive_read *a, size_t minimum)
2911 {
2912         struct _7zip *zip = (struct _7zip *)a->format->data;
2913         ssize_t bytes_avail;
2914         int r;
2915
2916         if (zip->codec == _7Z_COPY && zip->codec2 == (unsigned long)-1) {
2917                 if (minimum == 0)
2918                         minimum = 1;
2919                 if (__archive_read_ahead(a, minimum, &bytes_avail) == NULL
2920                     || bytes_avail <= 0) {
2921                         archive_set_error(&a->archive,
2922                             ARCHIVE_ERRNO_FILE_FORMAT,
2923                             "Truncated 7-Zip file body");
2924                         return (ARCHIVE_FATAL);
2925                 }
2926                 if (bytes_avail > (ssize_t)zip->pack_stream_inbytes_remaining)
2927                         bytes_avail = (ssize_t)zip->pack_stream_inbytes_remaining;
2928                 zip->pack_stream_inbytes_remaining -= bytes_avail;
2929                 if (bytes_avail > (ssize_t)zip->folder_outbytes_remaining)
2930                         bytes_avail = (ssize_t)zip->folder_outbytes_remaining;
2931                 zip->folder_outbytes_remaining -= bytes_avail;
2932                 zip->uncompressed_buffer_bytes_remaining = bytes_avail;
2933                 return (ARCHIVE_OK);
2934         }
2935
2936         /* If the buffer hasn't been allocated, allocate it now. */
2937         if (zip->uncompressed_buffer == NULL) {
2938                 zip->uncompressed_buffer_size = UBUFF_SIZE;
2939                 if (zip->uncompressed_buffer_size < minimum) {
2940                         zip->uncompressed_buffer_size = minimum + 1023;
2941                         zip->uncompressed_buffer_size &= ~0x3ff;
2942                 }
2943                 zip->uncompressed_buffer =
2944                     malloc(zip->uncompressed_buffer_size);
2945                 if (zip->uncompressed_buffer == NULL) {
2946                         archive_set_error(&a->archive, ENOMEM,
2947                             "No memory for 7-Zip decompression");
2948                         return (ARCHIVE_FATAL);
2949                 }
2950                 zip->uncompressed_buffer_bytes_remaining = 0;
2951         } else if (zip->uncompressed_buffer_size < minimum ||
2952             zip->uncompressed_buffer_bytes_remaining < minimum) {
2953                 /*
2954                  * Make sure the uncompressed buffer can have bytes
2955                  * at least `minimum' bytes.
2956                  * NOTE: This case happen when reading the header.
2957                  */
2958                 size_t used;
2959                 if (zip->uncompressed_buffer_pointer != 0)
2960                         used = zip->uncompressed_buffer_pointer -
2961                                 zip->uncompressed_buffer;
2962                 else
2963                         used = 0;
2964                 if (zip->uncompressed_buffer_size < minimum) {
2965                         /*
2966                          * Expand the uncompressed buffer up to
2967                          * the minimum size.
2968                          */
2969                         zip->uncompressed_buffer_size = minimum + 1023;
2970                         zip->uncompressed_buffer_size &= ~0x3ff;
2971                         zip->uncompressed_buffer =
2972                             realloc(zip->uncompressed_buffer,
2973                                 zip->uncompressed_buffer_size);
2974                         if (zip->uncompressed_buffer == NULL) {
2975                                 archive_set_error(&a->archive, ENOMEM,
2976                                     "No memory for 7-Zip decompression");
2977                                 return (ARCHIVE_FATAL);
2978                         }
2979                 }
2980                 /*
2981                  * Move unconsumed bytes to the head.
2982                  */
2983                 if (used) {
2984                         memmove(zip->uncompressed_buffer,
2985                                 zip->uncompressed_buffer + used,
2986                                 zip->uncompressed_buffer_bytes_remaining);
2987                 }
2988         } else
2989                 zip->uncompressed_buffer_bytes_remaining = 0;
2990         zip->uncompressed_buffer_pointer = NULL;
2991         for (;;) {
2992                 size_t bytes_in, bytes_out;
2993                 const void *buff_in;
2994                 unsigned char *buff_out;
2995                 int end_of_data;
2996
2997                 /*
2998                  * Note: '1' here is a performance optimization.
2999                  * Recall that the decompression layer returns a count of
3000                  * available bytes; asking for more than that forces the
3001                  * decompressor to combine reads by copying data.
3002                  */
3003                 buff_in = __archive_read_ahead(a, 1, &bytes_avail);
3004                 if (bytes_avail <= 0) {
3005                         archive_set_error(&a->archive,
3006                             ARCHIVE_ERRNO_FILE_FORMAT,
3007                             "Truncated 7-Zip file body");
3008                         return (ARCHIVE_FATAL);
3009                 }
3010
3011                 buff_out = zip->uncompressed_buffer
3012                         + zip->uncompressed_buffer_bytes_remaining;
3013                 bytes_out = zip->uncompressed_buffer_size
3014                         - zip->uncompressed_buffer_bytes_remaining;
3015                 bytes_in = bytes_avail;
3016                 if (bytes_in > zip->pack_stream_inbytes_remaining)
3017                         bytes_in = (size_t)zip->pack_stream_inbytes_remaining;
3018                 /* Drive decompression. */
3019                 r = decompress(a, zip, buff_out, &bytes_out,
3020                         buff_in, &bytes_in);
3021                 switch (r) {
3022                 case ARCHIVE_OK:
3023                         end_of_data = 0;
3024                         break;
3025                 case ARCHIVE_EOF:
3026                         end_of_data = 1;
3027                         break;
3028                 default:
3029                         return (ARCHIVE_FATAL);
3030                 }
3031                 zip->pack_stream_inbytes_remaining -= bytes_in;
3032                 if (bytes_out > zip->folder_outbytes_remaining)
3033                         bytes_out = (size_t)zip->folder_outbytes_remaining;
3034                 zip->folder_outbytes_remaining -= bytes_out;
3035                 zip->uncompressed_buffer_bytes_remaining += bytes_out;
3036                 zip->pack_stream_bytes_unconsumed = bytes_in;
3037
3038                 /*
3039                  * Continue decompression until uncompressed_buffer is full.
3040                  */
3041                 if (zip->uncompressed_buffer_bytes_remaining ==
3042                     zip->uncompressed_buffer_size)
3043                         break;
3044                 if (zip->codec2 == _7Z_X86 && zip->odd_bcj_size &&
3045                     zip->uncompressed_buffer_bytes_remaining + 5 >
3046                     zip->uncompressed_buffer_size)
3047                         break;
3048                 if (zip->pack_stream_inbytes_remaining == 0 &&
3049                     zip->folder_outbytes_remaining == 0)
3050                         break;
3051                 if (end_of_data || (bytes_in == 0 && bytes_out == 0)) {
3052                         archive_set_error(&(a->archive),
3053                             ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3054                         return (ARCHIVE_FATAL);
3055                 }
3056                 read_consume(a);
3057         }
3058         if (zip->uncompressed_buffer_bytes_remaining < minimum) {
3059                 archive_set_error(&(a->archive),
3060                     ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3061                 return (ARCHIVE_FATAL);
3062         }
3063         zip->uncompressed_buffer_pointer = zip->uncompressed_buffer;
3064         return (ARCHIVE_OK);
3065 }
3066
3067 static int
3068 seek_pack(struct archive_read *a)
3069 {
3070         struct _7zip *zip = (struct _7zip *)a->format->data;
3071         int64_t pack_offset;
3072
3073         if (zip->pack_stream_remaining <= 0) {
3074                 archive_set_error(&(a->archive),
3075                     ARCHIVE_ERRNO_MISC, "Damaged 7-Zip archive");
3076                 return (ARCHIVE_FATAL);
3077         }
3078         zip->pack_stream_inbytes_remaining =
3079             zip->si.pi.sizes[zip->pack_stream_index];
3080         pack_offset = zip->si.pi.positions[zip->pack_stream_index];
3081         if (zip->stream_offset != pack_offset) {
3082                 if (0 > __archive_read_seek(a, pack_offset + zip->seek_base,
3083                     SEEK_SET))
3084                         return (ARCHIVE_FATAL);
3085                 zip->stream_offset = pack_offset;
3086         }
3087         zip->pack_stream_index++;
3088         zip->pack_stream_remaining--;
3089         return (ARCHIVE_OK);
3090 }
3091
3092 static ssize_t
3093 read_stream(struct archive_read *a, const void **buff, size_t size,
3094     size_t minimum)
3095 {
3096         struct _7zip *zip = (struct _7zip *)a->format->data;
3097         uint64_t skip_bytes = 0;
3098         int r;
3099
3100         if (zip->uncompressed_buffer_bytes_remaining == 0) {
3101                 if (zip->pack_stream_inbytes_remaining > 0) {
3102                         r = extract_pack_stream(a, 0);
3103                         if (r < 0)
3104                                 return (r);
3105                         return (get_uncompressed_data(a, buff, size, minimum));
3106                 } else if (zip->folder_outbytes_remaining > 0) {
3107                         /* Extract a remaining pack stream. */
3108                         r = extract_pack_stream(a, 0);
3109                         if (r < 0)
3110                                 return (r);
3111                         return (get_uncompressed_data(a, buff, size, minimum));
3112                 }
3113         } else
3114                 return (get_uncompressed_data(a, buff, size, minimum));
3115
3116         /*
3117          * Current pack stream has been consumed.
3118          */
3119         if (zip->pack_stream_remaining == 0) {
3120                 if (zip->header_is_being_read) {
3121                         /* Invalid sequence. This might happen when
3122                          * reading a malformed archive. */
3123                         archive_set_error(&(a->archive),
3124                             ARCHIVE_ERRNO_MISC, "Malformed 7-Zip archive");
3125                         return (ARCHIVE_FATAL);
3126                 }
3127
3128                 /*
3129                  * All current folder's pack streams have been
3130                  * consumed. Switch to next folder.
3131                  */
3132                 if (zip->folder_index == 0 &&
3133                     (zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3134                      || zip->folder_index != zip->entry->folderIndex)) {
3135                         zip->folder_index = zip->entry->folderIndex;
3136                         skip_bytes =
3137                             zip->si.ci.folders[zip->folder_index].skipped_bytes;
3138                 }
3139
3140                 if (zip->folder_index >= zip->si.ci.numFolders) {
3141                         /*
3142                          * We have consumed all folders and its pack streams.
3143                          */
3144                         *buff = NULL;
3145                         return (0);
3146                 }
3147                 r = setup_decode_folder(a,
3148                         &(zip->si.ci.folders[zip->folder_index]), 0);
3149                 if (r != ARCHIVE_OK)
3150                         return (ARCHIVE_FATAL);
3151
3152                 zip->folder_index++;
3153         }
3154
3155         /*
3156          * Switch to next pack stream.
3157          */
3158         r = seek_pack(a);
3159         if (r < 0)
3160                 return (r);
3161
3162         /* Extract a new pack stream. */
3163         r = extract_pack_stream(a, 0);
3164         if (r < 0)
3165                 return (r);
3166
3167         /*
3168          * Skip the bytes we alrady has skipped in skip_stream().
3169          */
3170         while (skip_bytes) {
3171                 ssize_t skipped;
3172
3173                 if (zip->uncompressed_buffer_bytes_remaining == 0) {
3174                         if (zip->pack_stream_inbytes_remaining > 0) {
3175                                 r = extract_pack_stream(a, 0);
3176                                 if (r < 0)
3177                                         return (r);
3178                         } else if (zip->folder_outbytes_remaining > 0) {
3179                                 /* Extract a remaining pack stream. */
3180                                 r = extract_pack_stream(a, 0);
3181                                 if (r < 0)
3182                                         return (r);
3183                         } else {
3184                                 archive_set_error(&a->archive,
3185                                     ARCHIVE_ERRNO_FILE_FORMAT,
3186                                     "Truncated 7-Zip file body");
3187                                 return (ARCHIVE_FATAL);
3188                         }
3189                 }
3190                 skipped = get_uncompressed_data(
3191                         a, buff, (size_t)skip_bytes, 0);
3192                 if (skipped < 0)
3193                         return (skipped);
3194                 skip_bytes -= skipped;
3195                 if (zip->pack_stream_bytes_unconsumed)
3196                         read_consume(a);
3197         }
3198
3199         return (get_uncompressed_data(a, buff, size, minimum));
3200 }
3201
3202 static int
3203 setup_decode_folder(struct archive_read *a, struct _7z_folder *folder,
3204     int header)
3205 {
3206         struct _7zip *zip = (struct _7zip *)a->format->data;
3207         const struct _7z_coder *coder1, *coder2;
3208         const char *cname = (header)?"archive header":"file content";
3209         unsigned i;
3210         int r, found_bcj2 = 0;
3211
3212         /*
3213          * Release the memory which the previous folder used for BCJ2.
3214          */
3215         for (i = 0; i < 3; i++) {
3216                 if (zip->sub_stream_buff[i] != NULL)
3217                         free(zip->sub_stream_buff[i]);
3218                 zip->sub_stream_buff[i] = NULL;
3219         }
3220
3221         /*
3222          * Initialize a stream reader.
3223          */
3224         zip->pack_stream_remaining = (unsigned)folder->numPackedStreams;
3225         zip->pack_stream_index = (unsigned)folder->packIndex;
3226         zip->folder_outbytes_remaining = folder_uncompressed_size(folder);
3227         zip->uncompressed_buffer_bytes_remaining = 0;
3228
3229         /*
3230          * Check coder types.
3231          */
3232         for (i = 0; i < folder->numCoders; i++) {
3233                 if (folder->coders[i].codec == _7Z_CRYPTO) {
3234                         archive_set_error(&(a->archive),
3235                             ARCHIVE_ERRNO_MISC,
3236                             "The %s is encrypted, "
3237                             "but currently not supported", cname);
3238                         return (ARCHIVE_FATAL);
3239                 }
3240                 if (folder->coders[i].codec == _7Z_X86_BCJ2)
3241                         found_bcj2++;
3242         }
3243         if ((folder->numCoders > 2 && !found_bcj2) || found_bcj2 > 1) {
3244                 archive_set_error(&(a->archive),
3245                     ARCHIVE_ERRNO_MISC,
3246                     "The %s is encoded with many filters, "
3247                     "but currently not supported", cname);
3248                 return (ARCHIVE_FATAL);
3249         }
3250         coder1 = &(folder->coders[0]);
3251         if (folder->numCoders == 2)
3252                 coder2 = &(folder->coders[1]);
3253         else
3254                 coder2 = NULL;
3255
3256         if (found_bcj2) {
3257                 /*
3258                  * Preparation to decode BCJ2.
3259                  * Decoding BCJ2 requires four sources. Those are at least,
3260                  * as far as I know, two types of the storage form.
3261                  */
3262                 const struct _7z_coder *fc = folder->coders;
3263                 static const struct _7z_coder coder_copy = {0, 1, 1, 0, NULL};
3264                 const struct _7z_coder *scoder[3] =
3265                         {&coder_copy, &coder_copy, &coder_copy};
3266                 const void *buff;
3267                 ssize_t bytes;
3268                 unsigned char *b[3] = {NULL, NULL, NULL};
3269                 uint64_t sunpack[3] ={-1, -1, -1};
3270                 size_t s[3] = {0, 0, 0};
3271                 int idx[3] = {0, 1, 2};
3272
3273                 if (folder->numCoders == 4 && fc[3].codec == _7Z_X86_BCJ2 &&
3274                     folder->numInStreams == 7 && folder->numOutStreams == 4 &&
3275                     zip->pack_stream_remaining == 4) {
3276                         /* Source type 1 made by 7zr or 7z with -m options. */
3277                         if (folder->bindPairs[0].inIndex == 5) {
3278                                 /* The form made by 7zr */
3279                                 idx[0] = 1; idx[1] = 2; idx[2] = 0;
3280                                 scoder[1] = &(fc[1]);
3281                                 scoder[2] = &(fc[0]);
3282                                 sunpack[1] = folder->unPackSize[1];
3283                                 sunpack[2] = folder->unPackSize[0];
3284                                 coder1 = &(fc[2]);
3285                         } else {
3286                                 /*
3287                                  * NOTE: Some patterns do not work.
3288                                  * work:
3289                                  *  7z a -m0=BCJ2 -m1=COPY -m2=COPY
3290                                  *       -m3=(any)
3291                                  *  7z a -m0=BCJ2 -m1=COPY -m2=(any)
3292                                  *       -m3=COPY
3293                                  *  7z a -m0=BCJ2 -m1=(any) -m2=COPY
3294                                  *       -m3=COPY
3295                                  * not work:
3296                                  *  other patterns.
3297                                  *
3298                                  * We have to handle this like `pipe' or
3299                                  * our libarchive7s filter frame work,
3300                                  * decoding the BCJ2 main stream sequentially,
3301                                  * m3 -> m2 -> m1 -> BCJ2.
3302                                  *
3303                                  */
3304                                 if (fc[0].codec == _7Z_COPY &&
3305                                     fc[1].codec == _7Z_COPY)
3306                                         coder1 = &(folder->coders[2]);
3307                                 else if (fc[0].codec == _7Z_COPY &&
3308                                     fc[2].codec == _7Z_COPY)
3309                                         coder1 = &(folder->coders[1]);
3310                                 else if (fc[1].codec == _7Z_COPY &&
3311                                     fc[2].codec == _7Z_COPY)
3312                                         coder1 = &(folder->coders[0]);
3313                                 else {
3314                                         archive_set_error(&(a->archive),
3315                                             ARCHIVE_ERRNO_MISC,
3316                                             "Unsupported form of "
3317                                             "BCJ2 streams");
3318                                         return (ARCHIVE_FATAL);
3319                                 }
3320                         }
3321                         coder2 = &(fc[3]);
3322                         zip->main_stream_bytes_remaining =
3323                                 (size_t)folder->unPackSize[2];
3324                 } else if (coder2 != NULL && coder2->codec == _7Z_X86_BCJ2 &&
3325                     zip->pack_stream_remaining == 4 &&
3326                     folder->numInStreams == 5 && folder->numOutStreams == 2) {
3327                         /* Source type 0 made by 7z */
3328                         zip->main_stream_bytes_remaining =
3329                                 (size_t)folder->unPackSize[0];
3330                 } else {
3331                         /* We got an unexpected form. */
3332                         archive_set_error(&(a->archive),
3333                             ARCHIVE_ERRNO_MISC,
3334                             "Unsupported form of BCJ2 streams");
3335                         return (ARCHIVE_FATAL);
3336                 }
3337
3338                 /* Skip the main stream at this time. */
3339                 if ((r = seek_pack(a)) < 0)
3340                         return (r);
3341                 zip->pack_stream_bytes_unconsumed =
3342                     (size_t)zip->pack_stream_inbytes_remaining;
3343                 read_consume(a);
3344
3345                 /* Read following three sub streams. */
3346                 for (i = 0; i < 3; i++) {
3347                         const struct _7z_coder *coder = scoder[i];
3348
3349                         if ((r = seek_pack(a)) < 0)
3350                                 return (r);
3351
3352                         if (sunpack[i] == (uint64_t)-1)
3353                                 zip->folder_outbytes_remaining =
3354                                     zip->pack_stream_inbytes_remaining;
3355                         else
3356                                 zip->folder_outbytes_remaining = sunpack[i];
3357
3358                         r = init_decompression(a, zip, coder, NULL);
3359                         if (r != ARCHIVE_OK)
3360                                 return (ARCHIVE_FATAL);
3361
3362                         /* Allocate memory for the decorded data of a sub
3363                          * stream. */
3364                         b[i] = malloc((size_t)zip->folder_outbytes_remaining);
3365                         if (b[i] == NULL) {
3366                                 archive_set_error(&a->archive, ENOMEM,
3367                                     "No memory for 7-Zip decompression");
3368                                 return (ARCHIVE_FATAL);
3369                         }
3370
3371                         /* Extract a sub stream. */
3372                         while (zip->pack_stream_inbytes_remaining > 0) {
3373                                 r = extract_pack_stream(a, 0);
3374                                 if (r < 0)
3375                                         return (r);
3376                                 bytes = get_uncompressed_data(a, &buff,
3377                                     zip->uncompressed_buffer_bytes_remaining,
3378                                     0);
3379                                 if (bytes < 0)
3380                                         return ((int)bytes);
3381                                 memcpy(b[i]+s[i], buff, bytes);
3382                                 s[i] += bytes;
3383                                 if (zip->pack_stream_bytes_unconsumed)
3384                                         read_consume(a);
3385                         }
3386                 }
3387
3388                 /* Set the sub streams to the right place. */
3389                 for (i = 0; i < 3; i++) {
3390                         zip->sub_stream_buff[i] = b[idx[i]];
3391                         zip->sub_stream_size[i] = s[idx[i]];
3392                         zip->sub_stream_bytes_remaining[i] = s[idx[i]];
3393                 }
3394
3395                 /* Allocate memory used for decoded main stream bytes. */
3396                 if (zip->tmp_stream_buff == NULL) {
3397                         zip->tmp_stream_buff_size = 32 * 1024;
3398                         zip->tmp_stream_buff =
3399                             malloc(zip->tmp_stream_buff_size);
3400                         if (zip->tmp_stream_buff == NULL) {
3401                                 archive_set_error(&a->archive, ENOMEM,
3402                                     "No memory for 7-Zip decompression");
3403                                 return (ARCHIVE_FATAL);
3404                         }
3405                 }
3406                 zip->tmp_stream_bytes_avail = 0;
3407                 zip->tmp_stream_bytes_remaining = 0;
3408                 zip->odd_bcj_size = 0;
3409                 zip->bcj2_outPos = 0;
3410
3411                 /*
3412                  * Reset a stream reader in order to read the main stream
3413                  * of BCJ2.
3414                  */
3415                 zip->pack_stream_remaining = 1;
3416                 zip->pack_stream_index = (unsigned)folder->packIndex;
3417                 zip->folder_outbytes_remaining =
3418                     folder_uncompressed_size(folder);
3419                 zip->uncompressed_buffer_bytes_remaining = 0;
3420         }
3421
3422         /*
3423          * Initialize the decompressor for the new folder's pack streams.
3424          */
3425         r = init_decompression(a, zip, coder1, coder2);
3426         if (r != ARCHIVE_OK)
3427                 return (ARCHIVE_FATAL);
3428         return (ARCHIVE_OK);
3429 }
3430
3431 static int64_t
3432 skip_stream(struct archive_read *a, size_t skip_bytes)
3433 {
3434         struct _7zip *zip = (struct _7zip *)a->format->data;
3435         const void *p;
3436         int64_t skipped_bytes;
3437         size_t bytes = skip_bytes;
3438
3439         if (zip->folder_index == 0) {
3440                 /*
3441                  * Optimization for a list mode.
3442                  * Avoid unncecessary decoding operations.
3443                  */
3444                 zip->si.ci.folders[zip->entry->folderIndex].skipped_bytes
3445                     += skip_bytes;
3446                 return (skip_bytes);
3447         }
3448
3449         while (bytes) {
3450                 skipped_bytes = read_stream(a, &p, bytes, 0);
3451                 if (skipped_bytes < 0)
3452                         return (skipped_bytes);
3453                 if (skipped_bytes == 0) {
3454                         archive_set_error(&a->archive,
3455                             ARCHIVE_ERRNO_FILE_FORMAT,
3456                             "Truncated 7-Zip file body");
3457                         return (ARCHIVE_FATAL);
3458                 }
3459                 bytes -= (size_t)skipped_bytes;
3460                 if (zip->pack_stream_bytes_unconsumed)
3461                         read_consume(a);
3462         }
3463         return (skip_bytes);
3464 }
3465
3466 /*
3467  * Brought from LZMA SDK.
3468  *
3469  * Bra86.c -- Converter for x86 code (BCJ)
3470  * 2008-10-04 : Igor Pavlov : Public domain
3471  *
3472  */
3473
3474 #define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
3475
3476 static void
3477 x86_Init(struct _7zip *zip)
3478 {
3479         zip->bcj_state = 0;
3480         zip->bcj_prevPosT = (size_t)0 - 1;
3481         zip->bcj_prevMask = 0;
3482         zip->bcj_ip = 5;
3483 }
3484
3485 static size_t
3486 x86_Convert(struct _7zip *zip, uint8_t *data, size_t size)
3487 {
3488         static const uint8_t kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
3489         static const uint8_t kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
3490         size_t bufferPos, prevPosT;
3491         uint32_t ip, prevMask;
3492
3493         if (size < 5)
3494                 return 0;
3495
3496         bufferPos = 0;
3497         prevPosT = zip->bcj_prevPosT;
3498         prevMask = zip->bcj_prevMask;
3499         ip = zip->bcj_ip;
3500
3501         for (;;) {
3502                 uint8_t *p = data + bufferPos;
3503                 uint8_t *limit = data + size - 4;
3504
3505                 for (; p < limit; p++)
3506                         if ((*p & 0xFE) == 0xE8)
3507                                 break;
3508                 bufferPos = (size_t)(p - data);
3509                 if (p >= limit)
3510                         break;
3511                 prevPosT = bufferPos - prevPosT;
3512                 if (prevPosT > 3)
3513                         prevMask = 0;
3514                 else {
3515                         prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;
3516                         if (prevMask != 0) {
3517                                 unsigned char b =
3518                                         p[4 - kMaskToBitNumber[prevMask]];
3519                                 if (!kMaskToAllowedStatus[prevMask] ||
3520                                     Test86MSByte(b)) {
3521                                         prevPosT = bufferPos;
3522                                         prevMask = ((prevMask << 1) & 0x7) | 1;
3523                                         bufferPos++;
3524                                         continue;
3525                                 }
3526                         }
3527                 }
3528                 prevPosT = bufferPos;
3529
3530                 if (Test86MSByte(p[4])) {
3531                         uint32_t src = ((uint32_t)p[4] << 24) |
3532                                 ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) |
3533                                 ((uint32_t)p[1]);
3534                         uint32_t dest;
3535                         for (;;) {
3536                                 uint8_t b;
3537                                 int b_index;
3538
3539                                 dest = src - (ip + (uint32_t)bufferPos);
3540                                 if (prevMask == 0)
3541                                         break;
3542                                 b_index = kMaskToBitNumber[prevMask] * 8;
3543                                 b = (uint8_t)(dest >> (24 - b_index));
3544                                 if (!Test86MSByte(b))
3545                                         break;
3546                                 src = dest ^ ((1 << (32 - b_index)) - 1);
3547                         }
3548                         p[4] = (uint8_t)(~(((dest >> 24) & 1) - 1));
3549                         p[3] = (uint8_t)(dest >> 16);
3550                         p[2] = (uint8_t)(dest >> 8);
3551                         p[1] = (uint8_t)dest;
3552                         bufferPos += 5;
3553                 } else {
3554                         prevMask = ((prevMask << 1) & 0x7) | 1;
3555                         bufferPos++;
3556                 }
3557         }
3558         zip->bcj_prevPosT = prevPosT;
3559         zip->bcj_prevMask = prevMask;
3560         zip->bcj_ip += bufferPos;
3561         return (bufferPos);
3562 }
3563
3564 /*
3565  * Brought from LZMA SDK.
3566  *
3567  * Bcj2.c -- Converter for x86 code (BCJ2)
3568  * 2008-10-04 : Igor Pavlov : Public domain
3569  *
3570  */
3571
3572 #define SZ_ERROR_DATA    ARCHIVE_FAILED
3573
3574 #define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80)
3575 #define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1))
3576
3577 #define kNumTopBits 24
3578 #define kTopValue ((uint32_t)1 << kNumTopBits)
3579
3580 #define kNumBitModelTotalBits 11
3581 #define kBitModelTotal (1 << kNumBitModelTotalBits)
3582 #define kNumMoveBits 5
3583
3584 #define RC_READ_BYTE (*buffer++)
3585 #define RC_TEST { if (buffer == bufferLim) return SZ_ERROR_DATA; }
3586 #define RC_INIT2 zip->bcj2_code = 0; zip->bcj2_range = 0xFFFFFFFF; \
3587   { int ii; for (ii = 0; ii < 5; ii++) { RC_TEST; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }}
3588
3589 #define NORMALIZE if (zip->bcj2_range < kTopValue) { RC_TEST; zip->bcj2_range <<= 8; zip->bcj2_code = (zip->bcj2_code << 8) | RC_READ_BYTE; }
3590
3591 #define IF_BIT_0(p) ttt = *(p); bound = (zip->bcj2_range >> kNumBitModelTotalBits) * ttt; if (zip->bcj2_code < bound)
3592 #define UPDATE_0(p) zip->bcj2_range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); NORMALIZE;
3593 #define UPDATE_1(p) zip->bcj2_range -= bound; zip->bcj2_code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); NORMALIZE;
3594
3595 static ssize_t
3596 Bcj2_Decode(struct _7zip *zip, uint8_t *outBuf, size_t outSize)
3597 {
3598         size_t inPos = 0, outPos = 0;
3599         const uint8_t *buf0, *buf1, *buf2, *buf3;
3600         size_t size0, size1, size2, size3;
3601         const uint8_t *buffer, *bufferLim;
3602         unsigned int i, j;
3603
3604         size0 = zip->tmp_stream_bytes_remaining;
3605         buf0 = zip->tmp_stream_buff + zip->tmp_stream_bytes_avail - size0;
3606         size1 = zip->sub_stream_bytes_remaining[0];
3607         buf1 = zip->sub_stream_buff[0] + zip->sub_stream_size[0] - size1;
3608         size2 = zip->sub_stream_bytes_remaining[1];
3609         buf2 = zip->sub_stream_buff[1] + zip->sub_stream_size[1] - size2;
3610         size3 = zip->sub_stream_bytes_remaining[2];
3611         buf3 = zip->sub_stream_buff[2] + zip->sub_stream_size[2] - size3;
3612
3613         buffer = buf3;
3614         bufferLim = buffer + size3;
3615
3616         if (zip->bcj_state == 0) {
3617                 /*
3618                  * Initialize.
3619                  */
3620                 zip->bcj2_prevByte = 0;
3621                 for (i = 0;
3622                     i < sizeof(zip->bcj2_p) / sizeof(zip->bcj2_p[0]); i++)
3623                         zip->bcj2_p[i] = kBitModelTotal >> 1;
3624                 RC_INIT2;
3625                 zip->bcj_state = 1;
3626         }
3627
3628         /*
3629          * Gather the odd bytes of a previous call.
3630          */
3631         for (i = 0; zip->odd_bcj_size > 0 && outPos < outSize; i++) {
3632                 outBuf[outPos++] = zip->odd_bcj[i];
3633                 zip->odd_bcj_size--;
3634         }
3635
3636         if (outSize == 0) {
3637                 zip->bcj2_outPos += outPos;
3638                 return (outPos);
3639         }
3640
3641         for (;;) {
3642                 uint8_t b;
3643                 CProb *prob;
3644                 uint32_t bound;
3645                 uint32_t ttt;
3646
3647                 size_t limit = size0 - inPos;
3648                 if (outSize - outPos < limit)
3649                         limit = outSize - outPos;
3650
3651                 if (zip->bcj_state == 1) {
3652                         while (limit != 0) {
3653                                 uint8_t bb = buf0[inPos];
3654                                 outBuf[outPos++] = bb;
3655                                 if (IsJ(zip->bcj2_prevByte, bb)) {
3656                                         zip->bcj_state = 2;
3657                                         break;
3658                                 }
3659                                 inPos++;
3660                                 zip->bcj2_prevByte = bb;
3661                                 limit--;
3662                         }
3663                 }
3664
3665                 if (limit == 0 || outPos == outSize)
3666                         break;
3667                 zip->bcj_state = 1;
3668
3669                 b = buf0[inPos++];
3670
3671                 if (b == 0xE8)
3672                         prob = zip->bcj2_p + zip->bcj2_prevByte;
3673                 else if (b == 0xE9)
3674                         prob = zip->bcj2_p + 256;
3675                 else
3676                         prob = zip->bcj2_p + 257;
3677
3678                 IF_BIT_0(prob) {
3679                         UPDATE_0(prob)
3680                         zip->bcj2_prevByte = b;
3681                 } else {
3682                         uint32_t dest;
3683                         const uint8_t *v;
3684                         uint8_t out[4];
3685
3686                         UPDATE_1(prob)
3687                         if (b == 0xE8) {
3688                                 v = buf1;
3689                                 if (size1 < 4)
3690                                         return SZ_ERROR_DATA;
3691                                 buf1 += 4;
3692                                 size1 -= 4;
3693                         } else {
3694                                 v = buf2;
3695                                 if (size2 < 4)
3696                                         return SZ_ERROR_DATA;
3697                                 buf2 += 4;
3698                                 size2 -= 4;
3699                         }
3700                         dest = (((uint32_t)v[0] << 24) |
3701                             ((uint32_t)v[1] << 16) |
3702                             ((uint32_t)v[2] << 8) |
3703                             ((uint32_t)v[3])) -
3704                             ((uint32_t)zip->bcj2_outPos + outPos + 4);
3705                         out[0] = (uint8_t)dest;
3706                         out[1] = (uint8_t)(dest >> 8);
3707                         out[2] = (uint8_t)(dest >> 16);
3708                         out[3] = zip->bcj2_prevByte = (uint8_t)(dest >> 24);
3709
3710                         for (i = 0; i < 4 && outPos < outSize; i++)
3711                                 outBuf[outPos++] = out[i];
3712                         if (i < 4) {
3713                                 /*
3714                                  * Save odd bytes which we could not add into
3715                                  * the output buffer because of out of space.
3716                                  */
3717                                 zip->odd_bcj_size = 4 -i;
3718                                 for (; i < 4; i++) {
3719                                         j = i - 4 + zip->odd_bcj_size;
3720                                         zip->odd_bcj[j] = out[i];
3721                                 }
3722                                 break;
3723                         }
3724                 }
3725         }
3726         zip->tmp_stream_bytes_remaining -= inPos;
3727         zip->sub_stream_bytes_remaining[0] = size1;
3728         zip->sub_stream_bytes_remaining[1] = size2;
3729         zip->sub_stream_bytes_remaining[2] = bufferLim - buffer;
3730         zip->bcj2_outPos += outPos;
3731
3732         return ((ssize_t)outPos);
3733 }
3734