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
TEST_F(LocalSocketTest,smoke)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
CloseWithPacketThreadFunc(CloseWithPacketArg * arg)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.
TEST_F(LocalSocketTest,close_socket_with_packet)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.
TEST_F(LocalSocketTest,read_from_closing_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.
TEST_F(LocalSocketTest,write_error_when_having_packets)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.
TEST_F(LocalSocketTest,flush_after_shutdown)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
ClientThreadFunc()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
CloseRdHupSocketThreadFunc(CloseRdHupSocketArg * arg)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.
TEST_F(LocalSocketTest,close_socket_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.
VerifySkipHostSerial(std::string serial,const char * expected)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.
TEST(socket_test,test_skip_host_serial)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.
TEST(socket_test,test_skip_host_serial_prefix)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