| // Copyright 2015 The Bazel Authors. All rights reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| // | |
| // zip.cc -- .zip (.jar) file reading/writing routines. | |
| // | |
| // See README.txt for details. | |
| // | |
| // See http://www.pkware.com/documents/casestudies/APPNOTE.TXT | |
| // for definition of PKZIP file format. | |
| #define _FILE_OFFSET_BITS 64 // Support zip files larger than 2GB | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <stddef.h> | |
| #include <stdint.h> | |
| #include <stdarg.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <limits.h> | |
| #include <limits> | |
| #include <vector> | |
| #include "third_party/ijar/mapped_file.h" | |
| #include "third_party/ijar/platform_utils.h" | |
| #include "third_party/ijar/zip.h" | |
| #include "third_party/ijar/zlib_client.h" | |
| #define LOCAL_FILE_HEADER_SIGNATURE 0x04034b50 | |
| #define CENTRAL_FILE_HEADER_SIGNATURE 0x02014b50 | |
| #define UNIX_ZIP_FILE_VERSION 0x0300 | |
| #define DIGITAL_SIGNATURE 0x05054b50 | |
| #define ZIP64_EOCD_SIGNATURE 0x06064b50 | |
| #define ZIP64_EOCD_LOCATOR_SIGNATURE 0x07064b50 | |
| #define EOCD_SIGNATURE 0x06054b50 | |
| #define DATA_DESCRIPTOR_SIGNATURE 0x08074b50 | |
| #define ZIP64_EXTRA_FIELD_TAG 0x0001 | |
| #define U2_MAX 0xffff | |
| #define U4_MAX 0xffffffffUL | |
| #define ZIP64_EOCD_LOCATOR_SIZE 20 | |
| // zip64 eocd is fixed size in the absence of a zip64 extensible data sector | |
| #define ZIP64_EOCD_FIXED_SIZE 56 | |
| // version to extract: 1.0 - default value from APPNOTE.TXT. | |
| // Output JAR files contain no extra ZIP features, so this is enough. | |
| #define ZIP_VERSION_TO_EXTRACT 10 | |
| #define COMPRESSION_METHOD_STORED 0 // no compression | |
| #define COMPRESSION_METHOD_DEFLATED 8 | |
| #define GENERAL_PURPOSE_BIT_FLAG_COMPRESSED (1 << 3) | |
| #define GENERAL_PURPOSE_BIT_FLAG_UTF8_ENCODED (1 << 11) | |
| #define GENERAL_PURPOSE_BIT_FLAG_COMPRESSION_SPEED ((1 << 2) | (1 << 1)) | |
| #define GENERAL_PURPOSE_BIT_FLAG_SUPPORTED \ | |
| (GENERAL_PURPOSE_BIT_FLAG_COMPRESSED \ | |
| | GENERAL_PURPOSE_BIT_FLAG_UTF8_ENCODED \ | |
| | GENERAL_PURPOSE_BIT_FLAG_COMPRESSION_SPEED) | |
| namespace devtools_ijar { | |
| // In the absence of ZIP64 support, zip files are limited to 4GB. | |
| // http://www.info-zip.org/FAQ.html#limits | |
| static const size_t kMaximumOutputSize = std::numeric_limits<uint32_t>::max(); | |
| static const u4 kDefaultTimestamp = | |
| 30 << 25 | 1 << 21 | 1 << 16; // January 1, 2010 in DOS time | |
| // | |
| // A class representing a ZipFile for reading. Its public API is exposed | |
| // using the ZipExtractor abstract class. | |
| // | |
| class InputZipFile : public ZipExtractor { | |
| public: | |
| InputZipFile(ZipExtractorProcessor *processor, const char* filename); | |
| virtual ~InputZipFile(); | |
| virtual const char* GetError() { | |
| if (errmsg[0] == 0) { | |
| return NULL; | |
| } | |
| return errmsg; | |
| } | |
| bool Open(); | |
| virtual bool ProcessNext(); | |
| virtual void Reset(); | |
| virtual size_t GetSize() { | |
| return input_file_->Length(); | |
| } | |
| virtual u8 CalculateOutputLength(); | |
| virtual bool ProcessCentralDirEntry(const u1 *&p, u8 *compressed_size, | |
| u8 *uncompressed_size, char *filename, | |
| size_t filename_size, u4 *attr, | |
| u8 *offset); | |
| private: | |
| ZipExtractorProcessor *processor; | |
| const char* filename_; | |
| MappedInputFile *input_file_; | |
| // InputZipFile is responsible for maintaining the following | |
| // pointers. They are allocated by the Create() method before | |
| // the object is actually created using mmap. | |
| const u1 * zipdata_in_; // start of input file mmap | |
| size_t bytes_unmapped_; // bytes that have already been unmapped | |
| const u1 * central_dir_; // central directory in input file | |
| size_t in_offset_; // offset the input file | |
| const u1 *p; // input cursor | |
| const u1* central_dir_current_; // central dir input cursor | |
| // Buffer size is initially INITIAL_BUFFER_SIZE. It doubles in size every | |
| // time it is found too small, until it reaches MAX_BUFFER_SIZE. If that is | |
| // not enough, we bail out. We only decompress class files, so they should | |
| // be smaller than 64K anyway, but we give a little leeway. | |
| // MAX_BUFFER_SIZE must be bigger than the size of the biggest file in the | |
| // ZIP. It is set to 2GB here because no one has audited the code for 64-bit | |
| // cleanliness. | |
| static constexpr size_t INITIAL_BUFFER_SIZE = 256 * 1024; // 256K | |
| static constexpr size_t MAX_BUFFER_SIZE = std::numeric_limits<int32_t>::max(); | |
| static constexpr size_t MAX_MAPPED_REGION = 32 * 1024 * 1024; | |
| // These metadata fields are the fields of the ZIP header of the file being | |
| // processed. | |
| u2 extract_version_; | |
| u2 general_purpose_bit_flag_; | |
| u2 compression_method_; | |
| u8 uncompressed_size_; | |
| u8 compressed_size_; | |
| u2 file_name_length_; | |
| u2 extra_field_length_; | |
| const u1 *file_name_; | |
| const u1 *extra_field_; | |
| // Copy of the last filename entry - Null-terminated. | |
| char filename[PATH_MAX]; | |
| // The external file attribute field | |
| u4 attr; | |
| // last error | |
| char errmsg[4*PATH_MAX]; | |
| Decompressor *decompressor_; | |
| int error(const char *fmt, ...) { | |
| va_list ap; | |
| va_start(ap, fmt); | |
| vsnprintf(errmsg, 4*PATH_MAX, fmt, ap); | |
| va_end(ap); | |
| return -1; | |
| } | |
| // Check that at least n bytes remain in the input file, otherwise | |
| // abort with an error message. "state" is the name of the field | |
| // we're about to read, for diagnostics. | |
| int EnsureRemaining(size_t n, const char *state) { | |
| size_t in_offset = p - zipdata_in_; | |
| size_t remaining = input_file_->Length() - in_offset; | |
| if (n > remaining) { | |
| return error("Premature end of file (at offset %zd, state=%s); " | |
| "expected %zd more bytes but found %zd.\n", | |
| in_offset, state, n, remaining); | |
| } | |
| return 0; | |
| } | |
| // Read one entry from input zip file | |
| int ProcessLocalFileEntry(size_t compressed_size, size_t uncompressed_size); | |
| // Uncompress a file from the archive using zlib. The pointer returned | |
| // is owned by InputZipFile, so it must not be freed. Advances the input | |
| // cursor to the first byte after the compressed data. | |
| u1* UncompressFile(); | |
| // Skip a file | |
| int SkipFile(bool compressed); | |
| // Process a file | |
| int ProcessFile(bool compressed); | |
| }; | |
| // | |
| // A class implementing ZipBuilder that represent an open zip file for writing. | |
| // | |
| class OutputZipFile : public ZipBuilder { | |
| public: | |
| OutputZipFile(const char *filename, size_t estimated_size) | |
| : output_file_(NULL), | |
| filename_(filename), | |
| estimated_size_(estimated_size), | |
| finished_(false) { | |
| errmsg[0] = 0; | |
| } | |
| virtual const char* GetError() { | |
| if (errmsg[0] == 0) { | |
| return NULL; | |
| } | |
| return errmsg; | |
| } | |
| virtual ~OutputZipFile() { Finish(); } | |
| virtual u1 *NewFile(const char *filename, u4 attr); | |
| virtual int FinishFile(size_t filelength, bool compress = false, | |
| bool compute_crc = false); | |
| virtual int WriteEmptyFile(const char *filename); | |
| virtual size_t GetSize() { | |
| return Offset(q); | |
| } | |
| virtual int GetNumberFiles() { | |
| return entries_.size(); | |
| } | |
| virtual int Finish(); | |
| bool Open(); | |
| private: | |
| struct LocalFileEntry { | |
| // Start of the local header (in the output buffer). | |
| size_t local_header_offset; | |
| // Sizes of the file entry | |
| size_t uncompressed_length; | |
| size_t compressed_length; | |
| // Compression method | |
| u2 compression_method; | |
| // CRC32 | |
| u4 crc32; | |
| // external attributes field | |
| u4 external_attr; | |
| // Start/length of the file_name in the local header. | |
| u1 *file_name; | |
| u2 file_name_length; | |
| // Start/length of the extra_field in the local header. | |
| const u1 *extra_field; | |
| u2 extra_field_length; | |
| }; | |
| MappedOutputFile* output_file_; | |
| const char* filename_; | |
| size_t estimated_size_; | |
| bool finished_; | |
| // OutputZipFile is responsible for maintaining the following | |
| // pointers. They are allocated by the Create() method before | |
| // the object is actually created using mmap. | |
| u1 *zipdata_out_; // start of output file mmap | |
| u1 *q; // output cursor | |
| u1 *header_ptr; // Current pointer to "compression method" entry. | |
| // List of entries to write the central directory | |
| std::vector<LocalFileEntry*> entries_; | |
| // last error | |
| char errmsg[4*PATH_MAX]; | |
| int error(const char *fmt, ...) { | |
| va_list ap; | |
| va_start(ap, fmt); | |
| vsnprintf(errmsg, 4*PATH_MAX, fmt, ap); | |
| va_end(ap); | |
| return -1; | |
| } | |
| // Write the ZIP central directory structure for each local file | |
| // entry in "entries". | |
| void WriteCentralDirectory(); | |
| // Returns the offset of the pointer relative to the start of the | |
| // output zip file. | |
| size_t Offset(const u1 *const x) { | |
| return x - zipdata_out_; | |
| } | |
| // Write ZIP file header in the output. Since the compressed size is not | |
| // known in advance, it must be recorded later. This method returns a pointer | |
| // to "compressed size" in the file header that should be passed to | |
| // WriteFileSizeInLocalFileHeader() later. | |
| u1 *WriteLocalFileHeader(const char *filename, u4 attr); | |
| // Fill in the "compressed size" and "uncompressed size" fields in a local | |
| // file header previously written by WriteLocalFileHeader(). | |
| size_t WriteFileSizeInLocalFileHeader(u1 *header_ptr, size_t out_length, | |
| bool compress = false, u4 crc = 0); | |
| }; | |
| // | |
| // Implementation of InputZipFile | |
| // | |
| bool InputZipFile::ProcessNext() { | |
| // Process the next entry in the central directory. Also make sure that the | |
| // content pointer is in sync. | |
| u8 compressed, uncompressed; | |
| u8 offset; | |
| if (!ProcessCentralDirEntry(central_dir_current_, &compressed, &uncompressed, | |
| filename, PATH_MAX, &attr, &offset)) { | |
| return false; | |
| } | |
| // There might be an offset specified in the central directory that does | |
| // not match the file offset, so always update our pointer. | |
| p = zipdata_in_ + in_offset_ + offset; | |
| if (EnsureRemaining(4, "signature") < 0) { | |
| return false; | |
| } | |
| u4 signature = get_u4le(p); | |
| if (signature == LOCAL_FILE_HEADER_SIGNATURE) { | |
| if (ProcessLocalFileEntry(compressed, uncompressed) < 0) { | |
| return false; | |
| } | |
| } else { | |
| error("local file header signature for file %s not found\n", filename); | |
| return false; | |
| } | |
| return true; | |
| } | |
| int InputZipFile::ProcessLocalFileEntry( | |
| size_t compressed_size, size_t uncompressed_size) { | |
| if (EnsureRemaining(26, "extract_version") < 0) { | |
| return -1; | |
| } | |
| extract_version_ = get_u2le(p); | |
| general_purpose_bit_flag_ = get_u2le(p); | |
| if ((general_purpose_bit_flag_ & ~GENERAL_PURPOSE_BIT_FLAG_SUPPORTED) != 0) { | |
| return error("Unsupported value (0x%04x) in general purpose bit flag.\n", | |
| general_purpose_bit_flag_); | |
| } | |
| compression_method_ = get_u2le(p); | |
| if (compression_method_ != COMPRESSION_METHOD_DEFLATED && | |
| compression_method_ != COMPRESSION_METHOD_STORED) { | |
| return error("Unsupported compression method (%d).\n", | |
| compression_method_); | |
| } | |
| // skip over: last_mod_file_time, last_mod_file_date, crc32 | |
| p += 2 + 2 + 4; | |
| compressed_size_ = get_u4le(p); | |
| uncompressed_size_ = get_u4le(p); | |
| file_name_length_ = get_u2le(p); | |
| extra_field_length_ = get_u2le(p); | |
| if (EnsureRemaining(file_name_length_, "file_name") < 0) { | |
| return -1; | |
| } | |
| file_name_ = p; | |
| p += file_name_length_; | |
| if (EnsureRemaining(extra_field_length_, "extra_field") < 0) { | |
| return -1; | |
| } | |
| extra_field_ = p; | |
| p += extra_field_length_; | |
| bool is_compressed = compression_method_ == COMPRESSION_METHOD_DEFLATED; | |
| // If the zip is compressed, compressed and uncompressed size members are | |
| // zero in the local file header. If not, check that they are the same as the | |
| // lengths from the central directory, otherwise, just believe the central | |
| // directory | |
| if (compressed_size_ == 0 || compressed_size_ == U4_MAX) { | |
| compressed_size_ = compressed_size; | |
| } else { | |
| if (compressed_size_ != compressed_size) { | |
| return error("central directory and file header inconsistent\n"); | |
| } | |
| } | |
| if (uncompressed_size_ == 0 || uncompressed_size_ == U4_MAX) { | |
| uncompressed_size_ = uncompressed_size; | |
| } else { | |
| if (uncompressed_size_ != uncompressed_size) { | |
| return error("central directory and file header inconsistent\n"); | |
| } | |
| } | |
| if (processor->Accept(filename, attr)) { | |
| if (ProcessFile(is_compressed) < 0) { | |
| return -1; | |
| } | |
| } else { | |
| if (SkipFile(is_compressed) < 0) { | |
| return -1; | |
| } | |
| } | |
| if (general_purpose_bit_flag_ & GENERAL_PURPOSE_BIT_FLAG_COMPRESSED) { | |
| // Skip the data descriptor. Some implementations do not put the signature | |
| // here, so check if the next 4 bytes are a signature, and if so, skip the | |
| // next 12 bytes (for CRC, compressed/uncompressed size), otherwise skip | |
| // the next 8 bytes (because the value just read was the CRC). | |
| u4 signature = get_u4le(p); | |
| if (signature == DATA_DESCRIPTOR_SIGNATURE) { | |
| p += 4 * 3; | |
| } else { | |
| p += 4 * 2; | |
| } | |
| } | |
| size_t bytes_processed = p - zipdata_in_; | |
| if (bytes_processed > bytes_unmapped_ + MAX_MAPPED_REGION) { | |
| input_file_->Discard(MAX_MAPPED_REGION); | |
| bytes_unmapped_ += MAX_MAPPED_REGION; | |
| } | |
| return 0; | |
| } | |
| int InputZipFile::SkipFile(const bool compressed) { | |
| if (!compressed) { | |
| // In this case, compressed_size_ == uncompressed_size_ (since the file is | |
| // uncompressed), so we can use either. | |
| if (compressed_size_ != uncompressed_size_) { | |
| return error("compressed size != uncompressed size, although the file " | |
| "is uncompressed.\n"); | |
| } | |
| } | |
| if (EnsureRemaining(compressed_size_, "file_data") < 0) { | |
| return -1; | |
| } | |
| p += compressed_size_; | |
| return 0; | |
| } | |
| u1* InputZipFile::UncompressFile() { | |
| size_t in_offset = p - zipdata_in_; | |
| size_t remaining = input_file_->Length() - in_offset; | |
| DecompressedFile *decompressed_file = | |
| decompressor_->UncompressFile(p, remaining); | |
| if (decompressed_file == NULL) { | |
| if (decompressor_->GetError() != NULL) { | |
| error(decompressor_->GetError()); | |
| } | |
| return NULL; | |
| } else { | |
| compressed_size_ = decompressed_file->compressed_size; | |
| uncompressed_size_ = decompressed_file->uncompressed_size; | |
| u1 *uncompressed_data = decompressed_file->uncompressed_data; | |
| free(decompressed_file); | |
| p += compressed_size_; | |
| return uncompressed_data; | |
| } | |
| } | |
| int InputZipFile::ProcessFile(const bool compressed) { | |
| const u1 *file_data; | |
| if (compressed) { | |
| file_data = UncompressFile(); | |
| if (file_data == NULL) { | |
| return -1; | |
| } | |
| } else { | |
| // In this case, compressed_size_ == uncompressed_size_ (since the file is | |
| // uncompressed), so we can use either. | |
| if (compressed_size_ != uncompressed_size_) { | |
| return error("compressed size != uncompressed size, although the file " | |
| "is uncompressed.\n"); | |
| } | |
| if (EnsureRemaining(compressed_size_, "file_data") < 0) { | |
| return -1; | |
| } | |
| file_data = p; | |
| p += compressed_size_; | |
| } | |
| processor->Process(filename, attr, file_data, uncompressed_size_); | |
| return 0; | |
| } | |
| // Reads and returns some metadata of the next file from the central directory: | |
| // - compressed size | |
| // - uncompressed size | |
| // - whether the entry is a class file (to be included in the output). | |
| // Precondition: p points to the beginning of an entry in the central dir | |
| // Postcondition: p points to the beginning of the next entry in the central dir | |
| // Returns true if the central directory contains another file and false if not. | |
| // Of course, in the latter case, the size output variables are not changed. | |
| // Note that the central directory is always followed by another data structure | |
| // that has a signature, so parsing it this way is safe. | |
| bool InputZipFile::ProcessCentralDirEntry(const u1 *&p, u8 *compressed_size, | |
| u8 *uncompressed_size, char *filename, | |
| size_t filename_size, u4 *attr, | |
| u8 *offset) { | |
| u4 signature = get_u4le(p); | |
| if (signature != CENTRAL_FILE_HEADER_SIGNATURE) { | |
| if (signature != DIGITAL_SIGNATURE && signature != EOCD_SIGNATURE && | |
| signature != ZIP64_EOCD_SIGNATURE) { | |
| error("invalid central file header signature: 0x%x\n", signature); | |
| } | |
| return false; | |
| } | |
| p += 16; // skip to 'compressed size' field | |
| *compressed_size = get_u4le(p); | |
| *uncompressed_size = get_u4le(p); | |
| u2 file_name_length = get_u2le(p); | |
| u2 extra_field_length = get_u2le(p); | |
| u2 file_comment_length = get_u2le(p); | |
| p += 4; // skip to external file attributes field | |
| *attr = get_u4le(p); | |
| *offset = get_u4le(p); | |
| { | |
| size_t len = (file_name_length < filename_size) | |
| ? file_name_length | |
| : (filename_size - 1); | |
| memcpy(reinterpret_cast<void*>(filename), p, len); | |
| filename[len] = 0; | |
| } | |
| p += file_name_length; | |
| const u1 *extra_p = p; | |
| p += extra_field_length; | |
| while (extra_p != p) { | |
| const u2 header_id = get_u2le(extra_p); | |
| const u2 data_size = get_u2le(extra_p); | |
| const u1 *extra = extra_p; | |
| extra_p += data_size; | |
| if (header_id == ZIP64_EXTRA_FIELD_TAG) { | |
| if (*uncompressed_size == U4_MAX) { | |
| *uncompressed_size = get_u8le(extra); | |
| } | |
| if (*compressed_size == U4_MAX) { | |
| *compressed_size = get_u8le(extra); | |
| } | |
| if (*offset == U4_MAX) { | |
| *offset = get_u8le(extra); | |
| } | |
| } | |
| } | |
| p += file_comment_length; | |
| return true; | |
| } | |
| // Gives a maximum bound on the size of the interface JAR. Basically, adds | |
| // the difference between the compressed and uncompressed sizes to the size | |
| // of the input file. | |
| u8 InputZipFile::CalculateOutputLength() { | |
| const u1* current = central_dir_; | |
| u8 compressed_size = 0; | |
| u8 uncompressed_size = 0; | |
| u8 skipped_compressed_size = 0; | |
| u4 attr; | |
| u8 offset; | |
| char filename[PATH_MAX]; | |
| while (true) { | |
| u8 file_compressed, file_uncompressed; | |
| if (!ProcessCentralDirEntry(current, | |
| &file_compressed, &file_uncompressed, | |
| filename, PATH_MAX, &attr, &offset)) { | |
| break; | |
| } | |
| if (processor->Accept(filename, attr)) { | |
| compressed_size += (u8) file_compressed; | |
| uncompressed_size += (u8) file_uncompressed; | |
| } else { | |
| skipped_compressed_size += file_compressed; | |
| } | |
| } | |
| // The worst case is when the output is simply the input uncompressed. The | |
| // metadata in the zip file will stay the same, so the file will grow by the | |
| // difference between the compressed and uncompressed sizes. | |
| return (u8) input_file_->Length() - skipped_compressed_size | |
| + (uncompressed_size - compressed_size); | |
| } | |
| // An end of central directory record, sized for optional zip64 contents. | |
| struct EndOfCentralDirectoryRecord { | |
| u4 number_of_this_disk; | |
| u4 disk_with_central_dir; | |
| u8 central_dir_entries_on_this_disk; | |
| u8 central_dir_entries; | |
| u8 central_dir_size; | |
| u8 central_dir_offset; | |
| }; | |
| // Checks for a zip64 end of central directory record. If a valid zip64 EOCD is | |
| // found, updates the original EOCD record and returns true. | |
| bool MaybeReadZip64CentralDirectory(const u1 *bytes, size_t /*in_length*/, | |
| const u1 *current, | |
| const u1 **end_of_central_dir, | |
| EndOfCentralDirectoryRecord *cd) { | |
| if (current < bytes) { | |
| return false; | |
| } | |
| const u1 *candidate = current; | |
| u4 zip64_directory_signature = get_u4le(current); | |
| if (zip64_directory_signature != ZIP64_EOCD_SIGNATURE) { | |
| return false; | |
| } | |
| // size of zip64 end of central directory record | |
| // (fixed size unless there's a zip64 extensible data sector, which | |
| // we don't need to read) | |
| get_u8le(current); | |
| get_u2be(current); // version made by | |
| get_u2be(current); // version needed to extract | |
| u4 number_of_this_disk = get_u4be(current); | |
| u4 disk_with_central_dir = get_u4le(current); | |
| u8 central_dir_entries_on_this_disk = get_u8le(current); | |
| u8 central_dir_entries = get_u8le(current); | |
| u8 central_dir_size = get_u8le(current); | |
| u8 central_dir_offset = get_u8le(current); | |
| // check for a zip64 EOCD that matches the regular EOCD | |
| if (number_of_this_disk != cd->number_of_this_disk && | |
| cd->number_of_this_disk != U2_MAX) { | |
| return false; | |
| } | |
| if (disk_with_central_dir != cd->disk_with_central_dir && | |
| cd->disk_with_central_dir != U2_MAX) { | |
| return false; | |
| } | |
| if (central_dir_entries_on_this_disk != | |
| cd->central_dir_entries_on_this_disk && | |
| cd->central_dir_entries_on_this_disk != U2_MAX) { | |
| return false; | |
| } | |
| if (central_dir_entries != cd->central_dir_entries && | |
| cd->central_dir_entries != U2_MAX) { | |
| return false; | |
| } | |
| if (central_dir_size != cd->central_dir_size && | |
| cd->central_dir_size != U4_MAX) { | |
| return false; | |
| } | |
| if (central_dir_offset != cd->central_dir_offset && | |
| cd->central_dir_offset != U4_MAX) { | |
| return false; | |
| } | |
| *end_of_central_dir = candidate; | |
| cd->number_of_this_disk = number_of_this_disk; | |
| cd->disk_with_central_dir = disk_with_central_dir; | |
| cd->central_dir_entries_on_this_disk = central_dir_entries_on_this_disk; | |
| cd->central_dir_entries = central_dir_entries; | |
| cd->central_dir_size = central_dir_size; | |
| cd->central_dir_offset = central_dir_offset; | |
| return true; | |
| } | |
| // Starting from the end of central directory record, attempts to locate a zip64 | |
| // end of central directory record. If found, updates the given record and | |
| // offset with the zip64 data. Returns false on error. | |
| bool FindZip64CentralDirectory(const u1 *bytes, size_t in_length, | |
| const u1 **end_of_central_dir, | |
| EndOfCentralDirectoryRecord *cd) { | |
| // In the absence of a zip64 extensible data sector, the zip64 EOCD is at a | |
| // fixed offset from the regular central directory. | |
| if (MaybeReadZip64CentralDirectory( | |
| bytes, in_length, | |
| *end_of_central_dir - ZIP64_EOCD_LOCATOR_SIZE - ZIP64_EOCD_FIXED_SIZE, | |
| end_of_central_dir, cd)) { | |
| return true; | |
| } | |
| // If we couldn't find a zip64 EOCD at a fixed offset, either it doesn't exist | |
| // or there was a zip64 extensible data sector, so try going through the | |
| // locator. This approach doesn't work if data was prepended to the archive | |
| // without updating the offset in the locator. | |
| const u1 *zip64_locator = *end_of_central_dir - ZIP64_EOCD_LOCATOR_SIZE; | |
| if (zip64_locator - ZIP64_EOCD_FIXED_SIZE < bytes) { | |
| return true; | |
| } | |
| u4 zip64_locator_signature = get_u4le(zip64_locator); | |
| if (zip64_locator_signature != ZIP64_EOCD_LOCATOR_SIGNATURE) { | |
| return true; | |
| } | |
| u4 disk_with_zip64_central_directory = get_u4le(zip64_locator); | |
| u8 zip64_end_of_central_dir_offset = get_u8le(zip64_locator); | |
| u4 zip64_total_disks = get_u4le(zip64_locator); | |
| if (MaybeReadZip64CentralDirectory(bytes, in_length, | |
| bytes + zip64_end_of_central_dir_offset, | |
| end_of_central_dir, cd)) { | |
| // TODO(b/228519294) Add a test for a valid zip64 file with total disks = 0 | |
| if (disk_with_zip64_central_directory != 0 || zip64_total_disks > 1) { | |
| fprintf(stderr, "multi-disk JAR files are not supported\n"); | |
| return false; | |
| } | |
| return true; | |
| } | |
| return true; | |
| } | |
| // Given the data in the zip file, returns the offset of the central directory | |
| // and the number of files contained in it. | |
| bool FindZipCentralDirectory(const u1 *bytes, size_t in_length, u8 *offset, | |
| const u1 **central_dir) { | |
| static const int MAX_COMMENT_LENGTH = 0xffff; | |
| static const int CENTRAL_DIR_LOCATOR_SIZE = 22; | |
| // Maximum distance of start of central dir locator from end of file | |
| static const int MAX_DELTA = MAX_COMMENT_LENGTH + CENTRAL_DIR_LOCATOR_SIZE; | |
| const u1* last_pos_to_check = in_length < MAX_DELTA | |
| ? bytes | |
| : bytes + (in_length - MAX_DELTA); | |
| const u1* current; | |
| bool found = false; | |
| for (current = bytes + in_length - CENTRAL_DIR_LOCATOR_SIZE; | |
| current >= last_pos_to_check; | |
| current-- ) { | |
| const u1* p = current; | |
| if (get_u4le(p) != EOCD_SIGNATURE) { | |
| continue; | |
| } | |
| p += 16; // skip to comment length field | |
| u2 comment_length = get_u2le(p); | |
| // Does the comment go exactly till the end of the file? | |
| if (current + comment_length + CENTRAL_DIR_LOCATOR_SIZE | |
| != bytes + in_length) { | |
| continue; | |
| } | |
| // Hooray, we found it! | |
| found = true; | |
| break; | |
| } | |
| if (!found) { | |
| fprintf(stderr, "file is invalid or corrupted (missing end of central " | |
| "directory record)\n"); | |
| return false; | |
| } | |
| EndOfCentralDirectoryRecord cd; | |
| const u1* end_of_central_dir = current; | |
| get_u4le(current); // central directory locator signature, already checked | |
| cd.number_of_this_disk = get_u2le(current); | |
| cd.disk_with_central_dir = get_u2le(current); | |
| cd.central_dir_entries_on_this_disk = get_u2le(current); | |
| cd.central_dir_entries = get_u2le(current); | |
| cd.central_dir_size = get_u4le(current); | |
| cd.central_dir_offset = get_u4le(current); | |
| u2 file_comment_length = get_u2le(current); | |
| current += file_comment_length; // set current to the end of the central dir | |
| if (!FindZip64CentralDirectory(bytes, in_length, &end_of_central_dir, &cd)) { | |
| return false; | |
| } | |
| if (cd.number_of_this_disk != 0 || cd.disk_with_central_dir != 0 || | |
| cd.central_dir_entries_on_this_disk != cd.central_dir_entries) { | |
| fprintf(stderr, "multi-disk JAR files are not supported\n"); | |
| return false; | |
| } | |
| if (cd.central_dir_offset + cd.central_dir_size > in_length) { | |
| fprintf(stderr, "central directory offset/size is invalid\n"); | |
| return false; | |
| } | |
| // Do not change output values before determining that they are OK. | |
| *offset = cd.central_dir_offset; | |
| // Central directory start can then be used to determine the actual | |
| // starts of the zip file (which can be different in case of a non-zip | |
| // header like for auto-extractable binaries). | |
| *central_dir = end_of_central_dir - cd.central_dir_size; | |
| return true; | |
| } | |
| void InputZipFile::Reset() { | |
| central_dir_current_ = central_dir_; | |
| bytes_unmapped_ = 0; | |
| p = zipdata_in_ + in_offset_; | |
| } | |
| int ZipExtractor::ProcessAll() { | |
| while (ProcessNext()) {} | |
| if (GetError() != NULL) { | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| ZipExtractor* ZipExtractor::Create(const char* filename, | |
| ZipExtractorProcessor *processor) { | |
| InputZipFile* result = new InputZipFile(processor, filename); | |
| if (!result->Open()) { | |
| fprintf(stderr, "Opening zip \"%s\": %s\n", filename, result->GetError()); | |
| delete result; | |
| return NULL; | |
| } | |
| return result; | |
| } | |
| // zipdata_in_, in_offset_, p, central_dir_current_ | |
| InputZipFile::InputZipFile(ZipExtractorProcessor *processor, | |
| const char* filename) | |
| : processor(processor), filename_(filename), input_file_(NULL), | |
| bytes_unmapped_(0) { | |
| decompressor_ = new Decompressor(); | |
| errmsg[0] = 0; | |
| } | |
| bool InputZipFile::Open() { | |
| MappedInputFile* input_file = new MappedInputFile(filename_); | |
| if (!input_file->Opened()) { | |
| snprintf(errmsg, sizeof(errmsg), "%s", input_file->Error()); | |
| delete input_file; | |
| return false; | |
| } | |
| void *zipdata_in = input_file->Buffer(); | |
| u8 central_dir_offset; | |
| const u1 *central_dir = NULL; | |
| if (!devtools_ijar::FindZipCentralDirectory( | |
| static_cast<const u1*>(zipdata_in), input_file->Length(), | |
| ¢ral_dir_offset, ¢ral_dir)) { | |
| errno = EIO; // we don't really have a good error number | |
| error("Cannot find central directory"); | |
| delete input_file; | |
| return false; | |
| } | |
| const u1 *zipdata_start = static_cast<const u1*>(zipdata_in); | |
| in_offset_ = - static_cast<off_t>(zipdata_start | |
| + central_dir_offset | |
| - central_dir); | |
| input_file_ = input_file; | |
| zipdata_in_ = zipdata_start; | |
| central_dir_ = central_dir; | |
| central_dir_current_ = central_dir; | |
| p = zipdata_in_ + in_offset_; | |
| errmsg[0] = 0; | |
| return true; | |
| } | |
| InputZipFile::~InputZipFile() { | |
| delete decompressor_; | |
| if (input_file_ != NULL) { | |
| input_file_->Close(); | |
| delete input_file_; | |
| } | |
| } | |
| // | |
| // Implementation of OutputZipFile | |
| // | |
| int OutputZipFile::WriteEmptyFile(const char *filename) { | |
| const u1* file_name = (const u1*) filename; | |
| size_t file_name_length = strlen(filename); | |
| LocalFileEntry *entry = new LocalFileEntry; | |
| entry->local_header_offset = Offset(q); | |
| entry->external_attr = 0; | |
| entry->crc32 = 0; | |
| // Output the ZIP local_file_header: | |
| put_u4le(q, LOCAL_FILE_HEADER_SIGNATURE); | |
| put_u2le(q, 10); // extract_version | |
| put_u2le(q, 0); // general_purpose_bit_flag | |
| put_u2le(q, 0); // compression_method | |
| put_u4le(q, kDefaultTimestamp); // last_mod_file date and time | |
| put_u4le(q, entry->crc32); // crc32 | |
| put_u4le(q, 0); // compressed_size | |
| put_u4le(q, 0); // uncompressed_size | |
| put_u2le(q, file_name_length); | |
| put_u2le(q, 0); // extra_field_length | |
| put_n(q, file_name, file_name_length); | |
| entry->file_name_length = file_name_length; | |
| entry->extra_field_length = 0; | |
| entry->compressed_length = 0; | |
| entry->uncompressed_length = 0; | |
| entry->compression_method = 0; | |
| entry->extra_field = (const u1 *)""; | |
| entry->file_name = (u1*) strdup((const char *) file_name); | |
| entries_.push_back(entry); | |
| return 0; | |
| } | |
| void OutputZipFile::WriteCentralDirectory() { | |
| // central directory: | |
| const u1 *central_directory_start = q; | |
| for (size_t ii = 0; ii < entries_.size(); ++ii) { | |
| LocalFileEntry *entry = entries_[ii]; | |
| put_u4le(q, CENTRAL_FILE_HEADER_SIGNATURE); | |
| put_u2le(q, UNIX_ZIP_FILE_VERSION); | |
| put_u2le(q, ZIP_VERSION_TO_EXTRACT); // version to extract | |
| put_u2le(q, 0); // general purpose bit flag | |
| put_u2le(q, entry->compression_method); // compression method: | |
| put_u4le(q, kDefaultTimestamp); // last_mod_file date and time | |
| put_u4le(q, entry->crc32); // crc32 | |
| put_u4le(q, entry->compressed_length); // compressed_size | |
| put_u4le(q, entry->uncompressed_length); // uncompressed_size | |
| put_u2le(q, entry->file_name_length); | |
| put_u2le(q, entry->extra_field_length); | |
| put_u2le(q, 0); // file comment length | |
| put_u2le(q, 0); // disk number start | |
| put_u2le(q, 0); // internal file attributes | |
| put_u4le(q, entry->external_attr); // external file attributes | |
| // relative offset of local header: | |
| put_u4le(q, entry->local_header_offset); | |
| put_n(q, entry->file_name, entry->file_name_length); | |
| put_n(q, entry->extra_field, entry->extra_field_length); | |
| } | |
| u8 central_directory_size = q - central_directory_start; | |
| if (entries_.size() > U2_MAX || central_directory_size > U4_MAX || | |
| Offset(central_directory_start) > U4_MAX) { | |
| u1 *zip64_end_of_central_directory_start = q; | |
| put_u4le(q, ZIP64_EOCD_SIGNATURE); | |
| // signature and size field doesn't count towards size | |
| put_u8le(q, ZIP64_EOCD_FIXED_SIZE - 12); | |
| put_u2le(q, UNIX_ZIP_FILE_VERSION); // version made by | |
| put_u2le(q, 0); // version needed to extract | |
| put_u4le(q, 0); // number of this disk | |
| put_u4le(q, 0); // # of the disk with the start of the central directory | |
| put_u8le(q, entries_.size()); // # central dir entries on this disk | |
| put_u8le(q, entries_.size()); // total # entries in the central directory | |
| put_u8le(q, central_directory_size); // size of the central directory | |
| // offset of start of central directory wrt starting disk | |
| put_u8le(q, Offset(central_directory_start)); | |
| put_u4le(q, ZIP64_EOCD_LOCATOR_SIGNATURE); | |
| // number of the disk with the start of the zip64 end of central directory | |
| put_u4le(q, 0); | |
| // relative offset of the zip64 end of central directory record | |
| put_u8le(q, Offset(zip64_end_of_central_directory_start)); | |
| // total number of disks | |
| put_u4le(q, 1); | |
| put_u4le(q, EOCD_SIGNATURE); | |
| put_u2le(q, 0); // number of this disk | |
| put_u2le(q, 0); // # of disk with the start of the central directory | |
| // # central dir entries on this disk | |
| put_u2le(q, entries_.size() > 0xffff ? 0xffff : entries_.size()); | |
| // total # entries in the central directory | |
| put_u2le(q, entries_.size() > 0xffff ? 0xffff : entries_.size()); | |
| // size of the central directory | |
| put_u4le(q, | |
| central_directory_size > U4_MAX ? U4_MAX : central_directory_size); | |
| // offset of start of central | |
| put_u4le(q, Offset(central_directory_start) > U4_MAX | |
| ? U4_MAX | |
| : Offset(central_directory_start)); | |
| put_u2le(q, 0); // .ZIP file comment length | |
| } else { | |
| put_u4le(q, EOCD_SIGNATURE); | |
| put_u2le(q, 0); // number of this disk | |
| put_u2le(q, 0); // # of the disk with the start of the central directory | |
| put_u2le(q, entries_.size()); // # central dir entries on this disk | |
| put_u2le(q, entries_.size()); // total # entries in the central directory | |
| put_u4le(q, central_directory_size); // size of the central directory | |
| // offset of start of central directory wrt starting disk | |
| put_u4le(q, Offset(central_directory_start)); | |
| put_u2le(q, 0); // .ZIP file comment length | |
| } | |
| } | |
| u1* OutputZipFile::WriteLocalFileHeader(const char* filename, const u4 attr) { | |
| off_t file_name_length_ = strlen(filename); | |
| LocalFileEntry *entry = new LocalFileEntry; | |
| entry->local_header_offset = Offset(q); | |
| entry->file_name_length = file_name_length_; | |
| entry->file_name = new u1[file_name_length_]; | |
| entry->external_attr = attr; | |
| memcpy(entry->file_name, filename, file_name_length_); | |
| entry->extra_field_length = 0; | |
| entry->extra_field = (const u1 *)""; | |
| entry->crc32 = 0; | |
| // Output the ZIP local_file_header: | |
| put_u4le(q, LOCAL_FILE_HEADER_SIGNATURE); | |
| put_u2le(q, ZIP_VERSION_TO_EXTRACT); // version to extract | |
| put_u2le(q, 0); // general purpose bit flag | |
| u1 *header_ptr = q; | |
| put_u2le(q, COMPRESSION_METHOD_STORED); // compression method = placeholder | |
| put_u4le(q, kDefaultTimestamp); // last_mod_file date and time | |
| put_u4le(q, entry->crc32); // crc32 | |
| put_u4le(q, 0); // compressed_size = placeholder | |
| put_u4le(q, 0); // uncompressed_size = placeholder | |
| put_u2le(q, entry->file_name_length); | |
| put_u2le(q, entry->extra_field_length); | |
| put_n(q, entry->file_name, entry->file_name_length); | |
| put_n(q, entry->extra_field, entry->extra_field_length); | |
| entries_.push_back(entry); | |
| return header_ptr; | |
| } | |
| size_t OutputZipFile::WriteFileSizeInLocalFileHeader(u1 *header_ptr, | |
| size_t out_length, | |
| bool compress, | |
| const u4 crc) { | |
| size_t compressed_size = out_length; | |
| if (compress) { | |
| compressed_size = TryDeflate(q, out_length); | |
| } | |
| // compression method | |
| if (compressed_size < out_length) { | |
| put_u2le(header_ptr, COMPRESSION_METHOD_DEFLATED); | |
| } else { | |
| put_u2le(header_ptr, COMPRESSION_METHOD_STORED); | |
| } | |
| header_ptr += 4; | |
| put_u4le(header_ptr, crc); // crc32 | |
| put_u4le(header_ptr, compressed_size); // compressed_size | |
| put_u4le(header_ptr, out_length); // uncompressed_size | |
| return compressed_size; | |
| } | |
| int OutputZipFile::Finish() { | |
| if (finished_) { | |
| return 0; | |
| } | |
| finished_ = true; | |
| WriteCentralDirectory(); | |
| if (output_file_->Close(GetSize()) < 0) { | |
| return error("%s", output_file_->Error()); | |
| } | |
| delete output_file_; | |
| output_file_ = NULL; | |
| return 0; | |
| } | |
| u1* OutputZipFile::NewFile(const char* filename, const u4 attr) { | |
| header_ptr = WriteLocalFileHeader(filename, attr); | |
| return q; | |
| } | |
| int OutputZipFile::FinishFile(size_t filelength, bool compress, | |
| bool compute_crc) { | |
| u4 crc = 0; | |
| if (compute_crc) { | |
| crc = ComputeCrcChecksum(q, filelength); | |
| if (filelength > 0 && crc == 0) { | |
| fprintf(stderr, "Error calculating CRC32 checksum.\n"); | |
| return -1; | |
| } | |
| } | |
| size_t compressed_size = | |
| WriteFileSizeInLocalFileHeader(header_ptr, filelength, compress, crc); | |
| if (compressed_size == 0 && filelength > 0) { | |
| fprintf(stderr, "Error compressing files.\n"); | |
| return -1; | |
| } | |
| entries_.back()->crc32 = crc; | |
| entries_.back()->compressed_length = compressed_size; | |
| entries_.back()->uncompressed_length = filelength; | |
| if (compressed_size < filelength) { | |
| entries_.back()->compression_method = COMPRESSION_METHOD_DEFLATED; | |
| } else { | |
| entries_.back()->compression_method = COMPRESSION_METHOD_STORED; | |
| } | |
| q += compressed_size; | |
| return 0; | |
| } | |
| bool OutputZipFile::Open() { | |
| if (estimated_size_ > kMaximumOutputSize) { | |
| fprintf(stderr, | |
| "Uncompressed input jar has size %zu, " | |
| "which exceeds the maximum supported output size %zu.\n" | |
| "Assuming that ijar will be smaller and hoping for the best.\n", | |
| estimated_size_, kMaximumOutputSize); | |
| estimated_size_ = kMaximumOutputSize; | |
| } | |
| MappedOutputFile* output_file = new MappedOutputFile( | |
| filename_, estimated_size_); | |
| if (!output_file->Opened()) { | |
| snprintf(errmsg, sizeof(errmsg), "%s", output_file->Error()); | |
| delete output_file; | |
| return false; | |
| } | |
| output_file_ = output_file; | |
| q = output_file->Buffer(); | |
| zipdata_out_ = output_file->Buffer(); | |
| return true; | |
| } | |
| ZipBuilder *ZipBuilder::Create(const char *zip_file, size_t estimated_size) { | |
| OutputZipFile* result = new OutputZipFile(zip_file, estimated_size); | |
| if (!result->Open()) { | |
| fprintf(stderr, "%s\n", result->GetError()); | |
| delete result; | |
| return NULL; | |
| } | |
| return result; | |
| } | |
| u8 ZipBuilder::EstimateSize(char const* const* files, | |
| char const* const* zip_paths, | |
| int nb_entries) { | |
| Stat file_stat; | |
| // Digital signature field size = 6, End of central directory = 22, Total = 28 | |
| u8 size = 28; | |
| // Count the size of all the files in the input to estimate the size of the | |
| // output. | |
| for (int i = 0; i < nb_entries; i++) { | |
| file_stat.total_size = 0; | |
| if (files[i] != NULL && !stat_file(files[i], &file_stat)) { | |
| fprintf(stderr, "File %s does not seem to exist.", files[i]); | |
| return 0; | |
| } | |
| size += file_stat.total_size; | |
| // Add sizes of Zip meta data | |
| // local file header = 30 bytes | |
| // data descriptor = 12 bytes | |
| // central directory descriptor = 46 bytes | |
| // Total: 88bytes | |
| size += 88; | |
| // The filename is stored twice (once in the central directory | |
| // and once in the local file header). | |
| size += strlen((zip_paths[i] != NULL) ? zip_paths[i] : files[i]) * 2; | |
| } | |
| return size; | |
| } | |
| } // namespace devtools_ijar |