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