contrib/llvm/tools/lldb/tools/lldb-server/Acceptor.cpp

   1 //===-- Acceptor.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Acceptor.h"
  11
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/Support/ScopedPrinter.h"
  14
  15 #include "lldb/Host/ConnectionFileDescriptor.h"
  16 #include "lldb/Host/common/TCPSocket.h"
  17 #include "lldb/Utility/StreamString.h"
  18 #include "lldb/Utility/UriParser.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22 using namespace lldb_private::lldb_server;
  23 using namespace llvm;
  24
  25 namespace {
  26
  27 struct SocketScheme {
  28   const char *m_scheme;
  29   const Socket::SocketProtocol m_protocol;
  30 };
  31
  32 SocketScheme socket_schemes[] = {
  33     {"tcp", Socket::ProtocolTcp},
  34     {"udp", Socket::ProtocolUdp},
  35     {"unix", Socket::ProtocolUnixDomain},
  36     {"unix-abstract", Socket::ProtocolUnixAbstract},
  37 };
  38
  39 bool FindProtocolByScheme(const char *scheme,
  40                           Socket::SocketProtocol &protocol) {
  41   for (auto s : socket_schemes) {
  42     if (!strcmp(s.m_scheme, scheme)) {
  43       protocol = s.m_protocol;
  44       return true;
  45     }
  46   }
  47   return false;
  48 }
  49
  50 const char *FindSchemeByProtocol(const Socket::SocketProtocol protocol) {
  51   for (auto s : socket_schemes) {
  52     if (s.m_protocol == protocol)
  53       return s.m_scheme;
  54   }
  55   return nullptr;
  56 }
  57 }
  58
  59 Status Acceptor::Listen(int backlog) {
  60   return m_listener_socket_up->Listen(StringRef(m_name), backlog);
  61 }
  62
  63 Status Acceptor::Accept(const bool child_processes_inherit, Connection *&conn) {
  64   Socket *conn_socket = nullptr;
  65   auto error = m_listener_socket_up->Accept(conn_socket);
  66   if (error.Success())
  67     conn = new ConnectionFileDescriptor(conn_socket);
  68
  69   return error;
  70 }
  71
  72 Socket::SocketProtocol Acceptor::GetSocketProtocol() const {
  73   return m_listener_socket_up->GetSocketProtocol();
  74 }
  75
  76 const char *Acceptor::GetSocketScheme() const {
  77   return FindSchemeByProtocol(GetSocketProtocol());
  78 }
  79
  80 std::string Acceptor::GetLocalSocketId() const { return m_local_socket_id(); }
  81
  82 std::unique_ptr<Acceptor> Acceptor::Create(StringRef name,
  83                                            const bool child_processes_inherit,
  84                                            Status &error) {
  85   error.Clear();
  86
  87   Socket::SocketProtocol socket_protocol = Socket::ProtocolUnixDomain;
  88   int port;
  89   StringRef scheme, host, path;
  90   // Try to match socket name as URL - e.g., tcp://localhost:5555
  91   if (UriParser::Parse(name, scheme, host, port, path)) {
  92     if (!FindProtocolByScheme(scheme.str().c_str(), socket_protocol))
  93       error.SetErrorStringWithFormat("Unknown protocol scheme \"%s\"",
  94                                      scheme.str().c_str());
  95     else
  96       name = name.drop_front(scheme.size() + strlen("://"));
  97   } else {
  98     std::string host_str;
  99     std::string port_str;
 100     int32_t port = INT32_MIN;
 101     // Try to match socket name as $host:port - e.g., localhost:5555
 102     if (Socket::DecodeHostAndPort(name, host_str, port_str, port, nullptr))
 103       socket_protocol = Socket::ProtocolTcp;
 104   }
 105
 106   if (error.Fail())
 107     return std::unique_ptr<Acceptor>();
 108
 109   std::unique_ptr<Socket> listener_socket_up =
 110       Socket::Create(socket_protocol, child_processes_inherit, error);
 111
 112   LocalSocketIdFunc local_socket_id;
 113   if (error.Success()) {
 114     if (listener_socket_up->GetSocketProtocol() == Socket::ProtocolTcp) {
 115       TCPSocket *tcp_socket =
 116           static_cast<TCPSocket *>(listener_socket_up.get());
 117       local_socket_id = [tcp_socket]() {
 118         auto local_port = tcp_socket->GetLocalPortNumber();
 119         return (local_port != 0) ? llvm::to_string(local_port) : "";
 120       };
 121     } else {
 122       const std::string socket_name = name;
 123       local_socket_id = [socket_name]() { return socket_name; };
 124     }
 125
 126     return std::unique_ptr<Acceptor>(
 127         new Acceptor(std::move(listener_socket_up), name, local_socket_id));
 128   }
 129
 130   return std::unique_ptr<Acceptor>();
 131 }
 132
 133 Acceptor::Acceptor(std::unique_ptr<Socket> &&listener_socket, StringRef name,
 134                    const LocalSocketIdFunc &local_socket_id)
 135     : m_listener_socket_up(std::move(listener_socket)), m_name(name.str()),
 136       m_local_socket_id(local_socket_id) {}