1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include "tcp.h"
30
31 #include <gtest/gtest.h>
32
33 #include "socket_mock.h"
34
TEST(TcpConnectTest,TestSuccess)35 TEST(TcpConnectTest, TestSuccess) {
36 std::unique_ptr<SocketMock> mock(new SocketMock);
37 mock->ExpectSend("FB01");
38 mock->AddReceive("FB01");
39
40 std::string error;
41 EXPECT_NE(nullptr, tcp::internal::Connect(std::move(mock), &error));
42 EXPECT_EQ("", error);
43 }
44
TEST(TcpConnectTest,TestNewerVersionSuccess)45 TEST(TcpConnectTest, TestNewerVersionSuccess) {
46 std::unique_ptr<SocketMock> mock(new SocketMock);
47 mock->ExpectSend("FB01");
48 mock->AddReceive("FB99");
49
50 std::string error;
51 EXPECT_NE(nullptr, tcp::internal::Connect(std::move(mock), &error));
52 EXPECT_EQ("", error);
53 }
54
TEST(TcpConnectTest,TestSendFailure)55 TEST(TcpConnectTest, TestSendFailure) {
56 std::unique_ptr<SocketMock> mock(new SocketMock);
57 mock->ExpectSendFailure("FB01");
58
59 std::string error;
60 EXPECT_EQ(nullptr, tcp::internal::Connect(std::move(mock), &error));
61 EXPECT_NE(std::string::npos, error.find("Failed to send initialization message"));
62 }
63
TEST(TcpConnectTest,TestNoResponseFailure)64 TEST(TcpConnectTest, TestNoResponseFailure) {
65 std::unique_ptr<SocketMock> mock(new SocketMock);
66 mock->ExpectSend("FB01");
67 mock->AddReceiveFailure();
68
69 std::string error;
70 EXPECT_EQ(nullptr, tcp::internal::Connect(std::move(mock), &error));
71 EXPECT_NE(std::string::npos, error.find("No initialization message received"));
72 }
73
TEST(TcpConnectTest,TestBadResponseFailure)74 TEST(TcpConnectTest, TestBadResponseFailure) {
75 std::unique_ptr<SocketMock> mock(new SocketMock);
76 mock->ExpectSend("FB01");
77 mock->AddReceive("XX01");
78
79 std::string error;
80 EXPECT_EQ(nullptr, tcp::internal::Connect(std::move(mock), &error));
81 EXPECT_NE(std::string::npos, error.find("Unrecognized initialization message"));
82 }
83
TEST(TcpConnectTest,TestUnknownVersionFailure)84 TEST(TcpConnectTest, TestUnknownVersionFailure) {
85 std::unique_ptr<SocketMock> mock(new SocketMock);
86 mock->ExpectSend("FB01");
87 mock->AddReceive("FB00");
88
89 std::string error;
90 EXPECT_EQ(nullptr, tcp::internal::Connect(std::move(mock), &error));
91 EXPECT_EQ("Unknown TCP protocol version 00 (host version 01)", error);
92 }
93
94 // Fixture to configure a SocketMock for a successful TCP connection.
95 class TcpTest : public ::testing::Test {
96 protected:
SetUp()97 void SetUp() override {
98 mock_ = new SocketMock;
99 mock_->ExpectSend("FB01");
100 mock_->AddReceive("FB01");
101
102 std::string error;
103 transport_ = tcp::internal::Connect(std::unique_ptr<Socket>(mock_), &error);
104 ASSERT_NE(nullptr, transport_);
105 ASSERT_EQ("", error);
106 };
107
108 // Writes |message| to |transport_|, returns true on success.
Write(const std::string & message)109 bool Write(const std::string& message) {
110 return transport_->Write(message.data(), message.length()) ==
111 static_cast<ssize_t>(message.length());
112 }
113
114 // Reads from |transport_|, returns true if it matches |message|.
Read(const std::string & message)115 bool Read(const std::string& message) {
116 std::string buffer(message.length(), '\0');
117 return transport_->Read(&buffer[0], buffer.length()) ==
118 static_cast<ssize_t>(message.length()) &&
119 buffer == message;
120 }
121
122 // Use a raw SocketMock* here because we pass ownership to the Transport object, but we still
123 // need access to configure mock expectations.
124 SocketMock* mock_ = nullptr;
125 std::unique_ptr<Transport> transport_;
126 };
127
TEST_F(TcpTest,TestWriteSuccess)128 TEST_F(TcpTest, TestWriteSuccess) {
129 mock_->ExpectSend(std::string{0, 0, 0, 0, 0, 0, 0, 3} + "foo");
130
131 EXPECT_TRUE(Write("foo"));
132 }
133
TEST_F(TcpTest,TestReadSuccess)134 TEST_F(TcpTest, TestReadSuccess) {
135 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 3});
136 mock_->AddReceive("foo");
137
138 EXPECT_TRUE(Read("foo"));
139 }
140
141 // Tests that fragmented TCP reads are handled properly.
TEST_F(TcpTest,TestReadFragmentSuccess)142 TEST_F(TcpTest, TestReadFragmentSuccess) {
143 mock_->AddReceive(std::string{0, 0, 0, 0});
144 mock_->AddReceive(std::string{0, 0, 0, 3});
145 mock_->AddReceive("f");
146 mock_->AddReceive("o");
147 mock_->AddReceive("o");
148
149 EXPECT_TRUE(Read("foo"));
150 }
151
TEST_F(TcpTest,TestLargeWriteSuccess)152 TEST_F(TcpTest, TestLargeWriteSuccess) {
153 // 0x100000 = 1MiB.
154 std::string data(0x100000, '\0');
155 for (size_t i = 0; i < data.length(); ++i) {
156 data[i] = i;
157 }
158 mock_->ExpectSend(std::string{0, 0, 0, 0, 0, 0x10, 0, 0} + data);
159
160 EXPECT_TRUE(Write(data));
161 }
162
TEST_F(TcpTest,TestLargeReadSuccess)163 TEST_F(TcpTest, TestLargeReadSuccess) {
164 // 0x100000 = 1MiB.
165 std::string data(0x100000, '\0');
166 for (size_t i = 0; i < data.length(); ++i) {
167 data[i] = i;
168 }
169 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0x10, 0, 0});
170 mock_->AddReceive(data);
171
172 EXPECT_TRUE(Read(data));
173 }
174
175 // Tests a few sample fastboot protocol commands.
TEST_F(TcpTest,TestFastbootProtocolSuccess)176 TEST_F(TcpTest, TestFastbootProtocolSuccess) {
177 mock_->ExpectSend(std::string{0, 0, 0, 0, 0, 0, 0, 14} + "getvar:version");
178 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 7});
179 mock_->AddReceive("OKAY0.4");
180
181 mock_->ExpectSend(std::string{0, 0, 0, 0, 0, 0, 0, 10} + "getvar:all");
182 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 16});
183 mock_->AddReceive("INFOversion: 0.4");
184 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 12});
185 mock_->AddReceive("INFOfoo: bar");
186 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 4});
187 mock_->AddReceive("OKAY");
188
189 EXPECT_TRUE(Write("getvar:version"));
190 EXPECT_TRUE(Read("OKAY0.4"));
191
192 EXPECT_TRUE(Write("getvar:all"));
193 EXPECT_TRUE(Read("INFOversion: 0.4"));
194 EXPECT_TRUE(Read("INFOfoo: bar"));
195 EXPECT_TRUE(Read("OKAY"));
196 }
197
TEST_F(TcpTest,TestReadLengthFailure)198 TEST_F(TcpTest, TestReadLengthFailure) {
199 mock_->AddReceiveFailure();
200
201 char buffer[16];
202 EXPECT_EQ(-1, transport_->Read(buffer, sizeof(buffer)));
203 }
204
TEST_F(TcpTest,TestReadDataFailure)205 TEST_F(TcpTest, TestReadDataFailure) {
206 mock_->AddReceive(std::string{0, 0, 0, 0, 0, 0, 0, 3});
207 mock_->AddReceiveFailure();
208
209 char buffer[16];
210 EXPECT_EQ(-1, transport_->Read(buffer, sizeof(buffer)));
211 }
212
TEST_F(TcpTest,TestWriteFailure)213 TEST_F(TcpTest, TestWriteFailure) {
214 mock_->ExpectSendFailure(std::string{0, 0, 0, 0, 0, 0, 0, 3} + "foo");
215
216 EXPECT_EQ(-1, transport_->Write("foo", 3));
217 }
218
TEST_F(TcpTest,TestTransportClose)219 TEST_F(TcpTest, TestTransportClose) {
220 EXPECT_EQ(0, transport_->Close());
221
222 // After closing, Transport Read()/Write() should return -1 without actually attempting any
223 // network operations.
224 char buffer[16];
225 EXPECT_EQ(-1, transport_->Read(buffer, sizeof(buffer)));
226 EXPECT_EQ(-1, transport_->Write("foo", 3));
227 }
228