Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f7eb760f authored by Tao Bao's avatar Tao Bao
Browse files

applypatch: Change the ssize_t length parameters to size_t. 

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
parent f037b7b5

applypatch/applypatch.cpp

+18 −19
Original line number Diff line number Diff line
@@ -42,7 +42,7 @@ 
#include "print_sha1.h"



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,

                          const std::string& target_filename,

                          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;

  }



  ssize_t bytes_written = FileSink(file->data.data(), file->data.size(), &fd);

  if (bytes_written != static_cast<ssize_t>(file->data.size())) {

  size_t bytes_written = FileSink(file->data.data(), file->data.size(), &fd);

  if (bytes_written != file->data.size()) {

    printf("short write of \"%s\" (%zd bytes of %zu): %s\n", filename, bytes_written,

           file->data.size(), strerror(errno));

    return -1;
@@ -433,12 +433,11 @@ int ShowLicenses() { 
    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);

    ssize_t done = 0;

    ssize_t wrote;

  size_t done = 0;

  while (done < len) {

        wrote = TEMP_FAILURE_RETRY(ota_write(fd, data+done, len-done));

    ssize_t wrote = TEMP_FAILURE_RETRY(ota_write(fd, data + done, len - done));

    if (wrote == -1) {

      printf("error writing %zd bytes: %s\n", (len - done), strerror(errno));

      return done;
@@ -448,7 +447,7 @@ ssize_t FileSink(const unsigned char* data, ssize_t len, void* token) { 
  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);

  s->append(reinterpret_cast<const char*>(data), len);

  return len;

applypatch/bspatch.cpp

+4 −4
Original line number Diff line number Diff line
@@ -60,8 +60,8 @@ void ShowBSDiffLicense() { 
        );

}



int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size, const Value* patch,

                     ssize_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx) {

int ApplyBSDiffPatch(const unsigned char* old_data, size_t old_size, const Value* patch,

                     size_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx) {

  auto sha_sink = [&](const uint8_t* data, size_t len) {

    len = sink(data, len, token);

    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);

}



int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size, const Value* patch,

                        ssize_t patch_offset, std::vector<unsigned char>* new_data) {

int ApplyBSDiffPatchMem(const unsigned char* old_data, size_t old_size, const Value* patch,

                        size_t patch_offset, std::vector<unsigned char>* new_data) {

  auto vector_sink = [new_data](const uint8_t* data, size_t len) {

    new_data->insert(new_data->end(), data, data + len);

    return len;

applypatch/imgpatch.cpp

+8 −9
Original line number Diff line number Diff line
@@ -43,9 +43,8 @@ static inline int32_t Read4(const void *address) { 
  return android::base::get_unaligned<int32_t>(address);

}



int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,

                    const unsigned char* patch_data, ssize_t patch_size,

                    SinkFn sink, void* token) {

int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const unsigned char* patch_data,

                    size_t patch_size, SinkFn sink, void* token) {

  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);
@@ -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.

 * Return 0 on success.

 */

int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value* patch,

                    SinkFn sink, void* token, SHA_CTX* ctx, const Value* bonus_data) {

int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const Value* patch, SinkFn sink,

                    void* token, SHA_CTX* ctx, const Value* bonus_data) {

  if (patch->data.size() < 12) {

    printf("patch too short to contain header\n");

    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 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");

        return -1;

      }
@@ -110,7 +109,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size, const Value 
        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()) {

        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 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");

        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.next_out = temp_data.data();

          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) {

            printf("failed to write %zd compressed bytes to output\n", have);

applypatch/include/applypatch/applypatch.h

+7 −11
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ struct FileContents { 
// and use it as the source instead.

#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

int ShowLicenses();
@@ -66,18 +66,14 @@ int SaveFileContents(const char* filename, const FileContents* file); 


// bspatch.cpp

void ShowBSDiffLicense();

int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,

                     const Value* patch, ssize_t patch_offset,

                     SinkFn sink, void* token, SHA_CTX* ctx);

int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size,

                        const Value* patch, ssize_t patch_offset,

                        std::vector<unsigned char>* new_data);

int ApplyBSDiffPatch(const unsigned char* old_data, size_t old_size, const Value* patch,

                     size_t patch_offset, SinkFn sink, void* token, SHA_CTX* ctx);

int ApplyBSDiffPatchMem(const unsigned char* old_data, size_t old_size, const Value* patch,

                        size_t patch_offset, std::vector<unsigned char>* new_data);



// imgpatch.cpp

int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,

                    const Value* patch,

                    SinkFn sink, void* token, SHA_CTX* ctx,

                    const Value* bonus_data);

int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const Value* patch, SinkFn sink,

                    void* token, SHA_CTX* ctx, const Value* bonus_data);



// freecache.cpp

int MakeFreeSpaceOnCache(size_t bytes_needed);

applypatch/include/applypatch/imgpatch.h

+3 −4
Original line number Diff line number Diff line
@@ -19,10 +19,9 @@ 


#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,

                    const unsigned char* patch_data, ssize_t patch_size,

                    SinkFn sink, void* token);

int ApplyImagePatch(const unsigned char* old_data, size_t old_size, const unsigned char* patch_data,

                    size_t patch_size, SinkFn sink, void* token);



#endif  // _APPLYPATCH_IMGPATCH_H