436 lines · cpp
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-exception6//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#endif21 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_POSIX82 Socket::ProtocolUnixDomain,83 Socket::ProtocolUnixAbstract,84#endif85 };86 for (auto p : functional_protocols) {87 auto expected_socket_pair = Socket::CreatePair(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_POSIX102 Socket::ProtocolUnixDomain,103 Socket::ProtocolUnixAbstract,104#endif105 };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_POSIX113TEST_F(SocketTest, DomainListenConnectAccept) {114 llvm::SmallString<64> Path;115 std::error_code EC =116 llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", Path);117 ASSERT_FALSE(EC);118 llvm::sys::path::append(Path, "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, &socket_a_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("DomainListenConnectAccept", Path);133 ASSERT_FALSE(EC);134 llvm::sys::path::append(Path, "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=*/true);142 Status error = listen_socket_up->Listen(Path, 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("DomainListenConnectAccept", Path);155 ASSERT_FALSE(EC);156 llvm::sys::path::append(Path, "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=*/true);164 Status error = listen_socket_up->Listen(Path, 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, [&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=*/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#endif188 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(GetParam().localhost_ip, &socket_a_up,195 &socket_b_up);196}197 198TEST_P(SocketTest, TCPAcceptTimeout) {199 if (!HostSupportsProtocol())200 return;201 202 auto listen_socket_up = std::make_unique<TCPSocket>(true);203 Status error = listen_socket_up->Listen(204 llvm::formatv("[{0}]:0", GetParam().localhost_ip).str(), 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>(true);222 Status error = listen_socket_up->Listen(223 llvm::formatv("[{0}]:0", GetParam().localhost_ip).str(), 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, [&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>(true);237 ASSERT_THAT_ERROR(238 connect_socket_up239 ->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(GetParam().localhost_ip, &socket_a_up,257 &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("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("10.10.12.3:0", 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("[{0}]:0", GetParam().localhost_ip).str();297 llvm::Expected<std::unique_ptr<TCPSocket>> sock = Socket::TcpListen(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("localhost:0", 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(GetParam().localhost_ip, &socket_a_up,334 &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("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_POSIX355TEST_F(SocketTest, DomainGetConnectURI) {356 llvm::SmallString<64> domain_path;357 std::error_code EC = llvm::sys::fs::createUniqueDirectory(358 "DomainListenConnectAccept", domain_path);359 ASSERT_FALSE(EC);360 llvm::sys::path::append(domain_path, "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(domain_path, &socket_a_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 "DomainSocketFromBoundNativeSocket", name);382 ASSERT_FALSE(EC);383 llvm::sys::path::append(name, "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(native_socket,396 /*should_close=*/false);397 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());398 ASSERT_EQ(Socket::ProtocolUnixDomain, sock->get()->GetSocketProtocol());399}400#endif401 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("AbstractSocketFromBoundNativeSocket", name,407 true);408 llvm::sys::path::append(name, "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(native_socket,421 /*should_close=*/false);422 ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());423 ASSERT_EQ(Socket::ProtocolUnixAbstract, sock->get()->GetSocketProtocol());424}425#endif426 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