7133762232
Modifed lldb_private::Process to be able to handle connecting to a remote target that isn't running a process. This leaves lldb_private::Process in the eStateConnected state from which we can then do an attach or launch. Modified ProcessGDBRemote to be able to set stdin, stdout, stderr, working dir, disable ASLR and a few other settings down by using new GDB remote packets. This allows us to keep all of our current launch flags and settings intact and still be able to communicate them over to the remote GDB server. Previously these were being sent as arguments to the debugserver binary that we were spawning. Also modified ProcessGDBRemote to handle losing connection to the remote GDB server and always exit immediately. We do this by watching the lldb_private::Communication event bit for the read thread exiting in the ProcessGDBRemote async thread. Added support for many of the new 'Q' packets for setting stdin, stdout, stderr, working dir and disable ASLR to the GDBRemoteCommunication class for easy accesss. Modified debugserver for all of the new 'Q' packets and also made it so that debugserver always exists if it loses connection with the remote debugger. llvm-svn: 126444
373 lines
10 KiB
C++
373 lines
10 KiB
C++
//===-- StringExtractor.cpp -------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Utility/StringExtractor.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
|
|
static inline int
|
|
xdigit_to_sint (char ch)
|
|
{
|
|
if (ch >= 'a' && ch <= 'f')
|
|
return 10 + ch - 'a';
|
|
if (ch >= 'A' && ch <= 'F')
|
|
return 10 + ch - 'A';
|
|
return ch - '0';
|
|
}
|
|
|
|
static inline unsigned int
|
|
xdigit_to_uint (uint8_t ch)
|
|
{
|
|
if (ch >= 'a' && ch <= 'f')
|
|
return 10u + ch - 'a';
|
|
if (ch >= 'A' && ch <= 'F')
|
|
return 10u + ch - 'A';
|
|
return ch - '0';
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// StringExtractor constructor
|
|
//----------------------------------------------------------------------
|
|
StringExtractor::StringExtractor() :
|
|
m_packet(),
|
|
m_index (0)
|
|
{
|
|
}
|
|
|
|
|
|
StringExtractor::StringExtractor(const char *packet_cstr) :
|
|
m_packet(),
|
|
m_index (0)
|
|
{
|
|
if (packet_cstr)
|
|
m_packet.assign (packet_cstr);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// StringExtractor copy constructor
|
|
//----------------------------------------------------------------------
|
|
StringExtractor::StringExtractor(const StringExtractor& rhs) :
|
|
m_packet (rhs.m_packet),
|
|
m_index (rhs.m_index)
|
|
{
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// StringExtractor assignment operator
|
|
//----------------------------------------------------------------------
|
|
const StringExtractor&
|
|
StringExtractor::operator=(const StringExtractor& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
m_packet = rhs.m_packet;
|
|
m_index = rhs.m_index;
|
|
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
StringExtractor::~StringExtractor()
|
|
{
|
|
}
|
|
|
|
|
|
char
|
|
StringExtractor::GetChar (char fail_value)
|
|
{
|
|
if (m_index < m_packet.size())
|
|
{
|
|
char ch = m_packet[m_index];
|
|
++m_index;
|
|
return ch;
|
|
}
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint32_t
|
|
StringExtractor::GetNumHexASCIICharsAtFilePos (uint32_t max) const
|
|
{
|
|
uint32_t idx = m_index;
|
|
const size_t size = m_packet.size();
|
|
while (idx < size && idx - m_index < max && isxdigit(m_packet[idx]))
|
|
++idx;
|
|
return idx - m_index;
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Extract a signed character from two hex ASCII chars in the packet
|
|
// string
|
|
//----------------------------------------------------------------------
|
|
int8_t
|
|
StringExtractor::GetHexS8 (int8_t fail_value)
|
|
{
|
|
if (GetNumHexASCIICharsAtFilePos(2))
|
|
{
|
|
char hi_nibble_char = m_packet[m_index];
|
|
char lo_nibble_char = m_packet[m_index+1];
|
|
|
|
if (isxdigit(hi_nibble_char) && isxdigit(lo_nibble_char))
|
|
{
|
|
char hi_nibble = xdigit_to_sint (hi_nibble_char);
|
|
char lo_nibble = xdigit_to_sint (lo_nibble_char);
|
|
m_index += 2;
|
|
return (hi_nibble << 4) + lo_nibble;
|
|
}
|
|
}
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract an unsigned character from two hex ASCII chars in the packet
|
|
// string
|
|
//----------------------------------------------------------------------
|
|
uint8_t
|
|
StringExtractor::GetHexU8 (uint8_t fail_value)
|
|
{
|
|
if (GetNumHexASCIICharsAtFilePos(2))
|
|
{
|
|
uint8_t hi_nibble_char = m_packet[m_index];
|
|
uint8_t lo_nibble_char = m_packet[m_index+1];
|
|
|
|
if (isxdigit(hi_nibble_char) && isxdigit(lo_nibble_char))
|
|
{
|
|
uint8_t hi_nibble = xdigit_to_uint (hi_nibble_char);
|
|
uint8_t lo_nibble = xdigit_to_uint (lo_nibble_char);
|
|
m_index += 2;
|
|
return (hi_nibble << 4) + lo_nibble;
|
|
}
|
|
}
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint32_t
|
|
StringExtractor::GetHexMaxU32 (bool little_endian, uint32_t fail_value)
|
|
{
|
|
uint32_t result = 0;
|
|
uint32_t nibble_count = 0;
|
|
|
|
if (little_endian)
|
|
{
|
|
uint32_t shift_amount = 0;
|
|
while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
// Make sure we don't exceed the size of a uint32_t...
|
|
if (nibble_count >= (sizeof(uint32_t) * 2))
|
|
{
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint8_t nibble_lo;
|
|
uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
|
|
++m_index;
|
|
if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
nibble_lo = xdigit_to_sint (m_packet[m_index]);
|
|
++m_index;
|
|
result |= ((uint32_t)nibble_hi << (shift_amount + 4));
|
|
result |= ((uint32_t)nibble_lo << shift_amount);
|
|
nibble_count += 2;
|
|
shift_amount += 8;
|
|
}
|
|
else
|
|
{
|
|
result |= ((uint32_t)nibble_hi << shift_amount);
|
|
nibble_count += 1;
|
|
shift_amount += 4;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
// Make sure we don't exceed the size of a uint32_t...
|
|
if (nibble_count >= (sizeof(uint32_t) * 2))
|
|
{
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
|
|
// Big Endian
|
|
result <<= 4;
|
|
result |= nibble;
|
|
|
|
++m_index;
|
|
++nibble_count;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
uint64_t
|
|
StringExtractor::GetHexMaxU64 (bool little_endian, uint64_t fail_value)
|
|
{
|
|
uint64_t result = 0;
|
|
uint32_t nibble_count = 0;
|
|
|
|
if (little_endian)
|
|
{
|
|
uint32_t shift_amount = 0;
|
|
while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
// Make sure we don't exceed the size of a uint64_t...
|
|
if (nibble_count >= (sizeof(uint64_t) * 2))
|
|
{
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint8_t nibble_lo;
|
|
uint8_t nibble_hi = xdigit_to_sint (m_packet[m_index]);
|
|
++m_index;
|
|
if (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
nibble_lo = xdigit_to_sint (m_packet[m_index]);
|
|
++m_index;
|
|
result |= ((uint64_t)nibble_hi << (shift_amount + 4));
|
|
result |= ((uint64_t)nibble_lo << shift_amount);
|
|
nibble_count += 2;
|
|
shift_amount += 8;
|
|
}
|
|
else
|
|
{
|
|
result |= ((uint64_t)nibble_hi << shift_amount);
|
|
nibble_count += 1;
|
|
shift_amount += 4;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (m_index < m_packet.size() && ::isxdigit (m_packet[m_index]))
|
|
{
|
|
// Make sure we don't exceed the size of a uint64_t...
|
|
if (nibble_count >= (sizeof(uint64_t) * 2))
|
|
{
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
uint8_t nibble = xdigit_to_sint (m_packet[m_index]);
|
|
// Big Endian
|
|
result <<= 4;
|
|
result |= nibble;
|
|
|
|
++m_index;
|
|
++nibble_count;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
size_t
|
|
StringExtractor::GetHexBytes (void *dst_void, size_t dst_len, uint8_t fail_fill_value)
|
|
{
|
|
uint8_t *dst = (uint8_t*)dst_void;
|
|
size_t bytes_extracted = 0;
|
|
while (bytes_extracted < dst_len && GetBytesLeft ())
|
|
{
|
|
dst[bytes_extracted] = GetHexU8 (fail_fill_value);
|
|
if (IsGood())
|
|
++bytes_extracted;
|
|
else
|
|
break;
|
|
}
|
|
|
|
for (size_t i = bytes_extracted; i < dst_len; ++i)
|
|
dst[i] = fail_fill_value;
|
|
|
|
return bytes_extracted;
|
|
}
|
|
|
|
|
|
// Consume ASCII hex nibble character pairs until we have decoded byte_size
|
|
// bytes of data.
|
|
|
|
uint64_t
|
|
StringExtractor::GetHexWithFixedSize (uint32_t byte_size, bool little_endian, uint64_t fail_value)
|
|
{
|
|
if (byte_size <= 8 && GetBytesLeft() >= byte_size * 2)
|
|
{
|
|
uint64_t result = 0;
|
|
uint32_t i;
|
|
if (little_endian)
|
|
{
|
|
// Little Endian
|
|
uint32_t shift_amount;
|
|
for (i = 0, shift_amount = 0;
|
|
i < byte_size && m_index != UINT32_MAX;
|
|
++i, shift_amount += 8)
|
|
{
|
|
result |= ((uint64_t)GetHexU8() << shift_amount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Big Endian
|
|
for (i = 0; i < byte_size && m_index != UINT32_MAX; ++i)
|
|
{
|
|
result <<= 8;
|
|
result |= GetHexU8();
|
|
}
|
|
}
|
|
}
|
|
m_index = UINT32_MAX;
|
|
return fail_value;
|
|
}
|
|
|
|
size_t
|
|
StringExtractor::GetHexByteString (std::string &str)
|
|
{
|
|
str.clear();
|
|
char ch;
|
|
while ((ch = GetHexU8()) != '\0')
|
|
str.append(1, ch);
|
|
return str.size();
|
|
}
|
|
|
|
bool
|
|
StringExtractor::GetNameColonValue (std::string &name, std::string &value)
|
|
{
|
|
// Read something in the form of NNNN:VVVV; where NNNN is any character
|
|
// that is not a colon, followed by a ':' character, then a value (one or
|
|
// more ';' chars), followed by a ';'
|
|
if (m_index < m_packet.size())
|
|
{
|
|
const size_t colon_idx = m_packet.find (':', m_index);
|
|
if (colon_idx != std::string::npos)
|
|
{
|
|
const size_t semicolon_idx = m_packet.find (';', colon_idx);
|
|
if (semicolon_idx != std::string::npos)
|
|
{
|
|
name.assign (m_packet, m_index, colon_idx - m_index);
|
|
value.assign (m_packet, colon_idx + 1, semicolon_idx - (colon_idx + 1));
|
|
m_index = semicolon_idx + 1;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
m_index = UINT32_MAX;
|
|
return false;
|
|
}
|