Update LLDB Host to support IPv6 over TCP

[beanz]

Summary

This patch adds IPv6 support to LLDB/Host's TCP socket implementation. Supporting IPv6 involved a few significant changes to the implementation of the socket layers, and I have performed some significant code cleanup along the way.

This patch changes the Socket constructors for all types of sockets to not create sockets until first use. This is required for IPv6 support because the socket type will vary based on the address you are connecting to. This also has the benefit of removing code that could have errors from the Socket subclass constructors (which seems like a win to me).

The patch also slightly changes the API and behaviors of the Listen/Accept pattern. Previously both Listen and Accept calls took an address specified as a string. Now only listen does. This change was made because the Listen call can result in opening more than one socket. In order to support listening for both IPv4 and IPv6 connections we need to open one AF_INET socket and one AF_INET6 socket. During the listen call we construct a map of file descriptors to addrin structures which represent the allowable incoming connection address. This map removes the need for taking an address into the Accept call.

This does have a change in functionality. Previously you could Listen for connections based on one address, and Accept connections from a different address. This is no longer supported. I could not find anywhere in LLDB where we actually used the APIs in that way. The new API does still support AnyAddr for allowing incoming connections from any address.

The Listen implementation is implemented using kqueue on FreeBSD and Darwin, WSAPoll on Windows and poll(2) everywhere else.

[labath]

When I created the MainLoop class, i was hoping it would become the central place for all select-like functionality. Currently it uses pselect, but i don't see a reason we couldn't switch it to ppoll (but we actually don't have to, as the current implementation should work just fine for your use case). We also can-but-don't-have-to provide a specialized kevent-based implementation for mac&freebsd (afaict, kevent also supports listening for signals, but i would be fine with leaving that out even, as we don't need that functionality on these platforms). So all that needs to be added is a WSAPoll-based MainLoopWindows.

Then your Listen implementation would boil down to:

for (auto socket: sockets)
  handles.emplace_back(loop.RegisterReadObject(socket, [&] { accepted = accept(socket, ...); loop.RequestTermination(); });
loop.Run();

I'm not married to the current MainLoop interface in any way, so we can change it if you find the current one cumbersome, but I would like to cut down the number of selecting pieces of code.

What do you think about that?

source/Host/common/TCPSocket.cpp

284

Why not simply use infinite timeout if that's the behaviour you desire?

[zturner]

Networking isn't my area of domain expertise, so these are mostly just general comments.

include/lldb/Host/common/TCPSocket.h

55

Any particular reason you're using a std::map instead of a DenseMap or other similar LLVM structure? I was under the impression that the number of times where you should actually use std::map are pretty small.

source/Host/common/Socket.cpp

86

Is this ever set to false anywhere? If not, just delete the parameter.

Also, since you're in this code anyway, maybe you could use llvm::make_unique.

150

The parameters look reversed here.

260

Makes me wish we had StringRef::shrink(int N). Oh well, this is fine.

source/Host/common/TCPSocket.cpp

29

Can you use LLVM_ON_WIN32?

60

!m_listen_sockets.empty()

116

Should we perhaps assert here? Seems like creating 2 sockets back to back without cleaning up after yourself is not intended behavior. The owner of a socket should probably close it before they try to create a new one, and an assert(!IsValid()) would catch that.

194

LLVM_ON_WIN32.

Also can you raise this up into something like this:

#if defined(LLVM_ON_WIN32)
  #define CLOSE_SOCKET ::closesocket
#else
  #define CLOSE_SOCKET ::close
#endif

Then just write CLOSE_SOCKET(fd);

217

Use CLOSE_SOCKET macro from earlier.

250

Can you add sock_set.reserve(m_listen_sockets.size())?

284

Similar to before, you could add a #define POLL_SOCKET ...

318

CLOSE_SOCKET(fd)

323–326

llvm::errs() << formatv("error: rejecting incoming connection from {0} (expecting {1})", AcceptAddr.GetIPAddress(), AddrIn.GetIPAddress());

330

make_unique

source/Host/common/UDPSocket.cpp

125

This seems odd. Does return Error(g_not_supported_error) not work?

145–146

make_unique again.

[beanz]

@labath, I could adapt this into the MainLoop class, but I would actually want to change how that class hierarchy is implemented. Regardless of the event handling/polling model you use much of the code is identical between the classes. I'd rather get rid of MainLoopPosix and MainLoopBase and instead just implement a portable MainLoop class.

In particular the difference between Windows WSAPoll and posix poll(2) is the name of two functions, which makes the idea of having separate Windows and Posix implementations just seem overly complicated to me, although neither Darwin nor Windows have ppoll because it isn't POSIX, and Windows doesn't have pselect, so there isn't a remotely portable way to wait on file descriptors and signals... This is why we can't have nice things.

I'm going to dig into the MainLoop code. At first glance I do think that is a better way to fit this all together, but I'm going to need to think on it and experiment a bit.

[jasonmolenda]

Looks good. I'd recommend adding clayborg as a reviewer and giving him a couple days to comment on this if he has time. He wrote all of this code originally.

include/lldb/Host/common/TCPSocket.h

55

llvm docs say, "Also, because DenseMap allocates space for a large number of key/value pairs (it starts with 64 by default), it will waste a lot of space if your keys or values are large." I think std::map is the right choice. When it's a tossup between an llvm container class and an STL container class, my opinion is always to go with the standard container class that everyone is familiar with already. If there's a distinct benefit to a given llvm container class for a specific scenario, that's fine, but it just increases the barrier to entry for people outside the llvm community to use these classes pervasively.

source/Host/common/Socket.cpp

258

Ah, I'd originally said I thought we should just tack the :portnum on to the end of the string, search backwards to find it (because the [] characters are metacharacters in unix shells). but I see that RFC8986 says this is how things like this are specified, like http://[2001:db8:1f70::999:de8:7648:6e8]:100/ so cool with that.

[zturner]

include/lldb/Host/common/TCPSocket.h

55

I was under the impression SocketAddress was fairly small, but I checked and it turns out it's not. That said, I *still* don't think std::map is the right choice, because there is std::unordered_map which is more efficient when iterating over keys in sorted order is not a requirement.

In fact, I'm not even sure any kind of map is needed. Isn't the point of this just to allow listening on an IPv4 interface and an IPv6 interface at the same time? If so, the most common use case is either going to be 1 item in the map or 2 items in the map, in which case perhaps a SmallVector<std::pair<int, SocketAddress>, 2> is better.

[labath]

In D31823#724334, @beanz wrote:

@labath, I could adapt this into the MainLoop class, but I would actually want to change how that class hierarchy is implemented. Regardless of the event handling/polling model you use much of the code is identical between the classes. I'd rather get rid of MainLoopPosix and MainLoopBase and instead just implement a portable MainLoop class.

In particular the difference between Windows WSAPoll and posix poll(2) is the name of two functions, which makes the idea of having separate Windows and Posix implementations just seem overly complicated to me, although neither Darwin nor Windows have ppoll because it isn't POSIX, and Windows doesn't have pselect, so there isn't a remotely portable way to wait on file descriptors and signals... This is why we can't have nice things.

One extra thing you should be aware of is that unlike poll(2), WSAPoll only works on sockets. We currently have pieces of code ifdef-ed out on windows because we have no way to wait on pipes, and eventually I'd like to teach the MainLoop to do that as well. I'm not saying we should do that now, just pointing out that the implementations are likely to diverge in the future.

However, if you think that for the current minimal requirements (sockets on windows, signals and file descriptors on linux and netbsd, and file descriptors everywhere else) the cleanest implementation is a single class, then that's fine with me. We can revisit that decision when the need comes up.

[beanz]

Adding Greg to the reviewers list.

[beanz]

Updating to use MainLoop class, and refactor MainLoop class to operate on Windows.

I've added error cases to the MainLoop class for functionality that is not supported. Specifically non-socket IOObjects are not supported on Windows, and signal handling requires either kqueue or ppoll. In practice that means signal handling is not supported on Windows, older Linux OSs and some BSD variants. That is all controlled by proper configure-time checks.

[labath]

Thank you for taking the time to do this.

It looks like ppoll was added to linux quite a long time ago, but we still get some patches supporting surprisingly old kernels. I hope it doesn't come do that, but if it does, we can easily add a pselect-based fallback as well.

looks good, assuming that the SYS_EVENT_H define can go away.

source/Host/common/MainLoop.cpp

22 ↗

(On Diff #95355)

This looks wrong. Is this left over from testing ?

241 ↗

(On Diff #95355)

Nit: the if could be extracted out of the #ifdef

[beanz]

Updating patches to reflect feedback from zturner.

[beanz]

Removing code I accidentally left in that was from debugging, and moving some duplicated code that @labath spotted out of the ifdef.

[clayborg]

I'm good if Pavel is good.

[labath]

It looks like you had a fun day yesterday. :) Unfortunately, I have to add to your problems, as I've had to revert your commit due to a fairly big problem.

The problem that it can happen that the create-a-bunch-of-listening-sockets loop can sometimes only create an ipv6 socket if the respective ipv4 port is used by another process. Then the connecting side will try to connect to the IPv4 port and fail. I am not really sure what would be the best fix for this, but right now this is making our test suite completely unusable...

There was also an issue with not detecting ppoll properly, but that one was easy to fix.

I am sorry, I should have caught this earlier, but you seemed so certain of what you are doing that I did not bother trying to test the patch... :/

lldb/trunk/cmake/modules/LLDBConfig.cmake

435 ↗

(On Diff #95616)

This needs set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE) to detect ppoll on linux.

lldb/trunk/source/Host/common/TCPSocket.cpp

189 ↗

(On Diff #95616)

This has no effect now as we are not listening on the file descriptor internal to this object.

[krytarowski]

Fix from pkgsrc-wip to resurrect LLDB Standalone build in SVN r. 300654.

From 3371648af049cb4b40427ef87dcafb4745f10e8d Mon Sep 17 00:00:00 2001
From: Kamil Rytarowski <[e-mail]>
Date: Wed, 19 Apr 2017 06:17:30 +0200
Subject: [PATCH] lldb-netbsd: Upgrade to 300654

This code has FPR and DBR for NetBSD/amd64.

Add local patches to resurrect standalone build

Sponsored by <The NetBSD Foundation>
---
 lldb-netbsd/Makefile                                        |  2 +-
 lldb-netbsd/distinfo                                        |  3 +++
 .../patches/patch-cmake_modules_LLDBStandalone.cmake        | 13 +++++++++++++
 lldb-netbsd/patches/patch-source_Host_common_MainLoop.cpp   | 13 +++++++++++++
 lldb-netbsd/patches/patch-source_Host_common_TCPSocket.cpp  | 13 +++++++++++++
 5 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 lldb-netbsd/patches/patch-cmake_modules_LLDBStandalone.cmake
 create mode 100644 lldb-netbsd/patches/patch-source_Host_common_MainLoop.cpp
 create mode 100644 lldb-netbsd/patches/patch-source_Host_common_TCPSocket.cpp

diff --git a/lldb-netbsd/Makefile b/lldb-netbsd/Makefile
index 6604b75afe..d92ba960cd 100644
--- a/lldb-netbsd/Makefile
+++ b/lldb-netbsd/Makefile
@@ -5,7 +5,7 @@ CATEGORIES=	lang devel
 
 SVN_REPOSITORIES=	lldb
 SVN_REPO.lldb=		http://llvm.org/svn/llvm-project/lldb/trunk
-SVN_REVISION.lldb=	299783
+SVN_REVISION.lldb=	300654
 
 MAINTAINER=	[e-mail]
 HOMEPAGE=	http://lldb.org/
diff --git a/lldb-netbsd/distinfo b/lldb-netbsd/distinfo
index 9e296857d3..0a1ce52470 100644
--- a/lldb-netbsd/distinfo
+++ b/lldb-netbsd/distinfo
@@ -12,6 +12,9 @@ Size (libcxx-3.6.2.src.tar.xz) = 944020 bytes
 SHA1 (llvm-3.6.2.src.tar.xz) = 7a00257eb2bc9431e4c77c3a36b033072c54bc7e
 RMD160 (llvm-3.6.2.src.tar.xz) = 521cbc5fe2925ea3c6e90c7a31f752a04045c972
 Size (llvm-3.6.2.src.tar.xz) = 12802380 bytes
+SHA1 (patch-cmake_modules_LLDBStandalone.cmake) = c68c9fbe37d7f2d118febf2914b56b551eb5e696
+SHA1 (patch-source_Host_common_MainLoop.cpp) = 66cb4d07a092caac4d271ca4a638406076b5bd81
+SHA1 (patch-source_Host_common_TCPSocket.cpp) = e18a33e66c281cbc1353787752789faf609b21f0
 SHA1 (patch-source_Plugins_ObjectFile_ELF_ObjectFileELF.cpp) = cdc5861eedcc79d3484ba011f5be595b2afcbae2
 SHA1 (patch-source_Plugins_Process_elf-core_ProcessElfCore.cpp) = e8609042fb407f3507ac7cbe00494bbad5a2ca14
 SHA1 (patch-source_Plugins_Process_elf-core_ProcessElfCore.h) = 902ce5e0187aa2649986db08c79af7291b852727
diff --git a/lldb-netbsd/patches/patch-cmake_modules_LLDBStandalone.cmake b/lldb-netbsd/patches/patch-cmake_modules_LLDBStandalone.cmake
new file mode 100644
index 0000000000..4641527762
--- /dev/null
+++ b/lldb-netbsd/patches/patch-cmake_modules_LLDBStandalone.cmake
@@ -0,0 +1,13 @@
+$NetBSD$
+
+--- cmake/modules/LLDBStandalone.cmake.orig	2017-04-19 04:06:59.854088855 +0000
++++ cmake/modules/LLDBStandalone.cmake
+@@ -4,6 +4,8 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURR
+   project(lldb)
+   cmake_minimum_required(VERSION 2.8.12.2)
+ 
++  include(CheckIncludeFile)
++
+   if (POLICY CMP0022)
+     cmake_policy(SET CMP0022 NEW) # automatic when 2.8.12 is required
+   endif()
diff --git a/lldb-netbsd/patches/patch-source_Host_common_MainLoop.cpp b/lldb-netbsd/patches/patch-source_Host_common_MainLoop.cpp
new file mode 100644
index 0000000000..747b039d09
--- /dev/null
+++ b/lldb-netbsd/patches/patch-source_Host_common_MainLoop.cpp
@@ -0,0 +1,13 @@
+$NetBSD$
+
+--- source/Host/common/MainLoop.cpp.orig	2017-04-19 03:59:22.000000000 +0000
++++ source/Host/common/MainLoop.cpp
+@@ -7,7 +7,7 @@
+ //
+ //===----------------------------------------------------------------------===//
+ 
+-#include "llvm/Config/config.h"
++#include "llvm/Config/llvm-config.h"
+ 
+ #include "lldb/Host/MainLoop.h"
+ #include "lldb/Utility/Error.h"
diff --git a/lldb-netbsd/patches/patch-source_Host_common_TCPSocket.cpp b/lldb-netbsd/patches/patch-source_Host_common_TCPSocket.cpp
new file mode 100644
index 0000000000..18f5930997
--- /dev/null
+++ b/lldb-netbsd/patches/patch-source_Host_common_TCPSocket.cpp
@@ -0,0 +1,13 @@
+$NetBSD$
+
+--- source/Host/common/TCPSocket.cpp.orig	2017-04-19 03:59:22.000000000 +0000
++++ source/Host/common/TCPSocket.cpp
+@@ -17,7 +17,7 @@
+ #include "lldb/Host/MainLoop.h"
+ #include "lldb/Utility/Log.h"
+ 
+-#include "llvm/Config/config.h"
++#include "llvm/Config/llvm-config.h"
+ #include "llvm/Support/raw_ostream.h"
+ 
+ #ifndef LLDB_DISABLE_POSIX
-- 
2.11.0

https://wip.pkgsrc.org/cgi-bin/gitweb.cgi?p=pkgsrc-wip.git;a=commitdiff;h=3371648af049cb4b40427ef87dcafb4745f10e8d

[krytarowski]

lldb/trunk/cmake/modules/LLDBConfig.cmake

435 ↗

(On Diff #95616)

check_symbol_exists unrecognized in LLDB Standalone build. There is need to add include(CheckIncludeFile) somewhere in generic or standalone cmake file.

include/lldb/Host/Socket.h

public:
   ~Socket() override;
 
   static std::unique_ptr<Socket> Create(const SocketProtocol protocol,
                                         bool child_processes_inherit,
                                         Error &error);
 
   virtual Error Connect(llvm::StringRef name) = 0;
   virtual Error Listen(llvm::StringRef name, int backlog) = 0;
-  virtual Error Accept(llvm::StringRef name, bool child_processes_inherit,
-                       Socket *&socket) = 0;
+  virtual Error Accept(Socket *&socket) = 0;
 
   // Initialize a Tcp Socket object in listening mode.  listen and accept are
   // implemented
   // separately because the caller may wish to manipulate or query the socket
   // after it is
   // initialized, but before entering a blocking accept.
   static Error TcpListen(llvm::StringRef host_and_port,
                          bool child_processes_inherit, Socket *&socket,
public:
   bool IsValid() const override { return m_socket != kInvalidSocketValue; }
   WaitableHandle GetWaitableHandle() override;
 
   static bool DecodeHostAndPort(llvm::StringRef host_and_port,
                                 std::string &host_str, std::string &port_str,
                                 int32_t &port, Error *error_ptr);
 
 protected:
-  Socket(NativeSocket socket, SocketProtocol protocol, bool should_close);
+  Socket(SocketProtocol protocol, bool should_close,
+         bool m_child_process_inherit);
 
   virtual size_t Send(const void *buf, const size_t num_bytes);
 
   static void SetLastError(Error &error);
   static NativeSocket CreateSocket(const int domain, const int type,
                                    const int protocol,
                                    bool child_processes_inherit, Error &error);
   static NativeSocket AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
                                    socklen_t *addrlen,
                                    bool child_processes_inherit, Error &error);
 
   SocketProtocol m_protocol;
   NativeSocket m_socket;
+  bool m_child_processes_inherit;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Host_Socket_h_

include/lldb/Host/common/TCPSocket.h

 //===-- TCPSocket.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_TCPSocket_h_
 #define liblldb_TCPSocket_h_
 
 #include "lldb/Host/Socket.h"
+#include "lldb/Host/SocketAddress.h"
+#include <map>
 
 namespace lldb_private {
 class TCPSocket : public Socket {
 public:
-  TCPSocket(NativeSocket socket, bool should_close);
-  TCPSocket(bool child_processes_inherit, Error &error);
+  TCPSocket(bool should_close, bool child_processes_inherit);
+  TCPSocket(NativeSocket socket, bool should_close,
+            bool child_processes_inherit);
+  ~TCPSocket();
 
   // returns port number or 0 if error
   uint16_t GetLocalPortNumber() const;
 
   // returns ip address string or empty string if error
   std::string GetLocalIPAddress() const;
 
   // must be connected
   // returns port number or 0 if error
   uint16_t GetRemotePortNumber() const;
 
   // must be connected
   // returns ip address string or empty string if error
   std::string GetRemoteIPAddress() const;
 
   int SetOptionNoDelay();
   int SetOptionReuseAddress();
 
   Error Connect(llvm::StringRef name) override;
   Error Listen(llvm::StringRef name, int backlog) override;
-  Error Accept(llvm::StringRef name, bool child_processes_inherit,
-               Socket *&conn_socket) override;
+  Error Accept(Socket *&conn_socket) override;
+
+  Error CreateSocket(int domain);
+
+  bool IsValid() const override;
+
+private:
+  TCPSocket(NativeSocket socket, const TCPSocket &listen_socket);
+
+  void CloseListenSockets();
+
+  std::map<int, SocketAddress> m_listen_sockets;
 };
 }
 
 #endif // ifndef liblldb_TCPSocket_h_

include/lldb/Host/common/UDPSocket.h

 #ifndef liblldb_UDPSocket_h_
 #define liblldb_UDPSocket_h_
 
 #include "lldb/Host/Socket.h"
 
 namespace lldb_private {
 class UDPSocket : public Socket {
 public:
-  UDPSocket(bool child_processes_inherit, Error &error);
+  UDPSocket(bool should_close, bool child_processes_inherit);
 
   static Error Connect(llvm::StringRef name, bool child_processes_inherit,
                        Socket *&socket);
 
 private:
-  UDPSocket(NativeSocket socket);
+  UDPSocket(NativeSocket socket, const UDPSocket &listen_socket);
 
   size_t Send(const void *buf, const size_t num_bytes) override;
   Error Connect(llvm::StringRef name) override;
   Error Listen(llvm::StringRef name, int backlog) override;
-  Error Accept(llvm::StringRef name, bool child_processes_inherit,
-               Socket *&socket) override;
+  Error Accept(Socket *&socket) override;
+
+  Error CreateSocket();
 
   SocketAddress m_sockaddr;
 };
 }
 
 #endif // ifndef liblldb_UDPSocket_h_

include/lldb/Host/freebsd/Config.h

 #define LLDB_CONFIG_TERMIOS_SUPPORTED 1
 
 #define LLDB_CONFIG_TILDE_RESOLVES_TO_USER 1
 
 //#define LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 1
 
 //#define LLDB_CONFIG_FCNTL_GETPATH_SUPPORTED 1
 
+// FIXME: This should be set by a configure-time check.
+#define HAVE_SYS_EVENT_H 1
+
 #endif // #ifndef liblldb_Platform_Config_h_

include/lldb/Host/linux/AbstractSocket.h

 #ifndef liblldb_AbstractSocket_h_
 #define liblldb_AbstractSocket_h_
 
 #include "lldb/Host/posix/DomainSocket.h"
 
 namespace lldb_private {
 class AbstractSocket : public DomainSocket {
 public:
-  AbstractSocket(bool child_processes_inherit, Error &error);
+  AbstractSocket(bool child_processes_inherit);
 
 protected:
   size_t GetNameOffset() const override;
   void DeleteSocketFile(llvm::StringRef name) override;
 };
 }
 
 #endif // ifndef liblldb_AbstractSocket_h_

include/lldb/Host/macosx/Config.h

 //===-- Config.h -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 //----------------------------------------------------------------------
 // LLDB currently doesn't have a dynamic configuration mechanism, so we
 // are going to hardcode things for now. Eventually these files will
 // be auto generated by some configuration script that can detect
 // platform functionality availability.
 //----------------------------------------------------------------------
 
-#ifndef liblldb_Platform_Config_h_
-#define liblldb_Platform_Config_h_
+#ifndef LLDB_HOST_MACOSX_CONFIG_H
+#define LLDB_HOST_MACOSX_CONFIG_H
 
 #define LLDB_CONFIG_TERMIOS_SUPPORTED 1
 
 #define LLDB_CONFIG_TILDE_RESOLVES_TO_USER 1
 
 #define LLDB_CONFIG_DLOPEN_RTLD_FIRST_SUPPORTED 1
 
 #define LLDB_CONFIG_FCNTL_GETPATH_SUPPORTED 1
 
-#endif // #ifndef liblldb_Platform_Config_h_
+// FIXME: This should be set by a configure-time check.
+#define HAVE_SYS_EVENT_H 1
+
+#endif // LLDB_HOST_MACOSX_CONFIG_H

include/lldb/Host/posix/DomainSocket.h

 #ifndef liblldb_DomainSocket_h_
 #define liblldb_DomainSocket_h_
 
 #include "lldb/Host/Socket.h"
 
 namespace lldb_private {
 class DomainSocket : public Socket {
 public:
-  DomainSocket(bool child_processes_inherit, Error &error);
+  DomainSocket(bool should_close, bool child_processes_inherit);
 
   Error Connect(llvm::StringRef name) override;
   Error Listen(llvm::StringRef name, int backlog) override;
-  Error Accept(llvm::StringRef name, bool child_processes_inherit,
-               Socket *&socket) override;
+  Error Accept(Socket *&socket) override;
 
 protected:
-  DomainSocket(SocketProtocol protocol, bool child_processes_inherit,
-               Error &error);
+  DomainSocket(SocketProtocol protocol, bool child_processes_inherit);
 
   virtual size_t GetNameOffset() const;
   virtual void DeleteSocketFile(llvm::StringRef name);
 
 private:
-  DomainSocket(NativeSocket socket);
+  DomainSocket(NativeSocket socket, const DomainSocket &listen_socket);
 };
 }
 
 #endif // ifndef liblldb_DomainSocket_h_

source/Host/common/Socket.cpp

 #if defined(_WIN32)
   return ::WSAGetLastError() == WSAEINTR;
 #else
   return errno == EINTR;
 #endif
 }
 }
 
-Socket::Socket(NativeSocket socket, SocketProtocol protocol, bool should_close)
+Socket::Socket(SocketProtocol protocol, bool should_close,
+               bool child_processes_inherit)
     : IOObject(eFDTypeSocket, should_close), m_protocol(protocol),
-      m_socket(socket) {}
+      m_socket(kInvalidSocketValue),
+      m_child_processes_inherit(child_processes_inherit) {}
 
 Socket::~Socket() { Close(); }
 
 std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
                                        bool child_processes_inherit,
                                        Error &error) {
   error.Clear();
 
   std::unique_ptr<Socket> socket_up;
   switch (protocol) {
   case ProtocolTcp:
-    socket_up.reset(new TCPSocket(child_processes_inherit, error));
+    socket_up.reset(new TCPSocket(true, child_processes_inherit));
     break;
   case ProtocolUdp:
-    socket_up.reset(new UDPSocket(child_processes_inherit, error));
+    socket_up.reset(new UDPSocket(true, child_processes_inherit));
     break;
   case ProtocolUnixDomain:
 #ifndef LLDB_DISABLE_POSIX
-    socket_up.reset(new DomainSocket(child_processes_inherit, error));
+    socket_up.reset(new DomainSocket(true, child_processes_inherit));
 #else
     error.SetErrorString(
         "Unix domain sockets are not supported on this platform.");
 #endif
     break;
   case ProtocolUnixAbstract:
 #ifdef __linux__
-    socket_up.reset(new AbstractSocket(child_processes_inherit, error));
+    socket_up.reset(new AbstractSocket(true, child_processes_inherit));
 #else
     error.SetErrorString(
         "Abstract domain sockets are not supported on this platform.");
 #endif
     break;
   }
 
   if (error.Fail())
Error Socket::TcpListen(llvm::StringRef host_and_port,
   Error error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
   if (!DecodeHostAndPort(host_and_port, host_str, port_str, port, &error))
     return error;
 
   std::unique_ptr<TCPSocket> listen_socket(
-      new TCPSocket(child_processes_inherit, error));
+      new TCPSocket(child_processes_inherit, true));
   if (error.Fail())
     return error;
 
   error = listen_socket->Listen(host_and_port, backlog);
   if (error.Success()) {
     // We were asked to listen on port zero which means we
     // must now read the actual port that was given to us
     // as port zero is a special code for "find an open port
std::unique_ptr<Socket> listen_socket(
       Create(ProtocolUnixDomain, child_processes_inherit, error));
   if (error.Fail())
     return error;
 
   error = listen_socket->Listen(name, 5);
   if (error.Fail())
     return error;
 
-  error = listen_socket->Accept(name, child_processes_inherit, socket);
+  error = listen_socket->Accept(socket);
   return error;
 }
 
 Error Socket::UnixAbstractConnect(llvm::StringRef name,
                                   bool child_processes_inherit,
                                   Socket *&socket) {
   Error error;
   std::unique_ptr<Socket> connect_socket(
std::unique_ptr<Socket> listen_socket(
       Create(ProtocolUnixAbstract, child_processes_inherit, error));
   if (error.Fail())
     return error;
 
   error = listen_socket->Listen(name, 5);
   if (error.Fail())
     return error;
 
-  error = listen_socket->Accept(name, child_processes_inherit, socket);
+  error = listen_socket->Accept(socket);
   return error;
 }
 
 bool Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
                                std::string &host_str, std::string &port_str,
                                int32_t &port, Error *error_ptr) {
-  static RegularExpression g_regex(llvm::StringRef("([^:]+):([0-9]+)"));
+  static RegularExpression g_regex(
+      llvm::StringRef("([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)"));
   RegularExpression::Match regex_match(2);
   if (g_regex.Execute(host_and_port, &regex_match)) {
     if (regex_match.GetMatchAtIndex(host_and_port.data(), 1, host_str) &&
         regex_match.GetMatchAtIndex(host_and_port.data(), 2, port_str)) {
+      // IPv6 addresses are wrapped in [] when specified with ports
+      if (host_str.front() == '[' && host_str.back() == ']')
+        host_str = host_str.substr(1, host_str.size() - 2);
       bool ok = false;
       port = StringConvert::ToUInt32(port_str.c_str(), UINT32_MAX, 10, &ok);
       if (ok && port <= UINT16_MAX) {
         if (error_ptr)
           error_ptr->Clear();
         return true;
       }
       // port is too large
#else
   error.SetErrorToErrno();
 #endif
 }
 
 NativeSocket Socket::CreateSocket(const int domain, const int type,
                                   const int protocol,
                                   bool child_processes_inherit, Error &error) {
   error.Clear();
-  auto socketType = type;
+  auto socket_type = type;
 #ifdef SOCK_CLOEXEC
   if (!child_processes_inherit)
-    socketType |= SOCK_CLOEXEC;
+    socket_type |= SOCK_CLOEXEC;
 #endif
-  auto sock = ::socket(domain, socketType, protocol);
+  auto sock = ::socket(domain, socket_type, protocol);
   if (sock == kInvalidSocketValue)
     SetLastError(error);
 
   return sock;
 }
 
 NativeSocket Socket::AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
                                   socklen_t *addrlen,

source/Host/common/TCPSocket.cpp

 #include "lldb/Utility/Log.h"
 
 #ifndef LLDB_DISABLE_POSIX
 #include <arpa/inet.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 #endif
 
+// If kqueue(2) is available we prefer that over select(2). I believe that we
+// only have kqueue(2) on Darwin and FreeBSD.
+#if HAVE_SYS_EVENT_H
+#include <sys/event.h>
+#elif defined(_WIN32)
+#include <winsock2.h>
+#else
+#include <poll.h>
+#endif
+
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
-
-const int kDomain = AF_INET;
 const int kType = SOCK_STREAM;
 }
 
-TCPSocket::TCPSocket(NativeSocket socket, bool should_close)
-    : Socket(socket, ProtocolTcp, should_close) {}
+TCPSocket::TCPSocket(bool should_close, bool child_processes_inherit)
+    : Socket(ProtocolTcp, should_close, child_processes_inherit) {}
+
+TCPSocket::TCPSocket(NativeSocket socket, const TCPSocket &listen_socket)
+    : Socket(ProtocolTcp, listen_socket.m_should_close_fd,
+             listen_socket.m_child_processes_inherit) {
+  m_socket = socket;
+}
+
+TCPSocket::TCPSocket(NativeSocket socket, bool should_close,
+                     bool child_processes_inherit)
+    : Socket(ProtocolTcp, should_close, child_processes_inherit) {
+  m_socket = socket;
+}
 
-TCPSocket::TCPSocket(bool child_processes_inherit, Error &error)
-    : TCPSocket(CreateSocket(kDomain, kType, IPPROTO_TCP,
-                             child_processes_inherit, error),
-                true) {}
+TCPSocket::~TCPSocket() { CloseListenSockets(); }
+
+bool TCPSocket::IsValid() const {
+  return m_socket != kInvalidSocketValue || m_listen_sockets.size() != 0;
+}
 
 // Return the port number that is being used by the socket.
 uint16_t TCPSocket::GetLocalPortNumber() const {
   if (m_socket != kInvalidSocketValue) {
     SocketAddress sock_addr;
     socklen_t sock_addr_len = sock_addr.GetMaxLength();
     if (::getsockname(m_socket, sock_addr, &sock_addr_len) == 0)
       return sock_addr.GetPort();
+  } else if (!m_listen_sockets.empty()) {
+    SocketAddress sock_addr;
+    socklen_t sock_addr_len = sock_addr.GetMaxLength();
+    if (::getsockname(m_listen_sockets.begin()->first, sock_addr,
+                      &sock_addr_len) == 0)
+      return sock_addr.GetPort();
   }
   return 0;
 }
 
 std::string TCPSocket::GetLocalIPAddress() const {
   // We bound to port zero, so we need to figure out which port we actually
   // bound to
   if (m_socket != kInvalidSocketValue) {
if (m_socket != kInvalidSocketValue) {
     SocketAddress sock_addr;
     socklen_t sock_addr_len = sock_addr.GetMaxLength();
     if (::getpeername(m_socket, sock_addr, &sock_addr_len) == 0)
       return sock_addr.GetIPAddress();
   }
   return "";
 }
 
+Error TCPSocket::CreateSocket(int domain) {
+  Error error;
+  if (IsValid())
+    error = Close();
+  if (error.Fail())
+    return error;
+  m_socket = Socket::CreateSocket(domain, kType, IPPROTO_TCP,
+                                  m_child_processes_inherit, error);
+  return error;
+}
+
 Error TCPSocket::Connect(llvm::StringRef name) {
-  if (m_socket == kInvalidSocketValue)
-    return Error("Invalid socket");
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
   if (log)
     log->Printf("TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
 
   Error error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
     return error;
 
-  struct sockaddr_in sa;
-  ::memset(&sa, 0, sizeof(sa));
-  sa.sin_family = kDomain;
-  sa.sin_port = htons(port);
-
-  int inet_pton_result = ::inet_pton(kDomain, host_str.c_str(), &sa.sin_addr);
+  auto addresses =
+      lldb_private::SocketAddress::GetAddressInfo(host_str.c_str(), NULL);
+  for (auto address : addresses) {
+    error = CreateSocket(address.GetFamily());
+    if (error.Fail())
+      continue;
 
-  if (inet_pton_result <= 0) {
-    struct hostent *host_entry = gethostbyname(host_str.c_str());
-    if (host_entry)
-      host_str = ::inet_ntoa(*(struct in_addr *)*host_entry->h_addr_list);
-    inet_pton_result = ::inet_pton(kDomain, host_str.c_str(), &sa.sin_addr);
-    if (inet_pton_result <= 0) {
-      if (inet_pton_result == -1)
-        SetLastError(error);
-      else
-        error.SetErrorStringWithFormat("invalid host string: '%s'",
-                                       host_str.c_str());
+    address.SetPort(port);
 
-      return error;
-    }
+    if (-1 == ::connect(GetNativeSocket(), &address.sockaddr(),
+                        address.GetLength())) {
+      continue;
     }
 
-  if (-1 ==
-      ::connect(GetNativeSocket(), (const struct sockaddr *)&sa, sizeof(sa))) {
-    SetLastError(error);
+    SetOptionNoDelay();
+
+    error.Clear();
     return error;
   }
 
-  // Keep our TCP packets coming without any delays.
-  SetOptionNoDelay();
-  error.Clear();
+  error.SetErrorString("Failed to connect port");
   return error;
 }
 
 Error TCPSocket::Listen(llvm::StringRef name, int backlog) {
-  Error error;
-
-  // enable local address reuse
-  SetOptionReuseAddress();
-
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("TCPSocket::%s (%s)", __FUNCTION__, name.data());
 
+  Error error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
     return error;
 
-  SocketAddress bind_addr;
+  auto addresses =
+      lldb_private::SocketAddress::GetAddressInfo(host_str.c_str(), NULL);
+  for (auto address : addresses) {
+    int fd = Socket::CreateSocket(address.GetFamily(), kType, IPPROTO_TCP,
+                                  m_child_processes_inherit, error);
+    if (error.Fail()) {
+      error.Clear();
+      continue;
+    }
 
-  // Only bind to the loopback address if we are expecting a connection from
-  // localhost to avoid any firewall issues.
-  const bool bind_addr_success = (host_str == "127.0.0.1")
-                                     ? bind_addr.SetToLocalhost(kDomain, port)
-                                     : bind_addr.SetToAnyAddress(kDomain, port);
+    // enable local address reuse
+    SetOptionReuseAddress();
 
-  if (!bind_addr_success) {
-    error.SetErrorString("Failed to bind port");
-    return error;
-  }
+    address.SetPort(port);
 
-  int err = ::bind(GetNativeSocket(), bind_addr, bind_addr.GetLength());
-  if (err != -1)
-    err = ::listen(GetNativeSocket(), backlog);
+    int err = ::bind(fd, &address.sockaddr(), address.GetLength());
+    if (-1 != err)
+      err = ::listen(fd, backlog);
+
+    if (-1 == err) {
+#if defined(_WIN32)
+      closesocket(fd);
+#else
+      ::close(fd);
+#endif
+      continue;
+    }
 
-  if (err == -1)
-    SetLastError(error);
+    if (port == 0) {
+      socklen_t sa_len = address.GetLength();
+      if (getsockname(fd, &address.sockaddr(), &sa_len) == 0)
+        port = address.GetPort();
+    }
+    m_listen_sockets[fd] = address;
+  }
 
+  if (m_listen_sockets.size() == 0)
+    error.SetErrorString("Failed to connect port");
   return error;
 }
 
-Error TCPSocket::Accept(llvm::StringRef name, bool child_processes_inherit,
-                        Socket *&conn_socket) {
-  Error error;
-  std::string host_str;
-  std::string port_str;
-  int32_t port;
-  if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
-    return error;
+void TCPSocket::CloseListenSockets() {
+  for (auto socket : m_listen_sockets)
+#if defined(_WIN32)
+    closesocket(socket.first);
+#else
+    ::close(socket.first);
+#endif
+  m_listen_sockets.clear();
+}
 
-  const sa_family_t family = kDomain;
-  const int socktype = kType;
-  const int protocol = IPPROTO_TCP;
-  SocketAddress listen_addr;
-  if (host_str.empty())
-    listen_addr.SetToLocalhost(family, port);
-  else if (host_str.compare("*") == 0)
-    listen_addr.SetToAnyAddress(family, port);
-  else {
-    if (!listen_addr.getaddrinfo(host_str.c_str(), port_str.c_str(), family,
-                                 socktype, protocol)) {
-      error.SetErrorStringWithFormat("unable to resolve hostname '%s'",
-                                     host_str.c_str());
-      return error;
-    }
-  }
+Error TCPSocket::Accept(Socket *&conn_socket) {
+  Error error;
+  if (m_listen_sockets.size() == 0) {
+    error.SetErrorString("No open listening sockets!");
 
   bool accept_connection = false;
   std::unique_ptr<TCPSocket> accepted_socket;
 
+#if HAVE_SYS_EVENT_H
+
+  int queue_id = kqueue();
+  if (queue_id < 0) {
+    error.SetErrorString("error: failed to create kqueue.");
+    return error;
+  }
+
+  std::vector<struct kevent> events;
+  events.resize(m_listen_sockets.size());
+  int i = 0;
+  for (auto socket: m_listen_sockets) {
+    EV_SET(&events[i++], socket.first, EVFILT_READ, EV_ADD, 0, 0, 0);
+  }
+#else
+  std::vector<struct pollfd> sock_set;
+
+  int nfds = 0;
+  for (auto socket : m_listen_sockets) {
+    struct pollfd sock_fd;
+    sock_fd.fd = socket.first;
+    sock_fd.events = POLLIN | POLLERR;
+    sock_fd.revents = 0;
+    sock_set.push_back(sock_fd);
+  }
+#endif
+
   // Loop until we are happy with our connection
   while (!accept_connection) {
-    struct sockaddr_in accept_addr;
-    ::memset(&accept_addr, 0, sizeof accept_addr);
-#if !(defined(__linux__) || defined(_WIN32))
-    accept_addr.sin_len = sizeof accept_addr;
-#endif
-    socklen_t accept_addr_len = sizeof accept_addr;
+    int sock_fd = -1;
+#if HAVE_SYS_EVENT_H
+    struct kevent event_list[4];
+    int num_events =
+        kevent(queue_id, events.data(), events.size(), event_list, 4, NULL);
 
-    int sock = AcceptSocket(GetNativeSocket(), (struct sockaddr *)&accept_addr,
-                            &accept_addr_len, child_processes_inherit, error);
+    if (num_events < 0) {
+      error.SetErrorString("error: kevent() failed.");
+      return error;
+    }
 
-    if (error.Fail())
+    for (int i = 0; i < num_events; ++i) {
+      auto socket_pair = m_listen_sockets.find(event_list[i].ident);
+      if (socket_pair == m_listen_sockets.end())
+        continue;
+      sock_fd = event_list[i].ident;
+    }
+#else
+
+#if defined(_WIN32)
+    int retval = WSAPoll(sock_set.data(), sock_set.size(), 1000);
+#else
+    int retval = poll(sock_set.data(), sock_set.size(), 1000);
+#endif
+    if (retval == -1)
       break;
+    if (retval == 0)
+      continue;
+
+    for (auto socket : sock_set) {
+      if ((socket.revents & POLLERR) != 0) {
+        error.SetErrorString("Socket error encountered");
+        return error;
+      }
 
-    bool is_same_addr = true;
-#if !(defined(__linux__) || (defined(_WIN32)))
-    is_same_addr = (accept_addr_len == listen_addr.sockaddr_in().sin_len);
+      if ((socket.revents & POLLIN) == 0)
+        continue;
+      sock_fd = socket.fd;
+      break;
+    }
 #endif
-    if (is_same_addr)
-      is_same_addr = (accept_addr.sin_addr.s_addr ==
-                      listen_addr.sockaddr_in().sin_addr.s_addr);
 
-    if (is_same_addr ||
-        (listen_addr.sockaddr_in().sin_addr.s_addr == INADDR_ANY)) {
-      accept_connection = true;
-      accepted_socket.reset(new TCPSocket(sock, true));
-    } else {
-      const uint8_t *accept_ip = (const uint8_t *)&accept_addr.sin_addr.s_addr;
-      const uint8_t *listen_ip =
-          (const uint8_t *)&listen_addr.sockaddr_in().sin_addr.s_addr;
-      ::fprintf(stderr, "error: rejecting incoming connection from %u.%u.%u.%u "
-                        "(expecting %u.%u.%u.%u)\n",
-                accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
-                listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
-      accepted_socket.reset();
+    if(-1 == sock_fd)
+      continue;
+
+    lldb_private::SocketAddress AccptAddr;
+    socklen_t sa_len = AccptAddr.GetMaxLength();
+    int sock = AcceptSocket(sock_fd, &AccptAddr.sockaddr(), &sa_len,
+                            m_child_processes_inherit, error);
+    if (error.Fail())
+      return error;
+
+    lldb_private::SocketAddress &AddrIn = m_listen_sockets[sock_fd];
+    if (!AddrIn.IsAnyAddr() && AccptAddr != AddrIn) {
+#if defined(_WIN32)
+      closesocket(sock);
+#else
+      ::close(sock);
+#endif
+      ::fprintf(
+          stderr,
+          "error: rejecting incoming connection from %s (expecting %s)\n",
+          AccptAddr.GetIPAddress().c_str(), AddrIn.GetIPAddress().c_str());
+      continue;
     }
+    accept_connection = true;
+    accepted_socket.reset(new TCPSocket(sock, *this));
   }
 
   if (!accepted_socket)
     return error;
 
   // Keep our TCP packets coming without any delays.
   accepted_socket->SetOptionNoDelay();
   error.Clear();
   conn_socket = accepted_socket.release();
+  CloseListenSockets();
   return error;
 }
 
 int TCPSocket::SetOptionNoDelay() {
   return SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
 }
 
 int TCPSocket::SetOptionReuseAddress() {
   return SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
 }

source/Host/common/UDPSocket.cpp

 using namespace lldb_private;
 
 namespace {
 
 const int kDomain = AF_INET;
 const int kType = SOCK_DGRAM;
 
 static const char *g_not_supported_error = "Not supported";
-}
+} // namespace
 
-UDPSocket::UDPSocket(NativeSocket socket) : Socket(socket, ProtocolUdp, true) {}
+UDPSocket::UDPSocket(bool should_close, bool child_processes_inherit)
+    : Socket(ProtocolUdp, should_close, child_processes_inherit) {}
 
-UDPSocket::UDPSocket(bool child_processes_inherit, Error &error)
-    : UDPSocket(
-          CreateSocket(kDomain, kType, 0, child_processes_inherit, error)) {}
+UDPSocket::UDPSocket(NativeSocket socket, const UDPSocket &listen_socket)
+    : Socket(ProtocolUdp, listen_socket.m_should_close_fd,
+             listen_socket.m_child_processes_inherit) {
+  m_socket = socket;
+}
 
 size_t UDPSocket::Send(const void *buf, const size_t num_bytes) {
   return ::sendto(m_socket, static_cast<const char *>(buf), num_bytes, 0,
                   m_sockaddr, m_sockaddr.GetLength());
 }
 
 Error UDPSocket::Connect(llvm::StringRef name) {
-  return Error("%s", g_not_supported_error);
-}
-
-Error UDPSocket::Listen(llvm::StringRef name, int backlog) {
-  return Error("%s", g_not_supported_error);
-}
-
-Error UDPSocket::Accept(llvm::StringRef name, bool child_processes_inherit,
-                        Socket *&socket) {
-  return Error("%s", g_not_supported_error);
-}
-
-Error UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
-                         Socket *&socket) {
-  std::unique_ptr<UDPSocket> final_socket;
-
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("UDPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
 
   Error error;
+  if (error.Fail())
+    return error;
+
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
     return error;
 
   // At this point we have setup the receive port, now we need to
   // setup the UDP send socket

 #endif
         host_str.c_str(), port_str.c_str(), err, gai_strerror(err));
     return error;
   }
 
   for (struct addrinfo *service_info_ptr = service_info_list;
        service_info_ptr != nullptr;
        service_info_ptr = service_info_ptr->ai_next) {
-    auto send_fd = CreateSocket(
+    m_socket = Socket::CreateSocket(
         service_info_ptr->ai_family, service_info_ptr->ai_socktype,
-        service_info_ptr->ai_protocol, child_processes_inherit, error);
+        service_info_ptr->ai_protocol, m_child_processes_inherit, error);
     if (error.Success()) {
-      final_socket.reset(new UDPSocket(send_fd));
-      final_socket->m_sockaddr = service_info_ptr;
+      m_sockaddr = service_info_ptr;
       break;
     } else
       continue;
   }
 
   ::freeaddrinfo(service_info_list);
 
-  if (!final_socket)
+  if (IsValid())
     return error;
 
   SocketAddress bind_addr;
 
   // Only bind to the loopback address if we are expecting a connection from
   // localhost to avoid any firewall issues.
-  const bool bind_addr_success = (host_str == "127.0.0.1" || host_str == "localhost")
-                                     ? bind_addr.SetToLocalhost(kDomain, port)
-                                     : bind_addr.SetToAnyAddress(kDomain, port);
+  const bool bind_addr_success =
+      (host_str == "127.0.0.1" || host_str == "localhost")
 
   if (!bind_addr_success) {
     error.SetErrorString("Failed to get hostspec to bind for");
     return error;
   }
 
   bind_addr.SetPort(0); // Let the source port # be determined dynamically
 
-  err = ::bind(final_socket->GetNativeSocket(), bind_addr, bind_addr.GetLength());
+  err = ::bind(m_socket, bind_addr, bind_addr.GetLength());
 
-  struct sockaddr_in source_info;
-  socklen_t address_len = sizeof (struct sockaddr_in);
-  err = ::getsockname(final_socket->GetNativeSocket(), (struct sockaddr *) &source_info, &address_len);
+  error.Clear();
+  return error;
+}
+
+Error UDPSocket::Listen(llvm::StringRef name, int backlog) {
+  return Error("%s", g_not_supported_error);
+}
+
+Error UDPSocket::Accept(Socket *&socket) {
+  return Error("%s", g_not_supported_error);
+}
 
+Error UDPSocket::CreateSocket() {
+  Error error;
+  if (IsValid())
+    error = Close();
+  if (error.Fail())
+    return error;
+  m_socket =
+      Socket::CreateSocket(kDomain, kType, 0, m_child_processes_inherit, error);
+  return error;
+}
+
+Error UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
+                         Socket *&socket) {
+  std::unique_ptr<UDPSocket> final_socket(
+      new UDPSocket(true, child_processes_inherit));
+  Error error = final_socket->Connect(name);
+  if (!error.Fail())
     socket = final_socket.release();
-  error.Clear();
   return error;
 }

source/Host/linux/AbstractSocket.cpp

 //===-- AbstractSocket.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/linux/AbstractSocket.h"
 
 #include "llvm/ADT/StringRef.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-AbstractSocket::AbstractSocket(bool child_processes_inherit, Error &error)
-    : DomainSocket(ProtocolUnixAbstract, child_processes_inherit, error) {}
+AbstractSocket::AbstractSocket(bool child_processes_inherit)
+    : DomainSocket(ProtocolUnixAbstract, child_processes_inherit) {}
 
 size_t AbstractSocket::GetNameOffset() const { return 1; }
 
 void AbstractSocket::DeleteSocketFile(llvm::StringRef name) {}

source/Host/posix/ConnectionFileDescriptorPosix.cpp

else if ((addr = GetURLAddress(path, FD_SCHEME))) {
           // TODO: Since are using a URL to open connection we should
           // eventually parse options using the web standard where we
           // have "fd://123?opt1=value;opt2=value" and we can have an
           // option be "owns=1" or "owns=0" or something like this to
           // allow us to specify this. For now, we assume we must
           // assume we don't own it.
 
           std::unique_ptr<TCPSocket> tcp_socket;
-          tcp_socket.reset(new TCPSocket(fd, false));
+          tcp_socket.reset(new TCPSocket(fd, false, false));
           // Try and get a socket option from this file descriptor to
           // see if this is a socket and set m_is_socket accordingly.
           int resuse;
           bool is_socket =
               !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
           if (is_socket) {
             m_read_sp = std::move(tcp_socket);
             m_write_sp = m_read_sp;
if (error_ptr)
     *error_ptr = error;
   if (error.Fail())
     return eConnectionStatusError;
 
   std::unique_ptr<Socket> listening_socket_up;
 
   listening_socket_up.reset(socket);
   socket = nullptr;
-  error = listening_socket_up->Accept(s, m_child_processes_inherit, socket);
+  error = listening_socket_up->Accept(socket);
   listening_socket_up.reset();
   if (error_ptr)
     *error_ptr = error;
   if (error.Fail())
     return eConnectionStatusError;
 
   InitializeSocket(socket);
   return eConnectionStatusSuccess;

source/Host/posix/DomainSocket.cpp

saddr_un_len =
         offsetof(struct sockaddr_un, sun_path) + name_offset + name.size();
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
   saddr_un->sun_len = saddr_un_len;
 #endif
 
   return true;
 }
-}
-
-DomainSocket::DomainSocket(NativeSocket socket)
-    : Socket(socket, ProtocolUnixDomain, true) {}
+} // namespace
 
-DomainSocket::DomainSocket(bool child_processes_inherit, Error &error)
-    : DomainSocket(
-          CreateSocket(kDomain, kType, 0, child_processes_inherit, error)) {}
+DomainSocket::DomainSocket(bool should_close, bool child_processes_inherit)
+    : Socket(ProtocolUnixDomain, should_close, child_processes_inherit) {}
 
 DomainSocket::DomainSocket(SocketProtocol protocol,
-                           bool child_processes_inherit, Error &error)
-    : Socket(CreateSocket(kDomain, kType, 0, child_processes_inherit, error),
-             protocol, true) {}
+                           bool child_processes_inherit)
+    : Socket(protocol, true, child_processes_inherit) {}
+
+DomainSocket::DomainSocket(NativeSocket socket,
+                           const DomainSocket &listen_socket)
+    : Socket(ProtocolUnixDomain, listen_socket.m_should_close_fd,
+             listen_socket.m_child_processes_inherit) {
+  m_socket = socket;
+}
 
 Error DomainSocket::Connect(llvm::StringRef name) {
   sockaddr_un saddr_un;
   socklen_t saddr_un_len;
   if (!SetSockAddr(name, GetNameOffset(), &saddr_un, saddr_un_len))
     return Error("Failed to set socket address");
 
   Error error;
+  m_socket = CreateSocket(kDomain, kType, 0, m_child_processes_inherit, error);
+  if (error.Fail())
+    return error;
   if (::connect(GetNativeSocket(), (struct sockaddr *)&saddr_un, saddr_un_len) <
       0)
     SetLastError(error);
 
   return error;
 }
 
 Error DomainSocket::Listen(llvm::StringRef name, int backlog) {
   sockaddr_un saddr_un;
   socklen_t saddr_un_len;
   if (!SetSockAddr(name, GetNameOffset(), &saddr_un, saddr_un_len))
     return Error("Failed to set socket address");
 
   DeleteSocketFile(name);
 
   Error error;
+  m_socket = CreateSocket(kDomain, kType, 0, m_child_processes_inherit, error);
+  if (error.Fail())
+    return error;
   if (::bind(GetNativeSocket(), (struct sockaddr *)&saddr_un, saddr_un_len) ==
       0)
     if (::listen(GetNativeSocket(), backlog) == 0)
       return error;
 
   SetLastError(error);
   return error;
 }
 
-Error DomainSocket::Accept(llvm::StringRef name, bool child_processes_inherit,
-                           Socket *&socket) {
+Error DomainSocket::Accept(Socket *&socket) {
   Error error;
   auto conn_fd = AcceptSocket(GetNativeSocket(), nullptr, nullptr,
-                              child_processes_inherit, error);
+                              m_child_processes_inherit, error);
   if (error.Success())
-    socket = new DomainSocket(conn_fd);
+    socket = new DomainSocket(conn_fd, *this);
 
   return error;
 }
 
 size_t DomainSocket::GetNameOffset() const { return 0; }
 
 void DomainSocket::DeleteSocketFile(llvm::StringRef name) {
   llvm::sys::fs::remove(name);
 }

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 static Error DeleteForwardPortWithAdb(uint16_t local_port,
                                       const std::string &device_id) {
   AdbClient adb(device_id);
   return adb.DeletePortForwarding(local_port);
 }
 
 static Error FindUnusedPort(uint16_t &port) {
   Error error;
-  std::unique_ptr<TCPSocket> tcp_socket(new TCPSocket(false, error));
+  std::unique_ptr<TCPSocket> tcp_socket(new TCPSocket(true, false));
   if (error.Fail())
     return error;
 
   error = tcp_socket->Listen("127.0.0.1:0", 1);
   if (error.Success())
     port = tcp_socket->GetLocalPortNumber();
 
   return error;

tools/lldb-server/Acceptor.cpp

 }
 
 Error Acceptor::Listen(int backlog) {
   return m_listener_socket_up->Listen(StringRef(m_name), backlog);
 }
 
 Error Acceptor::Accept(const bool child_processes_inherit, Connection *&conn) {
   Socket *conn_socket = nullptr;
-  auto error = m_listener_socket_up->Accept(
-      StringRef(m_name), child_processes_inherit, conn_socket);
+  auto error = m_listener_socket_up->Accept(conn_socket);
   if (error.Success())
     conn = new ConnectionFileDescriptor(conn_socket);
 
   return error;
 }
 
 Socket::SocketProtocol Acceptor::GetSocketProtocol() const {
   return m_listener_socket_up->GetSocketProtocol();

unittests/Host/SocketTest.cpp

 #endif
   }
 
 protected:
   static void AcceptThread(Socket *listen_socket,
                            const char *listen_remote_address,
                            bool child_processes_inherit, Socket **accept_socket,
                            Error *error) {
-    *error = listen_socket->Accept(listen_remote_address,
-                                   child_processes_inherit, *accept_socket);
+    *error = listen_socket->Accept(*accept_socket);
   }
 
   template <typename SocketType>
   void CreateConnectedSockets(
       const char *listen_remote_address,
       const std::function<std::string(const SocketType &)> &get_connect_addr,
       std::unique_ptr<SocketType> *a_up, std::unique_ptr<SocketType> *b_up) {
     bool child_processes_inherit = false;
     Error error;
     std::unique_ptr<SocketType> listen_socket_up(
-        new SocketType(child_processes_inherit, error));
+        new SocketType(true, child_processes_inherit));
     EXPECT_FALSE(error.Fail());
     error = listen_socket_up->Listen(listen_remote_address, 5);
     EXPECT_FALSE(error.Fail());
     EXPECT_TRUE(listen_socket_up->IsValid());
 
     Error accept_error;
     Socket *accept_socket;
     std::thread accept_thread(AcceptThread, listen_socket_up.get(),
                               listen_remote_address, child_processes_inherit,
                               &accept_socket, &accept_error);
 
     std::string connect_remote_address = get_connect_addr(*listen_socket_up);
     std::unique_ptr<SocketType> connect_socket_up(
-        new SocketType(child_processes_inherit, error));
+        new SocketType(true, child_processes_inherit));
     EXPECT_FALSE(error.Fail());
     error = connect_socket_up->Connect(connect_remote_address);
     EXPECT_FALSE(error.Fail());
     EXPECT_TRUE(connect_socket_up->IsValid());
 
     a_up->swap(connect_socket_up);
     EXPECT_TRUE(error.Success());
     EXPECT_NE(nullptr, a_up->get());
TEST_F(SocketTest, DecodeHostAndPort) {
   EXPECT_TRUE(error.Success());
 
   EXPECT_TRUE(
       Socket::DecodeHostAndPort("*:65535", host_str, port_str, port, &error));
   EXPECT_STREQ("*", host_str.c_str());
   EXPECT_STREQ("65535", port_str.c_str());
   EXPECT_EQ(65535, port);
   EXPECT_TRUE(error.Success());
+
+  EXPECT_TRUE(
+      Socket::DecodeHostAndPort("[::1]:12345", host_str, port_str, port, &error));
+  EXPECT_STREQ("::1", host_str.c_str());
+  EXPECT_STREQ("12345", port_str.c_str());
+  EXPECT_EQ(12345, port);
+  EXPECT_TRUE(error.Success());
+
+  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());
 }
 
 #ifndef LLDB_DISABLE_POSIX
 TEST_F(SocketTest, DomainListenConnectAccept) {
   char *file_name_str = tempnam(nullptr, nullptr);
   EXPECT_NE(nullptr, file_name_str);
   const std::string file_name(file_name_str);
   free(file_name_str);

unittests/Process/gdb-remote/GDBRemoteTestUtils.cpp

 #if defined(_MSC_VER)
   ::WSACleanup();
 #endif
 }
 
 void Connect(GDBRemoteCommunication &client, GDBRemoteCommunication &server) {
   bool child_processes_inherit = false;
   Error error;
-  TCPSocket listen_socket(child_processes_inherit, error);
+  TCPSocket listen_socket(true, child_processes_inherit);
   ASSERT_FALSE(error.Fail());
   error = listen_socket.Listen("127.0.0.1:0", 5);
   ASSERT_FALSE(error.Fail());
 
   Socket *accept_socket;
   std::future<Error> accept_error = std::async(std::launch::async, [&] {
-    return listen_socket.Accept("127.0.0.1:0", child_processes_inherit,
-                                accept_socket);
+    return listen_socket.Accept(accept_socket);
   });
 
   char connect_remote_address[64];
   snprintf(connect_remote_address, sizeof(connect_remote_address),
            "connect://localhost:%u", listen_socket.GetLocalPortNumber());
 
   std::unique_ptr<ConnectionFileDescriptor> conn_ap(
       new ConnectionFileDescriptor());