source/API/SBCommunication.cpp

   1 //===-- SBCommunication.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBCommunication.h"
  11 #include "lldb/API/SBBroadcaster.h"
  12 #include "lldb/Core/Communication.h"
  13 #include "lldb/Core/Log.h"
  14 #include "lldb/Host/ConnectionFileDescriptor.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {}
  20
  21 SBCommunication::SBCommunication(const char *broadcaster_name)
  22     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
  23   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  24
  25   if (log)
  26     log->Printf("SBCommunication::SBCommunication (broadcaster_name=\"%s\") => "
  27                 "SBCommunication(%p)",
  28                 broadcaster_name, static_cast<void *>(m_opaque));
  29 }
  30
  31 SBCommunication::~SBCommunication() {
  32   if (m_opaque && m_opaque_owned)
  33     delete m_opaque;
  34   m_opaque = NULL;
  35   m_opaque_owned = false;
  36 }
  37
  38 bool SBCommunication::IsValid() const { return m_opaque != NULL; }
  39
  40 bool SBCommunication::GetCloseOnEOF() {
  41   if (m_opaque)
  42     return m_opaque->GetCloseOnEOF();
  43   return false;
  44 }
  45
  46 void SBCommunication::SetCloseOnEOF(bool b) {
  47   if (m_opaque)
  48     m_opaque->SetCloseOnEOF(b);
  49 }
  50
  51 ConnectionStatus SBCommunication::Connect(const char *url) {
  52   if (m_opaque) {
  53     if (!m_opaque->HasConnection())
  54       m_opaque->SetConnection(Connection::CreateDefaultConnection(url));
  55     return m_opaque->Connect(url, NULL);
  56   }
  57   return eConnectionStatusNoConnection;
  58 }
  59
  60 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
  61   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  62
  63   ConnectionStatus status = eConnectionStatusNoConnection;
  64   if (m_opaque) {
  65     if (m_opaque->HasConnection()) {
  66       if (m_opaque->IsConnected())
  67         m_opaque->Disconnect();
  68     }
  69     m_opaque->SetConnection(new ConnectionFileDescriptor(fd, owns_fd));
  70     if (m_opaque->IsConnected())
  71       status = eConnectionStatusSuccess;
  72     else
  73       status = eConnectionStatusLostConnection;
  74   }
  75
  76   if (log)
  77     log->Printf(
  78         "SBCommunication(%p)::AdoptFileDescriptor (fd=%d, ownd_fd=%i) => %s",
  79         static_cast<void *>(m_opaque), fd, owns_fd,
  80         Communication::ConnectionStatusAsCString(status));
  81
  82   return status;
  83 }
  84
  85 ConnectionStatus SBCommunication::Disconnect() {
  86   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  87
  88   ConnectionStatus status = eConnectionStatusNoConnection;
  89   if (m_opaque)
  90     status = m_opaque->Disconnect();
  91
  92   if (log)
  93     log->Printf("SBCommunication(%p)::Disconnect () => %s",
  94                 static_cast<void *>(m_opaque),
  95                 Communication::ConnectionStatusAsCString(status));
  96
  97   return status;
  98 }
  99
 100 bool SBCommunication::IsConnected() const {
 101   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 102   bool result = false;
 103   if (m_opaque)
 104     result = m_opaque->IsConnected();
 105
 106   if (log)
 107     log->Printf("SBCommunication(%p)::IsConnected () => %i",
 108                 static_cast<void *>(m_opaque), result);
 109
 110   return false;
 111 }
 112
 113 size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
 114                              ConnectionStatus &status) {
 115   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 116   if (log)
 117     log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
 118                 ", timeout_usec=%u, &status)...",
 119                 static_cast<void *>(m_opaque), static_cast<void *>(dst),
 120                 static_cast<uint64_t>(dst_len), timeout_usec);
 121   size_t bytes_read = 0;
 122   Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
 123                                     ? Timeout<std::micro>(llvm::None)
 124                                     : std::chrono::microseconds(timeout_usec);
 125   if (m_opaque)
 126     bytes_read = m_opaque->Read(dst, dst_len, timeout, status, NULL);
 127   else
 128     status = eConnectionStatusNoConnection;
 129
 130   if (log)
 131     log->Printf("SBCommunication(%p)::Read (dst=%p, dst_len=%" PRIu64
 132                 ", timeout_usec=%u, &status=%s) => %" PRIu64,
 133                 static_cast<void *>(m_opaque), static_cast<void *>(dst),
 134                 static_cast<uint64_t>(dst_len), timeout_usec,
 135                 Communication::ConnectionStatusAsCString(status),
 136                 static_cast<uint64_t>(bytes_read));
 137   return bytes_read;
 138 }
 139
 140 size_t SBCommunication::Write(const void *src, size_t src_len,
 141                               ConnectionStatus &status) {
 142   size_t bytes_written = 0;
 143   if (m_opaque)
 144     bytes_written = m_opaque->Write(src, src_len, status, NULL);
 145   else
 146     status = eConnectionStatusNoConnection;
 147
 148   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 149   if (log)
 150     log->Printf("SBCommunication(%p)::Write (src=%p, src_len=%" PRIu64
 151                 ", &status=%s) => %" PRIu64,
 152                 static_cast<void *>(m_opaque), static_cast<const void *>(src),
 153                 static_cast<uint64_t>(src_len),
 154                 Communication::ConnectionStatusAsCString(status),
 155                 static_cast<uint64_t>(bytes_written));
 156
 157   return 0;
 158 }
 159
 160 bool SBCommunication::ReadThreadStart() {
 161   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 162
 163   bool success = false;
 164   if (m_opaque)
 165     success = m_opaque->StartReadThread();
 166
 167   if (log)
 168     log->Printf("SBCommunication(%p)::ReadThreadStart () => %i",
 169                 static_cast<void *>(m_opaque), success);
 170
 171   return success;
 172 }
 173
 174 bool SBCommunication::ReadThreadStop() {
 175   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 176   if (log)
 177     log->Printf("SBCommunication(%p)::ReadThreadStop ()...",
 178                 static_cast<void *>(m_opaque));
 179
 180   bool success = false;
 181   if (m_opaque)
 182     success = m_opaque->StopReadThread();
 183
 184   if (log)
 185     log->Printf("SBCommunication(%p)::ReadThreadStop () => %i",
 186                 static_cast<void *>(m_opaque), success);
 187
 188   return success;
 189 }
 190
 191 bool SBCommunication::ReadThreadIsRunning() {
 192   bool result = false;
 193   if (m_opaque)
 194     result = m_opaque->ReadThreadIsRunning();
 195   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 196   if (log)
 197     log->Printf("SBCommunication(%p)::ReadThreadIsRunning () => %i",
 198                 static_cast<void *>(m_opaque), result);
 199   return result;
 200 }
 201
 202 bool SBCommunication::SetReadThreadBytesReceivedCallback(
 203     ReadThreadBytesReceived callback, void *callback_baton) {
 204   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 205
 206   bool result = false;
 207   if (m_opaque) {
 208     m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
 209     result = true;
 210   }
 211
 212   if (log)
 213     log->Printf("SBCommunication(%p)::SetReadThreadBytesReceivedCallback "
 214                 "(callback=%p, baton=%p) => %i",
 215                 static_cast<void *>(m_opaque),
 216                 reinterpret_cast<void *>(reinterpret_cast<intptr_t>(callback)),
 217                 static_cast<void *>(callback_baton), result);
 218
 219   return result;
 220 }
 221
 222 SBBroadcaster SBCommunication::GetBroadcaster() {
 223   SBBroadcaster broadcaster(m_opaque, false);
 224
 225   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 226
 227   if (log)
 228     log->Printf("SBCommunication(%p)::GetBroadcaster () => SBBroadcaster (%p)",
 229                 static_cast<void *>(m_opaque),
 230                 static_cast<void *>(broadcaster.get()));
 231
 232   return broadcaster;
 233 }
 234
 235 const char *SBCommunication::GetBroadcasterClass() {
 236   return Communication::GetStaticBroadcasterClass().AsCString();
 237 }
 238
 239 //
 240 // void
 241 // SBCommunication::CreateIfNeeded ()
 242 //{
 243 //    if (m_opaque == NULL)
 244 //    {
 245 //        static uint32_t g_broadcaster_num;
 246 //        char broadcaster_name[256];
 247 //        ::snprintf (name, broadcaster_name, "%p SBCommunication", this);
 248 //        m_opaque = new Communication (broadcaster_name);
 249 //        m_opaque_owned = true;
 250 //    }
 251 //    assert (m_opaque);
 252 //}
 253 //
 254 //