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

Commit f47259b1 authored by Tao Bao's avatar Tao Bao Committed by Rom Lemarchand
Browse files

applypatch: Support flash mode. 

We may carry a full copy of recovery image in the /system, and use
/system/bin/install-recovery.sh to install the recovery. This CL adds
support to flash the recovery partition with the given image.

Bug: 22641135
Change-Id: I345eaaee269f6443527f45a9be7e4ee47f6b2b39
(cherry picked from commit 68c5a679)
parent 3b199267

applypatch/applypatch.cpp

+72 −12
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ static int GenerateTarget(FileContents* source_file, 
                          const uint8_t target_sha1[SHA_DIGEST_SIZE],

                          size_t target_size,

                          const Value* bonus_data);

static std::string short_sha1(const uint8_t sha1[SHA_DIGEST_SIZE]);



static bool mtd_partitions_scanned = false;
@@ -461,7 +462,7 @@ int WriteToPartition(unsigned char* data, size_t len, const char* target) { 
                }



                if (start == len) {

                    printf("verification read succeeded (attempt %d)\n", attempt+1);

                    printf("verification read succeeded (attempt %zu)\n", attempt+1);

                    success = true;

                    break;

                }
@@ -628,12 +629,14 @@ int CacheSizeCheck(size_t bytes) { 
    }

}



static void print_short_sha1(const uint8_t sha1[SHA_DIGEST_SIZE]) {

static std::string short_sha1(const uint8_t sha1[SHA_DIGEST_SIZE]) {

    const char* hex = "0123456789abcdef";

    std::string result = "";

    for (size_t i = 0; i < 4; ++i) {

        putchar(hex[(sha1[i]>>4) & 0xf]);

        putchar(hex[sha1[i] & 0xf]);

        result.push_back(hex[(sha1[i]>>4) & 0xf]);

        result.push_back(hex[sha1[i] & 0xf]);

    }

    return result;

}



// This function applies binary patches to files in a way that is safe
@@ -648,7 +651,7 @@ static void print_short_sha1(const uint8_t sha1[SHA_DIGEST_SIZE]) { 
//   entries in <patch_sha1_str>, the corresponding patch from

//   <patch_data> (which must be a VAL_BLOB) is applied to produce a

//   new file (the type of patch is automatically detected from the

//   blob daat).  If that new file has sha1 hash <target_sha1_str>,

//   blob data).  If that new file has sha1 hash <target_sha1_str>,

//   moves it to replace <target_filename>, and exits successfully.

//   Note that if <source_filename> and <target_filename> are not the

//   same, <source_filename> is NOT deleted on success.
@@ -694,9 +697,7 @@ int applypatch(const char* source_filename, 
        if (memcmp(source_file.sha1, target_sha1, SHA_DIGEST_SIZE) == 0) {

            // The early-exit case:  the patch was already applied, this file

            // has the desired hash, nothing for us to do.

            printf("already ");

            print_short_sha1(target_sha1);

            putchar('\n');

            printf("already %s\n", short_sha1(target_sha1).c_str());

            free(source_file.data);

            return 0;

        }
@@ -753,6 +754,67 @@ int applypatch(const char* source_filename, 
    return result;

}



/*

 * This function flashes a given image to the target partition. It verifies

 * the target cheksum first, and will return if target has the desired hash.

 * It checks the checksum of the given source image before flashing, and

 * verifies the target partition afterwards. The function is idempotent.

 * Returns zero on success.

 */

int applypatch_flash(const char* source_filename, const char* target_filename,

                     const char* target_sha1_str, size_t target_size) {

    printf("flash %s: ", target_filename);



    uint8_t target_sha1[SHA_DIGEST_SIZE];

    if (ParseSha1(target_sha1_str, target_sha1) != 0) {

        printf("failed to parse tgt-sha1 \"%s\"\n", target_sha1_str);

        return 1;

    }



    FileContents source_file;

    source_file.data = NULL;

    std::string target_str(target_filename);



    std::vector<std::string> pieces = android::base::Split(target_str, ":");

    if (pieces.size() != 2 || (pieces[0] != "MTD" && pieces[0] != "EMMC")) {

        printf("invalid target name \"%s\"", target_filename);

        return 1;

    }



    // Load the target into the source_file object to see if already applied.

    pieces.push_back(std::to_string(target_size));

    pieces.push_back(target_sha1_str);

    std::string fullname = android::base::Join(pieces, ':');

    if (LoadPartitionContents(fullname.c_str(), &source_file) == 0 &&

        memcmp(source_file.sha1, target_sha1, SHA_DIGEST_SIZE) == 0) {

        // The early-exit case: the image was already applied, this partition

        // has the desired hash, nothing for us to do.

        printf("already %s\n", short_sha1(target_sha1).c_str());

        free(source_file.data);

        return 0;

    }



    if (LoadFileContents(source_filename, &source_file) == 0) {

        if (memcmp(source_file.sha1, target_sha1, SHA_DIGEST_SIZE) != 0) {

            // The source doesn't have desired checksum.

            printf("source \"%s\" doesn't have expected sha1 sum\n", source_filename);

            printf("expected: %s, found: %s\n", short_sha1(target_sha1).c_str(),

                    short_sha1(source_file.sha1).c_str());

            free(source_file.data);

            return 1;

        }

    }



    if (WriteToPartition(source_file.data, target_size, target_filename) != 0) {

        printf("write of copied data to %s failed\n", target_filename);

        free(source_file.data);

        return 1;

    }



    free(source_file.data);

    return 0;

}



static int GenerateTarget(FileContents* source_file,

                          const Value* source_patch_value,

                          FileContents* copy_file,
@@ -953,9 +1015,7 @@ static int GenerateTarget(FileContents* source_file, 
        printf("patch did not produce expected sha1\n");

        return 1;

    } else {

        printf("now ");

        print_short_sha1(target_sha1);

        putchar('\n');

        printf("now %s\n", short_sha1(target_sha1).c_str());

    }



    if (output < 0) {

applypatch/applypatch.h

+2 −0
Original line number Diff line number Diff line
@@ -48,6 +48,8 @@ size_t FreeSpaceForFile(const char* filename); 
int CacheSizeCheck(size_t bytes);

int ParseSha1(const char* str, uint8_t* digest);



int applypatch_flash(const char* source_filename, const char* target_filename,

                     const char* target_sha1_str, size_t target_size);

int applypatch(const char* source_filename,

               const char* target_filename,

               const char* target_sha1_str,

applypatch/main.cpp

+23 −4
Original line number Diff line number Diff line
@@ -47,8 +47,8 @@ static int SpaceMode(int argc, char** argv) { 
// "<sha1>:<filename>" into the new parallel arrays *sha1s and

// *patches (loading file contents into the patches).  Returns true on

// success.

static bool ParsePatchArgs(int argc, char** argv,

                          char*** sha1s, Value*** patches, int* num_patches) {

static bool ParsePatchArgs(int argc, char** argv, char*** sha1s,

                           Value*** patches, int* num_patches) {

    *num_patches = argc;

    *sha1s = reinterpret_cast<char**>(malloc(*num_patches * sizeof(char*)));

    *patches = reinterpret_cast<Value**>(malloc(*num_patches * sizeof(Value*)));
@@ -98,7 +98,12 @@ static bool ParsePatchArgs(int argc, char** argv, 
    return false;

}



int PatchMode(int argc, char** argv) {

static int FlashMode(const char* src_filename, const char* tgt_filename,

                     const char* tgt_sha1, size_t tgt_size) {

    return applypatch_flash(src_filename, tgt_filename, tgt_sha1, tgt_size);

}



static int PatchMode(int argc, char** argv) {

    Value* bonus = NULL;

    if (argc >= 3 && strcmp(argv[1], "-b") == 0) {

        FileContents fc;
@@ -114,7 +119,7 @@ int PatchMode(int argc, char** argv) { 
        argv += 2;

    }



    if (argc < 6) {

    if (argc < 4) {

        return 2;

    }
@@ -125,6 +130,16 @@ int PatchMode(int argc, char** argv) { 
        return 1;

    }



    // If no <src-sha1>:<patch> is provided, it is in flash mode.

    if (argc == 5) {

        if (bonus != NULL) {

            printf("bonus file not supported in flash mode\n");

            return 1;

        }

        return FlashMode(argv[1], argv[2], argv[3], target_size);

    }





    char** sha1s;

    Value** patches;

    int num_patches;
@@ -162,6 +177,10 @@ int PatchMode(int argc, char** argv) { 
// - if the sha1 hash of <tgt-file> is <tgt-sha1>, does nothing and exits

//   successfully.

//

// - otherwise, if no <src-sha1>:<patch> is provided, flashes <tgt-file> with

//   <src-file>. <tgt-file> must be a partition name, while <src-file> must

//   be a regular image file. <src-file> will not be deleted on success.

//

// - otherwise, if the sha1 hash of <src-file> is <src-sha1>, applies the

//   bsdiff <patch> to <src-file> to produce a new file (the type of patch

//   is automatically detected from the file header).  If that new