[lldb/ipv6] Support running lldb tests in an ipv6-only environment.

[rupprecht]

Summary

When running in an ipv6-only environment where AF_INET sockets are not available, many lldb tests (mostly gdb remote tests) fail because things like 127.0.0.1 don't work there.

This change does not use localhost because that may cause slowdown due to slow dns lookups depending on the user's configuration. Instead, try 127.0.0.1 and fallback to ::1 if that doesn't work. For sockets, create an AF_INET socket first and create an AF_INET6 if that doesn't work.

[clayborg]

FYI: we switched away from "localhost" a long time ago due to issues with people having a "localhost" entry in their /etc/hosts folder.

[rupprecht]

In D87333#2262229, @clayborg wrote:

FYI: we switched away from "localhost" a long time ago due to issues with people having a "localhost" entry in their /etc/hosts folder.

I assume you mean people *not* having a "localhost" entry? I didn't even realize that was an option. Yes, this patch would break that. I'll have to take another approach, then.

Do you happen to have any references (bugs etc.) for those kinds of issues?

[clayborg]

In D87333#2262236, @rupprecht wrote:

In D87333#2262229, @clayborg wrote:

FYI: we switched away from "localhost" a long time ago due to issues with people having a "localhost" entry in their /etc/hosts folder.

I assume you mean people *not* having a "localhost" entry?

I believe the issue was with people having a modified version that replaces localhost with some other IP address.

I didn't even realize that was an option. Yes, this patch would break that. I'll have to take another approach, then.

You might check the "git log" on any files that have "127.0.0.1" in them for details.

Do you happen to have any references (bugs etc.) for those kinds of issues?

[rupprecht]

In D87333#2262241, @clayborg wrote:

In D87333#2262236, @rupprecht wrote:

In D87333#2262229, @clayborg wrote:

FYI: we switched away from "localhost" a long time ago due to issues with people having a "localhost" entry in their /etc/hosts folder.

I assume you mean people *not* having a "localhost" entry?

I believe the issue was with people having a modified version that replaces localhost with some other IP address.

I didn't even realize that was an option. Yes, this patch would break that. I'll have to take another approach, then.

You might check the "git log" on any files that have "127.0.0.1" in them for details.

Do you happen to have any references (bugs etc.) for those kinds of issues?

Looks like rLLDB202424 is the patch that did most of this. There may be more context in rdar://problem/16154630 but I don't have access to that.

[JDevlieghere]

In D87333#2262260, @rupprecht wrote:

In D87333#2262241, @clayborg wrote:

In D87333#2262236, @rupprecht wrote:

In D87333#2262229, @clayborg wrote:

FYI: we switched away from "localhost" a long time ago due to issues with people having a "localhost" entry in their /etc/hosts folder.

I assume you mean people *not* having a "localhost" entry?

I believe the issue was with people having a modified version that replaces localhost with some other IP address.

I didn't even realize that was an option. Yes, this patch would break that. I'll have to take another approach, then.

You might check the "git log" on any files that have "127.0.0.1" in them for details.

Do you happen to have any references (bugs etc.) for those kinds of issues?

Looks like rLLDB202424 is the patch that did most of this. There may be more context in rdar://problem/16154630 but I don't have access to that.

Not a lot of context in that radar. Greg wrote:

Anyone who was able to previously reproduce this issue by having DNS lookups on "localhost" take more than 3 seconds should no longer see this issue because we are now using "127.0.0.1" which will just get parsed as 4 numbers, not as a "lookup this name in a DNS registry".

[rupprecht]

• Don't use "localhost" to avoid dns latency. Instead, prefer either 127.0.0.1 or ::1 directly.

[rupprecht]

• clang-format

[rupprecht]

This is ready for review now after scrubbing out the "localhost" changes I had earlier.

[clayborg]

Thanks for the extra work arounds! LGTM. Pavel?

[labath]

(Sorry about the delay.) Given the current requirements, I think this patch is fine (excellent even).

That said, I'm not sure whether the original motivation for this requirement (avoiding dns lookups) is still relevant. These days, we communicate with the local debug server via socketpair(2) sockets (which wasn't the case back then), which does not require any dns lookups and is immune to a misconfigured hosts file.

Given that none of the things touched by this patch is extremely critical (GDBRemoteCommunication::ConnectLocally is used for reproducers and the rest is test code), maybe we could use this to test the water and see whether we can start using the network stack the way it's supposed to be used ?

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1243

Nit: I believe the std::make_error_code call is redundant (direct comparison to the enum should work fine).

[rupprecht]

• Compare directly against the error code instead of hopping through std::make_error_code()

[rupprecht]

In D87333#2273506, @labath wrote:

(Sorry about the delay.) Given the current requirements, I think this patch is fine (excellent even).

That said, I'm not sure whether the original motivation for this requirement (avoiding dns lookups) is still relevant. These days, we communicate with the local debug server via socketpair(2) sockets (which wasn't the case back then), which does not require any dns lookups and is immune to a misconfigured hosts file.

The initial dns lookup may still fail, I think? e.g. my initial version of this patch had:

if (llvm::Error error =
        listen_socket.Listen("localhost:0", backlog).ToError())

If the hosts file has a bad value for localhost, that will create a bad socket. That said, I don't know how to reproduce the original issue -- maybe it isn't an issue for some other reason.

Given that none of the things touched by this patch is extremely critical (GDBRemoteCommunication::ConnectLocally is used for reproducers and the rest is test code), maybe we could use this to test the water and see whether we can start using the network stack the way it's supposed to be used ?

Many non-reproducers tests fail w/o the change to GDBRemoteCommunication::ConnectLocally, so it's at least used outside of that.

I can go either way with using localhost or using hard-coded localhost IPs. Whichever way we go, I have a slight preference for keeping the tests and code consistent, e.g. if we use hard-coded IPs in code linked into lldb to allow people with a bad hosts file to use lldb, we should use hard-coded IPs in the tests to allow those same users to develop on lldb.

[rupprecht]

• Switch back to using localhost for non-socket uses

[rupprecht]

In D87333#2274572, @rupprecht wrote:

In D87333#2273506, @labath wrote:

(Sorry about the delay.) Given the current requirements, I think this patch is fine (excellent even).

That said, I'm not sure whether the original motivation for this requirement (avoiding dns lookups) is still relevant. These days, we communicate with the local debug server via socketpair(2) sockets (which wasn't the case back then), which does not require any dns lookups and is immune to a misconfigured hosts file.

The initial dns lookup may still fail, I think? e.g. my initial version of this patch had:

if (llvm::Error error =
        listen_socket.Listen("localhost:0", backlog).ToError())

If the hosts file has a bad value for localhost, that will create a bad socket. That said, I don't know how to reproduce the original issue -- maybe it isn't an issue for some other reason.

Given that none of the things touched by this patch is extremely critical (GDBRemoteCommunication::ConnectLocally is used for reproducers and the rest is test code), maybe we could use this to test the water and see whether we can start using the network stack the way it's supposed to be used ?

Many non-reproducers tests fail w/o the change to GDBRemoteCommunication::ConnectLocally, so it's at least used outside of that.

I can go either way with using localhost or using hard-coded localhost IPs. Whichever way we go, I have a slight preference for keeping the tests and code consistent, e.g. if we use hard-coded IPs in code linked into lldb to allow people with a bad hosts file to use lldb, we should use hard-coded IPs in the tests to allow those same users to develop on lldb.

Switched back to the original approach of using localhost when possible [1], though I still have the git branch so I can always switch back. I don't have a personal preference either way, but would like to land one of the two approaches as this creates a strange amount of test flakiness internally when we need to support ipv4.

[1] IIUC, when connecting via hostname, attempting "localhost" will try both AF_INET and AF_INET6, but there is no corresponding way to construct a raw socket with automatic fallback to AF_INET6 if AF_INET does not work, so that part is the same as before (try to create AF_INET and catch the error manually)

[clayborg]

I am fine with trying "localhost" and seeing if we run into any issues. Hopefully slow DNS isn't a problem anymore on Macs. Everyone else ok?

[labath]

Sorry about the delay.

In D87333#2293266, @clayborg wrote:

I am fine with trying "localhost" and seeing if we run into any issues. Hopefully slow DNS isn't a problem anymore on Macs. Everyone else ok?

Sounds good to me. I'm mainly hoping that with the use of socketpair(2), the DNS will not be on the critical path anymore.

In D87333#2274572, @rupprecht wrote:

Many non-reproducers tests fail w/o the change to GDBRemoteCommunication::ConnectLocally, so it's at least used outside of that.

Well... it is used in a bunch of tests exercising the socket functionality, but these are just tests. The only production usage is in reproducers. Which makes total sense when you think about it -- why would anyone be creating a socket for communicating within the same process -- there are much simpler ways to do that.

In D87333#2291317, @rupprecht wrote:

[1] IIUC, when connecting via hostname, attempting "localhost" will try both AF_INET and AF_INET6, but there is no corresponding way to construct a raw socket with automatic fallback to AF_INET6 if AF_INET does not work, so that part is the same as before (try to create AF_INET and catch the error manually)

The fully generic way to handle this would be to loop over getaddrinfo("localhost") and try to listen on each address that returns (multiple sockets). That is at least for the case when you don't know who is going to connect to you. For tests, it should be sufficient to pick a first address that works and use that.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def _verify_socket(self, sock):
             return  # Not android.
         can_read, _, _ = select.select([sock], [], [], 0.1)
         if sock not in can_read:
             return  # Data is not available, but the connection is alive.
         if len(sock.recv(1, socket.MSG_PEEK)) == 0:
             raise _ConnectionRefused()  # Got EOF, connection dropped.
 
     def create_socket(self):
-        sock = socket.socket()
+        try:
+            sock = socket.socket(family=socket.AF_INET)
+        except OSError as e:
+            if e.errno != errno.EAFNOSUPPORT:
+                raise
+            sock = socket.socket(family=socket.AF_INET6)
+
         logger = self.logger
 
         triple = self.dbg.GetSelectedPlatform().GetTriple()
         if re.match(".*-.*-.*-android", triple):
             self.forward_adb_port(
                 self.port,
                 self.port,
                 "forward",
def set_inferior_startup_attach_manually(self):
         self._inferior_startup = self._STARTUP_ATTACH_MANUALLY
 
     def get_debug_monitor_command_line_args(self, attach_pid=None):
         if lldb.remote_platform:
             commandline_args = self.debug_monitor_extra_args + \
                 ["*:{}".format(self.port)]
         else:
             commandline_args = self.debug_monitor_extra_args + \
-                ["127.0.0.1:{}".format(self.port)]
+                ["localhost:{}".format(self.port)]
 
         if attach_pid:
             commandline_args += ["--attach=%d" % attach_pid]
         if self.named_pipe_path:
             commandline_args += ["--named-pipe", self.named_pipe_path]
         return commandline_args
 
     def get_target_byte_order(self):

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 
 llvm::Error
 GDBRemoteCommunication::ConnectLocally(GDBRemoteCommunication &client,
                                        GDBRemoteCommunication &server) {
   const bool child_processes_inherit = false;
   const int backlog = 5;
   TCPSocket listen_socket(true, child_processes_inherit);
   if (llvm::Error error =
-          listen_socket.Listen("127.0.0.1:0", backlog).ToError())
+          listen_socket.Listen("localhost:0", backlog).ToError())
     return error;
 
   Socket *accept_socket;
   std::future<Status> accept_status = std::async(
       std::launch::async, [&] { return listen_socket.Accept(accept_socket); });
 
   llvm::SmallString<32> remote_addr;
   llvm::raw_svector_ostream(remote_addr)
-      << "connect://127.0.0.1:" << listen_socket.GetLocalPortNumber();
+      << "connect://localhost:" << listen_socket.GetLocalPortNumber();
 
   std::unique_ptr<ConnectionFileDescriptor> conn_up(
       new ConnectionFileDescriptor());
   Status status;
   if (conn_up->Connect(remote_addr, &status) != lldb::eConnectionStatusSuccess)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Unable to connect: %s", status.AsCString());
 

lldb/test/API/functionalities/gdb_remote_client/gdbclientutils.py

+import errno
 import os
 import os.path
 import threading
 import socket
 import lldb
 import binascii
 import traceback
 from lldbsuite.support import seven
class MockGDBServer:
     _thread = None
     _receivedData = None
     _receivedDataOffset = None
     _shouldSendAck = True
 
     def __init__(self, port = 0):
         self.responder = MockGDBServerResponder()
         self.port = port
-        self._socket = socket.socket()
+        try:
+            self._socket = socket.socket(family=socket.AF_INET)
+        except OSError as e:
+            if e.errno != errno.EAFNOSUPPORT:
+                raise
+            self._socket = socket.socket(family=socket.AF_INET6)
 
     def start(self):
         # Block until the socket is up, so self.port is available immediately.
         # Then start a thread that waits for a client connection.
+        if self._socket.family == socket.AF_INET:
             addr = ("127.0.0.1", self.port)
+        elif self._socket.family == socket.AF_INET6:
+            addr = ("::1", self.port)
         self._socket.bind(addr)
         self.port = self._socket.getsockname()[1]
         self._socket.listen(1)
         self._thread = threading.Thread(target=self._run)
         self._thread.start()
 
     def stop(self):
         self._socket.close()

lldb/test/API/tools/lldb-server/commandline/TestStubReverseConnect.py

 from __future__ import print_function
 
+import errno
 import gdbremote_testcase
 import lldbgdbserverutils
 import re
 import select
 import socket
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Set up the test.
         gdbremote_testcase.GdbRemoteTestCaseBase.setUp(self)
 
         # Create a listener on a local port.
         self.listener_socket = self.create_listener_socket()
         self.assertIsNotNone(self.listener_socket)
         self.listener_port = self.listener_socket.getsockname()[1]
 
     def create_listener_socket(self):
+        try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        except OSError as e:
+            if e.errno != errno.EAFNOSUPPORT:
+                raise
+            sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
         self.assertIsNotNone(sock)
 
         sock.settimeout(self.DEFAULT_TIMEOUT)
-        sock.bind(("127.0.0.1", 0))
+        if sock.family == socket.AF_INET:
+            bind_addr = ("127.0.0.1", 0)
+        elif sock.family == socket.AF_INET6:
+            bind_addr = ("::1", 0)
+        sock.bind(bind_addr)
         sock.listen(1)
 
         def tear_down_listener():
             try:
                 sock.shutdown(socket.SHUT_RDWR)
             except:
                 # ignore
                 None

lldb/tools/lldb-server/lldb-gdbserver.cpp

#endif
     uint32_t connection_portno = 0;
 
     // If host_and_port starts with ':', default the host to be "localhost" and
     // expect the remainder to be the port.
     if (host_and_port[0] == ':')
       final_host_and_port.append("localhost");
     final_host_and_port.append(host_and_port);
 
-    const std::string::size_type colon_pos = final_host_and_port.find(':');
+    // Note: use rfind, because the host/port may look like "[::1]:12345".
+    const std::string::size_type colon_pos = final_host_and_port.rfind(':');
     if (colon_pos != std::string::npos) {
       connection_host = final_host_and_port.substr(0, colon_pos);
       connection_port = final_host_and_port.substr(colon_pos + 1);
       connection_portno = StringConvert::ToUInt32(connection_port.c_str(), 0);
     }
 
 
     if (reverse_connect) {

lldb/unittests/Host/SocketTest.cpp

 //===-- SocketTest.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SocketTestUtilities.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Utility/UriParser.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
-class SocketTest : public testing::Test {
+struct SocketTestParams {
+  bool is_ipv6;
+  std::string localhost_ip;
+};
+
+class SocketTest : public testing::TestWithParam<SocketTestParams> {
 public:
   SubsystemRAII<Socket> subsystems;
+
+protected:
+  bool HostSupportsProtocol() const {
+    if (GetParam().is_ipv6)
+      return HostSupportsIPv6();
+    return HostSupportsIPv4();
+  }
 };
 
-TEST_F(SocketTest, DecodeHostAndPort) {
+TEST_P(SocketTest, DecodeHostAndPort) {
   std::string host_str;
   std::string port_str;
   int32_t port;
   Status error;
   EXPECT_TRUE(Socket::DecodeHostAndPort("localhost:1138", host_str, port_str,
                                         port, &error));
   EXPECT_STREQ("localhost", host_str.c_str());
   EXPECT_STREQ("1138", port_str.c_str());
EXPECT_TRUE(
       Socket::DecodeHostAndPort("[abcd:12fg:AF58::1]:12345", host_str, port_str, port, &error));
   EXPECT_STREQ("abcd:12fg:AF58::1", host_str.c_str());
   EXPECT_STREQ("12345", port_str.c_str());
   EXPECT_EQ(12345, port);
   EXPECT_TRUE(error.Success());
 }
 
 #if LLDB_ENABLE_POSIX
-TEST_F(SocketTest, DomainListenConnectAccept) {
+TEST_P(SocketTest, DomainListenConnectAccept) {
   llvm::SmallString<64> Path;
   std::error_code EC = llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", Path);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(Path, "test");
 
   // Skip the test if the $TMPDIR is too long to hold a domain socket.
   if (Path.size() > 107u)
     return;
 
   std::unique_ptr<DomainSocket> socket_a_up;
   std::unique_ptr<DomainSocket> socket_b_up;
   CreateDomainConnectedSockets(Path, &socket_a_up, &socket_b_up);
 }
 #endif
 
-TEST_F(SocketTest, TCPListen0ConnectAccept) {
+TEST_P(SocketTest, TCPListen0ConnectAccept) {
+  if (!HostSupportsProtocol())
+    return;
   std::unique_ptr<TCPSocket> socket_a_up;
   std::unique_ptr<TCPSocket> socket_b_up;
-  CreateTCPConnectedSockets("127.0.0.1", &socket_a_up, &socket_b_up);
+  CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
+                            &socket_b_up);
 }
 
-TEST_F(SocketTest, TCPGetAddress) {
+TEST_P(SocketTest, TCPGetAddress) {
   std::unique_ptr<TCPSocket> socket_a_up;
   std::unique_ptr<TCPSocket> socket_b_up;
-  if (!HostSupportsIPv4())
+  if (!HostSupportsProtocol())
     return;
-  CreateTCPConnectedSockets("127.0.0.1", &socket_a_up, &socket_b_up);
+  CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
+                            &socket_b_up);
 
   EXPECT_EQ(socket_a_up->GetLocalPortNumber(),
             socket_b_up->GetRemotePortNumber());
   EXPECT_EQ(socket_b_up->GetLocalPortNumber(),
             socket_a_up->GetRemotePortNumber());
   EXPECT_NE(socket_a_up->GetLocalPortNumber(),
             socket_b_up->GetLocalPortNumber());
-  EXPECT_STREQ("127.0.0.1", socket_a_up->GetRemoteIPAddress().c_str());
-  EXPECT_STREQ("127.0.0.1", socket_b_up->GetRemoteIPAddress().c_str());
+  EXPECT_STREQ(GetParam().localhost_ip.c_str(),
+               socket_a_up->GetRemoteIPAddress().c_str());
+  EXPECT_STREQ(GetParam().localhost_ip.c_str(),
+               socket_b_up->GetRemoteIPAddress().c_str());
 }
 
-TEST_F(SocketTest, UDPConnect) {
+TEST_P(SocketTest, UDPConnect) {
+  // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
+  if (!HostSupportsIPv4())
+    return;
   llvm::Expected<std::unique_ptr<UDPSocket>> socket =
       UDPSocket::Connect("127.0.0.1:0", /*child_processes_inherit=*/false);
 
   ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
   EXPECT_TRUE(socket.get()->IsValid());
 }
 
-TEST_F(SocketTest, TCPListen0GetPort) {
+TEST_P(SocketTest, TCPListen0GetPort) {
+  if (!HostSupportsIPv4())
+    return;
   Predicate<uint16_t> port_predicate;
   port_predicate.SetValue(0, eBroadcastNever);
   llvm::Expected<std::unique_ptr<TCPSocket>> sock =
       Socket::TcpListen("10.10.12.3:0", false, &port_predicate);
   ASSERT_THAT_EXPECTED(sock, llvm::Succeeded());
   ASSERT_TRUE(sock.get()->IsValid());
   EXPECT_NE(sock.get()->GetLocalPortNumber(), 0);
 }
 
-TEST_F(SocketTest, TCPGetConnectURI) {
+TEST_P(SocketTest, TCPGetConnectURI) {
   std::unique_ptr<TCPSocket> socket_a_up;
   std::unique_ptr<TCPSocket> socket_b_up;
-  if (!HostSupportsIPv4())
+  if (!HostSupportsProtocol())
     return;
-  CreateTCPConnectedSockets("127.0.0.1", &socket_a_up, &socket_b_up);
+  CreateTCPConnectedSockets(GetParam().localhost_ip, &socket_a_up,
+                            &socket_b_up);
 
   llvm::StringRef scheme;
   llvm::StringRef hostname;
   int port;
   llvm::StringRef path;
   std::string uri(socket_a_up->GetRemoteConnectionURI());
   EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
   EXPECT_EQ(scheme, "connect");
   EXPECT_EQ(port, socket_a_up->GetRemotePortNumber());
 }
 
-TEST_F(SocketTest, UDPGetConnectURI) {
+TEST_P(SocketTest, UDPGetConnectURI) {
+  // UDPSocket::Connect() creates sockets with AF_INET (IPv4).
   if (!HostSupportsIPv4())
     return;
   llvm::Expected<std::unique_ptr<UDPSocket>> socket =
       UDPSocket::Connect("127.0.0.1:0", /*child_processes_inherit=*/false);
   ASSERT_THAT_EXPECTED(socket, llvm::Succeeded());
 
   llvm::StringRef scheme;
   llvm::StringRef hostname;
   int port;
   llvm::StringRef path;
   std::string uri = socket.get()->GetRemoteConnectionURI();
   EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
   EXPECT_EQ(scheme, "udp");
 }
 
 #if LLDB_ENABLE_POSIX
-TEST_F(SocketTest, DomainGetConnectURI) {
+TEST_P(SocketTest, DomainGetConnectURI) {
   llvm::SmallString<64> domain_path;
   std::error_code EC =
       llvm::sys::fs::createUniqueDirectory("DomainListenConnectAccept", domain_path);
   ASSERT_FALSE(EC);
   llvm::sys::path::append(domain_path, "test");
 
   // Skip the test if the $TMPDIR is too long to hold a domain socket.
   if (domain_path.size() > 107u)
     return;
 
   std::unique_ptr<DomainSocket> socket_a_up;
   std::unique_ptr<DomainSocket> socket_b_up;
   CreateDomainConnectedSockets(domain_path, &socket_a_up, &socket_b_up);
 
   llvm::StringRef scheme;
   llvm::StringRef hostname;
   int port;
   llvm::StringRef path;
   std::string uri(socket_a_up->GetRemoteConnectionURI());
   EXPECT_TRUE(UriParser::Parse(uri, scheme, hostname, port, path));
   EXPECT_EQ(scheme, "unix-connect");
   EXPECT_EQ(path, domain_path);
 }
 #endif
+
+INSTANTIATE_TEST_CASE_P(
+    SocketTests, SocketTest,
+    testing::Values(SocketTestParams{/*is_ipv6=*/false,
+                                     /*localhost_ip=*/"127.0.0.1"},
+                    SocketTestParams{/*is_ipv6=*/true, /*localhost_ip=*/"::1"}),
+    // Prints "SocketTests/SocketTest.DecodeHostAndPort/ipv4" etc. in test logs.
+    [](const testing::TestParamInfo<SocketTestParams> &info) {
+      return info.param.is_ipv6 ? "ipv6" : "ipv4";
+    });

lldb/unittests/Host/SocketTestUtilities.cpp

llvm::Expected<std::unique_ptr<TCPSocket>> Sock = Socket::TcpListen(
       Addr, /*child_processes_inherit=*/false, /*predicate=*/nullptr);
   if (Sock)
     return true;
   llvm::Error Err = Sock.takeError();
   GTEST_LOG_(WARNING) << llvm::formatv(
                              "Creating a canary {0} TCP socket failed: {1}.",
                              Proto, Err)
                              .str();
-  bool HasAddrNotAvail = false;
+  bool HasProtocolError = false;
   handleAllErrors(std::move(Err), [&](std::unique_ptr<llvm::ECError> ECErr) {
-    if (ECErr->convertToErrorCode() ==
-        std::make_error_code(std::errc::address_not_available))
-      HasAddrNotAvail = true;
+    std::error_code ec = ECErr->convertToErrorCode();
+    if (ec == std::make_error_code(std::errc::address_family_not_supported) ||
+        ec == std::make_error_code(std::errc::address_not_available))
+      HasProtocolError = true;
   });
-  if (HasAddrNotAvail) {
+  if (HasProtocolError) {
     GTEST_LOG_(WARNING)
         << llvm::formatv(
                "Assuming the host does not support {0}. Skipping test.", Proto)
                .str();
     return false;
   }
   GTEST_LOG_(WARNING) << "Continuing anyway. The test will probably fail.";
   return true;