lldb/unittests/Host/SocketTest.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-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 "gtest/gtest.h"
  16
  17 using namespace lldb_private;
  18
  19 struct SocketTestParams {
  20   bool is_ipv6;
  21   std::string localhost_ip;
  22 };
  23
  24 class SocketTest : public testing::TestWithParam<SocketTestParams> {
  25 public:
  26   SubsystemRAII<Socket> subsystems;
  27
  28 protected:
  29   bool HostSupportsProtocol() const {
  30     if (GetParam().is_ipv6)
  31       return HostSupportsIPv6();
  32     return HostSupportsIPv4();
  33   }
  34 };
  35
  36 TEST_P(SocketTest, DecodeHostAndPort) {
  37   EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("localhost:1138"),
  38                        llvm::HasValue(Socket::HostAndPort{"localhost", 1138}));
  39
  40   EXPECT_THAT_EXPECTED(
  41       Socket::DecodeHostAndPort("google.com:65536"),
  42       llvm::FailedWithMessage(
  43           "invalid host:port specification: 'google.com:65536'"));
  44
  45   EXPECT_THAT_EXPECTED(
  46       Socket::DecodeHostAndPort("google.com:-1138"),
  47       llvm::FailedWithMessage(
  48           "invalid host:port specification: 'google.com:-1138'"));
  49
  50   EXPECT_THAT_EXPECTED(
  51       Socket::DecodeHostAndPort("google.com:65536"),
  52       llvm::FailedWithMessage(
  53           "invalid host:port specification: 'google.com:65536'"));
  54
  55   EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("12345"),
  56                        llvm::HasValue(Socket::HostAndPort{"", 12345}));
  57
  58   EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("*:0"),
  59                        llvm::HasValue(Socket::HostAndPort{"*", 0}));
  60
  61   EXPECT_THAT_EXPECTED(Socket::DecodeHostAndPort("*:65535"),
  62                        llvm::HasValue(Socket::HostAndPort{"*", 65535}));
  63
  64   EXPECT_THAT_EXPECTED(
  65       Socket::DecodeHostAndPort("[::1]:12345"),
  66       llvm::HasValue(Socket::HostAndPort{"::1", 12345}));
  67
  68   EXPECT_THAT_EXPECTED(
  69       Socket::DecodeHostAndPort("[abcd:12fg:AF58::1]:12345"),
  70       llvm::HasValue(Socket::HostAndPort{"abcd:12fg:AF58::1", 12345}));
  71 }
  72
  73 #if LLDB_ENABLE_POSIX
  74 TEST_P(SocketTest, DomainListenConnectAccept) {
  75   llvm::SmallString<64> Path;
  76   std::error_code EC = llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", Path);
  77   ASSERT_FALSE(EC);
  78   llvm::sys::path::append(Path, "test");
  79
  80   // Skip the test if the $TMPDIR is too long to hold a domain socket.
  81   if (Path.size() > 107u)
  82     return;
  83
  84   std::unique_ptr<DomainSocket> socket_a_up;
  85   std::unique_ptr<DomainSocket> socket_b_up;
  86   CreateDomainConnectedSockets(Path, &socket_a_up, &socket_b_up);
  87 }
  88
  89 TEST_P(SocketTest, DomainMainLoopAccept) {
  90   llvm::SmallString<64> Path;
  91   std::error_code EC =
  92       llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", Path);
  93   ASSERT_FALSE(EC);
  94   llvm::sys::path::append(Path, "test");
  95
  96   // Skip the test if the $TMPDIR is too long to hold a domain socket.
  97   if (Path.size() > 107u)
  98     return;
  99
 100   auto listen_socket_up = std::make_unique<DomainSocket>(
 101       /*should_close=*/true, /*child_process_inherit=*/false);
 102   Status error = listen_socket_up->Listen(Path, 5);
 103   ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
 104   ASSERT_TRUE(listen_socket_up->IsValid());
 105
 106   MainLoop loop;
 107   std::unique_ptr<Socket> accepted_socket_up;
 108   auto expected_handles = listen_socket_up->Accept(
 109       loop, [&accepted_socket_up, &loop](std::unique_ptr<Socket> sock_up) {
 110         accepted_socket_up = std::move(sock_up);
 111         loop.RequestTermination();
 112       });
 113   ASSERT_THAT_EXPECTED(expected_handles, llvm::Succeeded());
 114
 115   auto connect_socket_up = std::make_unique<DomainSocket>(
 116       /*should_close=*/true, /*child_process_inherit=*/false);
 117   ASSERT_THAT_ERROR(connect_socket_up->Connect(Path).ToError(),
 118                     llvm::Succeeded());
 119   ASSERT_TRUE(connect_socket_up->IsValid());
 120
 121   loop.Run();
 122   ASSERT_TRUE(accepted_socket_up);
 123   ASSERT_TRUE(accepted_socket_up->IsValid());
 124 }
 125 #endif
 126
 127 TEST_P(SocketTest, TCPListen0ConnectAccept) {
 128   if (!HostSupportsProtocol())
 129     return;
 130   std::unique_ptr<TCPSocket> socket_a_up;
 131   std::unique_ptr<TCPSocket> socket_b_up;
 132   CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
 133                             &socket_b_up);
 134 }
 135
 136 TEST_P(SocketTest, TCPMainLoopAccept) {
 137   if (!HostSupportsProtocol())
 138     return;
 139
 140   const bool child_processes_inherit = false;
 141   auto listen_socket_up =
 142       std::make_unique<TCPSocket>(true, child_processes_inherit);
 143   Status error = listen_socket_up->Listen(
 144       llvm::formatv("[{0}]:0", GetParam().localhost_ip).str(), 5);
 145   ASSERT_THAT_ERROR(error.ToError(), llvm::Succeeded());
 146   ASSERT_TRUE(listen_socket_up->IsValid());
 147
 148   MainLoop loop;
 149   std::unique_ptr<Socket> accepted_socket_up;
 150   auto expected_handles = listen_socket_up->Accept(
 151       loop, [&accepted_socket_up, &loop](std::unique_ptr<Socket> sock_up) {
 152         accepted_socket_up = std::move(sock_up);
 153         loop.RequestTermination();
 154       });
 155   ASSERT_THAT_EXPECTED(expected_handles, llvm::Succeeded());
 156
 157   std::unique_ptr<TCPSocket> connect_socket_up(
 158       new TCPSocket(true, child_processes_inherit));
 159   ASSERT_THAT_ERROR(
 160       connect_socket_up
 161           ->Connect(llvm::formatv("[{0}]:{1}", GetParam().localhost_ip,
 162                                   listen_socket_up->GetLocalPortNumber())
 163                         .str())
 164           .ToError(),
 165       llvm::Succeeded());
 166   ASSERT_TRUE(connect_socket_up->IsValid());
 167
 168   loop.Run();
 169   ASSERT_TRUE(accepted_socket_up);
 170   ASSERT_TRUE(accepted_socket_up->IsValid());
 171 }
 172
 173 TEST_P(SocketTest, TCPGetAddress) {
 174   std::unique_ptr<TCPSocket> socket_a_up;
 175   std::unique_ptr<TCPSocket> socket_b_up;
 176   if (!HostSupportsProtocol())
 177     return;
 178   CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
 179                             &socket_b_up);
 180
 181   EXPECT_EQ(socket_a_up->GetLocalPortNumber(),
 182             socket_b_up->GetRemotePortNumber());
 183   EXPECT_EQ(socket_b_up->GetLocalPortNumber(),
 184             socket_a_up->GetRemotePortNumber());
 185   EXPECT_NE(socket_a_up->GetLocalPortNumber(),
 186             socket_b_up->GetLocalPortNumber());
 187   EXPECT_STREQ(GetParam().localhost_ip.c_str(),
 188                socket_a_up->GetRemoteIPAddress().c_str());
 189   EXPECT_STREQ(GetParam().localhost_ip.c_str(),
 190                socket_b_up->GetRemoteIPAddress().c_str());
 191 }
 192
 193 TEST_P(SocketTest, UDPConnect) {
 194   // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
 195   if (!HostSupportsIPv4())
 196     return;
 197   llvm::Expected<std::unique_ptr<UDPSocket>> socket =
 198       UDPSocket::Connect("127.0.0.1:0", /*child_processes_inherit=*/false);
 199
 200   ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
 201   EXPECT_TRUE(socket.get()->IsValid());
 202 }
 203
 204 TEST_P(SocketTest, TCPListen0GetPort) {
 205   if (!HostSupportsIPv4())
 206     return;
 207   llvm::Expected<std::unique_ptr<TCPSocket>> sock =
 208       Socket::TcpListen("10.10.12.3:0", false);
 209   ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
 210   ASSERT_TRUE(sock.get()->IsValid());
 211   EXPECT_NE(sock.get()->GetLocalPortNumber(), 0);
 212 }
 213
 214 TEST_P(SocketTest, TCPGetConnectURI) {
 215   std::unique_ptr<TCPSocket> socket_a_up;
 216   std::unique_ptr<TCPSocket> socket_b_up;
 217   if (!HostSupportsProtocol())
 218     return;
 219   CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
 220                             &socket_b_up);
 221
 222   std::string uri(socket_a_up->GetRemoteConnectionURI());
 223   EXPECT_EQ((URI{"connect", GetParam().localhost_ip,
 224                  socket_a_up->GetRemotePortNumber(), "/"}),
 225             URI::Parse(uri));
 226 }
 227
 228 TEST_P(SocketTest, UDPGetConnectURI) {
 229   // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
 230   if (!HostSupportsIPv4())
 231     return;
 232   llvm::Expected<std::unique_ptr<UDPSocket>> socket =
 233       UDPSocket::Connect("127.0.0.1:0", /*child_processes_inherit=*/false);
 234   ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
 235
 236   std::string uri = socket.get()->GetRemoteConnectionURI();
 237   EXPECT_EQ((URI{"udp", "127.0.0.1", 0, "/"}), URI::Parse(uri));
 238 }
 239
 240 #if LLDB_ENABLE_POSIX
 241 TEST_P(SocketTest, DomainGetConnectURI) {
 242   llvm::SmallString<64> domain_path;
 243   std::error_code EC =
 244       llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", domain_path);
 245   ASSERT_FALSE(EC);
 246   llvm::sys::path::append(domain_path, "test");
 247
 248   // Skip the test if the $TMPDIR is too long to hold a domain socket.
 249   if (domain_path.size() > 107u)
 250     return;
 251
 252   std::unique_ptr<DomainSocket> socket_a_up;
 253   std::unique_ptr<DomainSocket> socket_b_up;
 254   CreateDomainConnectedSockets(domain_path, &socket_a_up, &socket_b_up);
 255
 256   std::string uri(socket_a_up->GetRemoteConnectionURI());
 257   EXPECT_EQ((URI{"unix-connect", "", std::nullopt, domain_path}),
 258             URI::Parse(uri));
 259
 260   EXPECT_EQ(socket_b_up->GetRemoteConnectionURI(), "");
 261 }
 262 #endif
 263
 264 INSTANTIATE_TEST_SUITE_P(
 265     SocketTests, SocketTest,
 266     testing::Values(SocketTestParams{/*is_ipv6=*/false,
 267                                      /*localhost_ip=*/"127.0.0.1"},
 268                     SocketTestParams{/*is_ipv6=*/true, /*localhost_ip=*/"::1"}),
 269     // Prints "SocketTests/SocketTest.DecodeHostAndPort/ipv4" etc. in test logs.
 270     [](const testing::TestParamInfo<SocketTestParams> &info) {
 271       return info.param.is_ipv6 ? "ipv6" : "ipv4";
 272     });