1 //===-- SBCommunication.cpp -----------------------------------------------===//
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 "lldb/API/SBCommunication.h"
10 #include "lldb/API/SBBroadcaster.h"
11 #include "lldb/Core/Communication.h"
12 #include "lldb/Host/ConnectionFileDescriptor.h"
13 #include "lldb/Host/Host.h"
14 #include "lldb/Utility/Instrumentation.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18
SBCommunication()19 SBCommunication::SBCommunication() { LLDB_INSTRUMENT_VA(this); }
20
SBCommunication(const char * broadcaster_name)21 SBCommunication::SBCommunication(const char *broadcaster_name)
22 : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
23 LLDB_INSTRUMENT_VA(this, broadcaster_name);
24 }
25
~SBCommunication()26 SBCommunication::~SBCommunication() {
27 if (m_opaque && m_opaque_owned)
28 delete m_opaque;
29 m_opaque = nullptr;
30 m_opaque_owned = false;
31 }
32
IsValid() const33 bool SBCommunication::IsValid() const {
34 LLDB_INSTRUMENT_VA(this);
35 return this->operator bool();
36 }
operator bool() const37 SBCommunication::operator bool() const {
38 LLDB_INSTRUMENT_VA(this);
39
40 return m_opaque != nullptr;
41 }
42
GetCloseOnEOF()43 bool SBCommunication::GetCloseOnEOF() {
44 LLDB_INSTRUMENT_VA(this);
45
46 if (m_opaque)
47 return m_opaque->GetCloseOnEOF();
48 return false;
49 }
50
SetCloseOnEOF(bool b)51 void SBCommunication::SetCloseOnEOF(bool b) {
52 LLDB_INSTRUMENT_VA(this, b);
53
54 if (m_opaque)
55 m_opaque->SetCloseOnEOF(b);
56 }
57
Connect(const char * url)58 ConnectionStatus SBCommunication::Connect(const char *url) {
59 LLDB_INSTRUMENT_VA(this, url);
60
61 if (m_opaque) {
62 if (!m_opaque->HasConnection())
63 m_opaque->SetConnection(Host::CreateDefaultConnection(url));
64 return m_opaque->Connect(url, nullptr);
65 }
66 return eConnectionStatusNoConnection;
67 }
68
AdoptFileDesriptor(int fd,bool owns_fd)69 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
70 LLDB_INSTRUMENT_VA(this, fd, owns_fd);
71
72 ConnectionStatus status = eConnectionStatusNoConnection;
73 if (m_opaque) {
74 if (m_opaque->HasConnection()) {
75 if (m_opaque->IsConnected())
76 m_opaque->Disconnect();
77 }
78 m_opaque->SetConnection(
79 std::make_unique<ConnectionFileDescriptor>(fd, owns_fd));
80 if (m_opaque->IsConnected())
81 status = eConnectionStatusSuccess;
82 else
83 status = eConnectionStatusLostConnection;
84 }
85 return status;
86 }
87
Disconnect()88 ConnectionStatus SBCommunication::Disconnect() {
89 LLDB_INSTRUMENT_VA(this);
90
91 ConnectionStatus status = eConnectionStatusNoConnection;
92 if (m_opaque)
93 status = m_opaque->Disconnect();
94 return status;
95 }
96
IsConnected() const97 bool SBCommunication::IsConnected() const {
98 LLDB_INSTRUMENT_VA(this);
99
100 return m_opaque ? m_opaque->IsConnected() : false;
101 }
102
Read(void * dst,size_t dst_len,uint32_t timeout_usec,ConnectionStatus & status)103 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
104 ConnectionStatus &status) {
105 LLDB_INSTRUMENT_VA(this, dst, dst_len, timeout_usec, status);
106
107 size_t bytes_read = 0;
108 Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
109 ? Timeout<std::micro>(llvm::None)
110 : std::chrono::microseconds(timeout_usec);
111 if (m_opaque)
112 bytes_read = m_opaque->Read(dst, dst_len, timeout, status, nullptr);
113 else
114 status = eConnectionStatusNoConnection;
115
116 return bytes_read;
117 }
118
Write(const void * src,size_t src_len,ConnectionStatus & status)119 size_t SBCommunication::Write(const void *src, size_t src_len,
120 ConnectionStatus &status) {
121 LLDB_INSTRUMENT_VA(this, src, src_len, status);
122
123 size_t bytes_written = 0;
124 if (m_opaque)
125 bytes_written = m_opaque->Write(src, src_len, status, nullptr);
126 else
127 status = eConnectionStatusNoConnection;
128
129 return bytes_written;
130 }
131
ReadThreadStart()132 bool SBCommunication::ReadThreadStart() {
133 LLDB_INSTRUMENT_VA(this);
134
135 return m_opaque ? m_opaque->StartReadThread() : false;
136 }
137
ReadThreadStop()138 bool SBCommunication::ReadThreadStop() {
139 LLDB_INSTRUMENT_VA(this);
140
141 return m_opaque ? m_opaque->StopReadThread() : false;
142 }
143
ReadThreadIsRunning()144 bool SBCommunication::ReadThreadIsRunning() {
145 LLDB_INSTRUMENT_VA(this);
146
147 return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
148 }
149
SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived callback,void * callback_baton)150 bool SBCommunication::SetReadThreadBytesReceivedCallback(
151 ReadThreadBytesReceived callback, void *callback_baton) {
152 LLDB_INSTRUMENT_VA(this, callback, callback_baton);
153
154 bool result = false;
155 if (m_opaque) {
156 m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
157 result = true;
158 }
159 return result;
160 }
161
GetBroadcaster()162 SBBroadcaster SBCommunication::GetBroadcaster() {
163 LLDB_INSTRUMENT_VA(this);
164
165 SBBroadcaster broadcaster(m_opaque, false);
166 return broadcaster;
167 }
168
GetBroadcasterClass()169 const char *SBCommunication::GetBroadcasterClass() {
170 LLDB_INSTRUMENT();
171
172 return Communication::GetStaticBroadcasterClass().AsCString();
173 }
174