blob: 62de726a470c7f5941cb7be7691d1771b44f7242 [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/*
18 * This program constructs binary patches for images -- such as boot.img
19 * and recovery.img -- that consist primarily of large chunks of gzipped
20 * data interspersed with uncompressed data. Doing a naive bsdiff of
21 * these files is not useful because small changes in the data lead to
22 * large changes in the compressed bitstream; bsdiff patches of gzipped
23 * data are typically as large as the data itself.
24 *
25 * To patch these usefully, we break the source and target images up into
26 * chunks of two types: "normal" and "gzip". Normal chunks are simply
27 * patched using a plain bsdiff. Gzip chunks are first expanded, then a
28 * bsdiff is applied to the uncompressed data, then the patched data is
29 * gzipped using the same encoder parameters. Patched chunks are
30 * concatenated together to create the output file; the output image
31 * should be *exactly* the same series of bytes as the target image used
32 * originally to generate the patch.
33 *
34 * To work well with this tool, the gzipped sections of the target
35 * image must have been generated using the same deflate encoder that
36 * is available in applypatch, namely, the one in the zlib library.
37 * In practice this means that images should be compressed using the
38 * "minigzip" tool included in the zlib distribution, not the GNU gzip
39 * program.
40 *
41 * An "imgdiff" patch consists of a header describing the chunk structure
42 * of the file and any encoding parameters needed for the gzipped
43 * chunks, followed by N bsdiff patches, one per chunk.
44 *
45 * For a diff to be generated, the source and target images must have the
46 * same "chunk" structure: that is, the same number of gzipped and normal
47 * chunks in the same order. Android boot and recovery images currently
48 * consist of five chunks: a small normal header, a gzipped kernel, a
49 * small normal section, a gzipped ramdisk, and finally a small normal
50 * footer.
51 *
52 * Caveats: we locate gzipped sections within the source and target
53 * images by searching for the byte sequence 1f8b0800: 1f8b is the gzip
54 * magic number; 08 specifies the "deflate" encoding [the only encoding
55 * supported by the gzip standard]; and 00 is the flags byte. We do not
56 * currently support any extra header fields (which would be indicated by
57 * a nonzero flags byte). We also don't handle the case when that byte
58 * sequence appears spuriously in the file. (Note that it would have to
59 * occur spuriously within a normal chunk to be a problem.)
60 *
61 *
62 * The imgdiff patch header looks like this:
63 *
64 * "IMGDIFF1" (8) [magic number and version]
65 * chunk count (4)
66 * for each chunk:
67 * chunk type (4) [CHUNK_{NORMAL, GZIP, DEFLATE, RAW}]
68 * if chunk type == CHUNK_NORMAL:
69 * source start (8)
70 * source len (8)
71 * bsdiff patch offset (8) [from start of patch file]
72 * if chunk type == CHUNK_GZIP: (version 1 only)
73 * source start (8)
74 * source len (8)
75 * bsdiff patch offset (8) [from start of patch file]
76 * source expanded len (8) [size of uncompressed source]
77 * target expected len (8) [size of uncompressed target]
78 * gzip level (4)
79 * method (4)
80 * windowBits (4)
81 * memLevel (4)
82 * strategy (4)
83 * gzip header len (4)
84 * gzip header (gzip header len)
85 * gzip footer (8)
86 * if chunk type == CHUNK_DEFLATE: (version 2 only)
87 * source start (8)
88 * source len (8)
89 * bsdiff patch offset (8) [from start of patch file]
90 * source expanded len (8) [size of uncompressed source]
91 * target expected len (8) [size of uncompressed target]
92 * gzip level (4)
93 * method (4)
94 * windowBits (4)
95 * memLevel (4)
96 * strategy (4)
97 * if chunk type == RAW: (version 2 only)
98 * target len (4)
99 * data (target len)
100 *
101 * All integers are little-endian. "source start" and "source len"
102 * specify the section of the input image that comprises this chunk,
103 * including the gzip header and footer for gzip chunks. "source
104 * expanded len" is the size of the uncompressed source data. "target
105 * expected len" is the size of the uncompressed data after applying
106 * the bsdiff patch. The next five parameters specify the zlib
107 * parameters to be used when compressing the patched data, and the
108 * next three specify the header and footer to be wrapped around the
109 * compressed data to create the output chunk (so that header contents
110 * like the timestamp are recreated exactly).
111 *
112 * After the header there are 'chunk count' bsdiff patches; the offset
113 * of each from the beginning of the file is specified in the header.
Doug Zongkera3ccba62012-08-20 15:28:02 -0700114 *
115 * This tool can take an optional file of "bonus data". This is an
116 * extra file of data that is appended to chunk #1 after it is
117 * compressed (it must be a CHUNK_DEFLATE chunk). The same file must
118 * be available (and passed to applypatch with -b) when applying the
119 * patch. This is used to reduce the size of recovery-from-boot
120 * patches by combining the boot image with recovery ramdisk
121 * information that is stored on the system partition.
Doug Zongker512536a2010-02-17 16:11:44 -0800122 */
123
Tao Bao97555da2016-12-15 10:15:06 -0800124#include "applypatch/imgdiff.h"
125
Doug Zongker512536a2010-02-17 16:11:44 -0800126#include <errno.h>
Tao Baod37ce8f2016-12-17 17:10:04 -0800127#include <fcntl.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800128#include <stdio.h>
129#include <stdlib.h>
130#include <string.h>
131#include <sys/stat.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800132#include <sys/types.h>
Tao Bao97555da2016-12-15 10:15:06 -0800133#include <unistd.h>
Doug Zongker512536a2010-02-17 16:11:44 -0800134
Tao Baod37ce8f2016-12-17 17:10:04 -0800135#include <android-base/file.h>
136#include <android-base/unique_fd.h>
137
Sen Jiang2fffcb12016-05-03 15:49:10 -0700138#include <bsdiff.h>
Tao Bao97555da2016-12-15 10:15:06 -0800139#include <zlib.h>
Sen Jiang2fffcb12016-05-03 15:49:10 -0700140
Doug Zongker512536a2010-02-17 16:11:44 -0800141#include "utils.h"
142
143typedef struct {
144 int type; // CHUNK_NORMAL, CHUNK_DEFLATE
145 size_t start; // offset of chunk in original image file
146
147 size_t len;
148 unsigned char* data; // data to be patched (uncompressed, for deflate chunks)
149
150 size_t source_start;
151 size_t source_len;
152
Doug Zongker512536a2010-02-17 16:11:44 -0800153 // --- for CHUNK_DEFLATE chunks only: ---
154
155 // original (compressed) deflate data
156 size_t deflate_len;
157 unsigned char* deflate_data;
158
159 char* filename; // used for zip entries
160
161 // deflate encoder parameters
162 int level, method, windowBits, memLevel, strategy;
163
164 size_t source_uncompressed_len;
165} ImageChunk;
166
167typedef struct {
168 int data_offset;
169 int deflate_len;
170 int uncomp_len;
171 char* filename;
172} ZipFileEntry;
173
Tao Baoa0c40112016-06-01 13:15:44 -0700174static int fileentry_compare(const void* a, const void* b) {
175 int ao = ((ZipFileEntry*)a)->data_offset;
176 int bo = ((ZipFileEntry*)b)->data_offset;
177 if (ao < bo) {
178 return -1;
179 } else if (ao > bo) {
180 return 1;
181 } else {
182 return 0;
183 }
Doug Zongker512536a2010-02-17 16:11:44 -0800184}
185
Doug Zongker512536a2010-02-17 16:11:44 -0800186unsigned char* ReadZip(const char* filename,
187 int* num_chunks, ImageChunk** chunks,
188 int include_pseudo_chunk) {
189 struct stat st;
190 if (stat(filename, &st) != 0) {
191 printf("failed to stat \"%s\": %s\n", filename, strerror(errno));
192 return NULL;
193 }
194
Tao Baoba9a42a2015-06-23 23:23:33 -0700195 size_t sz = static_cast<size_t>(st.st_size);
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800196 unsigned char* img = static_cast<unsigned char*>(malloc(sz));
Doug Zongker512536a2010-02-17 16:11:44 -0800197 FILE* f = fopen(filename, "rb");
Tao Baoa0c40112016-06-01 13:15:44 -0700198 if (fread(img, 1, sz, f) != sz) {
Doug Zongker512536a2010-02-17 16:11:44 -0800199 printf("failed to read \"%s\" %s\n", filename, strerror(errno));
200 fclose(f);
201 return NULL;
202 }
203 fclose(f);
204
205 // look for the end-of-central-directory record.
206
207 int i;
208 for (i = st.st_size-20; i >= 0 && i > st.st_size - 65600; --i) {
209 if (img[i] == 0x50 && img[i+1] == 0x4b &&
210 img[i+2] == 0x05 && img[i+3] == 0x06) {
211 break;
212 }
213 }
214 // double-check: this archive consists of a single "disk"
215 if (!(img[i+4] == 0 && img[i+5] == 0 && img[i+6] == 0 && img[i+7] == 0)) {
216 printf("can't process multi-disk archive\n");
217 return NULL;
218 }
219
Tao Baoa0c40112016-06-01 13:15:44 -0700220 int cdcount = Read2(img+i+8);
221 int cdoffset = Read4(img+i+16);
Doug Zongker512536a2010-02-17 16:11:44 -0800222
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800223 ZipFileEntry* temp_entries = static_cast<ZipFileEntry*>(malloc(
Tao Baoa0c40112016-06-01 13:15:44 -0700224 cdcount * sizeof(ZipFileEntry)));
Doug Zongker512536a2010-02-17 16:11:44 -0800225 int entrycount = 0;
226
Tao Baoa0c40112016-06-01 13:15:44 -0700227 unsigned char* cd = img+cdoffset;
Doug Zongker512536a2010-02-17 16:11:44 -0800228 for (i = 0; i < cdcount; ++i) {
229 if (!(cd[0] == 0x50 && cd[1] == 0x4b && cd[2] == 0x01 && cd[3] == 0x02)) {
230 printf("bad central directory entry %d\n", i);
Rahul Chaudhry3a5177b2016-11-15 16:18:46 -0800231 free(temp_entries);
Doug Zongker512536a2010-02-17 16:11:44 -0800232 return NULL;
233 }
234
235 int clen = Read4(cd+20); // compressed len
236 int ulen = Read4(cd+24); // uncompressed len
237 int nlen = Read2(cd+28); // filename len
238 int xlen = Read2(cd+30); // extra field len
239 int mlen = Read2(cd+32); // file comment len
240 int hoffset = Read4(cd+42); // local header offset
241
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800242 char* filename = static_cast<char*>(malloc(nlen+1));
Doug Zongker512536a2010-02-17 16:11:44 -0800243 memcpy(filename, cd+46, nlen);
244 filename[nlen] = '\0';
245
246 int method = Read2(cd+10);
247
248 cd += 46 + nlen + xlen + mlen;
249
250 if (method != 8) { // 8 == deflate
251 free(filename);
252 continue;
253 }
254
Tao Baoa0c40112016-06-01 13:15:44 -0700255 unsigned char* lh = img + hoffset;
Doug Zongker512536a2010-02-17 16:11:44 -0800256
257 if (!(lh[0] == 0x50 && lh[1] == 0x4b && lh[2] == 0x03 && lh[3] == 0x04)) {
258 printf("bad local file header entry %d\n", i);
259 return NULL;
260 }
261
262 if (Read2(lh+26) != nlen || memcmp(lh+30, filename, nlen) != 0) {
263 printf("central dir filename doesn't match local header\n");
264 return NULL;
265 }
266
267 xlen = Read2(lh+28); // extra field len; might be different from CD entry?
268
269 temp_entries[entrycount].data_offset = hoffset+30+nlen+xlen;
270 temp_entries[entrycount].deflate_len = clen;
271 temp_entries[entrycount].uncomp_len = ulen;
272 temp_entries[entrycount].filename = filename;
273 ++entrycount;
274 }
275
Tao Baoa0c40112016-06-01 13:15:44 -0700276 qsort(temp_entries, entrycount, sizeof(ZipFileEntry), fileentry_compare);
Doug Zongker512536a2010-02-17 16:11:44 -0800277
278#if 0
279 printf("found %d deflated entries\n", entrycount);
280 for (i = 0; i < entrycount; ++i) {
281 printf("off %10d len %10d unlen %10d %p %s\n",
282 temp_entries[i].data_offset,
283 temp_entries[i].deflate_len,
284 temp_entries[i].uncomp_len,
285 temp_entries[i].filename,
286 temp_entries[i].filename);
287 }
288#endif
289
290 *num_chunks = 0;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800291 *chunks = static_cast<ImageChunk*>(malloc((entrycount*2+2) * sizeof(ImageChunk)));
Doug Zongker512536a2010-02-17 16:11:44 -0800292 ImageChunk* curr = *chunks;
293
294 if (include_pseudo_chunk) {
295 curr->type = CHUNK_NORMAL;
296 curr->start = 0;
297 curr->len = st.st_size;
Tao Baoa0c40112016-06-01 13:15:44 -0700298 curr->data = img;
Doug Zongker512536a2010-02-17 16:11:44 -0800299 curr->filename = NULL;
Doug Zongker512536a2010-02-17 16:11:44 -0800300 ++curr;
301 ++*num_chunks;
302 }
303
304 int pos = 0;
305 int nextentry = 0;
306
307 while (pos < st.st_size) {
308 if (nextentry < entrycount && pos == temp_entries[nextentry].data_offset) {
309 curr->type = CHUNK_DEFLATE;
310 curr->start = pos;
311 curr->deflate_len = temp_entries[nextentry].deflate_len;
Tao Baoa0c40112016-06-01 13:15:44 -0700312 curr->deflate_data = img + pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800313 curr->filename = temp_entries[nextentry].filename;
Doug Zongker512536a2010-02-17 16:11:44 -0800314
315 curr->len = temp_entries[nextentry].uncomp_len;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800316 curr->data = static_cast<unsigned char*>(malloc(curr->len));
Doug Zongker512536a2010-02-17 16:11:44 -0800317
318 z_stream strm;
319 strm.zalloc = Z_NULL;
320 strm.zfree = Z_NULL;
321 strm.opaque = Z_NULL;
322 strm.avail_in = curr->deflate_len;
323 strm.next_in = curr->deflate_data;
324
325 // -15 means we are decoding a 'raw' deflate stream; zlib will
326 // not expect zlib headers.
327 int ret = inflateInit2(&strm, -15);
Rahul Chaudhrya793c582016-11-29 17:10:14 -0800328 if (ret < 0) {
329 printf("failed to initialize inflate: %d\n", ret);
330 return NULL;
331 }
Doug Zongker512536a2010-02-17 16:11:44 -0800332
333 strm.avail_out = curr->len;
334 strm.next_out = curr->data;
335 ret = inflate(&strm, Z_NO_FLUSH);
336 if (ret != Z_STREAM_END) {
337 printf("failed to inflate \"%s\"; %d\n", curr->filename, ret);
338 return NULL;
339 }
340
341 inflateEnd(&strm);
342
343 pos += curr->deflate_len;
344 ++nextentry;
345 ++*num_chunks;
346 ++curr;
347 continue;
348 }
349
350 // use a normal chunk to take all the data up to the start of the
351 // next deflate section.
352
353 curr->type = CHUNK_NORMAL;
354 curr->start = pos;
355 if (nextentry < entrycount) {
356 curr->len = temp_entries[nextentry].data_offset - pos;
357 } else {
358 curr->len = st.st_size - pos;
359 }
Tao Baoa0c40112016-06-01 13:15:44 -0700360 curr->data = img + pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800361 curr->filename = NULL;
Doug Zongker512536a2010-02-17 16:11:44 -0800362 pos += curr->len;
363
364 ++*num_chunks;
365 ++curr;
366 }
367
Tao Baoa0c40112016-06-01 13:15:44 -0700368 free(temp_entries);
369 return img;
Doug Zongker512536a2010-02-17 16:11:44 -0800370}
371
372/*
373 * Read the given file and break it up into chunks, putting the number
374 * of chunks and their info in *num_chunks and **chunks,
375 * respectively. Returns a malloc'd block of memory containing the
376 * contents of the file; various pointers in the output chunk array
377 * will point into this block of memory. The caller should free the
378 * return value when done with all the chunks. Returns NULL on
379 * failure.
380 */
Tao Bao97555da2016-12-15 10:15:06 -0800381unsigned char* ReadImage(const char* filename, int* num_chunks, ImageChunk** chunks) {
Doug Zongker512536a2010-02-17 16:11:44 -0800382 struct stat st;
383 if (stat(filename, &st) != 0) {
384 printf("failed to stat \"%s\": %s\n", filename, strerror(errno));
385 return NULL;
386 }
387
Tao Baoba9a42a2015-06-23 23:23:33 -0700388 size_t sz = static_cast<size_t>(st.st_size);
Tao Baod37ce8f2016-12-17 17:10:04 -0800389 unsigned char* img = static_cast<unsigned char*>(malloc(sz));
390 android::base::unique_fd fd(open(filename, O_RDONLY));
391 if (!android::base::ReadFully(fd, img, sz)) {
Doug Zongker512536a2010-02-17 16:11:44 -0800392 printf("failed to read \"%s\" %s\n", filename, strerror(errno));
Tao Baod37ce8f2016-12-17 17:10:04 -0800393 return nullptr;
Doug Zongker512536a2010-02-17 16:11:44 -0800394 }
Doug Zongker512536a2010-02-17 16:11:44 -0800395
396 size_t pos = 0;
397
398 *num_chunks = 0;
399 *chunks = NULL;
400
Tao Baoba9a42a2015-06-23 23:23:33 -0700401 while (pos < sz) {
Tao Bao97555da2016-12-15 10:15:06 -0800402 unsigned char* p = img + pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800403
Tao Baoba9a42a2015-06-23 23:23:33 -0700404 if (sz - pos >= 4 &&
Doug Zongker512536a2010-02-17 16:11:44 -0800405 p[0] == 0x1f && p[1] == 0x8b &&
406 p[2] == 0x08 && // deflate compression
407 p[3] == 0x00) { // no header flags
408 // 'pos' is the offset of the start of a gzip chunk.
Johan Redestigc68bd342015-04-14 21:20:06 +0200409 size_t chunk_offset = pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800410
411 *num_chunks += 3;
Tao Bao97555da2016-12-15 10:15:06 -0800412 *chunks = static_cast<ImageChunk*>(realloc(*chunks, *num_chunks * sizeof(ImageChunk)));
Doug Zongker512536a2010-02-17 16:11:44 -0800413 ImageChunk* curr = *chunks + (*num_chunks-3);
414
415 // create a normal chunk for the header.
416 curr->start = pos;
417 curr->type = CHUNK_NORMAL;
418 curr->len = GZIP_HEADER_LEN;
419 curr->data = p;
Doug Zongker512536a2010-02-17 16:11:44 -0800420
421 pos += curr->len;
422 p += curr->len;
423 ++curr;
424
425 curr->type = CHUNK_DEFLATE;
426 curr->filename = NULL;
Doug Zongker512536a2010-02-17 16:11:44 -0800427
428 // We must decompress this chunk in order to discover where it
429 // ends, and so we can put the uncompressed data and its length
430 // into curr->data and curr->len.
431
432 size_t allocated = 32768;
433 curr->len = 0;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800434 curr->data = static_cast<unsigned char*>(malloc(allocated));
Doug Zongker512536a2010-02-17 16:11:44 -0800435 curr->start = pos;
436 curr->deflate_data = p;
437
438 z_stream strm;
439 strm.zalloc = Z_NULL;
440 strm.zfree = Z_NULL;
441 strm.opaque = Z_NULL;
Tao Baoba9a42a2015-06-23 23:23:33 -0700442 strm.avail_in = sz - pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800443 strm.next_in = p;
444
445 // -15 means we are decoding a 'raw' deflate stream; zlib will
446 // not expect zlib headers.
447 int ret = inflateInit2(&strm, -15);
Rahul Chaudhrya793c582016-11-29 17:10:14 -0800448 if (ret < 0) {
449 printf("failed to initialize inflate: %d\n", ret);
450 return NULL;
451 }
Doug Zongker512536a2010-02-17 16:11:44 -0800452
453 do {
454 strm.avail_out = allocated - curr->len;
455 strm.next_out = curr->data + curr->len;
456 ret = inflate(&strm, Z_NO_FLUSH);
Johan Redestigc68bd342015-04-14 21:20:06 +0200457 if (ret < 0) {
Sen Jiangfa4f1b72016-02-11 16:14:23 -0800458 printf("Warning: inflate failed [%s] at offset [%zu],"
459 " treating as a normal chunk\n",
David Riley0779fc92015-12-10 10:18:25 -0800460 strm.msg, chunk_offset);
Sen Jiangfa4f1b72016-02-11 16:14:23 -0800461 break;
Johan Redestigc68bd342015-04-14 21:20:06 +0200462 }
Doug Zongker512536a2010-02-17 16:11:44 -0800463 curr->len = allocated - strm.avail_out;
464 if (strm.avail_out == 0) {
465 allocated *= 2;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800466 curr->data = static_cast<unsigned char*>(realloc(curr->data, allocated));
Doug Zongker512536a2010-02-17 16:11:44 -0800467 }
468 } while (ret != Z_STREAM_END);
469
Tao Baoba9a42a2015-06-23 23:23:33 -0700470 curr->deflate_len = sz - strm.avail_in - pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800471 inflateEnd(&strm);
Sen Jiangfa4f1b72016-02-11 16:14:23 -0800472
473 if (ret < 0) {
474 free(curr->data);
475 *num_chunks -= 2;
476 continue;
477 }
478
Doug Zongker512536a2010-02-17 16:11:44 -0800479 pos += curr->deflate_len;
480 p += curr->deflate_len;
481 ++curr;
482
483 // create a normal chunk for the footer
484
485 curr->type = CHUNK_NORMAL;
486 curr->start = pos;
487 curr->len = GZIP_FOOTER_LEN;
Tao Baoa0c40112016-06-01 13:15:44 -0700488 curr->data = img+pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800489
490 pos += curr->len;
491 p += curr->len;
492 ++curr;
493
494 // The footer (that we just skipped over) contains the size of
495 // the uncompressed data. Double-check to make sure that it
496 // matches the size of the data we got when we actually did
497 // the decompression.
498 size_t footer_size = Read4(p-4);
499 if (footer_size != curr[-2].len) {
Tao Bao97555da2016-12-15 10:15:06 -0800500 printf("Error: footer size %zu != decompressed size %zu\n", footer_size, curr[-2].len);
Tao Baoa0c40112016-06-01 13:15:44 -0700501 free(img);
Doug Zongker512536a2010-02-17 16:11:44 -0800502 return NULL;
503 }
504 } else {
505 // Reallocate the list for every chunk; we expect the number of
506 // chunks to be small (5 for typical boot and recovery images).
507 ++*num_chunks;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800508 *chunks = static_cast<ImageChunk*>(realloc(*chunks, *num_chunks * sizeof(ImageChunk)));
Doug Zongker512536a2010-02-17 16:11:44 -0800509 ImageChunk* curr = *chunks + (*num_chunks-1);
510 curr->start = pos;
Doug Zongker512536a2010-02-17 16:11:44 -0800511
512 // 'pos' is not the offset of the start of a gzip chunk, so scan
513 // forward until we find a gzip header.
514 curr->type = CHUNK_NORMAL;
515 curr->data = p;
516
Tao Baoba9a42a2015-06-23 23:23:33 -0700517 for (curr->len = 0; curr->len < (sz - pos); ++curr->len) {
Tao Baod37ce8f2016-12-17 17:10:04 -0800518 if (sz - pos >= 4 && p[curr->len] == 0x1f && p[curr->len + 1] == 0x8b &&
519 p[curr->len + 2] == 0x08 && p[curr->len + 3] == 0x00) {
Doug Zongker512536a2010-02-17 16:11:44 -0800520 break;
521 }
522 }
523 pos += curr->len;
524 }
525 }
526
Tao Baoa0c40112016-06-01 13:15:44 -0700527 return img;
Doug Zongker512536a2010-02-17 16:11:44 -0800528}
529
530#define BUFFER_SIZE 32768
531
532/*
533 * Takes the uncompressed data stored in the chunk, compresses it
534 * using the zlib parameters stored in the chunk, and checks that it
535 * matches exactly the compressed data we started with (also stored in
536 * the chunk). Return 0 on success.
537 */
538int TryReconstruction(ImageChunk* chunk, unsigned char* out) {
539 size_t p = 0;
540
541#if 0
542 printf("trying %d %d %d %d %d\n",
543 chunk->level, chunk->method, chunk->windowBits,
544 chunk->memLevel, chunk->strategy);
545#endif
546
547 z_stream strm;
548 strm.zalloc = Z_NULL;
549 strm.zfree = Z_NULL;
550 strm.opaque = Z_NULL;
551 strm.avail_in = chunk->len;
552 strm.next_in = chunk->data;
553 int ret;
554 ret = deflateInit2(&strm, chunk->level, chunk->method, chunk->windowBits,
555 chunk->memLevel, chunk->strategy);
Rahul Chaudhrya793c582016-11-29 17:10:14 -0800556 if (ret < 0) {
557 printf("failed to initialize deflate: %d\n", ret);
558 return -1;
559 }
Doug Zongker512536a2010-02-17 16:11:44 -0800560 do {
561 strm.avail_out = BUFFER_SIZE;
562 strm.next_out = out;
563 ret = deflate(&strm, Z_FINISH);
Rahul Chaudhrya793c582016-11-29 17:10:14 -0800564 if (ret < 0) {
565 printf("failed to deflate: %d\n", ret);
566 return -1;
567 }
Doug Zongker512536a2010-02-17 16:11:44 -0800568 size_t have = BUFFER_SIZE - strm.avail_out;
569
570 if (memcmp(out, chunk->deflate_data+p, have) != 0) {
571 // mismatch; data isn't the same.
572 deflateEnd(&strm);
573 return -1;
574 }
575 p += have;
576 } while (ret != Z_STREAM_END);
577 deflateEnd(&strm);
578 if (p != chunk->deflate_len) {
579 // mismatch; ran out of data before we should have.
580 return -1;
581 }
582 return 0;
583}
584
585/*
586 * Verify that we can reproduce exactly the same compressed data that
587 * we started with. Sets the level, method, windowBits, memLevel, and
588 * strategy fields in the chunk to the encoding parameters needed to
589 * produce the right output. Returns 0 on success.
590 */
591int ReconstructDeflateChunk(ImageChunk* chunk) {
592 if (chunk->type != CHUNK_DEFLATE) {
593 printf("attempt to reconstruct non-deflate chunk\n");
594 return -1;
595 }
596
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800597 unsigned char* out = static_cast<unsigned char*>(malloc(BUFFER_SIZE));
Doug Zongker512536a2010-02-17 16:11:44 -0800598
599 // We only check two combinations of encoder parameters: level 6
600 // (the default) and level 9 (the maximum).
601 for (chunk->level = 6; chunk->level <= 9; chunk->level += 3) {
602 chunk->windowBits = -15; // 32kb window; negative to indicate a raw stream.
603 chunk->memLevel = 8; // the default value.
604 chunk->method = Z_DEFLATED;
605 chunk->strategy = Z_DEFAULT_STRATEGY;
606
607 if (TryReconstruction(chunk, out) == 0) {
608 free(out);
609 return 0;
610 }
611 }
612
613 free(out);
614 return -1;
615}
616
617/*
618 * Given source and target chunks, compute a bsdiff patch between them
619 * by running bsdiff in a subprocess. Return the patch data, placing
620 * its length in *size. Return NULL on failure. We expect the bsdiff
621 * program to be in the path.
622 */
623unsigned char* MakePatch(ImageChunk* src, ImageChunk* tgt, size_t* size) {
624 if (tgt->type == CHUNK_NORMAL) {
625 if (tgt->len <= 160) {
626 tgt->type = CHUNK_RAW;
627 *size = tgt->len;
628 return tgt->data;
629 }
630 }
631
Tao Bao97555da2016-12-15 10:15:06 -0800632#if defined(__ANDROID__)
633 char ptemp[] = "/data/local/tmp/imgdiff-patch-XXXXXX";
634#else
Doug Zongker512536a2010-02-17 16:11:44 -0800635 char ptemp[] = "/tmp/imgdiff-patch-XXXXXX";
Tao Bao97555da2016-12-15 10:15:06 -0800636#endif
Jeremy Compostellaa91c66d2015-09-08 19:15:09 +0200637 int fd = mkstemp(ptemp);
638
639 if (fd == -1) {
640 printf("MakePatch failed to create a temporary file: %s\n",
641 strerror(errno));
642 return NULL;
643 }
644 close(fd); // temporary file is created and we don't need its file
645 // descriptor
Doug Zongker512536a2010-02-17 16:11:44 -0800646
Sen Jiang2fffcb12016-05-03 15:49:10 -0700647 int r = bsdiff::bsdiff(src->data, src->len, tgt->data, tgt->len, ptemp);
Doug Zongker512536a2010-02-17 16:11:44 -0800648 if (r != 0) {
649 printf("bsdiff() failed: %d\n", r);
650 return NULL;
651 }
652
653 struct stat st;
654 if (stat(ptemp, &st) != 0) {
655 printf("failed to stat patch file %s: %s\n",
656 ptemp, strerror(errno));
657 return NULL;
658 }
659
Tao Baoba9a42a2015-06-23 23:23:33 -0700660 size_t sz = static_cast<size_t>(st.st_size);
Tao Baoa0c40112016-06-01 13:15:44 -0700661 // TODO: Memory leak on error return.
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800662 unsigned char* data = static_cast<unsigned char*>(malloc(sz));
Doug Zongker512536a2010-02-17 16:11:44 -0800663
Tao Baoba9a42a2015-06-23 23:23:33 -0700664 if (tgt->type == CHUNK_NORMAL && tgt->len <= sz) {
Doug Zongker512536a2010-02-17 16:11:44 -0800665 unlink(ptemp);
666
667 tgt->type = CHUNK_RAW;
668 *size = tgt->len;
669 return tgt->data;
670 }
671
Tao Baoba9a42a2015-06-23 23:23:33 -0700672 *size = sz;
Doug Zongker512536a2010-02-17 16:11:44 -0800673
674 FILE* f = fopen(ptemp, "rb");
675 if (f == NULL) {
676 printf("failed to open patch %s: %s\n", ptemp, strerror(errno));
677 return NULL;
678 }
Tao Baoa0c40112016-06-01 13:15:44 -0700679 if (fread(data, 1, sz, f) != sz) {
Doug Zongker512536a2010-02-17 16:11:44 -0800680 printf("failed to read patch %s: %s\n", ptemp, strerror(errno));
681 return NULL;
682 }
683 fclose(f);
684
685 unlink(ptemp);
686
687 tgt->source_start = src->start;
688 switch (tgt->type) {
689 case CHUNK_NORMAL:
690 tgt->source_len = src->len;
691 break;
692 case CHUNK_DEFLATE:
693 tgt->source_len = src->deflate_len;
694 tgt->source_uncompressed_len = src->len;
695 break;
696 }
697
Tao Baoa0c40112016-06-01 13:15:44 -0700698 return data;
Doug Zongker512536a2010-02-17 16:11:44 -0800699}
700
701/*
702 * Cause a gzip chunk to be treated as a normal chunk (ie, as a blob
703 * of uninterpreted data). The resulting patch will likely be about
704 * as big as the target file, but it lets us handle the case of images
705 * where some gzip chunks are reconstructible but others aren't (by
706 * treating the ones that aren't as normal chunks).
707 */
708void ChangeDeflateChunkToNormal(ImageChunk* ch) {
709 if (ch->type != CHUNK_DEFLATE) return;
710 ch->type = CHUNK_NORMAL;
711 free(ch->data);
712 ch->data = ch->deflate_data;
713 ch->len = ch->deflate_len;
714}
715
716/*
717 * Return true if the data in the chunk is identical (including the
718 * compressed representation, for gzip chunks).
719 */
720int AreChunksEqual(ImageChunk* a, ImageChunk* b) {
721 if (a->type != b->type) return 0;
722
723 switch (a->type) {
724 case CHUNK_NORMAL:
725 return a->len == b->len && memcmp(a->data, b->data, a->len) == 0;
726
727 case CHUNK_DEFLATE:
728 return a->deflate_len == b->deflate_len &&
729 memcmp(a->deflate_data, b->deflate_data, a->deflate_len) == 0;
730
731 default:
732 printf("unknown chunk type %d\n", a->type);
733 return 0;
734 }
735}
736
737/*
738 * Look for runs of adjacent normal chunks and compress them down into
739 * a single chunk. (Such runs can be produced when deflate chunks are
740 * changed to normal chunks.)
741 */
742void MergeAdjacentNormalChunks(ImageChunk* chunks, int* num_chunks) {
743 int out = 0;
744 int in_start = 0, in_end;
745 while (in_start < *num_chunks) {
746 if (chunks[in_start].type != CHUNK_NORMAL) {
747 in_end = in_start+1;
748 } else {
749 // in_start is a normal chunk. Look for a run of normal chunks
750 // that constitute a solid block of data (ie, each chunk begins
751 // where the previous one ended).
752 for (in_end = in_start+1;
753 in_end < *num_chunks && chunks[in_end].type == CHUNK_NORMAL &&
754 (chunks[in_end].start ==
755 chunks[in_end-1].start + chunks[in_end-1].len &&
756 chunks[in_end].data ==
757 chunks[in_end-1].data + chunks[in_end-1].len);
758 ++in_end);
759 }
760
761 if (in_end == in_start+1) {
762#if 0
763 printf("chunk %d is now %d\n", in_start, out);
764#endif
765 if (out != in_start) {
766 memcpy(chunks+out, chunks+in_start, sizeof(ImageChunk));
767 }
768 } else {
769#if 0
770 printf("collapse normal chunks %d-%d into %d\n", in_start, in_end-1, out);
771#endif
772
773 // Merge chunks [in_start, in_end-1] into one chunk. Since the
774 // data member of each chunk is just a pointer into an in-memory
775 // copy of the file, this can be done without recopying (the
776 // output chunk has the first chunk's start location and data
777 // pointer, and length equal to the sum of the input chunk
778 // lengths).
779 chunks[out].type = CHUNK_NORMAL;
780 chunks[out].start = chunks[in_start].start;
781 chunks[out].data = chunks[in_start].data;
782 chunks[out].len = chunks[in_end-1].len +
783 (chunks[in_end-1].start - chunks[in_start].start);
784 }
785
786 ++out;
787 in_start = in_end;
788 }
789 *num_chunks = out;
790}
791
Tao Bao97555da2016-12-15 10:15:06 -0800792ImageChunk* FindChunkByName(const char* name, ImageChunk* chunks, int num_chunks) {
793 for (int i = 0; i < num_chunks; ++i) {
Doug Zongker512536a2010-02-17 16:11:44 -0800794 if (chunks[i].type == CHUNK_DEFLATE && chunks[i].filename &&
795 strcmp(name, chunks[i].filename) == 0) {
796 return chunks+i;
797 }
798 }
799 return NULL;
800}
801
802void DumpChunks(ImageChunk* chunks, int num_chunks) {
Tao Baoba9a42a2015-06-23 23:23:33 -0700803 for (int i = 0; i < num_chunks; ++i) {
804 printf("chunk %d: type %d start %zu len %zu\n",
Doug Zongker512536a2010-02-17 16:11:44 -0800805 i, chunks[i].type, chunks[i].start, chunks[i].len);
806 }
807}
808
Tao Bao97555da2016-12-15 10:15:06 -0800809int imgdiff(int argc, const char** argv) {
810 bool zip_mode = false;
Doug Zongker512536a2010-02-17 16:11:44 -0800811
Doug Zongkera3ccba62012-08-20 15:28:02 -0700812 if (argc >= 2 && strcmp(argv[1], "-z") == 0) {
Tao Bao97555da2016-12-15 10:15:06 -0800813 zip_mode = true;
Doug Zongker512536a2010-02-17 16:11:44 -0800814 --argc;
815 ++argv;
816 }
817
Doug Zongkera3ccba62012-08-20 15:28:02 -0700818 size_t bonus_size = 0;
Tao Baoa0c40112016-06-01 13:15:44 -0700819 unsigned char* bonus_data = NULL;
Doug Zongkera3ccba62012-08-20 15:28:02 -0700820 if (argc >= 3 && strcmp(argv[1], "-b") == 0) {
821 struct stat st;
822 if (stat(argv[2], &st) != 0) {
823 printf("failed to stat bonus file %s: %s\n", argv[2], strerror(errno));
824 return 1;
825 }
826 bonus_size = st.st_size;
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800827 bonus_data = static_cast<unsigned char*>(malloc(bonus_size));
Doug Zongkera3ccba62012-08-20 15:28:02 -0700828 FILE* f = fopen(argv[2], "rb");
829 if (f == NULL) {
830 printf("failed to open bonus file %s: %s\n", argv[2], strerror(errno));
831 return 1;
832 }
Tao Baoa0c40112016-06-01 13:15:44 -0700833 if (fread(bonus_data, 1, bonus_size, f) != bonus_size) {
Doug Zongkera3ccba62012-08-20 15:28:02 -0700834 printf("failed to read bonus file %s: %s\n", argv[2], strerror(errno));
835 return 1;
836 }
837 fclose(f);
838
839 argc -= 2;
840 argv += 2;
841 }
842
843 if (argc != 4) {
Doug Zongkera3ccba62012-08-20 15:28:02 -0700844 printf("usage: %s [-z] [-b <bonus-file>] <src-img> <tgt-img> <patch-file>\n",
845 argv[0]);
846 return 2;
847 }
Doug Zongker512536a2010-02-17 16:11:44 -0800848
849 int num_src_chunks;
850 ImageChunk* src_chunks;
851 int num_tgt_chunks;
852 ImageChunk* tgt_chunks;
853 int i;
854
855 if (zip_mode) {
856 if (ReadZip(argv[1], &num_src_chunks, &src_chunks, 1) == NULL) {
857 printf("failed to break apart source zip file\n");
858 return 1;
859 }
860 if (ReadZip(argv[2], &num_tgt_chunks, &tgt_chunks, 0) == NULL) {
861 printf("failed to break apart target zip file\n");
862 return 1;
863 }
864 } else {
865 if (ReadImage(argv[1], &num_src_chunks, &src_chunks) == NULL) {
866 printf("failed to break apart source image\n");
867 return 1;
868 }
869 if (ReadImage(argv[2], &num_tgt_chunks, &tgt_chunks) == NULL) {
870 printf("failed to break apart target image\n");
871 return 1;
872 }
873
874 // Verify that the source and target images have the same chunk
875 // structure (ie, the same sequence of deflate and normal chunks).
876
Tao Bao97555da2016-12-15 10:15:06 -0800877 // Merge the gzip header and footer in with any adjacent
878 // normal chunks.
879 MergeAdjacentNormalChunks(tgt_chunks, &num_tgt_chunks);
880 MergeAdjacentNormalChunks(src_chunks, &num_src_chunks);
Doug Zongker512536a2010-02-17 16:11:44 -0800881
882 if (num_src_chunks != num_tgt_chunks) {
883 printf("source and target don't have same number of chunks!\n");
884 printf("source chunks:\n");
885 DumpChunks(src_chunks, num_src_chunks);
886 printf("target chunks:\n");
887 DumpChunks(tgt_chunks, num_tgt_chunks);
888 return 1;
889 }
890 for (i = 0; i < num_src_chunks; ++i) {
891 if (src_chunks[i].type != tgt_chunks[i].type) {
Tao Bao97555da2016-12-15 10:15:06 -0800892 printf("source and target don't have same chunk structure! (chunk %d)\n", i);
Doug Zongker512536a2010-02-17 16:11:44 -0800893 printf("source chunks:\n");
894 DumpChunks(src_chunks, num_src_chunks);
895 printf("target chunks:\n");
896 DumpChunks(tgt_chunks, num_tgt_chunks);
897 return 1;
898 }
899 }
900 }
901
902 for (i = 0; i < num_tgt_chunks; ++i) {
903 if (tgt_chunks[i].type == CHUNK_DEFLATE) {
904 // Confirm that given the uncompressed chunk data in the target, we
905 // can recompress it and get exactly the same bits as are in the
906 // input target image. If this fails, treat the chunk as a normal
907 // non-deflated chunk.
908 if (ReconstructDeflateChunk(tgt_chunks+i) < 0) {
909 printf("failed to reconstruct target deflate chunk %d [%s]; "
910 "treating as normal\n", i, tgt_chunks[i].filename);
911 ChangeDeflateChunkToNormal(tgt_chunks+i);
912 if (zip_mode) {
913 ImageChunk* src = FindChunkByName(tgt_chunks[i].filename, src_chunks, num_src_chunks);
914 if (src) {
915 ChangeDeflateChunkToNormal(src);
916 }
917 } else {
918 ChangeDeflateChunkToNormal(src_chunks+i);
919 }
920 continue;
921 }
922
923 // If two deflate chunks are identical (eg, the kernel has not
924 // changed between two builds), treat them as normal chunks.
925 // This makes applypatch much faster -- it can apply a trivial
926 // patch to the compressed data, rather than uncompressing and
927 // recompressing to apply the trivial patch to the uncompressed
928 // data.
929 ImageChunk* src;
930 if (zip_mode) {
931 src = FindChunkByName(tgt_chunks[i].filename, src_chunks, num_src_chunks);
932 } else {
933 src = src_chunks+i;
934 }
935
936 if (src == NULL || AreChunksEqual(tgt_chunks+i, src)) {
937 ChangeDeflateChunkToNormal(tgt_chunks+i);
938 if (src) {
939 ChangeDeflateChunkToNormal(src);
940 }
941 }
942 }
943 }
944
945 // Merging neighboring normal chunks.
946 if (zip_mode) {
947 // For zips, we only need to do this to the target: deflated
948 // chunks are matched via filename, and normal chunks are patched
949 // using the entire source file as the source.
950 MergeAdjacentNormalChunks(tgt_chunks, &num_tgt_chunks);
951 } else {
952 // For images, we need to maintain the parallel structure of the
953 // chunk lists, so do the merging in both the source and target
954 // lists.
955 MergeAdjacentNormalChunks(tgt_chunks, &num_tgt_chunks);
956 MergeAdjacentNormalChunks(src_chunks, &num_src_chunks);
957 if (num_src_chunks != num_tgt_chunks) {
958 // This shouldn't happen.
959 printf("merging normal chunks went awry\n");
960 return 1;
961 }
962 }
963
964 // Compute bsdiff patches for each chunk's data (the uncompressed
965 // data, in the case of deflate chunks).
966
Doug Zongkera3ccba62012-08-20 15:28:02 -0700967 DumpChunks(src_chunks, num_src_chunks);
968
Doug Zongker512536a2010-02-17 16:11:44 -0800969 printf("Construct patches for %d chunks...\n", num_tgt_chunks);
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800970 unsigned char** patch_data = static_cast<unsigned char**>(malloc(
Tao Baoba9a42a2015-06-23 23:23:33 -0700971 num_tgt_chunks * sizeof(unsigned char*)));
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800972 size_t* patch_size = static_cast<size_t*>(malloc(num_tgt_chunks * sizeof(size_t)));
Doug Zongker512536a2010-02-17 16:11:44 -0800973 for (i = 0; i < num_tgt_chunks; ++i) {
974 if (zip_mode) {
975 ImageChunk* src;
976 if (tgt_chunks[i].type == CHUNK_DEFLATE &&
Tao Bao97555da2016-12-15 10:15:06 -0800977 (src = FindChunkByName(tgt_chunks[i].filename, src_chunks, num_src_chunks))) {
Doug Zongker512536a2010-02-17 16:11:44 -0800978 patch_data[i] = MakePatch(src, tgt_chunks+i, patch_size+i);
979 } else {
980 patch_data[i] = MakePatch(src_chunks, tgt_chunks+i, patch_size+i);
981 }
982 } else {
Tao Baoa0c40112016-06-01 13:15:44 -0700983 if (i == 1 && bonus_data) {
Tao Baoba9a42a2015-06-23 23:23:33 -0700984 printf(" using %zu bytes of bonus data for chunk %d\n", bonus_size, i);
Rahul Chaudhryb29f23f2016-11-09 13:17:01 -0800985 src_chunks[i].data = static_cast<unsigned char*>(realloc(src_chunks[i].data,
Tao Baoba9a42a2015-06-23 23:23:33 -0700986 src_chunks[i].len + bonus_size));
Tao Baoa0c40112016-06-01 13:15:44 -0700987 memcpy(src_chunks[i].data+src_chunks[i].len, bonus_data, bonus_size);
Doug Zongkera3ccba62012-08-20 15:28:02 -0700988 src_chunks[i].len += bonus_size;
989 }
990
Doug Zongker512536a2010-02-17 16:11:44 -0800991 patch_data[i] = MakePatch(src_chunks+i, tgt_chunks+i, patch_size+i);
992 }
Tao Bao97555da2016-12-15 10:15:06 -0800993 printf("patch %3d is %zu bytes (of %zu)\n", i, patch_size[i], tgt_chunks[i].source_len);
Doug Zongker512536a2010-02-17 16:11:44 -0800994 }
995
996 // Figure out how big the imgdiff file header is going to be, so
997 // that we can correctly compute the offset of each bsdiff patch
998 // within the file.
999
1000 size_t total_header_size = 12;
1001 for (i = 0; i < num_tgt_chunks; ++i) {
1002 total_header_size += 4;
1003 switch (tgt_chunks[i].type) {
1004 case CHUNK_NORMAL:
1005 total_header_size += 8*3;
1006 break;
1007 case CHUNK_DEFLATE:
1008 total_header_size += 8*5 + 4*5;
1009 break;
1010 case CHUNK_RAW:
1011 total_header_size += 4 + patch_size[i];
1012 break;
1013 }
1014 }
1015
1016 size_t offset = total_header_size;
1017
1018 FILE* f = fopen(argv[3], "wb");
1019
1020 // Write out the headers.
1021
1022 fwrite("IMGDIFF2", 1, 8, f);
1023 Write4(num_tgt_chunks, f);
1024 for (i = 0; i < num_tgt_chunks; ++i) {
1025 Write4(tgt_chunks[i].type, f);
1026
1027 switch (tgt_chunks[i].type) {
1028 case CHUNK_NORMAL:
Tao Baoba9a42a2015-06-23 23:23:33 -07001029 printf("chunk %3d: normal (%10zu, %10zu) %10zu\n", i,
Doug Zongker512536a2010-02-17 16:11:44 -08001030 tgt_chunks[i].start, tgt_chunks[i].len, patch_size[i]);
1031 Write8(tgt_chunks[i].source_start, f);
1032 Write8(tgt_chunks[i].source_len, f);
1033 Write8(offset, f);
1034 offset += patch_size[i];
1035 break;
1036
1037 case CHUNK_DEFLATE:
Tao Baoba9a42a2015-06-23 23:23:33 -07001038 printf("chunk %3d: deflate (%10zu, %10zu) %10zu %s\n", i,
Doug Zongker512536a2010-02-17 16:11:44 -08001039 tgt_chunks[i].start, tgt_chunks[i].deflate_len, patch_size[i],
1040 tgt_chunks[i].filename);
1041 Write8(tgt_chunks[i].source_start, f);
1042 Write8(tgt_chunks[i].source_len, f);
1043 Write8(offset, f);
1044 Write8(tgt_chunks[i].source_uncompressed_len, f);
1045 Write8(tgt_chunks[i].len, f);
1046 Write4(tgt_chunks[i].level, f);
1047 Write4(tgt_chunks[i].method, f);
1048 Write4(tgt_chunks[i].windowBits, f);
1049 Write4(tgt_chunks[i].memLevel, f);
1050 Write4(tgt_chunks[i].strategy, f);
1051 offset += patch_size[i];
1052 break;
1053
1054 case CHUNK_RAW:
Tao Baoba9a42a2015-06-23 23:23:33 -07001055 printf("chunk %3d: raw (%10zu, %10zu)\n", i,
Doug Zongker512536a2010-02-17 16:11:44 -08001056 tgt_chunks[i].start, tgt_chunks[i].len);
1057 Write4(patch_size[i], f);
1058 fwrite(patch_data[i], 1, patch_size[i], f);
1059 break;
1060 }
1061 }
1062
1063 // Append each chunk's bsdiff patch, in order.
1064
1065 for (i = 0; i < num_tgt_chunks; ++i) {
1066 if (tgt_chunks[i].type != CHUNK_RAW) {
1067 fwrite(patch_data[i], 1, patch_size[i], f);
1068 }
1069 }
1070
Rahul Chaudhry3a5177b2016-11-15 16:18:46 -08001071 free(patch_data);
1072 free(patch_size);
1073
Doug Zongker512536a2010-02-17 16:11:44 -08001074 fclose(f);
Doug Zongker512536a2010-02-17 16:11:44 -08001075
1076 return 0;
1077}