1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "fdevent.h" 18 19 #include <gtest/gtest.h> 20 21 #include <array> 22 #include <limits> 23 #include <queue> 24 #include <string> 25 #include <thread> 26 #include <vector> 27 28 #include <unistd.h> 29 30 #include "adb.h" 31 #include "adb_io.h" 32 #include "fdevent_test.h" 33 #include "socket.h" 34 #include "sysdeps.h" 35 #include "sysdeps/chrono.h" 36 37 struct ThreadArg { 38 int first_read_fd; 39 int last_write_fd; 40 size_t middle_pipe_count; 41 }; 42 43 class LocalSocketTest : public FdeventTest {}; 44 45 constexpr auto SLEEP_FOR_FDEVENT = 100ms; 46 47 TEST_F(LocalSocketTest, smoke) { 48 // Join two socketpairs with a chain of intermediate socketpairs. 49 int first[2]; 50 std::vector<std::array<int, 2>> intermediates; 51 int last[2]; 52 53 constexpr size_t INTERMEDIATE_COUNT = 50; 54 constexpr size_t MESSAGE_LOOP_COUNT = 100; 55 const std::string MESSAGE = "socket_test"; 56 57 intermediates.resize(INTERMEDIATE_COUNT); 58 ASSERT_EQ(0, adb_socketpair(first)) << strerror(errno); 59 ASSERT_EQ(0, adb_socketpair(last)) << strerror(errno); 60 asocket* prev_tail = create_local_socket(first[1]); 61 ASSERT_NE(nullptr, prev_tail); 62 63 auto connect = [](asocket* tail, asocket* head) { 64 tail->peer = head; 65 head->peer = tail; 66 tail->ready(tail); 67 }; 68 69 for (auto& intermediate : intermediates) { 70 ASSERT_EQ(0, adb_socketpair(intermediate.data())) << strerror(errno); 71 72 asocket* head = create_local_socket(intermediate[0]); 73 ASSERT_NE(nullptr, head); 74 75 asocket* tail = create_local_socket(intermediate[1]); 76 ASSERT_NE(nullptr, tail); 77 78 connect(prev_tail, head); 79 prev_tail = tail; 80 } 81 82 asocket* end = create_local_socket(last[0]); 83 ASSERT_NE(nullptr, end); 84 connect(prev_tail, end); 85 86 PrepareThread(); 87 std::thread thread(fdevent_loop); 88 89 for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { 90 std::string read_buffer = MESSAGE; 91 std::string write_buffer(MESSAGE.size(), 'a'); 92 ASSERT_TRUE(WriteFdExactly(first[0], &read_buffer[0], read_buffer.size())); 93 ASSERT_TRUE(ReadFdExactly(last[1], &write_buffer[0], write_buffer.size())); 94 ASSERT_EQ(read_buffer, write_buffer); 95 } 96 97 ASSERT_EQ(0, adb_close(first[0])); 98 ASSERT_EQ(0, adb_close(last[1])); 99 100 // Wait until the local sockets are closed. 101 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 102 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 103 TerminateThread(thread); 104 } 105 106 struct CloseWithPacketArg { 107 int socket_fd; 108 size_t bytes_written; 109 int cause_close_fd; 110 }; 111 112 static void CloseWithPacketThreadFunc(CloseWithPacketArg* arg) { 113 asocket* s = create_local_socket(arg->socket_fd); 114 ASSERT_TRUE(s != nullptr); 115 arg->bytes_written = 0; 116 117 std::string data; 118 data.resize(MAX_PAYLOAD); 119 arg->bytes_written += data.size(); 120 int ret = s->enqueue(s, std::move(data)); 121 ASSERT_EQ(1, ret); 122 123 asocket* cause_close_s = create_local_socket(arg->cause_close_fd); 124 ASSERT_TRUE(cause_close_s != nullptr); 125 cause_close_s->peer = s; 126 s->peer = cause_close_s; 127 cause_close_s->ready(cause_close_s); 128 129 fdevent_loop(); 130 } 131 132 // This test checks if we can close local socket in the following situation: 133 // The socket is closing but having some packets, so it is not closed. Then 134 // some write error happens in the socket's file handler, e.g., the file 135 // handler is closed. 136 TEST_F(LocalSocketTest, close_socket_with_packet) { 137 int socket_fd[2]; 138 ASSERT_EQ(0, adb_socketpair(socket_fd)); 139 int cause_close_fd[2]; 140 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 141 CloseWithPacketArg arg; 142 arg.socket_fd = socket_fd[1]; 143 arg.cause_close_fd = cause_close_fd[1]; 144 145 PrepareThread(); 146 std::thread thread(CloseWithPacketThreadFunc, &arg); 147 // Wait until the fdevent_loop() starts. 148 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 149 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 150 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 151 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 152 ASSERT_EQ(0, adb_close(socket_fd[0])); 153 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 154 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 155 TerminateThread(thread); 156 } 157 158 // This test checks if we can read packets from a closing local socket. 159 TEST_F(LocalSocketTest, read_from_closing_socket) { 160 int socket_fd[2]; 161 ASSERT_EQ(0, adb_socketpair(socket_fd)); 162 int cause_close_fd[2]; 163 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 164 CloseWithPacketArg arg; 165 arg.socket_fd = socket_fd[1]; 166 arg.cause_close_fd = cause_close_fd[1]; 167 168 PrepareThread(); 169 std::thread thread(CloseWithPacketThreadFunc, &arg); 170 // Wait until the fdevent_loop() starts. 171 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 172 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 173 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 174 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 175 176 // Verify if we can read successfully. 177 std::vector<char> buf(arg.bytes_written); 178 ASSERT_NE(0u, arg.bytes_written); 179 ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size())); 180 ASSERT_EQ(0, adb_close(socket_fd[0])); 181 182 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 183 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 184 TerminateThread(thread); 185 } 186 187 // This test checks if we can close local socket in the following situation: 188 // The socket is not closed and has some packets. When it fails to write to 189 // the socket's file handler because the other end is closed, we check if the 190 // socket is closed. 191 TEST_F(LocalSocketTest, write_error_when_having_packets) { 192 int socket_fd[2]; 193 ASSERT_EQ(0, adb_socketpair(socket_fd)); 194 int cause_close_fd[2]; 195 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 196 CloseWithPacketArg arg; 197 arg.socket_fd = socket_fd[1]; 198 arg.cause_close_fd = cause_close_fd[1]; 199 200 PrepareThread(); 201 std::thread thread(CloseWithPacketThreadFunc, &arg); 202 // Wait until the fdevent_loop() starts. 203 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 204 EXPECT_EQ(2u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 205 ASSERT_EQ(0, adb_close(socket_fd[0])); 206 207 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 208 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 209 TerminateThread(thread); 210 } 211 212 // Ensure that if we fail to write output to an fd, we will still flush data coming from it. 213 TEST_F(LocalSocketTest, flush_after_shutdown) { 214 int head_fd[2]; 215 int tail_fd[2]; 216 ASSERT_EQ(0, adb_socketpair(head_fd)); 217 ASSERT_EQ(0, adb_socketpair(tail_fd)); 218 219 asocket* head = create_local_socket(head_fd[1]); 220 asocket* tail = create_local_socket(tail_fd[1]); 221 222 head->peer = tail; 223 head->ready(head); 224 225 tail->peer = head; 226 tail->ready(tail); 227 228 PrepareThread(); 229 std::thread thread(fdevent_loop); 230 231 EXPECT_TRUE(WriteFdExactly(head_fd[0], "foo", 3)); 232 233 EXPECT_EQ(0, adb_shutdown(head_fd[0], SHUT_RD)); 234 const char* str = "write succeeds, but local_socket will fail to write"; 235 EXPECT_TRUE(WriteFdExactly(tail_fd[0], str, strlen(str))); 236 EXPECT_TRUE(WriteFdExactly(head_fd[0], "bar", 3)); 237 238 char buf[6]; 239 EXPECT_TRUE(ReadFdExactly(tail_fd[0], buf, 6)); 240 EXPECT_EQ(0, memcmp(buf, "foobar", 6)); 241 242 adb_close(head_fd[0]); 243 adb_close(tail_fd[0]); 244 245 // Wait until the local sockets are closed. 246 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 247 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 248 TerminateThread(thread); 249 } 250 251 #if defined(__linux__) 252 253 static void ClientThreadFunc() { 254 std::string error; 255 int fd = network_loopback_client(5038, SOCK_STREAM, &error); 256 ASSERT_GE(fd, 0) << error; 257 std::this_thread::sleep_for(200ms); 258 ASSERT_EQ(0, adb_close(fd)); 259 } 260 261 struct CloseRdHupSocketArg { 262 int socket_fd; 263 }; 264 265 static void CloseRdHupSocketThreadFunc(CloseRdHupSocketArg* arg) { 266 asocket* s = create_local_socket(arg->socket_fd); 267 ASSERT_TRUE(s != nullptr); 268 269 fdevent_loop(); 270 } 271 272 // This test checks if we can close sockets in CLOSE_WAIT state. 273 TEST_F(LocalSocketTest, close_socket_in_CLOSE_WAIT_state) { 274 std::string error; 275 int listen_fd = network_inaddr_any_server(5038, SOCK_STREAM, &error); 276 ASSERT_GE(listen_fd, 0); 277 278 std::thread client_thread(ClientThreadFunc); 279 280 int accept_fd = adb_socket_accept(listen_fd, nullptr, nullptr); 281 ASSERT_GE(accept_fd, 0); 282 CloseRdHupSocketArg arg; 283 arg.socket_fd = accept_fd; 284 285 PrepareThread(); 286 std::thread thread(CloseRdHupSocketThreadFunc, &arg); 287 288 // Wait until the fdevent_loop() starts. 289 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 290 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 291 292 // Wait until the client closes its socket. 293 client_thread.join(); 294 295 std::this_thread::sleep_for(SLEEP_FOR_FDEVENT); 296 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 297 TerminateThread(thread); 298 } 299 300 #endif // defined(__linux__) 301 302 #if ADB_HOST 303 304 // Checks that skip_host_serial(serial) returns a pointer to the part of |serial| which matches 305 // |expected|, otherwise logs the failure to gtest. 306 void VerifySkipHostSerial(std::string serial, const char* expected) { 307 char* result = internal::skip_host_serial(&serial[0]); 308 if (expected == nullptr) { 309 EXPECT_EQ(nullptr, result); 310 } else { 311 EXPECT_STREQ(expected, result); 312 } 313 } 314 315 // Check [tcp:|udp:]<serial>[:<port>]:<command> format. 316 TEST(socket_test, test_skip_host_serial) { 317 for (const std::string& protocol : {"", "tcp:", "udp:"}) { 318 VerifySkipHostSerial(protocol, nullptr); 319 VerifySkipHostSerial(protocol + "foo", nullptr); 320 321 VerifySkipHostSerial(protocol + "foo:bar", ":bar"); 322 VerifySkipHostSerial(protocol + "foo:bar:baz", ":bar:baz"); 323 324 VerifySkipHostSerial(protocol + "foo:123:bar", ":bar"); 325 VerifySkipHostSerial(protocol + "foo:123:456", ":456"); 326 VerifySkipHostSerial(protocol + "foo:123:bar:baz", ":bar:baz"); 327 328 // Don't register a port unless it's all numbers and ends with ':'. 329 VerifySkipHostSerial(protocol + "foo:123", ":123"); 330 VerifySkipHostSerial(protocol + "foo:123bar:baz", ":123bar:baz"); 331 332 VerifySkipHostSerial(protocol + "100.100.100.100:5555:foo", ":foo"); 333 VerifySkipHostSerial(protocol + "[0123:4567:89ab:CDEF:0:9:a:f]:5555:foo", ":foo"); 334 VerifySkipHostSerial(protocol + "[::1]:5555:foo", ":foo"); 335 336 // If we can't find both [] then treat it as a normal serial with [ in it. 337 VerifySkipHostSerial(protocol + "[0123:foo", ":foo"); 338 339 // Don't be fooled by random IPv6 addresses in the command string. 340 VerifySkipHostSerial(protocol + "foo:ping [0123:4567:89ab:CDEF:0:9:a:f]:5555", 341 ":ping [0123:4567:89ab:CDEF:0:9:a:f]:5555"); 342 } 343 } 344 345 // Check <prefix>:<serial>:<command> format. 346 TEST(socket_test, test_skip_host_serial_prefix) { 347 for (const std::string& prefix : {"usb:", "product:", "model:", "device:"}) { 348 VerifySkipHostSerial(prefix, nullptr); 349 VerifySkipHostSerial(prefix + "foo", nullptr); 350 351 VerifySkipHostSerial(prefix + "foo:bar", ":bar"); 352 VerifySkipHostSerial(prefix + "foo:bar:baz", ":bar:baz"); 353 VerifySkipHostSerial(prefix + "foo:123:bar", ":123:bar"); 354 } 355 } 356 357 #endif // ADB_HOST 358
