1 //===-- StringExtractorGDBRemote.cpp --------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Utility/StringExtractorGDBRemote.h" 10 11 #include <ctype.h> 12 #include <string.h> 13 14 constexpr lldb::pid_t StringExtractorGDBRemote::AllProcesses; 15 constexpr lldb::tid_t StringExtractorGDBRemote::AllThreads; 16 17 StringExtractorGDBRemote::ResponseType 18 StringExtractorGDBRemote::GetResponseType() const { 19 if (m_packet.empty()) 20 return eUnsupported; 21 22 switch (m_packet[0]) { 23 case 'E': 24 if (isxdigit(m_packet[1]) && isxdigit(m_packet[2])) { 25 if (m_packet.size() == 3) 26 return eError; 27 llvm::StringRef packet_ref(m_packet); 28 if (packet_ref[3] == ';') { 29 auto err_string = packet_ref.substr(4); 30 for (auto e : err_string) 31 if (!isxdigit(e)) 32 return eResponse; 33 return eError; 34 } 35 } 36 break; 37 38 case 'O': 39 if (m_packet.size() == 2 && m_packet[1] == 'K') 40 return eOK; 41 break; 42 43 case '+': 44 if (m_packet.size() == 1) 45 return eAck; 46 break; 47 48 case '-': 49 if (m_packet.size() == 1) 50 return eNack; 51 break; 52 } 53 return eResponse; 54 } 55 56 StringExtractorGDBRemote::ServerPacketType 57 StringExtractorGDBRemote::GetServerPacketType() const { 58 #define PACKET_MATCHES(s) \ 59 ((packet_size == (sizeof(s) - 1)) && (strcmp((packet_cstr), (s)) == 0)) 60 #define PACKET_STARTS_WITH(s) \ 61 ((packet_size >= (sizeof(s) - 1)) && \ 62 ::strncmp(packet_cstr, s, (sizeof(s) - 1)) == 0) 63 64 // Empty is not a supported packet... 65 if (m_packet.empty()) 66 return eServerPacketType_invalid; 67 68 const size_t packet_size = m_packet.size(); 69 const char *packet_cstr = m_packet.c_str(); 70 switch (m_packet[0]) { 71 72 case '%': 73 return eServerPacketType_notify; 74 75 case '\x03': 76 if (packet_size == 1) 77 return eServerPacketType_interrupt; 78 break; 79 80 case '-': 81 if (packet_size == 1) 82 return eServerPacketType_nack; 83 break; 84 85 case '+': 86 if (packet_size == 1) 87 return eServerPacketType_ack; 88 break; 89 90 case 'A': 91 return eServerPacketType_A; 92 93 case 'Q': 94 95 switch (packet_cstr[1]) { 96 case 'E': 97 if (PACKET_STARTS_WITH("QEnvironment:")) 98 return eServerPacketType_QEnvironment; 99 if (PACKET_STARTS_WITH("QEnvironmentHexEncoded:")) 100 return eServerPacketType_QEnvironmentHexEncoded; 101 if (PACKET_STARTS_WITH("QEnableErrorStrings")) 102 return eServerPacketType_QEnableErrorStrings; 103 break; 104 105 case 'P': 106 if (PACKET_STARTS_WITH("QPassSignals:")) 107 return eServerPacketType_QPassSignals; 108 break; 109 110 case 'S': 111 if (PACKET_MATCHES("QStartNoAckMode")) 112 return eServerPacketType_QStartNoAckMode; 113 if (PACKET_STARTS_WITH("QSaveRegisterState")) 114 return eServerPacketType_QSaveRegisterState; 115 if (PACKET_STARTS_WITH("QSetDisableASLR:")) 116 return eServerPacketType_QSetDisableASLR; 117 if (PACKET_STARTS_WITH("QSetDetachOnError:")) 118 return eServerPacketType_QSetDetachOnError; 119 if (PACKET_STARTS_WITH("QSetSTDIN:")) 120 return eServerPacketType_QSetSTDIN; 121 if (PACKET_STARTS_WITH("QSetSTDOUT:")) 122 return eServerPacketType_QSetSTDOUT; 123 if (PACKET_STARTS_WITH("QSetSTDERR:")) 124 return eServerPacketType_QSetSTDERR; 125 if (PACKET_STARTS_WITH("QSetWorkingDir:")) 126 return eServerPacketType_QSetWorkingDir; 127 if (PACKET_STARTS_WITH("QSetLogging:")) 128 return eServerPacketType_QSetLogging; 129 if (PACKET_STARTS_WITH("QSetMaxPacketSize:")) 130 return eServerPacketType_QSetMaxPacketSize; 131 if (PACKET_STARTS_WITH("QSetMaxPayloadSize:")) 132 return eServerPacketType_QSetMaxPayloadSize; 133 if (PACKET_STARTS_WITH("QSetEnableAsyncProfiling;")) 134 return eServerPacketType_QSetEnableAsyncProfiling; 135 if (PACKET_STARTS_WITH("QSyncThreadState:")) 136 return eServerPacketType_QSyncThreadState; 137 break; 138 139 case 'L': 140 if (PACKET_STARTS_WITH("QLaunchArch:")) 141 return eServerPacketType_QLaunchArch; 142 if (PACKET_MATCHES("QListThreadsInStopReply")) 143 return eServerPacketType_QListThreadsInStopReply; 144 break; 145 146 case 'R': 147 if (PACKET_STARTS_WITH("QRestoreRegisterState:")) 148 return eServerPacketType_QRestoreRegisterState; 149 break; 150 151 case 'T': 152 if (PACKET_MATCHES("QThreadSuffixSupported")) 153 return eServerPacketType_QThreadSuffixSupported; 154 break; 155 } 156 break; 157 158 case 'q': 159 switch (packet_cstr[1]) { 160 case 's': 161 if (PACKET_MATCHES("qsProcessInfo")) 162 return eServerPacketType_qsProcessInfo; 163 if (PACKET_MATCHES("qsThreadInfo")) 164 return eServerPacketType_qsThreadInfo; 165 break; 166 167 case 'f': 168 if (PACKET_STARTS_WITH("qfProcessInfo")) 169 return eServerPacketType_qfProcessInfo; 170 if (PACKET_STARTS_WITH("qfThreadInfo")) 171 return eServerPacketType_qfThreadInfo; 172 break; 173 174 case 'C': 175 if (packet_size == 2) 176 return eServerPacketType_qC; 177 break; 178 179 case 'E': 180 if (PACKET_STARTS_WITH("qEcho:")) 181 return eServerPacketType_qEcho; 182 break; 183 184 case 'F': 185 if (PACKET_STARTS_WITH("qFileLoadAddress:")) 186 return eServerPacketType_qFileLoadAddress; 187 break; 188 189 case 'G': 190 if (PACKET_STARTS_WITH("qGroupName:")) 191 return eServerPacketType_qGroupName; 192 if (PACKET_MATCHES("qGetWorkingDir")) 193 return eServerPacketType_qGetWorkingDir; 194 if (PACKET_MATCHES("qGetPid")) 195 return eServerPacketType_qGetPid; 196 if (PACKET_STARTS_WITH("qGetProfileData;")) 197 return eServerPacketType_qGetProfileData; 198 if (PACKET_MATCHES("qGDBServerVersion")) 199 return eServerPacketType_qGDBServerVersion; 200 break; 201 202 case 'H': 203 if (PACKET_MATCHES("qHostInfo")) 204 return eServerPacketType_qHostInfo; 205 break; 206 207 case 'K': 208 if (PACKET_STARTS_WITH("qKillSpawnedProcess")) 209 return eServerPacketType_qKillSpawnedProcess; 210 break; 211 212 case 'L': 213 if (PACKET_STARTS_WITH("qLaunchGDBServer")) 214 return eServerPacketType_qLaunchGDBServer; 215 if (PACKET_MATCHES("qLaunchSuccess")) 216 return eServerPacketType_qLaunchSuccess; 217 break; 218 219 case 'M': 220 if (PACKET_STARTS_WITH("qMemoryRegionInfo:")) 221 return eServerPacketType_qMemoryRegionInfo; 222 if (PACKET_MATCHES("qMemoryRegionInfo")) 223 return eServerPacketType_qMemoryRegionInfoSupported; 224 if (PACKET_STARTS_WITH("qModuleInfo:")) 225 return eServerPacketType_qModuleInfo; 226 break; 227 228 case 'P': 229 if (PACKET_STARTS_WITH("qProcessInfoPID:")) 230 return eServerPacketType_qProcessInfoPID; 231 if (PACKET_STARTS_WITH("qPlatform_shell:")) 232 return eServerPacketType_qPlatform_shell; 233 if (PACKET_STARTS_WITH("qPlatform_mkdir:")) 234 return eServerPacketType_qPlatform_mkdir; 235 if (PACKET_STARTS_WITH("qPlatform_chmod:")) 236 return eServerPacketType_qPlatform_chmod; 237 if (PACKET_MATCHES("qProcessInfo")) 238 return eServerPacketType_qProcessInfo; 239 if (PACKET_STARTS_WITH("qPathComplete:")) 240 return eServerPacketType_qPathComplete; 241 break; 242 243 case 'Q': 244 if (PACKET_MATCHES("qQueryGDBServer")) 245 return eServerPacketType_qQueryGDBServer; 246 break; 247 248 case 'R': 249 if (PACKET_STARTS_WITH("qRcmd,")) 250 return eServerPacketType_qRcmd; 251 if (PACKET_STARTS_WITH("qRegisterInfo")) 252 return eServerPacketType_qRegisterInfo; 253 break; 254 255 case 'S': 256 if (PACKET_STARTS_WITH("qSpeedTest:")) 257 return eServerPacketType_qSpeedTest; 258 if (PACKET_MATCHES("qShlibInfoAddr")) 259 return eServerPacketType_qShlibInfoAddr; 260 if (PACKET_MATCHES("qStepPacketSupported")) 261 return eServerPacketType_qStepPacketSupported; 262 if (PACKET_STARTS_WITH("qSupported")) 263 return eServerPacketType_qSupported; 264 if (PACKET_MATCHES("qSyncThreadStateSupported")) 265 return eServerPacketType_qSyncThreadStateSupported; 266 break; 267 268 case 'T': 269 if (PACKET_STARTS_WITH("qThreadExtraInfo,")) 270 return eServerPacketType_qThreadExtraInfo; 271 if (PACKET_STARTS_WITH("qThreadStopInfo")) 272 return eServerPacketType_qThreadStopInfo; 273 break; 274 275 case 'U': 276 if (PACKET_STARTS_WITH("qUserName:")) 277 return eServerPacketType_qUserName; 278 break; 279 280 case 'V': 281 if (PACKET_MATCHES("qVAttachOrWaitSupported")) 282 return eServerPacketType_qVAttachOrWaitSupported; 283 break; 284 285 case 'W': 286 if (PACKET_STARTS_WITH("qWatchpointSupportInfo:")) 287 return eServerPacketType_qWatchpointSupportInfo; 288 if (PACKET_MATCHES("qWatchpointSupportInfo")) 289 return eServerPacketType_qWatchpointSupportInfoSupported; 290 break; 291 292 case 'X': 293 if (PACKET_STARTS_WITH("qXfer:")) 294 return eServerPacketType_qXfer; 295 break; 296 } 297 break; 298 299 case 'j': 300 if (PACKET_STARTS_WITH("jModulesInfo:")) 301 return eServerPacketType_jModulesInfo; 302 if (PACKET_MATCHES("jSignalsInfo")) 303 return eServerPacketType_jSignalsInfo; 304 if (PACKET_MATCHES("jThreadsInfo")) 305 return eServerPacketType_jThreadsInfo; 306 307 if (PACKET_MATCHES("jLLDBTraceSupported")) 308 return eServerPacketType_jLLDBTraceSupported; 309 if (PACKET_STARTS_WITH("jLLDBTraceStop:")) 310 return eServerPacketType_jLLDBTraceStop; 311 if (PACKET_STARTS_WITH("jLLDBTraceStart:")) 312 return eServerPacketType_jLLDBTraceStart; 313 if (PACKET_STARTS_WITH("jLLDBTraceGetState:")) 314 return eServerPacketType_jLLDBTraceGetState; 315 if (PACKET_STARTS_WITH("jLLDBTraceGetBinaryData:")) 316 return eServerPacketType_jLLDBTraceGetBinaryData; 317 break; 318 319 case 'v': 320 if (PACKET_STARTS_WITH("vFile:")) { 321 if (PACKET_STARTS_WITH("vFile:open:")) 322 return eServerPacketType_vFile_open; 323 else if (PACKET_STARTS_WITH("vFile:close:")) 324 return eServerPacketType_vFile_close; 325 else if (PACKET_STARTS_WITH("vFile:pread")) 326 return eServerPacketType_vFile_pread; 327 else if (PACKET_STARTS_WITH("vFile:pwrite")) 328 return eServerPacketType_vFile_pwrite; 329 else if (PACKET_STARTS_WITH("vFile:size")) 330 return eServerPacketType_vFile_size; 331 else if (PACKET_STARTS_WITH("vFile:exists")) 332 return eServerPacketType_vFile_exists; 333 else if (PACKET_STARTS_WITH("vFile:stat")) 334 return eServerPacketType_vFile_stat; 335 else if (PACKET_STARTS_WITH("vFile:mode")) 336 return eServerPacketType_vFile_mode; 337 else if (PACKET_STARTS_WITH("vFile:MD5")) 338 return eServerPacketType_vFile_md5; 339 else if (PACKET_STARTS_WITH("vFile:symlink")) 340 return eServerPacketType_vFile_symlink; 341 else if (PACKET_STARTS_WITH("vFile:unlink")) 342 return eServerPacketType_vFile_unlink; 343 344 } else { 345 if (PACKET_STARTS_WITH("vAttach;")) 346 return eServerPacketType_vAttach; 347 if (PACKET_STARTS_WITH("vAttachWait;")) 348 return eServerPacketType_vAttachWait; 349 if (PACKET_STARTS_WITH("vAttachOrWait;")) 350 return eServerPacketType_vAttachOrWait; 351 if (PACKET_STARTS_WITH("vAttachName;")) 352 return eServerPacketType_vAttachName; 353 if (PACKET_STARTS_WITH("vCont;")) 354 return eServerPacketType_vCont; 355 if (PACKET_MATCHES("vCont?")) 356 return eServerPacketType_vCont_actions; 357 } 358 break; 359 case '_': 360 switch (packet_cstr[1]) { 361 case 'M': 362 return eServerPacketType__M; 363 364 case 'm': 365 return eServerPacketType__m; 366 } 367 break; 368 369 case '?': 370 if (packet_size == 1) 371 return eServerPacketType_stop_reason; 372 break; 373 374 case 'c': 375 return eServerPacketType_c; 376 377 case 'C': 378 return eServerPacketType_C; 379 380 case 'D': 381 if (packet_size == 1) 382 return eServerPacketType_D; 383 break; 384 385 case 'g': 386 return eServerPacketType_g; 387 388 case 'G': 389 return eServerPacketType_G; 390 391 case 'H': 392 return eServerPacketType_H; 393 394 case 'I': 395 return eServerPacketType_I; 396 397 case 'k': 398 if (packet_size == 1) 399 return eServerPacketType_k; 400 break; 401 402 case 'm': 403 return eServerPacketType_m; 404 405 case 'M': 406 return eServerPacketType_M; 407 408 case 'p': 409 return eServerPacketType_p; 410 411 case 'P': 412 return eServerPacketType_P; 413 414 case 's': 415 if (packet_size == 1) 416 return eServerPacketType_s; 417 break; 418 419 case 'S': 420 return eServerPacketType_S; 421 422 case 'x': 423 return eServerPacketType_x; 424 425 case 'X': 426 return eServerPacketType_X; 427 428 case 'T': 429 return eServerPacketType_T; 430 431 case 'z': 432 if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4') 433 return eServerPacketType_z; 434 break; 435 436 case 'Z': 437 if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4') 438 return eServerPacketType_Z; 439 break; 440 } 441 return eServerPacketType_unimplemented; 442 } 443 444 bool StringExtractorGDBRemote::IsOKResponse() const { 445 return GetResponseType() == eOK; 446 } 447 448 bool StringExtractorGDBRemote::IsUnsupportedResponse() const { 449 return GetResponseType() == eUnsupported; 450 } 451 452 bool StringExtractorGDBRemote::IsNormalResponse() const { 453 return GetResponseType() == eResponse; 454 } 455 456 bool StringExtractorGDBRemote::IsErrorResponse() const { 457 return GetResponseType() == eError && isxdigit(m_packet[1]) && 458 isxdigit(m_packet[2]); 459 } 460 461 uint8_t StringExtractorGDBRemote::GetError() { 462 if (GetResponseType() == eError) { 463 SetFilePos(1); 464 return GetHexU8(255); 465 } 466 return 0; 467 } 468 469 lldb_private::Status StringExtractorGDBRemote::GetStatus() { 470 lldb_private::Status error; 471 if (GetResponseType() == eError) { 472 SetFilePos(1); 473 uint8_t errc = GetHexU8(255); 474 error.SetError(errc, lldb::eErrorTypeGeneric); 475 476 error.SetErrorStringWithFormat("Error %u", errc); 477 std::string error_messg; 478 if (GetChar() == ';') { 479 GetHexByteString(error_messg); 480 error.SetErrorString(error_messg); 481 } 482 } 483 return error; 484 } 485 486 size_t StringExtractorGDBRemote::GetEscapedBinaryData(std::string &str) { 487 // Just get the data bytes in the string as 488 // GDBRemoteCommunication::CheckForPacket() already removes any 0x7d escaped 489 // characters. If any 0x7d characters are left in the packet, then they are 490 // supposed to be there... 491 str.clear(); 492 const size_t bytes_left = GetBytesLeft(); 493 if (bytes_left > 0) { 494 str.assign(m_packet, m_index, bytes_left); 495 m_index += bytes_left; 496 } 497 return str.size(); 498 } 499 500 static bool 501 OKErrorNotSupportedResponseValidator(void *, 502 const StringExtractorGDBRemote &response) { 503 switch (response.GetResponseType()) { 504 case StringExtractorGDBRemote::eOK: 505 case StringExtractorGDBRemote::eError: 506 case StringExtractorGDBRemote::eUnsupported: 507 return true; 508 509 case StringExtractorGDBRemote::eAck: 510 case StringExtractorGDBRemote::eNack: 511 case StringExtractorGDBRemote::eResponse: 512 break; 513 } 514 return false; 515 } 516 517 static bool JSONResponseValidator(void *, 518 const StringExtractorGDBRemote &response) { 519 switch (response.GetResponseType()) { 520 case StringExtractorGDBRemote::eUnsupported: 521 case StringExtractorGDBRemote::eError: 522 return true; // Accept unsupported or EXX as valid responses 523 524 case StringExtractorGDBRemote::eOK: 525 case StringExtractorGDBRemote::eAck: 526 case StringExtractorGDBRemote::eNack: 527 break; 528 529 case StringExtractorGDBRemote::eResponse: 530 // JSON that is returned in from JSON query packets is currently always 531 // either a dictionary which starts with a '{', or an array which starts 532 // with a '['. This is a quick validator to just make sure the response 533 // could be valid JSON without having to validate all of the 534 // JSON content. 535 switch (response.GetStringRef()[0]) { 536 case '{': 537 return true; 538 case '[': 539 return true; 540 default: 541 break; 542 } 543 break; 544 } 545 return false; 546 } 547 548 static bool 549 ASCIIHexBytesResponseValidator(void *, 550 const StringExtractorGDBRemote &response) { 551 switch (response.GetResponseType()) { 552 case StringExtractorGDBRemote::eUnsupported: 553 case StringExtractorGDBRemote::eError: 554 return true; // Accept unsupported or EXX as valid responses 555 556 case StringExtractorGDBRemote::eOK: 557 case StringExtractorGDBRemote::eAck: 558 case StringExtractorGDBRemote::eNack: 559 break; 560 561 case StringExtractorGDBRemote::eResponse: { 562 uint32_t valid_count = 0; 563 for (const char ch : response.GetStringRef()) { 564 if (!isxdigit(ch)) { 565 return false; 566 } 567 if (++valid_count >= 16) 568 break; // Don't validate all the characters in case the packet is very 569 // large 570 } 571 return true; 572 } break; 573 } 574 return false; 575 } 576 577 void StringExtractorGDBRemote::CopyResponseValidator( 578 const StringExtractorGDBRemote &rhs) { 579 m_validator = rhs.m_validator; 580 m_validator_baton = rhs.m_validator_baton; 581 } 582 583 void StringExtractorGDBRemote::SetResponseValidator( 584 ResponseValidatorCallback callback, void *baton) { 585 m_validator = callback; 586 m_validator_baton = baton; 587 } 588 589 void StringExtractorGDBRemote::SetResponseValidatorToOKErrorNotSupported() { 590 m_validator = OKErrorNotSupportedResponseValidator; 591 m_validator_baton = nullptr; 592 } 593 594 void StringExtractorGDBRemote::SetResponseValidatorToASCIIHexBytes() { 595 m_validator = ASCIIHexBytesResponseValidator; 596 m_validator_baton = nullptr; 597 } 598 599 void StringExtractorGDBRemote::SetResponseValidatorToJSON() { 600 m_validator = JSONResponseValidator; 601 m_validator_baton = nullptr; 602 } 603 604 bool StringExtractorGDBRemote::ValidateResponse() const { 605 // If we have a validator callback, try to validate the callback 606 if (m_validator) 607 return m_validator(m_validator_baton, *this); 608 else 609 return true; // No validator, so response is valid 610 } 611 612 llvm::Optional<std::pair<lldb::pid_t, lldb::tid_t>> 613 StringExtractorGDBRemote::GetPidTid(lldb::pid_t default_pid) { 614 llvm::StringRef view = llvm::StringRef(m_packet).substr(m_index); 615 size_t initial_length = view.size(); 616 lldb::pid_t pid = default_pid; 617 lldb::tid_t tid; 618 619 if (view.consume_front("p")) { 620 // process identifier 621 if (view.consume_front("-1")) { 622 // -1 is a special case 623 pid = AllProcesses; 624 } else if (view.consumeInteger(16, pid) || pid == 0) { 625 // not a valid hex integer OR unsupported pid 0 626 m_index = UINT64_MAX; 627 return llvm::None; 628 } 629 630 // "." must follow if we expect TID too; otherwise, we assume -1 631 if (!view.consume_front(".")) { 632 // update m_index 633 m_index += initial_length - view.size(); 634 635 return {{pid, AllThreads}}; 636 } 637 } 638 639 // thread identifier 640 if (view.consume_front("-1")) { 641 // -1 is a special case 642 tid = AllThreads; 643 } else if (view.consumeInteger(16, tid) || tid == 0 || pid == AllProcesses) { 644 // not a valid hex integer OR tid 0 OR pid -1 + a specific tid 645 m_index = UINT64_MAX; 646 return llvm::None; 647 } 648 649 // update m_index 650 m_index += initial_length - view.size(); 651 652 return {{pid, tid}}; 653 } 654