blob: 91007ac3b930ad7d94df8ee4868a6c211dc1f3fc [file] [log] [blame]
Doug Zongker512536a2010-02-17 16:11:44 -08001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
Tianjie Xu82582b42017-08-31 18:05:19 -070018 * This program constructs binary patches for images -- such as boot.img and recovery.img -- that
19 * consist primarily of large chunks of gzipped data interspersed with uncompressed data. Doing a
20 * naive bsdiff of these files is not useful because small changes in the data lead to large
21 * changes in the compressed bitstream; bsdiff patches of gzipped data are typically as large as
22 * the data itself.
Doug Zongker512536a2010-02-17 16:11:44 -080023 *
Tianjie Xu82582b42017-08-31 18:05:19 -070024 * To patch these usefully, we break the source and target images up into chunks of two types:
25 * "normal" and "gzip". Normal chunks are simply patched using a plain bsdiff. Gzip chunks are
26 * first expanded, then a bsdiff is applied to the uncompressed data, then the patched data is
27 * gzipped using the same encoder parameters. Patched chunks are concatenated together to create
28 * the output file; the output image should be *exactly* the same series of bytes as the target
29 * image used originally to generate the patch.
Doug Zongker512536a2010-02-17 16:11:44 -080030 *
Tianjie Xu82582b42017-08-31 18:05:19 -070031 * To work well with this tool, the gzipped sections of the target image must have been generated
32 * using the same deflate encoder that is available in applypatch, namely, the one in the zlib
33 * library. In practice this means that images should be compressed using the "minigzip" tool
34 * included in the zlib distribution, not the GNU gzip program.
Doug Zongker512536a2010-02-17 16:11:44 -080035 *
Tianjie Xu82582b42017-08-31 18:05:19 -070036 * An "imgdiff" patch consists of a header describing the chunk structure of the file and any
37 * encoding parameters needed for the gzipped chunks, followed by N bsdiff patches, one per chunk.
Doug Zongker512536a2010-02-17 16:11:44 -080038 *
Tianjie Xu82582b42017-08-31 18:05:19 -070039 * For a diff to be generated, the source and target must be in well-formed zip archive format;
40 * or they are image files with the same "chunk" structure: that is, the same number of gzipped and
41 * normal chunks in the same order. Android boot and recovery images currently consist of five
42 * chunks: a small normal header, a gzipped kernel, a small normal section, a gzipped ramdisk, and
43 * finally a small normal footer.
Doug Zongker512536a2010-02-17 16:11:44 -080044 *
Tianjie Xu82582b42017-08-31 18:05:19 -070045 * Caveats: we locate gzipped sections within the source and target images by searching for the
46 * byte sequence 1f8b0800: 1f8b is the gzip magic number; 08 specifies the "deflate" encoding
47 * [the only encoding supported by the gzip standard]; and 00 is the flags byte. We do not
48 * currently support any extra header fields (which would be indicated by a nonzero flags byte).
49 * We also don't handle the case when that byte sequence appears spuriously in the file. (Note
50 * that it would have to occur spuriously within a normal chunk to be a problem.)
Doug Zongker512536a2010-02-17 16:11:44 -080051 *
52 *
53 * The imgdiff patch header looks like this:
54 *
Tianjie Xu82582b42017-08-31 18:05:19 -070055 * "IMGDIFF2" (8) [magic number and version]
Doug Zongker512536a2010-02-17 16:11:44 -080056 * chunk count (4)
57 * for each chunk:
58 * chunk type (4) [CHUNK_{NORMAL, GZIP, DEFLATE, RAW}]
59 * if chunk type == CHUNK_NORMAL:
60 * source start (8)
61 * source len (8)
62 * bsdiff patch offset (8) [from start of patch file]
63 * if chunk type == CHUNK_GZIP: (version 1 only)
64 * source start (8)
65 * source len (8)
66 * bsdiff patch offset (8) [from start of patch file]
67 * source expanded len (8) [size of uncompressed source]
68 * target expected len (8) [size of uncompressed target]
69 * gzip level (4)
70 * method (4)
71 * windowBits (4)
72 * memLevel (4)
73 * strategy (4)
74 * gzip header len (4)
75 * gzip header (gzip header len)
76 * gzip footer (8)
77 * if chunk type == CHUNK_DEFLATE: (version 2 only)
78 * source start (8)
79 * source len (8)
80 * bsdiff patch offset (8) [from start of patch file]
81 * source expanded len (8) [size of uncompressed source]
82 * target expected len (8) [size of uncompressed target]
83 * gzip level (4)
84 * method (4)
85 * windowBits (4)
86 * memLevel (4)
87 * strategy (4)
88 * if chunk type == RAW: (version 2 only)
89 * target len (4)
90 * data (target len)
91 *
Tianjie Xu82582b42017-08-31 18:05:19 -070092 * All integers are little-endian. "source start" and "source len" specify the section of the
93 * input image that comprises this chunk, including the gzip header and footer for gzip chunks.
94 * "source expanded len" is the size of the uncompressed source data. "target expected len" is the
95 * size of the uncompressed data after applying the bsdiff patch. The next five parameters
96 * specify the zlib parameters to be used when compressing the patched data, and the next three
97 * specify the header and footer to be wrapped around the compressed data to create the output
98 * chunk (so that header contents like the timestamp are recreated exactly).
Doug Zongker512536a2010-02-17 16:11:44 -080099 *
Tianjie Xu82582b42017-08-31 18:05:19 -0700100 * After the header there are 'chunk count' bsdiff patches; the offset of each from the beginning
101 * of the file is specified in the header.
Doug Zongkera3ccba62012-08-20 15:28:02 -0700102 *
Tianjie Xu82582b42017-08-31 18:05:19 -0700103 * This tool can take an optional file of "bonus data". This is an extra file of data that is
104 * appended to chunk #1 after it is compressed (it must be a CHUNK_DEFLATE chunk). The same file
105 * must be available (and passed to applypatch with -b) when applying the patch. This is used to
106 * reduce the size of recovery-from-boot patches by combining the boot image with recovery ramdisk
Doug Zongkera3ccba62012-08-20 15:28:02 -0700107 * information that is stored on the system partition.
Tianjie Xu82582b42017-08-31 18:05:19 -0700108 *
109 * When generating the patch between two zip files, this tool has an option "--block-limit" to
110 * split the large source/target files into several pair of pieces, with each piece has at most
111 * *limit* blocks. When this option is used, we also need to output the split info into the file
112 * path specified by "--split-info".
113 *
114 * Format of split info file:
115 * 2 [version of imgdiff]
116 * n [count of split pieces]
117 * <patch_size>, <tgt_size>, <src_range> [size and ranges for split piece#1]
118 * ...
119 * <patch_size>, <tgt_size>, <src_range> [size and ranges for split piece#n]
120 *
121 * To split a pair of large zip files, we walk through the chunks in target zip and search by its
122 * entry_name in the source zip. If the entry_name is non-empty and a matching entry in source
123 * is found, we'll add the source entry to the current split source image; otherwise we'll skip
124 * this chunk and later do bsdiff between all the skipped trunks and the whole split source image.
125 * We move on to the next pair of pieces if the size of the split source image reaches the block
126 * limit.
127 *
128 * After the split, the target pieces are continuous and block aligned, while the source pieces
129 * are mutually exclusive. Some of the source blocks may not be used if there's no matching
130 * entry_name in the target; as a result, they won't be included in any of these split source
131 * images. Then we will generate patches accordingly between each split image pairs; in particular,
132 * the unmatched trunks in the split target will diff against the entire split source image.
133 *
134 * For example:
135 * Input: [src_image, tgt_image]
136 * Split: [src-0, tgt-0; src-1, tgt-1, src-2, tgt-2]
137 * Diff: [ patch-0; patch-1; patch-2]
138 *
139 * Patch: [(src-0, patch-0) = tgt-0; (src-1, patch-1) = tgt-1; (src-2, patch-2) = tgt-2]
140 * Concatenate: [tgt-0 + tgt-1 + tgt-2 = tgt_image]
Doug Zongker512536a2010-02-17 16:11:44 -0800141 */
142
Tao Bao97555da2016-12-15 10:15:06 -0800143#include "applypatch/imgdiff.h"
144
Doug Zongker512536a2010-02-17 16:11:44 -0800145#include <errno.h>
Tao Baod37ce8f2016-12-17 17:10:04 -0800146#include <fcntl.h>
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700147#include <getopt.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800148#include <stdio.h>
149#include <stdlib.h>
150#include <string.h>
151#include <sys/stat.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800152#include <sys/types.h>
Tao Bao97555da2016-12-15 10:15:06 -0800153#include <unistd.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800154
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800155#include <algorithm>
156#include <string>
157#include <vector>
158
Tao Baod37ce8f2016-12-17 17:10:04 -0800159#include <android-base/file.h>
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800160#include <android-base/logging.h>
161#include <android-base/memory.h>
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700162#include <android-base/parseint.h>
Tao Bao45685822017-10-13 14:54:12 -0700163#include <android-base/stringprintf.h>
164#include <android-base/strings.h>
Tao Baod37ce8f2016-12-17 17:10:04 -0800165#include <android-base/unique_fd.h>
Alex Deymofa188262017-10-10 17:56:17 +0200166#include <bsdiff/bsdiff.h>
Tianjie Xu57dd9612017-08-17 17:50:56 -0700167#include <ziparchive/zip_archive.h>
Tao Bao97555da2016-12-15 10:15:06 -0800168#include <zlib.h>
Sen Jiang2fffcb12016-05-03 15:49:10 -0700169
Tianjie Xu57dd9612017-08-17 17:50:56 -0700170#include "applypatch/imgdiff_image.h"
Tao Bao09e468f2017-09-29 14:39:33 -0700171#include "otautil/rangeset.h"
Tianjie Xu57dd9612017-08-17 17:50:56 -0700172
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800173using android::base::get_unaligned;
Doug Zongker512536a2010-02-17 16:11:44 -0800174
Tianjie Xu82582b42017-08-31 18:05:19 -0700175static constexpr size_t VERSION = 2;
176
177// We assume the header "IMGDIFF#" is 8 bytes.
Tianjie Xu6e293c92017-11-15 16:26:41 -0800178static_assert(VERSION <= 9, "VERSION occupies more than one byte");
Tianjie Xu82582b42017-08-31 18:05:19 -0700179
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700180static constexpr size_t BLOCK_SIZE = 4096;
181static constexpr size_t BUFFER_SIZE = 0x8000;
Doug Zongker512536a2010-02-17 16:11:44 -0800182
Tianjie Xu12b90552017-03-07 14:44:14 -0800183// If we use this function to write the offset and length (type size_t), their values should not
184// exceed 2^63; because the signed bit will be casted away.
185static inline bool Write8(int fd, int64_t value) {
186 return android::base::WriteFully(fd, &value, sizeof(int64_t));
187}
188
189// Similarly, the value should not exceed 2^31 if we are casting from size_t (e.g. target chunk
190// size).
191static inline bool Write4(int fd, int32_t value) {
192 return android::base::WriteFully(fd, &value, sizeof(int32_t));
193}
194
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700195// Trim the head or tail to align with the block size. Return false if the chunk has nothing left
196// after alignment.
197static bool AlignHead(size_t* start, size_t* length) {
198 size_t residual = (*start % BLOCK_SIZE == 0) ? 0 : BLOCK_SIZE - *start % BLOCK_SIZE;
199
200 if (*length <= residual) {
201 *length = 0;
202 return false;
203 }
204
205 // Trim the data in the beginning.
206 *start += residual;
207 *length -= residual;
208 return true;
209}
210
211static bool AlignTail(size_t* start, size_t* length) {
212 size_t residual = (*start + *length) % BLOCK_SIZE;
213 if (*length <= residual) {
214 *length = 0;
215 return false;
216 }
217
218 // Trim the data in the end.
219 *length -= residual;
220 return true;
221}
222
223// Remove the used blocks from the source chunk to make sure the source ranges are mutually
224// exclusive after split. Return false if we fail to get the non-overlapped ranges. In such
225// a case, we'll skip the entire source chunk.
226static bool RemoveUsedBlocks(size_t* start, size_t* length, const SortedRangeSet& used_ranges) {
227 if (!used_ranges.Overlaps(*start, *length)) {
228 return true;
229 }
230
231 // TODO find the largest non-overlap chunk.
Tianjie Xu6e293c92017-11-15 16:26:41 -0800232 LOG(INFO) << "Removing block " << used_ranges.ToString() << " from " << *start << " - "
233 << *start + *length - 1;
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700234
235 // If there's no duplicate entry name, we should only overlap in the head or tail block. Try to
236 // trim both blocks. Skip this source chunk in case it still overlaps with the used ranges.
237 if (AlignHead(start, length) && !used_ranges.Overlaps(*start, *length)) {
238 return true;
239 }
240 if (AlignTail(start, length) && !used_ranges.Overlaps(*start, *length)) {
241 return true;
242 }
243
Tianjie Xu6e293c92017-11-15 16:26:41 -0800244 LOG(WARNING) << "Failed to remove the overlapped block ranges; skip the source";
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700245 return false;
246}
247
248static const struct option OPTIONS[] = {
249 { "zip-mode", no_argument, nullptr, 'z' },
250 { "bonus-file", required_argument, nullptr, 'b' },
251 { "block-limit", required_argument, nullptr, 0 },
252 { "debug-dir", required_argument, nullptr, 0 },
Tianjie Xu82582b42017-08-31 18:05:19 -0700253 { "split-info", required_argument, nullptr, 0 },
Tianjie Xu6e293c92017-11-15 16:26:41 -0800254 { "verbose", no_argument, nullptr, 'v' },
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700255 { nullptr, 0, nullptr, 0 },
256};
257
Tianjie Xu57dd9612017-08-17 17:50:56 -0700258ImageChunk::ImageChunk(int type, size_t start, const std::vector<uint8_t>* file_content,
259 size_t raw_data_len, std::string entry_name)
260 : type_(type),
261 start_(start),
262 input_file_ptr_(file_content),
263 raw_data_len_(raw_data_len),
264 compress_level_(6),
265 entry_name_(std::move(entry_name)) {
266 CHECK(file_content != nullptr) << "input file container can't be nullptr";
267}
Doug Zongker512536a2010-02-17 16:11:44 -0800268
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800269const uint8_t* ImageChunk::GetRawData() const {
270 CHECK_LE(start_ + raw_data_len_, input_file_ptr_->size());
271 return input_file_ptr_->data() + start_;
272}
273
274const uint8_t * ImageChunk::DataForPatch() const {
275 if (type_ == CHUNK_DEFLATE) {
276 return uncompressed_data_.data();
277 }
278 return GetRawData();
279}
280
281size_t ImageChunk::DataLengthForPatch() const {
282 if (type_ == CHUNK_DEFLATE) {
283 return uncompressed_data_.size();
284 }
285 return raw_data_len_;
286}
287
Tianjie Xu6e293c92017-11-15 16:26:41 -0800288void ImageChunk::Dump(size_t index) const {
289 LOG(INFO) << "chunk: " << index << ", type: " << type_ << ", start: " << start_
290 << ", len: " << DataLengthForPatch() << ", name: " << entry_name_;
291}
292
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800293bool ImageChunk::operator==(const ImageChunk& other) const {
294 if (type_ != other.type_) {
295 return false;
296 }
297 return (raw_data_len_ == other.raw_data_len_ &&
298 memcmp(GetRawData(), other.GetRawData(), raw_data_len_) == 0);
299}
300
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800301void ImageChunk::SetUncompressedData(std::vector<uint8_t> data) {
Tianjie Xu12b90552017-03-07 14:44:14 -0800302 uncompressed_data_ = std::move(data);
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800303}
304
305bool ImageChunk::SetBonusData(const std::vector<uint8_t>& bonus_data) {
306 if (type_ != CHUNK_DEFLATE) {
307 return false;
308 }
309 uncompressed_data_.insert(uncompressed_data_.end(), bonus_data.begin(), bonus_data.end());
310 return true;
311}
312
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800313void ImageChunk::ChangeDeflateChunkToNormal() {
314 if (type_ != CHUNK_DEFLATE) return;
315 type_ = CHUNK_NORMAL;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700316 // No need to clear the entry name.
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800317 uncompressed_data_.clear();
318}
319
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800320bool ImageChunk::IsAdjacentNormal(const ImageChunk& other) const {
321 if (type_ != CHUNK_NORMAL || other.type_ != CHUNK_NORMAL) {
322 return false;
323 }
324 return (other.start_ == start_ + raw_data_len_);
325}
326
327void ImageChunk::MergeAdjacentNormal(const ImageChunk& other) {
328 CHECK(IsAdjacentNormal(other));
329 raw_data_len_ = raw_data_len_ + other.raw_data_len_;
330}
331
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700332bool ImageChunk::MakePatch(const ImageChunk& tgt, const ImageChunk& src,
Alex Deymofa188262017-10-10 17:56:17 +0200333 std::vector<uint8_t>* patch_data,
334 bsdiff::SuffixArrayIndexInterface** bsdiff_cache) {
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700335#if defined(__ANDROID__)
336 char ptemp[] = "/data/local/tmp/imgdiff-patch-XXXXXX";
337#else
338 char ptemp[] = "/tmp/imgdiff-patch-XXXXXX";
339#endif
340
341 int fd = mkstemp(ptemp);
342 if (fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800343 PLOG(ERROR) << "MakePatch failed to create a temporary file";
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700344 return false;
345 }
346 close(fd);
347
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700348 int r = bsdiff::bsdiff(src.DataForPatch(), src.DataLengthForPatch(), tgt.DataForPatch(),
349 tgt.DataLengthForPatch(), ptemp, bsdiff_cache);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700350 if (r != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800351 LOG(ERROR) << "bsdiff() failed: " << r;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700352 return false;
353 }
354
355 android::base::unique_fd patch_fd(open(ptemp, O_RDONLY));
356 if (patch_fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800357 PLOG(ERROR) << "Failed to open " << ptemp;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700358 return false;
359 }
360 struct stat st;
361 if (fstat(patch_fd, &st) != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800362 PLOG(ERROR) << "Failed to stat patch file " << ptemp;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700363 return false;
364 }
365
366 size_t sz = static_cast<size_t>(st.st_size);
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700367
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700368 patch_data->resize(sz);
369 if (!android::base::ReadFully(patch_fd, patch_data->data(), sz)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800370 PLOG(ERROR) << "Failed to read " << ptemp;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700371 unlink(ptemp);
372 return false;
373 }
374
375 unlink(ptemp);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700376
377 return true;
378}
379
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800380bool ImageChunk::ReconstructDeflateChunk() {
381 if (type_ != CHUNK_DEFLATE) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800382 LOG(ERROR) << "Attempted to reconstruct non-deflate chunk";
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800383 return false;
Doug Zongker512536a2010-02-17 16:11:44 -0800384 }
385
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700386 // We only check two combinations of encoder parameters: level 6 (the default) and level 9
387 // (the maximum).
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800388 for (int level = 6; level <= 9; level += 3) {
389 if (TryReconstruction(level)) {
390 compress_level_ = level;
391 return true;
Doug Zongker512536a2010-02-17 16:11:44 -0800392 }
393 }
Doug Zongker512536a2010-02-17 16:11:44 -0800394
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800395 return false;
Doug Zongker512536a2010-02-17 16:11:44 -0800396}
397
398/*
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700399 * Takes the uncompressed data stored in the chunk, compresses it using the zlib parameters stored
400 * in the chunk, and checks that it matches exactly the compressed data we started with (also
401 * stored in the chunk).
Doug Zongker512536a2010-02-17 16:11:44 -0800402 */
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800403bool ImageChunk::TryReconstruction(int level) {
404 z_stream strm;
405 strm.zalloc = Z_NULL;
406 strm.zfree = Z_NULL;
407 strm.opaque = Z_NULL;
408 strm.avail_in = uncompressed_data_.size();
409 strm.next_in = uncompressed_data_.data();
410 int ret = deflateInit2(&strm, level, METHOD, WINDOWBITS, MEMLEVEL, STRATEGY);
411 if (ret < 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800412 LOG(ERROR) << "Failed to initialize deflate: " << ret;
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800413 return false;
414 }
415
416 std::vector<uint8_t> buffer(BUFFER_SIZE);
417 size_t offset = 0;
418 do {
419 strm.avail_out = buffer.size();
420 strm.next_out = buffer.data();
421 ret = deflate(&strm, Z_FINISH);
422 if (ret < 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800423 LOG(ERROR) << "Failed to deflate: " << ret;
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800424 return false;
425 }
426
427 size_t compressed_size = buffer.size() - strm.avail_out;
428 if (memcmp(buffer.data(), input_file_ptr_->data() + start_ + offset, compressed_size) != 0) {
429 // mismatch; data isn't the same.
430 deflateEnd(&strm);
431 return false;
432 }
433 offset += compressed_size;
434 } while (ret != Z_STREAM_END);
435 deflateEnd(&strm);
436
437 if (offset != raw_data_len_) {
438 // mismatch; ran out of data before we should have.
439 return false;
440 }
441 return true;
442}
443
Tianjie Xu57dd9612017-08-17 17:50:56 -0700444PatchChunk::PatchChunk(const ImageChunk& tgt, const ImageChunk& src, std::vector<uint8_t> data)
445 : type_(tgt.GetType()),
446 source_start_(src.GetStartOffset()),
447 source_len_(src.GetRawDataLength()),
448 source_uncompressed_len_(src.DataLengthForPatch()),
449 target_start_(tgt.GetStartOffset()),
450 target_len_(tgt.GetRawDataLength()),
451 target_uncompressed_len_(tgt.DataLengthForPatch()),
452 target_compress_level_(tgt.GetCompressLevel()),
453 data_(std::move(data)) {}
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700454
Tianjie Xu57dd9612017-08-17 17:50:56 -0700455// Construct a CHUNK_RAW patch from the target data directly.
456PatchChunk::PatchChunk(const ImageChunk& tgt)
457 : type_(CHUNK_RAW),
458 source_start_(0),
459 source_len_(0),
460 source_uncompressed_len_(0),
461 target_start_(tgt.GetStartOffset()),
462 target_len_(tgt.GetRawDataLength()),
463 target_uncompressed_len_(tgt.DataLengthForPatch()),
464 target_compress_level_(tgt.GetCompressLevel()),
Tianjie Xucc61cf62018-05-23 22:23:31 -0700465 data_(tgt.GetRawData(), tgt.GetRawData() + tgt.GetRawDataLength()) {}
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700466
467// Return true if raw data is smaller than the patch size.
468bool PatchChunk::RawDataIsSmaller(const ImageChunk& tgt, size_t patch_size) {
469 size_t target_len = tgt.GetRawDataLength();
Tianjie Xucc61cf62018-05-23 22:23:31 -0700470 return target_len < patch_size || (tgt.GetType() == CHUNK_NORMAL && target_len <= 160);
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700471}
472
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700473void PatchChunk::UpdateSourceOffset(const SortedRangeSet& src_range) {
474 if (type_ == CHUNK_DEFLATE) {
475 source_start_ = src_range.GetOffsetInRangeSet(source_start_);
476 }
477}
478
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700479// Header size:
480// header_type 4 bytes
481// CHUNK_NORMAL 8*3 = 24 bytes
482// CHUNK_DEFLATE 8*5 + 4*5 = 60 bytes
483// CHUNK_RAW 4 bytes + patch_size
484size_t PatchChunk::GetHeaderSize() const {
485 switch (type_) {
486 case CHUNK_NORMAL:
487 return 4 + 8 * 3;
488 case CHUNK_DEFLATE:
489 return 4 + 8 * 5 + 4 * 5;
490 case CHUNK_RAW:
491 return 4 + 4 + data_.size();
492 default:
493 CHECK(false) << "unexpected chunk type: " << type_; // Should not reach here.
494 return 0;
495 }
496}
497
498// Return the offset of the next patch into the patch data.
Tianjie Xu6e293c92017-11-15 16:26:41 -0800499size_t PatchChunk::WriteHeaderToFd(int fd, size_t offset, size_t index) const {
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700500 Write4(fd, type_);
501 switch (type_) {
502 case CHUNK_NORMAL:
Tianjie Xu6e293c92017-11-15 16:26:41 -0800503 LOG(INFO) << android::base::StringPrintf("chunk %zu: normal (%10zu, %10zu) %10zu", index,
504 target_start_, target_len_, data_.size());
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700505 Write8(fd, static_cast<int64_t>(source_start_));
506 Write8(fd, static_cast<int64_t>(source_len_));
507 Write8(fd, static_cast<int64_t>(offset));
508 return offset + data_.size();
509 case CHUNK_DEFLATE:
Tianjie Xu6e293c92017-11-15 16:26:41 -0800510 LOG(INFO) << android::base::StringPrintf("chunk %zu: deflate (%10zu, %10zu) %10zu", index,
511 target_start_, target_len_, data_.size());
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700512 Write8(fd, static_cast<int64_t>(source_start_));
513 Write8(fd, static_cast<int64_t>(source_len_));
514 Write8(fd, static_cast<int64_t>(offset));
515 Write8(fd, static_cast<int64_t>(source_uncompressed_len_));
516 Write8(fd, static_cast<int64_t>(target_uncompressed_len_));
517 Write4(fd, target_compress_level_);
518 Write4(fd, ImageChunk::METHOD);
519 Write4(fd, ImageChunk::WINDOWBITS);
520 Write4(fd, ImageChunk::MEMLEVEL);
521 Write4(fd, ImageChunk::STRATEGY);
522 return offset + data_.size();
523 case CHUNK_RAW:
Tianjie Xu6e293c92017-11-15 16:26:41 -0800524 LOG(INFO) << android::base::StringPrintf("chunk %zu: raw (%10zu, %10zu)", index,
525 target_start_, target_len_);
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700526 Write4(fd, static_cast<int32_t>(data_.size()));
527 if (!android::base::WriteFully(fd, data_.data(), data_.size())) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800528 CHECK(false) << "Failed to write " << data_.size() << " bytes patch";
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700529 }
530 return offset;
531 default:
532 CHECK(false) << "unexpected chunk type: " << type_;
533 return offset;
534 }
535}
536
Tianjie Xu82582b42017-08-31 18:05:19 -0700537size_t PatchChunk::PatchSize() const {
538 if (type_ == CHUNK_RAW) {
539 return GetHeaderSize();
540 }
541 return GetHeaderSize() + data_.size();
542}
543
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700544// Write the contents of |patch_chunks| to |patch_fd|.
545bool PatchChunk::WritePatchDataToFd(const std::vector<PatchChunk>& patch_chunks, int patch_fd) {
546 // Figure out how big the imgdiff file header is going to be, so that we can correctly compute
547 // the offset of each bsdiff patch within the file.
548 size_t total_header_size = 12;
549 for (const auto& patch : patch_chunks) {
550 total_header_size += patch.GetHeaderSize();
551 }
552
553 size_t offset = total_header_size;
554
555 // Write out the headers.
Tianjie Xu82582b42017-08-31 18:05:19 -0700556 if (!android::base::WriteStringToFd("IMGDIFF" + std::to_string(VERSION), patch_fd)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800557 PLOG(ERROR) << "Failed to write \"IMGDIFF" << VERSION << "\"";
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700558 return false;
559 }
560
561 Write4(patch_fd, static_cast<int32_t>(patch_chunks.size()));
Tianjie Xu6e293c92017-11-15 16:26:41 -0800562 LOG(INFO) << "Writing " << patch_chunks.size() << " patch headers...";
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700563 for (size_t i = 0; i < patch_chunks.size(); ++i) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800564 offset = patch_chunks[i].WriteHeaderToFd(patch_fd, offset, i);
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700565 }
566
567 // Append each chunk's bsdiff patch, in order.
568 for (const auto& patch : patch_chunks) {
569 if (patch.type_ == CHUNK_RAW) {
570 continue;
571 }
572 if (!android::base::WriteFully(patch_fd, patch.data_.data(), patch.data_.size())) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800573 PLOG(ERROR) << "Failed to write " << patch.data_.size() << " bytes patch to patch_fd";
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700574 return false;
575 }
576 }
577
578 return true;
579}
580
Tianjie Xu57dd9612017-08-17 17:50:56 -0700581ImageChunk& Image::operator[](size_t i) {
582 CHECK_LT(i, chunks_.size());
583 return chunks_[i];
584}
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700585
Tianjie Xu57dd9612017-08-17 17:50:56 -0700586const ImageChunk& Image::operator[](size_t i) const {
587 CHECK_LT(i, chunks_.size());
588 return chunks_[i];
589}
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700590
591void Image::MergeAdjacentNormalChunks() {
592 size_t merged_last = 0, cur = 0;
593 while (cur < chunks_.size()) {
594 // Look for normal chunks adjacent to the current one. If such chunk exists, extend the
595 // length of the current normal chunk.
596 size_t to_check = cur + 1;
597 while (to_check < chunks_.size() && chunks_[cur].IsAdjacentNormal(chunks_[to_check])) {
598 chunks_[cur].MergeAdjacentNormal(chunks_[to_check]);
599 to_check++;
600 }
601
602 if (merged_last != cur) {
603 chunks_[merged_last] = std::move(chunks_[cur]);
604 }
605 merged_last++;
606 cur = to_check;
607 }
608 if (merged_last < chunks_.size()) {
609 chunks_.erase(chunks_.begin() + merged_last, chunks_.end());
610 }
611}
612
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700613void Image::DumpChunks() const {
614 std::string type = is_source_ ? "source" : "target";
Tianjie Xu6e293c92017-11-15 16:26:41 -0800615 LOG(INFO) << "Dumping chunks for " << type;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700616 for (size_t i = 0; i < chunks_.size(); ++i) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800617 chunks_[i].Dump(i);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700618 }
619}
620
621bool Image::ReadFile(const std::string& filename, std::vector<uint8_t>* file_content) {
622 CHECK(file_content != nullptr);
623
624 android::base::unique_fd fd(open(filename.c_str(), O_RDONLY));
625 if (fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800626 PLOG(ERROR) << "Failed to open " << filename;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700627 return false;
628 }
629 struct stat st;
630 if (fstat(fd, &st) != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800631 PLOG(ERROR) << "Failed to stat " << filename;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700632 return false;
633 }
634
635 size_t sz = static_cast<size_t>(st.st_size);
636 file_content->resize(sz);
637 if (!android::base::ReadFully(fd, file_content->data(), sz)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800638 PLOG(ERROR) << "Failed to read " << filename;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700639 return false;
640 }
641 fd.reset();
642
643 return true;
644}
645
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700646bool ZipModeImage::Initialize(const std::string& filename) {
647 if (!ReadFile(filename, &file_content_)) {
648 return false;
649 }
650
651 // Omit the trailing zeros before we pass the file to ziparchive handler.
652 size_t zipfile_size;
653 if (!GetZipFileSize(&zipfile_size)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800654 LOG(ERROR) << "Failed to parse the actual size of " << filename;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700655 return false;
656 }
657 ZipArchiveHandle handle;
658 int err = OpenArchiveFromMemory(const_cast<uint8_t*>(file_content_.data()), zipfile_size,
659 filename.c_str(), &handle);
660 if (err != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800661 LOG(ERROR) << "Failed to open zip file " << filename << ": " << ErrorCodeString(err);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700662 CloseArchive(handle);
663 return false;
664 }
665
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700666 if (!InitializeChunks(filename, handle)) {
667 CloseArchive(handle);
668 return false;
669 }
670
671 CloseArchive(handle);
672 return true;
673}
674
675// Iterate the zip entries and compose the image chunks accordingly.
676bool ZipModeImage::InitializeChunks(const std::string& filename, ZipArchiveHandle handle) {
677 void* cookie;
Elliott Hughes143a03f2019-05-07 14:59:09 -0700678 int ret = StartIteration(handle, &cookie);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700679 if (ret != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800680 LOG(ERROR) << "Failed to iterate over entries in " << filename << ": " << ErrorCodeString(ret);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700681 return false;
682 }
683
684 // Create a list of deflated zip entries, sorted by offset.
685 std::vector<std::pair<std::string, ZipEntry>> temp_entries;
Elliott Hughes88d80012019-05-22 18:52:29 -0700686 std::string name;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700687 ZipEntry entry;
688 while ((ret = Next(cookie, &entry, &name)) == 0) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700689 if (entry.method == kCompressDeflated || limit_ > 0) {
Elliott Hughes88d80012019-05-22 18:52:29 -0700690 temp_entries.emplace_back(name, entry);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700691 }
692 }
693
694 if (ret != -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800695 LOG(ERROR) << "Error while iterating over zip entries: " << ErrorCodeString(ret);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700696 return false;
697 }
698 std::sort(temp_entries.begin(), temp_entries.end(),
699 [](auto& entry1, auto& entry2) { return entry1.second.offset < entry2.second.offset; });
700
701 EndIteration(cookie);
702
703 // For source chunks, we don't need to compose chunks for the metadata.
704 if (is_source_) {
705 for (auto& entry : temp_entries) {
706 if (!AddZipEntryToChunks(handle, entry.first, &entry.second)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800707 LOG(ERROR) << "Failed to add " << entry.first << " to source chunks";
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700708 return false;
709 }
710 }
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700711
712 // Add the end of zip file (mainly central directory) as a normal chunk.
713 size_t entries_end = 0;
714 if (!temp_entries.empty()) {
715 entries_end = static_cast<size_t>(temp_entries.back().second.offset +
716 temp_entries.back().second.compressed_length);
717 }
718 CHECK_LT(entries_end, file_content_.size());
719 chunks_.emplace_back(CHUNK_NORMAL, entries_end, &file_content_,
720 file_content_.size() - entries_end);
721
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700722 return true;
723 }
724
725 // For target chunks, add the deflate entries as CHUNK_DEFLATE and the contents between two
726 // deflate entries as CHUNK_NORMAL.
727 size_t pos = 0;
728 size_t nextentry = 0;
729 while (pos < file_content_.size()) {
730 if (nextentry < temp_entries.size() &&
731 static_cast<off64_t>(pos) == temp_entries[nextentry].second.offset) {
732 // Add the next zip entry.
733 std::string entry_name = temp_entries[nextentry].first;
734 if (!AddZipEntryToChunks(handle, entry_name, &temp_entries[nextentry].second)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800735 LOG(ERROR) << "Failed to add " << entry_name << " to target chunks";
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700736 return false;
737 }
738
739 pos += temp_entries[nextentry].second.compressed_length;
740 ++nextentry;
741 continue;
742 }
743
744 // Use a normal chunk to take all the data up to the start of the next entry.
745 size_t raw_data_len;
746 if (nextentry < temp_entries.size()) {
747 raw_data_len = temp_entries[nextentry].second.offset - pos;
748 } else {
749 raw_data_len = file_content_.size() - pos;
750 }
751 chunks_.emplace_back(CHUNK_NORMAL, pos, &file_content_, raw_data_len);
752
753 pos += raw_data_len;
754 }
755
756 return true;
757}
758
759bool ZipModeImage::AddZipEntryToChunks(ZipArchiveHandle handle, const std::string& entry_name,
760 ZipEntry* entry) {
761 size_t compressed_len = entry->compressed_length;
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700762 if (compressed_len == 0) return true;
763
764 // Split the entry into several normal chunks if it's too large.
765 if (limit_ > 0 && compressed_len > limit_) {
766 int count = 0;
767 while (compressed_len > 0) {
768 size_t length = std::min(limit_, compressed_len);
769 std::string name = entry_name + "-" + std::to_string(count);
770 chunks_.emplace_back(CHUNK_NORMAL, entry->offset + limit_ * count, &file_content_, length,
771 name);
772
773 count++;
774 compressed_len -= length;
775 }
776 } else if (entry->method == kCompressDeflated) {
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700777 size_t uncompressed_len = entry->uncompressed_length;
778 std::vector<uint8_t> uncompressed_data(uncompressed_len);
779 int ret = ExtractToMemory(handle, entry, uncompressed_data.data(), uncompressed_len);
780 if (ret != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800781 LOG(ERROR) << "Failed to extract " << entry_name << " with size " << uncompressed_len << ": "
782 << ErrorCodeString(ret);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700783 return false;
784 }
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700785 ImageChunk curr(CHUNK_DEFLATE, entry->offset, &file_content_, compressed_len, entry_name);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700786 curr.SetUncompressedData(std::move(uncompressed_data));
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700787 chunks_.push_back(std::move(curr));
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700788 } else {
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700789 chunks_.emplace_back(CHUNK_NORMAL, entry->offset, &file_content_, compressed_len, entry_name);
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700790 }
791
792 return true;
793}
794
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800795// EOCD record
796// offset 0: signature 0x06054b50, 4 bytes
797// offset 4: number of this disk, 2 bytes
798// ...
799// offset 20: comment length, 2 bytes
800// offset 22: comment, n bytes
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700801bool ZipModeImage::GetZipFileSize(size_t* input_file_size) {
802 if (file_content_.size() < 22) {
Tianjie Xu6e293c92017-11-15 16:26:41 -0800803 LOG(ERROR) << "File is too small to be a zip file";
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800804 return false;
805 }
806
807 // Look for End of central directory record of the zip file, and calculate the actual
808 // zip_file size.
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700809 for (int i = file_content_.size() - 22; i >= 0; i--) {
810 if (file_content_[i] == 0x50) {
811 if (get_unaligned<uint32_t>(&file_content_[i]) == 0x06054b50) {
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800812 // double-check: this archive consists of a single "disk".
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700813 CHECK_EQ(get_unaligned<uint16_t>(&file_content_[i + 4]), 0);
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800814
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700815 uint16_t comment_length = get_unaligned<uint16_t>(&file_content_[i + 20]);
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800816 size_t file_size = i + 22 + comment_length;
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700817 CHECK_LE(file_size, file_content_.size());
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800818 *input_file_size = file_size;
819 return true;
820 }
821 }
822 }
823
824 // EOCD not found, this file is likely not a valid zip file.
825 return false;
826}
827
Tianjie Xu57dd9612017-08-17 17:50:56 -0700828ImageChunk ZipModeImage::PseudoSource() const {
829 CHECK(is_source_);
830 return ImageChunk(CHUNK_NORMAL, 0, &file_content_, file_content_.size());
831}
832
833const ImageChunk* ZipModeImage::FindChunkByName(const std::string& name, bool find_normal) const {
834 if (name.empty()) {
835 return nullptr;
836 }
837 for (auto& chunk : chunks_) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700838 if (chunk.GetType() != CHUNK_DEFLATE && !find_normal) {
839 continue;
840 }
841
842 if (chunk.GetEntryName() == name) {
Tianjie Xu57dd9612017-08-17 17:50:56 -0700843 return &chunk;
844 }
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700845
846 // Edge case when target chunk is split due to size limit but source chunk isn't.
847 if (name == (chunk.GetEntryName() + "-0") || chunk.GetEntryName() == (name + "-0")) {
848 return &chunk;
849 }
850
851 // TODO handle the .so files with incremental version number.
852 // (e.g. lib/arm64-v8a/libcronet.59.0.3050.4.so)
Tianjie Xu57dd9612017-08-17 17:50:56 -0700853 }
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700854
Tianjie Xu57dd9612017-08-17 17:50:56 -0700855 return nullptr;
856}
857
858ImageChunk* ZipModeImage::FindChunkByName(const std::string& name, bool find_normal) {
859 return const_cast<ImageChunk*>(
860 static_cast<const ZipModeImage*>(this)->FindChunkByName(name, find_normal));
861}
862
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700863bool ZipModeImage::CheckAndProcessChunks(ZipModeImage* tgt_image, ZipModeImage* src_image) {
864 for (auto& tgt_chunk : *tgt_image) {
865 if (tgt_chunk.GetType() != CHUNK_DEFLATE) {
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800866 continue;
867 }
868
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700869 ImageChunk* src_chunk = src_image->FindChunkByName(tgt_chunk.GetEntryName());
870 if (src_chunk == nullptr) {
871 tgt_chunk.ChangeDeflateChunkToNormal();
872 } else if (tgt_chunk == *src_chunk) {
873 // If two deflate chunks are identical (eg, the kernel has not changed between two builds),
874 // treat them as normal chunks. This makes applypatch much faster -- it can apply a trivial
875 // patch to the compressed data, rather than uncompressing and recompressing to apply the
876 // trivial patch to the uncompressed data.
877 tgt_chunk.ChangeDeflateChunkToNormal();
878 src_chunk->ChangeDeflateChunkToNormal();
879 } else if (!tgt_chunk.ReconstructDeflateChunk()) {
880 // We cannot recompress the data and get exactly the same bits as are in the input target
881 // image. Treat the chunk as a normal non-deflated chunk.
Tianjie Xu6e293c92017-11-15 16:26:41 -0800882 LOG(WARNING) << "Failed to reconstruct target deflate chunk [" << tgt_chunk.GetEntryName()
883 << "]; treating as normal";
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800884
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700885 tgt_chunk.ChangeDeflateChunkToNormal();
886 src_chunk->ChangeDeflateChunkToNormal();
887 }
Tianjie Xu1ea84d62017-02-22 18:23:58 -0800888 }
889
Tianjie Xu6b03ba72017-07-19 14:16:30 -0700890 // For zips, we only need merge normal chunks for the target: deflated chunks are matched via
891 // filename, and normal chunks are patched using the entire source file as the source.
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700892 if (tgt_image->limit_ == 0) {
893 tgt_image->MergeAdjacentNormalChunks();
894 tgt_image->DumpChunks();
895 }
Tianjie Xu12b90552017-03-07 14:44:14 -0800896
Tianjie Xud82a2ed2017-08-08 17:35:01 -0700897 return true;
898}
899
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700900// For each target chunk, look for the corresponding source chunk by the zip_entry name. If
901// found, add the range of this chunk in the original source file to the block aligned source
902// ranges. Construct the split src & tgt image once the size of source range reaches limit.
903bool ZipModeImage::SplitZipModeImageWithLimit(const ZipModeImage& tgt_image,
904 const ZipModeImage& src_image,
905 std::vector<ZipModeImage>* split_tgt_images,
906 std::vector<ZipModeImage>* split_src_images,
907 std::vector<SortedRangeSet>* split_src_ranges) {
908 CHECK_EQ(tgt_image.limit_, src_image.limit_);
909 size_t limit = tgt_image.limit_;
910
911 src_image.DumpChunks();
Tianjie Xu6e293c92017-11-15 16:26:41 -0800912 LOG(INFO) << "Splitting " << tgt_image.NumOfChunks() << " tgt chunks...";
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700913
914 SortedRangeSet used_src_ranges; // ranges used for previous split source images.
915
916 // Reserve the central directory in advance for the last split image.
917 const auto& central_directory = src_image.cend() - 1;
918 CHECK_EQ(CHUNK_NORMAL, central_directory->GetType());
919 used_src_ranges.Insert(central_directory->GetStartOffset(),
920 central_directory->DataLengthForPatch());
921
922 SortedRangeSet src_ranges;
923 std::vector<ImageChunk> split_src_chunks;
924 std::vector<ImageChunk> split_tgt_chunks;
925 for (auto tgt = tgt_image.cbegin(); tgt != tgt_image.cend(); tgt++) {
926 const ImageChunk* src = src_image.FindChunkByName(tgt->GetEntryName(), true);
927 if (src == nullptr) {
928 split_tgt_chunks.emplace_back(CHUNK_NORMAL, tgt->GetStartOffset(), &tgt_image.file_content_,
929 tgt->GetRawDataLength());
930 continue;
931 }
932
933 size_t src_offset = src->GetStartOffset();
934 size_t src_length = src->GetRawDataLength();
935
936 CHECK(src_length > 0);
937 CHECK_LE(src_length, limit);
938
939 // Make sure this source range hasn't been used before so that the src_range pieces don't
940 // overlap with each other.
941 if (!RemoveUsedBlocks(&src_offset, &src_length, used_src_ranges)) {
942 split_tgt_chunks.emplace_back(CHUNK_NORMAL, tgt->GetStartOffset(), &tgt_image.file_content_,
943 tgt->GetRawDataLength());
944 } else if (src_ranges.blocks() * BLOCK_SIZE + src_length <= limit) {
945 src_ranges.Insert(src_offset, src_length);
946
947 // Add the deflate source chunk if it hasn't been aligned.
948 if (src->GetType() == CHUNK_DEFLATE && src_length == src->GetRawDataLength()) {
949 split_src_chunks.push_back(*src);
950 split_tgt_chunks.push_back(*tgt);
951 } else {
952 // TODO split smarter to avoid alignment of large deflate chunks
953 split_tgt_chunks.emplace_back(CHUNK_NORMAL, tgt->GetStartOffset(), &tgt_image.file_content_,
954 tgt->GetRawDataLength());
955 }
956 } else {
Tianjie Xu572abbb2018-02-22 15:40:39 -0800957 bool added_image = ZipModeImage::AddSplitImageFromChunkList(
958 tgt_image, src_image, src_ranges, split_tgt_chunks, split_src_chunks, split_tgt_images,
959 split_src_images);
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700960
961 split_tgt_chunks.clear();
962 split_src_chunks.clear();
Tianjie Xu572abbb2018-02-22 15:40:39 -0800963 // No need to update the split_src_ranges if we don't update the split source images.
964 if (added_image) {
965 used_src_ranges.Insert(src_ranges);
966 split_src_ranges->push_back(std::move(src_ranges));
967 }
Tianjie Xufb08b012020-03-07 17:22:40 -0800968 src_ranges = {};
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700969
970 // We don't have enough space for the current chunk; start a new split image and handle
971 // this chunk there.
972 tgt--;
973 }
974 }
975
976 // TODO Trim it in case the CD exceeds limit too much.
977 src_ranges.Insert(central_directory->GetStartOffset(), central_directory->DataLengthForPatch());
Tianjie Xu572abbb2018-02-22 15:40:39 -0800978 bool added_image = ZipModeImage::AddSplitImageFromChunkList(tgt_image, src_image, src_ranges,
979 split_tgt_chunks, split_src_chunks,
980 split_tgt_images, split_src_images);
981 if (added_image) {
982 split_src_ranges->push_back(std::move(src_ranges));
983 }
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700984
985 ValidateSplitImages(*split_tgt_images, *split_src_images, *split_src_ranges,
986 tgt_image.file_content_.size());
987
988 return true;
989}
990
Tianjie Xu572abbb2018-02-22 15:40:39 -0800991bool ZipModeImage::AddSplitImageFromChunkList(const ZipModeImage& tgt_image,
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700992 const ZipModeImage& src_image,
993 const SortedRangeSet& split_src_ranges,
994 const std::vector<ImageChunk>& split_tgt_chunks,
995 const std::vector<ImageChunk>& split_src_chunks,
996 std::vector<ZipModeImage>* split_tgt_images,
997 std::vector<ZipModeImage>* split_src_images) {
998 CHECK(!split_tgt_chunks.empty());
Tianjie Xu2903cdd2017-08-18 18:15:47 -0700999
1000 std::vector<ImageChunk> aligned_tgt_chunks;
1001
1002 // Align the target chunks in the beginning with BLOCK_SIZE.
1003 size_t i = 0;
1004 while (i < split_tgt_chunks.size()) {
1005 size_t tgt_start = split_tgt_chunks[i].GetStartOffset();
1006 size_t tgt_length = split_tgt_chunks[i].GetRawDataLength();
1007
1008 // Current ImageChunk is long enough to align.
1009 if (AlignHead(&tgt_start, &tgt_length)) {
1010 aligned_tgt_chunks.emplace_back(CHUNK_NORMAL, tgt_start, &tgt_image.file_content_,
1011 tgt_length);
1012 break;
1013 }
1014
1015 i++;
1016 }
Tianjie Xu572abbb2018-02-22 15:40:39 -08001017
1018 // Nothing left after alignment in the current split tgt chunks; skip adding the split_tgt_image.
1019 if (i == split_tgt_chunks.size()) {
1020 return false;
1021 }
1022
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001023 aligned_tgt_chunks.insert(aligned_tgt_chunks.end(), split_tgt_chunks.begin() + i + 1,
1024 split_tgt_chunks.end());
1025 CHECK(!aligned_tgt_chunks.empty());
1026
1027 // Add a normal chunk to align the contents in the end.
1028 size_t end_offset =
1029 aligned_tgt_chunks.back().GetStartOffset() + aligned_tgt_chunks.back().GetRawDataLength();
1030 if (end_offset % BLOCK_SIZE != 0 && end_offset < tgt_image.file_content_.size()) {
Tianjie Xu572abbb2018-02-22 15:40:39 -08001031 size_t tail_block_length = std::min<size_t>(tgt_image.file_content_.size() - end_offset,
1032 BLOCK_SIZE - (end_offset % BLOCK_SIZE));
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001033 aligned_tgt_chunks.emplace_back(CHUNK_NORMAL, end_offset, &tgt_image.file_content_,
Tianjie Xu572abbb2018-02-22 15:40:39 -08001034 tail_block_length);
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001035 }
1036
1037 ZipModeImage split_tgt_image(false);
Tianjie Xufb08b012020-03-07 17:22:40 -08001038 split_tgt_image.Initialize(aligned_tgt_chunks, {});
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001039 split_tgt_image.MergeAdjacentNormalChunks();
1040
1041 // Construct the dummy source file based on the src_ranges.
1042 std::vector<uint8_t> src_content;
1043 for (const auto& r : split_src_ranges) {
1044 size_t end = std::min(src_image.file_content_.size(), r.second * BLOCK_SIZE);
1045 src_content.insert(src_content.end(), src_image.file_content_.begin() + r.first * BLOCK_SIZE,
1046 src_image.file_content_.begin() + end);
1047 }
1048
1049 // We should not have an empty src in our design; otherwise we will encounter an error in
1050 // bsdiff since src_content.data() == nullptr.
1051 CHECK(!src_content.empty());
1052
1053 ZipModeImage split_src_image(true);
Tianjie Xufb08b012020-03-07 17:22:40 -08001054 split_src_image.Initialize(split_src_chunks, src_content);
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001055
1056 split_tgt_images->push_back(std::move(split_tgt_image));
1057 split_src_images->push_back(std::move(split_src_image));
Tianjie Xu572abbb2018-02-22 15:40:39 -08001058
1059 return true;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001060}
1061
1062void ZipModeImage::ValidateSplitImages(const std::vector<ZipModeImage>& split_tgt_images,
1063 const std::vector<ZipModeImage>& split_src_images,
1064 std::vector<SortedRangeSet>& split_src_ranges,
1065 size_t total_tgt_size) {
1066 CHECK_EQ(split_tgt_images.size(), split_src_images.size());
1067
Tianjie Xu6e293c92017-11-15 16:26:41 -08001068 LOG(INFO) << "Validating " << split_tgt_images.size() << " images";
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001069
1070 // Verify that the target image pieces is continuous and can add up to the total size.
1071 size_t last_offset = 0;
1072 for (const auto& tgt_image : split_tgt_images) {
1073 CHECK(!tgt_image.chunks_.empty());
1074
1075 CHECK_EQ(last_offset, tgt_image.chunks_.front().GetStartOffset());
1076 CHECK(last_offset % BLOCK_SIZE == 0);
1077
1078 // Check the target chunks within the split image are continuous.
1079 for (const auto& chunk : tgt_image.chunks_) {
1080 CHECK_EQ(last_offset, chunk.GetStartOffset());
1081 last_offset += chunk.GetRawDataLength();
1082 }
1083 }
1084 CHECK_EQ(total_tgt_size, last_offset);
1085
1086 // Verify that the source ranges are mutually exclusive.
1087 CHECK_EQ(split_src_images.size(), split_src_ranges.size());
1088 SortedRangeSet used_src_ranges;
1089 for (size_t i = 0; i < split_src_ranges.size(); i++) {
1090 CHECK(!used_src_ranges.Overlaps(split_src_ranges[i]))
1091 << "src range " << split_src_ranges[i].ToString() << " overlaps "
1092 << used_src_ranges.ToString();
1093 used_src_ranges.Insert(split_src_ranges[i]);
1094 }
1095}
1096
1097bool ZipModeImage::GeneratePatchesInternal(const ZipModeImage& tgt_image,
1098 const ZipModeImage& src_image,
1099 std::vector<PatchChunk>* patch_chunks) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001100 LOG(INFO) << "Constructing patches for " << tgt_image.NumOfChunks() << " chunks...";
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001101 patch_chunks->clear();
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001102
Alex Deymofa188262017-10-10 17:56:17 +02001103 bsdiff::SuffixArrayIndexInterface* bsdiff_cache = nullptr;
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001104 for (size_t i = 0; i < tgt_image.NumOfChunks(); i++) {
1105 const auto& tgt_chunk = tgt_image[i];
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001106
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001107 if (PatchChunk::RawDataIsSmaller(tgt_chunk, 0)) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001108 patch_chunks->emplace_back(tgt_chunk);
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001109 continue;
1110 }
1111
1112 const ImageChunk* src_chunk = (tgt_chunk.GetType() != CHUNK_DEFLATE)
1113 ? nullptr
1114 : src_image.FindChunkByName(tgt_chunk.GetEntryName());
1115
1116 const auto& src_ref = (src_chunk == nullptr) ? src_image.PseudoSource() : *src_chunk;
Alex Deymofa188262017-10-10 17:56:17 +02001117 bsdiff::SuffixArrayIndexInterface** bsdiff_cache_ptr =
1118 (src_chunk == nullptr) ? &bsdiff_cache : nullptr;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001119
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001120 std::vector<uint8_t> patch_data;
1121 if (!ImageChunk::MakePatch(tgt_chunk, src_ref, &patch_data, bsdiff_cache_ptr)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001122 LOG(ERROR) << "Failed to generate patch, name: " << tgt_chunk.GetEntryName();
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001123 return false;
1124 }
1125
Tianjie Xu6e293c92017-11-15 16:26:41 -08001126 LOG(INFO) << "patch " << i << " is " << patch_data.size() << " bytes (of "
1127 << tgt_chunk.GetRawDataLength() << ")";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001128
1129 if (PatchChunk::RawDataIsSmaller(tgt_chunk, patch_data.size())) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001130 patch_chunks->emplace_back(tgt_chunk);
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001131 } else {
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001132 patch_chunks->emplace_back(tgt_chunk, src_ref, std::move(patch_data));
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001133 }
Tianjie Xu12b90552017-03-07 14:44:14 -08001134 }
Alex Deymofa188262017-10-10 17:56:17 +02001135 delete bsdiff_cache;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001136
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001137 CHECK_EQ(patch_chunks->size(), tgt_image.NumOfChunks());
1138 return true;
1139}
1140
1141bool ZipModeImage::GeneratePatches(const ZipModeImage& tgt_image, const ZipModeImage& src_image,
1142 const std::string& patch_name) {
1143 std::vector<PatchChunk> patch_chunks;
1144
1145 ZipModeImage::GeneratePatchesInternal(tgt_image, src_image, &patch_chunks);
1146
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001147 CHECK_EQ(tgt_image.NumOfChunks(), patch_chunks.size());
1148
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001149 android::base::unique_fd patch_fd(
1150 open(patch_name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR));
1151 if (patch_fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001152 PLOG(ERROR) << "Failed to open " << patch_name;
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001153 return false;
1154 }
1155
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001156 return PatchChunk::WritePatchDataToFd(patch_chunks, patch_fd);
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001157}
1158
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001159bool ZipModeImage::GeneratePatches(const std::vector<ZipModeImage>& split_tgt_images,
1160 const std::vector<ZipModeImage>& split_src_images,
1161 const std::vector<SortedRangeSet>& split_src_ranges,
Tianjie Xu82582b42017-08-31 18:05:19 -07001162 const std::string& patch_name,
1163 const std::string& split_info_file,
1164 const std::string& debug_dir) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001165 LOG(INFO) << "Constructing patches for " << split_tgt_images.size() << " split images...";
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001166
1167 android::base::unique_fd patch_fd(
1168 open(patch_name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR));
1169 if (patch_fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001170 PLOG(ERROR) << "Failed to open " << patch_name;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001171 return false;
1172 }
1173
Tianjie Xu82582b42017-08-31 18:05:19 -07001174 std::vector<std::string> split_info_list;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001175 for (size_t i = 0; i < split_tgt_images.size(); i++) {
1176 std::vector<PatchChunk> patch_chunks;
1177 if (!ZipModeImage::GeneratePatchesInternal(split_tgt_images[i], split_src_images[i],
1178 &patch_chunks)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001179 LOG(ERROR) << "Failed to generate split patch";
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001180 return false;
1181 }
1182
Tianjie Xu82582b42017-08-31 18:05:19 -07001183 size_t total_patch_size = 12;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001184 for (auto& p : patch_chunks) {
1185 p.UpdateSourceOffset(split_src_ranges[i]);
Tianjie Xu82582b42017-08-31 18:05:19 -07001186 total_patch_size += p.PatchSize();
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001187 }
1188
1189 if (!PatchChunk::WritePatchDataToFd(patch_chunks, patch_fd)) {
1190 return false;
1191 }
1192
Tianjie Xu82582b42017-08-31 18:05:19 -07001193 size_t split_tgt_size = split_tgt_images[i].chunks_.back().GetStartOffset() +
1194 split_tgt_images[i].chunks_.back().GetRawDataLength() -
1195 split_tgt_images[i].chunks_.front().GetStartOffset();
1196 std::string split_info = android::base::StringPrintf(
1197 "%zu %zu %s", total_patch_size, split_tgt_size, split_src_ranges[i].ToString().c_str());
1198 split_info_list.push_back(split_info);
1199
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001200 // Write the split source & patch into the debug directory.
1201 if (!debug_dir.empty()) {
1202 std::string src_name = android::base::StringPrintf("%s/src-%zu", debug_dir.c_str(), i);
1203 android::base::unique_fd fd(
1204 open(src_name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR));
1205
1206 if (fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001207 PLOG(ERROR) << "Failed to open " << src_name;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001208 return false;
1209 }
1210 if (!android::base::WriteFully(fd, split_src_images[i].PseudoSource().DataForPatch(),
1211 split_src_images[i].PseudoSource().DataLengthForPatch())) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001212 PLOG(ERROR) << "Failed to write split source data into " << src_name;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001213 return false;
1214 }
1215
1216 std::string patch_name = android::base::StringPrintf("%s/patch-%zu", debug_dir.c_str(), i);
1217 fd.reset(open(patch_name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR));
1218
1219 if (fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001220 PLOG(ERROR) << "Failed to open " << patch_name;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001221 return false;
1222 }
1223 if (!PatchChunk::WritePatchDataToFd(patch_chunks, fd)) {
1224 return false;
1225 }
1226 }
1227 }
Tianjie Xu82582b42017-08-31 18:05:19 -07001228
1229 // Store the split in the following format:
1230 // Line 0: imgdiff version#
1231 // Line 1: number of pieces
1232 // Line 2: patch_size_1 tgt_size_1 src_range_1
1233 // ...
1234 // Line n+1: patch_size_n tgt_size_n src_range_n
1235 std::string split_info_string = android::base::StringPrintf(
1236 "%zu\n%zu\n", VERSION, split_info_list.size()) + android::base::Join(split_info_list, '\n');
1237 if (!android::base::WriteStringToFile(split_info_string, split_info_file)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001238 PLOG(ERROR) << "Failed to write split info to " << split_info_file;
Tianjie Xu82582b42017-08-31 18:05:19 -07001239 return false;
1240 }
1241
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001242 return true;
1243}
1244
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001245bool ImageModeImage::Initialize(const std::string& filename) {
1246 if (!ReadFile(filename, &file_content_)) {
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001247 return false;
Doug Zongker512536a2010-02-17 16:11:44 -08001248 }
Doug Zongker512536a2010-02-17 16:11:44 -08001249
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001250 size_t sz = file_content_.size();
Doug Zongker512536a2010-02-17 16:11:44 -08001251 size_t pos = 0;
Tao Baoba9a42a2015-06-23 23:23:33 -07001252 while (pos < sz) {
Tianjie Xu12b90552017-03-07 14:44:14 -08001253 // 0x00 no header flags, 0x08 deflate compression, 0x1f8b gzip magic number
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001254 if (sz - pos >= 4 && get_unaligned<uint32_t>(file_content_.data() + pos) == 0x00088b1f) {
Doug Zongker512536a2010-02-17 16:11:44 -08001255 // 'pos' is the offset of the start of a gzip chunk.
Johan Redestigc68bd342015-04-14 21:20:06 +02001256 size_t chunk_offset = pos;
Doug Zongker512536a2010-02-17 16:11:44 -08001257
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001258 // The remaining data is too small to be a gzip chunk; treat them as a normal chunk.
1259 if (sz - pos < GZIP_HEADER_LEN + GZIP_FOOTER_LEN) {
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001260 chunks_.emplace_back(CHUNK_NORMAL, pos, &file_content_, sz - pos);
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001261 break;
1262 }
Doug Zongker512536a2010-02-17 16:11:44 -08001263
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001264 // We need three chunks for the deflated image in total, one normal chunk for the header,
1265 // one deflated chunk for the body, and another normal chunk for the footer.
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001266 chunks_.emplace_back(CHUNK_NORMAL, pos, &file_content_, GZIP_HEADER_LEN);
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001267 pos += GZIP_HEADER_LEN;
Doug Zongker512536a2010-02-17 16:11:44 -08001268
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001269 // We must decompress this chunk in order to discover where it ends, and so we can update
1270 // the uncompressed_data of the image body and its length.
Doug Zongker512536a2010-02-17 16:11:44 -08001271
1272 z_stream strm;
1273 strm.zalloc = Z_NULL;
1274 strm.zfree = Z_NULL;
1275 strm.opaque = Z_NULL;
Tao Baoba9a42a2015-06-23 23:23:33 -07001276 strm.avail_in = sz - pos;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001277 strm.next_in = file_content_.data() + pos;
Doug Zongker512536a2010-02-17 16:11:44 -08001278
1279 // -15 means we are decoding a 'raw' deflate stream; zlib will
1280 // not expect zlib headers.
1281 int ret = inflateInit2(&strm, -15);
Rahul Chaudhrya793c582016-11-29 17:10:14 -08001282 if (ret < 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001283 LOG(ERROR) << "Failed to initialize inflate: " << ret;
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001284 return false;
Rahul Chaudhrya793c582016-11-29 17:10:14 -08001285 }
Doug Zongker512536a2010-02-17 16:11:44 -08001286
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001287 size_t allocated = BUFFER_SIZE;
1288 std::vector<uint8_t> uncompressed_data(allocated);
1289 size_t uncompressed_len = 0, raw_data_len = 0;
Doug Zongker512536a2010-02-17 16:11:44 -08001290 do {
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001291 strm.avail_out = allocated - uncompressed_len;
1292 strm.next_out = uncompressed_data.data() + uncompressed_len;
Doug Zongker512536a2010-02-17 16:11:44 -08001293 ret = inflate(&strm, Z_NO_FLUSH);
Johan Redestigc68bd342015-04-14 21:20:06 +02001294 if (ret < 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001295 LOG(WARNING) << "Inflate failed [" << strm.msg << "] at offset [" << chunk_offset
1296 << "]; treating as a normal chunk";
Sen Jiangfa4f1b72016-02-11 16:14:23 -08001297 break;
Johan Redestigc68bd342015-04-14 21:20:06 +02001298 }
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001299 uncompressed_len = allocated - strm.avail_out;
Doug Zongker512536a2010-02-17 16:11:44 -08001300 if (strm.avail_out == 0) {
1301 allocated *= 2;
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001302 uncompressed_data.resize(allocated);
Doug Zongker512536a2010-02-17 16:11:44 -08001303 }
1304 } while (ret != Z_STREAM_END);
1305
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001306 raw_data_len = sz - strm.avail_in - pos;
Doug Zongker512536a2010-02-17 16:11:44 -08001307 inflateEnd(&strm);
Sen Jiangfa4f1b72016-02-11 16:14:23 -08001308
1309 if (ret < 0) {
Sen Jiangfa4f1b72016-02-11 16:14:23 -08001310 continue;
1311 }
1312
Tianjie Xu14ebc1e2017-07-05 12:04:07 -07001313 // The footer contains the size of the uncompressed data. Double-check to make sure that it
1314 // matches the size of the data we got when we actually did the decompression.
1315 size_t footer_index = pos + raw_data_len + GZIP_FOOTER_LEN - 4;
1316 if (sz - footer_index < 4) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001317 LOG(WARNING) << "invalid footer position; treating as a normal chunk";
Tianjie Xu14ebc1e2017-07-05 12:04:07 -07001318 continue;
1319 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001320 size_t footer_size = get_unaligned<uint32_t>(file_content_.data() + footer_index);
Tianjie Xu14ebc1e2017-07-05 12:04:07 -07001321 if (footer_size != uncompressed_len) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001322 LOG(WARNING) << "footer size " << footer_size << " != " << uncompressed_len
1323 << "; treating as a normal chunk";
Tianjie Xu14ebc1e2017-07-05 12:04:07 -07001324 continue;
1325 }
1326
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001327 ImageChunk body(CHUNK_DEFLATE, pos, &file_content_, raw_data_len);
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001328 uncompressed_data.resize(uncompressed_len);
1329 body.SetUncompressedData(std::move(uncompressed_data));
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001330 chunks_.push_back(std::move(body));
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001331
1332 pos += raw_data_len;
Doug Zongker512536a2010-02-17 16:11:44 -08001333
1334 // create a normal chunk for the footer
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001335 chunks_.emplace_back(CHUNK_NORMAL, pos, &file_content_, GZIP_FOOTER_LEN);
Doug Zongker512536a2010-02-17 16:11:44 -08001336
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001337 pos += GZIP_FOOTER_LEN;
Doug Zongker512536a2010-02-17 16:11:44 -08001338 } else {
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001339 // Use a normal chunk to take all the contents until the next gzip chunk (or EOF); we expect
1340 // the number of chunks to be small (5 for typical boot and recovery images).
Doug Zongker512536a2010-02-17 16:11:44 -08001341
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001342 // Scan forward until we find a gzip header.
1343 size_t data_len = 0;
1344 while (data_len + pos < sz) {
Tianjie Xu12b90552017-03-07 14:44:14 -08001345 if (data_len + pos + 4 <= sz &&
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001346 get_unaligned<uint32_t>(file_content_.data() + pos + data_len) == 0x00088b1f) {
Doug Zongker512536a2010-02-17 16:11:44 -08001347 break;
1348 }
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001349 data_len++;
Doug Zongker512536a2010-02-17 16:11:44 -08001350 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001351 chunks_.emplace_back(CHUNK_NORMAL, pos, &file_content_, data_len);
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001352
1353 pos += data_len;
Doug Zongker512536a2010-02-17 16:11:44 -08001354 }
1355 }
1356
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001357 return true;
Doug Zongker512536a2010-02-17 16:11:44 -08001358}
1359
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001360bool ImageModeImage::SetBonusData(const std::vector<uint8_t>& bonus_data) {
1361 CHECK(is_source_);
1362 if (chunks_.size() < 2 || !chunks_[1].SetBonusData(bonus_data)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001363 LOG(ERROR) << "Failed to set bonus data";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001364 DumpChunks();
1365 return false;
1366 }
1367
Tianjie Xu6e293c92017-11-15 16:26:41 -08001368 LOG(INFO) << " using " << bonus_data.size() << " bytes of bonus data";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001369 return true;
1370}
1371
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001372// In Image Mode, verify that the source and target images have the same chunk structure (ie, the
1373// same sequence of deflate and normal chunks).
1374bool ImageModeImage::CheckAndProcessChunks(ImageModeImage* tgt_image, ImageModeImage* src_image) {
1375 // In image mode, merge the gzip header and footer in with any adjacent normal chunks.
1376 tgt_image->MergeAdjacentNormalChunks();
1377 src_image->MergeAdjacentNormalChunks();
Doug Zongker512536a2010-02-17 16:11:44 -08001378
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001379 if (tgt_image->NumOfChunks() != src_image->NumOfChunks()) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001380 LOG(ERROR) << "Source and target don't have same number of chunks!";
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001381 tgt_image->DumpChunks();
1382 src_image->DumpChunks();
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001383 return false;
Jeremy Compostellaa91c66d2015-09-08 19:15:09 +02001384 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001385 for (size_t i = 0; i < tgt_image->NumOfChunks(); ++i) {
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001386 if ((*tgt_image)[i].GetType() != (*src_image)[i].GetType()) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001387 LOG(ERROR) << "Source and target don't have same chunk structure! (chunk " << i << ")";
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001388 tgt_image->DumpChunks();
1389 src_image->DumpChunks();
1390 return false;
1391 }
Doug Zongker512536a2010-02-17 16:11:44 -08001392 }
1393
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001394 for (size_t i = 0; i < tgt_image->NumOfChunks(); ++i) {
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001395 auto& tgt_chunk = (*tgt_image)[i];
1396 auto& src_chunk = (*src_image)[i];
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001397 if (tgt_chunk.GetType() != CHUNK_DEFLATE) {
1398 continue;
1399 }
1400
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001401 // If two deflate chunks are identical treat them as normal chunks.
1402 if (tgt_chunk == src_chunk) {
1403 tgt_chunk.ChangeDeflateChunkToNormal();
1404 src_chunk.ChangeDeflateChunkToNormal();
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001405 } else if (!tgt_chunk.ReconstructDeflateChunk()) {
1406 // We cannot recompress the data and get exactly the same bits as are in the input target
1407 // image, fall back to normal
Tianjie Xu6e293c92017-11-15 16:26:41 -08001408 LOG(WARNING) << "Failed to reconstruct target deflate chunk " << i << " ["
1409 << tgt_chunk.GetEntryName() << "]; treating as normal";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001410 tgt_chunk.ChangeDeflateChunkToNormal();
1411 src_chunk.ChangeDeflateChunkToNormal();
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001412 }
Doug Zongker512536a2010-02-17 16:11:44 -08001413 }
1414
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001415 // For images, we need to maintain the parallel structure of the chunk lists, so do the merging
1416 // in both the source and target lists.
1417 tgt_image->MergeAdjacentNormalChunks();
1418 src_image->MergeAdjacentNormalChunks();
1419 if (tgt_image->NumOfChunks() != src_image->NumOfChunks()) {
1420 // This shouldn't happen.
Tianjie Xu6e293c92017-11-15 16:26:41 -08001421 LOG(ERROR) << "Merging normal chunks went awry";
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001422 return false;
Doug Zongker512536a2010-02-17 16:11:44 -08001423 }
Doug Zongker512536a2010-02-17 16:11:44 -08001424
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001425 return true;
Doug Zongker512536a2010-02-17 16:11:44 -08001426}
1427
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001428// In image mode, generate patches against the given source chunks and bonus_data; write the
1429// result to |patch_name|.
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001430bool ImageModeImage::GeneratePatches(const ImageModeImage& tgt_image,
1431 const ImageModeImage& src_image,
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001432 const std::string& patch_name) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001433 LOG(INFO) << "Constructing patches for " << tgt_image.NumOfChunks() << " chunks...";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001434 std::vector<PatchChunk> patch_chunks;
1435 patch_chunks.reserve(tgt_image.NumOfChunks());
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001436
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001437 for (size_t i = 0; i < tgt_image.NumOfChunks(); i++) {
1438 const auto& tgt_chunk = tgt_image[i];
1439 const auto& src_chunk = src_image[i];
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001440
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001441 if (PatchChunk::RawDataIsSmaller(tgt_chunk, 0)) {
1442 patch_chunks.emplace_back(tgt_chunk);
1443 continue;
Doug Zongker512536a2010-02-17 16:11:44 -08001444 }
1445
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001446 std::vector<uint8_t> patch_data;
1447 if (!ImageChunk::MakePatch(tgt_chunk, src_chunk, &patch_data, nullptr)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001448 LOG(ERROR) << "Failed to generate patch for target chunk " << i;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001449 return false;
Doug Zongker512536a2010-02-17 16:11:44 -08001450 }
Tianjie Xu6e293c92017-11-15 16:26:41 -08001451 LOG(INFO) << "patch " << i << " is " << patch_data.size() << " bytes (of "
1452 << tgt_chunk.GetRawDataLength() << ")";
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001453
1454 if (PatchChunk::RawDataIsSmaller(tgt_chunk, patch_data.size())) {
1455 patch_chunks.emplace_back(tgt_chunk);
1456 } else {
1457 patch_chunks.emplace_back(tgt_chunk, src_chunk, std::move(patch_data));
1458 }
Doug Zongker512536a2010-02-17 16:11:44 -08001459 }
Doug Zongker512536a2010-02-17 16:11:44 -08001460
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001461 CHECK_EQ(tgt_image.NumOfChunks(), patch_chunks.size());
1462
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001463 android::base::unique_fd patch_fd(
1464 open(patch_name.c_str(), O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR));
1465 if (patch_fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001466 PLOG(ERROR) << "Failed to open " << patch_name;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001467 return false;
Doug Zongker512536a2010-02-17 16:11:44 -08001468 }
Doug Zongker512536a2010-02-17 16:11:44 -08001469
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001470 return PatchChunk::WritePatchDataToFd(patch_chunks, patch_fd);
Doug Zongker512536a2010-02-17 16:11:44 -08001471}
1472
Tao Bao97555da2016-12-15 10:15:06 -08001473int imgdiff(int argc, const char** argv) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001474 bool verbose = false;
Tao Bao97555da2016-12-15 10:15:06 -08001475 bool zip_mode = false;
Tianjie Xu1ea84d62017-02-22 18:23:58 -08001476 std::vector<uint8_t> bonus_data;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001477 size_t blocks_limit = 0;
Tianjie Xu82582b42017-08-31 18:05:19 -07001478 std::string split_info_file;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001479 std::string debug_dir;
Tianjie Xu12b90552017-03-07 14:44:14 -08001480
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001481 int opt;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001482 int option_index;
Tianjie Xu6e293c92017-11-15 16:26:41 -08001483 optind = 0; // Reset the getopt state so that we can call it multiple times for test.
Doug Zongkera3ccba62012-08-20 15:28:02 -07001484
Tianjie Xu6e293c92017-11-15 16:26:41 -08001485 while ((opt = getopt_long(argc, const_cast<char**>(argv), "zb:v", OPTIONS, &option_index)) !=
1486 -1) {
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001487 switch (opt) {
1488 case 'z':
1489 zip_mode = true;
1490 break;
1491 case 'b': {
1492 android::base::unique_fd fd(open(optarg, O_RDONLY));
1493 if (fd == -1) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001494 PLOG(ERROR) << "Failed to open bonus file " << optarg;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001495 return 1;
1496 }
1497 struct stat st;
1498 if (fstat(fd, &st) != 0) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001499 PLOG(ERROR) << "Failed to stat bonus file " << optarg;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001500 return 1;
1501 }
1502
1503 size_t bonus_size = st.st_size;
1504 bonus_data.resize(bonus_size);
1505 if (!android::base::ReadFully(fd, bonus_data.data(), bonus_size)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001506 PLOG(ERROR) << "Failed to read bonus file " << optarg;
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001507 return 1;
1508 }
1509 break;
1510 }
Tianjie Xu6e293c92017-11-15 16:26:41 -08001511 case 'v':
1512 verbose = true;
1513 break;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001514 case 0: {
1515 std::string name = OPTIONS[option_index].name;
1516 if (name == "block-limit" && !android::base::ParseUint(optarg, &blocks_limit)) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001517 LOG(ERROR) << "Failed to parse size blocks_limit: " << optarg;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001518 return 1;
Tianjie Xu82582b42017-08-31 18:05:19 -07001519 } else if (name == "split-info") {
1520 split_info_file = optarg;
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001521 } else if (name == "debug-dir") {
1522 debug_dir = optarg;
1523 }
1524 break;
1525 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001526 default:
Tianjie Xu6e293c92017-11-15 16:26:41 -08001527 LOG(ERROR) << "unexpected opt: " << static_cast<char>(opt);
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001528 return 2;
1529 }
Doug Zongkera3ccba62012-08-20 15:28:02 -07001530 }
1531
Tianjie Xu6e293c92017-11-15 16:26:41 -08001532 if (!verbose) {
1533 android::base::SetMinimumLogSeverity(android::base::WARNING);
1534 }
1535
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001536 if (argc - optind != 3) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001537 LOG(ERROR) << "usage: " << argv[0] << " [options] <src-img> <tgt-img> <patch-file>";
1538 LOG(ERROR)
1539 << " -z <zip-mode>, Generate patches in zip mode, src and tgt should be zip files.\n"
1540 " -b <bonus-file>, Bonus file in addition to src, image mode only.\n"
1541 " --block-limit, For large zips, split the src and tgt based on the block limit;\n"
1542 " and generate patches between each pair of pieces. Concatenate "
1543 "these\n"
1544 " patches together and output them into <patch-file>.\n"
1545 " --split-info, Output the split information (patch_size, tgt_size, src_ranges);\n"
1546 " zip mode with block-limit only.\n"
Tianjie Xu572abbb2018-02-22 15:40:39 -08001547 " --debug-dir, Debug directory to put the split srcs and patches, zip mode only.\n"
Tianjie Xu6e293c92017-11-15 16:26:41 -08001548 " -v, --verbose, Enable verbose logging.";
Doug Zongkera3ccba62012-08-20 15:28:02 -07001549 return 2;
1550 }
Doug Zongker512536a2010-02-17 16:11:44 -08001551
Doug Zongker512536a2010-02-17 16:11:44 -08001552 if (zip_mode) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001553 ZipModeImage src_image(true, blocks_limit * BLOCK_SIZE);
1554 ZipModeImage tgt_image(false, blocks_limit * BLOCK_SIZE);
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001555
1556 if (!src_image.Initialize(argv[optind])) {
Doug Zongker512536a2010-02-17 16:11:44 -08001557 return 1;
1558 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001559 if (!tgt_image.Initialize(argv[optind + 1])) {
1560 return 1;
1561 }
1562
1563 if (!ZipModeImage::CheckAndProcessChunks(&tgt_image, &src_image)) {
1564 return 1;
1565 }
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001566
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001567 // Compute bsdiff patches for each chunk's data (the uncompressed data, in the case of
1568 // deflate chunks).
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001569 if (blocks_limit > 0) {
Tianjie Xu82582b42017-08-31 18:05:19 -07001570 if (split_info_file.empty()) {
Tianjie Xu6e293c92017-11-15 16:26:41 -08001571 LOG(ERROR) << "split-info path cannot be empty when generating patches with a block-limit";
Tianjie Xu82582b42017-08-31 18:05:19 -07001572 return 1;
1573 }
1574
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001575 std::vector<ZipModeImage> split_tgt_images;
1576 std::vector<ZipModeImage> split_src_images;
1577 std::vector<SortedRangeSet> split_src_ranges;
1578 ZipModeImage::SplitZipModeImageWithLimit(tgt_image, src_image, &split_tgt_images,
1579 &split_src_images, &split_src_ranges);
1580
1581 if (!ZipModeImage::GeneratePatches(split_tgt_images, split_src_images, split_src_ranges,
Tianjie Xu82582b42017-08-31 18:05:19 -07001582 argv[optind + 2], split_info_file, debug_dir)) {
Tianjie Xu2903cdd2017-08-18 18:15:47 -07001583 return 1;
1584 }
1585
1586 } else if (!ZipModeImage::GeneratePatches(tgt_image, src_image, argv[optind + 2])) {
Doug Zongker512536a2010-02-17 16:11:44 -08001587 return 1;
1588 }
1589 } else {
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001590 ImageModeImage src_image(true);
1591 ImageModeImage tgt_image(false);
1592
1593 if (!src_image.Initialize(argv[optind])) {
Doug Zongker512536a2010-02-17 16:11:44 -08001594 return 1;
1595 }
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001596 if (!tgt_image.Initialize(argv[optind + 1])) {
Doug Zongker512536a2010-02-17 16:11:44 -08001597 return 1;
1598 }
1599
Tianjie Xu6b03ba72017-07-19 14:16:30 -07001600 if (!ImageModeImage::CheckAndProcessChunks(&tgt_image, &src_image)) {
Doug Zongker512536a2010-02-17 16:11:44 -08001601 return 1;
1602 }
Tianjie Xud82a2ed2017-08-08 17:35:01 -07001603
1604 if (!bonus_data.empty() && !src_image.SetBonusData(bonus_data)) {
1605 return 1;
1606 }
1607
1608 if (!ImageModeImage::GeneratePatches(tgt_image, src_image, argv[optind + 2])) {
Doug Zongker512536a2010-02-17 16:11:44 -08001609 return 1;
1610 }
1611 }
1612
Doug Zongker512536a2010-02-17 16:11:44 -08001613 return 0;
1614}