1 //===-- TCPSocket.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 #if defined(_MSC_VER)
11 #define _WINSOCK_DEPRECATED_NO_WARNINGS
12 #endif
13 
14 #include "lldb/Host/common/TCPSocket.h"
15 
16 #include "lldb/Host/Config.h"
17 #include "lldb/Host/MainLoop.h"
18 #include "lldb/Utility/Log.h"
19 
20 #include "llvm/Config/llvm-config.h"
21 #include "llvm/Support/raw_ostream.h"
22 
23 #ifndef LLDB_DISABLE_POSIX
24 #include <arpa/inet.h>
25 #include <netinet/tcp.h>
26 #include <sys/socket.h>
27 #endif
28 
29 #if defined(LLVM_ON_WIN32)
30 #include <winsock2.h>
31 #endif
32 
33 #ifdef LLVM_ON_WIN32
34 #define CLOSE_SOCKET closesocket
35 typedef const char *set_socket_option_arg_type;
36 #else
37 #include <unistd.h>
38 #define CLOSE_SOCKET ::close
39 typedef const void *set_socket_option_arg_type;
40 #endif
41 
42 using namespace lldb;
43 using namespace lldb_private;
44 
45 namespace {
46 const int kType = SOCK_STREAM;
47 }
48 
49 TCPSocket::TCPSocket(bool should_close, bool child_processes_inherit)
50     : Socket(ProtocolTcp, should_close, child_processes_inherit) {}
51 
52 TCPSocket::TCPSocket(NativeSocket socket, const TCPSocket &listen_socket)
53     : Socket(ProtocolTcp, listen_socket.m_should_close_fd,
54              listen_socket.m_child_processes_inherit) {
55   m_socket = socket;
56 }
57 
58 TCPSocket::TCPSocket(NativeSocket socket, bool should_close,
59                      bool child_processes_inherit)
60     : Socket(ProtocolTcp, should_close, child_processes_inherit) {
61   m_socket = socket;
62 }
63 
64 TCPSocket::~TCPSocket() { CloseListenSockets(); }
65 
66 bool TCPSocket::IsValid() const {
67   return m_socket != kInvalidSocketValue || m_listen_sockets.size() != 0;
68 }
69 
70 // Return the port number that is being used by the socket.
71 uint16_t TCPSocket::GetLocalPortNumber() const {
72   if (m_socket != kInvalidSocketValue) {
73     SocketAddress sock_addr;
74     socklen_t sock_addr_len = sock_addr.GetMaxLength();
75     if (::getsockname(m_socket, sock_addr, &sock_addr_len) == 0)
76       return sock_addr.GetPort();
77   } else if (!m_listen_sockets.empty()) {
78     SocketAddress sock_addr;
79     socklen_t sock_addr_len = sock_addr.GetMaxLength();
80     if (::getsockname(m_listen_sockets.begin()->first, sock_addr,
81                       &sock_addr_len) == 0)
82       return sock_addr.GetPort();
83   }
84   return 0;
85 }
86 
87 std::string TCPSocket::GetLocalIPAddress() const {
88   // We bound to port zero, so we need to figure out which port we actually
89   // bound to
90   if (m_socket != kInvalidSocketValue) {
91     SocketAddress sock_addr;
92     socklen_t sock_addr_len = sock_addr.GetMaxLength();
93     if (::getsockname(m_socket, sock_addr, &sock_addr_len) == 0)
94       return sock_addr.GetIPAddress();
95   }
96   return "";
97 }
98 
99 uint16_t TCPSocket::GetRemotePortNumber() const {
100   if (m_socket != kInvalidSocketValue) {
101     SocketAddress sock_addr;
102     socklen_t sock_addr_len = sock_addr.GetMaxLength();
103     if (::getpeername(m_socket, sock_addr, &sock_addr_len) == 0)
104       return sock_addr.GetPort();
105   }
106   return 0;
107 }
108 
109 std::string TCPSocket::GetRemoteIPAddress() const {
110   // We bound to port zero, so we need to figure out which port we actually
111   // bound to
112   if (m_socket != kInvalidSocketValue) {
113     SocketAddress sock_addr;
114     socklen_t sock_addr_len = sock_addr.GetMaxLength();
115     if (::getpeername(m_socket, sock_addr, &sock_addr_len) == 0)
116       return sock_addr.GetIPAddress();
117   }
118   return "";
119 }
120 
121 Status TCPSocket::CreateSocket(int domain) {
122   Status error;
123   if (IsValid())
124     error = Close();
125   if (error.Fail())
126     return error;
127   m_socket = Socket::CreateSocket(domain, kType, IPPROTO_TCP,
128                                   m_child_processes_inherit, error);
129   return error;
130 }
131 
132 Status TCPSocket::Connect(llvm::StringRef name) {
133 
134   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
135   if (log)
136     log->Printf("TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
137 
138   Status error;
139   std::string host_str;
140   std::string port_str;
141   int32_t port = INT32_MIN;
142   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
143     return error;
144 
145   auto addresses = lldb_private::SocketAddress::GetAddressInfo(
146       host_str.c_str(), NULL, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
147   for (auto address : addresses) {
148     error = CreateSocket(address.GetFamily());
149     if (error.Fail())
150       continue;
151 
152     address.SetPort(port);
153 
154     if (-1 == ::connect(GetNativeSocket(), &address.sockaddr(),
155                         address.GetLength())) {
156       CLOSE_SOCKET(GetNativeSocket());
157       continue;
158     }
159 
160     SetOptionNoDelay();
161 
162     error.Clear();
163     return error;
164   }
165 
166   error.SetErrorString("Failed to connect port");
167   return error;
168 }
169 
170 Status TCPSocket::Listen(llvm::StringRef name, int backlog) {
171   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
172   if (log)
173     log->Printf("TCPSocket::%s (%s)", __FUNCTION__, name.data());
174 
175   Status error;
176   std::string host_str;
177   std::string port_str;
178   int32_t port = INT32_MIN;
179   if (!DecodeHostAndPort(name, host_str, port_str, port, &error))
180     return error;
181 
182   if (host_str == "*")
183     host_str = "0.0.0.0";
184   auto addresses = lldb_private::SocketAddress::GetAddressInfo(
185       host_str.c_str(), NULL, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
186   for (auto address : addresses) {
187     int fd = Socket::CreateSocket(address.GetFamily(), kType, IPPROTO_TCP,
188                                   m_child_processes_inherit, error);
189     if (error.Fail()) {
190       error.Clear();
191       continue;
192     }
193 
194     // enable local address reuse
195     int option_value = 1;
196     set_socket_option_arg_type option_value_p =
197         reinterpret_cast<set_socket_option_arg_type>(&option_value);
198     ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, option_value_p,
199                  sizeof(option_value));
200 
201     SocketAddress listen_address = address;
202     if(!listen_address.IsLocalhost())
203       listen_address.SetToAnyAddress(address.GetFamily(), port);
204     else
205       listen_address.SetPort(port);
206 
207     int err =
208         ::bind(fd, &listen_address.sockaddr(), listen_address.GetLength());
209     if (-1 != err)
210       err = ::listen(fd, backlog);
211 
212     if (-1 == err) {
213       CLOSE_SOCKET(fd);
214       continue;
215     }
216 
217     if (port == 0) {
218       socklen_t sa_len = address.GetLength();
219       if (getsockname(fd, &address.sockaddr(), &sa_len) == 0)
220         port = address.GetPort();
221     }
222     m_listen_sockets[fd] = address;
223   }
224 
225   if (m_listen_sockets.size() == 0)
226     error.SetErrorString("Failed to connect port");
227   return error;
228 }
229 
230 void TCPSocket::CloseListenSockets() {
231   for (auto socket : m_listen_sockets)
232   CLOSE_SOCKET(socket.first);
233   m_listen_sockets.clear();
234 }
235 
236 Status TCPSocket::Accept(Socket *&conn_socket) {
237   Status error;
238   if (m_listen_sockets.size() == 0) {
239     error.SetErrorString("No open listening sockets!");
240     return error;
241   }
242 
243   int sock = -1;
244   int listen_sock = -1;
245   lldb_private::SocketAddress AcceptAddr;
246   MainLoop accept_loop;
247   std::vector<MainLoopBase::ReadHandleUP> handles;
248   for (auto socket : m_listen_sockets) {
249     auto fd = socket.first;
250     auto inherit = this->m_child_processes_inherit;
251     auto io_sp = IOObjectSP(new TCPSocket(socket.first, false, inherit));
252     handles.emplace_back(accept_loop.RegisterReadObject(
253         io_sp, [fd, inherit, &sock, &AcceptAddr, &error,
254                         &listen_sock](MainLoopBase &loop) {
255           socklen_t sa_len = AcceptAddr.GetMaxLength();
256           sock = AcceptSocket(fd, &AcceptAddr.sockaddr(), &sa_len, inherit,
257                               error);
258           listen_sock = fd;
259           loop.RequestTermination();
260         }, error));
261     if (error.Fail())
262       return error;
263   }
264 
265   bool accept_connection = false;
266   std::unique_ptr<TCPSocket> accepted_socket;
267   // Loop until we are happy with our connection
268   while (!accept_connection) {
269     accept_loop.Run();
270 
271     if (error.Fail())
272         return error;
273 
274     lldb_private::SocketAddress &AddrIn = m_listen_sockets[listen_sock];
275     if (!AddrIn.IsAnyAddr() && AcceptAddr != AddrIn) {
276       CLOSE_SOCKET(sock);
277       llvm::errs() << llvm::formatv(
278           "error: rejecting incoming connection from {0} (expecting {1})",
279           AcceptAddr.GetIPAddress(), AddrIn.GetIPAddress());
280       continue;
281     }
282     accept_connection = true;
283     accepted_socket.reset(new TCPSocket(sock, *this));
284   }
285 
286   if (!accepted_socket)
287     return error;
288 
289   // Keep our TCP packets coming without any delays.
290   accepted_socket->SetOptionNoDelay();
291   error.Clear();
292   conn_socket = accepted_socket.release();
293   return error;
294 }
295 
296 int TCPSocket::SetOptionNoDelay() {
297   return SetOption(IPPROTO_TCP, TCP_NODELAY, 1);
298 }
299 
300 int TCPSocket::SetOptionReuseAddress() {
301   return SetOption(SOL_SOCKET, SO_REUSEADDR, 1);
302 }
303