Socket.cpp revision 360660 
150472Speter//===-- Socket.cpp ----------------------------------------------*- C++ -*-===//
233975Sjdp//
333975Sjdp// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
433975Sjdp// See https://llvm.org/LICENSE.txt for license information.
592840Sobrien// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
633975Sjdp//
784955Sobrien//===----------------------------------------------------------------------===//
884955Sobrien
9130575Sobrien#include "lldb/Host/Socket.h"
1084955Sobrien
1184955Sobrien#include "lldb/Host/Config.h"
12113398Sru#include "lldb/Host/Host.h"
13113398Sru#include "lldb/Host/SocketAddress.h"
14113398Sru#include "lldb/Host/StringConvert.h"
1584955Sobrien#include "lldb/Host/common/TCPSocket.h"
1633975Sjdp#include "lldb/Host/common/UDPSocket.h"
1733975Sjdp#include "lldb/Utility/Log.h"
18#include "lldb/Utility/RegularExpression.h"
19
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/Support/Errno.h"
22#include "llvm/Support/Error.h"
23#include "llvm/Support/WindowsError.h"
24
25#ifndef LLDB_DISABLE_POSIX
26#include "lldb/Host/posix/DomainSocket.h"
27
28#include <arpa/inet.h>
29#include <netdb.h>
30#include <netinet/in.h>
31#include <netinet/tcp.h>
32#include <sys/socket.h>
33#include <sys/un.h>
34#include <unistd.h>
35#endif
36
37#ifdef __linux__
38#include "lldb/Host/linux/AbstractSocket.h"
39#endif
40
41#ifdef __ANDROID__
42#include <arpa/inet.h>
43#include <asm-generic/errno-base.h>
44#include <errno.h>
45#include <linux/tcp.h>
46#include <fcntl.h>
47#include <sys/syscall.h>
48#include <unistd.h>
49#endif // __ANDROID__
50
51using namespace lldb;
52using namespace lldb_private;
53
54#if defined(_WIN32)
55typedef const char *set_socket_option_arg_type;
56typedef char *get_socket_option_arg_type;
57const NativeSocket Socket::kInvalidSocketValue = INVALID_SOCKET;
58#else  // #if defined(_WIN32)
59typedef const void *set_socket_option_arg_type;
60typedef void *get_socket_option_arg_type;
61const NativeSocket Socket::kInvalidSocketValue = -1;
62#endif // #if defined(_WIN32)
63
64namespace {
65
66bool IsInterrupted() {
67#if defined(_WIN32)
68  return ::WSAGetLastError() == WSAEINTR;
69#else
70  return errno == EINTR;
71#endif
72}
73}
74
75Socket::Socket(SocketProtocol protocol, bool should_close,
76               bool child_processes_inherit)
77    : IOObject(eFDTypeSocket, should_close), m_protocol(protocol),
78      m_socket(kInvalidSocketValue),
79      m_child_processes_inherit(child_processes_inherit) {}
80
81Socket::~Socket() { Close(); }
82
83llvm::Error Socket::Initialize() {
84#if defined(_WIN32)
85  auto wVersion = WINSOCK_VERSION;
86  WSADATA wsaData;
87  int err = ::WSAStartup(wVersion, &wsaData);
88  if (err == 0) {
89    if (wsaData.wVersion < wVersion) {
90      WSACleanup();
91      return llvm::make_error<llvm::StringError>(
92          "WSASock version is not expected.", llvm::inconvertibleErrorCode());
93    }
94  } else {
95    return llvm::errorCodeToError(llvm::mapWindowsError(::WSAGetLastError()));
96  }
97#endif
98
99  return llvm::Error::success();
100}
101
102void Socket::Terminate() {
103#if defined(_WIN32)
104  ::WSACleanup();
105#endif
106}
107
108std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
109                                       bool child_processes_inherit,
110                                       Status &error) {
111  error.Clear();
112
113  std::unique_ptr<Socket> socket_up;
114  switch (protocol) {
115  case ProtocolTcp:
116    socket_up =
117        llvm::make_unique<TCPSocket>(true, child_processes_inherit);
118    break;
119  case ProtocolUdp:
120    socket_up =
121        llvm::make_unique<UDPSocket>(true, child_processes_inherit);
122    break;
123  case ProtocolUnixDomain:
124#ifndef LLDB_DISABLE_POSIX
125    socket_up =
126        llvm::make_unique<DomainSocket>(true, child_processes_inherit);
127#else
128    error.SetErrorString(
129        "Unix domain sockets are not supported on this platform.");
130#endif
131    break;
132  case ProtocolUnixAbstract:
133#ifdef __linux__
134    socket_up =
135        llvm::make_unique<AbstractSocket>(child_processes_inherit);
136#else
137    error.SetErrorString(
138        "Abstract domain sockets are not supported on this platform.");
139#endif
140    break;
141  }
142
143  if (error.Fail())
144    socket_up.reset();
145
146  return socket_up;
147}
148
149Status Socket::TcpConnect(llvm::StringRef host_and_port,
150                          bool child_processes_inherit, Socket *&socket) {
151  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
152  if (log)
153    log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
154                host_and_port.str().c_str());
155
156  Status error;
157  std::unique_ptr<Socket> connect_socket(
158      Create(ProtocolTcp, child_processes_inherit, error));
159  if (error.Fail())
160    return error;
161
162  error = connect_socket->Connect(host_and_port);
163  if (error.Success())
164    socket = connect_socket.release();
165
166  return error;
167}
168
169Status Socket::TcpListen(llvm::StringRef host_and_port,
170                         bool child_processes_inherit, Socket *&socket,
171                         Predicate<uint16_t> *predicate, int backlog) {
172  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
173  if (log)
174    log->Printf("Socket::%s (%s)", __FUNCTION__, host_and_port.str().c_str());
175
176  Status error;
177  std::string host_str;
178  std::string port_str;
179  int32_t port = INT32_MIN;
180  if (!DecodeHostAndPort(host_and_port, host_str, port_str, port, &error))
181    return error;
182
183  std::unique_ptr<TCPSocket> listen_socket(
184      new TCPSocket(true, child_processes_inherit));
185  if (error.Fail())
186    return error;
187
188  error = listen_socket->Listen(host_and_port, backlog);
189  if (error.Success()) {
190    // We were asked to listen on port zero which means we must now read the
191    // actual port that was given to us as port zero is a special code for
192    // "find an open port for me".
193    if (port == 0)
194      port = listen_socket->GetLocalPortNumber();
195
196    // Set the port predicate since when doing a listen://<host>:<port> it
197    // often needs to accept the incoming connection which is a blocking system
198    // call. Allowing access to the bound port using a predicate allows us to
199    // wait for the port predicate to be set to a non-zero value from another
200    // thread in an efficient manor.
201    if (predicate)
202      predicate->SetValue(port, eBroadcastAlways);
203    socket = listen_socket.release();
204  }
205
206  return error;
207}
208
209Status Socket::UdpConnect(llvm::StringRef host_and_port,
210                          bool child_processes_inherit, Socket *&socket) {
211  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
212  if (log)
213    log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
214                host_and_port.str().c_str());
215
216  return UDPSocket::Connect(host_and_port, child_processes_inherit, socket);
217}
218
219Status Socket::UnixDomainConnect(llvm::StringRef name,
220                                 bool child_processes_inherit,
221                                 Socket *&socket) {
222  Status error;
223  std::unique_ptr<Socket> connect_socket(
224      Create(ProtocolUnixDomain, child_processes_inherit, error));
225  if (error.Fail())
226    return error;
227
228  error = connect_socket->Connect(name);
229  if (error.Success())
230    socket = connect_socket.release();
231
232  return error;
233}
234
235Status Socket::UnixDomainAccept(llvm::StringRef name,
236                                bool child_processes_inherit, Socket *&socket) {
237  Status error;
238  std::unique_ptr<Socket> listen_socket(
239      Create(ProtocolUnixDomain, child_processes_inherit, error));
240  if (error.Fail())
241    return error;
242
243  error = listen_socket->Listen(name, 5);
244  if (error.Fail())
245    return error;
246
247  error = listen_socket->Accept(socket);
248  return error;
249}
250
251Status Socket::UnixAbstractConnect(llvm::StringRef name,
252                                   bool child_processes_inherit,
253                                   Socket *&socket) {
254  Status error;
255  std::unique_ptr<Socket> connect_socket(
256      Create(ProtocolUnixAbstract, child_processes_inherit, error));
257  if (error.Fail())
258    return error;
259
260  error = connect_socket->Connect(name);
261  if (error.Success())
262    socket = connect_socket.release();
263  return error;
264}
265
266Status Socket::UnixAbstractAccept(llvm::StringRef name,
267                                  bool child_processes_inherit,
268                                  Socket *&socket) {
269  Status error;
270  std::unique_ptr<Socket> listen_socket(
271      Create(ProtocolUnixAbstract, child_processes_inherit, error));
272  if (error.Fail())
273    return error;
274
275  error = listen_socket->Listen(name, 5);
276  if (error.Fail())
277    return error;
278
279  error = listen_socket->Accept(socket);
280  return error;
281}
282
283bool Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
284                               std::string &host_str, std::string &port_str,
285                               int32_t &port, Status *error_ptr) {
286  static RegularExpression g_regex(
287      llvm::StringRef("([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)"));
288  RegularExpression::Match regex_match(2);
289  if (g_regex.Execute(host_and_port, &regex_match)) {
290    if (regex_match.GetMatchAtIndex(host_and_port, 1, host_str) &&
291        regex_match.GetMatchAtIndex(host_and_port, 2, port_str)) {
292      // IPv6 addresses are wrapped in [] when specified with ports
293      if (host_str.front() == '[' && host_str.back() == ']')
294        host_str = host_str.substr(1, host_str.size() - 2);
295      bool ok = false;
296      port = StringConvert::ToUInt32(port_str.c_str(), UINT32_MAX, 10, &ok);
297      if (ok && port <= UINT16_MAX) {
298        if (error_ptr)
299          error_ptr->Clear();
300        return true;
301      }
302      // port is too large
303      if (error_ptr)
304        error_ptr->SetErrorStringWithFormat(
305            "invalid host:port specification: '%s'",
306            host_and_port.str().c_str());
307      return false;
308    }
309  }
310
311  // If this was unsuccessful, then check if it's simply a signed 32-bit
312  // integer, representing a port with an empty host.
313  host_str.clear();
314  port_str.clear();
315  if (to_integer(host_and_port, port, 10) && port < UINT16_MAX) {
316    port_str = host_and_port;
317    if (error_ptr)
318      error_ptr->Clear();
319    return true;
320  }
321
322  if (error_ptr)
323    error_ptr->SetErrorStringWithFormat("invalid host:port specification: '%s'",
324                                        host_and_port.str().c_str());
325  return false;
326}
327
328IOObject::WaitableHandle Socket::GetWaitableHandle() {
329  // TODO: On Windows, use WSAEventSelect
330  return m_socket;
331}
332
333Status Socket::Read(void *buf, size_t &num_bytes) {
334  Status error;
335  int bytes_received = 0;
336  do {
337    bytes_received = ::recv(m_socket, static_cast<char *>(buf), num_bytes, 0);
338  } while (bytes_received < 0 && IsInterrupted());
339
340  if (bytes_received < 0) {
341    SetLastError(error);
342    num_bytes = 0;
343  } else
344    num_bytes = bytes_received;
345
346  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
347  if (log) {
348    log->Printf("%p Socket::Read() (socket = %" PRIu64
349                ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64
350                " (error = %s)",
351                static_cast<void *>(this), static_cast<uint64_t>(m_socket), buf,
352                static_cast<uint64_t>(num_bytes),
353                static_cast<int64_t>(bytes_received), error.AsCString());
354  }
355
356  return error;
357}
358
359Status Socket::Write(const void *buf, size_t &num_bytes) {
360  Status error;
361  int bytes_sent = 0;
362  do {
363    bytes_sent = Send(buf, num_bytes);
364  } while (bytes_sent < 0 && IsInterrupted());
365
366  if (bytes_sent < 0) {
367    SetLastError(error);
368    num_bytes = 0;
369  } else
370    num_bytes = bytes_sent;
371
372  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
373  if (log) {
374    log->Printf("%p Socket::Write() (socket = %" PRIu64
375                ", src = %p, src_len = %" PRIu64 ", flags = 0) => %" PRIi64
376                " (error = %s)",
377                static_cast<void *>(this), static_cast<uint64_t>(m_socket), buf,
378                static_cast<uint64_t>(num_bytes),
379                static_cast<int64_t>(bytes_sent), error.AsCString());
380  }
381
382  return error;
383}
384
385Status Socket::PreDisconnect() {
386  Status error;
387  return error;
388}
389
390Status Socket::Close() {
391  Status error;
392  if (!IsValid() || !m_should_close_fd)
393    return error;
394
395  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
396  if (log)
397    log->Printf("%p Socket::Close (fd = %" PRIu64 ")",
398                static_cast<void *>(this), static_cast<uint64_t>(m_socket));
399
400#if defined(_WIN32)
401  bool success = !!closesocket(m_socket);
402#else
403  bool success = !!::close(m_socket);
404#endif
405  // A reference to a FD was passed in, set it to an invalid value
406  m_socket = kInvalidSocketValue;
407  if (!success) {
408    SetLastError(error);
409  }
410
411  return error;
412}
413
414int Socket::GetOption(int level, int option_name, int &option_value) {
415  get_socket_option_arg_type option_value_p =
416      reinterpret_cast<get_socket_option_arg_type>(&option_value);
417  socklen_t option_value_size = sizeof(int);
418  return ::getsockopt(m_socket, level, option_name, option_value_p,
419                      &option_value_size);
420}
421
422int Socket::SetOption(int level, int option_name, int option_value) {
423  set_socket_option_arg_type option_value_p =
424      reinterpret_cast<get_socket_option_arg_type>(&option_value);
425  return ::setsockopt(m_socket, level, option_name, option_value_p,
426                      sizeof(option_value));
427}
428
429size_t Socket::Send(const void *buf, const size_t num_bytes) {
430  return ::send(m_socket, static_cast<const char *>(buf), num_bytes, 0);
431}
432
433void Socket::SetLastError(Status &error) {
434#if defined(_WIN32)
435  error.SetError(::WSAGetLastError(), lldb::eErrorTypeWin32);
436#else
437  error.SetErrorToErrno();
438#endif
439}
440
441NativeSocket Socket::CreateSocket(const int domain, const int type,
442                                  const int protocol,
443                                  bool child_processes_inherit, Status &error) {
444  error.Clear();
445  auto socket_type = type;
446#ifdef SOCK_CLOEXEC
447  if (!child_processes_inherit)
448    socket_type |= SOCK_CLOEXEC;
449#endif
450  auto sock = ::socket(domain, socket_type, protocol);
451  if (sock == kInvalidSocketValue)
452    SetLastError(error);
453
454  return sock;
455}
456
457NativeSocket Socket::AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
458                                  socklen_t *addrlen,
459                                  bool child_processes_inherit, Status &error) {
460  error.Clear();
461#if defined(ANDROID_USE_ACCEPT_WORKAROUND)
462  // Hack:
463  // This enables static linking lldb-server to an API 21 libc, but still
464  // having it run on older devices. It is necessary because API 21 libc's
465  // implementation of accept() uses the accept4 syscall(), which is not
466  // available in older kernels. Using an older libc would fix this issue, but
467  // introduce other ones, as the old libraries were quite buggy.
468  int fd = syscall(__NR_accept, sockfd, addr, addrlen);
469  if (fd >= 0 && !child_processes_inherit) {
470    int flags = ::fcntl(fd, F_GETFD);
471    if (flags != -1 && ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1)
472      return fd;
473    SetLastError(error);
474    close(fd);
475  }
476  return fd;
477#elif defined(SOCK_CLOEXEC) && defined(HAVE_ACCEPT4)
478  int flags = 0;
479  if (!child_processes_inherit) {
480    flags |= SOCK_CLOEXEC;
481  }
482  NativeSocket fd = llvm::sys::RetryAfterSignal(-1, ::accept4,
483      sockfd, addr, addrlen, flags);
484#else
485  NativeSocket fd = llvm::sys::RetryAfterSignal(-1, ::accept,
486      sockfd, addr, addrlen);
487#endif
488  if (fd == kInvalidSocketValue)
489    SetLastError(error);
490  return fd;
491}
492