Lines Matching +defs:file +defs:remote +defs:p
93 // Class to handle communications via gdb remote protocol.
113 static inline int decoded_hex_ascii_char(const char *p) {
114 const int hi_nibble = xdigit_to_sint(p[0]);
117 const int lo_nibble = xdigit_to_sint(p[1]);
124 static std::string decode_hex_ascii_string(const char *p,
127 if (p) {
128 for (const char *c = p; ((c - p) / 2) < max_length; c += 2) {
139 uint64_t decode_uint64(const char *p, int base, char **end = nullptr,
141 nub_addr_t addr = strtoull(p, end, 16);
150 const uint8_t *p = (const uint8_t *)buf;
153 ostrm << RAWHEX8(p[i]);
156 ostrm << RAWHEX8(p[i]);
244 t.push_back(Packet(read_register, &RNBRemote::HandlePacket_p, NULL, "p",
279 "Detach gdb from remote system"));
367 "Dynamically discover remote register context information."));
426 " stop acking remote protocol packets"));
431 "'G', 'p', and 'P') support having the thread ID appended "
611 // This makes use of asynchronous bit 'A' in the gdb remote protocol.
626 // of these coming out at the wrong time (i.e. when the remote side
818 /* Get a packet via gdb remote protocol.
829 // Only reset the remote command available event if we have no more
845 // Reset the remote command available event if we have no more packets
920 rnb_err_t RNBRemote::HandlePacket_UNIMPLEMENTED(const char *p) {
923 __FUNCTION__, p ? p : "NULL");
927 rnb_err_t RNBRemote::HandlePacket_ILLFORMED(const char *file, int line,
928 const char *p,
931 (uint32_t)m_comm.Timer().ElapsedMicroSeconds(true), file,
932 line, __FUNCTION__, p);
1071 // Parse up the packets into gdb remote packets
1193 // Wait for 2 seconds for the remote data thread to exit
1196 // Kill the remote data thread???
1204 DNBLogThreadedIf(LOG_RNB_REMOTE, "RNBRemote::%s (%p): thread starting...",
1210 pthread_setname_np("read gdb-remote packets thread");
1222 RNBRemote *remote = remoteSP.get();
1223 PThreadEvent &events = remote->Context().Events();
1225 // START: main receive remote command thread loop
1228 rnb_err_t err = remote->GetCommData();
1247 // START: main receive remote command thread loop
1251 DNBLogThreadedIf(LOG_RNB_REMOTE, "RNBRemote::%s (%p): thread exiting...",
1256 // If we fail to get back a valid CPU type for the remote process,
1309 // packet convention in the gdb-remote protocol.
1505 rnb_err_t RNBRemote::HandlePacket_A(const char *p) {
1506 if (p == NULL || *p == '\0') {
1507 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1510 p++;
1511 if (*p == '\0' || !isdigit(*p)) {
1512 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1519 char *buf = const_cast<char *>(p);
1531 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1535 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1543 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1547 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1563 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1584 rnb_err_t RNBRemote::HandlePacket_H(const char *p) {
1585 p++; // skip 'H'
1586 if (*p != 'c' && *p != 'g') {
1587 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1598 nub_thread_t tid = strtoul(p + 1, NULL, 16);
1600 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1603 if (*p == 'c')
1605 if (*p == 'g')
1611 rnb_err_t RNBRemote::HandlePacket_qLaunchSuccess(const char *p) {
1618 rnb_err_t RNBRemote::HandlePacket_qShlibInfoAddr(const char *p) {
1631 rnb_err_t RNBRemote::HandlePacket_qStepPacketSupported(const char *p) {
1637 // for remote targets (so the "s" packet will get used).
1641 rnb_err_t RNBRemote::HandlePacket_qSyncThreadStateSupported(const char *p) {
1647 rnb_err_t RNBRemote::HandlePacket_qVAttachOrWaitSupported(const char *p) {
1653 rnb_err_t RNBRemote::HandlePacket_qThreadStopInfo(const char *p) {
1654 p += strlen("qThreadStopInfo");
1655 nub_thread_t tid = strtoul(p, 0, 16);
1659 rnb_err_t RNBRemote::HandlePacket_qThreadInfo(const char *p) {
1669 if (p[1] == 'f') {
1688 rnb_err_t RNBRemote::HandlePacket_qThreadExtraInfo(const char *p) {
1700 p += strlen("qThreadExtraInfo");
1701 if (*p++ != ',')
1702 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1705 nub_thread_t tid = strtoul(p, NULL, 16);
1708 __FILE__, __LINE__, p,
1775 rnb_err_t RNBRemote::HandlePacket_qRcmd(const char *p) {
1776 const char *c = p + strlen("qRcmd,");
1783 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
1827 rnb_err_t RNBRemote::HandlePacket_qC(const char *p) {
1837 // Make sure we set the current thread so g and p packets return
1845 rnb_err_t RNBRemote::HandlePacket_qEcho(const char *p) {
1850 return SendPacket(p);
1853 rnb_err_t RNBRemote::HandlePacket_qGetPid(const char *p) {
1866 rnb_err_t RNBRemote::HandlePacket_qRegisterInfo(const char *p) {
1870 p += strlen("qRegisterInfo");
1874 uint32_t reg_num = static_cast<uint32_t>(strtoul(p, 0, 16));
2029 rnb_err_t set_logging(const char *p) {
2031 while (p && *p != '\0') {
2032 if (strncmp(p, "bitmask=", sizeof("bitmask=") - 1) == 0) {
2033 p += sizeof("bitmask=") - 1;
2034 while (p && *p != '\0' && *p != ';') {
2035 if (*p == '|')
2036 p++;
2042 // echo " else if (strncmp (p, \"$logname\", sizeof
2045 // echo " p += sizeof (\"$logname\") - 1;"
2049 if (strncmp(p, "LOG_VERBOSE", sizeof("LOG_VERBOSE") - 1) == 0) {
2050 p += sizeof("LOG_VERBOSE") - 1;
2052 } else if (strncmp(p, "LOG_PROCESS", sizeof("LOG_PROCESS") - 1) == 0) {
2053 p += sizeof("LOG_PROCESS") - 1;
2055 } else if (strncmp(p, "LOG_THREAD", sizeof("LOG_THREAD") - 1) == 0) {
2056 p += sizeof("LOG_THREAD") - 1;
2058 } else if (strncmp(p, "LOG_EXCEPTIONS", sizeof("LOG_EXCEPTIONS") - 1) ==
2060 p += sizeof("LOG_EXCEPTIONS") - 1;
2062 } else if (strncmp(p, "LOG_SHLIB", sizeof("LOG_SHLIB") - 1) == 0) {
2063 p += sizeof("LOG_SHLIB") - 1;
2065 } else if (strncmp(p, "LOG_MEMORY_DATA_SHORT",
2067 p += sizeof("LOG_MEMORY_DATA_SHORT") - 1;
2069 } else if (strncmp(p, "LOG_MEMORY_DATA_LONG",
2071 p += sizeof("LOG_MEMORY_DATA_LONG") - 1;
2073 } else if (strncmp(p, "LOG_MEMORY_PROTECTIONS",
2075 p += sizeof("LOG_MEMORY_PROTECTIONS") - 1;
2077 } else if (strncmp(p, "LOG_MEMORY", sizeof("LOG_MEMORY") - 1) == 0) {
2078 p += sizeof("LOG_MEMORY") - 1;
2080 } else if (strncmp(p, "LOG_BREAKPOINTS",
2082 p += sizeof("LOG_BREAKPOINTS") - 1;
2084 } else if (strncmp(p, "LOG_EVENTS", sizeof("LOG_EVENTS") - 1) == 0) {
2085 p += sizeof("LOG_EVENTS") - 1;
2087 } else if (strncmp(p, "LOG_WATCHPOINTS",
2089 p += sizeof("LOG_WATCHPOINTS") - 1;
2091 } else if (strncmp(p, "LOG_STEP", sizeof("LOG_STEP") - 1) == 0) {
2092 p += sizeof("LOG_STEP") - 1;
2094 } else if (strncmp(p, "LOG_TASK", sizeof("LOG_TASK") - 1) == 0) {
2095 p += sizeof("LOG_TASK") - 1;
2097 } else if (strncmp(p, "LOG_ALL", sizeof("LOG_ALL") - 1) == 0) {
2098 p += sizeof("LOG_ALL") - 1;
2100 } else if (strncmp(p, "LOG_DEFAULT", sizeof("LOG_DEFAULT") - 1) == 0) {
2101 p += sizeof("LOG_DEFAULT") - 1;
2106 else if (strncmp(p, "LOG_NONE", sizeof("LOG_NONE") - 1) == 0) {
2107 p += sizeof("LOG_NONE") - 1;
2109 } else if (strncmp(p, "LOG_RNB_MINIMAL",
2111 p += sizeof("LOG_RNB_MINIMAL") - 1;
2113 } else if (strncmp(p, "LOG_RNB_MEDIUM", sizeof("LOG_RNB_MEDIUM") - 1) ==
2115 p += sizeof("LOG_RNB_MEDIUM") - 1;
2117 } else if (strncmp(p, "LOG_RNB_MAX", sizeof("LOG_RNB_MAX") - 1) == 0) {
2118 p += sizeof("LOG_RNB_MAX") - 1;
2120 } else if (strncmp(p, "LOG_RNB_COMM", sizeof("LOG_RNB_COMM") - 1) ==
2122 p += sizeof("LOG_RNB_COMM") - 1;
2124 } else if (strncmp(p, "LOG_RNB_REMOTE", sizeof("LOG_RNB_REMOTE") - 1) ==
2126 p += sizeof("LOG_RNB_REMOTE") - 1;
2128 } else if (strncmp(p, "LOG_RNB_EVENTS", sizeof("LOG_RNB_EVENTS") - 1) ==
2130 p += sizeof("LOG_RNB_EVENTS") - 1;
2132 } else if (strncmp(p, "LOG_RNB_PROC", sizeof("LOG_RNB_PROC") - 1) ==
2134 p += sizeof("LOG_RNB_PROC") - 1;
2136 } else if (strncmp(p, "LOG_RNB_PACKETS",
2138 p += sizeof("LOG_RNB_PACKETS") - 1;
2140 } else if (strncmp(p, "LOG_RNB_ALL", sizeof("LOG_RNB_ALL") - 1) == 0) {
2141 p += sizeof("LOG_RNB_ALL") - 1;
2143 } else if (strncmp(p, "LOG_RNB_DEFAULT",
2145 p += sizeof("LOG_RNB_DEFAULT") - 1;
2147 } else if (strncmp(p, "LOG_DARWIN_LOG", sizeof("LOG_DARWIN_LOG") - 1) ==
2149 p += sizeof("LOG_DARWIN_LOG") - 1;
2151 } else if (strncmp(p, "LOG_RNB_NONE", sizeof("LOG_RNB_NONE") - 1) ==
2153 p += sizeof("LOG_RNB_NONE") - 1;
2157 const char *c = strchr(p, '|');
2159 p = c;
2161 c = strchr(p, ';');
2163 p = c;
2166 p = strchr(p, '\0');
2172 if (p && *p == ';') {
2182 p++;
2185 // We're not going to support logging to a file for now. All logging
2188 else if (strncmp (p, "mode=", sizeof ("mode=") - 1) == 0)
2190 p += sizeof ("mode=") - 1;
2191 if (strncmp (p, "asl;", sizeof ("asl;") - 1) == 0)
2194 p += sizeof ("asl;") - 1;
2196 else if (strncmp (p, "file;", sizeof ("file;") - 1) == 0)
2199 p += sizeof ("file;") - 1;
2204 const char *c = strchr (p, ';');
2206 p = c + 1;
2208 p = strchr (p, '\0');
2211 else if (strncmp (p, "filename=", sizeof ("filename=") - 1) == 0)
2213 p += sizeof ("filename=") - 1;
2214 const char *c = strchr (p, ';');
2217 c = strchr (p, '\0');
2220 char *fn = (char *) alloca (c - p + 1);
2221 strlcpy (fn, p, c - p);
2222 fn[c - p] = '\0';
2224 // A file name of "asl" is special and is another way to indicate
2225 // that logging should be done via ASL, not by file.
2240 p = c + 1;
2245 const char *c = strchr(p, ';');
2247 p = c + 1;
2249 p = strchr(p, '\0');
2256 rnb_err_t RNBRemote::HandlePacket_QSetIgnoredExceptions(const char *p) {
2261 p += sizeof("QSetIgnoredExceptions:") - 1;
2264 const char *bar = strchr(p, '|');
2266 success = m_ctx.AddIgnoredException(p);
2269 std::string exc_str(p, bar - p);
2278 p = bar + 1;
2287 rnb_err_t RNBRemote::HandlePacket_QThreadSuffixSupported(const char *p) {
2292 rnb_err_t RNBRemote::HandlePacket_QStartNoAckMode(const char *p) {
2299 rnb_err_t RNBRemote::HandlePacket_QSetLogging(const char *p) {
2300 p += sizeof("QSetLogging:") - 1;
2301 rnb_err_t result = set_logging(p);
2308 rnb_err_t RNBRemote::HandlePacket_QSetDisableASLR(const char *p) {
2310 p += sizeof("QSetDisableASLR:") - 1;
2311 switch (*p) {
2324 rnb_err_t RNBRemote::HandlePacket_QSetSTDIO(const char *p) {
2332 StdStringExtractor packet(p);
2364 rnb_err_t RNBRemote::HandlePacket_QSetWorkingDir(const char *p) {
2367 StdStringExtractor packet(p += sizeof("QSetWorkingDir:") - 1);
2386 rnb_err_t RNBRemote::HandlePacket_QSyncThreadState(const char *p) {
2395 p += strlen("QSyncThreadState:");
2396 nub_thread_t tid = strtoul(p, NULL, 16);
2399 __FILE__, __LINE__, p,
2408 rnb_err_t RNBRemote::HandlePacket_QSetDetachOnError(const char *p) {
2409 p += sizeof("QSetDetachOnError:") - 1;
2411 switch (*p) {
2420 __FILE__, __LINE__, p,
2429 rnb_err_t RNBRemote::HandlePacket_QListThreadsInStopReply(const char *p) {
2450 rnb_err_t RNBRemote::HandlePacket_QSetMaxPayloadSize(const char *p) {
2455 p += sizeof("QSetMaxPayloadSize:") - 1;
2457 uint32_t size = static_cast<uint32_t>(strtoul(p, NULL, 16));
2460 __FILE__, __LINE__, p, "Invalid length in QSetMaxPayloadSize packet");
2466 rnb_err_t RNBRemote::HandlePacket_QSetMaxPacketSize(const char *p) {
2470 p += sizeof("QSetMaxPacketSize:") - 1;
2472 uint32_t size = static_cast<uint32_t>(strtoul(p, NULL, 16));
2474 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
2481 rnb_err_t RNBRemote::HandlePacket_QEnvironment(const char *p) {
2491 (uint32_t)m_comm.Timer().ElapsedMicroSeconds(true), __FUNCTION__, p);
2493 p += sizeof("QEnvironment:") - 1;
2496 ctx.PushEnvironment(p);
2500 rnb_err_t RNBRemote::HandlePacket_QEnvironmentHexEncoded(const char *p) {
2508 meaning in the remote protocol won't break it.
2514 __FUNCTION__, p);
2516 p += sizeof("QEnvironmentHexEncoded:") - 1;
2520 c = p;
2524 __FILE__, __LINE__, p,
2535 __FILE__, __LINE__, p,
2549 rnb_err_t RNBRemote::HandlePacket_QLaunchArch(const char *p) {
2550 p += sizeof("QLaunchArch:") - 1;
2551 if (DNBSetArchitecture(p))
2556 rnb_err_t RNBRemote::HandlePacket_QSetProcessEvent(const char *p) {
2557 p += sizeof("QSetProcessEvent:") - 1;
2561 if (DNBProcessSendEvent(Context().ProcessID(), p))
2566 Context().PushProcessEvent(p);
2989 // Make sure we set the current thread so g and p packets return
3041 rnb_err_t RNBRemote::HandlePacket_M(const char *p) {
3042 if (p == NULL || p[0] == '\0' || strlen(p) < 3) {
3043 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, "Too short M packet");
3047 p++;
3049 nub_addr_t addr = strtoull(p, &c, 16);
3051 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3055 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3059 /* Advance 'p' to the length part of the packet. */
3060 p += (c - p) + 1;
3063 unsigned long length = strtoul(p, &c, 16);
3065 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3073 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3076 /* Advance 'p' to the data part of the packet. */
3077 p += (c - p) + 1;
3079 size_t datalen = strlen(p);
3081 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3091 while (*p != '\0' && *(p + 1) != '\0') {
3093 hexbuf[0] = *p;
3094 hexbuf[1] = *(p + 1);
3099 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3103 p += 2;
3114 rnb_err_t RNBRemote::HandlePacket_m(const char *p) {
3115 if (p == NULL || p[0] == '\0' || strlen(p) < 3) {
3116 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, "Too short m packet");
3120 p++;
3122 nub_addr_t addr = strtoull(p, &c, 16);
3124 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3128 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3132 /* Advance 'p' to the length part of the packet. */
3133 p += (c - p) + 1;
3136 auto length = strtoul(p, NULL, 16);
3138 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3176 rnb_err_t RNBRemote::HandlePacket_x(const char *p) {
3177 if (p == NULL || p[0] == '\0' || strlen(p) < 3) {
3178 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, "Too short X packet");
3182 p++;
3184 nub_addr_t addr = strtoull(p, &c, 16);
3186 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3190 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3194 /* Advance 'p' to the number of bytes to be read. */
3195 p += (c - p) + 1;
3198 auto length = strtoul(p, NULL, 16);
3200 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3240 rnb_err_t RNBRemote::HandlePacket_X(const char *p) {
3241 if (p == NULL || p[0] == '\0' || strlen(p) < 3) {
3242 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, "Too short X packet");
3246 p++;
3248 nub_addr_t addr = strtoull(p, &c, 16);
3250 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3254 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3258 /* Advance 'p' to the length part of the packet. NB this is the length of the
3263 p += (c - p) + 1;
3266 auto length = strtoul(p, NULL, 16);
3268 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3299 rnb_err_t RNBRemote::HandlePacket_g(const char *p) {
3309 nub_thread_t tid = ExtractThreadIDFromThreadSuffix(p + 1);
3311 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3312 "No thread specified in p packet");
3335 rnb_err_t RNBRemote::HandlePacket_G(const char *p) {
3343 p += 1; // Skip the 'G'
3346 nub_thread_t tid = ExtractThreadIDFromThreadSuffix(p);
3348 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3349 "No thread specified in p packet");
3351 const char *last_semi = strrchr(p, ';');
3353 p = last_semi + 1;
3355 StdStringExtractor packet(p);
3377 p, (uint64_t)bytes_extracted, (uint64_t)reg_ctx_size);
3387 RNBRemote *remote = remoteSP.get();
3388 return !remote->Comm().IsConnected();
3406 rnb_err_t RNBRemote::HandlePacket_AllocateMemory(const char *p) {
3407 StdStringExtractor packet(p);
3457 rnb_err_t RNBRemote::HandlePacket_DeallocateMemory(const char *p) {
3458 StdStringExtractor packet(p);
3485 rnb_err_t RNBRemote::HandlePacket_SaveRegisterState(const char *p) {
3487 nub_thread_t tid = ExtractThreadIDFromThreadSuffix(p);
3491 __FILE__, __LINE__, p,
3494 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3526 rnb_err_t RNBRemote::HandlePacket_RestoreRegisterState(const char *p) {
3528 nub_thread_t tid = ExtractThreadIDFromThreadSuffix(p);
3532 __FILE__, __LINE__, p,
3535 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3539 StdStringExtractor packet(p);
3554 static bool GetProcessNameFrom_vAttach(const char *&p,
3557 while (*p != '\0') {
3559 smallbuf[0] = *p;
3560 smallbuf[1] = *(p + 1);
3571 p += 2;
3576 rnb_err_t RNBRemote::HandlePacket_qSupported(const char *p) {
3785 rnb_err_t RNBRemote::HandlePacket_v(const char *p) {
3786 if (strcmp(p, "vCont;c") == 0) {
3789 } else if (strcmp(p, "vCont;s") == 0) {
3792 } else if (strstr(p, "vCont") == p) {
3794 char *c = const_cast<char *>(p += strlen("vCont"));
3815 __FILE__, __LINE__, p, "Could not parse signal in vCont packet");
3828 __FILE__, __LINE__, p, "Could not parse signal in vCont packet");
3837 HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
3846 __FILE__, __LINE__, p,
3859 } else if (strstr(p, "vAttach") == p) {
3867 if (strstr(p, "vAttachWait;") == p) {
3868 p += strlen("vAttachWait;");
3869 if (!GetProcessNameFrom_vAttach(p, attach_name)) {
3871 __FILE__, __LINE__, p, "non-hex char in arg on 'vAttachWait' pkt");
3880 } else if (strstr(p, "vAttachOrWait;") == p) {
3881 p += strlen("vAttachOrWait;");
3882 if (!GetProcessNameFrom_vAttach(p, attach_name)) {
3884 __FILE__, __LINE__, p,
3894 } else if (strstr(p, "vAttachName;") == p) {
3895 p += strlen("vAttachName;");
3896 if (!GetProcessNameFrom_vAttach(p, attach_name)) {
3898 __FILE__, __LINE__, p, "non-hex char in arg on 'vAttachName' pkt");
3908 } else if (strstr(p, "vAttach;") == p) {
3909 p += strlen("vAttach;");
3912 strtoul(p, &end, 16)); // PID will be in hex, so use base 16 to decode
3913 if (p != end && *end == '\0') {
3924 return HandlePacket_UNIMPLEMENTED(p);
4029 return HandlePacket_UNIMPLEMENTED(p);
4036 rnb_err_t RNBRemote::HandlePacket_T(const char *p) {
4037 p++;
4038 if (p == NULL || *p == '\0') {
4039 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4046 nub_thread_t tid = strtoul(p, NULL, 16);
4048 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4061 rnb_err_t RNBRemote::HandlePacket_z(const char *p) {
4062 if (p == NULL || *p == '\0')
4063 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4069 char packet_cmd = *p++;
4070 char break_type = *p++;
4072 if (*p++ != ',')
4073 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4079 nub_addr_t addr = strtoull(p, &c, 16);
4081 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4083 p = c;
4084 if (*p++ != ',')
4085 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4089 auto byte_size = strtoul(p, &c, 16);
4091 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4165 return HandlePacket_UNIMPLEMENTED(p);
4172 nub_thread_t RNBRemote::ExtractThreadIDFromThreadSuffix(const char *p) {
4175 if (p) {
4176 const char *tid_cstr = strstr(p, "thread:");
4187 /* 'p XX'
4190 rnb_err_t RNBRemote::HandlePacket_p(const char *p) {
4194 if (p == NULL || *p == '\0') {
4195 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4196 "No thread specified in p packet");
4204 uint32_t reg = static_cast<uint32_t>(strtoul(p + 1, &tid_cstr, 16));
4207 __FILE__, __LINE__, p, "Could not parse register number in p packet");
4212 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4213 "No thread specified in p packet");
4226 p, reg);
4245 rnb_err_t RNBRemote::HandlePacket_P(const char *p) {
4249 if (p == NULL || *p == '\0') {
4250 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p, "Empty P packet");
4258 StdStringExtractor packet(p);
4266 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4286 p, reg);
4295 nub_thread_t tid = ExtractThreadIDFromThreadSuffix(p);
4297 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4298 "No thread specified in p packet");
4311 rnb_err_t RNBRemote::HandlePacket_c(const char *p) {
4320 if (*(p + 1) != '\0') {
4323 action.addr = strtoull(p + 1, NULL, 16);
4325 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4339 rnb_err_t RNBRemote::HandlePacket_MemoryRegionInfo(const char *p) {
4365 OK // this packet is implemented by the remote nub
4368 p += sizeof("qMemoryRegionInfo") - 1;
4369 if (*p == '\0')
4371 if (*p++ != ':')
4373 if (*p == '0' && (*(p + 1) == 'x' || *(p + 1) == 'X'))
4374 p += 2;
4377 uint64_t address = strtoul(p, NULL, 16);
4380 __FILE__, __LINE__, p, "Invalid address in qMemoryRegionInfo packet");
4429 rnb_err_t RNBRemote::HandlePacket_GetProfileData(const char *p) {
4434 StdStringExtractor packet(p += sizeof("qGetProfileData"));
4457 rnb_err_t RNBRemote::HandlePacket_SetEnableAsyncProfiling(const char *p) {
4462 StdStringExtractor packet(p += sizeof("QSetEnableAsyncProfiling"));
4495 rnb_err_t RNBRemote::HandlePacket_QEnableCompression(const char *p) {
4496 p += sizeof("QEnableCompression:") - 1;
4498 if (strstr(p, "type:zlib-deflate;") != nullptr) {
4501 } else if (strstr(p, "type:lz4;") != nullptr) {
4504 } else if (strstr(p, "type:lzma;") != nullptr) {
4507 } else if (strstr(p, "type:lzfse;") != nullptr) {
4515 rnb_err_t RNBRemote::HandlePacket_qSpeedTest(const char *p) {
4516 p += strlen("qSpeedTest:response_size:");
4519 uint64_t response_size = ::strtoul(p, &end, 16);
4522 __FILE__, __LINE__, p,
4535 rnb_err_t RNBRemote::HandlePacket_WatchpointSupportInfo(const char *p) {
4543 OK // this packet is implemented by the remote nub
4546 p += sizeof("qWatchpointSupportInfo") - 1;
4547 if (*p == '\0')
4549 if (*p++ != ':')
4564 rnb_err_t RNBRemote::HandlePacket_C(const char *p) {
4573 if (*(p + 1) != '\0') {
4577 process_signo = static_cast<int>(strtoul(p + 1, &end, 16));
4579 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4585 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4604 rnb_err_t RNBRemote::HandlePacket_D(const char *p) {
4623 rnb_err_t RNBRemote::HandlePacket_k(const char *p) {
4632 rnb_err_t RNBRemote::HandlePacket_stop_process(const char *p) {
4636 rnb_err_t err = HandlePacket_k(p);
4654 rnb_err_t RNBRemote::HandlePacket_s(const char *p) {
4682 rnb_err_t RNBRemote::HandlePacket_S(const char *p) {
4690 if (*(p + 1) != '\0') {
4693 action.signal = static_cast<int>(strtoul(p + 1, &end, 16));
4695 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4701 return HandlePacket_ILLFORMED(__FILE__, __LINE__, p,
4828 rnb_err_t RNBRemote::HandlePacket_qHostInfo(const char *p) {
5216 const char *p = command;
5217 p += strlen("qXfer:");
5218 const char *sep = strchr(p, ':');
5220 std::string object(p, sep - p); // "auxv", "backtrace", "features", etc
5221 p = sep + 1;
5222 sep = strchr(p, ':');
5224 std::string rw(p, sep - p); // "read" or "write"
5225 p = sep + 1;
5226 sep = strchr(p, ':');
5228 std::string annex(p, sep - p); // "read" or "write"
5230 p = sep + 1;
5231 sep = strchr(p, ',');
5233 std::string offset_str(p, sep - p); // read the length as a string
5234 p = sep + 1;
5235 std::string length_str(p); // read the offset as a string
5292 rnb_err_t RNBRemote::HandlePacket_qGDBServerVersion(const char *p) {
5305 rnb_err_t RNBRemote::HandlePacket_jGetDyldProcessState(const char *p) {
5641 rnb_err_t RNBRemote::HandlePacket_jThreadsInfo(const char *p) {
5662 rnb_err_t RNBRemote::HandlePacket_jThreadExtendedInfo(const char *p) {
5673 if (strncmp(p, thread_extended_info_str,
5675 p += strlen(thread_extended_info_str);
5677 uint64_t tid = get_integer_value_for_key_name_from_json("thread", p);
5680 "plo_pthread_tsd_base_address_offset", p);
5683 p);
5686 p);
5688 get_integer_value_for_key_name_from_json("dti_qos_class_index", p);
5932 RNBRemote::HandlePacket_jGetLoadedDynamicLibrariesInfos(const char *p) {
5943 if (strncmp(p, get_loaded_dynamic_libraries_infos_str,
5945 p += strlen(get_loaded_dynamic_libraries_infos_str);
5952 get_boolean_value_for_key_name_from_json("report_load_commands", p,
5955 if (get_boolean_value_for_key_name_from_json("fetch_all_solibs", p,
5960 "solib_addresses", p, macho_addresses)) {
5983 rnb_err_t RNBRemote::HandlePacket_jGetSharedCacheInfo(const char *p) {
5993 if (strncmp(p, get_shared_cache_info_str,
6154 const char *p = command;
6155 p += strlen("qSymbol:");
6156 const char *sep = strchr(p, ':');
6161 if (sep > p)
6162 symbol_value_str.assign(p, sep - p);
6163 p = sep + 1;
6165 if (*p) {
6167 symbol_name = decode_hex_ascii_string(p);
6206 rnb_err_t RNBRemote::HandlePacket_QEnableErrorStrings(const char *p) {
6267 rnb_err_t RNBRemote::HandlePacket_qProcessInfo(const char *p) {
6395 const char *p = data.PeekCStr(offset);
6396 if ((p == NULL) || (*p != '\0'))