Make lldb-gdbserver to take explicit socket scheme as command line argument

[ovyalov]

Summary

Make lldb-gdbserver to take explicit socket scheme as command line argument - so lldb gdb-server uses the same socket type as platform does.

[clayborg]

Need to make a copy of socket_scheme in GDBRemoteCommunicationServerPlatform (save it to a std::string).

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

71

We should make a copy in a std::string here.

[ovyalov]

Addressed review comments - please take another look.

[ovyalov]

Greg, is it ok to submit the CL?

[ovyalov]

Files:

/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h
/lldb/trunk/tools/lldb-server/Acceptor.cpp
/lldb/trunk/tools/lldb-server/Acceptor.h
/lldb/trunk/tools/lldb-server/lldb-platform.cpp

Users:

ovyalov (Author)

http://reviews.llvm.org/rL251547

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

 namespace process_gdb_remote {
 
 class GDBRemoteCommunicationServerPlatform :
     public GDBRemoteCommunicationServerCommon
 {
 public:
     typedef std::map<uint16_t, lldb::pid_t> PortMap;
 
-    GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol);
+    GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
+                                         const char* socket_scheme);
 
     ~GDBRemoteCommunicationServerPlatform() override;
 
     Error
     LaunchProcess () override;
 
     // Set both ports to zero to let the platform automatically bind to 
     // a port chosen by the OS.
public:
     bool
     FreePortForProcess (lldb::pid_t pid);
 
     void
     SetPortOffset (uint16_t port_offset);
 
 protected:
     const Socket::SocketProtocol m_socket_protocol;
+    const char* m_socket_scheme;  // not owned.
     Mutex m_spawned_pids_mutex;
     std::set<lldb::pid_t> m_spawned_pids;
     lldb::PlatformSP m_platform_sp;
 
     PortMap m_port_map;
     uint16_t m_port_offset;
 
     PacketResult

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol) :
+GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
+                                                                           const char* socket_scheme) :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
     m_socket_protocol(socket_protocol),
+    m_socket_scheme(socket_scheme),
     m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
     m_platform_sp (Platform::GetHostPlatform ()),
     m_port_map (),
     m_port_offset(0)
 {
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qC);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
#else
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
     UNUSED_IF_ASSERT_DISABLED(ok);
     assert(ok);
 
     std::string socket_name;
     std::ostringstream url;
 
     uint16_t* port_ptr = &port;
+    url << m_socket_scheme << "://";
     if (m_socket_protocol == Socket::ProtocolTcp)
         url << platform_ip << ":" << port;
     else
     {
         socket_name = GetDomainSocketPath("gdbserver").GetPath();
         url << socket_name;
         port_ptr = nullptr;
     }

tools/lldb-server/Acceptor.h

public:
     Accept(const bool child_processes_inherit, Connection *&conn);
 
     static std::unique_ptr<Acceptor>
     Create(llvm::StringRef name, const bool child_processes_inherit, Error &error);
 
     Socket::SocketProtocol
     GetSocketProtocol() const;
 
+    const char*
+    GetSocketScheme() const;
+
     // Returns either TCP port number as string or domain socket path.
     // Empty string is returned in case of error.
     std::string
     GetLocalSocketId() const;
 
 private:
     typedef std::function<std::string()> LocalSocketIdFunc;
 

tools/lldb-server/Acceptor.cpp

 
 SocketScheme socket_schemes[] = {
     {"tcp", Socket::ProtocolTcp},
     {"udp", Socket::ProtocolUdp},
     {"unix", Socket::ProtocolUnixDomain},
     {"unix-abstract", Socket::ProtocolUnixAbstract},
 };
 
-bool FindProtocolByScheme(const char* scheme, Socket::SocketProtocol& protocol)
+bool
+FindProtocolByScheme(const char* scheme, Socket::SocketProtocol& protocol)
 {
     for (auto s: socket_schemes)
     {
         if (!strcmp(s.m_scheme, scheme))
         {
             protocol = s.m_protocol;
             return true;
         }
     }
     return false;
 }
 
+const char*
+FindSchemeByProtocol(const Socket::SocketProtocol protocol)
+{
+    for (auto s: socket_schemes)
+    {
+        if (s.m_protocol == protocol)
+            return s.m_scheme;
+    }
+    return nullptr;
+}
+
 }
 
 Error
 Acceptor::Listen(int backlog)
 {
     return m_listener_socket_up->Listen(StringRef(m_name.c_str()),
                                         backlog);
 }

 }
 
 Socket::SocketProtocol
 Acceptor::GetSocketProtocol() const
 {
     return m_listener_socket_up->GetSocketProtocol();
 }
 
+const char*
+Acceptor::GetSocketScheme() const
+{
+    return FindSchemeByProtocol(GetSocketProtocol());
+}
+
 std::string
 Acceptor::GetLocalSocketId() const
 {
     return m_local_socket_id();
 }
 
 std::unique_ptr<Acceptor>
 Acceptor::Create(StringRef name, const bool child_processes_inherit, Error &error)

tools/lldb-server/lldb-platform.cpp

if (socket_file)
         if (error.Fail())
         {
             fprintf(stderr, "failed to write socket id to %s: %s", socket_file.GetPath().c_str(), error.AsCString());
             return 1;
         }
     }
 
     do {
-        GDBRemoteCommunicationServerPlatform platform(acceptor_up->GetSocketProtocol());
+        GDBRemoteCommunicationServerPlatform platform(acceptor_up->GetSocketProtocol(),
+                                                      acceptor_up->GetSocketScheme());
         
         if (port_offset > 0)
             platform.SetPortOffset(port_offset);
 
         if (!gdbserver_portmap.empty())
         {
             platform.SetPortMap(std::move(gdbserver_portmap));
         }