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

Commit 856b7ecb authored by David Anderson's avatar David Anderson
Browse files

fastbootd: Allow returning errors from getvar handlers. 

Currently a few getvar handlers will return invalid strings when an
error occurs. This change allows those handlers to instead send a proper
failure message.

Bug: 78793464
Test: N/A
Change-Id: I7ff7d036c1e6fb0a3d700ecf21b1103ab77278d2
parent 7b1d163c

fastboot/device/commands.cpp

+2 −4
Original line number Diff line number Diff line
@@ -37,8 +37,7 @@ using ::android::hardware::boot::V1_0::CommandResult; 
using ::android::hardware::boot::V1_0::Slot;



bool GetVarHandler(FastbootDevice* device, const std::vector<std::string>& args) {

    using VariableHandler =

            std::function<std::string(FastbootDevice*, const std::vector<std::string>&)>;

    using VariableHandler = std::function<bool(FastbootDevice*, const std::vector<std::string>&)>;

    const std::unordered_map<std::string, VariableHandler> kVariableMap = {

            {FB_VAR_VERSION, GetVersion},

            {FB_VAR_VERSION_BOOTLOADER, GetBootloaderVersion},
@@ -61,8 +60,7 @@ bool GetVarHandler(FastbootDevice* device, const std::vector<std::string>& args) 
    }



    std::vector<std::string> getvar_args(args.begin() + 2, args.end());

    auto result = found_variable->second(device, getvar_args);

    return device->WriteStatus(FastbootResult::OKAY, result);

    return found_variable->second(device, getvar_args);

}



bool DownloadHandler(FastbootDevice* device, const std::vector<std::string>& args) {

fastboot/device/fastboot_device.cpp

+8 −0
Original line number Diff line number Diff line
@@ -122,3 +122,11 @@ void FastbootDevice::ExecuteCommands() { 
        }

    }

}



bool FastbootDevice::WriteOkay(const std::string& message) {

    return WriteStatus(FastbootResult::OKAY, message);

}



bool FastbootDevice::WriteFail(const std::string& message) {

    return WriteStatus(FastbootResult::FAIL, message);

}

fastboot/device/fastboot_device.h

+4 −0
Original line number Diff line number Diff line
@@ -39,6 +39,10 @@ class FastbootDevice { 
    bool HandleData(bool read, std::vector<char>* data);

    std::string GetCurrentSlot();



    // Shortcuts for writing OKAY and FAIL status results.

    bool WriteOkay(const std::string& message);

    bool WriteFail(const std::string& message);



    std::vector<char>& get_download_data() { return download_data_; }

    void set_upload_data(const std::vector<char>& data) { upload_data_ = data; }

    void set_upload_data(std::vector<char>&& data) { upload_data_ = std::move(data); }

fastboot/device/variables.cpp

+42 −37
Original line number Diff line number Diff line
@@ -32,91 +32,96 @@ using ::android::hardware::boot::V1_0::Slot; 
constexpr int kMaxDownloadSizeDefault = 0x20000000;

constexpr char kFastbootProtocolVersion[] = "0.4";



std::string GetVersion(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {

    return kFastbootProtocolVersion;

bool GetVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(kFastbootProtocolVersion);

}



std::string GetBootloaderVersion(FastbootDevice* /* device */,

                                 const std::vector<std::string>& /* args */) {

    return android::base::GetProperty("ro.bootloader", "");

bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(android::base::GetProperty("ro.bootloader", ""));

}



std::string GetBasebandVersion(FastbootDevice* /* device */,

                               const std::vector<std::string>& /* args */) {

    return android::base::GetProperty("ro.build.expect.baseband", "");

bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(android::base::GetProperty("ro.build.expect.baseband", ""));

}



std::string GetProduct(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {

    return android::base::GetProperty("ro.product.device", "");

bool GetProduct(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(android::base::GetProperty("ro.product.device", ""));

}



std::string GetSerial(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {

    return android::base::GetProperty("ro.serialno", "");

bool GetSerial(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(android::base::GetProperty("ro.serialno", ""));

}



std::string GetSecure(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {

    return android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no";

bool GetSecure(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no");

}



std::string GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */) {

bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    std::string suffix = device->GetCurrentSlot();

    return suffix.size() == 2 ? suffix.substr(1) : suffix;

    std::string slot = suffix.size() == 2 ? suffix.substr(1) : suffix;

    return device->WriteOkay(slot);

}



std::string GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */) {

bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    auto boot_control_hal = device->boot_control_hal();

    if (!boot_control_hal) {

        return "0";

    }

    return std::to_string(boot_control_hal->getNumberSlots());

    return device->WriteOkay(std::to_string(boot_control_hal->getNumberSlots()));

}



std::string GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args) {

bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args) {

    if (args.empty()) {

        return "no";

        return device->WriteFail("Missing argument");

    }

    Slot slot;

    if (!GetSlotNumber(args[0], &slot)) {

        return "no";

        return device->WriteFail("Invalid slot");

    }

    auto boot_control_hal = device->boot_control_hal();

    if (!boot_control_hal) {

        return "no";

        return device->WriteFail("Device has no slots");

    }

    return boot_control_hal->isSlotMarkedSuccessful(slot) == BoolResult::TRUE ? "yes" : "no";

    if (boot_control_hal->isSlotMarkedSuccessful(slot) != BoolResult::TRUE) {

        return device->WriteOkay("no");

    }

    return device->WriteOkay("yes");

}



std::string GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args) {

bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args) {

    if (args.empty()) {

        return "no";

        return device->WriteFail("Missing argument");

    }

    Slot slot;

    if (!GetSlotNumber(args[0], &slot)) {

        return "no";

        return device->WriteFail("Invalid slot");

    }

    auto boot_control_hal = device->boot_control_hal();

    if (!boot_control_hal) {

        return "no";

        return device->WriteFail("Device has no slots");

    }

    if (boot_control_hal->isSlotBootable(slot) != BoolResult::TRUE) {

        return device->WriteOkay("yes");

    }

    return boot_control_hal->isSlotBootable(slot) == BoolResult::TRUE ? "no" : "yes";

    return device->WriteOkay("no");

}



std::string GetMaxDownloadSize(FastbootDevice* /* device */,

                               const std::vector<std::string>& /* args */) {

    return std::to_string(kMaxDownloadSizeDefault);

bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay(std::to_string(kMaxDownloadSizeDefault));

}



std::string GetUnlocked(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {

    return "yes";

bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& /* args */) {

    return device->WriteOkay("yes");

}



std::string GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args) {

bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args) {

    if (args.empty()) {

        return "no";

        return device->WriteFail("Missing argument");

    }

    std::string slot_suffix = device->GetCurrentSlot();

    if (slot_suffix.empty()) {

        return "no";

        return device->WriteFail("Invalid slot");

    }

    return args[0] == "userdata" ? "no" : "yes";

    std::string result = (args[0] == "userdata" ? "no" : "yes");

    return device->WriteOkay(result);

}

fastboot/device/variables.h

+13 −13
Original line number Diff line number Diff line
@@ -21,16 +21,16 @@ 


class FastbootDevice;



std::string GetVersion(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetProduct(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetSerial(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetSecure(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args);

std::string GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args);
 
bool GetVersion(FastbootDevice* device, const std::vector<std::string>& args);

bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args);

bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args);

bool GetProduct(FastbootDevice* device, const std::vector<std::string>& args);

bool GetSerial(FastbootDevice* device, const std::vector<std::string>& args);

bool GetSecure(FastbootDevice* device, const std::vector<std::string>& args);

bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args);

bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args);

bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args);

bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args);

bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args);

bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args);

bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args);