PawletOS/android_bootable_recovery
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

applypatch: Change the ssize_t length parameters to size_t.

Browse Source 
Mostly for applypatch family APIs like ApplyBSDiffPatch() and
ApplyImagePatch(). Changing to size_t doesn't indicate they would
necessarily work with very large size_t (e.g. > ssize_t), just
similar to write(2). But otherwise accepting negative length doesn't
make much sense.

Also change the return type of SinkFn from ssize_t to size_t. Callers
tell a successful sink by comparing the number of written bytes against
the desired value. Negative return values like -1 are not needed. This
also makes it consistent with bsdiff::bspatch interface.

Test: recovery_component_test
Test: Apply an incremental with the new updater.
Change-Id: I7ff1615203a5c9854134f75d019e266f4ea6e714
This commit is contained in:
Tao Bao
2017-03-27 15:12:48 -07:00
parent f037b7b535
commit f7eb760fe7
7 changed files with 88 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
applypatch/applypatch.cpp
View File

@@ -42,7 +42,7 @@
#include "print_sha1.h" #include "print_sha1.h"
static int LoadPartitionContents(const std::string& filename, FileContents* file); static int LoadPartitionContents(const std::string& filename, FileContents* file);
static ssize_t FileSink(const unsigned char* data, ssize_t len, void* token); static size_t FileSink(const unsigned char* data, size_t len, void* token);
static int GenerateTarget(const FileContents& source_file, const std::unique_ptr<Value>& patch, static int GenerateTarget(const FileContents& source_file, const std::unique_ptr<Value>& patch,
const std::string& target_filename, const std::string& target_filename,
const uint8_t target_sha1[SHA_DIGEST_LENGTH], const Value* bonus_data); const uint8_t target_sha1[SHA_DIGEST_LENGTH], const Value* bonus_data);
@@ -194,8 +194,8 @@ int SaveFileContents(const char* filename, const FileContents* file) {
return -1; return -1;
} }
ssize_t bytes_written = FileSink(file->data.data(), file->data.size(), &fd); size_t bytes_written = FileSink(file->data.data(), file->data.size(), &fd);
if (bytes_written != static_cast<ssize_t>(file->data.size())) { if (bytes_written != file->data.size()) {
printf("short write of \"%s\" (%zd bytes of %zu): %s\n", filename, bytes_written, printf("short write of \"%s\" (%zd bytes of %zu): %s\n", filename, bytes_written,
file->data.size(), strerror(errno)); file->data.size(), strerror(errno));
return -1; return -1;
@@ -433,25 +433,24 @@ int ShowLicenses() {
return 0; return 0;
} }
ssize_t FileSink(const unsigned char* data, ssize_t len, void* token) { static size_t FileSink(const unsigned char* data, size_t len, void* token) {
int fd = *static_cast<int*>(token); int fd = *static_cast<int*>(token);
ssize_t done = 0; size_t done = 0;
ssize_t wrote; while (done < len) {
while (done < len) { ssize_t wrote = TEMP_FAILURE_RETRY(ota_write(fd, data + done, len - done));
wrote = TEMP_FAILURE_RETRY(ota_write(fd, data+done, len-done)); if (wrote == -1) {
if (wrote == -1) { printf("error writing %zd bytes: %s\n", (len - done), strerror(errno));
printf("error writing %zd bytes: %s\n", (len-done), strerror(errno)); return done;
return done;
}
done += wrote;
} }
return done; done += wrote;
}
return done;
} }
ssize_t MemorySink(const unsigned char* data, ssize_t len, void* token) { size_t MemorySink(const unsigned char* data, size_t len, void* token) {
std::string* s = static_cast<std::string*>(token); std::string* s = static_cast<std::string*>(token);
s->append(reinterpret_cast<const char*>(data), len); s->append(reinterpret_cast<const char*>(data), len);
return len; return len;
} }
// Return the amount of free space (in bytes) on the filesystem // Return the amount of free space (in bytes) on the filesystem

8
applypatch/bspatch.cpp
View File

@@ -60,8 +60,8 @@ void ShowBSDiffLicense() {
); );
} }
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, const Value* patch, int ApplyBSDiffPatch(const unsigned char* old_data, size_t old_size, const Value* patch,
ssize_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx) { size_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx) {
auto sha_sink = [&](const uint8_t* data, size_t len) { auto sha_sink = [&](const uint8_t* data, size_t len) {
len = sink(data, len, token); len = sink(data, len, token);
if (ctx) SHA1_Update(ctx, data, len); if (ctx) SHA1_Update(ctx, data, len);
@@ -72,8 +72,8 @@ int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, const Valu
patch->data.size(), sha_sink); patch->data.size(), sha_sink);
} }
int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size, const Value* patch, int ApplyBSDiffPatchMem(const unsigned char* old_data, size_t old_size, const Value* patch,
ssize_t patch_offset, std::vector<unsigned char>* new_data) { size_t patch_offset, std::vector<unsigned char>* new_data) {
auto vector_sink = [new_data](const uint8_t* data, size_t len) { auto vector_sink = [new_data](const uint8_t* data, size_t len) {
new_data->insert(new_data->end(), data, data + len); new_data->insert(new_data->end(), data, data + len);
return len; return len;

17
applypatch/imgpatch.cpp
View File

@@ -43,9 +43,8 @@ static inline int32_t Read4(const void *address) {
return android::base::get_unaligned<int32_t>(address); return android::base::get_unaligned<int32_t>(address);
} }
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const unsigned char* patch_data,
const unsigned char* patch_data, ssize_t patch_size, size_t patch_size, SinkFn sink, void* token) {
SinkFn sink, void* token) {
Value patch(VAL_BLOB, std::string(reinterpret_cast<const char*>(patch_data), patch_size)); Value patch(VAL_BLOB, std::string(reinterpret_cast<const char*>(patch_data), patch_size));
return ApplyImagePatch(old_data, old_size, &patch, sink, token, nullptr, nullptr); return ApplyImagePatch(old_data, old_size, &patch, sink, token, nullptr, nullptr);
@@ -57,8 +56,8 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
* file, and update the SHA context with the output data as well. * file, and update the SHA context with the output data as well.
* Return 0 on success. * Return 0 on success.
*/ */
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value* patch, int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const Value* patch, SinkFn sink,
SinkFn sink, void* token, SHA_CTX* ctx, const Value* bonus_data) { void* token, SHA_CTX* ctx, const Value* bonus_data) {
if (patch->data.size() < 12) { if (patch->data.size() < 12) {
printf("patch too short to contain header\n"); printf("patch too short to contain header\n");
return -1; return -1;
@@ -97,7 +96,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value
size_t src_len = static_cast<size_t>(Read8(normal_header + 8)); size_t src_len = static_cast<size_t>(Read8(normal_header + 8));
size_t patch_offset = static_cast<size_t>(Read8(normal_header + 16)); size_t patch_offset = static_cast<size_t>(Read8(normal_header + 16));
if (src_start + src_len > static_cast<size_t>(old_size)) { if (src_start + src_len > old_size) {
printf("source data too short\n"); printf("source data too short\n");
return -1; return -1;
} }
@@ -110,7 +109,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value
return -1; return -1;
} }
ssize_t data_len = Read4(raw_header); size_t data_len = static_cast<size_t>(Read4(raw_header));
if (pos + data_len > patch->data.size()) { if (pos + data_len > patch->data.size()) {
printf("failed to read chunk %d raw data\n", i); printf("failed to read chunk %d raw data\n", i);
@@ -143,7 +142,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value
int memLevel = Read4(deflate_header + 52); int memLevel = Read4(deflate_header + 52);
int strategy = Read4(deflate_header + 56); int strategy = Read4(deflate_header + 56);
if (src_start + src_len > static_cast<size_t>(old_size)) { if (src_start + src_len > old_size) {
printf("source data too short\n"); printf("source data too short\n");
return -1; return -1;
} }
@@ -240,7 +239,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value
strm.avail_out = temp_data.size(); strm.avail_out = temp_data.size();
strm.next_out = temp_data.data(); strm.next_out = temp_data.data();
ret = deflate(&strm, Z_FINISH); ret = deflate(&strm, Z_FINISH);
ssize_t have = temp_data.size() - strm.avail_out; size_t have = temp_data.size() - strm.avail_out;
if (sink(temp_data.data(), have, token) != have) { if (sink(temp_data.data(), have, token) != have) {
printf("failed to write %zd compressed bytes to output\n", have); printf("failed to write %zd compressed bytes to output\n", have);

18
applypatch/include/applypatch/applypatch.h
View File

@@ -41,7 +41,7 @@ struct FileContents {
// and use it as the source instead. // and use it as the source instead.
#define CACHE_TEMP_SOURCE "/cache/saved.file" #define CACHE_TEMP_SOURCE "/cache/saved.file"
typedef ssize_t (*SinkFn)(const unsigned char*, ssize_t, void*); using SinkFn = size_t (*)(const unsigned char*, size_t, void*);
// applypatch.cpp // applypatch.cpp
int ShowLicenses(); int ShowLicenses();
@@ -66,18 +66,14 @@ int SaveFileContents(const char* filename, const FileContents* file);
// bspatch.cpp // bspatch.cpp
void ShowBSDiffLicense(); void ShowBSDiffLicense();
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, int ApplyBSDiffPatch(const unsigned char* old_data, size_t old_size, const Value* patch,
const Value* patch, ssize_t patch_offset, size_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx);
SinkFn sink, void* token, SHA_CTX* ctx); int ApplyBSDiffPatchMem(const unsigned char* old_data, size_t old_size, const Value* patch,
int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size, size_t patch_offset, std::vector<unsigned char>* new_data);
const Value* patch, ssize_t patch_offset,
std::vector<unsigned char>* new_data);
// imgpatch.cpp // imgpatch.cpp
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const Value* patch, SinkFn sink,
const Value* patch, void* token, SHA_CTX* ctx, const Value* bonus_data);
SinkFn sink, void* token, SHA_CTX* ctx,
const Value* bonus_data);
// freecache.cpp // freecache.cpp
int MakeFreeSpaceOnCache(size_t bytes_needed); int MakeFreeSpaceOnCache(size_t bytes_needed);

7
applypatch/include/applypatch/imgpatch.h
View File

@@ -19,10 +19,9 @@
#include <sys/types.h> #include <sys/types.h>
using SinkFn = ssize_t (*)(const unsigned char*, ssize_t, void*); using SinkFn = size_t (*)(const unsigned char*, size_t, void*);
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const unsigned char* patch_data,
const unsigned char* patch_data, ssize_t patch_size, size_t patch_size, SinkFn sink, void* token);
SinkFn sink, void* token);
#endif // _APPLYPATCH_IMGPATCH_H #endif // _APPLYPATCH_IMGPATCH_H

2
tests/component/imgdiff_test.cpp
View File

@@ -27,7 +27,7 @@
using android::base::get_unaligned; using android::base::get_unaligned;
static ssize_t MemorySink(const unsigned char* data, ssize_t len, void* token) { static size_t MemorySink(const unsigned char* data, size_t len, void* token) {
std::string* s = static_cast<std::string*>(token); std::string* s = static_cast<std::string*>(token);
s->append(reinterpret_cast<const char*>(data), len); s->append(reinterpret_cast<const char*>(data), len);
return len; return len;

95
updater/blockimg.cpp
View File

@@ -240,57 +240,56 @@ struct RangeSinkState {
size_t p_remain; size_t p_remain;
}; };
static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) { static size_t RangeSinkWrite(const uint8_t* data, size_t size, void* token) {
RangeSinkState* rss = reinterpret_cast<RangeSinkState*>(token); RangeSinkState* rss = static_cast<RangeSinkState*>(token);
if (rss->p_remain == 0) {
LOG(ERROR) << "range sink write overrun";
return 0;
}
size_t written = 0;
while (size > 0) {
size_t write_now = size;
if (rss->p_remain < write_now) {
write_now = rss->p_remain;
}
if (write_all(rss->fd, data, write_now) == -1) {
break;
}
data += write_now;
size -= write_now;
rss->p_remain -= write_now;
written += write_now;
if (rss->p_remain == 0) { if (rss->p_remain == 0) {
LOG(ERROR) << "range sink write overrun"; // Move to the next block.
return 0; ++rss->p_block;
if (rss->p_block < rss->tgt.count) {
rss->p_remain =
(rss->tgt.pos[rss->p_block * 2 + 1] - rss->tgt.pos[rss->p_block * 2]) * BLOCKSIZE;
off64_t offset = static_cast<off64_t>(rss->tgt.pos[rss->p_block * 2]) * BLOCKSIZE;
if (!discard_blocks(rss->fd, offset, rss->p_remain)) {
break;
}
if (!check_lseek(rss->fd, offset, SEEK_SET)) {
break;
}
} else {
// We can't write any more; return how many bytes have been written so far.
break;
}
} }
}
ssize_t written = 0; return written;
while (size > 0) {
size_t write_now = size;
if (rss->p_remain < write_now) {
write_now = rss->p_remain;
}
if (write_all(rss->fd, data, write_now) == -1) {
break;
}
data += write_now;
size -= write_now;
rss->p_remain -= write_now;
written += write_now;
if (rss->p_remain == 0) {
// move to the next block
++rss->p_block;
if (rss->p_block < rss->tgt.count) {
rss->p_remain = (rss->tgt.pos[rss->p_block * 2 + 1] -
rss->tgt.pos[rss->p_block * 2]) * BLOCKSIZE;
off64_t offset = static_cast<off64_t>(rss->tgt.pos[rss->p_block*2]) * BLOCKSIZE;
if (!discard_blocks(rss->fd, offset, rss->p_remain)) {
break;
}
if (!check_lseek(rss->fd, offset, SEEK_SET)) {
break;
}
} else {
// we can't write any more; return how many bytes have
// been written so far.
break;
}
}
}
return written;
} }
// All of the data for all the 'new' transfers is contained in one // All of the data for all the 'new' transfers is contained in one
@@ -338,7 +337,7 @@ static bool receive_new_data(const uint8_t* data, size_t size, void* cookie) {
// At this point nti->rss is set, and we own it. The main // At this point nti->rss is set, and we own it. The main
// thread is waiting for it to disappear from nti. // thread is waiting for it to disappear from nti.
ssize_t written = RangeSinkWrite(data, size, nti->rss); size_t written = RangeSinkWrite(data, size, nti->rss);
data += written; data += written;
size -= written; size -= written;