1 //===-- StringExtractorGDBRemote.cpp ----------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "Utility/StringExtractorGDBRemote.h"
12 #include <ctype.h> // for isxdigit
15 StringExtractorGDBRemote::ResponseType
16 StringExtractorGDBRemote::GetResponseType() const {
20 switch (m_packet[0]) {
22 if (isxdigit(m_packet[1]) && isxdigit(m_packet[2])) {
23 if (m_packet.size() == 3)
25 llvm::StringRef packet_ref(m_packet);
26 if (packet_ref[3] == ';') {
27 auto err_string = packet_ref.substr(4);
28 for (auto e : err_string)
37 if (m_packet.size() == 2 && m_packet[1] == 'K')
42 if (m_packet.size() == 1)
47 if (m_packet.size() == 1)
54 StringExtractorGDBRemote::ServerPacketType
55 StringExtractorGDBRemote::GetServerPacketType() const {
56 #define PACKET_MATCHES(s) \
57 ((packet_size == (sizeof(s) - 1)) && (strcmp((packet_cstr), (s)) == 0))
58 #define PACKET_STARTS_WITH(s) \
59 ((packet_size >= (sizeof(s) - 1)) && \
60 ::strncmp(packet_cstr, s, (sizeof(s) - 1)) == 0)
62 // Empty is not a supported packet...
64 return eServerPacketType_invalid;
66 const size_t packet_size = m_packet.size();
67 const char *packet_cstr = m_packet.c_str();
68 switch (m_packet[0]) {
71 return eServerPacketType_notify;
75 return eServerPacketType_interrupt;
80 return eServerPacketType_nack;
85 return eServerPacketType_ack;
89 return eServerPacketType_A;
93 switch (packet_cstr[1]) {
95 if (PACKET_STARTS_WITH("QEnvironment:"))
96 return eServerPacketType_QEnvironment;
97 if (PACKET_STARTS_WITH("QEnvironmentHexEncoded:"))
98 return eServerPacketType_QEnvironmentHexEncoded;
99 if (PACKET_STARTS_WITH("QEnableErrorStrings"))
100 return eServerPacketType_QEnableErrorStrings;
104 if (PACKET_STARTS_WITH("QPassSignals:"))
105 return eServerPacketType_QPassSignals;
108 if (PACKET_MATCHES("QStartNoAckMode"))
109 return eServerPacketType_QStartNoAckMode;
110 if (PACKET_STARTS_WITH("QSaveRegisterState"))
111 return eServerPacketType_QSaveRegisterState;
112 if (PACKET_STARTS_WITH("QSetDisableASLR:"))
113 return eServerPacketType_QSetDisableASLR;
114 if (PACKET_STARTS_WITH("QSetDetachOnError:"))
115 return eServerPacketType_QSetDetachOnError;
116 if (PACKET_STARTS_WITH("QSetSTDIN:"))
117 return eServerPacketType_QSetSTDIN;
118 if (PACKET_STARTS_WITH("QSetSTDOUT:"))
119 return eServerPacketType_QSetSTDOUT;
120 if (PACKET_STARTS_WITH("QSetSTDERR:"))
121 return eServerPacketType_QSetSTDERR;
122 if (PACKET_STARTS_WITH("QSetWorkingDir:"))
123 return eServerPacketType_QSetWorkingDir;
124 if (PACKET_STARTS_WITH("QSetLogging:"))
125 return eServerPacketType_QSetLogging;
126 if (PACKET_STARTS_WITH("QSetMaxPacketSize:"))
127 return eServerPacketType_QSetMaxPacketSize;
128 if (PACKET_STARTS_WITH("QSetMaxPayloadSize:"))
129 return eServerPacketType_QSetMaxPayloadSize;
130 if (PACKET_STARTS_WITH("QSetEnableAsyncProfiling;"))
131 return eServerPacketType_QSetEnableAsyncProfiling;
132 if (PACKET_STARTS_WITH("QSyncThreadState:"))
133 return eServerPacketType_QSyncThreadState;
137 if (PACKET_STARTS_WITH("QLaunchArch:"))
138 return eServerPacketType_QLaunchArch;
139 if (PACKET_MATCHES("QListThreadsInStopReply"))
140 return eServerPacketType_QListThreadsInStopReply;
144 if (PACKET_STARTS_WITH("QRestoreRegisterState:"))
145 return eServerPacketType_QRestoreRegisterState;
149 if (PACKET_MATCHES("QThreadSuffixSupported"))
150 return eServerPacketType_QThreadSuffixSupported;
156 switch (packet_cstr[1]) {
158 if (PACKET_MATCHES("qsProcessInfo"))
159 return eServerPacketType_qsProcessInfo;
160 if (PACKET_MATCHES("qsThreadInfo"))
161 return eServerPacketType_qsThreadInfo;
165 if (PACKET_STARTS_WITH("qfProcessInfo"))
166 return eServerPacketType_qfProcessInfo;
167 if (PACKET_STARTS_WITH("qfThreadInfo"))
168 return eServerPacketType_qfThreadInfo;
172 if (packet_size == 2)
173 return eServerPacketType_qC;
177 if (PACKET_STARTS_WITH("qEcho:"))
178 return eServerPacketType_qEcho;
182 if (PACKET_STARTS_WITH("qFileLoadAddress:"))
183 return eServerPacketType_qFileLoadAddress;
187 if (PACKET_STARTS_WITH("qGroupName:"))
188 return eServerPacketType_qGroupName;
189 if (PACKET_MATCHES("qGetWorkingDir"))
190 return eServerPacketType_qGetWorkingDir;
191 if (PACKET_MATCHES("qGetPid"))
192 return eServerPacketType_qGetPid;
193 if (PACKET_STARTS_WITH("qGetProfileData;"))
194 return eServerPacketType_qGetProfileData;
195 if (PACKET_MATCHES("qGDBServerVersion"))
196 return eServerPacketType_qGDBServerVersion;
200 if (PACKET_MATCHES("qHostInfo"))
201 return eServerPacketType_qHostInfo;
205 if (PACKET_STARTS_WITH("qKillSpawnedProcess"))
206 return eServerPacketType_qKillSpawnedProcess;
210 if (PACKET_STARTS_WITH("qLaunchGDBServer"))
211 return eServerPacketType_qLaunchGDBServer;
212 if (PACKET_MATCHES("qLaunchSuccess"))
213 return eServerPacketType_qLaunchSuccess;
217 if (PACKET_STARTS_WITH("qMemoryRegionInfo:"))
218 return eServerPacketType_qMemoryRegionInfo;
219 if (PACKET_MATCHES("qMemoryRegionInfo"))
220 return eServerPacketType_qMemoryRegionInfoSupported;
221 if (PACKET_STARTS_WITH("qModuleInfo:"))
222 return eServerPacketType_qModuleInfo;
226 if (PACKET_STARTS_WITH("qProcessInfoPID:"))
227 return eServerPacketType_qProcessInfoPID;
228 if (PACKET_STARTS_WITH("qPlatform_shell:"))
229 return eServerPacketType_qPlatform_shell;
230 if (PACKET_STARTS_WITH("qPlatform_mkdir:"))
231 return eServerPacketType_qPlatform_mkdir;
232 if (PACKET_STARTS_WITH("qPlatform_chmod:"))
233 return eServerPacketType_qPlatform_chmod;
234 if (PACKET_MATCHES("qProcessInfo"))
235 return eServerPacketType_qProcessInfo;
239 if (PACKET_MATCHES("qQueryGDBServer"))
240 return eServerPacketType_qQueryGDBServer;
244 if (PACKET_STARTS_WITH("qRcmd,"))
245 return eServerPacketType_qRcmd;
246 if (PACKET_STARTS_WITH("qRegisterInfo"))
247 return eServerPacketType_qRegisterInfo;
251 if (PACKET_STARTS_WITH("qSpeedTest:"))
252 return eServerPacketType_qSpeedTest;
253 if (PACKET_MATCHES("qShlibInfoAddr"))
254 return eServerPacketType_qShlibInfoAddr;
255 if (PACKET_MATCHES("qStepPacketSupported"))
256 return eServerPacketType_qStepPacketSupported;
257 if (PACKET_STARTS_WITH("qSupported"))
258 return eServerPacketType_qSupported;
259 if (PACKET_MATCHES("qSyncThreadStateSupported"))
260 return eServerPacketType_qSyncThreadStateSupported;
264 if (PACKET_STARTS_WITH("qThreadExtraInfo,"))
265 return eServerPacketType_qThreadExtraInfo;
266 if (PACKET_STARTS_WITH("qThreadStopInfo"))
267 return eServerPacketType_qThreadStopInfo;
271 if (PACKET_STARTS_WITH("qUserName:"))
272 return eServerPacketType_qUserName;
276 if (PACKET_MATCHES("qVAttachOrWaitSupported"))
277 return eServerPacketType_qVAttachOrWaitSupported;
281 if (PACKET_STARTS_WITH("qWatchpointSupportInfo:"))
282 return eServerPacketType_qWatchpointSupportInfo;
283 if (PACKET_MATCHES("qWatchpointSupportInfo"))
284 return eServerPacketType_qWatchpointSupportInfoSupported;
288 if (PACKET_STARTS_WITH("qXfer:auxv:read::"))
289 return eServerPacketType_qXfer_auxv_read;
295 if (PACKET_STARTS_WITH("jModulesInfo:"))
296 return eServerPacketType_jModulesInfo;
297 if (PACKET_MATCHES("jSignalsInfo"))
298 return eServerPacketType_jSignalsInfo;
299 if (PACKET_MATCHES("jThreadsInfo"))
300 return eServerPacketType_jThreadsInfo;
301 if (PACKET_STARTS_WITH("jTraceBufferRead:"))
302 return eServerPacketType_jTraceBufferRead;
303 if (PACKET_STARTS_WITH("jTraceConfigRead:"))
304 return eServerPacketType_jTraceConfigRead;
305 if (PACKET_STARTS_WITH("jTraceMetaRead:"))
306 return eServerPacketType_jTraceMetaRead;
307 if (PACKET_STARTS_WITH("jTraceStart:"))
308 return eServerPacketType_jTraceStart;
309 if (PACKET_STARTS_WITH("jTraceStop:"))
310 return eServerPacketType_jTraceStop;
314 if (PACKET_STARTS_WITH("vFile:")) {
315 if (PACKET_STARTS_WITH("vFile:open:"))
316 return eServerPacketType_vFile_open;
317 else if (PACKET_STARTS_WITH("vFile:close:"))
318 return eServerPacketType_vFile_close;
319 else if (PACKET_STARTS_WITH("vFile:pread"))
320 return eServerPacketType_vFile_pread;
321 else if (PACKET_STARTS_WITH("vFile:pwrite"))
322 return eServerPacketType_vFile_pwrite;
323 else if (PACKET_STARTS_WITH("vFile:size"))
324 return eServerPacketType_vFile_size;
325 else if (PACKET_STARTS_WITH("vFile:exists"))
326 return eServerPacketType_vFile_exists;
327 else if (PACKET_STARTS_WITH("vFile:stat"))
328 return eServerPacketType_vFile_stat;
329 else if (PACKET_STARTS_WITH("vFile:mode"))
330 return eServerPacketType_vFile_mode;
331 else if (PACKET_STARTS_WITH("vFile:MD5"))
332 return eServerPacketType_vFile_md5;
333 else if (PACKET_STARTS_WITH("vFile:symlink"))
334 return eServerPacketType_vFile_symlink;
335 else if (PACKET_STARTS_WITH("vFile:unlink"))
336 return eServerPacketType_vFile_unlink;
339 if (PACKET_STARTS_WITH("vAttach;"))
340 return eServerPacketType_vAttach;
341 if (PACKET_STARTS_WITH("vAttachWait;"))
342 return eServerPacketType_vAttachWait;
343 if (PACKET_STARTS_WITH("vAttachOrWait;"))
344 return eServerPacketType_vAttachOrWait;
345 if (PACKET_STARTS_WITH("vAttachName;"))
346 return eServerPacketType_vAttachName;
347 if (PACKET_STARTS_WITH("vCont;"))
348 return eServerPacketType_vCont;
349 if (PACKET_MATCHES("vCont?"))
350 return eServerPacketType_vCont_actions;
354 switch (packet_cstr[1]) {
356 return eServerPacketType__M;
359 return eServerPacketType__m;
364 if (packet_size == 1)
365 return eServerPacketType_stop_reason;
369 return eServerPacketType_c;
372 return eServerPacketType_C;
375 if (packet_size == 1)
376 return eServerPacketType_D;
380 if (packet_size == 1)
381 return eServerPacketType_g;
385 return eServerPacketType_G;
388 return eServerPacketType_H;
391 return eServerPacketType_I;
394 if (packet_size == 1)
395 return eServerPacketType_k;
399 return eServerPacketType_m;
402 return eServerPacketType_M;
405 return eServerPacketType_p;
408 return eServerPacketType_P;
411 if (packet_size == 1)
412 return eServerPacketType_s;
416 return eServerPacketType_S;
419 return eServerPacketType_x;
422 return eServerPacketType_X;
425 return eServerPacketType_T;
428 if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4')
429 return eServerPacketType_z;
433 if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4')
434 return eServerPacketType_Z;
437 return eServerPacketType_unimplemented;
440 bool StringExtractorGDBRemote::IsOKResponse() const {
441 return GetResponseType() == eOK;
444 bool StringExtractorGDBRemote::IsUnsupportedResponse() const {
445 return GetResponseType() == eUnsupported;
448 bool StringExtractorGDBRemote::IsNormalResponse() const {
449 return GetResponseType() == eResponse;
452 bool StringExtractorGDBRemote::IsErrorResponse() const {
453 return GetResponseType() == eError && isxdigit(m_packet[1]) &&
454 isxdigit(m_packet[2]);
457 uint8_t StringExtractorGDBRemote::GetError() {
458 if (GetResponseType() == eError) {
460 return GetHexU8(255);
465 lldb_private::Status StringExtractorGDBRemote::GetStatus() {
466 lldb_private::Status error;
467 if (GetResponseType() == eError) {
469 uint8_t errc = GetHexU8(255);
470 error.SetError(errc, lldb::eErrorTypeGeneric);
472 error.SetErrorStringWithFormat("Error %u", errc);
473 std::string error_messg;
474 if (GetChar() == ';') {
475 GetHexByteString(error_messg);
476 error.SetErrorString(error_messg);
482 size_t StringExtractorGDBRemote::GetEscapedBinaryData(std::string &str) {
483 // Just get the data bytes in the string as
484 // GDBRemoteCommunication::CheckForPacket()
485 // already removes any 0x7d escaped characters. If any 0x7d characters are
487 // the packet, then they are supposed to be there...
489 const size_t bytes_left = GetBytesLeft();
490 if (bytes_left > 0) {
491 str.assign(m_packet, m_index, bytes_left);
492 m_index += bytes_left;
498 OKErrorNotSupportedResponseValidator(void *,
499 const StringExtractorGDBRemote &response) {
500 switch (response.GetResponseType()) {
501 case StringExtractorGDBRemote::eOK:
502 case StringExtractorGDBRemote::eError:
503 case StringExtractorGDBRemote::eUnsupported:
506 case StringExtractorGDBRemote::eAck:
507 case StringExtractorGDBRemote::eNack:
508 case StringExtractorGDBRemote::eResponse:
514 static bool JSONResponseValidator(void *,
515 const StringExtractorGDBRemote &response) {
516 switch (response.GetResponseType()) {
517 case StringExtractorGDBRemote::eUnsupported:
518 case StringExtractorGDBRemote::eError:
519 return true; // Accept unsupported or EXX as valid responses
521 case StringExtractorGDBRemote::eOK:
522 case StringExtractorGDBRemote::eAck:
523 case StringExtractorGDBRemote::eNack:
526 case StringExtractorGDBRemote::eResponse:
527 // JSON that is returned in from JSON query packets is currently always
528 // either a dictionary which starts with a '{', or an array which
529 // starts with a '['. This is a quick validator to just make sure the
530 // response could be valid JSON without having to validate all of the
532 switch (response.GetStringRef()[0]) {
546 ASCIIHexBytesResponseValidator(void *,
547 const StringExtractorGDBRemote &response) {
548 switch (response.GetResponseType()) {
549 case StringExtractorGDBRemote::eUnsupported:
550 case StringExtractorGDBRemote::eError:
551 return true; // Accept unsupported or EXX as valid responses
553 case StringExtractorGDBRemote::eOK:
554 case StringExtractorGDBRemote::eAck:
555 case StringExtractorGDBRemote::eNack:
558 case StringExtractorGDBRemote::eResponse: {
559 uint32_t valid_count = 0;
560 for (const char ch : response.GetStringRef()) {
564 if (++valid_count >= 16)
565 break; // Don't validate all the characters in case the packet is very
574 void StringExtractorGDBRemote::CopyResponseValidator(
575 const StringExtractorGDBRemote &rhs) {
576 m_validator = rhs.m_validator;
577 m_validator_baton = rhs.m_validator_baton;
580 void StringExtractorGDBRemote::SetResponseValidator(
581 ResponseValidatorCallback callback, void *baton) {
582 m_validator = callback;
583 m_validator_baton = baton;
586 void StringExtractorGDBRemote::SetResponseValidatorToOKErrorNotSupported() {
587 m_validator = OKErrorNotSupportedResponseValidator;
588 m_validator_baton = nullptr;
591 void StringExtractorGDBRemote::SetResponseValidatorToASCIIHexBytes() {
592 m_validator = ASCIIHexBytesResponseValidator;
593 m_validator_baton = nullptr;
596 void StringExtractorGDBRemote::SetResponseValidatorToJSON() {
597 m_validator = JSONResponseValidator;
598 m_validator_baton = nullptr;
601 bool StringExtractorGDBRemote::ValidateResponse() const {
602 // If we have a validator callback, try to validate the callback
604 return m_validator(m_validator_baton, *this);
606 return true; // No validator, so response is valid