Provide ADB port forwarding support for abstract sockets

[ovyalov]

Summary

Provide ADB port forwarding support for abstract sockets.

[tberghammer]

LGTM

source/Host/posix/ConnectionFileDescriptorPosix.cpp

182

(nit): Please initialize

[ovyalov]

Files:

/lldb/trunk/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h
/lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
/lldb/trunk/source/Plugins/Platform/Android/AdbClient.cpp
/lldb/trunk/source/Plugins/Platform/Android/AdbClient.h
/lldb/trunk/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp
/lldb/trunk/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

Users:

ovyalov (Author)

http://reviews.llvm.org/rL251879

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

 
 class Error;
 class Socket;
 class SocketAddress;
 
 class ConnectionFileDescriptor : public Connection
 {
   public:
+    static const char* LISTEN_SCHEME;
+    static const char* ACCEPT_SCHEME;
+    static const char* UNIX_ACCEPT_SCHEME;
+    static const char* CONNECT_SCHEME;
+    static const char* TCP_CONNECT_SCHEME;
+    static const char* UDP_SCHEME;
+    static const char* UNIX_CONNECT_SCHEME;
+    static const char* UNIX_ABSTRACT_CONNECT_SCHEME;
+    static const char* FD_SCHEME;
+    static const char* FILE_SCHEME;
+
     ConnectionFileDescriptor(bool child_processes_inherit = false);
 
     ConnectionFileDescriptor(int fd, bool owns_fd);
 
     ConnectionFileDescriptor(Socket* socket);
 
     ~ConnectionFileDescriptor() override;
 

source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #include "lldb/Host/Host.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Interpreter/Args.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+const char* ConnectionFileDescriptor::LISTEN_SCHEME = "listen";
+const char* ConnectionFileDescriptor::ACCEPT_SCHEME = "accept";
+const char* ConnectionFileDescriptor::UNIX_ACCEPT_SCHEME = "unix-accept";
+const char* ConnectionFileDescriptor::CONNECT_SCHEME = "connect";
+const char* ConnectionFileDescriptor::TCP_CONNECT_SCHEME = "tcp-connect";
+const char* ConnectionFileDescriptor::UDP_SCHEME = "udp";
+const char* ConnectionFileDescriptor::UNIX_CONNECT_SCHEME = "unix-connect";
+const char* ConnectionFileDescriptor::UNIX_ABSTRACT_CONNECT_SCHEME = "unix-abstract-connect";
+const char* ConnectionFileDescriptor::FD_SCHEME = "fd";
+const char* ConnectionFileDescriptor::FILE_SCHEME = "file";
+
+namespace {
+
+const char*
+GetURLAddress(const char *url, const char *scheme)
+{
+    const auto prefix = std::string(scheme) + "://";
+    if (strstr(url, prefix.c_str()) != url)
+        return nullptr;
+
+    return url + prefix.size();
+}
+
+}
+
 ConnectionFileDescriptor::ConnectionFileDescriptor(bool child_processes_inherit)
     : Connection()
     , m_pipe()
     , m_mutex(Mutex::eMutexTypeRecursive)
     , m_shutting_down(false)
     , m_waiting_for_accept(false)
     , m_child_processes_inherit(child_processes_inherit)
 {
ConnectionFileDescriptor::Connect(const char *s, Error *error_ptr)
     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
     if (log)
         log->Printf("%p ConnectionFileDescriptor::Connect (url = '%s')", static_cast<void *>(this), s);
 
     OpenCommandPipe();
 
     if (s && s[0])
     {
-        if (strstr(s, "listen://") == s)
+        const char *addr;
+        if ((addr = GetURLAddress(s, LISTEN_SCHEME)))
         {
             // listen://HOST:PORT
-            return SocketListenAndAccept(s + strlen("listen://"), error_ptr);
+            return SocketListenAndAccept(addr, error_ptr);
         }
-        else if (strstr(s, "accept://") == s)
+        else if ((addr = GetURLAddress(s, ACCEPT_SCHEME)))
         {
             // unix://SOCKNAME
-            return NamedSocketAccept(s + strlen("accept://"), error_ptr);
+            return NamedSocketAccept(addr, error_ptr);
         }
-        else if (strstr(s, "unix-accept://") == s)
+        else if ((addr = GetURLAddress(s, UNIX_ACCEPT_SCHEME)))
         {
             // unix://SOCKNAME
-            return NamedSocketAccept(s + strlen("unix-accept://"), error_ptr);
+            return NamedSocketAccept(addr, error_ptr);
         }
-        else if (strstr(s, "connect://") == s)
+        else if ((addr = GetURLAddress(s, CONNECT_SCHEME)))
         {
-            return ConnectTCP(s + strlen("connect://"), error_ptr);
+            return ConnectTCP(addr, error_ptr);
         }
-        else if (strstr(s, "tcp-connect://") == s)
+        else if ((addr = GetURLAddress(s, TCP_CONNECT_SCHEME)))
         {
-            return ConnectTCP(s + strlen("tcp-connect://"), error_ptr);
+            return ConnectTCP(addr, error_ptr);
         }
-        else if (strstr(s, "udp://") == s)
+        else if ((addr = GetURLAddress(s, UDP_SCHEME)))
         {
-            return ConnectUDP(s + strlen("udp://"), error_ptr);
+            return ConnectUDP(addr, error_ptr);
         }
-        else if (strstr(s, "unix-connect://") == s)
+        else if ((addr = GetURLAddress(s, UNIX_CONNECT_SCHEME)))
         {
             // unix-connect://SOCKNAME
-            return NamedSocketConnect(s + strlen("unix-connect://"), error_ptr);
+            return NamedSocketConnect(addr, error_ptr);
         }
-        else if (strstr(s, "unix-abstract-connect://") == s)
+        else if ((addr = GetURLAddress(s, UNIX_ABSTRACT_CONNECT_SCHEME)))
         {
             // unix-abstract-connect://SOCKNAME
-            return UnixAbstractSocketConnect(s + strlen("unix-abstract-connect://"), error_ptr);
+            return UnixAbstractSocketConnect(addr, error_ptr);
         }
 #ifndef LLDB_DISABLE_POSIX
-        else if (strstr(s, "fd://") == s)
+        else if ((addr = GetURLAddress(s, FD_SCHEME)))
         {
             // 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);
+            int fd = StringConvert::ToSInt32(addr, -1, 0, &success);
 
             if (success)
             {
                 // We have what looks to be a valid file descriptor, but we
                 // should make sure it is. We currently are doing this by trying to
                 // get the flags from the file descriptor and making sure it
                 // isn't a bad fd.
                 errno = 0;
#ifndef LLDB_DISABLE_POSIX
                         m_read_sp = std::move(tcp_socket);
                         m_write_sp = m_read_sp;
                     }
                     else
                     {
                         m_read_sp.reset(new File(fd, false));
                         m_write_sp.reset(new File(fd, false));
                     }
-                    m_uri.assign(s);
+                    m_uri.assign(addr);
                     return eConnectionStatusSuccess;
                 }
             }
 
             if (error_ptr)
-                error_ptr->SetErrorStringWithFormat("invalid file descriptor: \"fd://%s\"", s);
+                error_ptr->SetErrorStringWithFormat("invalid file descriptor: \"%s\"", s);
             m_read_sp.reset();
             m_write_sp.reset();
             return eConnectionStatusError;
         }
-        else if (strstr(s, "file://") == s)
+        else if ((addr = GetURLAddress(s, FILE_SCHEME)))
         {
             // file:///PATH
-            const char *path = s + strlen("file://");
+            const char *path = addr;
             int fd = -1;
             do
             {
                 fd = ::open(path, O_RDWR);
             } while (fd == -1 && errno == EINTR);
 
             if (fd == -1)
             {

source/Plugins/Platform/Android/AdbClient.h

 
 class FileSpec;
 
 namespace platform_android {
 
 class AdbClient
 {
 public:
+    enum UnixSocketNamespace
+    {
+        UnixSocketNamespaceAbstract,
+        UnixSocketNamespaceFileSystem,
+    };
+
     using DeviceIDList = std::list<std::string>;
 
     static Error
     CreateByDeviceID(const std::string &device_id, AdbClient &adb);
 
     AdbClient () = default;
     explicit AdbClient (const std::string &device_id);
 
     const std::string&
     GetDeviceID() const;
 
     Error
     GetDevices (DeviceIDList &device_list);
 
     Error
     SetPortForwarding (const uint16_t local_port, const uint16_t remote_port);
 
     Error
-    SetPortForwarding (const uint16_t local_port, const char* remote_socket_name);
+    SetPortForwarding (const uint16_t local_port,
+                       const char* remote_socket_name,
+                       const UnixSocketNamespace socket_namespace);
 
     Error
     DeletePortForwarding (const uint16_t local_port);
 
     Error
     PullFile (const FileSpec &remote_file, const FileSpec &local_file);
 
     Error

source/Plugins/Platform/Android/AdbClient.cpp

 const char * kSTAT = "STAT";
 
 const size_t kSyncPacketLen = 8;
 // Maximum size of a filesync DATA packet.
 const size_t kMaxPushData = 2*1024;
 // Default mode for pushed files.
 const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG
 
+const char * kSocketNamespaceAbstract = "localabstract";
+const char * kSocketNamespaceFileSystem = "localfilesystem";
+
 }  // namespace
 
 Error
 AdbClient::CreateByDeviceID(const std::string &device_id, AdbClient &adb)
 {
     DeviceIDList connect_devices;
     auto error = adb.GetDevices(connect_devices);
     if (error.Fail())
AdbClient::SetPortForwarding (const uint16_t local_port, const uint16_t remote_port)
     const auto error = SendDeviceMessage (message);
     if (error.Fail ())
         return error;
 
     return ReadResponseStatus ();
 }
 
 Error
-AdbClient::SetPortForwarding (const uint16_t local_port, const char* remote_socket_name)
+AdbClient::SetPortForwarding (const uint16_t local_port,
+                              const char* remote_socket_name,
+                              const UnixSocketNamespace socket_namespace)
 {
     char message[PATH_MAX];
-    snprintf (message, sizeof (message), "forward:tcp:%d;localfilesystem:%s", local_port, remote_socket_name);
+    const char * sock_namespace_str = (socket_namespace == UnixSocketNamespaceAbstract) ?
+        kSocketNamespaceAbstract : kSocketNamespaceFileSystem;
+    snprintf (message, sizeof (message), "forward:tcp:%d;%s:%s",
+              local_port,
+              sock_namespace_str,
+              remote_socket_name);
 
     const auto error = SendDeviceMessage (message);
     if (error.Fail ())
         return error;
 
     return ReadResponseStatus ();
 }
 

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

 // C++ Includes
 #include <map>
 #include <utility>
 
 // Other libraries and framework includes
 // Project includes
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 
+#include "llvm/ADT/Optional.h"
+
+#include "AdbClient.h"
+
 namespace lldb_private {
 namespace platform_android {
 
 class PlatformAndroidRemoteGDBServer : public platform_gdb_server::PlatformRemoteGDBServer
 {
 public:
     PlatformAndroidRemoteGDBServer();
 
     ~PlatformAndroidRemoteGDBServer() override;
 
     Error
     ConnectRemote (Args& args) override;
 
     Error
     DisconnectRemote () override;
 
 protected:
     std::string m_device_id;
     std::map<lldb::pid_t, uint16_t> m_port_forwards;
+    llvm::Optional<AdbClient::UnixSocketNamespace> m_socket_namespace;
 
     bool
     LaunchGDBServer (lldb::pid_t &pid, std::string &connect_url) override;
 
     bool
     KillSpawnedProcess (lldb::pid_t pid) override;
 
     void

source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 //===-- PlatformAndroidRemoteGDBServer.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Other libraries and framework includes
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Host/common/TCPSocket.h"
-#include "AdbClient.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 #include "Utility/UriParser.h"
 
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace platform_android;
 
 static const lldb::pid_t g_remote_platform_pid = 0; // Alias for the process id of lldb-platform
 
 static Error
 ForwardPortWithAdb (const uint16_t local_port,
                     const uint16_t remote_port,
                     const char* remote_socket_name,
+                    const llvm::Optional<AdbClient::UnixSocketNamespace>& socket_namespace,
                     std::string& device_id)
 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
 
     AdbClient adb;
     auto error = AdbClient::CreateByDeviceID(device_id, adb);
     if (error.Fail ())
         return error;
 
     device_id = adb.GetDeviceID();
     if (log)
         log->Printf("Connected to Android device \"%s\"", device_id.c_str ());
 
     if (remote_port != 0)
     {
         if (log)
             log->Printf("Forwarding remote TCP port %d to local TCP port %d", remote_port, local_port);
         return adb.SetPortForwarding(local_port, remote_port);
     }
 
     if (log)
         log->Printf("Forwarding remote socket \"%s\" to local TCP port %d", remote_socket_name, local_port);
-    return adb.SetPortForwarding(local_port, remote_socket_name);
+
+    if (!socket_namespace)
+        return Error("Invalid socket namespace");
+
+    return adb.SetPortForwarding(local_port, remote_socket_name, *socket_namespace);
 }
 
 static Error
 DeleteForwardPortWithAdb (uint16_t local_port, const std::string& device_id)
 {
     AdbClient adb (device_id);
     return adb.DeletePortForwarding (local_port);
 }
PlatformAndroidRemoteGDBServer::ConnectRemote (Args& args)
     const char *url = args.GetArgumentAtIndex (0);
     if (!url)
         return Error("URL is null.");
     if (!UriParser::Parse (url, scheme, host, remote_port, path))
         return Error("Invalid URL: %s", url);
     if (host != "localhost")
         m_device_id = host;
 
+    m_socket_namespace.reset();
+    if (scheme == ConnectionFileDescriptor::UNIX_CONNECT_SCHEME)
+        m_socket_namespace = AdbClient::UnixSocketNamespaceFileSystem;
+    else if (scheme == ConnectionFileDescriptor::UNIX_ABSTRACT_CONNECT_SCHEME)
+        m_socket_namespace = AdbClient::UnixSocketNamespaceAbstract;
+
     std::string connect_url;
     auto error = MakeConnectURL (g_remote_platform_pid,
                                  (remote_port < 0) ? 0 : remote_port,
                                  path.c_str (),
                                  connect_url);
 
     if (error.Fail ())
         return error;
PlatformAndroidRemoteGDBServer::MakeConnectURL(const lldb::pid_t pid,
     // adding the loop to mitigate such problem.
     for (auto i = 0; i < kAttempsNum; ++i)
     {
         uint16_t local_port = 0;
         error = FindUnusedPort(local_port);
         if (error.Fail())
             return error;
 
-        error = ForwardPortWithAdb(local_port, remote_port, remote_socket_name, m_device_id);
+        error = ForwardPortWithAdb(local_port,
+                                   remote_port,
+                                   remote_socket_name,
+                                   m_socket_namespace,
+                                   m_device_id);
         if (error.Success())
         {
             m_port_forwards[pid] = local_port;
             std::ostringstream url_str;
             url_str << "connect://localhost:" << local_port;
             connect_url = url_str.str();
             break;
         }
     }
 
     return error;
 }