Add support for abstract domain sockets.

[ovyalov]

Summary

Abstract domain sockets are supported only by Linux (at least, as documentation says) so I'm putting new socket class into linux subfolder.
Since there is a possibility that abstract namespace might be provided by other posix platforms it might be useful to link it with linux-independent URL scheme - i.e. "unix-abstract-connect".

[labath]

lgtm

[clayborg]

Looks good. At some point we should add these to the PluginMananger and have new instances found by having them register URL prefixes which match up with CreateInstance methods that are given the URL.

[ovyalov]

In D13970#273217, @clayborg wrote:

Looks good. At some point we should add these to the PluginMananger and have new instances found by having them register URL prefixes which match up with CreateInstance methods that are given the URL.

Thank you for the idea - I was planning to have a kind of URL-based factory inside lldb-server/Acceptor and PluginManager looks as a way to go.
If we're going to make Socket class a plugin should we then move all implementations into source/Plugins/Socket folder?

[clayborg]

In D13970#273267, @ovyalov wrote:

In D13970#273217, @clayborg wrote:

Looks good. At some point we should add these to the PluginMananger and have new instances found by having them register URL prefixes which match up with CreateInstance methods that are given the URL.

Thank you for the idea - I was planning to have a kind of URL-based factory inside lldb-server/Acceptor and PluginManager looks as a way to go.
If we're going to make Socket class a plugin should we then move all implementations into source/Plugins/Socket folder?

Yes.

[labath]

I believe this has landed a while back.

include/lldb/Host/Socket.h

 
 class Socket : public IOObject
 {
 public:
     typedef enum
     {
         ProtocolTcp,
         ProtocolUdp,
-        ProtocolUnixDomain
+        ProtocolUnixDomain,
+        ProtocolUnixAbstract
     } SocketProtocol;
 
     static const NativeSocket kInvalidSocketValue;
 
     ~Socket() override;
 
     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;
 
     // 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,
         Predicate<uint16_t>* predicate,
         int backlog = 5);
     static Error TcpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
     static Error UdpConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&send_socket, Socket *&recv_socket);
     static Error UnixDomainConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
     static Error UnixDomainAccept(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
+    static Error UnixAbstractConnect(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
+    static Error UnixAbstractAccept(llvm::StringRef host_and_port, bool child_processes_inherit, Socket *&socket);
 
     int GetOption (int level, int option_name, int &option_value);
     int SetOption (int level, int option_name, int option_value);
 
     NativeSocket GetNativeSocket () const { return m_socket; }
     SocketProtocol GetSocketProtocol () const { return m_protocol; }
 
     Error Read (void *buf, size_t &num_bytes) override;

include/lldb/Host/linux/AbstractSocket.h

+//===-- AbstractSocket.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_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);
+
+    protected:
+        size_t GetNameOffset() const override;
+        void DeleteSocketFile(llvm::StringRef name) override;
+    };
+}
+
+#endif // ifndef liblldb_AbstractSocket_h_

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

protected:
     lldb::ConnectionStatus ConnectTCP(const char *host_and_port, Error *error_ptr);
 
     lldb::ConnectionStatus ConnectUDP(const char *args, Error *error_ptr);
 
     lldb::ConnectionStatus NamedSocketConnect(const char *socket_name, Error *error_ptr);
 
     lldb::ConnectionStatus NamedSocketAccept(const char *socket_name, Error *error_ptr);
 
+    lldb::ConnectionStatus UnixAbstractSocketConnect(const char *socket_name, Error *error_ptr);
+
     lldb::IOObjectSP m_read_sp;
     lldb::IOObjectSP m_write_sp;
 
     Predicate<uint16_t> m_port_predicate; // Used when binding to port zero to wait for the thread
                                           // that creates the socket, binds and listens to resolve
                                           // the port number.
 
     Pipe m_pipe;

include/lldb/Host/posix/DomainSocket.h

namespace lldb_private
     class DomainSocket: public Socket
     {
     public:
         DomainSocket(bool child_processes_inherit, Error &error);
 
         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;
+
+    protected:
+        DomainSocket(SocketProtocol protocol, bool child_processes_inherit, Error &error);
+
+        virtual size_t GetNameOffset() const;
+        virtual void DeleteSocketFile(llvm::StringRef name);
+
     private:
         DomainSocket(NativeSocket socket);
     };
 }
 
 #endif // ifndef liblldb_DomainSocket_h_

source/Host/CMakeLists.txt

add_host_subdirectory(macosx
       )
 
   elseif (CMAKE_SYSTEM_NAME MATCHES "Linux")
     if (__ANDROID_NDK__)
       add_host_subdirectory(android
         android/HostInfoAndroid.cpp
         android/LibcGlue.cpp
         android/ProcessLauncherAndroid.cpp
+        linux/AbstractSocket.cpp
         linux/Host.cpp
         linux/HostInfoLinux.cpp
         linux/HostThreadLinux.cpp
         linux/LibcGlue.cpp
         linux/ThisThread.cpp
         )
     else()
       add_host_subdirectory(linux
+        linux/AbstractSocket.cpp
         linux/Host.cpp
         linux/HostInfoLinux.cpp
         linux/HostThreadLinux.cpp
         linux/LibcGlue.cpp
         linux/ThisThread.cpp
         )
     endif()
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")

source/Host/common/Socket.cpp

 #include <arpa/inet.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #endif
 
+#ifdef __linux__
+#include "lldb/Host/linux/AbstractSocket.h"
+#endif
+
 #ifdef __ANDROID_NDK__
 #include <linux/tcp.h>
 #include <bits/error_constants.h>
 #include <asm-generic/errno-base.h>
 #include <errno.h>
 #include <arpa/inet.h>
 #if defined(ANDROID_ARM_BUILD_STATIC)
 #include <unistd.h>
#ifndef LLDB_DISABLE_POSIX
 
     error = listen_socket->Accept(name, child_processes_inherit, socket);
 #else
     error.SetErrorString("Unix domain sockets are not supported on this platform.");
 #endif
     return error;
 }
 
+Error
+Socket::UnixAbstractConnect(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
+{
+    Error error;
+#ifdef __linux__
+    std::unique_ptr<Socket> connect_socket(new AbstractSocket(child_processes_inherit, error));
+    if (error.Fail())
+        return error;
+
+    error = connect_socket->Connect(name);
+    if (error.Success())
+      socket = connect_socket.release();
+#else
+    error.SetErrorString("Abstract domain sockets are not supported on this platform.");
+#endif
+    return error;
+}
+
+Error
+Socket::UnixAbstractAccept(llvm::StringRef name, bool child_processes_inherit, Socket *&socket)
+{
+    Error error;
+#ifdef __linux__
+    std::unique_ptr<Socket> listen_socket(new AbstractSocket(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);
+#else
+    error.SetErrorString("Abstract domain sockets are not supported on this platform.");
+#endif
+    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 ("([^:]+):([0-9]+)");

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)
+{
+}
+
+size_t
+AbstractSocket::GetNameOffset() const
+{
+    return 1;
+}
+
+void
+AbstractSocket::DeleteSocketFile(llvm::StringRef name)
+{
+}

source/Host/posix/ConnectionFileDescriptorPosix.cpp

if (s && s[0])
         {
             return ConnectUDP(s + strlen("udp://"), error_ptr);
         }
         else if (strstr(s, "unix-connect://") == s)
         {
             // unix-connect://SOCKNAME
             return NamedSocketConnect(s + strlen("unix-connect://"), error_ptr);
         }
+        else if (strstr(s, "unix-abstract-connect://") == s)
+        {
+            // unix-abstract-connect://SOCKNAME
+            return UnixAbstractSocketConnect(s + strlen("unix-abstract-connect://"), error_ptr);
+        }
 #ifndef LLDB_DISABLE_POSIX
         else if (strstr(s, "fd://") == s)
         {
             // Just passing a native file descriptor within this current process
             // that is already opened (possibly from a service or other source).
             s += strlen("fd://");
             bool success = false;
             int fd = StringConvert::ToSInt32(s, -1, 0, &success);
ConnectionFileDescriptor::NamedSocketConnect(const char *socket_name, Error *error_ptr)
     if (error.Fail())
     {
         return eConnectionStatusError;
     }
     m_uri.assign(socket_name);
     return eConnectionStatusSuccess;
 }
 
+lldb::ConnectionStatus
+ConnectionFileDescriptor::UnixAbstractSocketConnect(const char *socket_name, Error *error_ptr)
+{
+    Socket *socket = nullptr;
+    Error error = Socket::UnixAbstractConnect(socket_name, m_child_processes_inherit, socket);
+    if (error_ptr)
+        *error_ptr = error;
+    m_write_sp.reset(socket);
+    m_read_sp = m_write_sp;
+    if (error.Fail())
+    {
+        return eConnectionStatusError;
+    }
+    m_uri.assign(socket_name);
+    return eConnectionStatusSuccess;
+}
+
 ConnectionStatus
 ConnectionFileDescriptor::SocketListenAndAccept(const char *s, Error *error_ptr)
 {
     m_port_predicate.SetValue(0, eBroadcastNever);
 
     Socket *socket = nullptr;
     m_waiting_for_accept = true;
     Error error = Socket::TcpListen(s, m_child_processes_inherit, socket, &m_port_predicate);

source/Host/posix/DomainSocket.cpp

 #endif
 #endif // #ifdef __ANDROID__
 
 namespace {
 
 const int kDomain = AF_UNIX;
 const int kType   = SOCK_STREAM;
 
-void SetSockAddr(llvm::StringRef name, sockaddr_un* saddr_un)
+bool SetSockAddr(llvm::StringRef name, const size_t name_offset, sockaddr_un* saddr_un)
 {
+    if (name.size() + name_offset > sizeof(saddr_un->sun_path))
+        return false;
+
     saddr_un->sun_family = kDomain;
-    ::strncpy(saddr_un->sun_path, name.data(), sizeof(saddr_un->sun_path) - 1);
-    saddr_un->sun_path[sizeof(saddr_un->sun_path) - 1] = '\0';
+    memset(saddr_un->sun_path, 0, sizeof(saddr_un->sun_path));
+
+    strncpy(&saddr_un->sun_path[name_offset], name.data(), name.size());
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
     saddr_un->sun_len = SUN_LEN (saddr_un);
 #endif
+    return true;
 }
 
 }
 
 DomainSocket::DomainSocket(NativeSocket socket)
     : Socket(socket, ProtocolUnixDomain, true)
 {
 }
 
 DomainSocket::DomainSocket(bool child_processes_inherit, Error &error)
     : DomainSocket(CreateSocket(kDomain, kType, 0, child_processes_inherit, error))
 {
 }
 
+DomainSocket::DomainSocket(SocketProtocol protocol, bool child_processes_inherit, Error &error)
+    : Socket(CreateSocket(kDomain, kType, 0, child_processes_inherit, error), protocol, true)
+{
+}
+
 Error
 DomainSocket::Connect(llvm::StringRef name)
 {
     sockaddr_un saddr_un;
-    SetSockAddr(name, &saddr_un);
+    if (!SetSockAddr(name, GetNameOffset(), &saddr_un))
+        return Error("Failed to set socket address");
 
     Error error;
-    if (::connect(GetNativeSocket(), (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) < 0)
+    if (::connect(GetNativeSocket(), (struct sockaddr *)&saddr_un, sizeof(saddr_un)) < 0)
         SetLastError (error);
 
     return error;
 }
 
 Error
 DomainSocket::Listen(llvm::StringRef name, int backlog)
 {
     sockaddr_un saddr_un;
-    SetSockAddr(name, &saddr_un);
+    if (!SetSockAddr(name, GetNameOffset(), &saddr_un))
+        return Error("Failed to set socket address");
 
-    FileSystem::Unlink(FileSpec{name, true});
+    DeleteSocketFile(name);
 
     Error error;
-    if (::bind(GetNativeSocket(), (struct sockaddr *)&saddr_un, SUN_LEN (&saddr_un)) == 0)
+    if (::bind(GetNativeSocket(), (struct sockaddr *)&saddr_un, sizeof(saddr_un)) == 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 error;
     auto conn_fd = AcceptSocket(GetNativeSocket(), nullptr, nullptr, child_processes_inherit, error);
     if (error.Success())
         socket = new DomainSocket(conn_fd);
 
     return error;
 }
+
+size_t
+DomainSocket::GetNameOffset() const
+{
+    return 0;
+}
+
+void
+DomainSocket::DeleteSocketFile(llvm::StringRef name)
+{
+    FileSystem::Unlink(FileSpec{name, true});
+}