tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

refactor applypatch and friends

Browse source 
Change the applypatch function to take meaningful arguments instead of
argc and argv.  Move all the parsing of arguments into main.c (for the
standalone binary) and into install.c (for the updater function).
applypatch() takes patches as Value objects, so we can pass in blobs
extracted from the package without ever writing them to temp files.

The patching code is changed to read the patch from memory instead of
a file.

A bunch of compiler warnings (mostly about signed vs unsigned types)
are fixed.

Support for the IMGDIFF1 format is dropped.  (We've been generating
IMGDIFF2 packages for some time now.)

Change-Id: I217563c500012750f27110db821928a06211323f
This commit is contained in:
Doug Zongker 2010-02-22 14:46:32 -08:00
parent 583fc12c3d
commit c4351c7910
12 changed files with 1285 additions and 1311 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
applypatch/Android.mk
View file

@ -29,6 +29,7 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c LOCAL_SRC_FILES := main.c
LOCAL_MODULE := applypatch LOCAL_MODULE := applypatch
LOCAL_C_INCLUDES += bootable/recovery
LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz
LOCAL_SHARED_LIBRARIES += libz libcutils libstdc++ libc LOCAL_SHARED_LIBRARIES += libz libcutils libstdc++ libc
@ -40,6 +41,7 @@ LOCAL_SRC_FILES := main.c
LOCAL_MODULE := applypatch_static LOCAL_MODULE := applypatch_static
LOCAL_FORCE_STATIC_EXECUTABLE := true LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_MODULE_TAGS := eng LOCAL_MODULE_TAGS := eng
LOCAL_C_INCLUDES += bootable/recovery
LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz
LOCAL_STATIC_LIBRARIES += libz libcutils libstdc++ libc LOCAL_STATIC_LIBRARIES += libz libcutils libstdc++ libc

1333
applypatch/applypatch.c
View file

File diff suppressed because it is too large Load diff

22
applypatch/applypatch.h
View file

@ -19,6 +19,7 @@
#include <sys/stat.h> #include <sys/stat.h>
#include "mincrypt/sha.h" #include "mincrypt/sha.h"
#include "edify/expr.h"
typedef struct _Patch { typedef struct _Patch {
uint8_t sha1[SHA_DIGEST_SIZE]; uint8_t sha1[SHA_DIGEST_SIZE];
@ -42,8 +43,21 @@ typedef struct _FileContents {
typedef ssize_t (*SinkFn)(unsigned char*, ssize_t, void*); typedef ssize_t (*SinkFn)(unsigned char*, ssize_t, void*);
// applypatch.c // applypatch.c
int ShowLicenses();
size_t FreeSpaceForFile(const char* filename); size_t FreeSpaceForFile(const char* filename);
int applypatch(int argc, char** argv); int CacheSizeCheck(size_t bytes);
int ParseSha1(const char* str, uint8_t* digest);
int applypatch(const char* source_filename,
const char* target_filename,
const char* target_sha1_str,
size_t target_size,
int num_patches,
char** const patch_sha1_str,
Value** patch_data);
int applypatch_check(const char* filename,
int num_patches,
char** const patch_sha1_str);
// Read a file into memory; store it and its associated metadata in // Read a file into memory; store it and its associated metadata in
// *file. Return 0 on success. // *file. Return 0 on success.
@ -53,15 +67,15 @@ void FreeFileContents(FileContents* file);
// bsdiff.c // bsdiff.c
void ShowBSDiffLicense(); void ShowBSDiffLicense();
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t offset, const Value* patch, ssize_t patch_offset,
SinkFn sink, void* token, SHA_CTX* ctx); SinkFn sink, void* token, SHA_CTX* ctx);
int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size, int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t patch_offset, const Value* patch, ssize_t patch_offset,
unsigned char** new_data, ssize_t* new_size); unsigned char** new_data, ssize_t* new_size);
// imgpatch.c // imgpatch.c
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, const Value* patch,
SinkFn sink, void* token, SHA_CTX* ctx); SinkFn sink, void* token, SHA_CTX* ctx);
// freecache.c // freecache.c

11
applypatch/applypatch.sh
View file

@ -11,7 +11,7 @@
# the tests. # the tests.
EMULATOR_PORT=5580 EMULATOR_PORT=5580
DATA_DIR=$ANDROID_BUILD_TOP/build/tools/applypatch/testdata DATA_DIR=$ANDROID_BUILD_TOP/bootable/recovery/applypatch/testdata
# This must be the filename that applypatch uses for its copies. # This must be the filename that applypatch uses for its copies.
CACHE_TEMP_SOURCE=/cache/saved.file CACHE_TEMP_SOURCE=/cache/saved.file
@ -81,6 +81,7 @@ cleanup() {
testname "removing test files" testname "removing test files"
run_command rm $WORK_DIR/bloat.dat run_command rm $WORK_DIR/bloat.dat
run_command rm $WORK_DIR/old.file run_command rm $WORK_DIR/old.file
run_command rm $WORK_DIR/foo
run_command rm $WORK_DIR/patch.bsdiff run_command rm $WORK_DIR/patch.bsdiff
run_command rm $WORK_DIR/applypatch run_command rm $WORK_DIR/applypatch
run_command rm $CACHE_TEMP_SOURCE run_command rm $CACHE_TEMP_SOURCE
@ -88,10 +89,12 @@ cleanup() {
[ "$pid_emulator" == "" ] || kill $pid_emulator [ "$pid_emulator" == "" ] || kill $pid_emulator
rm -rf $tmpdir if [ $# == 0 ]; then
rm -rf $tmpdir
fi
} }
cleanup cleanup leave_tmp
$ADB push $ANDROID_PRODUCT_OUT/system/bin/applypatch $WORK_DIR/applypatch $ADB push $ANDROID_PRODUCT_OUT/system/bin/applypatch $WORK_DIR/applypatch
@ -153,6 +156,8 @@ run_command $WORK_DIR/applypatch -c $WORK_DIR/old.file $BAD2_SHA1 $BAD1_SHA1 &&
$ADB push $DATA_DIR/old.file $WORK_DIR $ADB push $DATA_DIR/old.file $WORK_DIR
$ADB push $DATA_DIR/patch.bsdiff $WORK_DIR $ADB push $DATA_DIR/patch.bsdiff $WORK_DIR
echo hello > $tmpdir/foo
$ADB push $tmpdir/foo $WORK_DIR
# Check that the partition has enough space to apply the patch without # Check that the partition has enough space to apply the patch without
# copying. If it doesn't, we'll be testing the low-space condition # copying. If it doesn't, we'll be testing the low-space condition

364
applypatch/bspatch.c
View file

@ -32,221 +32,221 @@
#include "applypatch.h" #include "applypatch.h"
void ShowBSDiffLicense() { void ShowBSDiffLicense() {
puts("The bsdiff library used herein is:\n" puts("The bsdiff library used herein is:\n"
"\n" "\n"
"Copyright 2003-2005 Colin Percival\n" "Copyright 2003-2005 Colin Percival\n"
"All rights reserved\n" "All rights reserved\n"
"\n" "\n"
"Redistribution and use in source and binary forms, with or without\n" "Redistribution and use in source and binary forms, with or without\n"
"modification, are permitted providing that the following conditions\n" "modification, are permitted providing that the following conditions\n"
"are met:\n" "are met:\n"
"1. Redistributions of source code must retain the above copyright\n" "1. Redistributions of source code must retain the above copyright\n"
" notice, this list of conditions and the following disclaimer.\n" " notice, this list of conditions and the following disclaimer.\n"
"2. Redistributions in binary form must reproduce the above copyright\n" "2. Redistributions in binary form must reproduce the above copyright\n"
" notice, this list of conditions and the following disclaimer in the\n" " notice, this list of conditions and the following disclaimer in the\n"
" documentation and/or other materials provided with the distribution.\n" " documentation and/or other materials provided with the distribution.\n"
"\n" "\n"
"THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n" "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n"
"IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n" "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n"
"WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n" "WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
"ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n" "ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n"
"DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n" "DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n"
"DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n" "DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n"
"OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n" "OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n"
"HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n" "HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n"
"STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\n" "STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\n"
"IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n" "IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
"POSSIBILITY OF SUCH DAMAGE.\n" "POSSIBILITY OF SUCH DAMAGE.\n"
"\n------------------\n\n" "\n------------------\n\n"
"This program uses Julian R Seward's \"libbzip2\" library, available\n" "This program uses Julian R Seward's \"libbzip2\" library, available\n"
"from http://www.bzip.org/.\n" "from http://www.bzip.org/.\n"
); );
} }
static off_t offtin(u_char *buf) static off_t offtin(u_char *buf)
{ {
off_t y; off_t y;
y=buf[7]&0x7F; y=buf[7]&0x7F;
y=y*256;y+=buf[6]; y=y*256;y+=buf[6];
y=y*256;y+=buf[5]; y=y*256;y+=buf[5];
y=y*256;y+=buf[4]; y=y*256;y+=buf[4];
y=y*256;y+=buf[3]; y=y*256;y+=buf[3];
y=y*256;y+=buf[2]; y=y*256;y+=buf[2];
y=y*256;y+=buf[1]; y=y*256;y+=buf[1];
y=y*256;y+=buf[0]; y=y*256;y+=buf[0];
if(buf[7]&0x80) y=-y; if(buf[7]&0x80) y=-y;
return y; return y;
} }
int FillBuffer(unsigned char* buffer, int size, bz_stream* stream) {
stream->next_out = (char*)buffer;
stream->avail_out = size;
while (stream->avail_out > 0) {
int bzerr = BZ2_bzDecompress(stream);
if (bzerr != BZ_OK && bzerr != BZ_STREAM_END) {
printf("bz error %d decompressing\n", bzerr);
return -1;
}
if (stream->avail_out > 0) {
printf("need %d more bytes\n", stream->avail_out);
}
}
return 0;
}
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t patch_offset, const Value* patch, ssize_t patch_offset,
SinkFn sink, void* token, SHA_CTX* ctx) { SinkFn sink, void* token, SHA_CTX* ctx) {
unsigned char* new_data; unsigned char* new_data;
ssize_t new_size; ssize_t new_size;
if (ApplyBSDiffPatchMem(old_data, old_size, patch_filename, patch_offset, if (ApplyBSDiffPatchMem(old_data, old_size, patch, patch_offset,
&new_data, &new_size) != 0) { &new_data, &new_size) != 0) {
return -1; return -1;
} }
if (sink(new_data, new_size, token) < new_size) { if (sink(new_data, new_size, token) < new_size) {
fprintf(stderr, "short write of output: %d (%s)\n", errno, strerror(errno)); printf("short write of output: %d (%s)\n", errno, strerror(errno));
return 1; return 1;
} }
if (ctx) { if (ctx) {
SHA_update(ctx, new_data, new_size); SHA_update(ctx, new_data, new_size);
} }
free(new_data); free(new_data);
return 0; return 0;
} }
int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size, int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t patch_offset, const Value* patch, ssize_t patch_offset,
unsigned char** new_data, ssize_t* new_size) { unsigned char** new_data, ssize_t* new_size) {
// Patch data format:
// 0 8 "BSDIFF40"
// 8 8 X
// 16 8 Y
// 24 8 sizeof(newfile)
// 32 X bzip2(control block)
// 32+X Y bzip2(diff block)
// 32+X+Y ??? bzip2(extra block)
// with control block 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".
FILE* f; unsigned char* header = (unsigned char*) patch->data + patch_offset;
if ((f = fopen(patch_filename, "rb")) == NULL) { if (memcmp(header, "BSDIFF40", 8) != 0) {
fprintf(stderr, "failed to open patch file\n"); printf("corrupt bsdiff patch file header (magic number)\n");
return 1;
}
// File format:
// 0 8 "BSDIFF40"
// 8 8 X
// 16 8 Y
// 24 8 sizeof(newfile)
// 32 X bzip2(control block)
// 32+X Y bzip2(diff block)
// 32+X+Y ??? bzip2(extra block)
// with control block 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".
fseek(f, patch_offset, SEEK_SET);
unsigned char header[32];
if (fread(header, 1, 32, f) < 32) {
fprintf(stderr, "failed to read patch file header\n");
return 1;
}
if (memcmp(header, "BSDIFF40", 8) != 0) {
fprintf(stderr, "corrupt bsdiff patch file header (magic number)\n");
return 1;
}
ssize_t ctrl_len, data_len;
ctrl_len = offtin(header+8);
data_len = offtin(header+16);
*new_size = offtin(header+24);
if (ctrl_len < 0 || data_len < 0 || *new_size < 0) {
fprintf(stderr, "corrupt patch file header (data lengths)\n");
return 1;
}
fclose(f);
int bzerr;
#define OPEN_AT(f, bzf, offset) \
FILE* f; \
BZFILE* bzf; \
if ((f = fopen(patch_filename, "rb")) == NULL) { \
fprintf(stderr, "failed to open patch file\n"); \
return 1; \
} \
if (fseeko(f, offset+patch_offset, SEEK_SET)) { \
fprintf(stderr, "failed to seek in patch file\n"); \
return 1; \
} \
if ((bzf = BZ2_bzReadOpen(&bzerr, f, 0, 0, NULL, 0)) == NULL) { \
fprintf(stderr, "failed to bzReadOpen in patch file (%d)\n", bzerr); \
return 1; \
}
OPEN_AT(cpf, cpfbz2, 32);
OPEN_AT(dpf, dpfbz2, 32+ctrl_len);
OPEN_AT(epf, epfbz2, 32+ctrl_len+data_len);
#undef OPEN_AT
*new_data = malloc(*new_size);
if (*new_data == NULL) {
fprintf(stderr, "failed to allocate %d bytes of memory for output file\n",
(int)*new_size);
return 1;
}
off_t oldpos = 0, newpos = 0;
off_t ctrl[3];
off_t len_read;
int i;
unsigned char buf[8];
while (newpos < *new_size) {
// Read control data
for (i = 0; i < 3; ++i) {
len_read = BZ2_bzRead(&bzerr, cpfbz2, buf, 8);
if (len_read < 8 || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) {
fprintf(stderr, "corrupt patch (read control)\n");
return 1; return 1;
}
ctrl[i] = offtin(buf);
} }
// Sanity check ssize_t ctrl_len, data_len;
if (newpos + ctrl[0] > *new_size) { ctrl_len = offtin(header+8);
fprintf(stderr, "corrupt patch (new file overrun)\n"); data_len = offtin(header+16);
return 1; *new_size = offtin(header+24);
if (ctrl_len < 0 || data_len < 0 || *new_size < 0) {
printf("corrupt patch file header (data lengths)\n");
return 1;
} }
// Read diff string int bzerr;
len_read = BZ2_bzRead(&bzerr, dpfbz2, *new_data + newpos, ctrl[0]);
if (len_read < ctrl[0] || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) { bz_stream cstream;
fprintf(stderr, "corrupt patch (read diff)\n"); cstream.next_in = patch->data + patch_offset + 32;
return 1; cstream.avail_in = ctrl_len;
cstream.bzalloc = NULL;
cstream.bzfree = NULL;
cstream.opaque = NULL;
if ((bzerr = BZ2_bzDecompressInit(&cstream, 0, 0)) != BZ_OK) {
printf("failed to bzinit control stream (%d)\n", bzerr);
} }
// Add old data to diff string bz_stream dstream;
for (i = 0; i < ctrl[0]; ++i) { dstream.next_in = patch->data + patch_offset + 32 + ctrl_len;
if ((oldpos+i >= 0) && (oldpos+i < old_size)) { dstream.avail_in = data_len;
(*new_data)[newpos+i] += old_data[oldpos+i]; dstream.bzalloc = NULL;
} dstream.bzfree = NULL;
dstream.opaque = NULL;
if ((bzerr = BZ2_bzDecompressInit(&dstream, 0, 0)) != BZ_OK) {
printf("failed to bzinit diff stream (%d)\n", bzerr);
} }
// Adjust pointers bz_stream estream;
newpos += ctrl[0]; estream.next_in = patch->data + patch_offset + 32 + ctrl_len + data_len;
oldpos += ctrl[0]; estream.avail_in = patch->size - (patch_offset + 32 + ctrl_len + data_len);
estream.bzalloc = NULL;
// Sanity check estream.bzfree = NULL;
if (newpos + ctrl[1] > *new_size) { estream.opaque = NULL;
fprintf(stderr, "corrupt patch (new file overrun)\n"); if ((bzerr = BZ2_bzDecompressInit(&estream, 0, 0)) != BZ_OK) {
return 1; printf("failed to bzinit extra stream (%d)\n", bzerr);
} }
// Read extra string *new_data = malloc(*new_size);
len_read = BZ2_bzRead(&bzerr, epfbz2, *new_data + newpos, ctrl[1]); if (*new_data == NULL) {
if (len_read < ctrl[1] || !(bzerr == BZ_OK || bzerr == BZ_STREAM_END)) { printf("failed to allocate %ld bytes of memory for output file\n",
fprintf(stderr, "corrupt patch (read extra)\n"); (long)*new_size);
return 1; return 1;
} }
// Adjust pointers off_t oldpos = 0, newpos = 0;
newpos += ctrl[1]; off_t ctrl[3];
oldpos += ctrl[2]; off_t len_read;
} int i;
unsigned char buf[24];
while (newpos < *new_size) {
// Read control data
if (FillBuffer(buf, 24, &cstream) != 0) {
printf("error while reading control stream\n");
return 1;
}
ctrl[0] = offtin(buf);
ctrl[1] = offtin(buf+8);
ctrl[2] = offtin(buf+16);
BZ2_bzReadClose(&bzerr, cpfbz2); // Sanity check
BZ2_bzReadClose(&bzerr, dpfbz2); if (newpos + ctrl[0] > *new_size) {
BZ2_bzReadClose(&bzerr, epfbz2); printf("corrupt patch (new file overrun)\n");
fclose(cpf); return 1;
fclose(dpf); }
fclose(epf);
return 0; // Read diff string
if (FillBuffer(*new_data + newpos, ctrl[0], &dstream) != 0) {
printf("error while reading diff stream\n");
return 1;
}
// Add old data to diff string
for (i = 0; i < ctrl[0]; ++i) {
if ((oldpos+i >= 0) && (oldpos+i < old_size)) {
(*new_data)[newpos+i] += old_data[oldpos+i];
}
}
// Adjust pointers
newpos += ctrl[0];
oldpos += ctrl[0];
// Sanity check
if (newpos + ctrl[1] > *new_size) {
printf("corrupt patch (new file overrun)\n");
return 1;
}
// Read extra string
if (FillBuffer(*new_data + newpos, ctrl[1], &estream) != 0) {
printf("error while reading extra stream\n");
return 1;
}
// Adjust pointers
newpos += ctrl[1];
oldpos += ctrl[2];
}
BZ2_bzDecompressEnd(&cstream);
BZ2_bzDecompressEnd(&dstream);
BZ2_bzDecompressEnd(&estream);
return 0;
} }

493
applypatch/imgpatch.c
View file

@ -36,329 +36,184 @@
* Return 0 on success. * Return 0 on success.
*/ */
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, const Value* patch,
SinkFn sink, void* token, SHA_CTX* ctx) { SinkFn sink, void* token, SHA_CTX* ctx) {
FILE* f; ssize_t pos = 12;
if ((f = fopen(patch_filename, "rb")) == NULL) { char* header = patch->data;
printf("failed to open patch file\n"); if (patch->size < 12) {
return -1; printf("patch too short to contain header\n");
} return -1;
unsigned char header[12];
if (fread(header, 1, 12, f) != 12) {
printf("failed to read patch file header\n");
return -1;
}
// IMGDIFF1 uses CHUNK_NORMAL and CHUNK_GZIP.
// IMGDIFF2 uses CHUNK_NORMAL, CHUNK_DEFLATE, and CHUNK_RAW.
if (memcmp(header, "IMGDIFF", 7) != 0 ||
(header[7] != '1' && header[7] != '2')) {
printf("corrupt patch file header (magic number)\n");
return -1;
}
int num_chunks = Read4(header+8);
int i;
for (i = 0; i < num_chunks; ++i) {
// each chunk's header record starts with 4 bytes.
unsigned char chunk[4];
if (fread(chunk, 1, 4, f) != 4) {
printf("failed to read chunk %d record\n", i);
return -1;
} }
int type = Read4(chunk); // IMGDIFF2 uses CHUNK_NORMAL, CHUNK_DEFLATE, and CHUNK_RAW.
// (IMGDIFF1, which is no longer supported, used CHUNK_NORMAL and
if (type == CHUNK_NORMAL) { // CHUNK_GZIP.)
unsigned char normal_header[24]; if (memcmp(header, "IMGDIFF2", 8) != 0) {
if (fread(normal_header, 1, 24, f) != 24) { printf("corrupt patch file header (magic number)\n");
printf("failed to read chunk %d normal header data\n", i);
return -1; return -1;
}
size_t src_start = Read8(normal_header);
size_t src_len = Read8(normal_header+8);
size_t patch_offset = Read8(normal_header+16);
printf("CHUNK %d: normal patch offset %d\n", i, patch_offset);
ApplyBSDiffPatch(old_data + src_start, src_len,
patch_filename, patch_offset,
sink, token, ctx);
} else if (type == CHUNK_GZIP) {
// This branch is basically a duplicate of the CHUNK_DEFLATE
// branch, with a bit of extra processing for the gzip header
// and footer. I've avoided factoring the common code out since
// this branch will just be deleted when we drop support for
// IMGDIFF1.
// gzip chunks have an additional 64 + gzip_header_len + 8 bytes
// in their chunk header.
unsigned char* gzip = malloc(64);
if (fread(gzip, 1, 64, f) != 64) {
printf("failed to read chunk %d initial gzip header data\n",
i);
return -1;
}
size_t gzip_header_len = Read4(gzip+60);
gzip = realloc(gzip, 64 + gzip_header_len + 8);
if (fread(gzip+64, 1, gzip_header_len+8, f) != gzip_header_len+8) {
printf("failed to read chunk %d remaining gzip header data\n",
i);
return -1;
}
size_t src_start = Read8(gzip);
size_t src_len = Read8(gzip+8);
size_t patch_offset = Read8(gzip+16);
size_t expanded_len = Read8(gzip+24);
size_t target_len = Read8(gzip+32);
int gz_level = Read4(gzip+40);
int gz_method = Read4(gzip+44);
int gz_windowBits = Read4(gzip+48);
int gz_memLevel = Read4(gzip+52);
int gz_strategy = Read4(gzip+56);
printf("CHUNK %d: gzip patch offset %d\n", i, patch_offset);
// Decompress the source data; the chunk header tells us exactly
// how big we expect it to be when decompressed.
unsigned char* expanded_source = malloc(expanded_len);
if (expanded_source == NULL) {
printf("failed to allocate %d bytes for expanded_source\n",
expanded_len);
return -1;
}
z_stream strm;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = src_len - (gzip_header_len + 8);
strm.next_in = (unsigned char*)(old_data + src_start + gzip_header_len);
strm.avail_out = expanded_len;
strm.next_out = expanded_source;
int ret;
ret = inflateInit2(&strm, -15);
if (ret != Z_OK) {
printf("failed to init source inflation: %d\n", ret);
return -1;
}
// Because we've provided enough room to accommodate the output
// data, we expect one call to inflate() to suffice.
ret = inflate(&strm, Z_SYNC_FLUSH);
if (ret != Z_STREAM_END) {
printf("source inflation returned %d\n", ret);
return -1;
}
// We should have filled the output buffer exactly.
if (strm.avail_out != 0) {
printf("source inflation short by %d bytes\n", strm.avail_out);
return -1;
}
inflateEnd(&strm);
// Next, apply the bsdiff patch (in memory) to the uncompressed
// data.
unsigned char* uncompressed_target_data;
ssize_t uncompressed_target_size;
if (ApplyBSDiffPatchMem(expanded_source, expanded_len,
patch_filename, patch_offset,
&uncompressed_target_data,
&uncompressed_target_size) != 0) {
return -1;
}
// Now compress the target data and append it to the output.
// start with the gzip header.
sink(gzip+64, gzip_header_len, token);
SHA_update(ctx, gzip+64, gzip_header_len);
// we're done with the expanded_source data buffer, so we'll
// reuse that memory to receive the output of deflate.
unsigned char* temp_data = expanded_source;
ssize_t temp_size = expanded_len;
if (temp_size < 32768) {
// ... unless the buffer is too small, in which case we'll
// allocate a fresh one.
free(temp_data);
temp_data = malloc(32768);
temp_size = 32768;
}
// now the deflate stream
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = uncompressed_target_size;
strm.next_in = uncompressed_target_data;
ret = deflateInit2(&strm, gz_level, gz_method, gz_windowBits,
gz_memLevel, gz_strategy);
do {
strm.avail_out = temp_size;
strm.next_out = temp_data;
ret = deflate(&strm, Z_FINISH);
size_t have = temp_size - strm.avail_out;
if (sink(temp_data, have, token) != have) {
printf("failed to write %d compressed bytes to output\n",
have);
return -1;
}
SHA_update(ctx, temp_data, have);
} while (ret != Z_STREAM_END);
deflateEnd(&strm);
// lastly, the gzip footer.
sink(gzip+64+gzip_header_len, 8, token);
SHA_update(ctx, gzip+64+gzip_header_len, 8);
free(temp_data);
free(uncompressed_target_data);
free(gzip);
} else if (type == CHUNK_RAW) {
unsigned char raw_header[4];
if (fread(raw_header, 1, 4, f) != 4) {
printf("failed to read chunk %d raw header data\n", i);
return -1;
}
size_t data_len = Read4(raw_header);
printf("CHUNK %d: raw data %d\n", i, data_len);
unsigned char* temp = malloc(data_len);
if (fread(temp, 1, data_len, f) != data_len) {
printf("failed to read chunk %d raw data\n", i);
return -1;
}
SHA_update(ctx, temp, data_len);
if (sink(temp, data_len, token) != data_len) {
printf("failed to write chunk %d raw data\n", i);
return -1;
}
} else if (type == CHUNK_DEFLATE) {
// deflate chunks have an additional 60 bytes in their chunk header.
unsigned char deflate_header[60];
if (fread(deflate_header, 1, 60, f) != 60) {
printf("failed to read chunk %d deflate header data\n", i);
return -1;
}
size_t src_start = Read8(deflate_header);
size_t src_len = Read8(deflate_header+8);
size_t patch_offset = Read8(deflate_header+16);
size_t expanded_len = Read8(deflate_header+24);
size_t target_len = Read8(deflate_header+32);
int level = Read4(deflate_header+40);
int method = Read4(deflate_header+44);
int windowBits = Read4(deflate_header+48);
int memLevel = Read4(deflate_header+52);
int strategy = Read4(deflate_header+56);
printf("CHUNK %d: deflate patch offset %d\n", i, patch_offset);
// Decompress the source data; the chunk header tells us exactly
// how big we expect it to be when decompressed.
unsigned char* expanded_source = malloc(expanded_len);
if (expanded_source == NULL) {
printf("failed to allocate %d bytes for expanded_source\n",
expanded_len);
return -1;
}
z_stream strm;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = src_len;
strm.next_in = (unsigned char*)(old_data + src_start);
strm.avail_out = expanded_len;
strm.next_out = expanded_source;
int ret;
ret = inflateInit2(&strm, -15);
if (ret != Z_OK) {
printf("failed to init source inflation: %d\n", ret);
return -1;
}
// Because we've provided enough room to accommodate the output
// data, we expect one call to inflate() to suffice.
ret = inflate(&strm, Z_SYNC_FLUSH);
if (ret != Z_STREAM_END) {
printf("source inflation returned %d\n", ret);
return -1;
}
// We should have filled the output buffer exactly.
if (strm.avail_out != 0) {
printf("source inflation short by %d bytes\n", strm.avail_out);
return -1;
}
inflateEnd(&strm);
// Next, apply the bsdiff patch (in memory) to the uncompressed
// data.
unsigned char* uncompressed_target_data;
ssize_t uncompressed_target_size;
if (ApplyBSDiffPatchMem(expanded_source, expanded_len,
patch_filename, patch_offset,
&uncompressed_target_data,
&uncompressed_target_size) != 0) {
return -1;
}
// Now compress the target data and append it to the output.
// we're done with the expanded_source data buffer, so we'll
// reuse that memory to receive the output of deflate.
unsigned char* temp_data = expanded_source;
ssize_t temp_size = expanded_len;
if (temp_size < 32768) {
// ... unless the buffer is too small, in which case we'll
// allocate a fresh one.
free(temp_data);
temp_data = malloc(32768);
temp_size = 32768;
}
// now the deflate stream
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = uncompressed_target_size;
strm.next_in = uncompressed_target_data;
ret = deflateInit2(&strm, level, method, windowBits, memLevel, strategy);
do {
strm.avail_out = temp_size;
strm.next_out = temp_data;
ret = deflate(&strm, Z_FINISH);
size_t have = temp_size - strm.avail_out;
if (sink(temp_data, have, token) != have) {
printf("failed to write %d compressed bytes to output\n",
have);
return -1;
}
SHA_update(ctx, temp_data, have);
} while (ret != Z_STREAM_END);
deflateEnd(&strm);
free(temp_data);
free(uncompressed_target_data);
} else {
printf("patch chunk %d is unknown type %d\n", i, type);
return -1;
} }
}
return 0; int num_chunks = Read4(header+8);
int i;
for (i = 0; i < num_chunks; ++i) {
// each chunk's header record starts with 4 bytes.
if (pos + 4 > patch->size) {
printf("failed to read chunk %d record\n", i);
return -1;
}
int type = Read4(patch->data + pos);
pos += 4;
if (type == CHUNK_NORMAL) {
char* normal_header = patch->data + pos;
pos += 24;
if (pos > patch->size) {
printf("failed to read chunk %d normal header data\n", i);
return -1;
}
size_t src_start = Read8(normal_header);
size_t src_len = Read8(normal_header+8);
size_t patch_offset = Read8(normal_header+16);
ApplyBSDiffPatch(old_data + src_start, src_len,
patch, patch_offset, sink, token, ctx);
} else if (type == CHUNK_RAW) {
char* raw_header = patch->data + pos;
pos += 4;
if (pos > patch->size) {
printf("failed to read chunk %d raw header data\n", i);
return -1;
}
ssize_t data_len = Read4(raw_header);
if (pos + data_len > patch->size) {
printf("failed to read chunk %d raw data\n", i);
return -1;
}
SHA_update(ctx, patch->data + pos, data_len);
if (sink((unsigned char*)patch->data + pos,
data_len, token) != data_len) {
printf("failed to write chunk %d raw data\n", i);
return -1;
}
pos += data_len;
} else if (type == CHUNK_DEFLATE) {
// deflate chunks have an additional 60 bytes in their chunk header.
char* deflate_header = patch->data + pos;
pos += 60;
if (pos > patch->size) {
printf("failed to read chunk %d deflate header data\n", i);
return -1;
}
size_t src_start = Read8(deflate_header);
size_t src_len = Read8(deflate_header+8);
size_t patch_offset = Read8(deflate_header+16);
size_t expanded_len = Read8(deflate_header+24);
size_t target_len = Read8(deflate_header+32);
int level = Read4(deflate_header+40);
int method = Read4(deflate_header+44);
int windowBits = Read4(deflate_header+48);
int memLevel = Read4(deflate_header+52);
int strategy = Read4(deflate_header+56);
// Decompress the source data; the chunk header tells us exactly
// how big we expect it to be when decompressed.
unsigned char* expanded_source = malloc(expanded_len);
if (expanded_source == NULL) {
printf("failed to allocate %d bytes for expanded_source\n",
expanded_len);
return -1;
}
z_stream strm;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = src_len;
strm.next_in = (unsigned char*)(old_data + src_start);
strm.avail_out = expanded_len;
strm.next_out = expanded_source;
int ret;
ret = inflateInit2(&strm, -15);
if (ret != Z_OK) {
printf("failed to init source inflation: %d\n", ret);
return -1;
}
// Because we've provided enough room to accommodate the output
// data, we expect one call to inflate() to suffice.
ret = inflate(&strm, Z_SYNC_FLUSH);
if (ret != Z_STREAM_END) {
printf("source inflation returned %d\n", ret);
return -1;
}
// We should have filled the output buffer exactly.
if (strm.avail_out != 0) {
printf("source inflation short by %d bytes\n", strm.avail_out);
return -1;
}
inflateEnd(&strm);
// Next, apply the bsdiff patch (in memory) to the uncompressed
// data.
unsigned char* uncompressed_target_data;
ssize_t uncompressed_target_size;
if (ApplyBSDiffPatchMem(expanded_source, expanded_len,
patch, patch_offset,
&uncompressed_target_data,
&uncompressed_target_size) != 0) {
return -1;
}
// Now compress the target data and append it to the output.
// we're done with the expanded_source data buffer, so we'll
// reuse that memory to receive the output of deflate.
unsigned char* temp_data = expanded_source;
ssize_t temp_size = expanded_len;
if (temp_size < 32768) {
// ... unless the buffer is too small, in which case we'll
// allocate a fresh one.
free(temp_data);
temp_data = malloc(32768);
temp_size = 32768;
}
// now the deflate stream
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
strm.avail_in = uncompressed_target_size;
strm.next_in = uncompressed_target_data;
ret = deflateInit2(&strm, level, method, windowBits, memLevel, strategy);
do {
strm.avail_out = temp_size;
strm.next_out = temp_data;
ret = deflate(&strm, Z_FINISH);
ssize_t have = temp_size - strm.avail_out;
if (sink(temp_data, have, token) != have) {
printf("failed to write %ld compressed bytes to output\n",
(long)have);
return -1;
}
SHA_update(ctx, temp_data, have);
} while (ret != Z_STREAM_END);
deflateEnd(&strm);
free(temp_data);
free(uncompressed_target_data);
} else {
printf("patch chunk %d is unknown type %d\n", i, type);
return -1;
}
}
return 0;
} }

147
applypatch/main.c
View file

@ -15,8 +15,126 @@
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
extern int applypatch(int argc, char** argv); #include "applypatch.h"
#include "edify/expr.h"
#include "mincrypt/sha.h"
int CheckMode(int argc, char** argv) {
if (argc < 3) {
return 2;
}
return applypatch_check(argv[2], argc-3, argv+3);
}
int SpaceMode(int argc, char** argv) {
if (argc != 3) {
return 2;
}
char* endptr;
size_t bytes = strtol(argv[2], &endptr, 10);
if (bytes == 0 && endptr == argv[2]) {
printf("can't parse \"%s\" as byte count\n\n", argv[2]);
return 1;
}
return CacheSizeCheck(bytes);
}
// Parse arguments (which should be of the form "<sha1>" or
// "<sha1>:<filename>" into the new parallel arrays *sha1s and
// *patches (loading file contents into the patches). Returns 0 on
// success.
static int ParsePatchArgs(int argc, char** argv,
char*** sha1s, Value*** patches, int* num_patches) {
*num_patches = argc;
*sha1s = malloc(*num_patches * sizeof(char*));
*patches = malloc(*num_patches * sizeof(Value*));
memset(*patches, 0, *num_patches * sizeof(Value*));
uint8_t digest[SHA_DIGEST_SIZE];
int i;
for (i = 0; i < *num_patches; ++i) {
char* colon = strchr(argv[i], ':');
if (colon != NULL) {
*colon = '\0';
++colon;
}
if (ParseSha1(argv[i], digest) != 0) {
printf("failed to parse sha1 \"%s\"\n", argv[i]);
return -1;
}
(*sha1s)[i] = argv[i];
if (colon == NULL) {
(*patches)[i] = NULL;
} else {
FileContents fc;
if (LoadFileContents(colon, &fc) != 0) {
goto abort;
}
(*patches)[i] = malloc(sizeof(Value));
(*patches)[i]->type = VAL_BLOB;
(*patches)[i]->size = fc.size;
(*patches)[i]->data = (char*)fc.data;
}
}
return 0;
abort:
for (i = 0; i < *num_patches; ++i) {
Value* p = (*patches)[i];
if (p != NULL) {
free(p->data);
free(p);
}
}
free(*sha1s);
free(*patches);
return -1;
}
int PatchMode(int argc, char** argv) {
if (argc < 6) {
return 2;
}
char* endptr;
size_t target_size = strtol(argv[4], &endptr, 10);
if (target_size == 0 && endptr == argv[4]) {
printf("can't parse \"%s\" as byte count\n\n", argv[4]);
return 1;
}
char** sha1s;
Value** patches;
int num_patches;
if (ParsePatchArgs(argc-5, argv+5, &sha1s, &patches, &num_patches) != 0) {
printf("failed to parse patch args\n");
return 1;
}
int result = applypatch(argv[1], argv[2], argv[3], target_size,
num_patches, sha1s, patches);
int i;
for (i = 0; i < num_patches; ++i) {
Value* p = patches[i];
if (p != NULL) {
free(p->data);
free(p);
}
}
free(sha1s);
free(patches);
return result;
}
// This program applies binary patches to files in a way that is safe // This program applies binary patches to files in a way that is safe
// (the original file is not touched until we have the desired // (the original file is not touched until we have the desired
@ -42,9 +160,9 @@ extern int applypatch(int argc, char** argv);
// LoadMTDContents() function above for the format of such a filename. // LoadMTDContents() function above for the format of such a filename.
int main(int argc, char** argv) { int main(int argc, char** argv) {
int result = applypatch(argc, argv); if (argc < 2) {
if (result == 2) { usage:
printf( printf(
"usage: %s <src-file> <tgt-file> <tgt-sha1> <tgt-size> " "usage: %s <src-file> <tgt-file> <tgt-sha1> <tgt-size> "
"[<src-sha1>:<patch> ...]\n" "[<src-sha1>:<patch> ...]\n"
" or %s -c <file> [<sha1> ...]\n" " or %s -c <file> [<sha1> ...]\n"
@ -55,6 +173,23 @@ int main(int argc, char** argv) {
" MTD:<partition>:<len_1>:<sha1_1>:<len_2>:<sha1_2>:...\n" " MTD:<partition>:<len_1>:<sha1_1>:<len_2>:<sha1_2>:...\n"
"to specify reading from or writing to an MTD partition.\n\n", "to specify reading from or writing to an MTD partition.\n\n",
argv[0], argv[0], argv[0], argv[0]); argv[0], argv[0], argv[0], argv[0]);
} return 2;
return result; }
int result;
if (strncmp(argv[1], "-l", 3) == 0) {
result = ShowLicenses();
} else if (strncmp(argv[1], "-c", 3) == 0) {
result = CheckMode(argc, argv);
} else if (strncmp(argv[1], "-s", 3) == 0) {
result = SpaceMode(argc, argv);
} else {
result = PatchMode(argc, argv);
}
if (result == 2) {
goto usage;
}
return result;
} }

37
applypatch/utils.c
View file

@ -38,25 +38,28 @@ void Write8(long long value, FILE* f) {
fputc((value >> 56) & 0xff, f); fputc((value >> 56) & 0xff, f);
} }
int Read2(unsigned char* p) { int Read2(void* pv) {
return (int)(((unsigned int)p[1] << 8) | unsigned char* p = pv;
(unsigned int)p[0]); return (int)(((unsigned int)p[1] << 8) |
(unsigned int)p[0]);
} }
int Read4(unsigned char* p) { int Read4(void* pv) {
return (int)(((unsigned int)p[3] << 24) | unsigned char* p = pv;
((unsigned int)p[2] << 16) | return (int)(((unsigned int)p[3] << 24) |
((unsigned int)p[1] << 8) | ((unsigned int)p[2] << 16) |
(unsigned int)p[0]); ((unsigned int)p[1] << 8) |
(unsigned int)p[0]);
} }
long long Read8(unsigned char* p) { long long Read8(void* pv) {
return (long long)(((unsigned long long)p[7] << 56) | unsigned char* p = pv;
((unsigned long long)p[6] << 48) | return (long long)(((unsigned long long)p[7] << 56) |
((unsigned long long)p[5] << 40) | ((unsigned long long)p[6] << 48) |
((unsigned long long)p[4] << 32) | ((unsigned long long)p[5] << 40) |
((unsigned long long)p[3] << 24) | ((unsigned long long)p[4] << 32) |
((unsigned long long)p[2] << 16) | ((unsigned long long)p[3] << 24) |
((unsigned long long)p[1] << 8) | ((unsigned long long)p[2] << 16) |
(unsigned long long)p[0]); ((unsigned long long)p[1] << 8) |
(unsigned long long)p[0]);
} }

6
applypatch/utils.h
View file

@ -23,8 +23,8 @@
void Write4(int value, FILE* f); void Write4(int value, FILE* f);
void Write8(long long value, FILE* f); void Write8(long long value, FILE* f);
int Read2(unsigned char* p); int Read2(void* p);
int Read4(unsigned char* p); int Read4(void* p);
long long Read8(unsigned char* p); long long Read8(void* p);
#endif // _BUILD_TOOLS_APPLYPATCH_UTILS_H #endif // _BUILD_TOOLS_APPLYPATCH_UTILS_H

3
edify/main.c
View file

@ -42,11 +42,12 @@ int expect(const char* expr_str, const char* expected, int* errors) {
State state; State state;
state.cookie = NULL; state.cookie = NULL;
state.script = expr_str; state.script = strdup(expr_str);
state.errmsg = NULL; state.errmsg = NULL;
result = Evaluate(&state, e); result = Evaluate(&state, e);
free(state.errmsg); free(state.errmsg);
free(state.script);
if (result == NULL && expected != NULL) { if (result == NULL && expected != NULL) {
fprintf(stderr, "error evaluating \"%s\"\n", expr_str); fprintf(stderr, "error evaluating \"%s\"\n", expr_str);
++*errors; ++*errors;

2
edify/yydefs.h
View file

@ -33,4 +33,6 @@ typedef struct {
} \ } \
} while (0) } while (0)
int yylex();
#endif #endif

176
updater/install.c
View file

@ -705,52 +705,124 @@ done:
return StringValue(result); return StringValue(result);
} }
// apply_patch(srcfile, tgtfile, tgtsha1, tgtsize, sha1:patch, ...)
// apply_patch_check(file, sha1, ...)
// apply_patch_space(bytes) // apply_patch_space(bytes)
Value* ApplyPatchSpaceFn(const char* name, State* state,
int argc, Expr* argv[]) {
char* bytes_str;
if (ReadArgs(state, argv, 1, &bytes_str) < 0) {
return NULL;
}
char* endptr;
size_t bytes = strtol(bytes_str, &endptr, 10);
if (bytes == 0 && endptr == bytes_str) {
ErrorAbort(state, "%s(): can't parse \"%s\" as byte count\n\n",
name, bytes_str);
free(bytes_str);
return NULL;
}
return StringValue(strdup(CacheSizeCheck(bytes) ? "" : "t"));
}
// apply_patch(srcfile, tgtfile, tgtsha1, tgtsize, sha1_1, patch_1, ...)
Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) { Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) {
printf("in applypatchfn (%s)\n", name); if (argc < 6 || (argc % 2) == 1) {
return ErrorAbort(state, "%s(): expected at least 6 args and an "
char* prepend = NULL; "even number, got %d",
if (strstr(name, "check") != NULL) { name, argc);
prepend = "-c";
} else if (strstr(name, "space") != NULL) {
prepend = "-s";
} }
char** args = ReadVarArgs(state, argc, argv); char* source_filename;
if (args == NULL) return NULL; char* target_filename;
char* target_sha1;
// insert the "program name" argv[0] and a copy of the "prepend" char* target_size_str;
// string (if any) at the start of the args. if (ReadArgs(state, argv, 4, &source_filename, &target_filename,
&target_sha1, &target_size_str) < 0) {
int extra = 1 + (prepend != NULL ? 1 : 0); return NULL;
char** temp = malloc((argc+extra) * sizeof(char*));
memcpy(temp+extra, args, argc * sizeof(char*));
temp[0] = strdup("updater");
if (prepend) {
temp[1] = strdup(prepend);
} }
free(args);
args = temp;
argc += extra;
printf("calling applypatch\n"); char* endptr;
fflush(stdout); size_t target_size = strtol(target_size_str, &endptr, 10);
int result = applypatch(argc, args); if (target_size == 0 && endptr == target_size_str) {
printf("applypatch returned %d\n", result); ErrorAbort(state, "%s(): can't parse \"%s\" as byte count",
name, target_size_str);
free(source_filename);
free(target_filename);
free(target_sha1);
free(target_size_str);
return NULL;
}
int patchcount = (argc-4) / 2;
Value** patches = ReadValueVarArgs(state, argc-4, argv+4);
int i; int i;
for (i = 0; i < argc; ++i) { for (i = 0; i < patchcount; ++i) {
free(args[i]); if (patches[i*2]->type != VAL_STRING) {
ErrorAbort(state, "%s(): sha-1 #%d is not string", name, i);
break;
}
if (patches[i*2+1]->type != VAL_BLOB) {
ErrorAbort(state, "%s(): patch #%d is not blob", name, i);
break;
}
}
if (i != patchcount) {
for (i = 0; i < patchcount*2; ++i) {
FreeValue(patches[i]);
}
free(patches);
return NULL;
} }
free(args);
switch (result) { char** patch_sha_str = malloc(patchcount * sizeof(char*));
case 0: return StringValue(strdup("t")); for (i = 0; i < patchcount; ++i) {
case 1: return StringValue(strdup("")); patch_sha_str[i] = patches[i*2]->data;
default: return ErrorAbort(state, "applypatch couldn't parse args"); patches[i*2]->data = NULL;
FreeValue(patches[i*2]);
patches[i] = patches[i*2+1];
} }
int result = applypatch(source_filename, target_filename,
target_sha1, target_size,
patchcount, patch_sha_str, patches);
for (i = 0; i < patchcount; ++i) {
FreeValue(patches[i]);
}
free(patch_sha_str);
free(patches);
return StringValue(strdup(result == 0 ? "t" : ""));
}
// apply_patch_check(file, [sha1_1, ...])
Value* ApplyPatchCheckFn(const char* name, State* state,
int argc, Expr* argv[]) {
if (argc < 1) {
return ErrorAbort(state, "%s(): expected at least 1 arg, got %d",
name, argc);
}
char* filename;
if (ReadArgs(state, argv, 1, &filename) < 0) {
return NULL;
}
int patchcount = argc-1;
char** sha1s = ReadVarArgs(state, argc-1, argv+1);
int result = applypatch_check(filename, patchcount, sha1s);
int i;
for (i = 0; i < patchcount; ++i) {
free(sha1s[i]);
}
free(sha1s);
return StringValue(strdup(result == 0 ? "t" : ""));
} }
Value* UIPrintFn(const char* name, State* state, int argc, Expr* argv[]) { Value* UIPrintFn(const char* name, State* state, int argc, Expr* argv[]) {
@ -831,36 +903,6 @@ Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) {
return StringValue(strdup(buffer)); return StringValue(strdup(buffer));
} }
// Take a string 'str' of 40 hex digits and parse it into the 20
// byte array 'digest'. 'str' may contain only the digest or be of
// the form "<digest>:<anything>". Return 0 on success, -1 on any
// error.
static int ParseSha1(const char* str, uint8_t* digest) {
int i;
const char* ps = str;
uint8_t* pd = digest;
for (i = 0; i < SHA_DIGEST_SIZE * 2; ++i, ++ps) {
int digit;
if (*ps >= '0' && *ps <= '9') {
digit = *ps - '0';
} else if (*ps >= 'a' && *ps <= 'f') {
digit = *ps - 'a' + 10;
} else if (*ps >= 'A' && *ps <= 'F') {
digit = *ps - 'A' + 10;
} else {
return -1;
}
if (i % 2 == 0) {
*pd = digit << 4;
} else {
*pd |= digit;
++pd;
}
}
if (*ps != '\0') return -1;
return 0;
}
// Take a sha-1 digest and return it as a newly-allocated hex string. // Take a sha-1 digest and return it as a newly-allocated hex string.
static char* PrintSha1(uint8_t* digest) { static char* PrintSha1(uint8_t* digest) {
char* buffer = malloc(SHA_DIGEST_SIZE*2 + 1); char* buffer = malloc(SHA_DIGEST_SIZE*2 + 1);
@ -981,8 +1023,8 @@ void RegisterInstallFunctions() {
RegisterFunction("write_raw_image", WriteRawImageFn); RegisterFunction("write_raw_image", WriteRawImageFn);
RegisterFunction("apply_patch", ApplyPatchFn); RegisterFunction("apply_patch", ApplyPatchFn);
RegisterFunction("apply_patch_check", ApplyPatchFn); RegisterFunction("apply_patch_check", ApplyPatchCheckFn);
RegisterFunction("apply_patch_space", ApplyPatchFn); RegisterFunction("apply_patch_space", ApplyPatchSpaceFn);
RegisterFunction("read_file", ReadFileFn); RegisterFunction("read_file", ReadFileFn);
RegisterFunction("sha1_check", Sha1CheckFn); RegisterFunction("sha1_check", Sha1CheckFn);