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 <vector> 26 27 #include <unistd.h> 28 29 #include "adb.h" 30 #include "adb_io.h" 31 #include "fdevent_test.h" 32 #include "socket.h" 33 #include "sysdeps.h" 34 35 struct ThreadArg { 36 int first_read_fd; 37 int last_write_fd; 38 size_t middle_pipe_count; 39 }; 40 41 class LocalSocketTest : public FdeventTest {}; 42 43 static void FdEventThreadFunc(void*) { 44 fdevent_loop(); 45 } 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 adb_thread_t thread; 88 ASSERT_TRUE(adb_thread_create(FdEventThreadFunc, nullptr, &thread)); 89 90 for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { 91 std::string read_buffer = MESSAGE; 92 std::string write_buffer(MESSAGE.size(), 'a'); 93 ASSERT_TRUE(WriteFdExactly(first[0], &read_buffer[0], read_buffer.size())); 94 ASSERT_TRUE(ReadFdExactly(last[1], &write_buffer[0], write_buffer.size())); 95 ASSERT_EQ(read_buffer, write_buffer); 96 } 97 98 ASSERT_EQ(0, adb_close(first[0])); 99 ASSERT_EQ(0, adb_close(last[1])); 100 101 // Wait until the local sockets are closed. 102 adb_sleep_ms(100); 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 while (true) { 117 apacket* p = get_apacket(); 118 p->len = sizeof(p->data); 119 arg->bytes_written += p->len; 120 int ret = s->enqueue(s, p); 121 if (ret == 1) { 122 // The writer has one packet waiting to send. 123 break; 124 } 125 } 126 127 asocket* cause_close_s = create_local_socket(arg->cause_close_fd); 128 ASSERT_TRUE(cause_close_s != nullptr); 129 cause_close_s->peer = s; 130 s->peer = cause_close_s; 131 cause_close_s->ready(cause_close_s); 132 133 fdevent_loop(); 134 } 135 136 // This test checks if we can close local socket in the following situation: 137 // The socket is closing but having some packets, so it is not closed. Then 138 // some write error happens in the socket's file handler, e.g., the file 139 // handler is closed. 140 TEST_F(LocalSocketTest, close_socket_with_packet) { 141 int socket_fd[2]; 142 ASSERT_EQ(0, adb_socketpair(socket_fd)); 143 int cause_close_fd[2]; 144 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 145 CloseWithPacketArg arg; 146 arg.socket_fd = socket_fd[1]; 147 arg.cause_close_fd = cause_close_fd[1]; 148 149 PrepareThread(); 150 adb_thread_t thread; 151 ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseWithPacketThreadFunc), 152 &arg, &thread)); 153 // Wait until the fdevent_loop() starts. 154 adb_sleep_ms(100); 155 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 156 adb_sleep_ms(100); 157 EXPECT_EQ(2u, fdevent_installed_count()); 158 ASSERT_EQ(0, adb_close(socket_fd[0])); 159 160 TerminateThread(thread); 161 } 162 163 // This test checks if we can read packets from a closing local socket. 164 TEST_F(LocalSocketTest, read_from_closing_socket) { 165 int socket_fd[2]; 166 ASSERT_EQ(0, adb_socketpair(socket_fd)); 167 int cause_close_fd[2]; 168 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 169 CloseWithPacketArg arg; 170 arg.socket_fd = socket_fd[1]; 171 arg.cause_close_fd = cause_close_fd[1]; 172 173 PrepareThread(); 174 adb_thread_t thread; 175 ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseWithPacketThreadFunc), 176 &arg, &thread)); 177 // Wait until the fdevent_loop() starts. 178 adb_sleep_ms(100); 179 ASSERT_EQ(0, adb_close(cause_close_fd[0])); 180 adb_sleep_ms(100); 181 EXPECT_EQ(2u, fdevent_installed_count()); 182 183 // Verify if we can read successfully. 184 std::vector<char> buf(arg.bytes_written); 185 ASSERT_NE(0u, arg.bytes_written); 186 ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size())); 187 ASSERT_EQ(0, adb_close(socket_fd[0])); 188 189 TerminateThread(thread); 190 } 191 192 // This test checks if we can close local socket in the following situation: 193 // The socket is not closed and has some packets. When it fails to write to 194 // the socket's file handler because the other end is closed, we check if the 195 // socket is closed. 196 TEST_F(LocalSocketTest, write_error_when_having_packets) { 197 int socket_fd[2]; 198 ASSERT_EQ(0, adb_socketpair(socket_fd)); 199 int cause_close_fd[2]; 200 ASSERT_EQ(0, adb_socketpair(cause_close_fd)); 201 CloseWithPacketArg arg; 202 arg.socket_fd = socket_fd[1]; 203 arg.cause_close_fd = cause_close_fd[1]; 204 205 PrepareThread(); 206 adb_thread_t thread; 207 ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseWithPacketThreadFunc), 208 &arg, &thread)); 209 210 // Wait until the fdevent_loop() starts. 211 adb_sleep_ms(100); 212 EXPECT_EQ(3u, fdevent_installed_count()); 213 ASSERT_EQ(0, adb_close(socket_fd[0])); 214 215 TerminateThread(thread); 216 } 217 218 #if defined(__linux__) 219 220 static void ClientThreadFunc() { 221 std::string error; 222 int fd = network_loopback_client(5038, SOCK_STREAM, &error); 223 ASSERT_GE(fd, 0) << error; 224 adb_sleep_ms(200); 225 ASSERT_EQ(0, adb_close(fd)); 226 } 227 228 struct CloseRdHupSocketArg { 229 int socket_fd; 230 }; 231 232 static void CloseRdHupSocketThreadFunc(CloseRdHupSocketArg* arg) { 233 asocket* s = create_local_socket(arg->socket_fd); 234 ASSERT_TRUE(s != nullptr); 235 236 fdevent_loop(); 237 } 238 239 // This test checks if we can close sockets in CLOSE_WAIT state. 240 TEST_F(LocalSocketTest, close_socket_in_CLOSE_WAIT_state) { 241 std::string error; 242 int listen_fd = network_inaddr_any_server(5038, SOCK_STREAM, &error); 243 ASSERT_GE(listen_fd, 0); 244 245 adb_thread_t client_thread; 246 ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(ClientThreadFunc), nullptr, 247 &client_thread)); 248 249 struct sockaddr addr; 250 socklen_t alen; 251 alen = sizeof(addr); 252 int accept_fd = adb_socket_accept(listen_fd, &addr, &alen); 253 ASSERT_GE(accept_fd, 0); 254 CloseRdHupSocketArg arg; 255 arg.socket_fd = accept_fd; 256 257 PrepareThread(); 258 adb_thread_t thread; 259 ASSERT_TRUE(adb_thread_create(reinterpret_cast<void (*)(void*)>(CloseRdHupSocketThreadFunc), 260 &arg, &thread)); 261 262 // Wait until the fdevent_loop() starts. 263 adb_sleep_ms(100); 264 EXPECT_EQ(2u, fdevent_installed_count()); 265 266 // Wait until the client closes its socket. 267 ASSERT_TRUE(adb_thread_join(client_thread)); 268 269 TerminateThread(thread); 270 } 271 272 #endif // defined(__linux__) 273 274 #if ADB_HOST 275 276 // Checks that skip_host_serial(serial) returns a pointer to the part of |serial| which matches 277 // |expected|, otherwise logs the failure to gtest. 278 void VerifySkipHostSerial(const std::string& serial, const char* expected) { 279 const char* result = internal::skip_host_serial(serial.c_str()); 280 if (expected == nullptr) { 281 EXPECT_EQ(nullptr, result); 282 } else { 283 EXPECT_STREQ(expected, result); 284 } 285 } 286 287 // Check [tcp:|udp:]<serial>[:<port>]:<command> format. 288 TEST(socket_test, test_skip_host_serial) { 289 for (const std::string& protocol : {"", "tcp:", "udp:"}) { 290 VerifySkipHostSerial(protocol, nullptr); 291 VerifySkipHostSerial(protocol + "foo", nullptr); 292 293 VerifySkipHostSerial(protocol + "foo:bar", ":bar"); 294 VerifySkipHostSerial(protocol + "foo:bar:baz", ":bar:baz"); 295 296 VerifySkipHostSerial(protocol + "foo:123:bar", ":bar"); 297 VerifySkipHostSerial(protocol + "foo:123:456", ":456"); 298 VerifySkipHostSerial(protocol + "foo:123:bar:baz", ":bar:baz"); 299 300 // Don't register a port unless it's all numbers and ends with ':'. 301 VerifySkipHostSerial(protocol + "foo:123", ":123"); 302 VerifySkipHostSerial(protocol + "foo:123bar:baz", ":123bar:baz"); 303 } 304 } 305 306 // Check <prefix>:<serial>:<command> format. 307 TEST(socket_test, test_skip_host_serial_prefix) { 308 for (const std::string& prefix : {"usb:", "product:", "model:", "device:"}) { 309 VerifySkipHostSerial(prefix, nullptr); 310 VerifySkipHostSerial(prefix + "foo", nullptr); 311 312 VerifySkipHostSerial(prefix + "foo:bar", ":bar"); 313 VerifySkipHostSerial(prefix + "foo:bar:baz", ":bar:baz"); 314 VerifySkipHostSerial(prefix + "foo:123:bar", ":123:bar"); 315 } 316 } 317 318 #endif // ADB_HOST 319