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