1//===-- SocketTest.cpp ----------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "TestingSupport/Host/SocketTestUtilities.h"
10#include "TestingSupport/SubsystemRAII.h"
11#include "lldb/Host/Config.h"
12#include "lldb/Host/MainLoop.h"
13#include "lldb/Utility/UriParser.h"
14#include "llvm/Testing/Support/Error.h"
15#include "gmock/gmock.h"
16#include "gtest/gtest.h"
17#include <chrono>
18#if __linux__
19#include <lldb/Host/linux/AbstractSocket.h>
20#endif
21
22using namespace lldb_private;
23
24struct SocketTestParams {
25 bool is_ipv6;
26 std::string localhost_ip;
27};
28
29class SocketTest : public testing::TestWithParam<SocketTestParams> {
30public:
31 SubsystemRAII<Socket> subsystems;
32
33protected:
34 bool HostSupportsProtocol() const {
35 if (GetParam().is_ipv6)
36 return HostSupportsIPv6();
37 return HostSupportsIPv4();
38 }
39};
40
41TEST_F(SocketTest, DecodeHostAndPort) {
42 EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("localhost:1138"),
43 llvm::HasValue(Socket::HostAndPort{"localhost", 1138}));
44
45 EXPECT_THAT_EXPECTED(
46 Socket::DecodeHostAndPort("google.com:65536"),
47 llvm::FailedWithMessage(
48 "invalid host:port specification: 'google.com:65536'"));
49
50 EXPECT_THAT_EXPECTED(
51 Socket::DecodeHostAndPort("google.com:-1138"),
52 llvm::FailedWithMessage(
53 "invalid host:port specification: 'google.com:-1138'"));
54
55 EXPECT_THAT_EXPECTED(
56 Socket::DecodeHostAndPort("google.com:65536"),
57 llvm::FailedWithMessage(
58 "invalid host:port specification: 'google.com:65536'"));
59
60 EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("12345"),
61 llvm::HasValue(Socket::HostAndPort{"", 12345}));
62
63 EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("*:0"),
64 llvm::HasValue(Socket::HostAndPort{"*", 0}));
65
66 EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("*:65535"),
67 llvm::HasValue(Socket::HostAndPort{"*", 65535}));
68
69 EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("[::1]:12345"),
70 llvm::HasValue(Socket::HostAndPort{"::1", 12345}));
71
72 EXPECT_THAT_EXPECTED(
73 Socket::DecodeHostAndPort("[abcd:12fg:AF58::1]:12345"),
74 llvm::HasValue(Socket::HostAndPort{"abcd:12fg:AF58::1", 12345}));
75}
76
77TEST_F(SocketTest, CreatePair) {
78 std::vector<std::optional<Socket::SocketProtocol>> functional_protocols = {
79 std::nullopt,
80 Socket::ProtocolTcp,
81#if LLDB_ENABLE_POSIX
82 Socket::ProtocolUnixDomain,
83 Socket::ProtocolUnixAbstract,
84#endif
85 };
86 for (auto p : functional_protocols) {
87 auto expected_socket_pair = Socket::CreatePair(protocol: p);
88 ASSERT_THAT_EXPECTED(expected_socket_pair, llvm::Succeeded());
89 Socket &a = *expected_socket_pair->first;
90 Socket &b = *expected_socket_pair->second;
91 size_t num_bytes = 1;
92 ASSERT_THAT_ERROR(a.Write("a", num_bytes).takeError(), llvm::Succeeded());
93 ASSERT_EQ(num_bytes, 1U);
94 char c;
95 ASSERT_THAT_ERROR(b.Read(&c, num_bytes).takeError(), llvm::Succeeded());
96 ASSERT_EQ(num_bytes, 1U);
97 ASSERT_EQ(c, 'a');
98 }
99
100 std::vector<Socket::SocketProtocol> erroring_protocols = {
101#if !LLDB_ENABLE_POSIX
102 Socket::ProtocolUnixDomain,
103 Socket::ProtocolUnixAbstract,
104#endif
105 };
106 for (auto p : erroring_protocols) {
107 ASSERT_THAT_EXPECTED(Socket::CreatePair(p),
108 llvm::FailedWithMessage("Unsupported protocol"));
109 }
110}
111
112#if LLDB_ENABLE_POSIX
113TEST_F(SocketTest, DomainListenConnectAccept) {
114 llvm::SmallString<64> Path;
115 std::error_code EC =
116 llvm::sys::fs::createUniqueDirectory(Prefix: "DomainListenConnectAccept", ResultPath&: Path);
117 ASSERT_FALSE(EC);
118 llvm::sys::path::append(path&: Path, a: "test");
119
120 // Skip the test if the $TMPDIR is too long to hold a domain socket.
121 if (Path.size() > 107u)
122 return;
123
124 std::unique_ptr<DomainSocket> socket_a_up;
125 std::unique_ptr<DomainSocket> socket_b_up;
126 CreateDomainConnectedSockets(path: Path, a_up: &socket_a_up, b_up: &socket_b_up);
127}
128
129TEST_F(SocketTest, DomainListenGetListeningConnectionURI) {
130 llvm::SmallString<64> Path;
131 std::error_code EC =
132 llvm::sys::fs::createUniqueDirectory(Prefix: "DomainListenConnectAccept", ResultPath&: Path);
133 ASSERT_FALSE(EC);
134 llvm::sys::path::append(path&: Path, a: "test");
135
136 // Skip the test if the $TMPDIR is too long to hold a domain socket.
137 if (Path.size() > 107u)
138 return;
139
140 auto listen_socket_up = std::make_unique<DomainSocket>(
141 /*should_close=*/args: true);
142 Status error = listen_socket_up->Listen(name: Path, backlog: 5);
143 ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
144 ASSERT_TRUE(listen_socket_up->IsValid());
145
146 ASSERT_THAT(
147 listen_socket_up->GetListeningConnectionURI(),
148 testing::ElementsAre(llvm::formatv("unix-connect://{0}", Path).str()));
149}
150
151TEST_F(SocketTest, DomainMainLoopAccept) {
152 llvm::SmallString<64> Path;
153 std::error_code EC =
154 llvm::sys::fs::createUniqueDirectory(Prefix: "DomainListenConnectAccept", ResultPath&: Path);
155 ASSERT_FALSE(EC);
156 llvm::sys::path::append(path&: Path, a: "test");
157
158 // Skip the test if the $TMPDIR is too long to hold a domain socket.
159 if (Path.size() > 107u)
160 return;
161
162 auto listen_socket_up = std::make_unique<DomainSocket>(
163 /*should_close=*/args: true);
164 Status error = listen_socket_up->Listen(name: Path, backlog: 5);
165 ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
166 ASSERT_TRUE(listen_socket_up->IsValid());
167
168 MainLoop loop;
169 std::unique_ptr<Socket> accepted_socket_up;
170 auto expected_handles = listen_socket_up->Accept(
171 loop, sock_cb: [&accepted_socket_up, &loop](std::unique_ptr<Socket> sock_up) {
172 accepted_socket_up = std::move(sock_up);
173 loop.RequestTermination();
174 });
175 ASSERT_THAT_EXPECTED(expected_handles, llvm::Succeeded());
176
177 auto connect_socket_up = std::make_unique<DomainSocket>(
178 /*should_close=*/args: true);
179 ASSERT_THAT_ERROR(connect_socket_up->Connect(Path).ToError(),
180 llvm::Succeeded());
181 ASSERT_TRUE(connect_socket_up->IsValid());
182
183 loop.Run();
184 ASSERT_TRUE(accepted_socket_up);
185 ASSERT_TRUE(accepted_socket_up->IsValid());
186}
187#endif
188
189TEST_P(SocketTest, TCPListen0ConnectAccept) {
190 if (!HostSupportsProtocol())
191 return;
192 std::unique_ptr<TCPSocket> socket_a_up;
193 std::unique_ptr<TCPSocket> socket_b_up;
194 CreateTCPConnectedSockets(listen_remote_ip: GetParam().localhost_ip, a_up: &socket_a_up,
195 b_up: &socket_b_up);
196}
197
198TEST_P(SocketTest, TCPAcceptTimeout) {
199 if (!HostSupportsProtocol())
200 return;
201
202 auto listen_socket_up = std::make_unique<TCPSocket>(args: true);
203 Status error = listen_socket_up->Listen(
204 name: llvm::formatv(Fmt: "[{0}]:0", Vals: GetParam().localhost_ip).str(), backlog: 5);
205 ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
206 ASSERT_TRUE(listen_socket_up->IsValid());
207
208 Socket *socket;
209 ASSERT_THAT_ERROR(
210 listen_socket_up->Accept(std::chrono::milliseconds(10), socket)
211 .takeError(),
212 llvm::Failed<llvm::ErrorInfoBase>(
213 testing::Property(&llvm::ErrorInfoBase::convertToErrorCode,
214 std::make_error_code(std::errc::timed_out))));
215}
216
217TEST_P(SocketTest, TCPMainLoopAccept) {
218 if (!HostSupportsProtocol())
219 return;
220
221 auto listen_socket_up = std::make_unique<TCPSocket>(args: true);
222 Status error = listen_socket_up->Listen(
223 name: llvm::formatv(Fmt: "[{0}]:0", Vals: GetParam().localhost_ip).str(), backlog: 5);
224 ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
225 ASSERT_TRUE(listen_socket_up->IsValid());
226
227 MainLoop loop;
228 std::unique_ptr<Socket> accepted_socket_up;
229 auto expected_handles = listen_socket_up->Accept(
230 loop, sock_cb: [&accepted_socket_up, &loop](std::unique_ptr<Socket> sock_up) {
231 accepted_socket_up = std::move(sock_up);
232 loop.RequestTermination();
233 });
234 ASSERT_THAT_EXPECTED(expected_handles, llvm::Succeeded());
235
236 auto connect_socket_up = std::make_unique<TCPSocket>(args: true);
237 ASSERT_THAT_ERROR(
238 connect_socket_up
239 ->Connect(llvm::formatv("[{0}]:{1}", GetParam().localhost_ip,
240 listen_socket_up->GetLocalPortNumber())
241 .str())
242 .ToError(),
243 llvm::Succeeded());
244 ASSERT_TRUE(connect_socket_up->IsValid());
245
246 loop.Run();
247 ASSERT_TRUE(accepted_socket_up);
248 ASSERT_TRUE(accepted_socket_up->IsValid());
249}
250
251TEST_P(SocketTest, TCPGetAddress) {
252 std::unique_ptr<TCPSocket> socket_a_up;
253 std::unique_ptr<TCPSocket> socket_b_up;
254 if (!HostSupportsProtocol())
255 return;
256 CreateTCPConnectedSockets(listen_remote_ip: GetParam().localhost_ip, a_up: &socket_a_up,
257 b_up: &socket_b_up);
258
259 EXPECT_EQ(socket_a_up->GetLocalPortNumber(),
260 socket_b_up->GetRemotePortNumber());
261 EXPECT_EQ(socket_b_up->GetLocalPortNumber(),
262 socket_a_up->GetRemotePortNumber());
263 EXPECT_NE(socket_a_up->GetLocalPortNumber(),
264 socket_b_up->GetLocalPortNumber());
265 EXPECT_STREQ(GetParam().localhost_ip.c_str(),
266 socket_a_up->GetRemoteIPAddress().c_str());
267 EXPECT_STREQ(GetParam().localhost_ip.c_str(),
268 socket_b_up->GetRemoteIPAddress().c_str());
269}
270
271TEST_P(SocketTest, UDPConnect) {
272 // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
273 if (!HostSupportsIPv4())
274 return;
275 llvm::Expected<std::unique_ptr<UDPSocket>> socket =
276 UDPSocket::CreateConnected(name: "127.0.0.1:0");
277
278 ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
279 EXPECT_TRUE(socket.get()->IsValid());
280}
281
282TEST_P(SocketTest, TCPListen0GetPort) {
283 if (!HostSupportsIPv4())
284 return;
285 llvm::Expected<std::unique_ptr<TCPSocket>> sock =
286 Socket::TcpListen(host_and_port: "10.10.12.3:0", backlog: 5);
287 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
288 ASSERT_TRUE(sock.get()->IsValid());
289 EXPECT_NE(sock.get()->GetLocalPortNumber(), 0);
290}
291
292TEST_P(SocketTest, TCPListen0GetListeningConnectionURI) {
293 if (!HostSupportsProtocol())
294 return;
295
296 std::string addr = llvm::formatv(Fmt: "[{0}]:0", Vals: GetParam().localhost_ip).str();
297 llvm::Expected<std::unique_ptr<TCPSocket>> sock = Socket::TcpListen(host_and_port: addr);
298 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
299 ASSERT_TRUE(sock.get()->IsValid());
300
301 EXPECT_THAT(
302 sock.get()->GetListeningConnectionURI(),
303 testing::ElementsAre(llvm::formatv("connection://[{0}]:{1}",
304 GetParam().localhost_ip,
305 sock->get()->GetLocalPortNumber())
306 .str()));
307}
308
309TEST_F(SocketTest, TCPListen0MultiListenerGetListeningConnectionURI) {
310 if (!HostSupportsLocalhostToIPv4() || !HostSupportsLocalhostToIPv6())
311 return;
312
313 llvm::Expected<std::unique_ptr<TCPSocket>> sock =
314 Socket::TcpListen(host_and_port: "localhost:0", backlog: 5);
315 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
316 ASSERT_TRUE(sock.get()->IsValid());
317
318 EXPECT_THAT(sock.get()->GetListeningConnectionURI(),
319 testing::UnorderedElementsAre(
320 llvm::formatv("connection://[::1]:{0}",
321 sock->get()->GetLocalPortNumber())
322 .str(),
323 llvm::formatv("connection://[127.0.0.1]:{0}",
324 sock->get()->GetLocalPortNumber())
325 .str()));
326}
327
328TEST_P(SocketTest, TCPGetConnectURI) {
329 std::unique_ptr<TCPSocket> socket_a_up;
330 std::unique_ptr<TCPSocket> socket_b_up;
331 if (!HostSupportsProtocol())
332 return;
333 CreateTCPConnectedSockets(listen_remote_ip: GetParam().localhost_ip, a_up: &socket_a_up,
334 b_up: &socket_b_up);
335
336 std::string uri(socket_a_up->GetRemoteConnectionURI());
337 EXPECT_EQ((URI{"connect", GetParam().localhost_ip,
338 socket_a_up->GetRemotePortNumber(), "/"}),
339 URI::Parse(uri));
340}
341
342TEST_P(SocketTest, UDPGetConnectURI) {
343 // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
344 if (!HostSupportsIPv4())
345 return;
346 llvm::Expected<std::unique_ptr<UDPSocket>> socket =
347 UDPSocket::CreateConnected(name: "127.0.0.1:0");
348 ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
349
350 std::string uri = socket.get()->GetRemoteConnectionURI();
351 EXPECT_EQ((URI{"udp", "127.0.0.1", 0, "/"}), URI::Parse(uri));
352}
353
354#if LLDB_ENABLE_POSIX
355TEST_F(SocketTest, DomainGetConnectURI) {
356 llvm::SmallString<64> domain_path;
357 std::error_code EC = llvm::sys::fs::createUniqueDirectory(
358 Prefix: "DomainListenConnectAccept", ResultPath&: domain_path);
359 ASSERT_FALSE(EC);
360 llvm::sys::path::append(path&: domain_path, a: "test");
361
362 // Skip the test if the $TMPDIR is too long to hold a domain socket.
363 if (domain_path.size() > 107u)
364 return;
365
366 std::unique_ptr<DomainSocket> socket_a_up;
367 std::unique_ptr<DomainSocket> socket_b_up;
368 CreateDomainConnectedSockets(path: domain_path, a_up: &socket_a_up, b_up: &socket_b_up);
369
370 std::string uri(socket_a_up->GetRemoteConnectionURI());
371 EXPECT_EQ((URI{"unix-connect", "", std::nullopt, domain_path}),
372 URI::Parse(uri));
373
374 EXPECT_EQ(socket_b_up->GetRemoteConnectionURI(), "");
375}
376
377TEST_F(SocketTest, DomainSocketFromBoundNativeSocket) {
378 // Generate a name for the domain socket.
379 llvm::SmallString<64> name;
380 std::error_code EC = llvm::sys::fs::createUniqueDirectory(
381 Prefix: "DomainSocketFromBoundNativeSocket", ResultPath&: name);
382 ASSERT_FALSE(EC);
383 llvm::sys::path::append(path&: name, a: "test");
384
385 // Skip the test if the $TMPDIR is too long to hold a domain socket.
386 if (name.size() > 107u)
387 GTEST_SKIP() << "$TMPDIR is too long to hold a domain socket";
388
389 DomainSocket socket(true);
390 Status error = socket.Listen(name, /*backlog=*/10);
391 ASSERT_THAT_ERROR(error.takeError(), llvm::Succeeded());
392 NativeSocket native_socket = socket.GetNativeSocket();
393
394 llvm::Expected<std::unique_ptr<DomainSocket>> sock =
395 DomainSocket::FromBoundNativeSocket(sockfd: native_socket,
396 /*should_close=*/false);
397 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
398 ASSERT_EQ(Socket::ProtocolUnixDomain, sock->get()->GetSocketProtocol());
399}
400#endif
401
402#if __linux__
403TEST_F(SocketTest, AbstractSocketFromBoundNativeSocket) {
404 // Generate a name for the abstract socket.
405 llvm::SmallString<100> name;
406 llvm::sys::fs::createUniquePath(Model: "AbstractSocketFromBoundNativeSocket", ResultPath&: name,
407 MakeAbsolute: true);
408 llvm::sys::path::append(path&: name, a: "test");
409
410 // Skip the test if the $TMPDIR is too long to hold a domain socket.
411 if (name.size() > 107u)
412 GTEST_SKIP() << "$TMPDIR is too long to hold a domain socket";
413
414 AbstractSocket socket;
415 Status error = socket.Listen(name, /*backlog=*/10);
416 ASSERT_THAT_ERROR(error.takeError(), llvm::Succeeded());
417 NativeSocket native_socket = socket.GetNativeSocket();
418
419 llvm::Expected<std::unique_ptr<DomainSocket>> sock =
420 DomainSocket::FromBoundNativeSocket(sockfd: native_socket,
421 /*should_close=*/false);
422 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
423 ASSERT_EQ(Socket::ProtocolUnixAbstract, sock->get()->GetSocketProtocol());
424}
425#endif
426
427INSTANTIATE_TEST_SUITE_P(
428 SocketTests, SocketTest,
429 testing::Values(SocketTestParams{/*is_ipv6=*/false,
430 /*localhost_ip=*/"127.0.0.1"},
431 SocketTestParams{/*is_ipv6=*/true, /*localhost_ip=*/"::1"}),
432 // Prints "SocketTests/SocketTest.TCPGetAddress/ipv4" etc. in test logs.
433 [](const testing::TestParamInfo<SocketTestParams> &info) {
434 return info.param.is_ipv6 ? "ipv6" : "ipv4";
435 });
436

source code of lldb/unittests/Host/SocketTest.cpp