1/*- 2 * Copyright 2003-2005 Colin Percival 3 * All rights reserved 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted providing that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 22 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 23 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 24 * POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#if 0 28__FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:06 cperciva Exp $"); 29#endif 30 31#include <sys/types.h> 32 33#include <bzlib.h> 34#include <err.h> 35#include <fcntl.h> 36#include <lzma.h> 37#include <stdlib.h> 38#include <stdio.h> 39#include <string.h> 40#include <unistd.h> 41#include <zlib.h> 42 43#if defined(__APPLE__) 44#include <libkern/OSByteOrder.h> 45#define le64toh(x) OSSwapLittleToHostInt64(x) 46#elif defined(__linux__) 47#include <endian.h> 48#elif defined(_WIN32) && (defined(_M_IX86) || defined(_M_X64)) 49#define le64toh(x) (x) 50#else 51#error Provide le64toh for this platform 52#endif 53 54#include "chrome/installer/mac/third_party/bsdiff/sha1_adapter.h" 55 56static inline off_t offtin(u_char *buf) 57{ 58 return le64toh(*((off_t*)buf)); 59} 60 61static void sha1tostr(const u_char *sha1, char *sha1str) 62{ 63 int i; 64 for (i = 0; i < SHA1_DIGEST_LENGTH; ++i) 65 sprintf(&sha1str[i * 2], "%02x", sha1[i]); 66} 67 68/* xzfile is a provisional stdio-like interface to xz/lzma2-compressed data. 69 * liblzma does not currently include this functionality. The interface is 70 * read-only and only supports sequential access. */ 71 72typedef struct { 73 /* in and out are the underlying buffers to be used with lzma_stream. */ 74 u_char in[BUFSIZ]; 75 u_char out[BUFSIZ]; 76 77 lzma_stream ls; 78 FILE *f; 79 80 /* read_out points to the first byte in out not yet consumed by an 81 * xzread call. read_out_len tracks the amount of data available in 82 * out beginning at read_out. */ 83 u_char *read_out; 84 size_t read_out_len; 85 86 /* Error and end-of-file indicators. */ 87 lzma_ret err; 88 int eof; 89} xzfile; 90 91/* Initializes and returns a new xzfile pointer that will read from f. On 92 * failure, returns NULL. If err is non-NULL, it will be set to indicate any 93 * error that may have occurred. */ 94static xzfile *xzdopen(FILE *f, lzma_ret *err) 95{ 96 xzfile *xzf; 97 lzma_stream ls = LZMA_STREAM_INIT; 98 uint64_t physmem, memlimit; 99 100 if (!(xzf = malloc(sizeof(xzfile)))) { 101 if (err) *err = LZMA_MEM_ERROR; 102 return NULL; 103 } 104 105 xzf->ls = ls; 106 xzf->f = f; 107 108 xzf->read_out = xzf->out; 109 xzf->read_out_len = 0; 110 111 xzf->err = LZMA_OK; 112 xzf->eof = 0; 113 114 /* Use the same memory limits used by xzdec and xz. Use 40% of 115 * physical memory if 80MB or more, otherwise use 80% of physical 116 * memory if 80MB or less, otherwise use 80MB. If physical memory 117 * can't be determined, use 128MB. These limits should be sufficient 118 * for any decompression on any general-purpose system. */ 119 physmem = lzma_physmem(); 120 if (physmem == 0) 121 physmem = 128 * 1024 * 1024; 122 memlimit = 40 * physmem / 100; 123 if (memlimit < 80 * 1024 * 1024) { 124 memlimit = 80 * physmem / 100; 125 if (memlimit > 80 * 1024 * 1024) 126 memlimit = 80 * 1024 * 1024; 127 } 128 129 xzf->err = lzma_stream_decoder(&xzf->ls, memlimit, 130 LZMA_TELL_NO_CHECK | 131 LZMA_TELL_UNSUPPORTED_CHECK); 132 if (xzf->err != LZMA_OK) { 133 if (err) *err = xzf->err; 134 free(xzf); 135 return NULL; 136 } 137 138 if (err) *err = xzf->err; 139 return xzf; 140} 141 142/* Closes an xzfile opened by xzopen, freeing all memory and closing all 143 * files. Returns LZMA_OK normally, or LZMA_STREAM_END if fclose fails. */ 144static lzma_ret xzclose(xzfile *xzf) 145{ 146 lzma_ret lzma_err = LZMA_OK; 147 148 lzma_end(&xzf->ls); 149 if (fclose(xzf->f) != 0) 150 lzma_err = LZMA_STREAM_END; 151 free(xzf); 152 153 return lzma_err; 154} 155 156/* Reads len uncompressed bytes from xzf into buf. Returns the number of bytes 157 * read, which may be less than len at the end of the file. Upon error, if 158 * err is non-NULL, it will be set to an appropriate value, which will either 159 * be a return value from lzma_code (with the exception of LZMA_STREAM_END, 160 * which is remapped to LZMA_OK), or LZMA_STREAM_END to indicate an I/O error. 161 */ 162static size_t xzread(xzfile *xzf, u_char *buf, size_t len, lzma_ret *err) 163{ 164 lzma_action action = LZMA_RUN; 165 size_t copylen; 166 size_t nread = 0; 167 168 while (xzf->err == LZMA_OK && len > 0) { 169 if (xzf->read_out_len == 0) { 170 /* No unconsumed data is available, need to run 171 * lzma_code to decompress. */ 172 if (xzf->ls.avail_in == 0 && !xzf->eof) { 173 /* No input data available, need to read. */ 174 xzf->ls.next_in = xzf->in; 175 xzf->ls.avail_in = fread(xzf->in, 1, BUFSIZ, 176 xzf->f); 177 if (ferror(xzf->f)) { 178 /* Map I/O errors to LZMA_STREAM_END. */ 179 xzf->err = LZMA_STREAM_END; 180 if (err) *err = xzf->err; 181 return 0; 182 } else if (feof(xzf->f)) { 183 xzf->eof = 1; 184 } 185 } 186 187 /* Use the full output buffer. */ 188 xzf->ls.next_out = xzf->out; 189 xzf->ls.avail_out = BUFSIZ; 190 191 /* There must be something to decode. */ 192 if (xzf->ls.avail_in == 0) { 193 xzf->err = LZMA_BUF_ERROR; 194 if (err) *err = xzf->err; 195 return 0; 196 } 197 198 /* LZMA_FINISH is not critical because 199 * LZMA_CONCATENATED is not in use. */ 200 if (xzf->eof) 201 action = LZMA_FINISH; 202 203 /* Run the decoder. */ 204 xzf->err = lzma_code(&xzf->ls, action); 205 if (xzf->err == LZMA_STREAM_END) { 206 xzf->eof = 1; 207 xzf->err = LZMA_OK; 208 } else if (xzf->err != LZMA_OK) { 209 if (err) *err = xzf->err; 210 return 0; 211 } 212 213 /* Everything that was decoded is now available for 214 * reading into buf. */ 215 xzf->read_out = xzf->out; 216 xzf->read_out_len = BUFSIZ - xzf->ls.avail_out; 217 } 218 219 /* Copy everything available up to len, and push some 220 * pointers. */ 221 copylen = xzf->read_out_len; 222 if (copylen > len) 223 copylen = len; 224 memcpy(buf, xzf->read_out, copylen); 225 nread += copylen; 226 buf += copylen; 227 len -= copylen; 228 xzf->read_out += copylen; 229 xzf->read_out_len -= copylen; 230 } 231 232 if (err) *err = xzf->err; 233 return nread; 234} 235 236/* cfile is a uniform interface to read from maybe-compressed files. */ 237 238typedef struct { 239 FILE *f; /* method = 1, 2 */ 240 union { 241 BZFILE *bz2; /* method = 2 */ 242 gzFile gz; /* method = 3 */ 243 xzfile *xz; /* method = 4 */ 244 } u; 245 const char *tag; 246 unsigned char method; 247} cfile; 248 249/* Opens a file at path, seeks to offset off, and prepares for reading using 250 * the specified method. Supported methods are plain uncompressed (1), bzip2 251 * (2), gzip (3), and xz/lzma2 (4). tag is used as an identifier for error 252 * reporting. */ 253static void cfopen(cfile *cf, const char *path, off_t off, 254 const char *tag, unsigned char method) 255{ 256 int fd; 257 int bz2_err, gz_err; 258 lzma_ret lzma_err; 259 260 if (method == 1 || method == 2 || method == 4) { 261 /* Use stdio for uncompressed files. The bzip interface also 262 * sits on top of a stdio FILE* but does not take "ownership" 263 * of the FILE*. The xz/lzma2 interface sits on top of a FILE* 264 * and does take ownership of the FILE*. */ 265 if ((cf->f = fopen(path, "rb")) == NULL) 266 err(1, "fdopen(%s)", tag); 267 if ((fseeko(cf->f, off, SEEK_SET)) != 0) 268 err(1, "fseeko(%s, %lld)", tag, off); 269 if (method == 2) { 270 if ((cf->u.bz2 = BZ2_bzReadOpen(&bz2_err, cf->f, 0, 0, 271 NULL, 0)) == NULL) 272 errx(1, "BZ2_bzReadOpen(%s): %d", tag, bz2_err); 273 } else if (method == 4) { 274 if ((cf->u.xz = xzdopen(cf->f, &lzma_err)) == NULL) 275 errx(1, "xzdopen(%s): %d", tag, lzma_err); 276 /* cf->f belongs to the xzfile now, don't access it 277 * from here. */ 278 cf->f = NULL; 279 } 280 } else if (method == 3) { 281 if ((fd = open(path, O_RDONLY)) < 0) 282 err(1, "open(%s)", tag); 283 if (lseek(fd, off, SEEK_SET) != off) 284 err(1, "lseek(%s, %lld)", tag, off); 285 if ((cf->u.gz = gzdopen(fd, "rb")) == NULL) 286 errx(1, "gzdopen(%s)", tag); 287 } else { 288 errx(1, "cfopen(%s): unknown method %d", tag, method); 289 } 290 291 cf->tag = tag; 292 cf->method = method; 293} 294 295static void cfclose(cfile *cf) 296{ 297 int bz2_err, gz_err; 298 lzma_ret lzma_err; 299 300 if (cf->method == 1 || cf->method == 2) { 301 if (cf->method == 2) { 302 bz2_err = BZ_OK; 303 BZ2_bzReadClose(&bz2_err, cf->u.bz2); 304 if (bz2_err != BZ_OK) 305 errx(1, "BZ2_bzReadClose(%s): %d\n", 306 cf->tag, bz2_err); 307 } 308 if (fclose(cf->f) != 0) 309 err(1, "fclose(%s)", cf->tag); 310 } else if (cf->method == 3) { 311 if ((gz_err = gzclose(cf->u.gz)) != Z_OK) 312 errx(1, "gzclose(%s): %d", cf->tag, gz_err); 313 } else if (cf->method == 4) { 314 if ((lzma_err = xzclose(cf->u.xz)) != LZMA_OK) 315 errx(1, "xzclose(%s): %d", cf->tag, lzma_err); 316 } else { 317 errx(1, "cfclose(%s): unknown method %d", cf->tag, cf->method); 318 } 319} 320 321static void cfread(cfile *cf, u_char *buf, size_t len) 322{ 323 size_t nread; 324 int bz2_err, gz_err; 325 lzma_ret lzma_err; 326 327 if (cf->method == 1) { 328 if ((nread = fread(buf, 1, len, cf->f)) != len) { 329 if (!ferror(cf->f)) 330 errx(1, "fread(%s, %zd): short read %zd", 331 cf->tag, len, nread); 332 err(1, "fread(%s, %zd)", cf->tag, len); 333 } 334 } else if (cf->method == 2) { 335 bz2_err = BZ_OK; 336 if ((nread = BZ2_bzRead(&bz2_err, cf->u.bz2, buf, len)) != 337 len) { 338 if (bz2_err == BZ_OK) 339 errx(1, "BZ2_bzRead(%s, %zd): short read %zd", 340 cf->tag, len, nread); 341 errx(1, "BZ2_bzRead(%s, %zd): %d", 342 cf->tag, len, bz2_err); 343 } 344 } else if (cf->method == 3) { 345 if ((nread = gzread(cf->u.gz, buf, len)) != len) { 346 gz_err = Z_OK; 347 gzerror(cf->u.gz, &gz_err); 348 if (gz_err == Z_OK) 349 errx(1, "gzread(%s, %zd): short read %zd", 350 cf->tag, len, nread); 351 errx(1, "gzread(%s, %zd): %d", cf->tag, len, gz_err); 352 } 353 } else if (cf->method == 4) { 354 if ((nread = xzread(cf->u.xz, buf, len, &lzma_err)) != len) { 355 if (lzma_err == LZMA_OK) 356 errx(1, "xzread(%s, %zd): short read %zd", 357 cf->tag, len, nread); 358 errx(1, "xzread(%s, %zd): %d", cf->tag, len, lzma_err); 359 } 360 } else { 361 errx(1, "cfread(%s, %zd): unknown method %d", 362 cf->tag, len, cf->method); 363 } 364} 365 366int main(int argc,char * argv[]) 367{ 368 FILE * f; 369 cfile cf, df, ef; 370 int fd; 371 off_t expect_oldsize, oldsize, newsize, patchsize; 372 off_t zctrllen, zdatalen, zextralen; 373 u_char header[96], buf[8]; 374 u_char *old, *new; 375 off_t oldpos,newpos; 376 off_t ctrl[3]; 377 off_t i; 378 u_char sha1[SHA1_DIGEST_LENGTH]; 379 char sha1str[SHA1_DIGEST_LENGTH * 2 + 1]; 380 char expected_sha1str[SHA1_DIGEST_LENGTH * 2 + 1]; 381 382 if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile",argv[0]); 383 384 /* Open patch file */ 385 if ((f = fopen(argv[3], "rb")) == NULL) 386 err(1, "fopen(%s)", argv[3]); 387 388 /* 389 File format: 390 0 8 "BSDIFF4G" 391 8 8 length of compressed control block (x) 392 16 8 length of compressed diff block (y) 393 24 8 length of compressed extra block (z) 394 32 8 length of old file 395 40 8 length of new file 396 48 20 SHA1 of old file 397 68 20 SHA1 of new file 398 88 1 encoding of control block 399 89 1 encoding of diff block 400 90 1 encoding of extra block 401 91 5 unused 402 96 x compressed control block 403 96+x y compressed diff block 404 96+x+y z compressed extra block 405 Encodings are 1 (uncompressed), 2 (bzip2), 3 (gzip), and 4 (xz/lzma2). 406 The control block is a set of triples (x,y,z) meaning "add x bytes 407 from oldfile to x bytes from the diff block; copy y bytes from the 408 extra block; seek forwards in oldfile by z bytes". 409 */ 410 411 /* Read header */ 412 if (fread(header, 1, sizeof(header), f) < sizeof(header)) { 413 if (feof(f)) 414 errx(1, "corrupt patch (header size)"); 415 err(1, "fread(%s)", argv[3]); 416 } 417 418 /* Check for appropriate magic */ 419 if (memcmp(header, "BSDIFF4G", 8) != 0) 420 errx(1, "corrupt patch (magic)"); 421 422 /* Read lengths from header */ 423 zctrllen = offtin(header + 8); 424 zdatalen = offtin(header + 16); 425 zextralen = offtin(header + 24); 426 expect_oldsize = offtin(header + 32); 427 newsize = offtin(header + 40); 428 if (zctrllen < 0 || zdatalen < 0 || zextralen < 0) 429 errx(1, "corrupt patch (stream sizes)"); 430 if (expect_oldsize < 0 || newsize < 0) 431 errx(1, "corrupt patch (file sizes)"); 432 433 if (fseeko(f, 0, SEEK_END) != 0 || (patchsize = ftello(f)) < 0) 434 err(1, "fseeko/ftello(%s)", argv[3]); 435 if (patchsize != sizeof(header) + zctrllen + zdatalen + zextralen) 436 errx(1, "corrupt patch (patch size)"); 437 438 cfopen(&cf, argv[3], sizeof(header), "control", header[88]); 439 cfopen(&df, argv[3], sizeof(header) + zctrllen, "diff", header[89]); 440 cfopen(&ef, argv[3], sizeof(header) + zctrllen + zdatalen, "extra", 441 header[90]); 442 443 if (fclose(f)) 444 err(1, "fclose(%s)", argv[3]); 445 446 if(((fd=open(argv[1],O_RDONLY,0))<0) || 447 ((oldsize=lseek(fd,0,SEEK_END))==-1) || 448 ((old=malloc(oldsize+1))==NULL) || 449 (lseek(fd,0,SEEK_SET)!=0) || 450 (read(fd,old,oldsize)!=oldsize) || 451 (close(fd)==-1)) err(1,"%s",argv[1]); 452 if (expect_oldsize != oldsize) 453 errx(1, "old size mismatch: %lld != %lld", 454 oldsize, expect_oldsize); 455 SHA1(old, oldsize, sha1); 456 if (memcmp(sha1, header + 48, sizeof(sha1)) != 0) { 457 sha1tostr(sha1, sha1str); 458 sha1tostr(header + 48, expected_sha1str); 459 errx(1, "old hash mismatch: %s != %s", 460 sha1str, expected_sha1str); 461 } 462 if((new=malloc(newsize+1))==NULL) err(1,NULL); 463 464 oldpos=0;newpos=0; 465 while(newpos<newsize) { 466 /* Read control data */ 467 for(i=0;i<=2;i++) { 468 cfread(&cf, buf, 8); 469 ctrl[i]=offtin(buf); 470 }; 471 472 /* Sanity-check */ 473 if((ctrl[0]<0) || (ctrl[1]<0)) 474 errx(1,"corrupt patch (diff): negative chunk size"); 475 476 /* Sanity-check */ 477 if(newpos+ctrl[0]>newsize) 478 errx(1,"corrupt patch (diff): overrun"); 479 480 /* Read diff string */ 481 cfread(&df, new + newpos, ctrl[0]); 482 483 /* Add old data to diff string */ 484 for(i=0;i<ctrl[0];i++) 485 if((oldpos+i>=0) && (oldpos+i<oldsize)) 486 new[newpos+i]+=old[oldpos+i]; 487 488 /* Adjust pointers */ 489 newpos+=ctrl[0]; 490 oldpos+=ctrl[0]; 491 492 /* Sanity-check */ 493 if(newpos+ctrl[1]>newsize) 494 errx(1,"corrupt patch (extra): overrun"); 495 496 /* Read extra string */ 497 cfread(&ef, new + newpos, ctrl[1]); 498 499 /* Adjust pointers */ 500 newpos+=ctrl[1]; 501 oldpos+=ctrl[2]; 502 }; 503 504 /* Clean up the readers */ 505 cfclose(&cf); 506 cfclose(&df); 507 cfclose(&ef); 508 509 SHA1(new, newsize, sha1); 510 if (memcmp(sha1, header + 68, sizeof(sha1)) != 0) { 511 sha1tostr(sha1, sha1str); 512 sha1tostr(header + 68, expected_sha1str); 513 errx(1, "new hash mismatch: %s != %s", 514 sha1str, expected_sha1str); 515 } 516 517 /* Write the new file */ 518 if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0644))<0) || 519 (write(fd,new,newsize)!=newsize) || (close(fd)==-1)) 520 err(1,"open/write/close(%s)",argv[2]); 521 522 free(new); 523 free(old); 524 525 return 0; 526} 527