/*- * Copyright 2003-2005 Colin Percival * All rights reserved * * Redistribution and use in source and binary forms, with or without * modification, are permitted providing that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #if 0 __FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:06 cperciva Exp $"); #endif #include #include #include #include #include #include #include #include #include #include #if defined(__APPLE__) #include #define le64toh(x) OSSwapLittleToHostInt64(x) #elif defined(__linux__) #include #elif defined(_WIN32) && (defined(_M_IX86) || defined(_M_X64)) #define le64toh(x) (x) #else #error Provide le64toh for this platform #endif #include "chrome/installer/mac/third_party/bsdiff/sha1_adapter.h" static inline off_t offtin(u_char *buf) { return le64toh(*((off_t*)buf)); } static void sha1tostr(const u_char *sha1, char *sha1str) { int i; for (i = 0; i < SHA1_DIGEST_LENGTH; ++i) sprintf(&sha1str[i * 2], "%02x", sha1[i]); } /* xzfile is a provisional stdio-like interface to xz/lzma2-compressed data. * liblzma does not currently include this functionality. The interface is * read-only and only supports sequential access. */ typedef struct { /* in and out are the underlying buffers to be used with lzma_stream. */ u_char in[BUFSIZ]; u_char out[BUFSIZ]; lzma_stream ls; FILE *f; /* read_out points to the first byte in out not yet consumed by an * xzread call. read_out_len tracks the amount of data available in * out beginning at read_out. */ u_char *read_out; size_t read_out_len; /* Error and end-of-file indicators. */ lzma_ret err; int eof; } xzfile; /* Initializes and returns a new xzfile pointer that will read from f. On * failure, returns NULL. If err is non-NULL, it will be set to indicate any * error that may have occurred. */ static xzfile *xzdopen(FILE *f, lzma_ret *err) { xzfile *xzf; lzma_stream ls = LZMA_STREAM_INIT; uint64_t physmem, memlimit; if (!(xzf = malloc(sizeof(xzfile)))) { if (err) *err = LZMA_MEM_ERROR; return NULL; } xzf->ls = ls; xzf->f = f; xzf->read_out = xzf->out; xzf->read_out_len = 0; xzf->err = LZMA_OK; xzf->eof = 0; /* Use the same memory limits used by xzdec and xz. Use 40% of * physical memory if 80MB or more, otherwise use 80% of physical * memory if 80MB or less, otherwise use 80MB. If physical memory * can't be determined, use 128MB. These limits should be sufficient * for any decompression on any general-purpose system. */ physmem = lzma_physmem(); if (physmem == 0) physmem = 128 * 1024 * 1024; memlimit = 40 * physmem / 100; if (memlimit < 80 * 1024 * 1024) { memlimit = 80 * physmem / 100; if (memlimit > 80 * 1024 * 1024) memlimit = 80 * 1024 * 1024; } xzf->err = lzma_stream_decoder(&xzf->ls, memlimit, LZMA_TELL_NO_CHECK | LZMA_TELL_UNSUPPORTED_CHECK); if (xzf->err != LZMA_OK) { if (err) *err = xzf->err; free(xzf); return NULL; } if (err) *err = xzf->err; return xzf; } /* Closes an xzfile opened by xzopen, freeing all memory and closing all * files. Returns LZMA_OK normally, or LZMA_STREAM_END if fclose fails. */ static lzma_ret xzclose(xzfile *xzf) { lzma_ret lzma_err = LZMA_OK; lzma_end(&xzf->ls); if (fclose(xzf->f) != 0) lzma_err = LZMA_STREAM_END; free(xzf); return lzma_err; } /* Reads len uncompressed bytes from xzf into buf. Returns the number of bytes * read, which may be less than len at the end of the file. Upon error, if * err is non-NULL, it will be set to an appropriate value, which will either * be a return value from lzma_code (with the exception of LZMA_STREAM_END, * which is remapped to LZMA_OK), or LZMA_STREAM_END to indicate an I/O error. */ static size_t xzread(xzfile *xzf, u_char *buf, size_t len, lzma_ret *err) { lzma_action action = LZMA_RUN; size_t copylen; size_t nread = 0; while (xzf->err == LZMA_OK && len > 0) { if (xzf->read_out_len == 0) { /* No unconsumed data is available, need to run * lzma_code to decompress. */ if (xzf->ls.avail_in == 0 && !xzf->eof) { /* No input data available, need to read. */ xzf->ls.next_in = xzf->in; xzf->ls.avail_in = fread(xzf->in, 1, BUFSIZ, xzf->f); if (ferror(xzf->f)) { /* Map I/O errors to LZMA_STREAM_END. */ xzf->err = LZMA_STREAM_END; if (err) *err = xzf->err; return 0; } else if (feof(xzf->f)) { xzf->eof = 1; } } /* Use the full output buffer. */ xzf->ls.next_out = xzf->out; xzf->ls.avail_out = BUFSIZ; /* There must be something to decode. */ if (xzf->ls.avail_in == 0) { xzf->err = LZMA_BUF_ERROR; if (err) *err = xzf->err; return 0; } /* LZMA_FINISH is not critical because * LZMA_CONCATENATED is not in use. */ if (xzf->eof) action = LZMA_FINISH; /* Run the decoder. */ xzf->err = lzma_code(&xzf->ls, action); if (xzf->err == LZMA_STREAM_END) { xzf->eof = 1; xzf->err = LZMA_OK; } else if (xzf->err != LZMA_OK) { if (err) *err = xzf->err; return 0; } /* Everything that was decoded is now available for * reading into buf. */ xzf->read_out = xzf->out; xzf->read_out_len = BUFSIZ - xzf->ls.avail_out; } /* Copy everything available up to len, and push some * pointers. */ copylen = xzf->read_out_len; if (copylen > len) copylen = len; memcpy(buf, xzf->read_out, copylen); nread += copylen; buf += copylen; len -= copylen; xzf->read_out += copylen; xzf->read_out_len -= copylen; } if (err) *err = xzf->err; return nread; } /* cfile is a uniform interface to read from maybe-compressed files. */ typedef struct { FILE *f; /* method = 1, 2 */ union { BZFILE *bz2; /* method = 2 */ gzFile gz; /* method = 3 */ xzfile *xz; /* method = 4 */ } u; const char *tag; unsigned char method; } cfile; /* Opens a file at path, seeks to offset off, and prepares for reading using * the specified method. Supported methods are plain uncompressed (1), bzip2 * (2), gzip (3), and xz/lzma2 (4). tag is used as an identifier for error * reporting. */ static void cfopen(cfile *cf, const char *path, off_t off, const char *tag, unsigned char method) { int fd; int bz2_err, gz_err; lzma_ret lzma_err; if (method == 1 || method == 2 || method == 4) { /* Use stdio for uncompressed files. The bzip interface also * sits on top of a stdio FILE* but does not take "ownership" * of the FILE*. The xz/lzma2 interface sits on top of a FILE* * and does take ownership of the FILE*. */ if ((cf->f = fopen(path, "rb")) == NULL) err(1, "fdopen(%s)", tag); if ((fseeko(cf->f, off, SEEK_SET)) != 0) err(1, "fseeko(%s, %lld)", tag, off); if (method == 2) { if ((cf->u.bz2 = BZ2_bzReadOpen(&bz2_err, cf->f, 0, 0, NULL, 0)) == NULL) errx(1, "BZ2_bzReadOpen(%s): %d", tag, bz2_err); } else if (method == 4) { if ((cf->u.xz = xzdopen(cf->f, &lzma_err)) == NULL) errx(1, "xzdopen(%s): %d", tag, lzma_err); /* cf->f belongs to the xzfile now, don't access it * from here. */ cf->f = NULL; } } else if (method == 3) { if ((fd = open(path, O_RDONLY)) < 0) err(1, "open(%s)", tag); if (lseek(fd, off, SEEK_SET) != off) err(1, "lseek(%s, %lld)", tag, off); if ((cf->u.gz = gzdopen(fd, "rb")) == NULL) errx(1, "gzdopen(%s)", tag); } else { errx(1, "cfopen(%s): unknown method %d", tag, method); } cf->tag = tag; cf->method = method; } static void cfclose(cfile *cf) { int bz2_err, gz_err; lzma_ret lzma_err; if (cf->method == 1 || cf->method == 2) { if (cf->method == 2) { bz2_err = BZ_OK; BZ2_bzReadClose(&bz2_err, cf->u.bz2); if (bz2_err != BZ_OK) errx(1, "BZ2_bzReadClose(%s): %d\n", cf->tag, bz2_err); } if (fclose(cf->f) != 0) err(1, "fclose(%s)", cf->tag); } else if (cf->method == 3) { if ((gz_err = gzclose(cf->u.gz)) != Z_OK) errx(1, "gzclose(%s): %d", cf->tag, gz_err); } else if (cf->method == 4) { if ((lzma_err = xzclose(cf->u.xz)) != LZMA_OK) errx(1, "xzclose(%s): %d", cf->tag, lzma_err); } else { errx(1, "cfclose(%s): unknown method %d", cf->tag, cf->method); } } static void cfread(cfile *cf, u_char *buf, size_t len) { size_t nread; int bz2_err, gz_err; lzma_ret lzma_err; if (cf->method == 1) { if ((nread = fread(buf, 1, len, cf->f)) != len) { if (!ferror(cf->f)) errx(1, "fread(%s, %zd): short read %zd", cf->tag, len, nread); err(1, "fread(%s, %zd)", cf->tag, len); } } else if (cf->method == 2) { bz2_err = BZ_OK; if ((nread = BZ2_bzRead(&bz2_err, cf->u.bz2, buf, len)) != len) { if (bz2_err == BZ_OK) errx(1, "BZ2_bzRead(%s, %zd): short read %zd", cf->tag, len, nread); errx(1, "BZ2_bzRead(%s, %zd): %d", cf->tag, len, bz2_err); } } else if (cf->method == 3) { if ((nread = gzread(cf->u.gz, buf, len)) != len) { gz_err = Z_OK; gzerror(cf->u.gz, &gz_err); if (gz_err == Z_OK) errx(1, "gzread(%s, %zd): short read %zd", cf->tag, len, nread); errx(1, "gzread(%s, %zd): %d", cf->tag, len, gz_err); } } else if (cf->method == 4) { if ((nread = xzread(cf->u.xz, buf, len, &lzma_err)) != len) { if (lzma_err == LZMA_OK) errx(1, "xzread(%s, %zd): short read %zd", cf->tag, len, nread); errx(1, "xzread(%s, %zd): %d", cf->tag, len, lzma_err); } } else { errx(1, "cfread(%s, %zd): unknown method %d", cf->tag, len, cf->method); } } int main(int argc,char * argv[]) { FILE * f; cfile cf, df, ef; int fd; off_t expect_oldsize, oldsize, newsize, patchsize; off_t zctrllen, zdatalen, zextralen; u_char header[96], buf[8]; u_char *old, *new; off_t oldpos,newpos; off_t ctrl[3]; off_t i; u_char sha1[SHA1_DIGEST_LENGTH]; char sha1str[SHA1_DIGEST_LENGTH * 2 + 1]; char expected_sha1str[SHA1_DIGEST_LENGTH * 2 + 1]; if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile",argv[0]); /* Open patch file */ if ((f = fopen(argv[3], "rb")) == NULL) err(1, "fopen(%s)", argv[3]); /* File format: 0 8 "BSDIFF4G" 8 8 length of compressed control block (x) 16 8 length of compressed diff block (y) 24 8 length of compressed extra block (z) 32 8 length of old file 40 8 length of new file 48 20 SHA1 of old file 68 20 SHA1 of new file 88 1 encoding of control block 89 1 encoding of diff block 90 1 encoding of extra block 91 5 unused 96 x compressed control block 96+x y compressed diff block 96+x+y z compressed extra block Encodings are 1 (uncompressed), 2 (bzip2), 3 (gzip), and 4 (xz/lzma2). The control block is a set of triples (x,y,z) meaning "add x bytes from oldfile to x bytes from the diff block; copy y bytes from the extra block; seek forwards in oldfile by z bytes". */ /* Read header */ if (fread(header, 1, sizeof(header), f) < sizeof(header)) { if (feof(f)) errx(1, "corrupt patch (header size)"); err(1, "fread(%s)", argv[3]); } /* Check for appropriate magic */ if (memcmp(header, "BSDIFF4G", 8) != 0) errx(1, "corrupt patch (magic)"); /* Read lengths from header */ zctrllen = offtin(header + 8); zdatalen = offtin(header + 16); zextralen = offtin(header + 24); expect_oldsize = offtin(header + 32); newsize = offtin(header + 40); if (zctrllen < 0 || zdatalen < 0 || zextralen < 0) errx(1, "corrupt patch (stream sizes)"); if (expect_oldsize < 0 || newsize < 0) errx(1, "corrupt patch (file sizes)"); if (fseeko(f, 0, SEEK_END) != 0 || (patchsize = ftello(f)) < 0) err(1, "fseeko/ftello(%s)", argv[3]); if (patchsize != sizeof(header) + zctrllen + zdatalen + zextralen) errx(1, "corrupt patch (patch size)"); cfopen(&cf, argv[3], sizeof(header), "control", header[88]); cfopen(&df, argv[3], sizeof(header) + zctrllen, "diff", header[89]); cfopen(&ef, argv[3], sizeof(header) + zctrllen + zdatalen, "extra", header[90]); if (fclose(f)) err(1, "fclose(%s)", argv[3]); if(((fd=open(argv[1],O_RDONLY,0))<0) || ((oldsize=lseek(fd,0,SEEK_END))==-1) || ((old=malloc(oldsize+1))==NULL) || (lseek(fd,0,SEEK_SET)!=0) || (read(fd,old,oldsize)!=oldsize) || (close(fd)==-1)) err(1,"%s",argv[1]); if (expect_oldsize != oldsize) errx(1, "old size mismatch: %lld != %lld", oldsize, expect_oldsize); SHA1(old, oldsize, sha1); if (memcmp(sha1, header + 48, sizeof(sha1)) != 0) { sha1tostr(sha1, sha1str); sha1tostr(header + 48, expected_sha1str); errx(1, "old hash mismatch: %s != %s", sha1str, expected_sha1str); } if((new=malloc(newsize+1))==NULL) err(1,NULL); oldpos=0;newpos=0; while(newposnewsize) errx(1,"corrupt patch (diff): overrun"); /* Read diff string */ cfread(&df, new + newpos, ctrl[0]); /* Add old data to diff string */ for(i=0;i=0) && (oldpos+inewsize) errx(1,"corrupt patch (extra): overrun"); /* Read extra string */ cfread(&ef, new + newpos, ctrl[1]); /* Adjust pointers */ newpos+=ctrl[1]; oldpos+=ctrl[2]; }; /* Clean up the readers */ cfclose(&cf); cfclose(&df); cfclose(&ef); SHA1(new, newsize, sha1); if (memcmp(sha1, header + 68, sizeof(sha1)) != 0) { sha1tostr(sha1, sha1str); sha1tostr(header + 68, expected_sha1str); errx(1, "new hash mismatch: %s != %s", sha1str, expected_sha1str); } /* Write the new file */ if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0644))<0) || (write(fd,new,newsize)!=newsize) || (close(fd)==-1)) err(1,"open/write/close(%s)",argv[2]); free(new); free(old); return 0; }