Bug Summary

File:tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
Location:line 1046, column 21
Description:Value stored to 'success' is never read

Annotated Source Code

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