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/StreamFile.h"
  22 #include "lldb/Core/StreamString.h"
  23 #include "lldb/Host/ConnectionFileDescriptor.h"
  24 #include "lldb/Host/FileSpec.h"
  25 #include "lldb/Host/Host.h"
  26 #include "lldb/Host/HostInfo.h"
  27 #include "lldb/Host/Pipe.h"
  28 #include "lldb/Host/Socket.h"
  29 #include "lldb/Host/ThreadLauncher.h"
  30 #include "lldb/Host/TimeValue.h"
  31 #include "lldb/Target/Process.h"
  32
  33 // Project includes
  34 #include "ProcessGDBRemoteLog.h"
  35
  36 #if defined(__APPLE__)
  37 # define DEBUGSERVER_BASENAME    "debugserver"
  38 #else
  39 # define DEBUGSERVER_BASENAME    "lldb-gdbserver"
  40 #endif
  41
  42 using namespace lldb;
  43 using namespace lldb_private;
  44
  45 GDBRemoteCommunication::History::History (uint32_t size) :
  46     m_packets(),
  47     m_curr_idx (0),
  48     m_total_packet_count (0),
  49     m_dumped_to_log (false)
  50 {
  51     m_packets.resize(size);
  52 }
  53
  54 GDBRemoteCommunication::History::~History ()
  55 {
  56 }
  57
  58 void
  59 GDBRemoteCommunication::History::AddPacket (char packet_char,
  60                                             PacketType type,
  61                                             uint32_t bytes_transmitted)
  62 {
  63     const size_t size = m_packets.size();
  64     if (size > 0)
  65     {
  66         const uint32_t idx = GetNextIndex();
  67         m_packets[idx].packet.assign (1, packet_char);
  68         m_packets[idx].type = type;
  69         m_packets[idx].bytes_transmitted = bytes_transmitted;
  70         m_packets[idx].packet_idx = m_total_packet_count;
  71         m_packets[idx].tid = Host::GetCurrentThreadID();
  72     }
  73 }
  74
  75 void
  76 GDBRemoteCommunication::History::AddPacket (const std::string &src,
  77                                             uint32_t src_len,
  78                                             PacketType type,
  79                                             uint32_t bytes_transmitted)
  80 {
  81     const size_t size = m_packets.size();
  82     if (size > 0)
  83     {
  84         const uint32_t idx = GetNextIndex();
  85         m_packets[idx].packet.assign (src, 0, src_len);
  86         m_packets[idx].type = type;
  87         m_packets[idx].bytes_transmitted = bytes_transmitted;
  88         m_packets[idx].packet_idx = m_total_packet_count;
  89         m_packets[idx].tid = Host::GetCurrentThreadID();
  90     }
  91 }
  92
  93 void
  94 GDBRemoteCommunication::History::Dump (lldb_private::Stream &strm) const
  95 {
  96     const uint32_t size = GetNumPacketsInHistory ();
  97     const uint32_t first_idx = GetFirstSavedPacketIndex ();
  98     const uint32_t stop_idx = m_curr_idx + size;
  99     for (uint32_t i = first_idx;  i < stop_idx; ++i)
 100     {
 101         const uint32_t idx = NormalizeIndex (i);
 102         const Entry &entry = m_packets[idx];
 103         if (entry.type == ePacketTypeInvalid || entry.packet.empty())
 104             break;
 105         strm.Printf ("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s\n",
 106                      entry.packet_idx,
 107                      entry.tid,
 108                      entry.bytes_transmitted,
 109                      (entry.type == ePacketTypeSend) ? "send" : "read",
 110                      entry.packet.c_str());
 111     }
 112 }
 113
 114 void
 115 GDBRemoteCommunication::History::Dump (lldb_private::Log *log) const
 116 {
 117     if (log && !m_dumped_to_log)
 118     {
 119         m_dumped_to_log = true;
 120         const uint32_t size = GetNumPacketsInHistory ();
 121         const uint32_t first_idx = GetFirstSavedPacketIndex ();
 122         const uint32_t stop_idx = m_curr_idx + size;
 123         for (uint32_t i = first_idx;  i < stop_idx; ++i)
 124         {
 125             const uint32_t idx = NormalizeIndex (i);
 126             const Entry &entry = m_packets[idx];
 127             if (entry.type == ePacketTypeInvalid || entry.packet.empty())
 128                 break;
 129             log->Printf ("history[%u] tid=0x%4.4" PRIx64 " <%4u> %s packet: %s",
 130                          entry.packet_idx,
 131                          entry.tid,
 132                          entry.bytes_transmitted,
 133                          (entry.type == ePacketTypeSend) ? "send" : "read",
 134                          entry.packet.c_str());
 135         }
 136     }
 137 }
 138
 139 //----------------------------------------------------------------------
 140 // GDBRemoteCommunication constructor
 141 //----------------------------------------------------------------------
 142 GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
 143                                                const char *listener_name,
 144                                                bool is_platform) :
 145     Communication(comm_name),
 146 #ifdef LLDB_CONFIGURATION_DEBUG
 147     m_packet_timeout (1000),
 148 #else
 149     m_packet_timeout (1),
 150 #endif
 151     m_sequence_mutex (Mutex::eMutexTypeRecursive),
 152     m_public_is_running (false),
 153     m_private_is_running (false),
 154     m_history (512),
 155     m_send_acks (true),
 156     m_is_platform (is_platform),
 157     m_listen_url ()
 158 {
 159 }
 160
 161 //----------------------------------------------------------------------
 162 // Destructor
 163 //----------------------------------------------------------------------
 164 GDBRemoteCommunication::~GDBRemoteCommunication()
 165 {
 166     if (IsConnected())
 167     {
 168         Disconnect();
 169     }
 170 }
 171
 172 char
 173 GDBRemoteCommunication::CalculcateChecksum (const char *payload, size_t payload_length)
 174 {
 175     int checksum = 0;
 176
 177     for (size_t i = 0; i < payload_length; ++i)
 178         checksum += payload[i];
 179
 180     return checksum & 255;
 181 }
 182
 183 size_t
 184 GDBRemoteCommunication::SendAck ()
 185 {
 186     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 187     ConnectionStatus status = eConnectionStatusSuccess;
 188     char ch = '+';
 189     const size_t bytes_written = Write (&ch, 1, status, NULL);
 190     if (log)
 191         log->Printf ("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
 192     m_history.AddPacket (ch, History::ePacketTypeSend, bytes_written);
 193     return bytes_written;
 194 }
 195
 196 size_t
 197 GDBRemoteCommunication::SendNack ()
 198 {
 199     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 200     ConnectionStatus status = eConnectionStatusSuccess;
 201     char ch = '-';
 202     const size_t bytes_written = Write (&ch, 1, status, NULL);
 203     if (log)
 204         log->Printf("<%4" PRIu64 "> send packet: %c", (uint64_t)bytes_written, ch);
 205     m_history.AddPacket (ch, History::ePacketTypeSend, bytes_written);
 206     return bytes_written;
 207 }
 208
 209 GDBRemoteCommunication::PacketResult
 210 GDBRemoteCommunication::SendPacket (const char *payload, size_t payload_length)
 211 {
 212     Mutex::Locker locker(m_sequence_mutex);
 213     return SendPacketNoLock (payload, payload_length);
 214 }
 215
 216 GDBRemoteCommunication::PacketResult
 217 GDBRemoteCommunication::SendPacketNoLock (const char *payload, size_t payload_length)
 218 {
 219     if (IsConnected())
 220     {
 221         StreamString packet(0, 4, eByteOrderBig);
 222
 223         packet.PutChar('$');
 224         packet.Write (payload, payload_length);
 225         packet.PutChar('#');
 226         packet.PutHex8(CalculcateChecksum (payload, payload_length));
 227
 228         Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 229         ConnectionStatus status = eConnectionStatusSuccess;
 230         const char *packet_data = packet.GetData();
 231         const size_t packet_length = packet.GetSize();
 232         size_t bytes_written = Write (packet_data, packet_length, status, NULL);
 233         if (log)
 234         {
 235             size_t binary_start_offset = 0;
 236             if (strncmp(packet_data, "$vFile:pwrite:", strlen("$vFile:pwrite:")) == 0)
 237             {
 238                 const char *first_comma = strchr(packet_data, ',');
 239                 if (first_comma)
 240                 {
 241                     const char *second_comma = strchr(first_comma + 1, ',');
 242                     if (second_comma)
 243                         binary_start_offset = second_comma - packet_data + 1;
 244                 }
 245             }
 246
 247             // If logging was just enabled and we have history, then dump out what
 248             // we have to the log so we get the historical context. The Dump() call that
 249             // logs all of the packet will set a boolean so that we don't dump this more
 250             // than once
 251             if (!m_history.DidDumpToLog ())
 252                 m_history.Dump (log);
 253
 254             if (binary_start_offset)
 255             {
 256                 StreamString strm;
 257                 // Print non binary data header
 258                 strm.Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)binary_start_offset, packet_data);
 259                 const uint8_t *p;
 260                 // Print binary data exactly as sent
 261                 for (p = (uint8_t*)packet_data + binary_start_offset; *p != '#'; ++p)
 262                     strm.Printf("\\x%2.2x", *p);
 263                 // Print the checksum
 264                 strm.Printf("%*s", (int)3, p);
 265                 log->PutCString(strm.GetString().c_str());
 266             }
 267             else
 268                 log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)packet_length, packet_data);
 269         }
 270
 271         m_history.AddPacket (packet.GetString(), packet_length, History::ePacketTypeSend, bytes_written);
 272
 273
 274         if (bytes_written == packet_length)
 275         {
 276             if (GetSendAcks ())
 277                 return GetAck ();
 278             else
 279                 return PacketResult::Success;
 280         }
 281         else
 282         {
 283             if (log)
 284                 log->Printf ("error: failed to send packet: %.*s", (int)packet_length, packet_data);
 285         }
 286     }
 287     return PacketResult::ErrorSendFailed;
 288 }
 289
 290 GDBRemoteCommunication::PacketResult
 291 GDBRemoteCommunication::GetAck ()
 292 {
 293     StringExtractorGDBRemote packet;
 294     PacketResult result = WaitForPacketWithTimeoutMicroSecondsNoLock (packet, GetPacketTimeoutInMicroSeconds ());
 295     if (result == PacketResult::Success)
 296     {
 297         if (packet.GetResponseType() == StringExtractorGDBRemote::ResponseType::eAck)
 298             return PacketResult::Success;
 299         else
 300             return PacketResult::ErrorSendAck;
 301     }
 302     return result;
 303 }
 304
 305 bool
 306 GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker, const char *failure_message)
 307 {
 308     if (IsRunning())
 309         return locker.TryLock (m_sequence_mutex, failure_message);
 310
 311     locker.Lock (m_sequence_mutex);
 312     return true;
 313 }
 314
 315
 316 bool
 317 GDBRemoteCommunication::WaitForNotRunningPrivate (const TimeValue *timeout_ptr)
 318 {
 319     return m_private_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
 320 }
 321
 322 GDBRemoteCommunication::PacketResult
 323 GDBRemoteCommunication::WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtractorGDBRemote &packet, uint32_t timeout_usec)
 324 {
 325     uint8_t buffer[8192];
 326     Error error;
 327
 328     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS | GDBR_LOG_VERBOSE));
 329
 330     // Check for a packet from our cache first without trying any reading...
 331     if (CheckForPacket (NULL, 0, packet))
 332         return PacketResult::Success;
 333
 334     bool timed_out = false;
 335     bool disconnected = false;
 336     while (IsConnected() && !timed_out)
 337     {
 338         lldb::ConnectionStatus status = eConnectionStatusNoConnection;
 339         size_t bytes_read = Read (buffer, sizeof(buffer), timeout_usec, status, &error);
 340
 341         if (log)
 342             log->Printf ("%s: Read (buffer, (sizeof(buffer), timeout_usec = 0x%x, status = %s, error = %s) => bytes_read = %" PRIu64,
 343                          __PRETTY_FUNCTION__,
 344                          timeout_usec,
 345                          Communication::ConnectionStatusAsCString (status),
 346                          error.AsCString(),
 347                          (uint64_t)bytes_read);
 348
 349         if (bytes_read > 0)
 350         {
 351             if (CheckForPacket (buffer, bytes_read, packet))
 352                 return PacketResult::Success;
 353         }
 354         else
 355         {
 356             switch (status)
 357             {
 358             case eConnectionStatusTimedOut:
 359             case eConnectionStatusInterrupted:
 360                 timed_out = true;
 361                 break;
 362             case eConnectionStatusSuccess:
 363                 //printf ("status = success but error = %s\n", error.AsCString("<invalid>"));
 364                 break;
 365
 366             case eConnectionStatusEndOfFile:
 367             case eConnectionStatusNoConnection:
 368             case eConnectionStatusLostConnection:
 369             case eConnectionStatusError:
 370                 disconnected = true;
 371                 Disconnect();
 372                 break;
 373             }
 374         }
 375     }
 376     packet.Clear ();
 377     if (disconnected)
 378         return PacketResult::ErrorDisconnected;
 379     if (timed_out)
 380         return PacketResult::ErrorReplyTimeout;
 381     else
 382         return PacketResult::ErrorReplyFailed;
 383 }
 384
 385 bool
 386 GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, StringExtractorGDBRemote &packet)
 387 {
 388     // Put the packet data into the buffer in a thread safe fashion
 389     Mutex::Locker locker(m_bytes_mutex);
 390
 391     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 392
 393     if (src && src_len > 0)
 394     {
 395         if (log && log->GetVerbose())
 396         {
 397             StreamString s;
 398             log->Printf ("GDBRemoteCommunication::%s adding %u bytes: %.*s",
 399                          __FUNCTION__,
 400                          (uint32_t)src_len,
 401                          (uint32_t)src_len,
 402                          src);
 403         }
 404         m_bytes.append ((const char *)src, src_len);
 405     }
 406
 407     // Parse up the packets into gdb remote packets
 408     if (!m_bytes.empty())
 409     {
 410         // end_idx must be one past the last valid packet byte. Start
 411         // it off with an invalid value that is the same as the current
 412         // index.
 413         size_t content_start = 0;
 414         size_t content_length = 0;
 415         size_t total_length = 0;
 416         size_t checksum_idx = std::string::npos;
 417
 418         switch (m_bytes[0])
 419         {
 420             case '+':       // Look for ack
 421             case '-':       // Look for cancel
 422             case '\x03':    // ^C to halt target
 423                 content_length = total_length = 1;  // The command is one byte long...
 424                 break;
 425
 426             case '$':
 427                 // Look for a standard gdb packet?
 428                 {
 429                     size_t hash_pos = m_bytes.find('#');
 430                     if (hash_pos != std::string::npos)
 431                     {
 432                         if (hash_pos + 2 < m_bytes.size())
 433                         {
 434                             checksum_idx = hash_pos + 1;
 435                             // Skip the dollar sign
 436                             content_start = 1;
 437                             // Don't include the # in the content or the $ in the content length
 438                             content_length = hash_pos - 1;
 439
 440                             total_length = hash_pos + 3; // Skip the # and the two hex checksum bytes
 441                         }
 442                         else
 443                         {
 444                             // Checksum bytes aren't all here yet
 445                             content_length = std::string::npos;
 446                         }
 447                     }
 448                 }
 449                 break;
 450
 451             default:
 452                 {
 453                     // We have an unexpected byte and we need to flush all bad
 454                     // data that is in m_bytes, so we need to find the first
 455                     // byte that is a '+' (ACK), '-' (NACK), \x03 (CTRL+C interrupt),
 456                     // or '$' character (start of packet header) or of course,
 457                     // the end of the data in m_bytes...
 458                     const size_t bytes_len = m_bytes.size();
 459                     bool done = false;
 460                     uint32_t idx;
 461                     for (idx = 1; !done && idx < bytes_len; ++idx)
 462                     {
 463                         switch (m_bytes[idx])
 464                         {
 465                         case '+':
 466                         case '-':
 467                         case '\x03':
 468                         case '$':
 469                             done = true;
 470                             break;
 471
 472                         default:
 473                             break;
 474                         }
 475                     }
 476                     if (log)
 477                         log->Printf ("GDBRemoteCommunication::%s tossing %u junk bytes: '%.*s'",
 478                                      __FUNCTION__, idx - 1, idx - 1, m_bytes.c_str());
 479                     m_bytes.erase(0, idx - 1);
 480                 }
 481                 break;
 482         }
 483
 484         if (content_length == std::string::npos)
 485         {
 486             packet.Clear();
 487             return false;
 488         }
 489         else if (total_length > 0)
 490         {
 491
 492             // We have a valid packet...
 493             assert (content_length <= m_bytes.size());
 494             assert (total_length <= m_bytes.size());
 495             assert (content_length <= total_length);
 496             const size_t content_end = content_start + content_length;
 497
 498             bool success = true;
 499             std::string &packet_str = packet.GetStringRef();
 500
 501
 502             if (log)
 503             {
 504                 // If logging was just enabled and we have history, then dump out what
 505                 // we have to the log so we get the historical context. The Dump() call that
 506                 // logs all of the packet will set a boolean so that we don't dump this more
 507                 // than once
 508                 if (!m_history.DidDumpToLog ())
 509                     m_history.Dump (log);
 510
 511                 bool binary = false;
 512                 // Only detect binary for packets that start with a '$' and have a '#CC' checksum
 513                 if (m_bytes[0] == '$' && total_length > 4)
 514                 {
 515                     for (size_t i=0; !binary && i<total_length; ++i)
 516                     {
 517                         if (isprint(m_bytes[i]) == 0)
 518                             binary = true;
 519                     }
 520                 }
 521                 if (binary)
 522                 {
 523                     StreamString strm;
 524                     // Packet header...
 525                     strm.Printf("<%4" PRIu64 "> read packet: %c", (uint64_t)total_length, m_bytes[0]);
 526                     for (size_t i=content_start; i<content_end; ++i)
 527                     {
 528                         // Remove binary escaped bytes when displaying the packet...
 529                         const char ch = m_bytes[i];
 530                         if (ch == 0x7d)
 531                         {
 532                             // 0x7d is the escape character.  The next character is to
 533                             // be XOR'd with 0x20.
 534                             const char escapee = m_bytes[++i] ^ 0x20;
 535                             strm.Printf("%2.2x", escapee);
 536                         }
 537                         else
 538                         {
 539                             strm.Printf("%2.2x", (uint8_t)ch);
 540                         }
 541                     }
 542                     // Packet footer...
 543                     strm.Printf("%c%c%c", m_bytes[total_length-3], m_bytes[total_length-2], m_bytes[total_length-1]);
 544                     log->PutCString(strm.GetString().c_str());
 545                 }
 546                 else
 547                 {
 548                     log->Printf("<%4" PRIu64 "> read packet: %.*s", (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
 549                 }
 550             }
 551
 552             m_history.AddPacket (m_bytes.c_str(), total_length, History::ePacketTypeRecv, total_length);
 553
 554             // Clear packet_str in case there is some existing data in it.
 555             packet_str.clear();
 556             // Copy the packet from m_bytes to packet_str expanding the
 557             // run-length encoding in the process.
 558             // Reserve enough byte for the most common case (no RLE used)
 559             packet_str.reserve(m_bytes.length());
 560             for (std::string::const_iterator c = m_bytes.begin() + content_start; c != m_bytes.begin() + content_end; ++c)
 561             {
 562                 if (*c == '*')
 563                 {
 564                     // '*' indicates RLE. Next character will give us the
 565                     // repeat count and previous character is what is to be
 566                     // repeated.
 567                     char char_to_repeat = packet_str.back();
 568                     // Number of time the previous character is repeated
 569                     int repeat_count = *++c + 3 - ' ';
 570                     // We have the char_to_repeat and repeat_count. Now push
 571                     // it in the packet.
 572                     for (int i = 0; i < repeat_count; ++i)
 573                         packet_str.push_back(char_to_repeat);
 574                 }
 575                 else if (*c == 0x7d)
 576                 {
 577                     // 0x7d is the escape character.  The next character is to
 578                     // be XOR'd with 0x20.
 579                     char escapee = *++c ^ 0x20;
 580                     packet_str.push_back(escapee);
 581                 }
 582                 else
 583                 {
 584                     packet_str.push_back(*c);
 585                 }
 586             }
 587
 588             if (m_bytes[0] == '$')
 589             {
 590                 assert (checksum_idx < m_bytes.size());
 591                 if (::isxdigit (m_bytes[checksum_idx+0]) ||
 592                     ::isxdigit (m_bytes[checksum_idx+1]))
 593                 {
 594                     if (GetSendAcks ())
 595                     {
 596                         const char *packet_checksum_cstr = &m_bytes[checksum_idx];
 597                         char packet_checksum = strtol (packet_checksum_cstr, NULL, 16);
 598                         char actual_checksum = CalculcateChecksum (packet_str.c_str(), packet_str.size());
 599                         success = packet_checksum == actual_checksum;
 600                         if (!success)
 601                         {
 602                             if (log)
 603                                 log->Printf ("error: checksum mismatch: %.*s expected 0x%2.2x, got 0x%2.2x",
 604                                              (int)(total_length),
 605                                              m_bytes.c_str(),
 606                                              (uint8_t)packet_checksum,
 607                                              (uint8_t)actual_checksum);
 608                         }
 609                         // Send the ack or nack if needed
 610                         if (!success)
 611                             SendNack();
 612                         else
 613                             SendAck();
 614                     }
 615                 }
 616                 else
 617                 {
 618                     success = false;
 619                     if (log)
 620                         log->Printf ("error: invalid checksum in packet: '%s'\n", m_bytes.c_str());
 621                 }
 622             }
 623
 624             m_bytes.erase(0, total_length);
 625             packet.SetFilePos(0);
 626             return success;
 627         }
 628     }
 629     packet.Clear();
 630     return false;
 631 }
 632
 633 Error
 634 GDBRemoteCommunication::StartListenThread (const char *hostname, uint16_t port)
 635 {
 636     Error error;
 637     if (m_listen_thread.IsJoinable())
 638     {
 639         error.SetErrorString("listen thread already running");
 640     }
 641     else
 642     {
 643         char listen_url[512];
 644         if (hostname && hostname[0])
 645             snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
 646         else
 647             snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
 648         m_listen_url = listen_url;
 649         SetConnection(new ConnectionFileDescriptor());
 650         m_listen_thread = ThreadLauncher::LaunchThread(listen_url, GDBRemoteCommunication::ListenThread, this, &error);
 651     }
 652     return error;
 653 }
 654
 655 bool
 656 GDBRemoteCommunication::JoinListenThread ()
 657 {
 658     if (m_listen_thread.IsJoinable())
 659         m_listen_thread.Join(nullptr);
 660     return true;
 661 }
 662
 663 lldb::thread_result_t
 664 GDBRemoteCommunication::ListenThread (lldb::thread_arg_t arg)
 665 {
 666     GDBRemoteCommunication *comm = (GDBRemoteCommunication *)arg;
 667     Error error;
 668     ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)comm->GetConnection ();
 669
 670     if (connection)
 671     {
 672         // Do the listen on another thread so we can continue on...
 673         if (connection->Connect(comm->m_listen_url.c_str(), &error) != eConnectionStatusSuccess)
 674             comm->SetConnection(NULL);
 675     }
 676     return NULL;
 677 }
 678
 679 Error
 680 GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
 681                                                  uint16_t in_port,
 682                                                  lldb_private::ProcessLaunchInfo &launch_info,
 683                                                  uint16_t &out_port)
 684 {
 685     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 686     if (log)
 687         log->Printf ("GDBRemoteCommunication::%s(hostname=%s, in_port=%" PRIu16 ", out_port=%" PRIu16, __FUNCTION__, hostname ? hostname : "<empty>", in_port, out_port);
 688
 689     out_port = in_port;
 690     Error error;
 691     // If we locate debugserver, keep that located version around
 692     static FileSpec g_debugserver_file_spec;
 693
 694     char debugserver_path[PATH_MAX];
 695     FileSpec &debugserver_file_spec = launch_info.GetExecutableFile();
 696
 697     // Always check to see if we have an environment override for the path
 698     // to the debugserver to use and use it if we do.
 699     const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
 700     if (env_debugserver_path)
 701     {
 702         debugserver_file_spec.SetFile (env_debugserver_path, false);
 703         if (log)
 704             log->Printf ("GDBRemoteCommunication::%s() gdb-remote stub exe path set from environment variable: %s", __FUNCTION__, env_debugserver_path);
 705     }
 706     else
 707         debugserver_file_spec = g_debugserver_file_spec;
 708     bool debugserver_exists = debugserver_file_spec.Exists();
 709     if (!debugserver_exists)
 710     {
 711         // The debugserver binary is in the LLDB.framework/Resources
 712         // directory.
 713         if (HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir, debugserver_file_spec))
 714         {
 715             debugserver_file_spec.AppendPathComponent (DEBUGSERVER_BASENAME);
 716             debugserver_exists = debugserver_file_spec.Exists();
 717             if (debugserver_exists)
 718             {
 719                 if (log)
 720                     log->Printf ("GDBRemoteCommunication::%s() found gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
 721
 722                 g_debugserver_file_spec = debugserver_file_spec;
 723             }
 724             else
 725             {
 726                 if (log)
 727                     log->Printf ("GDBRemoteCommunication::%s() could not find gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
 728
 729                 g_debugserver_file_spec.Clear();
 730                 debugserver_file_spec.Clear();
 731             }
 732         }
 733     }
 734
 735     if (debugserver_exists)
 736     {
 737         debugserver_file_spec.GetPath (debugserver_path, sizeof(debugserver_path));
 738
 739         Args &debugserver_args = launch_info.GetArguments();
 740         debugserver_args.Clear();
 741         char arg_cstr[PATH_MAX];
 742
 743         // Start args with "debugserver /file/path -r --"
 744         debugserver_args.AppendArgument(debugserver_path);
 745
 746         // If a host and port is supplied then use it
 747         char host_and_port[128];
 748         if (hostname)
 749         {
 750             snprintf (host_and_port, sizeof(host_and_port), "%s:%u", hostname, in_port);
 751             debugserver_args.AppendArgument(host_and_port);
 752         }
 753         else
 754         {
 755             host_and_port[0] = '\0';
 756         }
 757
 758         // use native registers, not the GDB registers
 759         debugserver_args.AppendArgument("--native-regs");
 760         // make debugserver run in its own session so signals generated by
 761         // special terminal key sequences (^C) don't affect debugserver
 762         debugserver_args.AppendArgument("--setsid");
 763
 764         char named_pipe_path[PATH_MAX];
 765         named_pipe_path[0] = '\0';
 766         Pipe port_named_pipe;
 767
 768         bool listen = false;
 769         if (host_and_port[0])
 770         {
 771             // Create a temporary file to get the stdout/stderr and redirect the
 772             // output of the command into this file. We will later read this file
 773             // if all goes well and fill the data into "command_output_ptr"
 774
 775             if (in_port == 0)
 776             {
 777                 // Binding to port zero, we need to figure out what port it ends up
 778                 // using using a named pipe...
 779                 FileSpec tmpdir_file_spec;
 780                 if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
 781                 {
 782                     tmpdir_file_spec.AppendPathComponent("debugserver-named-pipe.XXXXXX");
 783                     strncpy(named_pipe_path, tmpdir_file_spec.GetPath().c_str(), sizeof(named_pipe_path));
 784                 }
 785                 else
 786                 {
 787                     strncpy(named_pipe_path, "/tmp/debugserver-named-pipe.XXXXXX", sizeof(named_pipe_path));
 788                 }
 789
 790                 if (::mktemp (named_pipe_path))
 791                 {
 792                     error = port_named_pipe.CreateNew(named_pipe_path, false);
 793                     if (error.Fail())
 794                         return error;
 795                     debugserver_args.AppendArgument("--named-pipe");
 796                     debugserver_args.AppendArgument(named_pipe_path);
 797                 }
 798             }
 799             else
 800             {
 801                 listen = true;
 802             }
 803         }
 804         else
 805         {
 806             // No host and port given, so lets listen on our end and make the debugserver
 807             // connect to us..
 808             error = StartListenThread ("127.0.0.1", 0);
 809             if (error.Fail())
 810                 return error;
 811
 812             ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)GetConnection ();
 813             // Wait for 10 seconds to resolve the bound port
 814             out_port = connection->GetListeningPort(10);
 815             if (out_port > 0)
 816             {
 817                 char port_cstr[32];
 818                 snprintf(port_cstr, sizeof(port_cstr), "127.0.0.1:%i", out_port);
 819                 // Send the host and port down that debugserver and specify an option
 820                 // so that it connects back to the port we are listening to in this process
 821                 debugserver_args.AppendArgument("--reverse-connect");
 822                 debugserver_args.AppendArgument(port_cstr);
 823             }
 824             else
 825             {
 826                 error.SetErrorString ("failed to bind to port 0 on 127.0.0.1");
 827                 return error;
 828             }
 829         }
 830
 831         const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
 832         if (env_debugserver_log_file)
 833         {
 834             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file);
 835             debugserver_args.AppendArgument(arg_cstr);
 836         }
 837
 838         const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS");
 839         if (env_debugserver_log_flags)
 840         {
 841             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
 842             debugserver_args.AppendArgument(arg_cstr);
 843         }
 844
 845         // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an env var doesn't come back.
 846         uint32_t env_var_index = 1;
 847         bool has_env_var;
 848         do
 849         {
 850             char env_var_name[64];
 851             snprintf (env_var_name, sizeof (env_var_name), "LLDB_DEBUGSERVER_EXTRA_ARG_%" PRIu32, env_var_index++);
 852             const char *extra_arg = getenv(env_var_name);
 853             has_env_var = extra_arg != nullptr;
 854
 855             if (has_env_var)
 856             {
 857                 debugserver_args.AppendArgument (extra_arg);
 858                 if (log)
 859                     log->Printf ("GDBRemoteCommunication::%s adding env var %s contents to stub command line (%s)", __FUNCTION__, env_var_name, extra_arg);
 860             }
 861         } while (has_env_var);
 862
 863         // Close STDIN, STDOUT and STDERR.
 864         launch_info.AppendCloseFileAction (STDIN_FILENO);
 865         launch_info.AppendCloseFileAction (STDOUT_FILENO);
 866         launch_info.AppendCloseFileAction (STDERR_FILENO);
 867
 868         // Redirect STDIN, STDOUT and STDERR to "/dev/null".
 869         launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false);
 870         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);
 871         launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true);
 872
 873         error = Host::LaunchProcess(launch_info);
 874
 875         if (error.Success() && launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
 876         {
 877             if (named_pipe_path[0])
 878             {
 879                 error = port_named_pipe.OpenAsReader(named_pipe_path, false);
 880                 if (error.Success())
 881                 {
 882                     char port_cstr[256];
 883                     port_cstr[0] = '\0';
 884                     size_t num_bytes = sizeof(port_cstr);
 885                     // Read port from pipe with 10 second timeout.
 886                     error = port_named_pipe.ReadWithTimeout(port_cstr, num_bytes, std::chrono::microseconds(10 * 1000000), num_bytes);
 887                     if (error.Success())
 888                     {
 889                         assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
 890                         out_port = Args::StringToUInt32(port_cstr, 0);
 891                         if (log)
 892                             log->Printf("GDBRemoteCommunication::%s() debugserver listens %u port", __FUNCTION__, out_port);
 893                     }
 894                     else
 895                     {
 896                         if (log)
 897                             log->Printf("GDBRemoteCommunication::%s() failed to read a port value from named pipe %s: %s", __FUNCTION__, named_pipe_path, error.AsCString());
 898
 899                     }
 900                     port_named_pipe.Close();
 901                 }
 902                 else
 903                 {
 904                     if (log)
 905                         log->Printf("GDBRemoteCommunication::%s() failed to open named pipe %s for reading: %s", __FUNCTION__, named_pipe_path, error.AsCString());
 906                 }
 907                 const auto err = port_named_pipe.Delete(named_pipe_path);
 908                 if (err.Fail())
 909                 {
 910                     if (log)
 911                         log->Printf ("GDBRemoteCommunication::%s failed to delete pipe %s: %s", __FUNCTION__, named_pipe_path, err.AsCString());
 912                 }
 913             }
 914             else if (listen)
 915             {
 916
 917             }
 918             else
 919             {
 920                 // Make sure we actually connect with the debugserver...
 921                 JoinListenThread();
 922             }
 923         }
 924     }
 925     else
 926     {
 927         error.SetErrorStringWithFormat ("unable to locate " DEBUGSERVER_BASENAME );
 928     }
 929     return error;
 930 }
 931
 932 void
 933 GDBRemoteCommunication::DumpHistory(Stream &strm)
 934 {
 935     m_history.Dump (strm);
 936 }