summaryrefslogtreecommitdiffstats
path: root/applypatch
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--applypatch/Android.mk8
-rw-r--r--applypatch/applypatch.cpp (renamed from applypatch/applypatch.c)155
-rw-r--r--applypatch/bsdiff.cpp (renamed from applypatch/bsdiff.c)48
-rw-r--r--applypatch/bspatch.cpp (renamed from applypatch/bspatch.c)5
-rw-r--r--applypatch/freecache.cpp (renamed from applypatch/freecache.c)28
-rw-r--r--applypatch/imgdiff.cpp (renamed from applypatch/imgdiff.c)84
-rw-r--r--applypatch/imgpatch.cpp (renamed from applypatch/imgpatch.c)4
-rw-r--r--applypatch/main.cpp (renamed from applypatch/main.c)31
-rw-r--r--applypatch/utils.cpp (renamed from applypatch/utils.c)6
9 files changed, 183 insertions, 186 deletions
diff --git a/applypatch/Android.mk b/applypatch/Android.mk
index eb3e4580e..1f73fd897 100644
--- a/applypatch/Android.mk
+++ b/applypatch/Android.mk
@@ -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
diff --git a/applypatch/applypatch.c b/applypatch/applypatch.cpp
index 2358d4292..96bd88e88 100644
--- a/applypatch/applypatch.c
+++ b/applypatch/applypatch.cpp
@@ -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;
diff --git a/applypatch/bsdiff.c b/applypatch/bsdiff.cpp
index b6d342b7a..55dbe5cf1 100644
--- a/applypatch/bsdiff.c
+++ b/applypatch/bsdiff.cpp
@@ -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);
diff --git a/applypatch/bspatch.c b/applypatch/bspatch.cpp
index b57760eda..9d201b477 100644
--- a/applypatch/bspatch.c
+++ b/applypatch/bspatch.cpp
@@ -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;
}
diff --git a/applypatch/freecache.c b/applypatch/freecache.cpp
index 9827fda06..2eb2f55ef 100644
--- a/applypatch/freecache.c
+++ b/applypatch/freecache.cpp
@@ -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]);
}
}
diff --git a/applypatch/imgdiff.c b/applypatch/imgdiff.cpp
index 3bac8be91..4d83ffb2e 100644
--- a/applypatch/imgdiff.c
+++ b/applypatch/imgdiff.cpp
@@ -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,8 +498,8 @@ 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",
- footer_size, curr[-2].len);
+ 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);
diff --git a/applypatch/imgpatch.c b/applypatch/imgpatch.cpp
index 09b0a7397..26888f8ee 100644
--- a/applypatch/imgpatch.c
+++ b/applypatch/imgpatch.cpp
@@ -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;
}
diff --git a/applypatch/main.c b/applypatch/main.cpp
index 8e9fe80ef..63ff5c2c0 100644
--- a/applypatch/main.c
+++ b/applypatch/main.cpp
@@ -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;
}
diff --git a/applypatch/utils.c b/applypatch/utils.cpp
index 41ff676dc..4a80be75f 100644
--- a/applypatch/utils.c
+++ b/applypatch/utils.cpp
@@ -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) |
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 03:01:47 +0100