contrib/llvm/tools/lldb/source/Utility/StringExtractorGDBRemote.cpp

   1 //===-- StringExtractorGDBRemote.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 #include "Utility/StringExtractorGDBRemote.h"
  11
  12 #include <ctype.h> // for isxdigit
  13 #include <string.h>
  14
  15 StringExtractorGDBRemote::ResponseType
  16 StringExtractorGDBRemote::GetResponseType() const {
  17   if (m_packet.empty())
  18     return eUnsupported;
  19
  20   switch (m_packet[0]) {
  21   case 'E':
  22     if (isxdigit(m_packet[1]) && isxdigit(m_packet[2])) {
  23       if (m_packet.size() == 3)
  24         return eError;
  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)
  29           if (!isxdigit(e))
  30             return eResponse;
  31         return eError;
  32       }
  33     }
  34     break;
  35
  36   case 'O':
  37     if (m_packet.size() == 2 && m_packet[1] == 'K')
  38       return eOK;
  39     break;
  40
  41   case '+':
  42     if (m_packet.size() == 1)
  43       return eAck;
  44     break;
  45
  46   case '-':
  47     if (m_packet.size() == 1)
  48       return eNack;
  49     break;
  50   }
  51   return eResponse;
  52 }
  53
  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)
  61
  62   // Empty is not a supported packet...
  63   if (m_packet.empty())
  64     return eServerPacketType_invalid;
  65
  66   const size_t packet_size = m_packet.size();
  67   const char *packet_cstr = m_packet.c_str();
  68   switch (m_packet[0]) {
  69
  70   case '%':
  71     return eServerPacketType_notify;
  72
  73   case '\x03':
  74     if (packet_size == 1)
  75       return eServerPacketType_interrupt;
  76     break;
  77
  78   case '-':
  79     if (packet_size == 1)
  80       return eServerPacketType_nack;
  81     break;
  82
  83   case '+':
  84     if (packet_size == 1)
  85       return eServerPacketType_ack;
  86     break;
  87
  88   case 'A':
  89     return eServerPacketType_A;
  90
  91   case 'Q':
  92
  93     switch (packet_cstr[1]) {
  94     case 'E':
  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;
 101       break;
 102
 103     case 'P':
 104       if (PACKET_STARTS_WITH("QPassSignals:"))
 105         return eServerPacketType_QPassSignals;
 106
 107     case 'S':
 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;
 134       break;
 135
 136     case 'L':
 137       if (PACKET_STARTS_WITH("QLaunchArch:"))
 138         return eServerPacketType_QLaunchArch;
 139       if (PACKET_MATCHES("QListThreadsInStopReply"))
 140         return eServerPacketType_QListThreadsInStopReply;
 141       break;
 142
 143     case 'R':
 144       if (PACKET_STARTS_WITH("QRestoreRegisterState:"))
 145         return eServerPacketType_QRestoreRegisterState;
 146       break;
 147
 148     case 'T':
 149       if (PACKET_MATCHES("QThreadSuffixSupported"))
 150         return eServerPacketType_QThreadSuffixSupported;
 151       break;
 152     }
 153     break;
 154
 155   case 'q':
 156     switch (packet_cstr[1]) {
 157     case 's':
 158       if (PACKET_MATCHES("qsProcessInfo"))
 159         return eServerPacketType_qsProcessInfo;
 160       if (PACKET_MATCHES("qsThreadInfo"))
 161         return eServerPacketType_qsThreadInfo;
 162       break;
 163
 164     case 'f':
 165       if (PACKET_STARTS_WITH("qfProcessInfo"))
 166         return eServerPacketType_qfProcessInfo;
 167       if (PACKET_STARTS_WITH("qfThreadInfo"))
 168         return eServerPacketType_qfThreadInfo;
 169       break;
 170
 171     case 'C':
 172       if (packet_size == 2)
 173         return eServerPacketType_qC;
 174       break;
 175
 176     case 'E':
 177       if (PACKET_STARTS_WITH("qEcho:"))
 178         return eServerPacketType_qEcho;
 179       break;
 180
 181     case 'F':
 182       if (PACKET_STARTS_WITH("qFileLoadAddress:"))
 183         return eServerPacketType_qFileLoadAddress;
 184       break;
 185
 186     case 'G':
 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;
 197       break;
 198
 199     case 'H':
 200       if (PACKET_MATCHES("qHostInfo"))
 201         return eServerPacketType_qHostInfo;
 202       break;
 203
 204     case 'K':
 205       if (PACKET_STARTS_WITH("qKillSpawnedProcess"))
 206         return eServerPacketType_qKillSpawnedProcess;
 207       break;
 208
 209     case 'L':
 210       if (PACKET_STARTS_WITH("qLaunchGDBServer"))
 211         return eServerPacketType_qLaunchGDBServer;
 212       if (PACKET_MATCHES("qLaunchSuccess"))
 213         return eServerPacketType_qLaunchSuccess;
 214       break;
 215
 216     case 'M':
 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;
 223       break;
 224
 225     case 'P':
 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;
 236       break;
 237
 238     case 'Q':
 239       if (PACKET_MATCHES("qQueryGDBServer"))
 240         return eServerPacketType_qQueryGDBServer;
 241       break;
 242
 243     case 'R':
 244       if (PACKET_STARTS_WITH("qRcmd,"))
 245         return eServerPacketType_qRcmd;
 246       if (PACKET_STARTS_WITH("qRegisterInfo"))
 247         return eServerPacketType_qRegisterInfo;
 248       break;
 249
 250     case 'S':
 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;
 261       break;
 262
 263     case 'T':
 264       if (PACKET_STARTS_WITH("qThreadExtraInfo,"))
 265         return eServerPacketType_qThreadExtraInfo;
 266       if (PACKET_STARTS_WITH("qThreadStopInfo"))
 267         return eServerPacketType_qThreadStopInfo;
 268       break;
 269
 270     case 'U':
 271       if (PACKET_STARTS_WITH("qUserName:"))
 272         return eServerPacketType_qUserName;
 273       break;
 274
 275     case 'V':
 276       if (PACKET_MATCHES("qVAttachOrWaitSupported"))
 277         return eServerPacketType_qVAttachOrWaitSupported;
 278       break;
 279
 280     case 'W':
 281       if (PACKET_STARTS_WITH("qWatchpointSupportInfo:"))
 282         return eServerPacketType_qWatchpointSupportInfo;
 283       if (PACKET_MATCHES("qWatchpointSupportInfo"))
 284         return eServerPacketType_qWatchpointSupportInfoSupported;
 285       break;
 286
 287     case 'X':
 288       if (PACKET_STARTS_WITH("qXfer:auxv:read::"))
 289         return eServerPacketType_qXfer_auxv_read;
 290       break;
 291     }
 292     break;
 293
 294   case 'j':
 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;
 311     break;
 312
 313   case 'v':
 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;
 337
 338     } else {
 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;
 351     }
 352     break;
 353   case '_':
 354     switch (packet_cstr[1]) {
 355     case 'M':
 356       return eServerPacketType__M;
 357
 358     case 'm':
 359       return eServerPacketType__m;
 360     }
 361     break;
 362
 363   case '?':
 364     if (packet_size == 1)
 365       return eServerPacketType_stop_reason;
 366     break;
 367
 368   case 'c':
 369     return eServerPacketType_c;
 370
 371   case 'C':
 372     return eServerPacketType_C;
 373
 374   case 'D':
 375     if (packet_size == 1)
 376       return eServerPacketType_D;
 377     break;
 378
 379   case 'g':
 380     if (packet_size == 1)
 381       return eServerPacketType_g;
 382     break;
 383
 384   case 'G':
 385     return eServerPacketType_G;
 386
 387   case 'H':
 388     return eServerPacketType_H;
 389
 390   case 'I':
 391     return eServerPacketType_I;
 392
 393   case 'k':
 394     if (packet_size == 1)
 395       return eServerPacketType_k;
 396     break;
 397
 398   case 'm':
 399     return eServerPacketType_m;
 400
 401   case 'M':
 402     return eServerPacketType_M;
 403
 404   case 'p':
 405     return eServerPacketType_p;
 406
 407   case 'P':
 408     return eServerPacketType_P;
 409
 410   case 's':
 411     if (packet_size == 1)
 412       return eServerPacketType_s;
 413     break;
 414
 415   case 'S':
 416     return eServerPacketType_S;
 417
 418   case 'x':
 419     return eServerPacketType_x;
 420
 421   case 'X':
 422     return eServerPacketType_X;
 423
 424   case 'T':
 425     return eServerPacketType_T;
 426
 427   case 'z':
 428     if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4')
 429       return eServerPacketType_z;
 430     break;
 431
 432   case 'Z':
 433     if (packet_cstr[1] >= '0' && packet_cstr[1] <= '4')
 434       return eServerPacketType_Z;
 435     break;
 436   }
 437   return eServerPacketType_unimplemented;
 438 }
 439
 440 bool StringExtractorGDBRemote::IsOKResponse() const {
 441   return GetResponseType() == eOK;
 442 }
 443
 444 bool StringExtractorGDBRemote::IsUnsupportedResponse() const {
 445   return GetResponseType() == eUnsupported;
 446 }
 447
 448 bool StringExtractorGDBRemote::IsNormalResponse() const {
 449   return GetResponseType() == eResponse;
 450 }
 451
 452 bool StringExtractorGDBRemote::IsErrorResponse() const {
 453   return GetResponseType() == eError && isxdigit(m_packet[1]) &&
 454          isxdigit(m_packet[2]);
 455 }
 456
 457 uint8_t StringExtractorGDBRemote::GetError() {
 458   if (GetResponseType() == eError) {
 459     SetFilePos(1);
 460     return GetHexU8(255);
 461   }
 462   return 0;
 463 }
 464
 465 lldb_private::Status StringExtractorGDBRemote::GetStatus() {
 466   lldb_private::Status error;
 467   if (GetResponseType() == eError) {
 468     SetFilePos(1);
 469     uint8_t errc = GetHexU8(255);
 470     error.SetError(errc, lldb::eErrorTypeGeneric);
 471
 472     error.SetErrorStringWithFormat("Error %u", errc);
 473     std::string error_messg;
 474     if (GetChar() == ';') {
 475       GetHexByteString(error_messg);
 476       error.SetErrorString(error_messg);
 477     }
 478   }
 479   return error;
 480 }
 481
 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
 486   // left in
 487   // the packet, then they are supposed to be there...
 488   str.clear();
 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;
 493   }
 494   return str.size();
 495 }
 496
 497 static bool
 498 OKErrorNotSupportedResponseValidator(void *,
 499                                      const StringExtractorGDBRemote &response) {
 500   switch (response.GetResponseType()) {
 501   case StringExtractorGDBRemote::eOK:
 502   case StringExtractorGDBRemote::eError:
 503   case StringExtractorGDBRemote::eUnsupported:
 504     return true;
 505
 506   case StringExtractorGDBRemote::eAck:
 507   case StringExtractorGDBRemote::eNack:
 508   case StringExtractorGDBRemote::eResponse:
 509     break;
 510   }
 511   return false;
 512 }
 513
 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
 520
 521   case StringExtractorGDBRemote::eOK:
 522   case StringExtractorGDBRemote::eAck:
 523   case StringExtractorGDBRemote::eNack:
 524     break;
 525
 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
 531     // JSON content.
 532     switch (response.GetStringRef()[0]) {
 533     case '{':
 534       return true;
 535     case '[':
 536       return true;
 537     default:
 538       break;
 539     }
 540     break;
 541   }
 542   return false;
 543 }
 544
 545 static bool
 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
 552
 553   case StringExtractorGDBRemote::eOK:
 554   case StringExtractorGDBRemote::eAck:
 555   case StringExtractorGDBRemote::eNack:
 556     break;
 557
 558   case StringExtractorGDBRemote::eResponse: {
 559     uint32_t valid_count = 0;
 560     for (const char ch : response.GetStringRef()) {
 561       if (!isxdigit(ch)) {
 562         return false;
 563       }
 564       if (++valid_count >= 16)
 565         break; // Don't validate all the characters in case the packet is very
 566                // large
 567     }
 568     return true;
 569   } break;
 570   }
 571   return false;
 572 }
 573
 574 void StringExtractorGDBRemote::CopyResponseValidator(
 575     const StringExtractorGDBRemote &rhs) {
 576   m_validator = rhs.m_validator;
 577   m_validator_baton = rhs.m_validator_baton;
 578 }
 579
 580 void StringExtractorGDBRemote::SetResponseValidator(
 581     ResponseValidatorCallback callback, void *baton) {
 582   m_validator = callback;
 583   m_validator_baton = baton;
 584 }
 585
 586 void StringExtractorGDBRemote::SetResponseValidatorToOKErrorNotSupported() {
 587   m_validator = OKErrorNotSupportedResponseValidator;
 588   m_validator_baton = nullptr;
 589 }
 590
 591 void StringExtractorGDBRemote::SetResponseValidatorToASCIIHexBytes() {
 592   m_validator = ASCIIHexBytesResponseValidator;
 593   m_validator_baton = nullptr;
 594 }
 595
 596 void StringExtractorGDBRemote::SetResponseValidatorToJSON() {
 597   m_validator = JSONResponseValidator;
 598   m_validator_baton = nullptr;
 599 }
 600
 601 bool StringExtractorGDBRemote::ValidateResponse() const {
 602   // If we have a validator callback, try to validate the callback
 603   if (m_validator)
 604     return m_validator(m_validator_baton, *this);
 605   else
 606     return true; // No validator, so response is valid
 607 }