diff options
| -rw-r--r-- | tests/component/updater_test.cpp | 22 | ||||
| -rw-r--r-- | tests/unit/commands_test.cpp | 56 | ||||
| -rw-r--r-- | updater/commands.cpp | 51 | ||||
| -rw-r--r-- | updater/include/private/commands.h | 67 |
4 files changed, 186 insertions, 10 deletions
diff --git a/tests/component/updater_test.cpp b/tests/component/updater_test.cpp index 248b469b0..2ed797e62 100644 --- a/tests/component/updater_test.cpp +++ b/tests/component/updater_test.cpp @@ -56,8 +56,6 @@ using namespace std::string_literals; using PackageEntries = std::unordered_map<std::string, std::string>; -static constexpr size_t kTransferListHeaderLines = 4; - struct selabel_handle* sehandle = nullptr; static void expect(const char* expected, const std::string& expr_str, CauseCode cause_code, @@ -846,7 +844,8 @@ TEST_F(UpdaterTest, last_command_update) { }; // "2\nstash " + block3_hash + " 2,2,3" - std::string last_command_content = "2\n" + transfer_list_fail[kTransferListHeaderLines + 2]; + std::string last_command_content = + "2\n" + transfer_list_fail[TransferList::kTransferListHeaderLines + 2]; RunBlockImageUpdate(false, entries, image_file_, ""); @@ -895,7 +894,8 @@ TEST_F(UpdaterTest, last_command_update_unresumable) { ASSERT_TRUE(android::base::WriteStringToFile(block1 + block1, image_file_)); - std::string last_command_content = "0\n" + transfer_list_unresumable[kTransferListHeaderLines]; + std::string last_command_content = + "0\n" + transfer_list_unresumable[TransferList::kTransferListHeaderLines]; ASSERT_TRUE(android::base::WriteStringToFile(last_command_content, last_command_file_)); RunBlockImageUpdate(false, entries, image_file_, ""); @@ -934,7 +934,8 @@ TEST_F(UpdaterTest, last_command_verify) { ASSERT_TRUE(android::base::WriteStringToFile(block1 + block1 + block3, image_file_)); // Last command: "move " + block1_hash + " 2,1,2 1 2,0,1" - std::string last_command_content = "2\n" + transfer_list_verify[kTransferListHeaderLines + 2]; + std::string last_command_content = + "2\n" + transfer_list_verify[TransferList::kTransferListHeaderLines + 2]; // First run: expect the verification to succeed and the last_command_file is intact. ASSERT_TRUE(android::base::WriteStringToFile(last_command_content, last_command_file_)); @@ -1129,16 +1130,17 @@ static const std::vector<std::string> g_transfer_list = GenerateTransferList(); INSTANTIATE_TEST_CASE_P(InterruptAfterEachCommand, ResumableUpdaterTest, ::testing::Range(static_cast<size_t>(0), - g_transfer_list.size() - kTransferListHeaderLines)); + g_transfer_list.size() - + TransferList::kTransferListHeaderLines)); TEST_P(ResumableUpdaterTest, InterruptVerifyResume) { ASSERT_TRUE(android::base::WriteStringToFile(g_source_image, image_file_)); LOG(INFO) << "Interrupting at line " << index_ << " (" - << g_transfer_list[kTransferListHeaderLines + index_] << ")"; + << g_transfer_list[TransferList::kTransferListHeaderLines + index_] << ")"; std::vector<std::string> transfer_list_copy{ g_transfer_list }; - transfer_list_copy[kTransferListHeaderLines + index_] = "abort"; + transfer_list_copy[TransferList::kTransferListHeaderLines + index_] = "abort"; g_entries["transfer_list"] = android::base::Join(transfer_list_copy, '\n'); @@ -1151,8 +1153,8 @@ TEST_P(ResumableUpdaterTest, InterruptVerifyResume) { if (index_ == 0) { ASSERT_EQ(-1, access(last_command_file_.c_str(), R_OK)); } else { - last_command_expected = - std::to_string(index_ - 1) + "\n" + g_transfer_list[kTransferListHeaderLines + index_ - 1]; + last_command_expected = std::to_string(index_ - 1) + "\n" + + g_transfer_list[TransferList::kTransferListHeaderLines + index_ - 1]; std::string last_command_actual; ASSERT_TRUE(android::base::ReadFileToString(last_command_file_, &last_command_actual)); ASSERT_EQ(last_command_expected, last_command_actual); diff --git a/tests/unit/commands_test.cpp b/tests/unit/commands_test.cpp index 5c69e07b5..8a54df703 100644 --- a/tests/unit/commands_test.cpp +++ b/tests/unit/commands_test.cpp @@ -17,6 +17,7 @@ #include <algorithm> #include <string> +#include <android-base/strings.h> #include <gtest/gtest.h> #include <openssl/sha.h> @@ -496,3 +497,58 @@ TEST(SourceInfoTest, ReadAll_FailingReader) { auto failing_stash_reader = [](const std::string&, std::vector<uint8_t>*) -> int { return -1; }; ASSERT_FALSE(source.ReadAll(&buffer, kBlockSize, block_reader, failing_stash_reader)); } + +TEST(TransferListTest, Parse) { + std::vector<std::string> input_lines{ + "4", // version + "2", // total blocks + "1", // max stashed entries + "1", // max stashed blocks + "stash 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1", + "move 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1 1 2,0,1", + }; + + std::string err; + TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err); + ASSERT_TRUE(static_cast<bool>(transfer_list)); + ASSERT_EQ(4, transfer_list.version()); + ASSERT_EQ(2, transfer_list.total_blocks()); + ASSERT_EQ(1, transfer_list.stash_max_entries()); + ASSERT_EQ(1, transfer_list.stash_max_blocks()); + ASSERT_EQ(2U, transfer_list.commands().size()); + ASSERT_EQ(Command::Type::STASH, transfer_list.commands()[0].type()); + ASSERT_EQ(Command::Type::MOVE, transfer_list.commands()[1].type()); +} + +TEST(TransferListTest, Parse_InvalidCommand) { + std::vector<std::string> input_lines{ + "4", // version + "2", // total blocks + "1", // max stashed entries + "1", // max stashed blocks + "stash 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1", + "move 1d74d1a60332fd38cf9405f1bae67917888da6cb 2,0,1 1", + }; + + std::string err; + TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err); + ASSERT_FALSE(static_cast<bool>(transfer_list)); +} + +TEST(TransferListTest, Parse_ZeroTotalBlocks) { + std::vector<std::string> input_lines{ + "4", // version + "0", // total blocks + "0", // max stashed entries + "0", // max stashed blocks + }; + + std::string err; + TransferList transfer_list = TransferList::Parse(android::base::Join(input_lines, '\n'), &err); + ASSERT_TRUE(static_cast<bool>(transfer_list)); + ASSERT_EQ(4, transfer_list.version()); + ASSERT_EQ(0, transfer_list.total_blocks()); + ASSERT_EQ(0, transfer_list.stash_max_entries()); + ASSERT_EQ(0, transfer_list.stash_max_blocks()); + ASSERT_TRUE(transfer_list.commands().empty()); +} diff --git a/updater/commands.cpp b/updater/commands.cpp index 017086323..aed63369c 100644 --- a/updater/commands.cpp +++ b/updater/commands.cpp @@ -401,3 +401,54 @@ std::ostream& operator<<(std::ostream& os, const SourceInfo& source) { } return os; } + +TransferList TransferList::Parse(const std::string& transfer_list_str, std::string* err) { + TransferList result{}; + + std::vector<std::string> lines = android::base::Split(transfer_list_str, "\n"); + if (lines.size() < kTransferListHeaderLines) { + *err = android::base::StringPrintf("too few lines in the transfer list [%zu]", lines.size()); + return TransferList{}; + } + + // First line in transfer list is the version number. + if (!android::base::ParseInt(lines[0], &result.version_, 3, 4)) { + *err = "unexpected transfer list version ["s + lines[0] + "]"; + return TransferList{}; + } + + // Second line in transfer list is the total number of blocks we expect to write. + if (!android::base::ParseUint(lines[1], &result.total_blocks_)) { + *err = "unexpected block count ["s + lines[1] + "]"; + return TransferList{}; + } + + // Third line is how many stash entries are needed simultaneously. + if (!android::base::ParseUint(lines[2], &result.stash_max_entries_)) { + return TransferList{}; + } + + // Fourth line is the maximum number of blocks that will be stashed simultaneously. + if (!android::base::ParseUint(lines[3], &result.stash_max_blocks_)) { + *err = "unexpected maximum stash blocks ["s + lines[3] + "]"; + return TransferList{}; + } + + // Subsequent lines are all individual transfer commands. + for (size_t i = kTransferListHeaderLines; i < lines.size(); i++) { + const std::string& line = lines[i]; + if (line.empty()) continue; + + size_t cmdindex = i - kTransferListHeaderLines; + std::string parsing_error; + Command command = Command::Parse(line, cmdindex, &parsing_error); + if (!command) { + *err = android::base::StringPrintf("Failed to parse command %zu [%s]: %s", cmdindex, + line.c_str(), parsing_error.c_str()); + return TransferList{}; + } + result.commands_.push_back(command); + } + + return result; +} diff --git a/updater/include/private/commands.h b/updater/include/private/commands.h index 521289780..79f915434 100644 --- a/updater/include/private/commands.h +++ b/updater/include/private/commands.h @@ -406,3 +406,70 @@ class Command { }; std::ostream& operator<<(std::ostream& os, const Command& command); + +// TransferList represents the info for a transfer list, which is parsed from input text lines +// containing commands to transfer data from one place to another on the target partition. +// +// The creator of the transfer list will guarantee that no block is read (i.e., used as the source +// for a patch or move) after it has been written. +// +// The creator will guarantee that a given stash is loaded (with a stash command) before it's used +// in a move/bsdiff/imgdiff command. +// +// Within one command the source and target ranges may overlap so in general we need to read the +// entire source into memory before writing anything to the target blocks. +// +// All the patch data is concatenated into one patch_data file in the update package. It must be +// stored uncompressed because we memory-map it in directly from the archive. (Since patches are +// already compressed, we lose very little by not compressing their concatenation.) +// +// Commands that read data from the partition (i.e. move/bsdiff/imgdiff/stash) have one or more +// additional hashes before the range parameters, which are used to check if the command has +// already been completed and verify the integrity of the source data. +class TransferList { + public: + // Number of header lines. + static constexpr size_t kTransferListHeaderLines = 4; + + TransferList() = default; + + // Parses the given input string and returns a TransferList object. Sets error message if any. + static TransferList Parse(const std::string& transfer_list_str, std::string* err); + + int version() const { + return version_; + } + + size_t total_blocks() const { + return total_blocks_; + } + + size_t stash_max_entries() const { + return stash_max_entries_; + } + + size_t stash_max_blocks() const { + return stash_max_blocks_; + } + + const std::vector<Command>& commands() const { + return commands_; + } + + // Returns whether the TransferList is valid. + constexpr explicit operator bool() const { + return version_ != 0; + } + + private: + // BBOTA version. + int version_{ 0 }; + // Total number of blocks to be written in this transfer. + size_t total_blocks_; + // Maximum number of stashes that exist at the same time. + size_t stash_max_entries_; + // Maximum number of blocks to be stashed. + size_t stash_max_blocks_; + // Commands in this transfer. + std::vector<Command> commands_; +}; |