contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

   1 //===-- GDBRemoteCommunication.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
  11 #include "GDBRemoteCommunication.h"
  12
  13 // C Includes
  14 #include <limits.h>
  15 #include <string.h>
  16 #include <sys/stat.h>
  17
  18 // C++ Includes
  19 // Other libraries and framework includes
  20 #include "lldb/Core/Log.h"
  21 #include "lldb/Core/RegularExpression.h"
  22 #include "lldb/Core/StreamFile.h"
  23 #include "lldb/Core/StreamString.h"
  24 #include "lldb/Host/ConnectionFileDescriptor.h"
  25 #include "lldb/Host/FileSpec.h"
  26 #include "lldb/Host/Host.h"
  27 #include "lldb/Host/HostInfo.h"
  28 #include "lldb/Host/Pipe.h"
  29 #include "lldb/Host/Socket.h"
  30 #include "lldb/Host/StringConvert.h"
  31 #include "lldb/Host/ThreadLauncher.h"
  32 #include "lldb/Host/TimeValue.h"
  33 #include "lldb/Target/Platform.h"
  34 #include "lldb/Target/Process.h"
  35 #include "llvm/ADT/SmallString.h"
  36
  37 // Project includes
  38 #include "ProcessGDBRemoteLog.h"
  39
  40 #if defined(__APPLE__)
  41 # define DEBUGSERVER_BASENAME    "debugserver"
  42 #else
  43 # define DEBUGSERVER_BASENAME    "lldb-server"
  44 #endif
  45
  46 #if defined (HAVE_LIBCOMPRESSION)
  47 #include <compression.h>
  48 #endif
  49
  50 #if defined (HAVE_LIBZ)
  51 #include <zlib.h>
  52 #endif
  53
  54 using namespace lldb;
  55 using namespace lldb_private;
  56 using namespace lldb_private::process_gdb_remote;
  57
  58 GDBRemoteCommunication::History::History (uint32_t size) :
  59     m_packets(),
  60     m_curr_idx (0),
  61     m_total_packet_count (0),
  62     m_dumped_to_log (false)
  63 {
  64     m_packets.resize(size);
  65 }
  66
  67 GDBRemoteCommunication::History::~History ()
  68 {
  69 }
  70
  71 void
  72 GDBRemoteCommunication::History::AddPacket (char packet_char,
  73                                             PacketType type,
  74                                             uint32_t bytes_transmitted)
  75 {
  76     const size_t size = m_packets.size();
  77     if (size > 0)
  78     {
  79         const uint32_t idx = GetNextIndex();
  80         m_packets[idx].packet.assign (1, packet_char);
  81         m_packets[idx].type = type;
  82         m_packets[idx].bytes_transmitted = bytes_transmitted;
  83         m_packets[idx].packet_idx = m_total_packet_count;
  84         m_packets[idx].tid = Host::GetCurrentThreadID();
  85     }
  86 }
  87
  88 void
  89 GDBRemoteCommunication::History::AddPacket (const std::string &src,
  90                                             uint32_t src_len,
  91                                             PacketType type,
  92                                             uint32_t bytes_transmitted)
  93 {
  94     const size_t size = m_packets.size();
  95     if (size > 0)
  96     {
  97         const uint32_t idx = GetNextIndex();
  98         m_packets[idx].packet.assign (src, 0, src_len);
  99         m_packets[idx].type = type;
 100         m_packets[idx].bytes_transmitted = bytes_transmitted;
 101         m_packets[idx].packet_idx = m_total_packet_count;
 102         m_packets[idx].tid = Host::GetCurrentThreadID();
 103     }
 104 }
 105
 106 void
 107 GDBRemoteCommunication::History::Dump (Stream &strm) const
 108 {
 109     const uint32_t size = GetNumPacketsInHistory ();
 110     const uint32_t first_idx = GetFirstSavedPacketIndex ();
 111     const uint32_t stop_idx = m_curr_idx + size;
 112     for (uint32_t i = first_idx;  i < stop_idx; ++i)
 113     {
 114         const uint32_t idx = NormalizeIndex (i);
 115         const Entry &entry = m_packets[idx];
 116         if (entry.type == ePacketTypeInvalid || entry.packet.empty())
 117             break;
 118         strm.Printf ("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n",
 119                      entry.packet_idx,
 120                      entry.tid,
 121                      entry.bytes_transmitted,
 122                      (entry.type == ePacketTypeSend) ? "send" : "read",
 123                      entry.packet.c_str());
 124     }
 125 }
 126
 127 void
 128 GDBRemoteCommunication::History::Dump (Log *log) const
 129 {
 130     if (log && !m_dumped_to_log)
 131     {
 132         m_dumped_to_log = true;
 133         const uint32_t size = GetNumPacketsInHistory ();
 134         const uint32_t first_idx = GetFirstSavedPacketIndex ();
 135         const uint32_t stop_idx = m_curr_idx + size;
 136         for (uint32_t i = first_idx;  i < stop_idx; ++i)
 137         {
 138             const uint32_t idx = NormalizeIndex (i);
 139             const Entry &entry = m_packets[idx];
 140             if (entry.type == ePacketTypeInvalid || entry.packet.empty())
 141                 break;
 142             log->Printf ("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s",
 143                          entry.packet_idx,
 144                          entry.tid,
 145                          entry.bytes_transmitted,
 146                          (entry.type == ePacketTypeSend) ? "send" : "read",
 147                          entry.packet.c_str());
 148         }
 149     }
 150 }
 151
 152 //----------------------------------------------------------------------
 153 // GDBRemoteCommunication constructor
 154 //----------------------------------------------------------------------
 155 GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
 156                                                const char *listener_name) :
 157     Communication(comm_name),
 158 #ifdef LLDB_CONFIGURATION_DEBUG
 159     m_packet_timeout (1000),
 160 #else
 161     m_packet_timeout (1),
 162 #endif
 163     m_echo_number(0),
 164     m_supports_qEcho (eLazyBoolCalculate),
 165     m_sequence_mutex (Mutex::eMutexTypeRecursive),
 166     m_public_is_running (false),
 167     m_private_is_running (false),
 168     m_history (512),
 169     m_send_acks (true),
 170     m_compression_type (CompressionType::None),
 171     m_listen_url ()
 172 {
 173 }
 174
 175 //----------------------------------------------------------------------
 176 // Destructor
 177 //----------------------------------------------------------------------
 178 GDBRemoteCommunication::~GDBRemoteCommunication()
 179 {
 180     if (IsConnected())
 181     {
 182         Disconnect();
 183     }
 184
 185     // Stop the communications read thread which is used to parse all
 186     // incoming packets.  This function will block until the read
 187     // thread returns.
 188     if (m_read_thread_enabled)
 189         StopReadThread();
 190 }
 191
 192 char
 193 GDBRemoteCommunication::CalculcateChecksum (const char *payload, size_t payload_length)
 194 {
 195     int checksum = 0;
 196
 197     for (size_t i = 0; i < payload_length; ++i)
 198         checksum += payload[i];
 199
 200     return checksum & 255;
 201 }
 202
 203 size_t
 204 GDBRemoteCommunication::SendAck ()
 205 {
 206     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 207     ConnectionStatus status = eConnectionStatusSuccess;
 208     char ch = '+';
 209     const size_t bytes_written = Write (&ch, 1, status, NULL);
 210     if (log)
 211         log->Printf ("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
 212     m_history.AddPacket (ch, History::ePacketTypeSend, bytes_written);
 213     return bytes_written;
 214 }
 215
 216 size_t
 217 GDBRemoteCommunication::SendNack ()
 218 {
 219     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 220     ConnectionStatus status = eConnectionStatusSuccess;
 221     char ch = '-';
 222     const size_t bytes_written = Write (&ch, 1, status, NULL);
 223     if (log)
 224         log->Printf("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
 225     m_history.AddPacket (ch, History::ePacketTypeSend, bytes_written);
 226     return bytes_written;
 227 }
 228
 229 GDBRemoteCommunication::PacketResult
 230 GDBRemoteCommunication::SendPacket (const char *payload, size_t payload_length)
 231 {
 232     Mutex::Locker locker(m_sequence_mutex);
 233     return SendPacketNoLock (payload, payload_length);
 234 }
 235
 236 GDBRemoteCommunication::PacketResult
 237 GDBRemoteCommunication::SendPacketNoLock (const char *payload, size_t payload_length)
 238 {
 239     if (IsConnected())
 240     {
 241         StreamString packet(0, 4, eByteOrderBig);
 242
 243         packet.PutChar('$');
 244         packet.Write (payload, payload_length);
 245         packet.PutChar('#');
 246         packet.PutHex8(CalculcateChecksum (payload, payload_length));
 247
 248         Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 249         ConnectionStatus status = eConnectionStatusSuccess;
 250         const char *packet_data = packet.GetData();
 251         const size_t packet_length = packet.GetSize();
 252         size_t bytes_written = Write (packet_data, packet_length, status, NULL);
 253         if (log)
 254         {
 255             size_t binary_start_offset = 0;
 256             if (strncmp(packet_data, "$vFile:pwrite:", strlen("$vFile:pwrite:")) == 0)
 257             {
 258                 const char *first_comma = strchr(packet_data, ',');
 259                 if (first_comma)
 260                 {
 261                     const char *second_comma = strchr(first_comma + 1, ',');
 262                     if (second_comma)
 263                         binary_start_offset = second_comma - packet_data + 1;
 264                 }
 265             }
 266
 267             // If logging was just enabled and we have history, then dump out what
 268             // we have to the log so we get the historical context. The Dump() call that
 269             // logs all of the packet will set a boolean so that we don't dump this more
 270             // than once
 271             if (!m_history.DidDumpToLog ())
 272                 m_history.Dump (log);
 273
 274             if (binary_start_offset)
 275             {
 276                 StreamString strm;
 277                 // Print non binary data header
 278                 strm.Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)binary_start_offset, packet_data);
 279                 const uint8_t *p;
 280                 // Print binary data exactly as sent
 281                 for (p = (const uint8_t*)packet_data + binary_start_offset; *p != '#'; ++p)
 282                     strm.Printf("\\x%2.2x", *p);
 283                 // Print the checksum
 284                 strm.Printf("%*s", (int)3, p);
 285                 log->PutCString(strm.GetString().c_str());
 286             }
 287             else
 288                 log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)packet_length, packet_data);
 289         }
 290
 291         m_history.AddPacket (packet.GetString(), packet_length, History::ePacketTypeSend, bytes_written);
 292
 293
 294         if (bytes_written == packet_length)
 295         {
 296             if (GetSendAcks ())
 297                 return GetAck ();
 298             else
 299                 return PacketResult::Success;
 300         }
 301         else
 302         {
 303             if (log)
 304                 log->Printf ("error: failed to send packet: %.*s", (int)packet_length, packet_data);
 305         }
 306     }
 307     return PacketResult::ErrorSendFailed;
 308 }
 309
 310 GDBRemoteCommunication::PacketResult
 311 GDBRemoteCommunication::GetAck ()
 312 {
 313     StringExtractorGDBRemote packet;
 314     PacketResult result = ReadPacket (packet, GetPacketTimeoutInMicroSeconds (), false);
 315     if (result == PacketResult::Success)
 316     {
 317         if (packet.GetResponseType() == StringExtractorGDBRemote::ResponseType::eAck)
 318             return PacketResult::Success;
 319         else
 320             return PacketResult::ErrorSendAck;
 321     }
 322     return result;
 323 }
 324
 325 bool
 326 GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker, const char *failure_message)
 327 {
 328     if (IsRunning())
 329         return locker.TryLock (m_sequence_mutex, failure_message);
 330
 331     locker.Lock (m_sequence_mutex);
 332     return true;
 333 }
 334
 335
 336 bool
 337 GDBRemoteCommunication::WaitForNotRunningPrivate (const TimeValue *timeout_ptr)
 338 {
 339     return m_private_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
 340 }
 341
 342 GDBRemoteCommunication::PacketResult
 343 GDBRemoteCommunication::ReadPacket (StringExtractorGDBRemote &response, uint32_t timeout_usec, bool sync_on_timeout)
 344 {
 345    if (m_read_thread_enabled)
 346        return PopPacketFromQueue (response, timeout_usec);
 347    else
 348        return WaitForPacketWithTimeoutMicroSecondsNoLock (response, timeout_usec, sync_on_timeout);
 349 }
 350
 351
 352 // This function is called when a packet is requested.
 353 // A whole packet is popped from the packet queue and returned to the caller.
 354 // Packets are placed into this queue from the communication read thread.
 355 // See GDBRemoteCommunication::AppendBytesToCache.
 356 GDBRemoteCommunication::PacketResult
 357 GDBRemoteCommunication::PopPacketFromQueue (StringExtractorGDBRemote &response, uint32_t timeout_usec)
 358 {
 359     // Calculate absolute timeout value
 360     TimeValue timeout = TimeValue::Now();
 361     timeout.OffsetWithMicroSeconds(timeout_usec);
 362
 363     do
 364     {
 365         // scope for the mutex
 366         {
 367             // lock down the packet queue
 368             Mutex::Locker locker(m_packet_queue_mutex);
 369
 370             // Wait on condition variable.
 371             if (m_packet_queue.size() == 0)
 372                 m_condition_queue_not_empty.Wait(m_packet_queue_mutex, &timeout);
 373
 374             if (m_packet_queue.size() > 0)
 375             {
 376                 // get the front element of the queue
 377                 response = m_packet_queue.front();
 378
 379                 // remove the front element
 380                 m_packet_queue.pop();
 381
 382                 // we got a packet
 383                 return PacketResult::Success;
 384             }
 385          }
 386
 387          // Disconnected
 388          if (!IsConnected())
 389              return PacketResult::ErrorDisconnected;
 390
 391       // Loop while not timed out
 392     } while (TimeValue::Now() < timeout);
 393
 394     return PacketResult::ErrorReplyTimeout;
 395 }
 396
 397
 398 GDBRemoteCommunication::PacketResult
 399 GDBRemoteCommunication::WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtractorGDBRemote &packet, uint32_t timeout_usec, bool sync_on_timeout)
 400 {
 401     uint8_t buffer[8192];
 402     Error error;
 403
 404     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS | GDBR_LOG_VERBOSE));
 405
 406     // Check for a packet from our cache first without trying any reading...
 407     if (CheckForPacket(NULL, 0, packet) != PacketType::Invalid)
 408         return PacketResult::Success;
 409
 410     bool timed_out = false;
 411     bool disconnected = false;
 412     while (IsConnected() && !timed_out)
 413     {
 414         lldb::ConnectionStatus status = eConnectionStatusNoConnection;
 415         size_t bytes_read = Read (buffer, sizeof(buffer), timeout_usec, status, &error);
 416
 417         if (log)
 418             log->Printf ("%s: Read (buffer, (sizeof(buffer), timeout_usec = 0x%x, status = %s, error = %s) => bytes_read = %" PRIu64,
 419                          __PRETTY_FUNCTION__,
 420                          timeout_usec,
 421                          Communication::ConnectionStatusAsCString (status),
 422                          error.AsCString(),
 423                          (uint64_t)bytes_read);
 424
 425         if (bytes_read > 0)
 426         {
 427             if (CheckForPacket(buffer, bytes_read, packet) != PacketType::Invalid)
 428                 return PacketResult::Success;
 429         }
 430         else
 431         {
 432             switch (status)
 433             {
 434             case eConnectionStatusTimedOut:
 435             case eConnectionStatusInterrupted:
 436                 if (sync_on_timeout)
 437                 {
 438                     //------------------------------------------------------------------
 439                     /// Sync the remote GDB server and make sure we get a response that
 440                     /// corresponds to what we send.
 441                     ///
 442                     /// Sends a "qEcho" packet and makes sure it gets the exact packet
 443                     /// echoed back. If the qEcho packet isn't supported, we send a qC
 444                     /// packet and make sure we get a valid thread ID back. We use the
 445                     /// "qC" packet since its response if very unique: is responds with
 446                     /// "QC%x" where %x is the thread ID of the current thread. This
 447                     /// makes the response unique enough from other packet responses to
 448                     /// ensure we are back on track.
 449                     ///
 450                     /// This packet is needed after we time out sending a packet so we
 451                     /// can ensure that we are getting the response for the packet we
 452                     /// are sending. There are no sequence IDs in the GDB remote
 453                     /// protocol (there used to be, but they are not supported anymore)
 454                     /// so if you timeout sending packet "abc", you might then send
 455                     /// packet "cde" and get the response for the previous "abc" packet.
 456                     /// Many responses are "OK" or "" (unsupported) or "EXX" (error) so
 457                     /// many responses for packets can look like responses for other
 458                     /// packets. So if we timeout, we need to ensure that we can get
 459                     /// back on track. If we can't get back on track, we must
 460                     /// disconnect.
 461                     //------------------------------------------------------------------
 462                     bool sync_success = false;
 463                     bool got_actual_response = false;
 464                     // We timed out, we need to sync back up with the
 465                     char echo_packet[32];
 466                     int echo_packet_len = 0;
 467                     RegularExpression response_regex;
 468
 469                     if (m_supports_qEcho == eLazyBoolYes)
 470                     {
 471                         echo_packet_len = ::snprintf (echo_packet, sizeof(echo_packet), "qEcho:%u", ++m_echo_number);
 472                         std::string regex_str = "^";
 473                         regex_str += echo_packet;
 474                         regex_str += "$";
 475                         response_regex.Compile(regex_str.c_str());
 476                     }
 477                     else
 478                     {
 479                         echo_packet_len = ::snprintf (echo_packet, sizeof(echo_packet), "qC");
 480                         response_regex.Compile("^QC[0-9A-Fa-f]+$");
 481                     }
 482
 483                     PacketResult echo_packet_result = SendPacketNoLock (echo_packet, echo_packet_len);
 484                     if (echo_packet_result == PacketResult::Success)
 485                     {
 486                         const uint32_t max_retries = 3;
 487                         uint32_t successful_responses = 0;
 488                         for (uint32_t i=0; i<max_retries; ++i)
 489                         {
 490                             StringExtractorGDBRemote echo_response;
 491                             echo_packet_result = WaitForPacketWithTimeoutMicroSecondsNoLock (echo_response, timeout_usec, false);
 492                             if (echo_packet_result == PacketResult::Success)
 493                             {
 494                                 ++successful_responses;
 495                                 if (response_regex.Execute(echo_response.GetStringRef().c_str()))
 496                                 {
 497                                     sync_success = true;
 498                                     break;
 499                                 }
 500                                 else if (successful_responses == 1)
 501                                 {
 502                                     // We got something else back as the first successful response, it probably is
 503                                     // the  response to the packet we actually wanted, so copy it over if this
 504                                     // is the first success and continue to try to get the qEcho response
 505                                     packet = echo_response;
 506                                     got_actual_response = true;
 507                                 }
 508                             }
 509                             else if (echo_packet_result == PacketResult::ErrorReplyTimeout)
 510                                 continue;   // Packet timed out, continue waiting for a response
 511                             else
 512                                 break;      // Something else went wrong getting the packet back, we failed and are done trying
 513                         }
 514                     }
 515
 516                     // We weren't able to sync back up with the server, we must abort otherwise
 517                     // all responses might not be from the right packets...
 518                     if (sync_success)
 519                     {
 520                         // We timed out, but were able to recover
 521                         if (got_actual_response)
 522                         {
 523                             // We initially timed out, but we did get a response that came in before the successful
 524                             // reply to our qEcho packet, so lets say everything is fine...
 525                             return PacketResult::Success;
 526                         }
 527                     }
 528                     else
 529                     {
 530                         disconnected = true;
 531                         Disconnect();
 532                     }
 533                 }
 534                 timed_out = true;
 535                 break;
 536             case eConnectionStatusSuccess:
 537                 //printf ("status = success but error = %s\n", error.AsCString("<invalid>"));
 538                 break;
 539
 540             case eConnectionStatusEndOfFile:
 541             case eConnectionStatusNoConnection:
 542             case eConnectionStatusLostConnection:
 543             case eConnectionStatusError:
 544                 disconnected = true;
 545                 Disconnect();
 546                 break;
 547             }
 548         }
 549     }
 550     packet.Clear ();
 551     if (disconnected)
 552         return PacketResult::ErrorDisconnected;
 553     if (timed_out)
 554         return PacketResult::ErrorReplyTimeout;
 555     else
 556         return PacketResult::ErrorReplyFailed;
 557 }
 558
 559 bool
 560 GDBRemoteCommunication::DecompressPacket ()
 561 {
 562     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 563
 564     if (!CompressionIsEnabled())
 565         return true;
 566
 567     size_t pkt_size = m_bytes.size();
 568
 569     // Smallest possible compressed packet is $N#00 - an uncompressed empty reply, most commonly indicating
 570     // an unsupported packet.  Anything less than 5 characters, it's definitely not a compressed packet.
 571     if (pkt_size < 5)
 572         return true;
 573
 574     if (m_bytes[0] != '$' && m_bytes[0] != '%')
 575         return true;
 576     if (m_bytes[1] != 'C' && m_bytes[1] != 'N')
 577         return true;
 578
 579     size_t hash_mark_idx = m_bytes.find ('#');
 580     if (hash_mark_idx == std::string::npos)
 581         return true;
 582     if (hash_mark_idx + 2 >= m_bytes.size())
 583         return true;
 584
 585     if (!::isxdigit (m_bytes[hash_mark_idx + 1]) || !::isxdigit (m_bytes[hash_mark_idx + 2]))
 586         return true;
 587
 588     size_t content_length = pkt_size - 5;    // not counting '$', 'C' | 'N', '#', & the two hex checksum chars
 589     size_t content_start = 2;                // The first character of the compressed/not-compressed text of the packet
 590     size_t checksum_idx = hash_mark_idx + 1; // The first character of the two hex checksum characters
 591
 592     // Normally size_of_first_packet == m_bytes.size() but m_bytes may contain multiple packets.
 593     // size_of_first_packet is the size of the initial packet which we'll replace with the decompressed
 594     // version of, leaving the rest of m_bytes unmodified.
 595     size_t size_of_first_packet = hash_mark_idx + 3;
 596
 597     // Compressed packets ("$C") start with a base10 number which is the size of the uncompressed payload,
 598     // then a : and then the compressed data.  e.g. $C1024:<binary>#00
 599     // Update content_start and content_length to only include the <binary> part of the packet.
 600
 601     uint64_t decompressed_bufsize = ULONG_MAX;
 602     if (m_bytes[1] == 'C')
 603     {
 604         size_t i = content_start;
 605         while (i < hash_mark_idx && isdigit(m_bytes[i]))
 606             i++;
 607         if (i < hash_mark_idx && m_bytes[i] == ':')
 608         {
 609             i++;
 610             content_start = i;
 611             content_length = hash_mark_idx - content_start;
 612             std::string bufsize_str (m_bytes.data() + 2, i - 2 - 1);
 613             errno = 0;
 614             decompressed_bufsize = ::strtoul (bufsize_str.c_str(), NULL, 10);
 615             if (errno != 0 || decompressed_bufsize == ULONG_MAX)
 616             {
 617                 m_bytes.erase (0, size_of_first_packet);
 618                 return false;
 619             }
 620         }
 621     }
 622
 623     if (GetSendAcks ())
 624     {
 625         char packet_checksum_cstr[3];
 626         packet_checksum_cstr[0] = m_bytes[checksum_idx];
 627         packet_checksum_cstr[1] = m_bytes[checksum_idx + 1];
 628         packet_checksum_cstr[2] = '\0';
 629         long packet_checksum = strtol (packet_checksum_cstr, NULL, 16);
 630
 631         long actual_checksum = CalculcateChecksum (m_bytes.data() + 1, hash_mark_idx - 1);
 632         bool success = packet_checksum == actual_checksum;
 633         if (!success)
 634         {
 635             if (log)
 636                 log->Printf ("error: checksum mismatch: %.*s expected 0x%2.2x, got 0x%2.2x",
 637                              (int)(pkt_size),
 638                              m_bytes.c_str(),
 639                              (uint8_t)packet_checksum,
 640                              (uint8_t)actual_checksum);
 641         }
 642         // Send the ack or nack if needed
 643         if (!success)
 644         {
 645             SendNack();
 646             m_bytes.erase (0, size_of_first_packet);
 647             return false;
 648         }
 649         else
 650         {
 651             SendAck();
 652         }
 653     }
 654
 655     if (m_bytes[1] == 'N')
 656     {
 657         // This packet was not compressed -- delete the 'N' character at the
 658         // start and the packet may be processed as-is.
 659         m_bytes.erase(1, 1);
 660         return true;
 661     }
 662
 663     // Reverse the gdb-remote binary escaping that was done to the compressed text to
 664     // guard characters like '$', '#', '}', etc.
 665     std::vector<uint8_t> unescaped_content;
 666     unescaped_content.reserve (content_length);
 667     size_t i = content_start;
 668     while (i < hash_mark_idx)
 669     {
 670         if (m_bytes[i] == '}')
 671         {
 672             i++;
 673             unescaped_content.push_back (m_bytes[i] ^ 0x20);
 674         }
 675         else
 676         {
 677             unescaped_content.push_back (m_bytes[i]);
 678         }
 679         i++;
 680     }
 681
 682     uint8_t *decompressed_buffer = nullptr;
 683     size_t decompressed_bytes = 0;
 684
 685     if (decompressed_bufsize != ULONG_MAX)
 686     {
 687         decompressed_buffer = (uint8_t *) malloc (decompressed_bufsize + 1);
 688         if (decompressed_buffer == nullptr)
 689         {
 690             m_bytes.erase (0, size_of_first_packet);
 691             return false;
 692         }
 693
 694     }
 695
 696 #if defined (HAVE_LIBCOMPRESSION)
 697     // libcompression is weak linked so check that compression_decode_buffer() is available
 698     if (compression_decode_buffer != NULL &&
 699         (m_compression_type == CompressionType::ZlibDeflate
 700          || m_compression_type == CompressionType::LZFSE
 701          || m_compression_type == CompressionType::LZ4))
 702     {
 703         compression_algorithm compression_type;
 704         if (m_compression_type == CompressionType::ZlibDeflate)
 705             compression_type = COMPRESSION_ZLIB;
 706         else if (m_compression_type == CompressionType::LZFSE)
 707             compression_type = COMPRESSION_LZFSE;
 708         else if (m_compression_type == CompressionType::LZ4)
 709             compression_type = COMPRESSION_LZ4_RAW;
 710         else if (m_compression_type == CompressionType::LZMA)
 711             compression_type = COMPRESSION_LZMA;
 712
 713
 714         // If we have the expected size of the decompressed payload, we can allocate
 715         // the right-sized buffer and do it.  If we don't have that information, we'll
 716         // need to try decoding into a big buffer and if the buffer wasn't big enough,
 717         // increase it and try again.
 718
 719         if (decompressed_bufsize != ULONG_MAX && decompressed_buffer != nullptr)
 720         {
 721             decompressed_bytes = compression_decode_buffer (decompressed_buffer, decompressed_bufsize + 10 ,
 722                                                         (uint8_t*) unescaped_content.data(),
 723                                                         unescaped_content.size(),
 724                                                         NULL,
 725                                                         compression_type);
 726         }
 727     }
 728 #endif
 729
 730 #if defined (HAVE_LIBZ)
 731     if (decompressed_bytes == 0
 732         && decompressed_bufsize != ULONG_MAX
 733         && decompressed_buffer != nullptr
 734         && m_compression_type == CompressionType::ZlibDeflate)
 735     {
 736         z_stream stream;
 737         memset (&stream, 0, sizeof (z_stream));
 738         stream.next_in = (Bytef *) unescaped_content.data();
 739         stream.avail_in = (uInt) unescaped_content.size();
 740         stream.total_in = 0;
 741         stream.next_out = (Bytef *) decompressed_buffer;
 742         stream.avail_out = decompressed_bufsize;
 743         stream.total_out = 0;
 744         stream.zalloc = Z_NULL;
 745         stream.zfree = Z_NULL;
 746         stream.opaque = Z_NULL;
 747
 748         if (inflateInit2 (&stream, -15) == Z_OK)
 749         {
 750             int status = inflate (&stream, Z_NO_FLUSH);
 751             inflateEnd (&stream);
 752             if (status == Z_STREAM_END)
 753             {
 754                 decompressed_bytes = stream.total_out;
 755             }
 756         }
 757     }
 758 #endif
 759
 760     if (decompressed_bytes == 0 || decompressed_buffer == nullptr)
 761     {
 762         if (decompressed_buffer)
 763             free (decompressed_buffer);
 764         m_bytes.erase (0, size_of_first_packet);
 765         return false;
 766     }
 767
 768     std::string new_packet;
 769     new_packet.reserve (decompressed_bytes + 6);
 770     new_packet.push_back (m_bytes[0]);
 771     new_packet.append ((const char *) decompressed_buffer, decompressed_bytes);
 772     new_packet.push_back ('#');
 773     if (GetSendAcks ())
 774     {
 775         uint8_t decompressed_checksum = CalculcateChecksum ((const char *) decompressed_buffer, decompressed_bytes);
 776         char decompressed_checksum_str[3];
 777         snprintf (decompressed_checksum_str, 3, "%02x", decompressed_checksum);
 778         new_packet.append (decompressed_checksum_str);
 779     }
 780     else
 781     {
 782         new_packet.push_back ('0');
 783         new_packet.push_back ('0');
 784     }
 785
 786     m_bytes.replace (0, size_of_first_packet, new_packet.data(), new_packet.size());
 787
 788     free (decompressed_buffer);
 789     return true;
 790 }
 791
 792 GDBRemoteCommunication::PacketType
 793 GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, StringExtractorGDBRemote &packet)
 794 {
 795     // Put the packet data into the buffer in a thread safe fashion
 796     std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
 797
 798     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 799
 800     if (src && src_len > 0)
 801     {
 802         if (log && log->GetVerbose())
 803         {
 804             StreamString s;
 805             log->Printf ("GDBRemoteCommunication::%s adding %u bytes: %.*s",
 806                          __FUNCTION__,
 807                          (uint32_t)src_len,
 808                          (uint32_t)src_len,
 809                          src);
 810         }
 811         m_bytes.append ((const char *)src, src_len);
 812     }
 813
 814     bool isNotifyPacket = false;
 815
 816     // Parse up the packets into gdb remote packets
 817     if (!m_bytes.empty())
 818     {
 819         // end_idx must be one past the last valid packet byte. Start
 820         // it off with an invalid value that is the same as the current
 821         // index.
 822         size_t content_start = 0;
 823         size_t content_length = 0;
 824         size_t total_length = 0;
 825         size_t checksum_idx = std::string::npos;
 826
 827         // Size of packet before it is decompressed, for logging purposes
 828         size_t original_packet_size = m_bytes.size();
 829         if (CompressionIsEnabled())
 830         {
 831             if (DecompressPacket() == false)
 832             {
 833                 packet.Clear();
 834                 return GDBRemoteCommunication::PacketType::Standard;
 835             }
 836         }
 837
 838         switch (m_bytes[0])
 839         {
 840             case '+':       // Look for ack
 841             case '-':       // Look for cancel
 842             case '\x03':    // ^C to halt target
 843                 content_length = total_length = 1;  // The command is one byte long...
 844                 break;
 845
 846             case '%': // Async notify packet
 847                 isNotifyPacket = true;
 848                 LLVM_FALLTHROUGH;
 849
 850             case '$':
 851                 // Look for a standard gdb packet?
 852                 {
 853                     size_t hash_pos = m_bytes.find('#');
 854                     if (hash_pos != std::string::npos)
 855                     {
 856                         if (hash_pos + 2 < m_bytes.size())
 857                         {
 858                             checksum_idx = hash_pos + 1;
 859                             // Skip the dollar sign
 860                             content_start = 1;
 861                             // Don't include the # in the content or the $ in the content length
 862                             content_length = hash_pos - 1;
 863
 864                             total_length = hash_pos + 3; // Skip the # and the two hex checksum bytes
 865                         }
 866                         else
 867                         {
 868                             // Checksum bytes aren't all here yet
 869                             content_length = std::string::npos;
 870                         }
 871                     }
 872                 }
 873                 break;
 874
 875             default:
 876                 {
 877                     // We have an unexpected byte and we need to flush all bad
 878                     // data that is in m_bytes, so we need to find the first
 879                     // byte that is a '+' (ACK), '-' (NACK), \x03 (CTRL+C interrupt),
 880                     // or '$' character (start of packet header) or of course,
 881                     // the end of the data in m_bytes...
 882                     const size_t bytes_len = m_bytes.size();
 883                     bool done = false;
 884                     uint32_t idx;
 885                     for (idx = 1; !done && idx < bytes_len; ++idx)
 886                     {
 887                         switch (m_bytes[idx])
 888                         {
 889                         case '+':
 890                         case '-':
 891                         case '\x03':
 892                         case '%':
 893                         case '$':
 894                             done = true;
 895                             break;
 896
 897                         default:
 898                             break;
 899                         }
 900                     }
 901                     if (log)
 902                         log->Printf ("GDBRemoteCommunication::%s tossing %u junk bytes: '%.*s'",
 903                                      __FUNCTION__, idx - 1, idx - 1, m_bytes.c_str());
 904                     m_bytes.erase(0, idx - 1);
 905                 }
 906                 break;
 907         }
 908
 909         if (content_length == std::string::npos)
 910         {
 911             packet.Clear();
 912             return GDBRemoteCommunication::PacketType::Invalid;
 913         }
 914         else if (total_length > 0)
 915         {
 916
 917             // We have a valid packet...
 918             assert (content_length <= m_bytes.size());
 919             assert (total_length <= m_bytes.size());
 920             assert (content_length <= total_length);
 921             size_t content_end = content_start + content_length;
 922
 923             bool success = true;
 924             std::string &packet_str = packet.GetStringRef();
 925             if (log)
 926             {
 927                 // If logging was just enabled and we have history, then dump out what
 928                 // we have to the log so we get the historical context. The Dump() call that
 929                 // logs all of the packet will set a boolean so that we don't dump this more
 930                 // than once
 931                 if (!m_history.DidDumpToLog ())
 932                     m_history.Dump (log);
 933
 934                 bool binary = false;
 935                 // Only detect binary for packets that start with a '$' and have a '#CC' checksum
 936                 if (m_bytes[0] == '$' && total_length > 4)
 937                 {
 938                     for (size_t i=0; !binary && i<total_length; ++i)
 939                     {
 940                         if (isprint (m_bytes[i]) == 0 && isspace (m_bytes[i]) == 0)
 941                         {
 942                             binary = true;
 943                         }
 944                     }
 945                 }
 946                 if (binary)
 947                 {
 948                     StreamString strm;
 949                     // Packet header...
 950                     if (CompressionIsEnabled())
 951                         strm.Printf("<%4" PRIu64 ":%" PRIu64 "> read packet: %c", (uint64_t) original_packet_size, (uint64_t)total_length, m_bytes[0]);
 952                     else
 953                         strm.Printf("<%4" PRIu64 "> read packet: %c", (uint64_t)total_length, m_bytes[0]);
 954                     for (size_t i=content_start; i<content_end; ++i)
 955                     {
 956                         // Remove binary escaped bytes when displaying the packet...
 957                         const char ch = m_bytes[i];
 958                         if (ch == 0x7d)
 959                         {
 960                             // 0x7d is the escape character.  The next character is to
 961                             // be XOR'd with 0x20.
 962                             const char escapee = m_bytes[++i] ^ 0x20;
 963                             strm.Printf("%2.2x", escapee);
 964                         }
 965                         else
 966                         {
 967                             strm.Printf("%2.2x", (uint8_t)ch);
 968                         }
 969                     }
 970                     // Packet footer...
 971                     strm.Printf("%c%c%c", m_bytes[total_length-3], m_bytes[total_length-2], m_bytes[total_length-1]);
 972                     log->PutCString(strm.GetString().c_str());
 973                 }
 974                 else
 975                 {
 976                     if (CompressionIsEnabled())
 977                         log->Printf("<%4" PRIu64 ":%" PRIu64 "> read packet: %.*s", (uint64_t) original_packet_size, (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
 978                     else
 979                         log->Printf("<%4" PRIu64 "> read packet: %.*s", (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
 980                 }
 981             }
 982
 983             m_history.AddPacket (m_bytes.c_str(), total_length, History::ePacketTypeRecv, total_length);
 984
 985             // Clear packet_str in case there is some existing data in it.
 986             packet_str.clear();
 987             // Copy the packet from m_bytes to packet_str expanding the
 988             // run-length encoding in the process.
 989             // Reserve enough byte for the most common case (no RLE used)
 990             packet_str.reserve(m_bytes.length());
 991             for (std::string::const_iterator c = m_bytes.begin() + content_start; c != m_bytes.begin() + content_end; ++c)
 992             {
 993                 if (*c == '*')
 994                 {
 995                     // '*' indicates RLE. Next character will give us the
 996                     // repeat count and previous character is what is to be
 997                     // repeated.
 998                     char char_to_repeat = packet_str.back();
 999                     // Number of time the previous character is repeated
1000                     int repeat_count = *++c + 3 - ' ';
1001                     // We have the char_to_repeat and repeat_count. Now push
1002                     // it in the packet.
1003                     for (int i = 0; i < repeat_count; ++i)
1004                         packet_str.push_back(char_to_repeat);
1005                 }
1006                 else if (*c == 0x7d)
1007                 {
1008                     // 0x7d is the escape character.  The next character is to
1009                     // be XOR'd with 0x20.
1010                     char escapee = *++c ^ 0x20;
1011                     packet_str.push_back(escapee);
1012                 }
1013                 else
1014                 {
1015                     packet_str.push_back(*c);
1016                 }
1017             }
1018
1019             if (m_bytes[0] == '$' || m_bytes[0] == '%')
1020             {
1021                 assert (checksum_idx < m_bytes.size());
1022                 if (::isxdigit (m_bytes[checksum_idx+0]) ||
1023                     ::isxdigit (m_bytes[checksum_idx+1]))
1024                 {
1025                     if (GetSendAcks ())
1026                     {
1027                         const char *packet_checksum_cstr = &m_bytes[checksum_idx];
1028                         char packet_checksum = strtol (packet_checksum_cstr, NULL, 16);
1029                         char actual_checksum = CalculcateChecksum (packet_str.c_str(), packet_str.size());
1030                         success = packet_checksum == actual_checksum;
1031                         if (!success)
1032                         {
1033                             if (log)
1034                                 log->Printf ("error: checksum mismatch: %.*s expected 0x%2.2x, got 0x%2.2x",
1035                                              (int)(total_length),
1036                                              m_bytes.c_str(),
1037                                              (uint8_t)packet_checksum,
1038                                              (uint8_t)actual_checksum);
1039                         }
1040                         // Send the ack or nack if needed
1041                         if (!success)
1042                             SendNack();
1043                         else
1044                             SendAck();
1045                     }
1046                 }
1047                 else
1048                 {
1049                     success = false;
1050                     if (log)
1051                         log->Printf ("error: invalid checksum in packet: '%s'\n", m_bytes.c_str());
1052                 }
1053             }
1054
1055             m_bytes.erase(0, total_length);
1056             packet.SetFilePos(0);
1057
1058             if (isNotifyPacket)
1059                 return GDBRemoteCommunication::PacketType::Notify;
1060             else
1061                 return GDBRemoteCommunication::PacketType::Standard;
1062         }
1063     }
1064     packet.Clear();
1065     return GDBRemoteCommunication::PacketType::Invalid;
1066 }
1067
1068 Error
1069 GDBRemoteCommunication::StartListenThread (const char *hostname, uint16_t port)
1070 {
1071     Error error;
1072     if (m_listen_thread.IsJoinable())
1073     {
1074         error.SetErrorString("listen thread already running");
1075     }
1076     else
1077     {
1078         char listen_url[512];
1079         if (hostname && hostname[0])
1080             snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
1081         else
1082             snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
1083         m_listen_url = listen_url;
1084         SetConnection(new ConnectionFileDescriptor());
1085         m_listen_thread = ThreadLauncher::LaunchThread(listen_url, GDBRemoteCommunication::ListenThread, this, &error);
1086     }
1087     return error;
1088 }
1089
1090 bool
1091 GDBRemoteCommunication::JoinListenThread ()
1092 {
1093     if (m_listen_thread.IsJoinable())
1094         m_listen_thread.Join(nullptr);
1095     return true;
1096 }
1097
1098 lldb::thread_result_t
1099 GDBRemoteCommunication::ListenThread (lldb::thread_arg_t arg)
1100 {
1101     GDBRemoteCommunication *comm = (GDBRemoteCommunication *)arg;
1102     Error error;
1103     ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)comm->GetConnection ();
1104
1105     if (connection)
1106     {
1107         // Do the listen on another thread so we can continue on...
1108         if (connection->Connect(comm->m_listen_url.c_str(), &error) != eConnectionStatusSuccess)
1109             comm->SetConnection(NULL);
1110     }
1111     return NULL;
1112 }
1113
1114 Error
1115 GDBRemoteCommunication::StartDebugserverProcess (const char *url,
1116                                                  Platform *platform,
1117                                                  ProcessLaunchInfo &launch_info,
1118                                                  uint16_t *port,
1119                                                  const Args& inferior_args)
1120 {
1121     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
1122     if (log)
1123         log->Printf ("GDBRemoteCommunication::%s(url=%s, port=%" PRIu16 ")", __FUNCTION__, url ? url : "<empty>", port ? *port : uint16_t(0));
1124
1125     Error error;
1126     // If we locate debugserver, keep that located version around
1127     static FileSpec g_debugserver_file_spec;
1128
1129     char debugserver_path[PATH_MAX];
1130     FileSpec &debugserver_file_spec = launch_info.GetExecutableFile();
1131
1132     // Always check to see if we have an environment override for the path
1133     // to the debugserver to use and use it if we do.
1134     const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
1135     if (env_debugserver_path)
1136     {
1137         debugserver_file_spec.SetFile (env_debugserver_path, false);
1138         if (log)
1139             log->Printf ("GDBRemoteCommunication::%s() gdb-remote stub exe path set from environment variable: %s", __FUNCTION__, env_debugserver_path);
1140     }
1141     else
1142         debugserver_file_spec = g_debugserver_file_spec;
1143     bool debugserver_exists = debugserver_file_spec.Exists();
1144     if (!debugserver_exists)
1145     {
1146         // The debugserver binary is in the LLDB.framework/Resources
1147         // directory.
1148         if (HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir, debugserver_file_spec))
1149         {
1150             debugserver_file_spec.AppendPathComponent (DEBUGSERVER_BASENAME);
1151             debugserver_exists = debugserver_file_spec.Exists();
1152             if (debugserver_exists)
1153             {
1154                 if (log)
1155                     log->Printf ("GDBRemoteCommunication::%s() found gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
1156
1157                 g_debugserver_file_spec = debugserver_file_spec;
1158             }
1159             else
1160             {
1161                 debugserver_file_spec = platform->LocateExecutable(DEBUGSERVER_BASENAME);
1162                 if (debugserver_file_spec)
1163                 {
1164                     // Platform::LocateExecutable() wouldn't return a path if it doesn't exist
1165                     debugserver_exists = true;
1166                 }
1167                 else
1168                 {
1169                     if (log)
1170                         log->Printf ("GDBRemoteCommunication::%s() could not find gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
1171                 }
1172                 // Don't cache the platform specific GDB server binary as it could change
1173                 // from platform to platform
1174                 g_debugserver_file_spec.Clear();
1175             }
1176         }
1177     }
1178
1179     if (debugserver_exists)
1180     {
1181         debugserver_file_spec.GetPath (debugserver_path, sizeof(debugserver_path));
1182
1183         Args &debugserver_args = launch_info.GetArguments();
1184         debugserver_args.Clear();
1185         char arg_cstr[PATH_MAX];
1186
1187         // Start args with "debugserver /file/path -r --"
1188         debugserver_args.AppendArgument(debugserver_path);
1189
1190 #if !defined(__APPLE__)
1191         // First argument to lldb-server must be mode in which to run.
1192         debugserver_args.AppendArgument("gdbserver");
1193 #endif
1194
1195         // If a url is supplied then use it
1196         if (url)
1197             debugserver_args.AppendArgument(url);
1198
1199         // use native registers, not the GDB registers
1200         debugserver_args.AppendArgument("--native-regs");
1201
1202         if (launch_info.GetLaunchInSeparateProcessGroup())
1203         {
1204             debugserver_args.AppendArgument("--setsid");
1205         }
1206
1207         llvm::SmallString<PATH_MAX> named_pipe_path;
1208         // socket_pipe is used by debug server to communicate back either
1209         // TCP port or domain socket name which it listens on.
1210         // The second purpose of the pipe to serve as a synchronization point -
1211         // once data is written to the pipe, debug server is up and running.
1212         Pipe socket_pipe;
1213
1214         // port is null when debug server should listen on domain socket -
1215         // we're not interested in port value but rather waiting for debug server
1216         // to become available.
1217         if ((port != nullptr && *port == 0) || port == nullptr)
1218         {
1219             if (url)
1220             {
1221                 // Create a temporary file to get the stdout/stderr and redirect the
1222                 // output of the command into this file. We will later read this file
1223                 // if all goes well and fill the data into "command_output_ptr"
1224
1225 #if defined(__APPLE__)
1226                 // Binding to port zero, we need to figure out what port it ends up
1227                 // using using a named pipe...
1228                 error = socket_pipe.CreateWithUniqueName("debugserver-named-pipe", false, named_pipe_path);
1229                 if (error.Fail())
1230                 {
1231                     if (log)
1232                         log->Printf("GDBRemoteCommunication::%s() "
1233                                 "named pipe creation failed: %s",
1234                                 __FUNCTION__, error.AsCString());
1235                     return error;
1236                 }
1237                 debugserver_args.AppendArgument("--named-pipe");
1238                 debugserver_args.AppendArgument(named_pipe_path.c_str());
1239 #else
1240                 // Binding to port zero, we need to figure out what port it ends up
1241                 // using using an unnamed pipe...
1242                 error = socket_pipe.CreateNew(true);
1243                 if (error.Fail())
1244                 {
1245                     if (log)
1246                         log->Printf("GDBRemoteCommunication::%s() "
1247                                 "unnamed pipe creation failed: %s",
1248                                 __FUNCTION__, error.AsCString());
1249                     return error;
1250                 }
1251                 int write_fd = socket_pipe.GetWriteFileDescriptor();
1252                 debugserver_args.AppendArgument("--pipe");
1253                 debugserver_args.AppendArgument(std::to_string(write_fd).c_str());
1254                 launch_info.AppendCloseFileAction(socket_pipe.GetReadFileDescriptor());
1255 #endif
1256             }
1257             else
1258             {
1259                 // No host and port given, so lets listen on our end and make the debugserver
1260                 // connect to us..
1261                 error = StartListenThread ("127.0.0.1", 0);
1262                 if (error.Fail())
1263                 {
1264                     if (log)
1265                         log->Printf ("GDBRemoteCommunication::%s() unable to start listen thread: %s", __FUNCTION__, error.AsCString());
1266                     return error;
1267                 }
1268
1269                 ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)GetConnection ();
1270                 // Wait for 10 seconds to resolve the bound port
1271                 *port = connection->GetListeningPort(10);
1272                 if (*port > 0)
1273                 {
1274                     char port_cstr[32];
1275                     snprintf(port_cstr, sizeof(port_cstr), "127.0.0.1:%i", *port);
1276                     // Send the host and port down that debugserver and specify an option
1277                     // so that it connects back to the port we are listening to in this process
1278                     debugserver_args.AppendArgument("--reverse-connect");
1279                     debugserver_args.AppendArgument(port_cstr);
1280                 }
1281                 else
1282                 {
1283                     error.SetErrorString ("failed to bind to port 0 on 127.0.0.1");
1284                     if (log)
1285                         log->Printf ("GDBRemoteCommunication::%s() failed: %s", __FUNCTION__, error.AsCString());
1286                     return error;
1287                 }
1288             }
1289         }
1290
1291         const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
1292         if (env_debugserver_log_file)
1293         {
1294             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file);
1295             debugserver_args.AppendArgument(arg_cstr);
1296         }
1297
1298 #if defined(__APPLE__)
1299         const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS");
1300         if (env_debugserver_log_flags)
1301         {
1302             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
1303             debugserver_args.AppendArgument(arg_cstr);
1304         }
1305 #else
1306         const char *env_debugserver_log_channels = getenv("LLDB_SERVER_LOG_CHANNELS");
1307         if (env_debugserver_log_channels)
1308         {
1309             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-channels=%s", env_debugserver_log_channels);
1310             debugserver_args.AppendArgument(arg_cstr);
1311         }
1312 #endif
1313
1314         // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an env var doesn't come back.
1315         uint32_t env_var_index = 1;
1316         bool has_env_var;
1317         do
1318         {
1319             char env_var_name[64];
1320             snprintf (env_var_name, sizeof (env_var_name), "LLDB_DEBUGSERVER_EXTRA_ARG_%" PRIu32, env_var_index++);
1321             const char *extra_arg = getenv(env_var_name);
1322             has_env_var = extra_arg != nullptr;
1323
1324             if (has_env_var)
1325             {
1326                 debugserver_args.AppendArgument (extra_arg);
1327                 if (log)
1328                     log->Printf ("GDBRemoteCommunication::%s adding env var %s contents to stub command line (%s)", __FUNCTION__, env_var_name, extra_arg);
1329             }
1330         } while (has_env_var);
1331
1332         if (inferior_args.GetArgumentCount() > 0)
1333         {
1334             debugserver_args.AppendArgument ("--");
1335             debugserver_args.AppendArguments (inferior_args);
1336         }
1337
1338         // Copy the current environment to the gdbserver/debugserver instance
1339         StringList env;
1340         if (Host::GetEnvironment(env))
1341         {
1342             for (size_t i = 0; i < env.GetSize(); ++i)
1343                 launch_info.GetEnvironmentEntries().AppendArgument(env[i].c_str());
1344         }
1345
1346         // Close STDIN, STDOUT and STDERR.
1347         launch_info.AppendCloseFileAction (STDIN_FILENO);
1348         launch_info.AppendCloseFileAction (STDOUT_FILENO);
1349         launch_info.AppendCloseFileAction (STDERR_FILENO);
1350
1351         // Redirect STDIN, STDOUT and STDERR to "/dev/null".
1352         launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false);
1353         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);
1354         launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true);
1355
1356         if (log)
1357         {
1358             StreamString string_stream;
1359             Platform *const platform = nullptr;
1360             launch_info.Dump(string_stream, platform);
1361             log->Printf("launch info for gdb-remote stub:\n%s", string_stream.GetString().c_str());
1362         }
1363         error = Host::LaunchProcess(launch_info);
1364
1365         if (error.Success() &&
1366             launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1367         {
1368             if (named_pipe_path.size() > 0)
1369             {
1370                 error = socket_pipe.OpenAsReader(named_pipe_path, false);
1371                 if (error.Fail())
1372                     if (log)
1373                         log->Printf("GDBRemoteCommunication::%s() "
1374                                 "failed to open named pipe %s for reading: %s",
1375                                 __FUNCTION__, named_pipe_path.c_str(), error.AsCString());
1376             }
1377
1378             if (socket_pipe.CanWrite())
1379                 socket_pipe.CloseWriteFileDescriptor();
1380             if (socket_pipe.CanRead())
1381             {
1382                 char port_cstr[PATH_MAX] = {0};
1383                 port_cstr[0] = '\0';
1384                 size_t num_bytes = sizeof(port_cstr);
1385                 // Read port from pipe with 10 second timeout.
1386                 error = socket_pipe.ReadWithTimeout(port_cstr, num_bytes,
1387                         std::chrono::seconds{10}, num_bytes);
1388                 if (error.Success() && (port != nullptr))
1389                 {
1390                     assert(num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
1391                     *port = StringConvert::ToUInt32(port_cstr, 0);
1392                     if (log)
1393                         log->Printf("GDBRemoteCommunication::%s() "
1394                                     "debugserver listens %u port",
1395                                     __FUNCTION__, *port);
1396                 }
1397                 else
1398                 {
1399                     if (log)
1400                         log->Printf("GDBRemoteCommunication::%s() "
1401                                 "failed to read a port value from pipe %s: %s",
1402                                 __FUNCTION__, named_pipe_path.c_str(), error.AsCString());
1403
1404                 }
1405                 socket_pipe.Close();
1406             }
1407
1408             if (named_pipe_path.size() > 0)
1409             {
1410                 const auto err = socket_pipe.Delete(named_pipe_path);
1411                 if (err.Fail())
1412                 {
1413                     if (log)
1414                         log->Printf ("GDBRemoteCommunication::%s failed to delete pipe %s: %s",
1415                                 __FUNCTION__, named_pipe_path.c_str(), err.AsCString());
1416                 }
1417             }
1418
1419             // Make sure we actually connect with the debugserver...
1420             JoinListenThread();
1421         }
1422     }
1423     else
1424     {
1425         error.SetErrorStringWithFormat ("unable to locate " DEBUGSERVER_BASENAME );
1426     }
1427
1428     if (error.Fail())
1429     {
1430         if (log)
1431             log->Printf ("GDBRemoteCommunication::%s() failed: %s", __FUNCTION__, error.AsCString());
1432     }
1433
1434     return error;
1435 }
1436
1437 void
1438 GDBRemoteCommunication::DumpHistory(Stream &strm)
1439 {
1440     m_history.Dump (strm);
1441 }
1442
1443 GDBRemoteCommunication::ScopedTimeout::ScopedTimeout (GDBRemoteCommunication& gdb_comm,
1444                                                       uint32_t timeout) :
1445     m_gdb_comm (gdb_comm)
1446 {
1447     m_saved_timeout = m_gdb_comm.SetPacketTimeout (timeout);
1448 }
1449
1450 GDBRemoteCommunication::ScopedTimeout::~ScopedTimeout ()
1451 {
1452     m_gdb_comm.SetPacketTimeout (m_saved_timeout);
1453 }
1454
1455 // This function is called via the Communications class read thread when bytes become available
1456 // for this connection. This function will consume all incoming bytes and try to parse whole
1457 // packets as they become available. Full packets are placed in a queue, so that all packet
1458 // requests can simply pop from this queue. Async notification packets will be dispatched
1459 // immediately to the ProcessGDBRemote Async thread via an event.
1460 void GDBRemoteCommunication::AppendBytesToCache (const uint8_t * bytes, size_t len, bool broadcast, lldb::ConnectionStatus status)
1461 {
1462     StringExtractorGDBRemote packet;
1463
1464     while (true)
1465     {
1466         PacketType type = CheckForPacket(bytes, len, packet);
1467
1468         // scrub the data so we do not pass it back to CheckForPacket
1469         // on future passes of the loop
1470         bytes = nullptr;
1471         len = 0;
1472
1473         // we may have received no packet so lets bail out
1474         if (type == PacketType::Invalid)
1475             break;
1476
1477         if (type == PacketType::Standard)
1478         {
1479             // scope for the mutex
1480             {
1481                 // lock down the packet queue
1482                 Mutex::Locker locker(m_packet_queue_mutex);
1483                 // push a new packet into the queue
1484                 m_packet_queue.push(packet);
1485                 // Signal condition variable that we have a packet
1486                 m_condition_queue_not_empty.Signal();
1487
1488             }
1489         }
1490
1491         if (type == PacketType::Notify)
1492         {
1493             // put this packet into an event
1494             const char *pdata = packet.GetStringRef().c_str();
1495
1496             // as the communication class, we are a broadcaster and the
1497             // async thread is tuned to listen to us
1498             BroadcastEvent(
1499                 eBroadcastBitGdbReadThreadGotNotify,
1500                 new EventDataBytes(pdata));
1501         }
1502     }
1503 }