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 
FdEventThreadFunc(void *)43 static void FdEventThreadFunc(void*) {
44     fdevent_loop();
45 }
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     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 
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     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.
TEST_F(LocalSocketTest,close_socket_with_packet)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.
TEST_F(LocalSocketTest,read_from_closing_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.
TEST_F(LocalSocketTest,write_error_when_having_packets)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 
ClientThreadFunc()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 
CloseRdHupSocketThreadFunc(CloseRdHupSocketArg * arg)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.
TEST_F(LocalSocketTest,close_socket_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.
VerifySkipHostSerial(const std::string & serial,const char * expected)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.
TEST(socket_test,test_skip_host_serial)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.
TEST(socket_test,test_skip_host_serial_prefix)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