Merge "fastbootd: Allow returning errors from getvar handlers." (e60694d6) · Commits · e / os / android_system_core

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