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

Commit fc79767f authored by Elliott Hughes's avatar Elliott Hughes
Browse files

Use 64-bit file sizes in fastboot. 

Bug: 20110580
Change-Id: I5d3718103ff581ff3b5241c8b0e52b585b4f37e5
parent 43f43d87

fastboot/bootimg_utils.cpp

+14 −22
Original line number Diff line number Diff line
@@ -37,27 +37,22 @@ void bootimg_set_cmdline(boot_img_hdr *h, const char *cmdline) 
    strcpy((char*) h->cmdline, cmdline);

}



boot_img_hdr *mkbootimg(void *kernel, unsigned kernel_size, unsigned kernel_offset,

                        void *ramdisk, unsigned ramdisk_size, unsigned ramdisk_offset,

                        void *second, unsigned second_size, unsigned second_offset,

                        unsigned page_size, unsigned base, unsigned tags_offset,

                        unsigned *bootimg_size)

boot_img_hdr* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset,

                        void* ramdisk, int64_t ramdisk_size, off_t ramdisk_offset,

                        void* second, int64_t second_size, off_t second_offset,

                        size_t page_size, size_t base, off_t tags_offset,

                        int64_t* bootimg_size)

{

    unsigned kernel_actual;

    unsigned ramdisk_actual;

    unsigned second_actual;

    unsigned page_mask;

    size_t page_mask = page_size - 1;



    page_mask = page_size - 1;



    kernel_actual = (kernel_size + page_mask) & (~page_mask);

    ramdisk_actual = (ramdisk_size + page_mask) & (~page_mask);

    second_actual = (second_size + page_mask) & (~page_mask);

    int64_t kernel_actual = (kernel_size + page_mask) & (~page_mask);

    int64_t ramdisk_actual = (ramdisk_size + page_mask) & (~page_mask);

    int64_t second_actual = (second_size + page_mask) & (~page_mask);



    *bootimg_size = page_size + kernel_actual + ramdisk_actual + second_actual;



    boot_img_hdr* hdr = reinterpret_cast<boot_img_hdr*>(calloc(*bootimg_size, 1));

    if (hdr == 0) {

    if (hdr == nullptr) {

        return hdr;

    }
@@ -74,12 +69,9 @@ boot_img_hdr *mkbootimg(void *kernel, unsigned kernel_size, unsigned kernel_offs 


    hdr->page_size =    page_size;



    memcpy(hdr->magic + page_size, kernel, kernel_size);

    memcpy(hdr->magic + page_size + kernel_actual, ramdisk, ramdisk_size);

    memcpy(hdr->magic + page_size + kernel_actual + ramdisk_actual, second, second_size);



    memcpy(hdr->magic + page_size,

           kernel, kernel_size);

    memcpy(hdr->magic + page_size + kernel_actual,

           ramdisk, ramdisk_size);

    memcpy(hdr->magic + page_size + kernel_actual + ramdisk_actual,

           second, second_size);

    return hdr;

}

fastboot/bootimg_utils.h

+8 −14
Original line number Diff line number Diff line
@@ -30,20 +30,14 @@ 
#define _FASTBOOT_BOOTIMG_UTILS_H_



#include <bootimg.h>



#if defined(__cplusplus)

extern "C" {

#endif

#include <inttypes.h>

#include <sys/types.h>



void bootimg_set_cmdline(boot_img_hdr* h, const char* cmdline);

boot_img_hdr *mkbootimg(void *kernel, unsigned kernel_size, unsigned kernel_offset,

                        void *ramdisk, unsigned ramdisk_size, unsigned ramdisk_offset,

                        void *second, unsigned second_size, unsigned second_offset,

                        unsigned page_size, unsigned base, unsigned tags_offset,

                        unsigned *bootimg_size);



#if defined(__cplusplus)

}

#endif

boot_img_hdr* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset,

                        void* ramdisk, int64_t ramdisk_size, off_t ramdisk_offset,

                        void* second, int64_t second_size, off_t second_offset,

                        size_t page_size, size_t base, off_t tags_offset,

                        int64_t* bootimg_size);



#endif

fastboot/engine.cpp

+9 −15
Original line number Diff line number Diff line
@@ -30,8 +30,6 @@ 
#include "fs.h"



#include <errno.h>

#include <stdarg.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>
@@ -39,12 +37,6 @@ 
#include <sys/types.h>

#include <unistd.h>



#ifdef USE_MINGW

#include <fcntl.h>

#else

#include <sys/mman.h>

#endif



#define ARRAY_SIZE(x)           (sizeof(x)/sizeof(x[0]))



#define OP_DOWNLOAD   1
@@ -58,15 +50,17 @@ typedef struct Action Action; 


#define CMD_SIZE 64



struct Action

{

struct Action {

    unsigned op;

    Action* next;



    char cmd[CMD_SIZE];

    const char* prod;

    void* data;

    unsigned size;



    // The protocol only supports 32-bit sizes, so you'll have to break

    // anything larger into chunks.

    uint32_t size;



    const char *msg;

    int (*func)(Action* a, int status, const char* resp);
@@ -267,7 +261,7 @@ static int cb_reject(Action* a, int status, const char* resp) { 
}



void fb_queue_require(const char *prod, const char *var,

                      int invert, unsigned nvalues, const char **value)

                      bool invert, size_t nvalues, const char **value)

{

    Action *a;

    a = queue_action(OP_QUERY, "getvar:%s", var);

fastboot/fastboot.cpp

+116 −156
Original line number Diff line number Diff line
@@ -34,7 +34,6 @@ 
#include <getopt.h>

#include <inttypes.h>

#include <limits.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>
@@ -67,12 +66,12 @@ static int long_listing = 0; 
static int64_t sparse_limit = -1;

static int64_t target_sparse_limit = -1;



unsigned page_size = 2048;

unsigned base_addr      = 0x10000000;

unsigned kernel_offset  = 0x00008000;

unsigned ramdisk_offset = 0x01000000;

unsigned second_offset  = 0x00f00000;

unsigned tags_offset    = 0x00000100;

static unsigned page_size = 2048;

static unsigned base_addr      = 0x10000000;

static unsigned kernel_offset  = 0x00008000;

static unsigned ramdisk_offset = 0x01000000;

static unsigned second_offset  = 0x00f00000;

static unsigned tags_offset    = 0x00000100;



enum fb_buffer_type {

    FB_BUFFER,
@@ -82,7 +81,7 @@ enum fb_buffer_type { 
struct fastboot_buffer {

    enum fb_buffer_type type;

    void* data;

    unsigned int sz;

    int64_t sz;

};



static struct {
@@ -97,8 +96,7 @@ static struct { 
    {"vendor.img", "vendor.sig", "vendor", true},

};



char *find_item(const char *item, const char *product)

{

static char* find_item(const char* item, const char* product) {

    char *dir;

    const char *fn;

    char path[PATH_MAX + 128];
@@ -139,36 +137,26 @@ char *find_item(const char *item, const char *product) 
    return strdup(path);

}



static int64_t file_size(int fd)

{

    struct stat st;

    int ret;



    ret = fstat(fd, &st);



    return ret ? -1 : st.st_size;

static int64_t get_file_size(int fd) {

    struct stat sb;

    return fstat(fd, &sb) == -1 ? -1 : sb.st_size;

}



static void *load_fd(int fd, unsigned *_sz)

{

    char *data;

    int sz;

static void* load_fd(int fd, int64_t* sz) {

    int errno_tmp;

    char* data = nullptr;



    data = 0;



    sz = file_size(fd);

    if (sz < 0) {

    *sz = get_file_size(fd);

    if (*sz < 0) {

        goto oops;

    }



    data = (char*) malloc(sz);

    if(data == 0) goto oops;

    data = (char*) malloc(*sz);

    if (data == nullptr) goto oops;



    if(read(fd, data, sz) != sz) goto oops;

    if(read(fd, data, *sz) != *sz) goto oops;

    close(fd);



    if(_sz) *_sz = sz;

    return data;



oops:
@@ -179,17 +167,13 @@ oops: 
    return 0;

}



static void *load_file(const char *fn, unsigned *_sz)

{

    int fd;



    fd = open(fn, O_RDONLY | O_BINARY);

    if(fd < 0) return 0;



    return load_fd(fd, _sz);

static void* load_file(const char* fn, int64_t* sz) {

    int fd = open(fn, O_RDONLY | O_BINARY);

    if (fd == -1) return nullptr;

    return load_fd(fd, sz);

}



int match_fastboot_with_serial(usb_ifc_info* info, const char* local_serial) {

static int match_fastboot_with_serial(usb_ifc_info* info, const char* local_serial) {

    // Require a matching vendor id if the user specified one with -i.

    if (vendor_id != 0 && info->dev_vendor != vendor_id) {

        return -1;
@@ -206,14 +190,12 @@ int match_fastboot_with_serial(usb_ifc_info* info, const char* local_serial) { 
    return 0;

}



int match_fastboot(usb_ifc_info *info)

{

static int match_fastboot(usb_ifc_info* info) {

    return match_fastboot_with_serial(info, serial);

}



int list_devices_callback(usb_ifc_info *info)

{

    if (match_fastboot_with_serial(info, NULL) == 0) {

static int list_devices_callback(usb_ifc_info* info) {

    if (match_fastboot_with_serial(info, nullptr) == 0) {

        const char* serial = info->serial_number;

        if (!info->writable) {

            serial = "no permissions"; // like "adb devices"
@@ -234,8 +216,7 @@ int list_devices_callback(usb_ifc_info *info) 
    return -1;

}



usb_handle *open_device(void)

{

static usb_handle* open_device() {

    static usb_handle *usb = 0;

    int announce = 1;
@@ -252,15 +233,14 @@ usb_handle *open_device(void) 
    }

}



void list_devices(void) {

static void list_devices() {

    // We don't actually open a USB device here,

    // just getting our callback called so we can

    // list all the connected devices.

    usb_open(list_devices_callback);

}



void usage(void)

{

static void usage() {

    fprintf(stderr,

/*           1234567890123456789012345678901234567890123456789012345678901234567890123456 */

            "usage: fastboot [ <option> ] <command>\n"
@@ -315,27 +295,22 @@ void usage(void) 
        );

}



void *load_bootable_image(const char *kernel, const char *ramdisk,

                          const char *secondstage, unsigned *sz,

                          const char *cmdline)

{

    void *kdata = 0, *rdata = 0, *sdata = 0;

    unsigned ksize = 0, rsize = 0, ssize = 0;

    void *bdata;

    unsigned bsize;



    if(kernel == 0) {

static void* load_bootable_image(const char* kernel, const char* ramdisk,

                                 const char* secondstage, int64_t* sz,

                                 const char* cmdline) {

    if (kernel == nullptr) {

        fprintf(stderr, "no image specified\n");

        return 0;

    }



    kdata = load_file(kernel, &ksize);

    if(kdata == 0) {

    int64_t ksize;

    void* kdata = load_file(kernel, &ksize);

    if (kdata == nullptr) {

        fprintf(stderr, "cannot load '%s': %s\n", kernel, strerror(errno));

        return 0;

    }



        /* is this actually a boot image? */

    // Is this actually a boot image?

    if(!memcmp(kdata, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {

        if (cmdline) bootimg_set_cmdline((boot_img_hdr*) kdata, cmdline);
@@ -348,39 +323,44 @@ void *load_bootable_image(const char *kernel, const char *ramdisk, 
        return kdata;

    }



    void* rdata = nullptr;

    int64_t rsize = 0;

    if (ramdisk) {

        rdata = load_file(ramdisk, &rsize);

        if(rdata == 0) {

        if (rdata == nullptr) {

            fprintf(stderr,"cannot load '%s': %s\n", ramdisk, strerror(errno));

            return  0;

        }

    }



    void* sdata = nullptr;

    int64_t ssize = 0;

    if (secondstage) {

        sdata = load_file(secondstage, &ssize);

        if(sdata == 0) {

        if (sdata == nullptr) {

            fprintf(stderr,"cannot load '%s': %s\n", secondstage, strerror(errno));

            return  0;

        }

    }



    fprintf(stderr,"creating boot image...\n");

    bdata = mkbootimg(kdata, ksize, kernel_offset,

    int64_t bsize = 0;

    void* bdata = mkbootimg(kdata, ksize, kernel_offset,

                      rdata, rsize, ramdisk_offset,

                      sdata, ssize, second_offset,

                      page_size, base_addr, tags_offset, &bsize);

    if(bdata == 0) {

    if (bdata == nullptr) {

        fprintf(stderr,"failed to create boot.img\n");

        return 0;

    }

    if (cmdline) bootimg_set_cmdline((boot_img_hdr*) bdata, cmdline);

    fprintf(stderr,"creating boot image - %d bytes\n", bsize);

    fprintf(stderr, "creating boot image - %" PRId64 " bytes\n", bsize);

    *sz = bsize;



    return bdata;

}



static void* unzip_file(ZipArchiveHandle zip, const char* entry_name, unsigned* sz)

static void* unzip_file(ZipArchiveHandle zip, const char* entry_name, int64_t* sz)

{

    ZipString zip_entry_name(entry_name);

    ZipEntry zip_entry;
@@ -392,8 +372,8 @@ static void* unzip_file(ZipArchiveHandle zip, const char* entry_name, unsigned* 
    *sz = zip_entry.uncompressed_length;



    uint8_t* data = reinterpret_cast<uint8_t*>(malloc(zip_entry.uncompressed_length));

    if (data == NULL) {

        fprintf(stderr, "failed to allocate %u bytes for '%s'\n", *sz, entry_name);

    if (data == nullptr) {

        fprintf(stderr, "failed to allocate %" PRId64 " bytes for '%s'\n", *sz, entry_name);

        return 0;

    }
@@ -438,7 +418,7 @@ static FILE* win32_tmpfile() { 


static int unzip_to_file(ZipArchiveHandle zip, char* entry_name) {

    FILE* fp = tmpfile();

    if (fp == NULL) {

    if (fp == nullptr) {

        fprintf(stderr, "failed to create temporary file for '%s': %s\n",

                entry_name, strerror(errno));

        return -1;
@@ -478,7 +458,7 @@ static char *strip(char *s) 
static int setup_requirement_line(char *name)

{

    char *val[MAX_OPTIONS];

    char *prod = NULL;

    char *prod = nullptr;

    unsigned n, count;

    char *x;

    int invert = 0;
@@ -539,11 +519,8 @@ static int setup_requirement_line(char *name) 
    return 0;

}



static void setup_requirements(char *data, unsigned sz)

{

    char *s;



    s = data;

static void setup_requirements(char* data, int64_t sz) {

    char* s = data;

    while (sz-- > 0) {

        if (*s == '\n') {

            *s++ = 0;
@@ -557,8 +534,7 @@ static void setup_requirements(char *data, unsigned sz) 
    }

}



void queue_info_dump(void)

{

static void queue_info_dump() {

    fb_queue_notice("--------------------------------------------");

    fb_queue_display("version-bootloader", "Bootloader Version...");

    fb_queue_display("version-baseband",   "Baseband Version.....");
@@ -573,7 +549,7 @@ static struct sparse_file **load_sparse_files(int fd, int max_size) 
        die("cannot sparse read file\n");

    }



    int files = sparse_file_resparse(s, max_size, NULL, 0);

    int files = sparse_file_resparse(s, max_size, nullptr, 0);

    if (files < 0) {

        die("Failed to resparse\n");

    }
@@ -598,7 +574,7 @@ static int64_t get_target_sparse_limit(struct usb_handle *usb) 
    int status = fb_getvar(usb, response, "max-download-size");



    if (!status) {

        limit = strtoul(response, NULL, 0);

        limit = strtoul(response, nullptr, 0);

        if (limit > 0) {

            fprintf(stderr, "target reported max download size of %" PRId64 " bytes\n",

                    limit);
@@ -643,35 +619,27 @@ static int needs_erase(usb_handle* usb, const char *part) 
    /* The function fb_format_supported() currently returns the value

     * we want, so just call it.

     */

     return fb_format_supported(usb, part, NULL);

     return fb_format_supported(usb, part, nullptr);

}



static int load_buf_fd(usb_handle *usb, int fd,

        struct fastboot_buffer *buf)

{

    int64_t sz64;

    void *data;

    int64_t limit;





    sz64 = file_size(fd);

    if (sz64 < 0) {

static int load_buf_fd(usb_handle* usb, int fd, struct fastboot_buffer* buf) {

    int64_t sz = get_file_size(fd);

    if (sz == -1) {

        return -1;

    }



    lseek(fd, 0, SEEK_SET);

    limit = get_sparse_limit(usb, sz64);

    lseek64(fd, 0, SEEK_SET);

    int64_t limit = get_sparse_limit(usb, sz);

    if (limit) {

        struct sparse_file **s = load_sparse_files(fd, limit);

        if (s == NULL) {

        sparse_file** s = load_sparse_files(fd, limit);

        if (s == nullptr) {

            return -1;

        }

        buf->type = FB_BUFFER_SPARSE;

        buf->data = s;

    } else {

        unsigned int sz;

        data = load_fd(fd, &sz);

        if (data == 0) return -1;

        void* data = load_fd(fd, &sz);

        if (data == nullptr) return -1;

        buf->type = FB_BUFFER;

        buf->data = data;

        buf->sz = sz;
@@ -701,8 +669,8 @@ static void flash_buf(const char *pname, struct fastboot_buffer *buf) 
        case FB_BUFFER_SPARSE:

            s = reinterpret_cast<sparse_file**>(buf->data);

            while (*s) {

                int64_t sz64 = sparse_file_len(*s, true, false);

                fb_queue_flash_sparse(pname, *s++, sz64);

                int64_t sz = sparse_file_len(*s, true, false);

                fb_queue_flash_sparse(pname, *s++, sz);

            }

            break;

        case FB_BUFFER:
@@ -713,8 +681,7 @@ static void flash_buf(const char *pname, struct fastboot_buffer *buf) 
    }

}



void do_flash(usb_handle *usb, const char *pname, const char *fname)

{

static void do_flash(usb_handle* usb, const char* pname, const char* fname) {

    struct fastboot_buffer buf;



    if (load_buf(usb, fname, &buf)) {
@@ -723,17 +690,15 @@ void do_flash(usb_handle *usb, const char *pname, const char *fname) 
    flash_buf(pname, &buf);

}



void do_update_signature(ZipArchiveHandle zip, char *fn)

{

    unsigned sz;

static void do_update_signature(ZipArchiveHandle zip, char* fn) {

    int64_t sz;

    void* data = unzip_file(zip, fn, &sz);

    if (data == 0) return;

    if (data == nullptr) return;

    fb_queue_download("signature", data, sz);

    fb_queue_command("signature", "installing signature");

}



void do_update(usb_handle *usb, const char *filename, int erase_first)

{

static void do_update(usb_handle* usb, const char* filename, bool erase_first) {

    queue_info_dump();



    fb_queue_query_save("product", cur_product, sizeof(cur_product));
@@ -745,9 +710,9 @@ void do_update(usb_handle *usb, const char *filename, int erase_first) 
        die("failed to open zip file '%s': %s", filename, ErrorCodeString(error));

    }



    unsigned sz;

    int64_t sz;

    void* data = unzip_file(zip, "android-info.txt", &sz);

    if (data == 0) {

    if (data == nullptr) {

        CloseArchive(zip);

        die("update package '%s' has no android-info.txt", filename);

    }
@@ -780,36 +745,33 @@ void do_update(usb_handle *usb, const char *filename, int erase_first) 
    CloseArchive(zip);

}



void do_send_signature(char *fn)

{

    void *data;

    unsigned sz;

    char *xtn;



    xtn = strrchr(fn, '.');

static void do_send_signature(char* fn) {

    char* xtn = strrchr(fn, '.');

    if (!xtn) return;



    if (strcmp(xtn, ".img")) return;



    strcpy(xtn, ".sig");

    data = load_file(fn, &sz);



    int64_t sz;

    void* data = load_file(fn, &sz);

    strcpy(xtn, ".img");

    if (data == 0) return;

    if (data == nullptr) return;

    fb_queue_download("signature", data, sz);

    fb_queue_command("signature", "installing signature");

}



void do_flashall(usb_handle *usb, int erase_first)

{

static void do_flashall(usb_handle* usb, int erase_first) {

    queue_info_dump();



    fb_queue_query_save("product", cur_product, sizeof(cur_product));



    char* fname = find_item("info", product);

    if (fname == 0) die("cannot find android-info.txt");

    if (fname == nullptr) die("cannot find android-info.txt");



    unsigned sz;

    int64_t sz;

    void* data = load_file(fname, &sz);

    if (data == 0) die("could not load android-info.txt: %s", strerror(errno));

    if (data == nullptr) die("could not load android-info.txt: %s", strerror(errno));



    setup_requirements(reinterpret_cast<char*>(data), sz);
@@ -832,8 +794,7 @@ void do_flashall(usb_handle *usb, int erase_first) 
#define skip(n) do { argc -= (n); argv += (n); } while (0)

#define require(n) do { if (argc < (n)) {usage(); exit(1);}} while (0)



int do_oem_command(int argc, char **argv)

{

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

    char command[256];

    if (argc <= 1) return 0;
@@ -890,16 +851,15 @@ static int64_t parse_num(const char *arg) 
    return num;

}



void fb_perform_format(usb_handle* usb,

static void fb_perform_format(usb_handle* usb,

                              const char *partition, int skip_if_not_supported,

                       const char *type_override, const char *size_override)

{

                              const char *type_override, const char *size_override) {

    char pTypeBuff[FB_RESPONSE_SZ + 1], pSizeBuff[FB_RESPONSE_SZ + 1];

    char *pType = pTypeBuff;

    char *pSize = pSizeBuff;

    unsigned int limit = INT_MAX;

    struct fastboot_buffer buf;

    const char *errMsg = NULL;

    const char *errMsg = nullptr;

    const struct fs_generator *gen;

    uint64_t pSz;

    int status;
@@ -949,7 +909,7 @@ void fb_perform_format(usb_handle* usb, 
        return;

    }



    pSz = strtoll(pSize, (char **)NULL, 16);

    pSz = strtoll(pSize, (char **)nullptr, 16);



    fd = fileno(tmpfile());

    if (fs_generator_generate(gen, fd, pSz)) {
@@ -982,9 +942,9 @@ int main(int argc, char **argv) 
    int wants_wipe = 0;

    int wants_reboot = 0;

    int wants_reboot_bootloader = 0;

    int erase_first = 1;

    bool erase_first = true;

    void *data;

    unsigned sz;

    int64_t sz;

    int status;

    int c;

    int longindex;
@@ -1020,7 +980,7 @@ int main(int argc, char **argv) 
            usage();

            return 1;

        case 'i': {

                char *endptr = NULL;

                char *endptr = nullptr;

                unsigned long val;



                val = strtoul(optarg, &endptr, 0);
@@ -1036,7 +996,7 @@ int main(int argc, char **argv) 
            long_listing = 1;

            break;

        case 'n':

            page_size = (unsigned)strtoul(optarg, NULL, 0);

            page_size = (unsigned)strtoul(optarg, nullptr, 0);

            if (!page_size) die("invalid page size");

            break;

        case 'p':
@@ -1058,7 +1018,7 @@ int main(int argc, char **argv) 
            }

            break;

        case 'u':

            erase_first = 0;

            erase_first = false;

            break;

        case 'w':

            wants_wipe = 1;
@@ -1067,8 +1027,8 @@ int main(int argc, char **argv) 
            return 1;

        case 0:

            if (strcmp("unbuffered", longopts[longindex].name) == 0) {

                setvbuf(stdout, NULL, _IONBF, 0);

                setvbuf(stderr, NULL, _IONBF, 0);

                setvbuf(stdout, nullptr, _IONBF, 0);

                setvbuf(stderr, nullptr, _IONBF, 0);

            } else if (strcmp("version", longopts[longindex].name) == 0) {

                fprintf(stdout, "fastboot version %s\n", FASTBOOT_REVISION);

                return 0;
@@ -1108,7 +1068,7 @@ int main(int argc, char **argv) 
        } else if(!strcmp(*argv, "erase")) {

            require(2);



            if (fb_format_supported(usb, argv[1], NULL)) {

            if (fb_format_supported(usb, argv[1], nullptr)) {

                fprintf(stderr, "******** Did you mean to fastboot format this partition?\n");

            }
@@ -1116,8 +1076,8 @@ int main(int argc, char **argv) 
            skip(2);

        } else if(!strncmp(*argv, "format", strlen("format"))) {

            char *overrides;

            char *type_override = NULL;

            char *size_override = NULL;

            char *type_override = nullptr;

            char *size_override = nullptr;

            require(2);

            /*

             * Parsing for: "format[:[type][:[size]]]"
@@ -1138,8 +1098,8 @@ int main(int argc, char **argv) 
                }

                type_override = overrides;

            }

            if (type_override && !type_override[0]) type_override = NULL;

            if (size_override && !size_override[0]) size_override = NULL;

            if (type_override && !type_override[0]) type_override = nullptr;

            if (size_override && !size_override[0]) size_override = nullptr;

            if (erase_first && needs_erase(usb, argv[1])) {

                fb_queue_erase(argv[1]);

            }
@@ -1148,7 +1108,7 @@ int main(int argc, char **argv) 
        } else if(!strcmp(*argv, "signature")) {

            require(2);

            data = load_file(argv[1], &sz);

            if (data == 0) die("could not load '%s': %s", argv[1], strerror(errno));

            if (data == nullptr) die("could not load '%s': %s", argv[1], strerror(errno));

            if (sz != 256) die("signature must be 256 bytes");

            fb_queue_download("signature", data, sz);

            fb_queue_command("signature", "installing signature");
@@ -1258,9 +1218,9 @@ int main(int argc, char **argv) 


    if (wants_wipe) {

        fb_queue_erase("userdata");

        fb_perform_format(usb, "userdata", 1, NULL, NULL);

        fb_perform_format(usb, "userdata", 1, nullptr, nullptr);

        fb_queue_erase("cache");

        fb_perform_format(usb, "cache", 1, NULL, NULL);

        fb_perform_format(usb, "cache", 1, nullptr, nullptr);

    }

    if (wants_reboot) {

        fb_queue_reboot();

fastboot/fastboot.h

+11 −16
Original line number Diff line number Diff line
@@ -29,18 +29,17 @@ 
#ifndef _FASTBOOT_H_

#define _FASTBOOT_H_



#include "usb.h"

#include <inttypes.h>

#include <stdlib.h>



#if defined(__cplusplus)

extern "C" {

#endif

#include "usb.h"



struct sparse_file;



/* protocol.c - fastboot protocol */

int fb_command(usb_handle *usb, const char *cmd);

int fb_command_response(usb_handle *usb, const char *cmd, char *response);

int fb_download_data(usb_handle *usb, const void *data, unsigned size);

int fb_download_data(usb_handle *usb, const void *data, uint32_t size);

int fb_download_data_sparse(usb_handle *usb, struct sparse_file *s);

char *fb_get_error(void);
@@ -50,17 +49,17 @@ char *fb_get_error(void); 
/* engine.c - high level command queue engine */

int fb_getvar(struct usb_handle *usb, char *response, const char *fmt, ...);

int fb_format_supported(usb_handle *usb, const char *partition, const char *type_override);

void fb_queue_flash(const char *ptn, void *data, unsigned sz);

void fb_queue_flash_sparse(const char *ptn, struct sparse_file *s, unsigned sz);

void fb_queue_flash(const char *ptn, void *data, uint32_t sz);

void fb_queue_flash_sparse(const char *ptn, struct sparse_file *s, uint32_t sz);

void fb_queue_erase(const char *ptn);

void fb_queue_format(const char *ptn, int skip_if_not_supported, unsigned int max_chunk_sz);

void fb_queue_require(const char *prod, const char *var, int invert,

        unsigned nvalues, const char **value);

void fb_queue_format(const char *ptn, int skip_if_not_supported, int32_t max_chunk_sz);

void fb_queue_require(const char *prod, const char *var, bool invert,

                      size_t nvalues, const char **value);

void fb_queue_display(const char *var, const char *prettyname);

void fb_queue_query_save(const char *var, char *dest, unsigned dest_size);

void fb_queue_query_save(const char *var, char *dest, uint32_t dest_size);

void fb_queue_reboot(void);

void fb_queue_command(const char *cmd, const char *msg);

void fb_queue_download(const char *name, void *data, unsigned size);

void fb_queue_download(const char *name, void *data, uint32_t size);

void fb_queue_notice(const char *notice);

void fb_queue_wait_for_disconnect(void);

int fb_execute_queue(usb_handle *usb);
@@ -76,8 +75,4 @@ void get_my_path(char *path); 
/* Current product */

extern char cur_product[FB_RESPONSE_SZ + 1];



#if defined(__cplusplus)

}

#endif



#endif