1 //===-- SBCommunication.cpp -----------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/API/SBCommunication.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBBroadcaster.h"
12 #include "lldb/Core/Communication.h"
13 #include "lldb/Host/ConnectionFileDescriptor.h"
14 #include "lldb/Host/Host.h"
17 using namespace lldb_private;
19 SBCommunication::SBCommunication() : m_opaque(nullptr), m_opaque_owned(false) {
20 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
23 SBCommunication::SBCommunication(const char *broadcaster_name)
24 : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
25 LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
28 SBCommunication::~SBCommunication() {
29 if (m_opaque && m_opaque_owned)
32 m_opaque_owned = false;
35 bool SBCommunication::IsValid() const {
36 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
37 return this->operator bool();
39 SBCommunication::operator bool() const {
40 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
42 return m_opaque != nullptr;
45 bool SBCommunication::GetCloseOnEOF() {
46 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
49 return m_opaque->GetCloseOnEOF();
53 void SBCommunication::SetCloseOnEOF(bool b) {
54 LLDB_RECORD_METHOD(void, SBCommunication, SetCloseOnEOF, (bool), b);
57 m_opaque->SetCloseOnEOF(b);
60 ConnectionStatus SBCommunication::Connect(const char *url) {
61 LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
65 if (!m_opaque->HasConnection())
66 m_opaque->SetConnection(Host::CreateDefaultConnection(url));
67 return m_opaque->Connect(url, nullptr);
69 return eConnectionStatusNoConnection;
72 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
73 LLDB_RECORD_METHOD(lldb::ConnectionStatus, SBCommunication,
74 AdoptFileDesriptor, (int, bool), fd, owns_fd);
76 ConnectionStatus status = eConnectionStatusNoConnection;
78 if (m_opaque->HasConnection()) {
79 if (m_opaque->IsConnected())
80 m_opaque->Disconnect();
82 m_opaque->SetConnection(
83 std::make_unique<ConnectionFileDescriptor>(fd, owns_fd));
84 if (m_opaque->IsConnected())
85 status = eConnectionStatusSuccess;
87 status = eConnectionStatusLostConnection;
92 ConnectionStatus SBCommunication::Disconnect() {
93 LLDB_RECORD_METHOD_NO_ARGS(lldb::ConnectionStatus, SBCommunication,
96 ConnectionStatus status = eConnectionStatusNoConnection;
98 status = m_opaque->Disconnect();
102 bool SBCommunication::IsConnected() const {
103 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsConnected);
105 return m_opaque ? m_opaque->IsConnected() : false;
108 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
109 ConnectionStatus &status) {
110 LLDB_RECORD_DUMMY(size_t, SBCommunication, Read,
111 (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
112 dst_len, timeout_usec, status);
114 size_t bytes_read = 0;
115 Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
116 ? Timeout<std::micro>(llvm::None)
117 : std::chrono::microseconds(timeout_usec);
119 bytes_read = m_opaque->Read(dst, dst_len, timeout, status, nullptr);
121 status = eConnectionStatusNoConnection;
126 size_t SBCommunication::Write(const void *src, size_t src_len,
127 ConnectionStatus &status) {
128 LLDB_RECORD_DUMMY(size_t, SBCommunication, Write,
129 (const void *, size_t, lldb::ConnectionStatus &), src,
132 size_t bytes_written = 0;
134 bytes_written = m_opaque->Write(src, src_len, status, nullptr);
136 status = eConnectionStatusNoConnection;
138 return bytes_written;
141 bool SBCommunication::ReadThreadStart() {
142 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStart);
144 return m_opaque ? m_opaque->StartReadThread() : false;
147 bool SBCommunication::ReadThreadStop() {
148 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadStop);
150 return m_opaque ? m_opaque->StopReadThread() : false;
153 bool SBCommunication::ReadThreadIsRunning() {
154 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, ReadThreadIsRunning);
156 return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
159 bool SBCommunication::SetReadThreadBytesReceivedCallback(
160 ReadThreadBytesReceived callback, void *callback_baton) {
161 LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
162 (lldb::SBCommunication::ReadThreadBytesReceived, void *),
163 callback, callback_baton);
167 m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
173 SBBroadcaster SBCommunication::GetBroadcaster() {
174 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBCommunication,
177 SBBroadcaster broadcaster(m_opaque, false);
178 return LLDB_RECORD_RESULT(broadcaster);
181 const char *SBCommunication::GetBroadcasterClass() {
182 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBCommunication,
183 GetBroadcasterClass);
185 return Communication::GetStaticBroadcasterClass().AsCString();
188 namespace lldb_private {
192 void RegisterMethods<SBCommunication>(Registry &R) {
193 LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
194 LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
195 LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
196 LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
197 LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
198 LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
199 LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
201 LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
202 AdoptFileDesriptor, (int, bool));
203 LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
205 LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsConnected, ());
206 LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStart, ());
207 LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadStop, ());
208 LLDB_REGISTER_METHOD(bool, SBCommunication, ReadThreadIsRunning, ());
209 LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommunication, GetBroadcaster,
211 LLDB_REGISTER_STATIC_METHOD(const char *, SBCommunication,
212 GetBroadcasterClass, ());