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
FindProtocolByScheme(const char * scheme,Socket::SocketProtocol & protocol)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
FindSchemeByProtocol(const Socket::SocketProtocol protocol)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
Listen(int backlog)59 Status Acceptor::Listen(int backlog) {
60 return m_listener_socket_up->Listen(StringRef(m_name), backlog);
61 }
62
Accept(const bool child_processes_inherit,Connection * & conn)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
GetSocketProtocol() const72 Socket::SocketProtocol Acceptor::GetSocketProtocol() const {
73 return m_listener_socket_up->GetSocketProtocol();
74 }
75
GetSocketScheme() const76 const char *Acceptor::GetSocketScheme() const {
77 return FindSchemeByProtocol(GetSocketProtocol());
78 }
79
GetLocalSocketId() const80 std::string Acceptor::GetLocalSocketId() const { return m_local_socket_id(); }
81
Create(StringRef name,const bool child_processes_inherit,Status & error)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
Acceptor(std::unique_ptr<Socket> && listener_socket,StringRef name,const LocalSocketIdFunc & local_socket_id)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) {}
137