diff options
Diffstat (limited to 'fastboot/udp_test.cpp')
| -rw-r--r-- | fastboot/udp_test.cpp | 531 |
1 files changed, 531 insertions, 0 deletions
diff --git a/fastboot/udp_test.cpp b/fastboot/udp_test.cpp new file mode 100644 index 000000000..ff8cf0fc8 --- /dev/null +++ b/fastboot/udp_test.cpp @@ -0,0 +1,531 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "udp.h" + +#include <gtest/gtest.h> + +#include "socket.h" +#include "socket_mock.h" + +using namespace udp; +using namespace udp::internal; + +// Some possible corner case sequence numbers we want to check. +static const uint16_t kTestSequenceNumbers[] = {0x0000, 0x0001, 0x00FF, 0x0100, + 0x7FFF, 0x8000, 0xFFFF}; + +// Converts |value| to a binary big-endian string. +static std::string PacketValue(uint16_t value) { + return std::string{static_cast<char>(value >> 8), static_cast<char>(value)}; +} + +// Returns an Error packet. +static std::string ErrorPacket(uint16_t sequence, const std::string& message = "", + char flags = kFlagNone) { + return std::string{kIdError, flags} + PacketValue(sequence) + message; +} + +// Returns a Query packet with no data. +static std::string QueryPacket(uint16_t sequence) { + return std::string{kIdDeviceQuery, kFlagNone} + PacketValue(sequence); +} + +// Returns a Query packet with a 2-byte |new_sequence|. +static std::string QueryPacket(uint16_t sequence, uint16_t new_sequence) { + return std::string{kIdDeviceQuery, kFlagNone} + PacketValue(sequence) + + PacketValue(new_sequence); +} + +// Returns an Init packet with a 2-byte |version| and |max_packet_size|. +static std::string InitPacket(uint16_t sequence, uint16_t version, uint16_t max_packet_size) { + return std::string{kIdInitialization, kFlagNone} + PacketValue(sequence) + + PacketValue(version) + PacketValue(max_packet_size); +} + +// Returns a Fastboot packet with |data|. +static std::string FastbootPacket(uint16_t sequence, const std::string& data = "", + char flags = kFlagNone) { + return std::string{kIdFastboot, flags} + PacketValue(sequence) + data; +} + +// Fixture class to test protocol initialization. Usage is to set up the expected calls to the +// SocketMock object then call UdpConnect() and check the result. +class UdpConnectTest : public ::testing::Test { + public: + UdpConnectTest() : mock_socket_(new SocketMock) {} + + // Run the initialization, return whether it was successful or not. This passes ownership of + // the current |mock_socket_| but allocates a new one for re-use. + bool UdpConnect(std::string* error = nullptr) { + std::string local_error; + if (error == nullptr) { + error = &local_error; + } + std::unique_ptr<Transport> transport(Connect(std::move(mock_socket_), error)); + mock_socket_.reset(new SocketMock); + return transport != nullptr && error->empty(); + } + + protected: + std::unique_ptr<SocketMock> mock_socket_; +}; + +// Tests a successful protocol initialization with various starting sequence numbers. +TEST_F(UdpConnectTest, InitializationSuccess) { + for (uint16_t seq : kTestSequenceNumbers) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, seq)); + mock_socket_->ExpectSend(InitPacket(seq, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(seq, kProtocolVersion, 1024)); + + EXPECT_TRUE(UdpConnect()); + } +} + +// Tests continuation packets during initialization. +TEST_F(UdpConnectTest, InitializationContinuationSuccess) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(std::string{kIdDeviceQuery, kFlagContinuation, 0, 0, 0x44}); + mock_socket_->ExpectSend(std::string{kIdDeviceQuery, kFlagNone, 0, 1}); + mock_socket_->AddReceive(std::string{kIdDeviceQuery, kFlagNone, 0, 1, 0x55}); + + mock_socket_->ExpectSend(InitPacket(0x4455, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(std::string{kIdInitialization, kFlagContinuation, 0x44, 0x55, 0}); + mock_socket_->ExpectSend(std::string{kIdInitialization, kFlagNone, 0x44, 0x56}); + mock_socket_->AddReceive(std::string{kIdInitialization, kFlagContinuation, 0x44, 0x56, 1}); + mock_socket_->ExpectSend(std::string{kIdInitialization, kFlagNone, 0x44, 0x57}); + mock_socket_->AddReceive(std::string{kIdInitialization, kFlagContinuation, 0x44, 0x57, 2}); + mock_socket_->ExpectSend(std::string{kIdInitialization, kFlagNone, 0x44, 0x58}); + mock_socket_->AddReceive(std::string{kIdInitialization, kFlagNone, 0x44, 0x58, 0}); + + EXPECT_TRUE(UdpConnect()); +} + + +// Tests a mismatched version number; as long as the minimum of the two versions is supported +// we should allow the connection. +TEST_F(UdpConnectTest, InitializationVersionMismatch) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, 2, 1024)); + + EXPECT_TRUE(UdpConnect()); + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, 0, 1024)); + + EXPECT_FALSE(UdpConnect()); +} + +TEST_F(UdpConnectTest, QueryResponseTimeoutFailure) { + for (int i = 0; i < kMaxConnectAttempts; ++i) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceiveTimeout(); + } + + EXPECT_FALSE(UdpConnect()); +} + +TEST_F(UdpConnectTest, QueryResponseReceiveFailure) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceiveFailure(); + + EXPECT_FALSE(UdpConnect()); +} + +TEST_F(UdpConnectTest, InitResponseTimeoutFailure) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + for (int i = 0; i < kMaxTransmissionAttempts; ++i) { + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceiveTimeout(); + } + + EXPECT_FALSE(UdpConnect()); +} + +TEST_F(UdpConnectTest, InitResponseReceiveFailure) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceiveFailure(); + + EXPECT_FALSE(UdpConnect()); +} + +// Tests that we can recover up to the maximum number of allowed retries. +TEST_F(UdpConnectTest, ResponseRecovery) { + // The device query packet can recover from up to (kMaxConnectAttempts - 1) timeouts. + for (int i = 0; i < kMaxConnectAttempts - 1; ++i) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceiveTimeout(); + } + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + + // Subsequent packets try up to (kMaxTransmissionAttempts - 1) times. + for (int i = 0; i < kMaxTransmissionAttempts - 1; ++i) { + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceiveTimeout(); + } + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, kProtocolVersion, 1024)); + + EXPECT_TRUE(UdpConnect()); +} + +// Tests that the host can handle receiving additional bytes for forward compatibility. +TEST_F(UdpConnectTest, ExtraResponseDataSuccess) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0) + "foo"); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, kProtocolVersion, 1024) + "bar"); + + EXPECT_TRUE(UdpConnect()); +} + +// Tests mismatched response sequence numbers. A wrong sequence number is interpreted as a previous +// retransmission and just ignored so we should be able to recover. +TEST_F(UdpConnectTest, WrongSequenceRecovery) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(1, 0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(1, kProtocolVersion, 1024)); + mock_socket_->AddReceive(InitPacket(0, kProtocolVersion, 1024)); + + EXPECT_TRUE(UdpConnect()); +} + +// Tests mismatched response IDs. This should also be interpreted as a retransmission and ignored. +TEST_F(UdpConnectTest, WrongIdRecovery) { + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(FastbootPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(FastbootPacket(0)); + mock_socket_->AddReceive(InitPacket(0, kProtocolVersion, 1024)); + + EXPECT_TRUE(UdpConnect()); +} + +// Tests an invalid query response. Query responses must have at least 2 bytes of data. +TEST_F(UdpConnectTest, InvalidQueryResponseFailure) { + std::string error; + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0)); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_EQ("invalid query response from target", error); + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0) + std::string{0x00}); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_EQ("invalid query response from target", error); +} + +// Tests an invalid initialization response. Max packet size must be at least 512 bytes. +TEST_F(UdpConnectTest, InvalidInitResponseFailure) { + std::string error; + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, kProtocolVersion, 511)); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_EQ("target reported invalid packet size 511", error); + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(InitPacket(0, 0, 1024)); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_EQ("target reported invalid protocol version 0", error); +} + +TEST_F(UdpConnectTest, ErrorResponseFailure) { + std::string error; + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(ErrorPacket(0, "error1")); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_NE(std::string::npos, error.find("error1")); + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, 0)); + mock_socket_->ExpectSend(InitPacket(0, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive(ErrorPacket(0, "error2")); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_NE(std::string::npos, error.find("error2")); +} + +// Tests an error response with continuation flag. +TEST_F(UdpConnectTest, ErrorContinuationFailure) { + std::string error; + + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(ErrorPacket(0, "error1", kFlagContinuation)); + mock_socket_->ExpectSend(ErrorPacket(1)); + mock_socket_->AddReceive(ErrorPacket(1, " ", kFlagContinuation)); + mock_socket_->ExpectSend(ErrorPacket(2)); + mock_socket_->AddReceive(ErrorPacket(2, "error2")); + + EXPECT_FALSE(UdpConnect(&error)); + EXPECT_NE(std::string::npos, error.find("error1 error2")); +} + +// Fixture class to test UDP Transport read/write functionality. +class UdpTest : public ::testing::Test { + public: + void SetUp() override { + // Create |transport_| starting at sequence 0 with 512 byte max packet size. Tests can call + // InitializeTransport() again to change settings. + ASSERT_TRUE(InitializeTransport(0, 512)); + } + + // Sets up |mock_socket_| to correctly initialize the protocol and creates |transport_|. This + // can be called multiple times in a test if needed. + bool InitializeTransport(uint16_t starting_sequence, int device_max_packet_size = 512) { + mock_socket_ = new SocketMock; + mock_socket_->ExpectSend(QueryPacket(0)); + mock_socket_->AddReceive(QueryPacket(0, starting_sequence)); + mock_socket_->ExpectSend( + InitPacket(starting_sequence, kProtocolVersion, kHostMaxPacketSize)); + mock_socket_->AddReceive( + InitPacket(starting_sequence, kProtocolVersion, device_max_packet_size)); + + std::string error; + transport_ = Connect(std::unique_ptr<Socket>(mock_socket_), &error); + return transport_ != nullptr && error.empty(); + } + + // Writes |message| to |transport_|, returns true on success. + bool Write(const std::string& message) { + return transport_->Write(message.data(), message.length()) == + static_cast<ssize_t>(message.length()); + } + + // Reads from |transport_|, returns true if it matches |message|. + bool Read(const std::string& message) { + std::string buffer(message.length(), '\0'); + return transport_->Read(&buffer[0], buffer.length()) == + static_cast<ssize_t>(message.length()) && buffer == message; + } + + protected: + // |mock_socket_| is a raw pointer here because we transfer ownership to |transport_| but we + // need to retain a pointer to set send and receive expectations. + SocketMock* mock_socket_ = nullptr; + std::unique_ptr<Transport> transport_; +}; + +// Tests sequence behavior with various starting sequence numbers. +TEST_F(UdpTest, SequenceIncrementCheck) { + for (uint16_t seq : kTestSequenceNumbers) { + ASSERT_TRUE(InitializeTransport(seq)); + + for (int i = 0; i < 10; ++i) { + mock_socket_->ExpectSend(FastbootPacket(++seq, "foo")); + mock_socket_->AddReceive(FastbootPacket(seq, "")); + mock_socket_->ExpectSend(FastbootPacket(++seq, "")); + mock_socket_->AddReceive(FastbootPacket(seq, "bar")); + + EXPECT_TRUE(Write("foo")); + EXPECT_TRUE(Read("bar")); + } + } +} + +// Tests sending and receiving a few small packets. +TEST_F(UdpTest, ReadAndWriteSmallPackets) { + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceive(FastbootPacket(1, "")); + mock_socket_->ExpectSend(FastbootPacket(2, "")); + mock_socket_->AddReceive(FastbootPacket(2, "bar")); + + EXPECT_TRUE(Write("foo")); + EXPECT_TRUE(Read("bar")); + + mock_socket_->ExpectSend(FastbootPacket(3, "12345 67890")); + mock_socket_->AddReceive(FastbootPacket(3)); + mock_socket_->ExpectSend(FastbootPacket(4, "\x01\x02\x03\x04\x05")); + mock_socket_->AddReceive(FastbootPacket(4)); + + EXPECT_TRUE(Write("12345 67890")); + EXPECT_TRUE(Write("\x01\x02\x03\x04\x05")); + + // Reads are done by sending empty packets. + mock_socket_->ExpectSend(FastbootPacket(5)); + mock_socket_->AddReceive(FastbootPacket(5, "foo bar baz")); + mock_socket_->ExpectSend(FastbootPacket(6)); + mock_socket_->AddReceive(FastbootPacket(6, "\x01\x02\x03\x04\x05")); + + EXPECT_TRUE(Read("foo bar baz")); + EXPECT_TRUE(Read("\x01\x02\x03\x04\x05")); +} + +TEST_F(UdpTest, ResponseTimeoutFailure) { + for (int i = 0; i < kMaxTransmissionAttempts; ++i) { + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceiveTimeout(); + } + + EXPECT_FALSE(Write("foo")); +} + +TEST_F(UdpTest, ResponseReceiveFailure) { + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceiveFailure(); + + EXPECT_FALSE(Write("foo")); +} + +TEST_F(UdpTest, ResponseTimeoutRecovery) { + for (int i = 0; i < kMaxTransmissionAttempts - 1; ++i) { + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceiveTimeout(); + } + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceive(FastbootPacket(1, "")); + + EXPECT_TRUE(Write("foo")); +} + +// Tests continuation packets for various max packet sizes. +// The important part of this test is that regardless of what kind of packet fragmentation happens +// at the socket layer, a single call to Transport::Read() and Transport::Write() is all the +// fastboot code needs to do. +TEST_F(UdpTest, ContinuationPackets) { + for (uint16_t max_packet_size : {512, 1024, 1200}) { + ASSERT_TRUE(InitializeTransport(0, max_packet_size)); + + // Initialize the data we want to send. Use (size - 4) to leave room for the header. + size_t max_data_size = max_packet_size - 4; + std::string data(max_data_size * 3, '\0'); + for (size_t i = 0; i < data.length(); ++i) { + data[i] = i; + } + std::string chunks[] = {data.substr(0, max_data_size), + data.substr(max_data_size, max_data_size), + data.substr(max_data_size * 2, max_data_size)}; + + // Write data: split into 3 UDP packets, each of which will be ACKed. + mock_socket_->ExpectSend(FastbootPacket(1, chunks[0], kFlagContinuation)); + mock_socket_->AddReceive(FastbootPacket(1)); + mock_socket_->ExpectSend(FastbootPacket(2, chunks[1], kFlagContinuation)); + mock_socket_->AddReceive(FastbootPacket(2)); + mock_socket_->ExpectSend(FastbootPacket(3, chunks[2])); + mock_socket_->AddReceive(FastbootPacket(3)); + EXPECT_TRUE(Write(data)); + + // Same thing for reading the data. + mock_socket_->ExpectSend(FastbootPacket(4)); + mock_socket_->AddReceive(FastbootPacket(4, chunks[0], kFlagContinuation)); + mock_socket_->ExpectSend(FastbootPacket(5)); + mock_socket_->AddReceive(FastbootPacket(5, chunks[1], kFlagContinuation)); + mock_socket_->ExpectSend(FastbootPacket(6)); + mock_socket_->AddReceive(FastbootPacket(6, chunks[2])); + EXPECT_TRUE(Read(data)); + } +} + +// Tests that the continuation bit is respected even if the packet isn't max size. +TEST_F(UdpTest, SmallContinuationPackets) { + mock_socket_->ExpectSend(FastbootPacket(1)); + mock_socket_->AddReceive(FastbootPacket(1, "foo", kFlagContinuation)); + mock_socket_->ExpectSend(FastbootPacket(2)); + mock_socket_->AddReceive(FastbootPacket(2, "bar")); + + EXPECT_TRUE(Read("foobar")); +} + +// Tests receiving an error packet mid-continuation. +TEST_F(UdpTest, ContinuationPacketError) { + mock_socket_->ExpectSend(FastbootPacket(1)); + mock_socket_->AddReceive(FastbootPacket(1, "foo", kFlagContinuation)); + mock_socket_->ExpectSend(FastbootPacket(2)); + mock_socket_->AddReceive(ErrorPacket(2, "test error")); + + EXPECT_FALSE(Read("foo")); +} + +// Tests timeout during a continuation sequence. +TEST_F(UdpTest, ContinuationTimeoutRecovery) { + mock_socket_->ExpectSend(FastbootPacket(1)); + mock_socket_->AddReceive(FastbootPacket(1, "foo", kFlagContinuation)); + mock_socket_->ExpectSend(FastbootPacket(2)); + mock_socket_->AddReceiveTimeout(); + mock_socket_->ExpectSend(FastbootPacket(2)); + mock_socket_->AddReceive(FastbootPacket(2, "bar")); + + EXPECT_TRUE(Read("foobar")); +} + +// Tests read overflow returns -1 to indicate the failure. +TEST_F(UdpTest, MultipleReadPacket) { + mock_socket_->ExpectSend(FastbootPacket(1)); + mock_socket_->AddReceive(FastbootPacket(1, "foobarbaz")); + + char buffer[3]; + EXPECT_EQ(-1, transport_->Read(buffer, 3)); +} + +// Tests that packets arriving out-of-order are ignored. +TEST_F(UdpTest, IgnoreOutOfOrderPackets) { + mock_socket_->ExpectSend(FastbootPacket(1)); + mock_socket_->AddReceive(FastbootPacket(0, "sequence too low")); + mock_socket_->AddReceive(FastbootPacket(2, "sequence too high")); + mock_socket_->AddReceive(QueryPacket(1)); + mock_socket_->AddReceive(FastbootPacket(1, "correct")); + + EXPECT_TRUE(Read("correct")); +} + +// Tests that an error response with the correct sequence number causes immediate failure. +TEST_F(UdpTest, ErrorResponse) { + // Error packets with the wrong sequence number should be ignored like any other packet. + mock_socket_->ExpectSend(FastbootPacket(1, "foo")); + mock_socket_->AddReceive(ErrorPacket(0, "ignored error")); + mock_socket_->AddReceive(FastbootPacket(1)); + + EXPECT_TRUE(Write("foo")); + + // Error packets with the correct sequence should abort immediately without retransmission. + mock_socket_->ExpectSend(FastbootPacket(2, "foo")); + mock_socket_->AddReceive(ErrorPacket(2, "test error")); + + EXPECT_FALSE(Write("foo")); +} + +// Tests that attempting to use a closed transport returns -1 without making any socket calls. +TEST_F(UdpTest, CloseTransport) { + char buffer[32]; + EXPECT_EQ(0, transport_->Close()); + EXPECT_EQ(-1, transport_->Write("foo", 3)); + EXPECT_EQ(-1, transport_->Read(buffer, sizeof(buffer))); +} |