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 
19 SBCommunication::SBCommunication() { LLDB_INSTRUMENT_VA(this); }
20 
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 
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 
33 bool SBCommunication::IsValid() const {
34   LLDB_INSTRUMENT_VA(this);
35   return this->operator bool();
36 }
37 SBCommunication::operator bool() const {
38   LLDB_INSTRUMENT_VA(this);
39 
40   return m_opaque != nullptr;
41 }
42 
43 bool SBCommunication::GetCloseOnEOF() {
44   LLDB_INSTRUMENT_VA(this);
45 
46   if (m_opaque)
47     return m_opaque->GetCloseOnEOF();
48   return false;
49 }
50 
51 void SBCommunication::SetCloseOnEOF(bool b) {
52   LLDB_INSTRUMENT_VA(this, b);
53 
54   if (m_opaque)
55     m_opaque->SetCloseOnEOF(b);
56 }
57 
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 
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 
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 
97 bool SBCommunication::IsConnected() const {
98   LLDB_INSTRUMENT_VA(this);
99 
100   return m_opaque ? m_opaque->IsConnected() : false;
101 }
102 
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 
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 
132 bool SBCommunication::ReadThreadStart() {
133   LLDB_INSTRUMENT_VA(this);
134 
135   return m_opaque ? m_opaque->StartReadThread() : false;
136 }
137 
138 bool SBCommunication::ReadThreadStop() {
139   LLDB_INSTRUMENT_VA(this);
140 
141   return m_opaque ? m_opaque->StopReadThread() : false;
142 }
143 
144 bool SBCommunication::ReadThreadIsRunning() {
145   LLDB_INSTRUMENT_VA(this);
146 
147   return m_opaque ? m_opaque->ReadThreadIsRunning() : false;
148 }
149 
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 
162 SBBroadcaster SBCommunication::GetBroadcaster() {
163   LLDB_INSTRUMENT_VA(this);
164 
165   SBBroadcaster broadcaster(m_opaque, false);
166   return broadcaster;
167 }
168 
169 const char *SBCommunication::GetBroadcasterClass() {
170   LLDB_INSTRUMENT();
171 
172   return Communication::GetStaticBroadcasterClass().AsCString();
173 }
174