Coverage Report

Created: 2022-01-18 06:27

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