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