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/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/fdevent_test.h" 33 #include "socket.h" 34 #include "sysdeps.h" 35 #include "sysdeps/chrono.h" 36 37 using namespace std::string_literals; 38 using namespace std::string_view_literals; 39 40 struct ThreadArg { 41 int first_read_fd; 42 int last_write_fd; 43 size_t middle_pipe_count; 44 }; 45 46 class LocalSocketTest : public FdeventTest {}; 47 48 TEST_F(LocalSocketTest, smoke) { 49 // Join two socketpairs with a chain of intermediate socketpairs. 50 int first[2]; 51 std::vector<std::array<int, 2>> intermediates; 52 int last[2]; 53 54 constexpr size_t INTERMEDIATE_COUNT = 50; 55 constexpr size_t MESSAGE_LOOP_COUNT = 100; 56 const std::string MESSAGE = "socket_test"; 57 58 intermediates.resize(INTERMEDIATE_COUNT); 59 ASSERT_EQ(0, adb_socketpair(first)) << strerror(errno); 60 ASSERT_EQ(0, adb_socketpair(last)) << strerror(errno); 61 asocket* prev_tail = create_local_socket(unique_fd(first[1])); 62 ASSERT_NE(nullptr, prev_tail); 63 64 auto connect = [](asocket* tail, asocket* head) { 65 tail->peer = head; 66 head->peer = tail; 67 tail->ready(tail); 68 }; 69 70 for (auto& intermediate : intermediates) { 71 ASSERT_EQ(0, adb_socketpair(intermediate.data())) << strerror(errno); 72 73 asocket* head = create_local_socket(unique_fd(intermediate[0])); 74 ASSERT_NE(nullptr, head); 75 76 asocket* tail = create_local_socket(unique_fd(intermediate[1])); 77 ASSERT_NE(nullptr, tail); 78 79 connect(prev_tail, head); 80 prev_tail = tail; 81 } 82 83 asocket* end = create_local_socket(unique_fd(last[0])); 84 ASSERT_NE(nullptr, end); 85 connect(prev_tail, end); 86 87 PrepareThread(); 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 WaitForFdeventLoop(); 102 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 103 TerminateThread(); 104 } 105 106 struct CloseWithPacketArg { 107 unique_fd socket_fd; 108 size_t bytes_written; 109 unique_fd cause_close_fd; 110 }; 111 112 static void CreateCloser(CloseWithPacketArg* arg) { 113 fdevent_run_on_main_thread([arg]() { 114 asocket* s = create_local_socket(std::move(arg->socket_fd)); 115 ASSERT_TRUE(s != nullptr); 116 arg->bytes_written = 0; 117 118 // On platforms that implement sockets via underlying sockets (e.g. Wine), 119 // a socket can appear to be full, and then become available for writes 120 // again without read being called on the other end. Loop and sleep after 121 // each write to give the underlying implementation time to flush. 122 bool socket_filled = false; 123 for (int i = 0; i < 128; ++i) { 124 apacket::payload_type data; 125 data.resize(MAX_PAYLOAD); 126 arg->bytes_written += data.size(); 127 int ret = s->enqueue(s, std::move(data)); 128 if (ret == 1) { 129 socket_filled = true; 130 break; 131 } 132 ASSERT_NE(-1, ret); 133 134 std::this_thread::sleep_for(250ms); 135 } 136 ASSERT_TRUE(socket_filled); 137 138 asocket* cause_close_s = create_local_socket(std::move(arg->cause_close_fd)); 139 ASSERT_TRUE(cause_close_s != nullptr); 140 cause_close_s->peer = s; 141 s->peer = cause_close_s; 142 cause_close_s->ready(cause_close_s); 143 }); 144 WaitForFdeventLoop(); 145 } 146 147 // This test checks if we can close local socket in the following situation: 148 // The socket is closing but having some packets, so it is not closed. Then 149 // some write error happens in the socket's file handler, e.g., the file 150 // handler is closed. 151 TEST_F(LocalSocketTest, close_socket_with_packet) { 152 int socket_fd[2]; 153 ASSERT_EQ(0, adb_socketpair(socket_fd)); 154 int cause_close_fd[2]; 155 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 156 CloseWithPacketArg arg; 157 arg.socket_fd.reset(socket_fd[1]); 158 arg.cause_close_fd.reset(cause_close_fd[1]); 159 160 PrepareThread(); 161 CreateCloser(&arg); 162 163 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 164 165 WaitForFdeventLoop(); 166 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 167 ASSERT_EQ(0, adb_close(socket_fd[0])); 168 169 WaitForFdeventLoop(); 170 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 171 TerminateThread(); 172 } 173 174 // This test checks if we can read packets from a closing local socket. 175 TEST_F(LocalSocketTest, read_from_closing_socket) { 176 int socket_fd[2]; 177 ASSERT_EQ(0, adb_socketpair(socket_fd)); 178 int cause_close_fd[2]; 179 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 180 CloseWithPacketArg arg; 181 arg.socket_fd.reset(socket_fd[1]); 182 arg.cause_close_fd.reset(cause_close_fd[1]); 183 184 PrepareThread(); 185 CreateCloser(&arg); 186 187 WaitForFdeventLoop(); 188 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 189 190 WaitForFdeventLoop(); 191 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 192 193 // Verify if we can read successfully. 194 std::vector<char> buf(arg.bytes_written); 195 ASSERT_NE(0u, arg.bytes_written); 196 ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size())); 197 ASSERT_EQ(0, adb_close(socket_fd[0])); 198 199 WaitForFdeventLoop(); 200 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 201 TerminateThread(); 202 } 203 204 // This test checks if we can close local socket in the following situation: 205 // The socket is not closed and has some packets. When it fails to write to 206 // the socket's file handler because the other end is closed, we check if the 207 // socket is closed. 208 TEST_F(LocalSocketTest, write_error_when_having_packets) { 209 int socket_fd[2]; 210 ASSERT_EQ(0, adb_socketpair(socket_fd)); 211 int cause_close_fd[2]; 212 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 213 CloseWithPacketArg arg; 214 arg.socket_fd.reset(socket_fd[1]); 215 arg.cause_close_fd.reset(cause_close_fd[1]); 216 217 PrepareThread(); 218 CreateCloser(&arg); 219 220 WaitForFdeventLoop(); 221 EXPECT_EQ(2u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 222 ASSERT_EQ(0, adb_close(socket_fd[0])); 223 224 std::this_thread::sleep_for(2s); 225 226 WaitForFdeventLoop(); 227 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 228 TerminateThread(); 229 } 230 231 // Ensure that if we fail to write output to an fd, we will still flush data coming from it. 232 TEST_F(LocalSocketTest, flush_after_shutdown) { 233 int head_fd[2]; 234 int tail_fd[2]; 235 ASSERT_EQ(0, adb_socketpair(head_fd)); 236 ASSERT_EQ(0, adb_socketpair(tail_fd)); 237 238 asocket* head = create_local_socket(unique_fd(head_fd[1])); 239 asocket* tail = create_local_socket(unique_fd(tail_fd[1])); 240 241 head->peer = tail; 242 head->ready(head); 243 244 tail->peer = head; 245 tail->ready(tail); 246 247 PrepareThread(); 248 249 EXPECT_TRUE(WriteFdExactly(head_fd[0], "foo", 3)); 250 251 EXPECT_EQ(0, adb_shutdown(head_fd[0], SHUT_RD)); 252 const char* str = "write succeeds, but local_socket will fail to write"; 253 EXPECT_TRUE(WriteFdExactly(tail_fd[0], str, strlen(str))); 254 EXPECT_TRUE(WriteFdExactly(head_fd[0], "bar", 3)); 255 256 char buf[6]; 257 EXPECT_TRUE(ReadFdExactly(tail_fd[0], buf, 6)); 258 EXPECT_EQ(0, memcmp(buf, "foobar", 6)); 259 260 adb_close(head_fd[0]); 261 adb_close(tail_fd[0]); 262 263 WaitForFdeventLoop(); 264 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 265 TerminateThread(); 266 } 267 268 #if defined(__linux__) 269 270 static void ClientThreadFunc() { 271 std::string error; 272 int fd = network_loopback_client(5038, SOCK_STREAM, &error); 273 ASSERT_GE(fd, 0) << error; 274 std::this_thread::sleep_for(1s); 275 ASSERT_EQ(0, adb_close(fd)); 276 } 277 278 // This test checks if we can close sockets in CLOSE_WAIT state. 279 TEST_F(LocalSocketTest, close_socket_in_CLOSE_WAIT_state) { 280 std::string error; 281 int listen_fd = network_inaddr_any_server(5038, SOCK_STREAM, &error); 282 ASSERT_GE(listen_fd, 0); 283 284 std::thread client_thread(ClientThreadFunc); 285 286 int accept_fd = adb_socket_accept(listen_fd, nullptr, nullptr); 287 ASSERT_GE(accept_fd, 0); 288 289 PrepareThread(); 290 291 fdevent_run_on_main_thread([accept_fd]() { 292 asocket* s = create_local_socket(unique_fd(accept_fd)); 293 ASSERT_TRUE(s != nullptr); 294 }); 295 296 WaitForFdeventLoop(); 297 EXPECT_EQ(1u + GetAdditionalLocalSocketCount(), fdevent_installed_count()); 298 299 // Wait until the client closes its socket. 300 client_thread.join(); 301 302 WaitForFdeventLoop(); 303 ASSERT_EQ(GetAdditionalLocalSocketCount(), fdevent_installed_count()); 304 TerminateThread(); 305 } 306 307 #endif // defined(__linux__) 308 309 #if ADB_HOST 310 311 #define VerifyParseHostServiceFailed(s) \ 312 do { \ 313 std::string service(s); \ 314 std::string_view serial, command; \ 315 bool result = internal::parse_host_service(&serial, &command, service); \ 316 EXPECT_FALSE(result); \ 317 } while (0) 318 319 #define VerifyParseHostService(s, expected_serial, expected_command) \ 320 do { \ 321 std::string service(s); \ 322 std::string_view serial, command; \ 323 bool result = internal::parse_host_service(&serial, &command, service); \ 324 EXPECT_TRUE(result); \ 325 EXPECT_EQ(std::string(expected_serial), std::string(serial)); \ 326 EXPECT_EQ(std::string(expected_command), std::string(command)); \ 327 } while (0); 328 329 // Check [tcp:|udp:]<serial>[:<port>]:<command> format. 330 TEST(socket_test, test_parse_host_service) { 331 for (const std::string& protocol : {"", "tcp:", "udp:"}) { 332 VerifyParseHostServiceFailed(protocol); 333 VerifyParseHostServiceFailed(protocol + "foo"); 334 335 { 336 std::string serial = protocol + "foo"; 337 VerifyParseHostService(serial + ":bar", serial, "bar"); 338 VerifyParseHostService(serial + " :bar:baz", serial, "bar:baz"); 339 } 340 341 { 342 // With port. 343 std::string serial = protocol + "foo:123"; 344 VerifyParseHostService(serial + ":bar", serial, "bar"); 345 VerifyParseHostService(serial + ":456", serial, "456"); 346 VerifyParseHostService(serial + ":bar:baz", serial, "bar:baz"); 347 } 348 349 // Don't register a port unless it's all numbers and ends with ':'. 350 VerifyParseHostService(protocol + "foo:123", protocol + "foo", "123"); 351 VerifyParseHostService(protocol + "foo:123bar:baz", protocol + "foo", "123bar:baz"); 352 353 std::string addresses[] = {"100.100.100.100", "[0123:4567:89ab:CDEF:0:9:a:f]", "[::1]"}; 354 for (const std::string& address : addresses) { 355 std::string serial = protocol + address; 356 std::string serial_with_port = protocol + address + ":5555"; 357 VerifyParseHostService(serial + ":foo", serial, "foo"); 358 VerifyParseHostService(serial_with_port + ":foo", serial_with_port, "foo"); 359 } 360 361 // If we can't find both [] then treat it as a normal serial with [ in it. 362 VerifyParseHostService(protocol + "[0123:foo", protocol + "[0123", "foo"); 363 364 // Don't be fooled by random IPv6 addresses in the command string. 365 VerifyParseHostService(protocol + "foo:ping [0123:4567:89ab:CDEF:0:9:a:f]:5555", 366 protocol + "foo", "ping [0123:4567:89ab:CDEF:0:9:a:f]:5555"); 367 368 // Handle embedded NULs properly. 369 VerifyParseHostService(protocol + "foo:echo foo\0bar"s, protocol + "foo", 370 "echo foo\0bar"sv); 371 } 372 } 373 374 // Check <prefix>:<serial>:<command> format. 375 TEST(socket_test, test_parse_host_service_prefix) { 376 for (const std::string& prefix : {"usb:", "product:", "model:", "device:"}) { 377 VerifyParseHostServiceFailed(prefix); 378 VerifyParseHostServiceFailed(prefix + "foo"); 379 380 VerifyParseHostService(prefix + "foo:bar", prefix + "foo", "bar"); 381 VerifyParseHostService(prefix + "foo:bar:baz", prefix + "foo", "bar:baz"); 382 VerifyParseHostService(prefix + "foo:123:bar", prefix + "foo", "123:bar"); 383 } 384 } 385 386 #endif // ADB_HOST 387