am 0bacbfd0: Merge "recovery: Switch applypatch/ and updater/ to cpp."
* commit '0bacbfd03c866b9078f86216e6786da91238ac91': recovery: Switch applypatch/ and updater/ to cpp.
This commit is contained in:
Tao Bao
Android Git Automerger
commit
307eecfdc7
15 changed files with 304 additions and 300 deletions
|
|
@ -17,7 +17,7 @@ LOCAL_PATH := $(call my-dir)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_CLANG := true
|
||||
LOCAL_SRC_FILES := applypatch.c bspatch.c freecache.c imgpatch.c utils.c
|
||||
LOCAL_SRC_FILES := applypatch.cpp bspatch.cpp freecache.cpp imgpatch.cpp utils.cpp
|
||||
LOCAL_MODULE := libapplypatch
|
||||
LOCAL_MODULE_TAGS := eng
|
||||
LOCAL_C_INCLUDES += external/bzip2 external/zlib bootable/recovery
|
||||
|
|
@ -28,7 +28,7 @@ include $(BUILD_STATIC_LIBRARY)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_CLANG := true
|
||||
LOCAL_SRC_FILES := main.c
|
||||
LOCAL_SRC_FILES := main.cpp
|
||||
LOCAL_MODULE := applypatch
|
||||
LOCAL_C_INCLUDES += bootable/recovery
|
||||
LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz
|
||||
|
|
@ -39,7 +39,7 @@ include $(BUILD_EXECUTABLE)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_CLANG := true
|
||||
LOCAL_SRC_FILES := main.c
|
||||
LOCAL_SRC_FILES := main.cpp
|
||||
LOCAL_MODULE := applypatch_static
|
||||
LOCAL_FORCE_STATIC_EXECUTABLE := true
|
||||
LOCAL_MODULE_TAGS := eng
|
||||
|
|
@ -52,7 +52,7 @@ include $(BUILD_EXECUTABLE)
|
|||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_CLANG := true
|
||||
LOCAL_SRC_FILES := imgdiff.c utils.c bsdiff.c
|
||||
LOCAL_SRC_FILES := imgdiff.cpp utils.cpp bsdiff.cpp
|
||||
LOCAL_MODULE := imgdiff
|
||||
LOCAL_FORCE_STATIC_EXECUTABLE := true
|
||||
LOCAL_C_INCLUDES += external/zlib external/bzip2
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <libgen.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
|
@ -22,9 +23,7 @@
|
|||
#include <sys/stat.h>
|
||||
#include <sys/statfs.h>
|
||||
#include <sys/types.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "mincrypt/sha.h"
|
||||
#include "applypatch.h"
|
||||
|
|
@ -65,7 +64,7 @@ int LoadFileContents(const char* filename, FileContents* file) {
|
|||
}
|
||||
|
||||
file->size = file->st.st_size;
|
||||
file->data = malloc(file->size);
|
||||
file->data = reinterpret_cast<unsigned char*>(malloc(file->size));
|
||||
|
||||
FILE* f = fopen(filename, "rb");
|
||||
if (f == NULL) {
|
||||
|
|
@ -75,10 +74,9 @@ int LoadFileContents(const char* filename, FileContents* file) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
ssize_t bytes_read = fread(file->data, 1, file->size, f);
|
||||
if (bytes_read != file->size) {
|
||||
printf("short read of \"%s\" (%ld bytes of %ld)\n",
|
||||
filename, (long)bytes_read, (long)file->size);
|
||||
size_t bytes_read = fread(file->data, 1, file->size, f);
|
||||
if (bytes_read != static_cast<size_t>(file->size)) {
|
||||
printf("short read of \"%s\" (%zu bytes of %zd)\n", filename, bytes_read, file->size);
|
||||
free(file->data);
|
||||
file->data = NULL;
|
||||
return -1;
|
||||
|
|
@ -93,8 +91,8 @@ static size_t* size_array;
|
|||
// comparison function for qsort()ing an int array of indexes into
|
||||
// size_array[].
|
||||
static int compare_size_indices(const void* a, const void* b) {
|
||||
int aa = *(int*)a;
|
||||
int bb = *(int*)b;
|
||||
const int aa = *reinterpret_cast<const int*>(a);
|
||||
const int bb = *reinterpret_cast<const int*>(b);
|
||||
if (size_array[aa] < size_array[bb]) {
|
||||
return -1;
|
||||
} else if (size_array[aa] > size_array[bb]) {
|
||||
|
|
@ -132,8 +130,7 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
} else if (strcmp(magic, "EMMC") == 0) {
|
||||
type = EMMC;
|
||||
} else {
|
||||
printf("LoadPartitionContents called with bad filename (%s)\n",
|
||||
filename);
|
||||
printf("LoadPartitionContents called with bad filename (%s)\n", filename);
|
||||
return -1;
|
||||
}
|
||||
const char* partition = strtok(NULL, ":");
|
||||
|
|
@ -151,9 +148,9 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
}
|
||||
|
||||
int pairs = (colons-1)/2; // # of (size,sha1) pairs in filename
|
||||
int* index = malloc(pairs * sizeof(int));
|
||||
size_t* size = malloc(pairs * sizeof(size_t));
|
||||
char** sha1sum = malloc(pairs * sizeof(char*));
|
||||
int* index = reinterpret_cast<int*>(malloc(pairs * sizeof(int)));
|
||||
size_t* size = reinterpret_cast<size_t*>(malloc(pairs * sizeof(size_t)));
|
||||
char** sha1sum = reinterpret_cast<char**>(malloc(pairs * sizeof(char*)));
|
||||
|
||||
for (i = 0; i < pairs; ++i) {
|
||||
const char* size_str = strtok(NULL, ":");
|
||||
|
|
@ -175,7 +172,7 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
FILE* dev = NULL;
|
||||
|
||||
switch (type) {
|
||||
case MTD:
|
||||
case MTD: {
|
||||
if (!mtd_partitions_scanned) {
|
||||
mtd_scan_partitions();
|
||||
mtd_partitions_scanned = 1;
|
||||
|
|
@ -195,6 +192,7 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
return -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case EMMC:
|
||||
dev = fopen(partition, "rb");
|
||||
|
|
@ -210,7 +208,7 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
uint8_t parsed_sha[SHA_DIGEST_SIZE];
|
||||
|
||||
// allocate enough memory to hold the largest size.
|
||||
file->data = malloc(size[index[pairs-1]]);
|
||||
file->data = reinterpret_cast<unsigned char*>(malloc(size[index[pairs-1]]));
|
||||
char* p = (char*)file->data;
|
||||
file->size = 0; // # bytes read so far
|
||||
|
||||
|
|
@ -248,8 +246,7 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
const uint8_t* sha_so_far = SHA_final(&temp_ctx);
|
||||
|
||||
if (ParseSha1(sha1sum[index[i]], parsed_sha) != 0) {
|
||||
printf("failed to parse sha1 %s in %s\n",
|
||||
sha1sum[index[i]], filename);
|
||||
printf("failed to parse sha1 %s in %s\n", sha1sum[index[i]], filename);
|
||||
free(file->data);
|
||||
file->data = NULL;
|
||||
return -1;
|
||||
|
|
@ -280,15 +277,14 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
if (i == pairs) {
|
||||
// Ran off the end of the list of (size,sha1) pairs without
|
||||
// finding a match.
|
||||
printf("contents of partition \"%s\" didn't match %s\n",
|
||||
partition, filename);
|
||||
printf("contents of partition \"%s\" didn't match %s\n", partition, filename);
|
||||
free(file->data);
|
||||
file->data = NULL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
const uint8_t* sha_final = SHA_final(&sha_ctx);
|
||||
for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
|
||||
for (size_t i = 0; i < SHA_DIGEST_SIZE; ++i) {
|
||||
file->sha1[i] = sha_final[i];
|
||||
}
|
||||
|
||||
|
|
@ -311,16 +307,14 @@ static int LoadPartitionContents(const char* filename, FileContents* file) {
|
|||
int SaveFileContents(const char* filename, const FileContents* file) {
|
||||
int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_SYNC, S_IRUSR | S_IWUSR);
|
||||
if (fd < 0) {
|
||||
printf("failed to open \"%s\" for write: %s\n",
|
||||
filename, strerror(errno));
|
||||
printf("failed to open \"%s\" for write: %s\n", filename, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
ssize_t bytes_written = FileSink(file->data, file->size, &fd);
|
||||
if (bytes_written != file->size) {
|
||||
printf("short write of \"%s\" (%ld bytes of %ld) (%s)\n",
|
||||
filename, (long)bytes_written, (long)file->size,
|
||||
strerror(errno));
|
||||
printf("short write of \"%s\" (%zd bytes of %zd) (%s)\n",
|
||||
filename, bytes_written, file->size, strerror(errno));
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -348,8 +342,7 @@ int SaveFileContents(const char* filename, const FileContents* file) {
|
|||
// Write a memory buffer to 'target' partition, a string of the form
|
||||
// "MTD:<partition>[:...]" or "EMMC:<partition_device>:". Return 0 on
|
||||
// success.
|
||||
int WriteToPartition(unsigned char* data, size_t len,
|
||||
const char* target) {
|
||||
int WriteToPartition(unsigned char* data, size_t len, const char* target) {
|
||||
char* copy = strdup(target);
|
||||
const char* magic = strtok(copy, ":");
|
||||
|
||||
|
|
@ -370,7 +363,7 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
}
|
||||
|
||||
switch (type) {
|
||||
case MTD:
|
||||
case MTD: {
|
||||
if (!mtd_partitions_scanned) {
|
||||
mtd_scan_partitions();
|
||||
mtd_partitions_scanned = 1;
|
||||
|
|
@ -378,22 +371,19 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
|
||||
const MtdPartition* mtd = mtd_find_partition_by_name(partition);
|
||||
if (mtd == NULL) {
|
||||
printf("mtd partition \"%s\" not found for writing\n",
|
||||
partition);
|
||||
printf("mtd partition \"%s\" not found for writing\n", partition);
|
||||
return -1;
|
||||
}
|
||||
|
||||
MtdWriteContext* ctx = mtd_write_partition(mtd);
|
||||
if (ctx == NULL) {
|
||||
printf("failed to init mtd partition \"%s\" for writing\n",
|
||||
partition);
|
||||
printf("failed to init mtd partition \"%s\" for writing\n", partition);
|
||||
return -1;
|
||||
}
|
||||
|
||||
size_t written = mtd_write_data(ctx, (char*)data, len);
|
||||
size_t written = mtd_write_data(ctx, reinterpret_cast<char*>(data), len);
|
||||
if (written != len) {
|
||||
printf("only wrote %zu of %zu bytes to MTD %s\n",
|
||||
written, len, partition);
|
||||
printf("only wrote %zu of %zu bytes to MTD %s\n", written, len, partition);
|
||||
mtd_write_close(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -409,22 +399,20 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
return -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case EMMC:
|
||||
{
|
||||
case EMMC: {
|
||||
size_t start = 0;
|
||||
int success = 0;
|
||||
bool success = false;
|
||||
int fd = open(partition, O_RDWR | O_SYNC);
|
||||
if (fd < 0) {
|
||||
printf("failed to open %s: %s\n", partition, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
int attempt;
|
||||
|
||||
for (attempt = 0; attempt < 2; ++attempt) {
|
||||
for (int attempt = 0; attempt < 2; ++attempt) {
|
||||
if (TEMP_FAILURE_RETRY(lseek(fd, start, SEEK_SET)) == -1) {
|
||||
printf("failed seek on %s: %s\n",
|
||||
partition, strerror(errno));
|
||||
printf("failed seek on %s: %s\n", partition, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
while (start < len) {
|
||||
|
|
@ -439,23 +427,20 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
start += written;
|
||||
}
|
||||
if (fsync(fd) != 0) {
|
||||
printf("failed to sync to %s (%s)\n",
|
||||
partition, strerror(errno));
|
||||
printf("failed to sync to %s (%s)\n", partition, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
if (close(fd) != 0) {
|
||||
printf("failed to close %s (%s)\n",
|
||||
partition, strerror(errno));
|
||||
printf("failed to close %s (%s)\n", partition, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
fd = open(partition, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
printf("failed to reopen %s for verify (%s)\n",
|
||||
partition, strerror(errno));
|
||||
printf("failed to reopen %s for verify (%s)\n", partition, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
// drop caches so our subsequent verification read
|
||||
// Drop caches so our subsequent verification read
|
||||
// won't just be reading the cache.
|
||||
sync();
|
||||
int dc = open("/proc/sys/vm/drop_caches", O_WRONLY);
|
||||
|
|
@ -475,10 +460,11 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
}
|
||||
unsigned char buffer[4096];
|
||||
start = len;
|
||||
size_t p;
|
||||
for (p = 0; p < len; p += sizeof(buffer)) {
|
||||
for (size_t p = 0; p < len; p += sizeof(buffer)) {
|
||||
size_t to_read = len - p;
|
||||
if (to_read > sizeof(buffer)) to_read = sizeof(buffer);
|
||||
if (to_read > sizeof(buffer)) {
|
||||
to_read = sizeof(buffer);
|
||||
}
|
||||
|
||||
size_t so_far = 0;
|
||||
while (so_far < to_read) {
|
||||
|
|
@ -489,14 +475,14 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
partition, p, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
if ((size_t)read_count < to_read) {
|
||||
if (static_cast<size_t>(read_count) < to_read) {
|
||||
printf("short verify read %s at %zu: %zd %zu %s\n",
|
||||
partition, p, read_count, to_read, strerror(errno));
|
||||
}
|
||||
so_far += read_count;
|
||||
}
|
||||
|
||||
if (memcmp(buffer, data+p, to_read)) {
|
||||
if (memcmp(buffer, data+p, to_read) != 0) {
|
||||
printf("verification failed starting at %zu\n", p);
|
||||
start = p;
|
||||
break;
|
||||
|
|
@ -534,10 +520,9 @@ int WriteToPartition(unsigned char* data, size_t len,
|
|||
// the form "<digest>:<anything>". Return 0 on success, -1 on any
|
||||
// error.
|
||||
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) {
|
||||
for (int i = 0; i < SHA_DIGEST_SIZE * 2; ++i, ++ps) {
|
||||
int digit;
|
||||
if (*ps >= '0' && *ps <= '9') {
|
||||
digit = *ps - '0';
|
||||
|
|
@ -564,9 +549,8 @@ int ParseSha1(const char* str, uint8_t* digest) {
|
|||
// found.
|
||||
int FindMatchingPatch(uint8_t* sha1, char* const * const patch_sha1_str,
|
||||
int num_patches) {
|
||||
int i;
|
||||
uint8_t patch_sha1[SHA_DIGEST_SIZE];
|
||||
for (i = 0; i < num_patches; ++i) {
|
||||
for (int i = 0; i < num_patches; ++i) {
|
||||
if (ParseSha1(patch_sha1_str[i], patch_sha1) == 0 &&
|
||||
memcmp(patch_sha1, sha1, SHA_DIGEST_SIZE) == 0) {
|
||||
return i;
|
||||
|
|
@ -578,8 +562,8 @@ int FindMatchingPatch(uint8_t* sha1, char* const * const patch_sha1_str,
|
|||
// Returns 0 if the contents of the file (argv[2]) or the cached file
|
||||
// match any of the sha1's on the command line (argv[3:]). Returns
|
||||
// nonzero otherwise.
|
||||
int applypatch_check(const char* filename,
|
||||
int num_patches, char** const patch_sha1_str) {
|
||||
int applypatch_check(const char* filename, int num_patches,
|
||||
char** const patch_sha1_str) {
|
||||
FileContents file;
|
||||
file.data = NULL;
|
||||
|
||||
|
|
@ -624,13 +608,13 @@ int ShowLicenses() {
|
|||
}
|
||||
|
||||
ssize_t FileSink(const unsigned char* data, ssize_t len, void* token) {
|
||||
int fd = *(int *)token;
|
||||
int fd = *reinterpret_cast<int *>(token);
|
||||
ssize_t done = 0;
|
||||
ssize_t wrote;
|
||||
while (done < (ssize_t) len) {
|
||||
while (done < len) {
|
||||
wrote = TEMP_FAILURE_RETRY(write(fd, data+done, len-done));
|
||||
if (wrote == -1) {
|
||||
printf("error writing %d bytes: %s\n", (int)(len-done), strerror(errno));
|
||||
printf("error writing %zd bytes: %s\n", (len-done), strerror(errno));
|
||||
return done;
|
||||
}
|
||||
done += wrote;
|
||||
|
|
@ -645,7 +629,7 @@ typedef struct {
|
|||
} MemorySinkInfo;
|
||||
|
||||
ssize_t MemorySink(const unsigned char* data, ssize_t len, void* token) {
|
||||
MemorySinkInfo* msi = (MemorySinkInfo*)token;
|
||||
MemorySinkInfo* msi = reinterpret_cast<MemorySinkInfo*>(token);
|
||||
if (msi->size - msi->pos < len) {
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -675,9 +659,8 @@ int CacheSizeCheck(size_t bytes) {
|
|||
}
|
||||
|
||||
static void print_short_sha1(const uint8_t sha1[SHA_DIGEST_SIZE]) {
|
||||
int i;
|
||||
const char* hex = "0123456789abcdef";
|
||||
for (i = 0; i < 4; ++i) {
|
||||
for (size_t i = 0; i < 4; ++i) {
|
||||
putchar(hex[(sha1[i]>>4) & 0xf]);
|
||||
putchar(hex[sha1[i] & 0xf]);
|
||||
}
|
||||
|
|
@ -719,8 +702,7 @@ int applypatch(const char* source_filename,
|
|||
Value* bonus_data) {
|
||||
printf("patch %s: ", source_filename);
|
||||
|
||||
if (target_filename[0] == '-' &&
|
||||
target_filename[1] == '\0') {
|
||||
if (target_filename[0] == '-' && target_filename[1] == '\0') {
|
||||
target_filename = source_filename;
|
||||
}
|
||||
|
||||
|
|
@ -761,8 +743,7 @@ int applypatch(const char* source_filename,
|
|||
}
|
||||
|
||||
if (source_file.data != NULL) {
|
||||
int to_use = FindMatchingPatch(source_file.sha1,
|
||||
patch_sha1_str, num_patches);
|
||||
int to_use = FindMatchingPatch(source_file.sha1, patch_sha1_str, num_patches);
|
||||
if (to_use >= 0) {
|
||||
source_patch_value = patch_data[to_use];
|
||||
}
|
||||
|
|
@ -779,8 +760,7 @@ int applypatch(const char* source_filename,
|
|||
return 1;
|
||||
}
|
||||
|
||||
int to_use = FindMatchingPatch(copy_file.sha1,
|
||||
patch_sha1_str, num_patches);
|
||||
int to_use = FindMatchingPatch(copy_file.sha1, patch_sha1_str, num_patches);
|
||||
if (to_use >= 0) {
|
||||
copy_patch_value = patch_data[to_use];
|
||||
}
|
||||
|
|
@ -865,8 +845,8 @@ static int GenerateTarget(FileContents* source_file,
|
|||
(free_space > (256 << 10)) && // 256k (two-block) minimum
|
||||
(free_space > (target_size * 3 / 2)); // 50% margin of error
|
||||
if (!enough_space) {
|
||||
printf("target %ld bytes; free space %ld bytes; retry %d; enough %d\n",
|
||||
(long)target_size, (long)free_space, retry, enough_space);
|
||||
printf("target %zu bytes; free space %zu bytes; retry %d; enough %d\n",
|
||||
target_size, free_space, retry, enough_space);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -884,8 +864,7 @@ static int GenerateTarget(FileContents* source_file,
|
|||
// It's impossible to free space on the target filesystem by
|
||||
// deleting the source if the source is a partition. If
|
||||
// we're ever in a state where we need to do this, fail.
|
||||
printf("not enough free space for target but source "
|
||||
"is partition\n");
|
||||
printf("not enough free space for target but source is partition\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -902,7 +881,7 @@ static int GenerateTarget(FileContents* source_file,
|
|||
unlink(source_filename);
|
||||
|
||||
size_t free_space = FreeSpaceForFile(target_fs);
|
||||
printf("(now %ld bytes free for target) ", (long)free_space);
|
||||
printf("(now %zu bytes free for target) ", free_space);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -927,10 +906,9 @@ static int GenerateTarget(FileContents* source_file,
|
|||
if (strncmp(target_filename, "MTD:", 4) == 0 ||
|
||||
strncmp(target_filename, "EMMC:", 5) == 0) {
|
||||
// We store the decoded output in memory.
|
||||
msi.buffer = malloc(target_size);
|
||||
msi.buffer = reinterpret_cast<unsigned char*>(malloc(target_size));
|
||||
if (msi.buffer == NULL) {
|
||||
printf("failed to alloc %ld bytes for output\n",
|
||||
(long)target_size);
|
||||
printf("failed to alloc %zu bytes for output\n", target_size);
|
||||
return 1;
|
||||
}
|
||||
msi.pos = 0;
|
||||
|
|
@ -939,12 +917,11 @@ static int GenerateTarget(FileContents* source_file,
|
|||
token = &msi;
|
||||
} else {
|
||||
// We write the decoded output to "<tgt-file>.patch".
|
||||
outname = (char*)malloc(strlen(target_filename) + 10);
|
||||
outname = reinterpret_cast<char*>(malloc(strlen(target_filename) + 10));
|
||||
strcpy(outname, target_filename);
|
||||
strcat(outname, ".patch");
|
||||
|
||||
output = open(outname, O_WRONLY | O_CREAT | O_TRUNC | O_SYNC,
|
||||
S_IRUSR | S_IWUSR);
|
||||
output = open(outname, O_WRONLY | O_CREAT | O_TRUNC | O_SYNC, S_IRUSR | S_IWUSR);
|
||||
if (output < 0) {
|
||||
printf("failed to open output file %s: %s\n",
|
||||
outname, strerror(errno));
|
||||
|
|
@ -1025,23 +1002,23 @@ static int GenerateTarget(FileContents* source_file,
|
|||
printf("chmod of \"%s\" failed: %s\n", outname, strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
if (chown(outname, source_to_use->st.st_uid,
|
||||
source_to_use->st.st_gid) != 0) {
|
||||
if (chown(outname, source_to_use->st.st_uid, source_to_use->st.st_gid) != 0) {
|
||||
printf("chown of \"%s\" failed: %s\n", outname, strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Finally, rename the .patch file to replace the target file.
|
||||
if (rename(outname, target_filename) != 0) {
|
||||
printf("rename of .patch to \"%s\" failed: %s\n",
|
||||
target_filename, strerror(errno));
|
||||
printf("rename of .patch to \"%s\" failed: %s\n", target_filename, strerror(errno));
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
// If this run of applypatch created the copy, and we're here, we
|
||||
// can delete it.
|
||||
if (made_copy) unlink(CACHE_TEMP_SOURCE);
|
||||
if (made_copy) {
|
||||
unlink(CACHE_TEMP_SOURCE);
|
||||
}
|
||||
|
||||
// Success!
|
||||
return 0;
|
||||
|
|
@ -156,24 +156,24 @@ static void qsufsort(off_t *I,off_t *V,u_char *old,off_t oldsize)
|
|||
for(i=0;i<oldsize+1;i++) I[V[i]]=i;
|
||||
}
|
||||
|
||||
static off_t matchlen(u_char *old,off_t oldsize,u_char *new,off_t newsize)
|
||||
static off_t matchlen(u_char *olddata,off_t oldsize,u_char *newdata,off_t newsize)
|
||||
{
|
||||
off_t i;
|
||||
|
||||
for(i=0;(i<oldsize)&&(i<newsize);i++)
|
||||
if(old[i]!=new[i]) break;
|
||||
if(olddata[i]!=newdata[i]) break;
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static off_t search(off_t *I,u_char *old,off_t oldsize,
|
||||
u_char *new,off_t newsize,off_t st,off_t en,off_t *pos)
|
||||
u_char *newdata,off_t newsize,off_t st,off_t en,off_t *pos)
|
||||
{
|
||||
off_t x,y;
|
||||
|
||||
if(en-st<2) {
|
||||
x=matchlen(old+I[st],oldsize-I[st],new,newsize);
|
||||
y=matchlen(old+I[en],oldsize-I[en],new,newsize);
|
||||
x=matchlen(old+I[st],oldsize-I[st],newdata,newsize);
|
||||
y=matchlen(old+I[en],oldsize-I[en],newdata,newsize);
|
||||
|
||||
if(x>y) {
|
||||
*pos=I[st];
|
||||
|
|
@ -185,10 +185,10 @@ static off_t search(off_t *I,u_char *old,off_t oldsize,
|
|||
};
|
||||
|
||||
x=st+(en-st)/2;
|
||||
if(memcmp(old+I[x],new,MIN(oldsize-I[x],newsize))<0) {
|
||||
return search(I,old,oldsize,new,newsize,x,en,pos);
|
||||
if(memcmp(old+I[x],newdata,MIN(oldsize-I[x],newsize))<0) {
|
||||
return search(I,old,oldsize,newdata,newsize,x,en,pos);
|
||||
} else {
|
||||
return search(I,old,oldsize,new,newsize,st,x,pos);
|
||||
return search(I,old,oldsize,newdata,newsize,st,x,pos);
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -212,8 +212,8 @@ static void offtout(off_t x,u_char *buf)
|
|||
|
||||
// This is main() from bsdiff.c, with the following changes:
|
||||
//
|
||||
// - old, oldsize, new, newsize are arguments; we don't load this
|
||||
// data from files. old and new are owned by the caller; we
|
||||
// - old, oldsize, newdata, newsize are arguments; we don't load this
|
||||
// data from files. old and newdata are owned by the caller; we
|
||||
// don't free them at the end.
|
||||
//
|
||||
// - the "I" block of memory is owned by the caller, who passes a
|
||||
|
|
@ -221,7 +221,7 @@ static void offtout(off_t x,u_char *buf)
|
|||
// bsdiff() multiple times with the same 'old' data, we only do
|
||||
// the qsufsort() step the first time.
|
||||
//
|
||||
int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
||||
int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* newdata, off_t newsize,
|
||||
const char* patch_filename)
|
||||
{
|
||||
int fd;
|
||||
|
|
@ -242,15 +242,15 @@ int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
|||
|
||||
if (*IP == NULL) {
|
||||
off_t* V;
|
||||
*IP = malloc((oldsize+1) * sizeof(off_t));
|
||||
V = malloc((oldsize+1) * sizeof(off_t));
|
||||
*IP = reinterpret_cast<off_t*>(malloc((oldsize+1) * sizeof(off_t)));
|
||||
V = reinterpret_cast<off_t*>(malloc((oldsize+1) * sizeof(off_t)));
|
||||
qsufsort(*IP, V, old, oldsize);
|
||||
free(V);
|
||||
}
|
||||
I = *IP;
|
||||
|
||||
if(((db=malloc(newsize+1))==NULL) ||
|
||||
((eb=malloc(newsize+1))==NULL)) err(1,NULL);
|
||||
if(((db=reinterpret_cast<u_char*>(malloc(newsize+1)))==NULL) ||
|
||||
((eb=reinterpret_cast<u_char*>(malloc(newsize+1)))==NULL)) err(1,NULL);
|
||||
dblen=0;
|
||||
eblen=0;
|
||||
|
||||
|
|
@ -284,26 +284,26 @@ int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
|||
oldscore=0;
|
||||
|
||||
for(scsc=scan+=len;scan<newsize;scan++) {
|
||||
len=search(I,old,oldsize,new+scan,newsize-scan,
|
||||
len=search(I,old,oldsize,newdata+scan,newsize-scan,
|
||||
0,oldsize,&pos);
|
||||
|
||||
for(;scsc<scan+len;scsc++)
|
||||
if((scsc+lastoffset<oldsize) &&
|
||||
(old[scsc+lastoffset] == new[scsc]))
|
||||
(old[scsc+lastoffset] == newdata[scsc]))
|
||||
oldscore++;
|
||||
|
||||
if(((len==oldscore) && (len!=0)) ||
|
||||
(len>oldscore+8)) break;
|
||||
|
||||
if((scan+lastoffset<oldsize) &&
|
||||
(old[scan+lastoffset] == new[scan]))
|
||||
(old[scan+lastoffset] == newdata[scan]))
|
||||
oldscore--;
|
||||
};
|
||||
|
||||
if((len!=oldscore) || (scan==newsize)) {
|
||||
s=0;Sf=0;lenf=0;
|
||||
for(i=0;(lastscan+i<scan)&&(lastpos+i<oldsize);) {
|
||||
if(old[lastpos+i]==new[lastscan+i]) s++;
|
||||
if(old[lastpos+i]==newdata[lastscan+i]) s++;
|
||||
i++;
|
||||
if(s*2-i>Sf*2-lenf) { Sf=s; lenf=i; };
|
||||
};
|
||||
|
|
@ -312,7 +312,7 @@ int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
|||
if(scan<newsize) {
|
||||
s=0;Sb=0;
|
||||
for(i=1;(scan>=lastscan+i)&&(pos>=i);i++) {
|
||||
if(old[pos-i]==new[scan-i]) s++;
|
||||
if(old[pos-i]==newdata[scan-i]) s++;
|
||||
if(s*2-i>Sb*2-lenb) { Sb=s; lenb=i; };
|
||||
};
|
||||
};
|
||||
|
|
@ -321,9 +321,9 @@ int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
|||
overlap=(lastscan+lenf)-(scan-lenb);
|
||||
s=0;Ss=0;lens=0;
|
||||
for(i=0;i<overlap;i++) {
|
||||
if(new[lastscan+lenf-overlap+i]==
|
||||
if(newdata[lastscan+lenf-overlap+i]==
|
||||
old[lastpos+lenf-overlap+i]) s++;
|
||||
if(new[scan-lenb+i]==
|
||||
if(newdata[scan-lenb+i]==
|
||||
old[pos-lenb+i]) s--;
|
||||
if(s>Ss) { Ss=s; lens=i+1; };
|
||||
};
|
||||
|
|
@ -333,9 +333,9 @@ int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
|||
};
|
||||
|
||||
for(i=0;i<lenf;i++)
|
||||
db[dblen+i]=new[lastscan+i]-old[lastpos+i];
|
||||
db[dblen+i]=newdata[lastscan+i]-old[lastpos+i];
|
||||
for(i=0;i<(scan-lenb)-(lastscan+lenf);i++)
|
||||
eb[eblen+i]=new[lastscan+lenf+i];
|
||||
eb[eblen+i]=newdata[lastscan+lenf+i];
|
||||
|
||||
dblen+=lenf;
|
||||
eblen+=(scan-lenb)-(lastscan+lenf);
|
||||
|
|
@ -182,10 +182,9 @@ int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size,
|
|||
printf("failed to bzinit extra stream (%d)\n", bzerr);
|
||||
}
|
||||
|
||||
*new_data = malloc(*new_size);
|
||||
*new_data = reinterpret_cast<unsigned char*>(malloc(*new_size));
|
||||
if (*new_data == NULL) {
|
||||
printf("failed to allocate %ld bytes of memory for output file\n",
|
||||
(long)*new_size);
|
||||
printf("failed to allocate %zd bytes of memory for output file\n", *new_size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -1,3 +1,19 @@
|
|||
/*
|
||||
* Copyright (C) 2010 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <libgen.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -76,7 +92,7 @@ int FindExpendableFiles(char*** names, int* entries) {
|
|||
struct dirent* de;
|
||||
int size = 32;
|
||||
*entries = 0;
|
||||
*names = malloc(size * sizeof(char*));
|
||||
*names = reinterpret_cast<char**>(malloc(size * sizeof(char*)));
|
||||
|
||||
char path[FILENAME_MAX];
|
||||
|
||||
|
|
@ -84,8 +100,7 @@ int FindExpendableFiles(char*** names, int* entries) {
|
|||
// directories.
|
||||
const char* dirs[2] = {"/cache", "/cache/recovery/otatest"};
|
||||
|
||||
unsigned int i;
|
||||
for (i = 0; i < sizeof(dirs)/sizeof(dirs[0]); ++i) {
|
||||
for (size_t i = 0; i < sizeof(dirs)/sizeof(dirs[0]); ++i) {
|
||||
d = opendir(dirs[i]);
|
||||
if (d == NULL) {
|
||||
printf("error opening %s: %s\n", dirs[i], strerror(errno));
|
||||
|
|
@ -107,7 +122,7 @@ int FindExpendableFiles(char*** names, int* entries) {
|
|||
if (stat(path, &st) == 0 && S_ISREG(st.st_mode)) {
|
||||
if (*entries >= size) {
|
||||
size *= 2;
|
||||
*names = realloc(*names, size * sizeof(char*));
|
||||
*names = reinterpret_cast<char**>(realloc(*names, size * sizeof(char*)));
|
||||
}
|
||||
(*names)[(*entries)++] = strdup(path);
|
||||
}
|
||||
|
|
@ -127,8 +142,7 @@ int FindExpendableFiles(char*** names, int* entries) {
|
|||
|
||||
int MakeFreeSpaceOnCache(size_t bytes_needed) {
|
||||
size_t free_now = FreeSpaceForFile("/cache");
|
||||
printf("%ld bytes free on /cache (%ld needed)\n",
|
||||
(long)free_now, (long)bytes_needed);
|
||||
printf("%zu bytes free on /cache (%zu needed)\n", free_now, bytes_needed);
|
||||
|
||||
if (free_now >= bytes_needed) {
|
||||
return 0;
|
||||
|
|
@ -158,7 +172,7 @@ int MakeFreeSpaceOnCache(size_t bytes_needed) {
|
|||
if (names[i]) {
|
||||
unlink(names[i]);
|
||||
free_now = FreeSpaceForFile("/cache");
|
||||
printf("deleted %s; now %ld bytes free\n", names[i], (long)free_now);
|
||||
printf("deleted %s; now %zu bytes free\n", names[i], free_now);
|
||||
free(names[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -122,6 +122,7 @@
|
|||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
|
@ -179,7 +180,7 @@ static int fileentry_compare(const void* a, const void* b) {
|
|||
}
|
||||
|
||||
// from bsdiff.c
|
||||
int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* new, off_t newsize,
|
||||
int bsdiff(u_char* old, off_t oldsize, off_t** IP, u_char* newdata, off_t newsize,
|
||||
const char* patch_filename);
|
||||
|
||||
unsigned char* ReadZip(const char* filename,
|
||||
|
|
@ -191,9 +192,10 @@ unsigned char* ReadZip(const char* filename,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
unsigned char* img = malloc(st.st_size);
|
||||
size_t sz = static_cast<size_t>(st.st_size);
|
||||
unsigned char* img = reinterpret_cast<unsigned char*>(malloc(sz));
|
||||
FILE* f = fopen(filename, "rb");
|
||||
if (fread(img, 1, st.st_size, f) != st.st_size) {
|
||||
if (fread(img, 1, sz, f) != sz) {
|
||||
printf("failed to read \"%s\" %s\n", filename, strerror(errno));
|
||||
fclose(f);
|
||||
return NULL;
|
||||
|
|
@ -218,7 +220,8 @@ unsigned char* ReadZip(const char* filename,
|
|||
int cdcount = Read2(img+i+8);
|
||||
int cdoffset = Read4(img+i+16);
|
||||
|
||||
ZipFileEntry* temp_entries = malloc(cdcount * sizeof(ZipFileEntry));
|
||||
ZipFileEntry* temp_entries = reinterpret_cast<ZipFileEntry*>(malloc(
|
||||
cdcount * sizeof(ZipFileEntry)));
|
||||
int entrycount = 0;
|
||||
|
||||
unsigned char* cd = img+cdoffset;
|
||||
|
|
@ -235,7 +238,7 @@ unsigned char* ReadZip(const char* filename,
|
|||
int mlen = Read2(cd+32); // file comment len
|
||||
int hoffset = Read4(cd+42); // local header offset
|
||||
|
||||
char* filename = malloc(nlen+1);
|
||||
char* filename = reinterpret_cast<char*>(malloc(nlen+1));
|
||||
memcpy(filename, cd+46, nlen);
|
||||
filename[nlen] = '\0';
|
||||
|
||||
|
|
@ -284,7 +287,7 @@ unsigned char* ReadZip(const char* filename,
|
|||
#endif
|
||||
|
||||
*num_chunks = 0;
|
||||
*chunks = malloc((entrycount*2+2) * sizeof(ImageChunk));
|
||||
*chunks = reinterpret_cast<ImageChunk*>(malloc((entrycount*2+2) * sizeof(ImageChunk)));
|
||||
ImageChunk* curr = *chunks;
|
||||
|
||||
if (include_pseudo_chunk) {
|
||||
|
|
@ -311,7 +314,7 @@ unsigned char* ReadZip(const char* filename,
|
|||
curr->I = NULL;
|
||||
|
||||
curr->len = temp_entries[nextentry].uncomp_len;
|
||||
curr->data = malloc(curr->len);
|
||||
curr->data = reinterpret_cast<unsigned char*>(malloc(curr->len));
|
||||
|
||||
z_stream strm;
|
||||
strm.zalloc = Z_NULL;
|
||||
|
|
@ -381,9 +384,10 @@ unsigned char* ReadImage(const char* filename,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
unsigned char* img = malloc(st.st_size + 4);
|
||||
size_t sz = static_cast<size_t>(st.st_size);
|
||||
unsigned char* img = reinterpret_cast<unsigned char*>(malloc(sz + 4));
|
||||
FILE* f = fopen(filename, "rb");
|
||||
if (fread(img, 1, st.st_size, f) != st.st_size) {
|
||||
if (fread(img, 1, sz, f) != sz) {
|
||||
printf("failed to read \"%s\" %s\n", filename, strerror(errno));
|
||||
fclose(f);
|
||||
return NULL;
|
||||
|
|
@ -393,17 +397,17 @@ unsigned char* ReadImage(const char* filename,
|
|||
// append 4 zero bytes to the data so we can always search for the
|
||||
// four-byte string 1f8b0800 starting at any point in the actual
|
||||
// file data, without special-casing the end of the data.
|
||||
memset(img+st.st_size, 0, 4);
|
||||
memset(img+sz, 0, 4);
|
||||
|
||||
size_t pos = 0;
|
||||
|
||||
*num_chunks = 0;
|
||||
*chunks = NULL;
|
||||
|
||||
while (pos < st.st_size) {
|
||||
while (pos < sz) {
|
||||
unsigned char* p = img+pos;
|
||||
|
||||
if (st.st_size - pos >= 4 &&
|
||||
if (sz - pos >= 4 &&
|
||||
p[0] == 0x1f && p[1] == 0x8b &&
|
||||
p[2] == 0x08 && // deflate compression
|
||||
p[3] == 0x00) { // no header flags
|
||||
|
|
@ -411,7 +415,8 @@ unsigned char* ReadImage(const char* filename,
|
|||
size_t chunk_offset = pos;
|
||||
|
||||
*num_chunks += 3;
|
||||
*chunks = realloc(*chunks, *num_chunks * sizeof(ImageChunk));
|
||||
*chunks = reinterpret_cast<ImageChunk*>(realloc(*chunks,
|
||||
*num_chunks * sizeof(ImageChunk)));
|
||||
ImageChunk* curr = *chunks + (*num_chunks-3);
|
||||
|
||||
// create a normal chunk for the header.
|
||||
|
|
@ -435,7 +440,7 @@ unsigned char* ReadImage(const char* filename,
|
|||
|
||||
size_t allocated = 32768;
|
||||
curr->len = 0;
|
||||
curr->data = malloc(allocated);
|
||||
curr->data = reinterpret_cast<unsigned char*>(malloc(allocated));
|
||||
curr->start = pos;
|
||||
curr->deflate_data = p;
|
||||
|
||||
|
|
@ -443,7 +448,7 @@ unsigned char* ReadImage(const char* filename,
|
|||
strm.zalloc = Z_NULL;
|
||||
strm.zfree = Z_NULL;
|
||||
strm.opaque = Z_NULL;
|
||||
strm.avail_in = st.st_size - pos;
|
||||
strm.avail_in = sz - pos;
|
||||
strm.next_in = p;
|
||||
|
||||
// -15 means we are decoding a 'raw' deflate stream; zlib will
|
||||
|
|
@ -465,11 +470,11 @@ unsigned char* ReadImage(const char* filename,
|
|||
curr->len = allocated - strm.avail_out;
|
||||
if (strm.avail_out == 0) {
|
||||
allocated *= 2;
|
||||
curr->data = realloc(curr->data, allocated);
|
||||
curr->data = reinterpret_cast<unsigned char*>(realloc(curr->data, allocated));
|
||||
}
|
||||
} while (ret != Z_STREAM_END);
|
||||
|
||||
curr->deflate_len = st.st_size - strm.avail_in - pos;
|
||||
curr->deflate_len = sz - strm.avail_in - pos;
|
||||
inflateEnd(&strm);
|
||||
pos += curr->deflate_len;
|
||||
p += curr->deflate_len;
|
||||
|
|
@ -493,7 +498,7 @@ unsigned char* ReadImage(const char* filename,
|
|||
// the decompression.
|
||||
size_t footer_size = Read4(p-4);
|
||||
if (footer_size != curr[-2].len) {
|
||||
printf("Error: footer size %d != decompressed size %d\n",
|
||||
printf("Error: footer size %zu != decompressed size %zu\n",
|
||||
footer_size, curr[-2].len);
|
||||
free(img);
|
||||
return NULL;
|
||||
|
|
@ -502,7 +507,7 @@ unsigned char* ReadImage(const char* filename,
|
|||
// Reallocate the list for every chunk; we expect the number of
|
||||
// chunks to be small (5 for typical boot and recovery images).
|
||||
++*num_chunks;
|
||||
*chunks = realloc(*chunks, *num_chunks * sizeof(ImageChunk));
|
||||
*chunks = reinterpret_cast<ImageChunk*>(realloc(*chunks, *num_chunks * sizeof(ImageChunk)));
|
||||
ImageChunk* curr = *chunks + (*num_chunks-1);
|
||||
curr->start = pos;
|
||||
curr->I = NULL;
|
||||
|
|
@ -512,7 +517,7 @@ unsigned char* ReadImage(const char* filename,
|
|||
curr->type = CHUNK_NORMAL;
|
||||
curr->data = p;
|
||||
|
||||
for (curr->len = 0; curr->len < (st.st_size - pos); ++curr->len) {
|
||||
for (curr->len = 0; curr->len < (sz - pos); ++curr->len) {
|
||||
if (p[curr->len] == 0x1f &&
|
||||
p[curr->len+1] == 0x8b &&
|
||||
p[curr->len+2] == 0x08 &&
|
||||
|
|
@ -587,7 +592,7 @@ int ReconstructDeflateChunk(ImageChunk* chunk) {
|
|||
}
|
||||
|
||||
size_t p = 0;
|
||||
unsigned char* out = malloc(BUFFER_SIZE);
|
||||
unsigned char* out = reinterpret_cast<unsigned char*>(malloc(BUFFER_SIZE));
|
||||
|
||||
// We only check two combinations of encoder parameters: level 6
|
||||
// (the default) and level 9 (the maximum).
|
||||
|
|
@ -638,9 +643,11 @@ unsigned char* MakePatch(ImageChunk* src, ImageChunk* tgt, size_t* size) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
unsigned char* data = malloc(st.st_size);
|
||||
size_t sz = static_cast<size_t>(st.st_size);
|
||||
// TODO: Memory leak on error return.
|
||||
unsigned char* data = reinterpret_cast<unsigned char*>(malloc(sz));
|
||||
|
||||
if (tgt->type == CHUNK_NORMAL && tgt->len <= st.st_size) {
|
||||
if (tgt->type == CHUNK_NORMAL && tgt->len <= sz) {
|
||||
unlink(ptemp);
|
||||
|
||||
tgt->type = CHUNK_RAW;
|
||||
|
|
@ -648,14 +655,14 @@ unsigned char* MakePatch(ImageChunk* src, ImageChunk* tgt, size_t* size) {
|
|||
return tgt->data;
|
||||
}
|
||||
|
||||
*size = st.st_size;
|
||||
*size = sz;
|
||||
|
||||
FILE* f = fopen(ptemp, "rb");
|
||||
if (f == NULL) {
|
||||
printf("failed to open patch %s: %s\n", ptemp, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
if (fread(data, 1, st.st_size, f) != st.st_size) {
|
||||
if (fread(data, 1, sz, f) != sz) {
|
||||
printf("failed to read patch %s: %s\n", ptemp, strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -781,9 +788,8 @@ ImageChunk* FindChunkByName(const char* name,
|
|||
}
|
||||
|
||||
void DumpChunks(ImageChunk* chunks, int num_chunks) {
|
||||
int i;
|
||||
for (i = 0; i < num_chunks; ++i) {
|
||||
printf("chunk %d: type %d start %d len %d\n",
|
||||
for (int i = 0; i < num_chunks; ++i) {
|
||||
printf("chunk %d: type %d start %zu len %zu\n",
|
||||
i, chunks[i].type, chunks[i].start, chunks[i].len);
|
||||
}
|
||||
}
|
||||
|
|
@ -806,7 +812,7 @@ int main(int argc, char** argv) {
|
|||
return 1;
|
||||
}
|
||||
bonus_size = st.st_size;
|
||||
bonus_data = malloc(bonus_size);
|
||||
bonus_data = reinterpret_cast<unsigned char*>(malloc(bonus_size));
|
||||
FILE* f = fopen(argv[2], "rb");
|
||||
if (f == NULL) {
|
||||
printf("failed to open bonus file %s: %s\n", argv[2], strerror(errno));
|
||||
|
|
@ -953,8 +959,9 @@ int main(int argc, char** argv) {
|
|||
DumpChunks(src_chunks, num_src_chunks);
|
||||
|
||||
printf("Construct patches for %d chunks...\n", num_tgt_chunks);
|
||||
unsigned char** patch_data = malloc(num_tgt_chunks * sizeof(unsigned char*));
|
||||
size_t* patch_size = malloc(num_tgt_chunks * sizeof(size_t));
|
||||
unsigned char** patch_data = reinterpret_cast<unsigned char**>(malloc(
|
||||
num_tgt_chunks * sizeof(unsigned char*)));
|
||||
size_t* patch_size = reinterpret_cast<size_t*>(malloc(num_tgt_chunks * sizeof(size_t)));
|
||||
for (i = 0; i < num_tgt_chunks; ++i) {
|
||||
if (zip_mode) {
|
||||
ImageChunk* src;
|
||||
|
|
@ -967,15 +974,16 @@ int main(int argc, char** argv) {
|
|||
}
|
||||
} else {
|
||||
if (i == 1 && bonus_data) {
|
||||
printf(" using %d bytes of bonus data for chunk %d\n", bonus_size, i);
|
||||
src_chunks[i].data = realloc(src_chunks[i].data, src_chunks[i].len + bonus_size);
|
||||
printf(" using %zu bytes of bonus data for chunk %d\n", bonus_size, i);
|
||||
src_chunks[i].data = reinterpret_cast<unsigned char*>(realloc(src_chunks[i].data,
|
||||
src_chunks[i].len + bonus_size));
|
||||
memcpy(src_chunks[i].data+src_chunks[i].len, bonus_data, bonus_size);
|
||||
src_chunks[i].len += bonus_size;
|
||||
}
|
||||
|
||||
patch_data[i] = MakePatch(src_chunks+i, tgt_chunks+i, patch_size+i);
|
||||
}
|
||||
printf("patch %3d is %d bytes (of %d)\n",
|
||||
printf("patch %3d is %zu bytes (of %zu)\n",
|
||||
i, patch_size[i], tgt_chunks[i].source_len);
|
||||
}
|
||||
|
||||
|
|
@ -1012,7 +1020,7 @@ int main(int argc, char** argv) {
|
|||
|
||||
switch (tgt_chunks[i].type) {
|
||||
case CHUNK_NORMAL:
|
||||
printf("chunk %3d: normal (%10d, %10d) %10d\n", i,
|
||||
printf("chunk %3d: normal (%10zu, %10zu) %10zu\n", i,
|
||||
tgt_chunks[i].start, tgt_chunks[i].len, patch_size[i]);
|
||||
Write8(tgt_chunks[i].source_start, f);
|
||||
Write8(tgt_chunks[i].source_len, f);
|
||||
|
|
@ -1021,7 +1029,7 @@ int main(int argc, char** argv) {
|
|||
break;
|
||||
|
||||
case CHUNK_DEFLATE:
|
||||
printf("chunk %3d: deflate (%10d, %10d) %10d %s\n", i,
|
||||
printf("chunk %3d: deflate (%10zu, %10zu) %10zu %s\n", i,
|
||||
tgt_chunks[i].start, tgt_chunks[i].deflate_len, patch_size[i],
|
||||
tgt_chunks[i].filename);
|
||||
Write8(tgt_chunks[i].source_start, f);
|
||||
|
|
@ -1038,7 +1046,7 @@ int main(int argc, char** argv) {
|
|||
break;
|
||||
|
||||
case CHUNK_RAW:
|
||||
printf("chunk %3d: raw (%10d, %10d)\n", i,
|
||||
printf("chunk %3d: raw (%10zu, %10zu)\n", i,
|
||||
tgt_chunks[i].start, tgt_chunks[i].len);
|
||||
Write4(patch_size[i], f);
|
||||
fwrite(patch_data[i], 1, patch_size[i], f);
|
||||
|
|
@ -132,7 +132,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size __unused,
|
|||
// must be appended from the bonus_data value.
|
||||
size_t bonus_size = (i == 1 && bonus_data != NULL) ? bonus_data->size : 0;
|
||||
|
||||
unsigned char* expanded_source = malloc(expanded_len);
|
||||
unsigned char* expanded_source = reinterpret_cast<unsigned char*>(malloc(expanded_len));
|
||||
if (expanded_source == NULL) {
|
||||
printf("failed to allocate %zu bytes for expanded_source\n",
|
||||
expanded_len);
|
||||
|
|
@ -196,7 +196,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size __unused,
|
|||
// ... unless the buffer is too small, in which case we'll
|
||||
// allocate a fresh one.
|
||||
free(temp_data);
|
||||
temp_data = malloc(32768);
|
||||
temp_data = reinterpret_cast<unsigned char*>(malloc(32768));
|
||||
temp_size = 32768;
|
||||
}
|
||||
|
||||
|
|
@ -23,14 +23,14 @@
|
|||
#include "edify/expr.h"
|
||||
#include "mincrypt/sha.h"
|
||||
|
||||
int CheckMode(int argc, char** argv) {
|
||||
static 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) {
|
||||
static int SpaceMode(int argc, char** argv) {
|
||||
if (argc != 3) {
|
||||
return 2;
|
||||
}
|
||||
|
|
@ -45,19 +45,18 @@ int SpaceMode(int argc, char** argv) {
|
|||
|
||||
// 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
|
||||
// *patches (loading file contents into the patches). Returns true on
|
||||
// success.
|
||||
static int ParsePatchArgs(int argc, char** argv,
|
||||
static bool 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*));
|
||||
*sha1s = reinterpret_cast<char**>(malloc(*num_patches * sizeof(char*)));
|
||||
*patches = reinterpret_cast<Value**>(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) {
|
||||
for (int i = 0; i < *num_patches; ++i) {
|
||||
char* colon = strchr(argv[i], ':');
|
||||
if (colon != NULL) {
|
||||
*colon = '\0';
|
||||
|
|
@ -66,7 +65,7 @@ static int ParsePatchArgs(int argc, char** argv,
|
|||
|
||||
if (ParseSha1(argv[i], digest) != 0) {
|
||||
printf("failed to parse sha1 \"%s\"\n", argv[i]);
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
(*sha1s)[i] = argv[i];
|
||||
|
|
@ -77,17 +76,17 @@ static int ParsePatchArgs(int argc, char** argv,
|
|||
if (LoadFileContents(colon, &fc) != 0) {
|
||||
goto abort;
|
||||
}
|
||||
(*patches)[i] = malloc(sizeof(Value));
|
||||
(*patches)[i] = reinterpret_cast<Value*>(malloc(sizeof(Value)));
|
||||
(*patches)[i]->type = VAL_BLOB;
|
||||
(*patches)[i]->size = fc.size;
|
||||
(*patches)[i]->data = (char*)fc.data;
|
||||
(*patches)[i]->data = reinterpret_cast<char*>(fc.data);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return true;
|
||||
|
||||
abort:
|
||||
for (i = 0; i < *num_patches; ++i) {
|
||||
for (int i = 0; i < *num_patches; ++i) {
|
||||
Value* p = (*patches)[i];
|
||||
if (p != NULL) {
|
||||
free(p->data);
|
||||
|
|
@ -96,7 +95,7 @@ static int ParsePatchArgs(int argc, char** argv,
|
|||
}
|
||||
free(*sha1s);
|
||||
free(*patches);
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
int PatchMode(int argc, char** argv) {
|
||||
|
|
@ -107,7 +106,7 @@ int PatchMode(int argc, char** argv) {
|
|||
printf("failed to load bonus file %s\n", argv[2]);
|
||||
return 1;
|
||||
}
|
||||
bonus = malloc(sizeof(Value));
|
||||
bonus = reinterpret_cast<Value*>(malloc(sizeof(Value)));
|
||||
bonus->type = VAL_BLOB;
|
||||
bonus->size = fc.size;
|
||||
bonus->data = (char*)fc.data;
|
||||
|
|
@ -129,7 +128,7 @@ int PatchMode(int argc, char** argv) {
|
|||
char** sha1s;
|
||||
Value** patches;
|
||||
int num_patches;
|
||||
if (ParsePatchArgs(argc-5, argv+5, &sha1s, &patches, &num_patches) != 0) {
|
||||
if (!ParsePatchArgs(argc-5, argv+5, &sha1s, &patches, &num_patches)) {
|
||||
printf("failed to parse patch args\n");
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -39,13 +39,13 @@ void Write8(long long value, FILE* f) {
|
|||
}
|
||||
|
||||
int Read2(void* pv) {
|
||||
unsigned char* p = pv;
|
||||
unsigned char* p = reinterpret_cast<unsigned char*>(pv);
|
||||
return (int)(((unsigned int)p[1] << 8) |
|
||||
(unsigned int)p[0]);
|
||||
}
|
||||
|
||||
int Read4(void* pv) {
|
||||
unsigned char* p = pv;
|
||||
unsigned char* p = reinterpret_cast<unsigned char*>(pv);
|
||||
return (int)(((unsigned int)p[3] << 24) |
|
||||
((unsigned int)p[2] << 16) |
|
||||
((unsigned int)p[1] << 8) |
|
||||
|
|
@ -53,7 +53,7 @@ int Read4(void* pv) {
|
|||
}
|
||||
|
||||
long long Read8(void* pv) {
|
||||
unsigned char* p = pv;
|
||||
unsigned char* p = reinterpret_cast<unsigned char*>(pv);
|
||||
return (long long)(((unsigned long long)p[7] << 56) |
|
||||
((unsigned long long)p[6] << 48) |
|
||||
((unsigned long long)p[5] << 40) |
|
||||
|
|
@ -15,6 +15,10 @@
|
|||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* compute the hash of an item with a specific type */
|
||||
typedef unsigned int (*HashCompute)(const void* item);
|
||||
|
||||
|
|
@ -183,4 +187,8 @@ typedef unsigned int (*HashCalcFunc)(const void* item);
|
|||
void mzHashTableProbeCount(HashTable* pHashTable, HashCalcFunc calcFunc,
|
||||
HashCompareFunc cmpFunc);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /*_MINZIP_HASH*/
|
||||
|
|
|
|||
|
|
@ -30,10 +30,8 @@
|
|||
#include "roots.h"
|
||||
#include "common.h"
|
||||
#include "make_ext4fs.h"
|
||||
extern "C" {
|
||||
#include "wipe.h"
|
||||
#include "cryptfs.h"
|
||||
}
|
||||
|
||||
static struct fstab *fstab = NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,11 +1,23 @@
|
|||
# Copyright 2009 The Android Open Source Project
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
updater_src_files := \
|
||||
install.c \
|
||||
blockimg.c \
|
||||
updater.c
|
||||
install.cpp \
|
||||
blockimg.cpp \
|
||||
updater.cpp
|
||||
|
||||
#
|
||||
# Build a statically-linked binary to include in OTA packages
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <inttypes.h>
|
||||
#include <linux/fs.h>
|
||||
#include <pthread.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -44,10 +45,6 @@
|
|||
// erase to mean fill the region with zeroes.
|
||||
#define DEBUG_ERASE 0
|
||||
|
||||
#ifndef BLKDISCARD
|
||||
#define BLKDISCARD _IO(0x12,119)
|
||||
#endif
|
||||
|
||||
#define STASH_DIRECTORY_BASE "/cache/recovery"
|
||||
#define STASH_DIRECTORY_MODE 0700
|
||||
#define STASH_FILE_MODE 0600
|
||||
|
|
@ -66,7 +63,7 @@ typedef struct {
|
|||
static RangeSet* parse_range(char* text) {
|
||||
char* save;
|
||||
char* token;
|
||||
int i, num;
|
||||
int num;
|
||||
long int val;
|
||||
RangeSet* out = NULL;
|
||||
size_t bufsize;
|
||||
|
|
@ -92,7 +89,7 @@ static RangeSet* parse_range(char* text) {
|
|||
num = (int) val;
|
||||
bufsize = sizeof(RangeSet) + num * sizeof(int);
|
||||
|
||||
out = malloc(bufsize);
|
||||
out = reinterpret_cast<RangeSet*>(malloc(bufsize));
|
||||
|
||||
if (!out) {
|
||||
fprintf(stderr, "failed to allocate range of %zu bytes\n", bufsize);
|
||||
|
|
@ -102,7 +99,7 @@ static RangeSet* parse_range(char* text) {
|
|||
out->count = num / 2;
|
||||
out->size = 0;
|
||||
|
||||
for (i = 0; i < num; ++i) {
|
||||
for (int i = 0; i < num; ++i) {
|
||||
token = strtok_r(NULL, ",", &save);
|
||||
|
||||
if (!token) {
|
||||
|
|
@ -477,7 +474,7 @@ static char* GetStashFileName(const char* base, const char* id, const char* post
|
|||
}
|
||||
|
||||
len = strlen(STASH_DIRECTORY_BASE) + 1 + strlen(base) + 1 + strlen(id) + strlen(postfix) + 1;
|
||||
fn = malloc(len);
|
||||
fn = reinterpret_cast<char*>(malloc(len));
|
||||
|
||||
if (fn == NULL) {
|
||||
fprintf(stderr, "failed to malloc %d bytes for fn\n", len);
|
||||
|
|
@ -528,7 +525,7 @@ static void EnumerateStash(const char* dirname, StashCallback callback, void* da
|
|||
}
|
||||
|
||||
len = strlen(dirname) + 1 + strlen(item->d_name) + 1;
|
||||
fn = malloc(len);
|
||||
fn = reinterpret_cast<char*>(malloc(len));
|
||||
|
||||
if (fn == NULL) {
|
||||
fprintf(stderr, "failed to malloc %d bytes for fn\n", len);
|
||||
|
|
@ -648,7 +645,8 @@ static int LoadStash(const char* base, const char* id, int verify, int* blocks,
|
|||
fprintf(stderr, " loading %s\n", fn);
|
||||
|
||||
if ((st.st_size % BLOCKSIZE) != 0) {
|
||||
fprintf(stderr, "%s size %zd not multiple of block size %d", fn, st.st_size, BLOCKSIZE);
|
||||
fprintf(stderr, "%s size %" PRId64 " not multiple of block size %d",
|
||||
fn, static_cast<int64_t>(st.st_size), BLOCKSIZE);
|
||||
goto lsout;
|
||||
}
|
||||
|
||||
|
|
@ -856,7 +854,6 @@ csout:
|
|||
static int SaveStash(const char* base, char** wordsave, uint8_t** buffer, size_t* buffer_alloc,
|
||||
int fd, int usehash, int* isunresumable) {
|
||||
char *id = NULL;
|
||||
int res = -1;
|
||||
int blocks = 0;
|
||||
|
||||
if (!wordsave || !buffer || !buffer_alloc || !isunresumable) {
|
||||
|
|
@ -952,7 +949,6 @@ static int LoadSrcTgtVersion2(char** wordsave, RangeSet** tgt, int* src_blocks,
|
|||
char* word;
|
||||
char* colonsave;
|
||||
char* colon;
|
||||
int id;
|
||||
int res;
|
||||
RangeSet* locs;
|
||||
size_t stashalloc = 0;
|
||||
|
|
@ -1068,7 +1064,6 @@ static int LoadSrcTgtVersion3(CommandParameters* params, RangeSet** tgt, int* sr
|
|||
char* srchash = NULL;
|
||||
char* tgthash = NULL;
|
||||
int stash_exists = 0;
|
||||
int overlap_blocks = 0;
|
||||
int rc = -1;
|
||||
uint8_t* tgtbuffer = NULL;
|
||||
|
||||
|
|
@ -1491,7 +1486,7 @@ static int PerformCommandErase(CommandParameters* params) {
|
|||
range = strtok_r(NULL, " ", ¶ms->cpos);
|
||||
|
||||
if (range == NULL) {
|
||||
fprintf(stderr, "missing target blocks for zero\n");
|
||||
fprintf(stderr, "missing target blocks for erase\n");
|
||||
goto pceout;
|
||||
}
|
||||
|
||||
|
|
@ -1666,7 +1661,7 @@ static Value* PerformBlockImageUpdate(const char* name, State* state, int argc,
|
|||
|
||||
// The data in transfer_list_value is not necessarily null-terminated, so we need
|
||||
// to copy it to a new buffer and add the null that strtok_r will need.
|
||||
transfer_list = malloc(transfer_list_value->size + 1);
|
||||
transfer_list = reinterpret_cast<char*>(malloc(transfer_list_value->size + 1));
|
||||
|
||||
if (transfer_list == NULL) {
|
||||
fprintf(stderr, "failed to allocate %zd bytes for transfer list\n",
|
||||
|
|
@ -1944,13 +1939,15 @@ Value* RangeSha1Fn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
goto done;
|
||||
}
|
||||
|
||||
int fd = open(blockdev_filename->data, O_RDWR);
|
||||
int fd;
|
||||
fd = open(blockdev_filename->data, O_RDWR);
|
||||
if (fd < 0) {
|
||||
ErrorAbort(state, "open \"%s\" failed: %s", blockdev_filename->data, strerror(errno));
|
||||
goto done;
|
||||
}
|
||||
|
||||
RangeSet* rs = parse_range(ranges->data);
|
||||
RangeSet* rs;
|
||||
rs = parse_range(ranges->data);
|
||||
uint8_t buffer[BLOCKSIZE];
|
||||
|
||||
SHA_CTX ctx;
|
||||
|
|
@ -80,9 +80,9 @@ void uiPrintf(State* state, const char* format, ...) {
|
|||
|
||||
// Take a sha-1 digest and return it as a newly-allocated hex string.
|
||||
char* PrintSha1(const uint8_t* digest) {
|
||||
char* buffer = malloc(SHA_DIGEST_SIZE*2 + 1);
|
||||
int i;
|
||||
char* buffer = reinterpret_cast<char*>(malloc(SHA_DIGEST_SIZE*2 + 1));
|
||||
const char* alphabet = "0123456789abcdef";
|
||||
size_t i;
|
||||
for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
|
||||
buffer[i*2] = alphabet[(digest[i] >> 4) & 0xf];
|
||||
buffer[i*2+1] = alphabet[digest[i] & 0xf];
|
||||
|
|
@ -138,6 +138,7 @@ Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
char *secontext = NULL;
|
||||
|
||||
if (sehandle) {
|
||||
|
|
@ -151,6 +152,7 @@ Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
freecon(secontext);
|
||||
setfscreatecon(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
if (strcmp(partition_type, "MTD") == 0) {
|
||||
mtd_scan_partitions();
|
||||
|
|
@ -207,12 +209,14 @@ Value* IsMountedFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
}
|
||||
|
||||
scan_mounted_volumes();
|
||||
{
|
||||
const MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point);
|
||||
if (vol == NULL) {
|
||||
result = strdup("");
|
||||
} else {
|
||||
result = mount_point;
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
if (result != mount_point) free(mount_point);
|
||||
|
|
@ -235,6 +239,7 @@ Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
}
|
||||
|
||||
scan_mounted_volumes();
|
||||
{
|
||||
const MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point);
|
||||
if (vol == NULL) {
|
||||
uiPrintf(state, "unmount of %s failed; no such volume\n", mount_point);
|
||||
|
|
@ -247,6 +252,7 @@ Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
}
|
||||
result = mount_point;
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
if (result != mount_point) free(mount_point);
|
||||
|
|
@ -418,9 +424,8 @@ done:
|
|||
}
|
||||
|
||||
Value* DeleteFn(const char* name, State* state, int argc, Expr* argv[]) {
|
||||
char** paths = malloc(argc * sizeof(char*));
|
||||
int i;
|
||||
for (i = 0; i < argc; ++i) {
|
||||
char** paths = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
paths[i] = Evaluate(state, argv[i]);
|
||||
if (paths[i] == NULL) {
|
||||
int j;
|
||||
|
|
@ -435,7 +440,7 @@ Value* DeleteFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
bool recursive = (strcmp(name, "delete_recursive") == 0);
|
||||
|
||||
int success = 0;
|
||||
for (i = 0; i < argc; ++i) {
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
if ((recursive ? dirUnlinkHierarchy(paths[i]) : unlink(paths[i])) == 0)
|
||||
++success;
|
||||
free(paths[i]);
|
||||
|
|
@ -522,8 +527,6 @@ Value* PackageExtractFileFn(const char* name, State* state,
|
|||
}
|
||||
bool success = false;
|
||||
|
||||
UpdaterInfo* ui = (UpdaterInfo*)(state->cookie);
|
||||
|
||||
if (argc == 2) {
|
||||
// The two-argument version extracts to a file.
|
||||
|
||||
|
|
@ -539,6 +542,7 @@ Value* PackageExtractFileFn(const char* name, State* state,
|
|||
goto done2;
|
||||
}
|
||||
|
||||
{
|
||||
FILE* f = fopen(dest_path, "wb");
|
||||
if (f == NULL) {
|
||||
printf("%s: can't open %s for write: %s\n",
|
||||
|
|
@ -547,6 +551,7 @@ Value* PackageExtractFileFn(const char* name, State* state,
|
|||
}
|
||||
success = mzExtractZipEntryToFile(za, entry, fileno(f));
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
done2:
|
||||
free(zip_path);
|
||||
|
|
@ -557,7 +562,7 @@ Value* PackageExtractFileFn(const char* name, State* state,
|
|||
// as the result.
|
||||
|
||||
char* zip_path;
|
||||
Value* v = malloc(sizeof(Value));
|
||||
Value* v = reinterpret_cast<Value*>(malloc(sizeof(Value)));
|
||||
v->type = VAL_BLOB;
|
||||
v->size = -1;
|
||||
v->data = NULL;
|
||||
|
|
@ -572,7 +577,7 @@ Value* PackageExtractFileFn(const char* name, State* state,
|
|||
}
|
||||
|
||||
v->size = mzGetZipEntryUncompLen(entry);
|
||||
v->data = malloc(v->size);
|
||||
v->data = reinterpret_cast<char*>(malloc(v->size));
|
||||
if (v->data == NULL) {
|
||||
printf("%s: failed to allocate %ld bytes for %s\n",
|
||||
name, (long)v->size, zip_path);
|
||||
|
|
@ -871,17 +876,14 @@ static int do_SetMetadataRecursive(const char* filename, const struct stat *stat
|
|||
}
|
||||
|
||||
static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv[]) {
|
||||
int i;
|
||||
int bad = 0;
|
||||
static int nwarnings = 0;
|
||||
struct stat sb;
|
||||
Value* result = NULL;
|
||||
|
||||
bool recursive = (strcmp(name, "set_metadata_recursive") == 0);
|
||||
|
||||
if ((argc % 2) != 1) {
|
||||
return ErrorAbort(state, "%s() expects an odd number of arguments, got %d",
|
||||
name, argc);
|
||||
return ErrorAbort(state, "%s() expects an odd number of arguments, got %d", name, argc);
|
||||
}
|
||||
|
||||
char** args = ReadVarArgs(state, argc, argv);
|
||||
|
|
@ -892,6 +894,7 @@ static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv
|
|||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
struct perm_parsed_args parsed = ParsePermArgs(state, argc, args);
|
||||
|
||||
if (recursive) {
|
||||
|
|
@ -903,9 +906,10 @@ static Value* SetMetadataFn(const char* name, State* state, int argc, Expr* argv
|
|||
} else {
|
||||
bad += ApplyParsedPerms(state, args[0], &sb, parsed);
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
for (i = 0; i < argc; ++i) {
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
free(args[i]);
|
||||
}
|
||||
free(args);
|
||||
|
|
@ -925,8 +929,7 @@ Value* GetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
if (argc != 1) {
|
||||
return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
|
||||
}
|
||||
char* key;
|
||||
key = Evaluate(state, argv[0]);
|
||||
char* key = Evaluate(state, argv[0]);
|
||||
if (key == NULL) return NULL;
|
||||
|
||||
char value[PROPERTY_VALUE_MAX];
|
||||
|
|
@ -953,29 +956,27 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
|
||||
struct stat st;
|
||||
if (stat(filename, &st) < 0) {
|
||||
ErrorAbort(state, "%s: failed to stat \"%s\": %s",
|
||||
name, filename, strerror(errno));
|
||||
ErrorAbort(state, "%s: failed to stat \"%s\": %s", name, filename, strerror(errno));
|
||||
goto done;
|
||||
}
|
||||
|
||||
#define MAX_FILE_GETPROP_SIZE 65536
|
||||
|
||||
if (st.st_size > MAX_FILE_GETPROP_SIZE) {
|
||||
ErrorAbort(state, "%s too large for %s (max %d)",
|
||||
filename, name, MAX_FILE_GETPROP_SIZE);
|
||||
ErrorAbort(state, "%s too large for %s (max %d)", filename, name, MAX_FILE_GETPROP_SIZE);
|
||||
goto done;
|
||||
}
|
||||
|
||||
buffer = malloc(st.st_size+1);
|
||||
buffer = reinterpret_cast<char*>(malloc(st.st_size+1));
|
||||
if (buffer == NULL) {
|
||||
ErrorAbort(state, "%s: failed to alloc %lld bytes", name, (long long)st.st_size+1);
|
||||
goto done;
|
||||
}
|
||||
|
||||
FILE* f = fopen(filename, "rb");
|
||||
FILE* f;
|
||||
f = fopen(filename, "rb");
|
||||
if (f == NULL) {
|
||||
ErrorAbort(state, "%s: failed to open %s: %s",
|
||||
name, filename, strerror(errno));
|
||||
ErrorAbort(state, "%s: failed to open %s: %s", name, filename, strerror(errno));
|
||||
goto done;
|
||||
}
|
||||
|
||||
|
|
@ -989,7 +990,8 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
|
||||
fclose(f);
|
||||
|
||||
char* line = strtok(buffer, "\n");
|
||||
char* line;
|
||||
line = strtok(buffer, "\n");
|
||||
do {
|
||||
// skip whitespace at start of line
|
||||
while (*line && isspace(*line)) ++line;
|
||||
|
|
@ -1033,15 +1035,6 @@ Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
return StringValue(result);
|
||||
}
|
||||
|
||||
|
||||
static bool write_raw_image_cb(const unsigned char* data,
|
||||
int data_len, void* ctx) {
|
||||
int r = mtd_write_data((MtdWriteContext*)ctx, (const char *)data, data_len);
|
||||
if (r == data_len) return true;
|
||||
printf("%s\n", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
// write_raw_image(filename_or_blob, partition)
|
||||
Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {
|
||||
char* result = NULL;
|
||||
|
|
@ -1068,14 +1061,16 @@ Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
}
|
||||
|
||||
mtd_scan_partitions();
|
||||
const MtdPartition* mtd = mtd_find_partition_by_name(partition);
|
||||
const MtdPartition* mtd;
|
||||
mtd = mtd_find_partition_by_name(partition);
|
||||
if (mtd == NULL) {
|
||||
printf("%s: no mtd partition named \"%s\"\n", name, partition);
|
||||
result = strdup("");
|
||||
goto done;
|
||||
}
|
||||
|
||||
MtdWriteContext* ctx = mtd_write_partition(mtd);
|
||||
MtdWriteContext* ctx;
|
||||
ctx = mtd_write_partition(mtd);
|
||||
if (ctx == NULL) {
|
||||
printf("%s: can't write mtd partition \"%s\"\n",
|
||||
name, partition);
|
||||
|
|
@ -1090,14 +1085,13 @@ Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
char* filename = contents->data;
|
||||
FILE* f = fopen(filename, "rb");
|
||||
if (f == NULL) {
|
||||
printf("%s: can't open %s: %s\n",
|
||||
name, filename, strerror(errno));
|
||||
printf("%s: can't open %s: %s\n", name, filename, strerror(errno));
|
||||
result = strdup("");
|
||||
goto done;
|
||||
}
|
||||
|
||||
success = true;
|
||||
char* buffer = malloc(BUFSIZ);
|
||||
char* buffer = reinterpret_cast<char*>(malloc(BUFSIZ));
|
||||
int read;
|
||||
while (success && (read = fread(buffer, 1, BUFSIZ, f)) > 0) {
|
||||
int wrote = mtd_write_data(ctx, buffer, read);
|
||||
|
|
@ -1144,8 +1138,7 @@ Value* ApplyPatchSpaceFn(const char* name, State* state,
|
|||
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);
|
||||
ErrorAbort(state, "%s(): can't parse \"%s\" as byte count\n\n", name, bytes_str);
|
||||
free(bytes_str);
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -1205,7 +1198,7 @@ Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
char** patch_sha_str = malloc(patchcount * sizeof(char*));
|
||||
char** patch_sha_str = reinterpret_cast<char**>(malloc(patchcount * sizeof(char*)));
|
||||
for (i = 0; i < patchcount; ++i) {
|
||||
patch_sha_str[i] = patches[i*2]->data;
|
||||
patches[i*2]->data = NULL;
|
||||
|
|
@ -1264,7 +1257,7 @@ Value* UIPrintFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
for (i = 0; i < argc; ++i) {
|
||||
size += strlen(args[i]);
|
||||
}
|
||||
char* buffer = malloc(size+1);
|
||||
char* buffer = reinterpret_cast<char*>(malloc(size+1));
|
||||
size = 0;
|
||||
for (i = 0; i < argc; ++i) {
|
||||
strcpy(buffer+size, args[i]);
|
||||
|
|
@ -1294,7 +1287,7 @@ Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
char** args2 = malloc(sizeof(char*) * (argc+1));
|
||||
char** args2 = reinterpret_cast<char**>(malloc(sizeof(char*) * (argc+1)));
|
||||
memcpy(args2, args, sizeof(char*) * argc);
|
||||
args2[argc] = NULL;
|
||||
|
||||
|
|
@ -1361,7 +1354,7 @@ Value* Sha1CheckFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
}
|
||||
|
||||
int i;
|
||||
uint8_t* arg_digest = malloc(SHA_DIGEST_SIZE);
|
||||
uint8_t* arg_digest = reinterpret_cast<uint8_t*>(malloc(SHA_DIGEST_SIZE));
|
||||
for (i = 1; i < argc; ++i) {
|
||||
if (args[i]->type != VAL_STRING) {
|
||||
printf("%s(): arg %d is not a string; skipping",
|
||||
|
|
@ -1397,7 +1390,7 @@ Value* ReadFileFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
char* filename;
|
||||
if (ReadArgs(state, argv, 1, &filename) < 0) return NULL;
|
||||
|
||||
Value* v = malloc(sizeof(Value));
|
||||
Value* v = reinterpret_cast<Value*>(malloc(sizeof(Value)));
|
||||
v->type = VAL_BLOB;
|
||||
|
||||
FileContents fc;
|
||||
|
|
@ -1555,15 +1548,14 @@ Value* Tune2FsFn(const char* name, State* state, int argc, Expr* argv[]) {
|
|||
return ErrorAbort(state, "%s() could not read args", name);
|
||||
}
|
||||
|
||||
int i;
|
||||
char** args2 = malloc(sizeof(char*) * (argc+1));
|
||||
char** args2 = reinterpret_cast<char**>(malloc(sizeof(char*) * (argc+1)));
|
||||
// Tune2fs expects the program name as its args[0]
|
||||
args2[0] = strdup(name);
|
||||
for (i = 0; i < argc; ++i) {
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
args2[i + 1] = args[i];
|
||||
}
|
||||
int result = tune2fs_main(argc + 1, args2);
|
||||
for (i = 0; i < argc; ++i) {
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
free(args[i]);
|
||||
}
|
||||
free(args);
|
||||
|
|
@ -89,7 +89,7 @@ int main(int argc, char** argv) {
|
|||
return 4;
|
||||
}
|
||||
|
||||
char* script = malloc(script_entry->uncompLen+1);
|
||||
char* script = reinterpret_cast<char*>(malloc(script_entry->uncompLen+1));
|
||||
if (!mzReadZipEntry(&za, script_entry, script, script_entry->uncompLen)) {
|
||||
printf("failed to read script from package\n");
|
||||
return 5;
|
||||
Loading…
Reference in a new issue