1 //===-- GDBRemoteCommunicationServerCommon.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 "GDBRemoteCommunicationServerCommon.h"
10 
11 #include <cerrno>
12 
13 #ifdef __APPLE__
14 #include <TargetConditionals.h>
15 #endif
16 
17 #include <chrono>
18 #include <cstring>
19 
20 #include "lldb/Core/ModuleSpec.h"
21 #include "lldb/Host/Config.h"
22 #include "lldb/Host/File.h"
23 #include "lldb/Host/FileAction.h"
24 #include "lldb/Host/FileSystem.h"
25 #include "lldb/Host/Host.h"
26 #include "lldb/Host/HostInfo.h"
27 #include "lldb/Host/SafeMachO.h"
28 #include "lldb/Interpreter/OptionArgParser.h"
29 #include "lldb/Symbol/ObjectFile.h"
30 #include "lldb/Target/Platform.h"
31 #include "lldb/Utility/Endian.h"
32 #include "lldb/Utility/GDBRemote.h"
33 #include "lldb/Utility/LLDBLog.h"
34 #include "lldb/Utility/Log.h"
35 #include "lldb/Utility/StreamString.h"
36 #include "lldb/Utility/StructuredData.h"
37 #include "llvm/ADT/StringSwitch.h"
38 #include "llvm/ADT/Triple.h"
39 #include "llvm/Support/JSON.h"
40 
41 #include "ProcessGDBRemoteLog.h"
42 #include "lldb/Utility/StringExtractorGDBRemote.h"
43 
44 #ifdef __ANDROID__
45 #include "lldb/Host/android/HostInfoAndroid.h"
46 #endif
47 
48 
49 using namespace lldb;
50 using namespace lldb_private::process_gdb_remote;
51 using namespace lldb_private;
52 
53 #ifdef __ANDROID__
54 const static uint32_t g_default_packet_timeout_sec = 20; // seconds
55 #else
56 const static uint32_t g_default_packet_timeout_sec = 0; // not specified
57 #endif
58 
59 // GDBRemoteCommunicationServerCommon constructor
GDBRemoteCommunicationServerCommon(const char * comm_name,const char * listener_name)60 GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(
61     const char *comm_name, const char *listener_name)
62     : GDBRemoteCommunicationServer(comm_name, listener_name),
63       m_process_launch_info(), m_process_launch_error(), m_proc_infos(),
64       m_proc_infos_index(0) {
65   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_A,
66                                 &GDBRemoteCommunicationServerCommon::Handle_A);
67   RegisterMemberFunctionHandler(
68       StringExtractorGDBRemote::eServerPacketType_QEnvironment,
69       &GDBRemoteCommunicationServerCommon::Handle_QEnvironment);
70   RegisterMemberFunctionHandler(
71       StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded,
72       &GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded);
73   RegisterMemberFunctionHandler(
74       StringExtractorGDBRemote::eServerPacketType_qfProcessInfo,
75       &GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo);
76   RegisterMemberFunctionHandler(
77       StringExtractorGDBRemote::eServerPacketType_qGroupName,
78       &GDBRemoteCommunicationServerCommon::Handle_qGroupName);
79   RegisterMemberFunctionHandler(
80       StringExtractorGDBRemote::eServerPacketType_qHostInfo,
81       &GDBRemoteCommunicationServerCommon::Handle_qHostInfo);
82   RegisterMemberFunctionHandler(
83       StringExtractorGDBRemote::eServerPacketType_QLaunchArch,
84       &GDBRemoteCommunicationServerCommon::Handle_QLaunchArch);
85   RegisterMemberFunctionHandler(
86       StringExtractorGDBRemote::eServerPacketType_qLaunchSuccess,
87       &GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess);
88   RegisterMemberFunctionHandler(
89       StringExtractorGDBRemote::eServerPacketType_qEcho,
90       &GDBRemoteCommunicationServerCommon::Handle_qEcho);
91   RegisterMemberFunctionHandler(
92       StringExtractorGDBRemote::eServerPacketType_qModuleInfo,
93       &GDBRemoteCommunicationServerCommon::Handle_qModuleInfo);
94   RegisterMemberFunctionHandler(
95       StringExtractorGDBRemote::eServerPacketType_jModulesInfo,
96       &GDBRemoteCommunicationServerCommon::Handle_jModulesInfo);
97   RegisterMemberFunctionHandler(
98       StringExtractorGDBRemote::eServerPacketType_qPlatform_chmod,
99       &GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod);
100   RegisterMemberFunctionHandler(
101       StringExtractorGDBRemote::eServerPacketType_qPlatform_mkdir,
102       &GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir);
103   RegisterMemberFunctionHandler(
104       StringExtractorGDBRemote::eServerPacketType_qPlatform_shell,
105       &GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell);
106   RegisterMemberFunctionHandler(
107       StringExtractorGDBRemote::eServerPacketType_qProcessInfoPID,
108       &GDBRemoteCommunicationServerCommon::Handle_qProcessInfoPID);
109   RegisterMemberFunctionHandler(
110       StringExtractorGDBRemote::eServerPacketType_QSetDetachOnError,
111       &GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError);
112   RegisterMemberFunctionHandler(
113       StringExtractorGDBRemote::eServerPacketType_QSetSTDERR,
114       &GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR);
115   RegisterMemberFunctionHandler(
116       StringExtractorGDBRemote::eServerPacketType_QSetSTDIN,
117       &GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN);
118   RegisterMemberFunctionHandler(
119       StringExtractorGDBRemote::eServerPacketType_QSetSTDOUT,
120       &GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT);
121   RegisterMemberFunctionHandler(
122       StringExtractorGDBRemote::eServerPacketType_qSpeedTest,
123       &GDBRemoteCommunicationServerCommon::Handle_qSpeedTest);
124   RegisterMemberFunctionHandler(
125       StringExtractorGDBRemote::eServerPacketType_qsProcessInfo,
126       &GDBRemoteCommunicationServerCommon::Handle_qsProcessInfo);
127   RegisterMemberFunctionHandler(
128       StringExtractorGDBRemote::eServerPacketType_QStartNoAckMode,
129       &GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode);
130   RegisterMemberFunctionHandler(
131       StringExtractorGDBRemote::eServerPacketType_qSupported,
132       &GDBRemoteCommunicationServerCommon::Handle_qSupported);
133   RegisterMemberFunctionHandler(
134       StringExtractorGDBRemote::eServerPacketType_qUserName,
135       &GDBRemoteCommunicationServerCommon::Handle_qUserName);
136   RegisterMemberFunctionHandler(
137       StringExtractorGDBRemote::eServerPacketType_vFile_close,
138       &GDBRemoteCommunicationServerCommon::Handle_vFile_Close);
139   RegisterMemberFunctionHandler(
140       StringExtractorGDBRemote::eServerPacketType_vFile_exists,
141       &GDBRemoteCommunicationServerCommon::Handle_vFile_Exists);
142   RegisterMemberFunctionHandler(
143       StringExtractorGDBRemote::eServerPacketType_vFile_md5,
144       &GDBRemoteCommunicationServerCommon::Handle_vFile_MD5);
145   RegisterMemberFunctionHandler(
146       StringExtractorGDBRemote::eServerPacketType_vFile_mode,
147       &GDBRemoteCommunicationServerCommon::Handle_vFile_Mode);
148   RegisterMemberFunctionHandler(
149       StringExtractorGDBRemote::eServerPacketType_vFile_open,
150       &GDBRemoteCommunicationServerCommon::Handle_vFile_Open);
151   RegisterMemberFunctionHandler(
152       StringExtractorGDBRemote::eServerPacketType_vFile_pread,
153       &GDBRemoteCommunicationServerCommon::Handle_vFile_pRead);
154   RegisterMemberFunctionHandler(
155       StringExtractorGDBRemote::eServerPacketType_vFile_pwrite,
156       &GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite);
157   RegisterMemberFunctionHandler(
158       StringExtractorGDBRemote::eServerPacketType_vFile_size,
159       &GDBRemoteCommunicationServerCommon::Handle_vFile_Size);
160   RegisterMemberFunctionHandler(
161       StringExtractorGDBRemote::eServerPacketType_vFile_fstat,
162       &GDBRemoteCommunicationServerCommon::Handle_vFile_FStat);
163   RegisterMemberFunctionHandler(
164       StringExtractorGDBRemote::eServerPacketType_vFile_stat,
165       &GDBRemoteCommunicationServerCommon::Handle_vFile_Stat);
166   RegisterMemberFunctionHandler(
167       StringExtractorGDBRemote::eServerPacketType_vFile_symlink,
168       &GDBRemoteCommunicationServerCommon::Handle_vFile_symlink);
169   RegisterMemberFunctionHandler(
170       StringExtractorGDBRemote::eServerPacketType_vFile_unlink,
171       &GDBRemoteCommunicationServerCommon::Handle_vFile_unlink);
172 }
173 
174 // Destructor
175 GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() =
176     default;
177 
178 GDBRemoteCommunication::PacketResult
Handle_qHostInfo(StringExtractorGDBRemote & packet)179 GDBRemoteCommunicationServerCommon::Handle_qHostInfo(
180     StringExtractorGDBRemote &packet) {
181   StreamString response;
182 
183   // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
184 
185   ArchSpec host_arch(HostInfo::GetArchitecture());
186   const llvm::Triple &host_triple = host_arch.GetTriple();
187   response.PutCString("triple:");
188   response.PutStringAsRawHex8(host_triple.getTriple());
189   response.Printf(";ptrsize:%u;", host_arch.GetAddressByteSize());
190 
191   const char *distribution_id = host_arch.GetDistributionId().AsCString();
192   if (distribution_id) {
193     response.PutCString("distribution_id:");
194     response.PutStringAsRawHex8(distribution_id);
195     response.PutCString(";");
196   }
197 
198 #if defined(__APPLE__)
199   // For parity with debugserver, we'll include the vendor key.
200   response.PutCString("vendor:apple;");
201 
202   // Send out MachO info.
203   uint32_t cpu = host_arch.GetMachOCPUType();
204   uint32_t sub = host_arch.GetMachOCPUSubType();
205   if (cpu != LLDB_INVALID_CPUTYPE)
206     response.Printf("cputype:%u;", cpu);
207   if (sub != LLDB_INVALID_CPUTYPE)
208     response.Printf("cpusubtype:%u;", sub);
209 
210   if (cpu == llvm::MachO::CPU_TYPE_ARM || cpu == llvm::MachO::CPU_TYPE_ARM64) {
211 // Indicate the OS type.
212 #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
213     response.PutCString("ostype:tvos;");
214 #elif defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
215     response.PutCString("ostype:watchos;");
216 #elif defined(TARGET_OS_BRIDGE) && TARGET_OS_BRIDGE == 1
217     response.PutCString("ostype:bridgeos;");
218 #else
219     response.PutCString("ostype:ios;");
220 #endif
221 
222     // On arm, we use "synchronous" watchpoints which means the exception is
223     // delivered before the instruction executes.
224     response.PutCString("watchpoint_exceptions_received:before;");
225   } else {
226     response.PutCString("ostype:macosx;");
227     response.Printf("watchpoint_exceptions_received:after;");
228   }
229 
230 #else
231   if (host_arch.GetMachine() == llvm::Triple::aarch64 ||
232       host_arch.GetMachine() == llvm::Triple::aarch64_32 ||
233       host_arch.GetMachine() == llvm::Triple::aarch64_be ||
234       host_arch.GetMachine() == llvm::Triple::arm ||
235       host_arch.GetMachine() == llvm::Triple::armeb || host_arch.IsMIPS())
236     response.Printf("watchpoint_exceptions_received:before;");
237   else
238     response.Printf("watchpoint_exceptions_received:after;");
239 #endif
240 
241   switch (endian::InlHostByteOrder()) {
242   case eByteOrderBig:
243     response.PutCString("endian:big;");
244     break;
245   case eByteOrderLittle:
246     response.PutCString("endian:little;");
247     break;
248   case eByteOrderPDP:
249     response.PutCString("endian:pdp;");
250     break;
251   default:
252     response.PutCString("endian:unknown;");
253     break;
254   }
255 
256   llvm::VersionTuple version = HostInfo::GetOSVersion();
257   if (!version.empty()) {
258     response.Format("os_version:{0}", version.getAsString());
259     response.PutChar(';');
260   }
261 
262 #if defined(__APPLE__)
263   llvm::VersionTuple maccatalyst_version = HostInfo::GetMacCatalystVersion();
264   if (!maccatalyst_version.empty()) {
265     response.Format("maccatalyst_version:{0}",
266                     maccatalyst_version.getAsString());
267     response.PutChar(';');
268   }
269 #endif
270 
271   if (llvm::Optional<std::string> s = HostInfo::GetOSBuildString()) {
272     response.PutCString("os_build:");
273     response.PutStringAsRawHex8(*s);
274     response.PutChar(';');
275   }
276   if (llvm::Optional<std::string> s = HostInfo::GetOSKernelDescription()) {
277     response.PutCString("os_kernel:");
278     response.PutStringAsRawHex8(*s);
279     response.PutChar(';');
280   }
281 
282   std::string s;
283 #if defined(__APPLE__)
284 
285 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
286   // For iOS devices, we are connected through a USB Mux so we never pretend to
287   // actually have a hostname as far as the remote lldb that is connecting to
288   // this lldb-platform is concerned
289   response.PutCString("hostname:");
290   response.PutStringAsRawHex8("127.0.0.1");
291   response.PutChar(';');
292 #else  // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
293   if (HostInfo::GetHostname(s)) {
294     response.PutCString("hostname:");
295     response.PutStringAsRawHex8(s);
296     response.PutChar(';');
297   }
298 #endif // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
299 
300 #else  // #if defined(__APPLE__)
301   if (HostInfo::GetHostname(s)) {
302     response.PutCString("hostname:");
303     response.PutStringAsRawHex8(s);
304     response.PutChar(';');
305   }
306 #endif // #if defined(__APPLE__)
307 
308   if (g_default_packet_timeout_sec > 0)
309     response.Printf("default_packet_timeout:%u;", g_default_packet_timeout_sec);
310 
311   return SendPacketNoLock(response.GetString());
312 }
313 
314 GDBRemoteCommunication::PacketResult
Handle_qProcessInfoPID(StringExtractorGDBRemote & packet)315 GDBRemoteCommunicationServerCommon::Handle_qProcessInfoPID(
316     StringExtractorGDBRemote &packet) {
317   // Packet format: "qProcessInfoPID:%i" where %i is the pid
318   packet.SetFilePos(::strlen("qProcessInfoPID:"));
319   lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID);
320   if (pid != LLDB_INVALID_PROCESS_ID) {
321     ProcessInstanceInfo proc_info;
322     if (Host::GetProcessInfo(pid, proc_info)) {
323       StreamString response;
324       CreateProcessInfoResponse(proc_info, response);
325       return SendPacketNoLock(response.GetString());
326     }
327   }
328   return SendErrorResponse(1);
329 }
330 
331 GDBRemoteCommunication::PacketResult
Handle_qfProcessInfo(StringExtractorGDBRemote & packet)332 GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo(
333     StringExtractorGDBRemote &packet) {
334   m_proc_infos_index = 0;
335   m_proc_infos.clear();
336 
337   ProcessInstanceInfoMatch match_info;
338   packet.SetFilePos(::strlen("qfProcessInfo"));
339   if (packet.GetChar() == ':') {
340     llvm::StringRef key;
341     llvm::StringRef value;
342     while (packet.GetNameColonValue(key, value)) {
343       bool success = true;
344       if (key.equals("name")) {
345         StringExtractor extractor(value);
346         std::string file;
347         extractor.GetHexByteString(file);
348         match_info.GetProcessInfo().GetExecutableFile().SetFile(
349             file, FileSpec::Style::native);
350       } else if (key.equals("name_match")) {
351         NameMatch name_match = llvm::StringSwitch<NameMatch>(value)
352                                    .Case("equals", NameMatch::Equals)
353                                    .Case("starts_with", NameMatch::StartsWith)
354                                    .Case("ends_with", NameMatch::EndsWith)
355                                    .Case("contains", NameMatch::Contains)
356                                    .Case("regex", NameMatch::RegularExpression)
357                                    .Default(NameMatch::Ignore);
358         match_info.SetNameMatchType(name_match);
359         if (name_match == NameMatch::Ignore)
360           return SendErrorResponse(2);
361       } else if (key.equals("pid")) {
362         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
363         if (value.getAsInteger(0, pid))
364           return SendErrorResponse(2);
365         match_info.GetProcessInfo().SetProcessID(pid);
366       } else if (key.equals("parent_pid")) {
367         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
368         if (value.getAsInteger(0, pid))
369           return SendErrorResponse(2);
370         match_info.GetProcessInfo().SetParentProcessID(pid);
371       } else if (key.equals("uid")) {
372         uint32_t uid = UINT32_MAX;
373         if (value.getAsInteger(0, uid))
374           return SendErrorResponse(2);
375         match_info.GetProcessInfo().SetUserID(uid);
376       } else if (key.equals("gid")) {
377         uint32_t gid = UINT32_MAX;
378         if (value.getAsInteger(0, gid))
379           return SendErrorResponse(2);
380         match_info.GetProcessInfo().SetGroupID(gid);
381       } else if (key.equals("euid")) {
382         uint32_t uid = UINT32_MAX;
383         if (value.getAsInteger(0, uid))
384           return SendErrorResponse(2);
385         match_info.GetProcessInfo().SetEffectiveUserID(uid);
386       } else if (key.equals("egid")) {
387         uint32_t gid = UINT32_MAX;
388         if (value.getAsInteger(0, gid))
389           return SendErrorResponse(2);
390         match_info.GetProcessInfo().SetEffectiveGroupID(gid);
391       } else if (key.equals("all_users")) {
392         match_info.SetMatchAllUsers(
393             OptionArgParser::ToBoolean(value, false, &success));
394       } else if (key.equals("triple")) {
395         match_info.GetProcessInfo().GetArchitecture() =
396             HostInfo::GetAugmentedArchSpec(value);
397       } else {
398         success = false;
399       }
400 
401       if (!success)
402         return SendErrorResponse(2);
403     }
404   }
405 
406   if (Host::FindProcesses(match_info, m_proc_infos)) {
407     // We found something, return the first item by calling the get subsequent
408     // process info packet handler...
409     return Handle_qsProcessInfo(packet);
410   }
411   return SendErrorResponse(3);
412 }
413 
414 GDBRemoteCommunication::PacketResult
Handle_qsProcessInfo(StringExtractorGDBRemote & packet)415 GDBRemoteCommunicationServerCommon::Handle_qsProcessInfo(
416     StringExtractorGDBRemote &packet) {
417   if (m_proc_infos_index < m_proc_infos.size()) {
418     StreamString response;
419     CreateProcessInfoResponse(m_proc_infos[m_proc_infos_index], response);
420     ++m_proc_infos_index;
421     return SendPacketNoLock(response.GetString());
422   }
423   return SendErrorResponse(4);
424 }
425 
426 GDBRemoteCommunication::PacketResult
Handle_qUserName(StringExtractorGDBRemote & packet)427 GDBRemoteCommunicationServerCommon::Handle_qUserName(
428     StringExtractorGDBRemote &packet) {
429 #if LLDB_ENABLE_POSIX
430   Log *log = GetLog(LLDBLog::Process);
431   LLDB_LOGF(log, "GDBRemoteCommunicationServerCommon::%s begin", __FUNCTION__);
432 
433   // Packet format: "qUserName:%i" where %i is the uid
434   packet.SetFilePos(::strlen("qUserName:"));
435   uint32_t uid = packet.GetU32(UINT32_MAX);
436   if (uid != UINT32_MAX) {
437     if (llvm::Optional<llvm::StringRef> name =
438             HostInfo::GetUserIDResolver().GetUserName(uid)) {
439       StreamString response;
440       response.PutStringAsRawHex8(*name);
441       return SendPacketNoLock(response.GetString());
442     }
443   }
444   LLDB_LOGF(log, "GDBRemoteCommunicationServerCommon::%s end", __FUNCTION__);
445 #endif
446   return SendErrorResponse(5);
447 }
448 
449 GDBRemoteCommunication::PacketResult
Handle_qGroupName(StringExtractorGDBRemote & packet)450 GDBRemoteCommunicationServerCommon::Handle_qGroupName(
451     StringExtractorGDBRemote &packet) {
452 #if LLDB_ENABLE_POSIX
453   // Packet format: "qGroupName:%i" where %i is the gid
454   packet.SetFilePos(::strlen("qGroupName:"));
455   uint32_t gid = packet.GetU32(UINT32_MAX);
456   if (gid != UINT32_MAX) {
457     if (llvm::Optional<llvm::StringRef> name =
458             HostInfo::GetUserIDResolver().GetGroupName(gid)) {
459       StreamString response;
460       response.PutStringAsRawHex8(*name);
461       return SendPacketNoLock(response.GetString());
462     }
463   }
464 #endif
465   return SendErrorResponse(6);
466 }
467 
468 GDBRemoteCommunication::PacketResult
Handle_qSpeedTest(StringExtractorGDBRemote & packet)469 GDBRemoteCommunicationServerCommon::Handle_qSpeedTest(
470     StringExtractorGDBRemote &packet) {
471   packet.SetFilePos(::strlen("qSpeedTest:"));
472 
473   llvm::StringRef key;
474   llvm::StringRef value;
475   bool success = packet.GetNameColonValue(key, value);
476   if (success && key.equals("response_size")) {
477     uint32_t response_size = 0;
478     if (!value.getAsInteger(0, response_size)) {
479       if (response_size == 0)
480         return SendOKResponse();
481       StreamString response;
482       uint32_t bytes_left = response_size;
483       response.PutCString("data:");
484       while (bytes_left > 0) {
485         if (bytes_left >= 26) {
486           response.PutCString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
487           bytes_left -= 26;
488         } else {
489           response.Printf("%*.*s;", bytes_left, bytes_left,
490                           "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
491           bytes_left = 0;
492         }
493       }
494       return SendPacketNoLock(response.GetString());
495     }
496   }
497   return SendErrorResponse(7);
498 }
499 
500 GDBRemoteCommunication::PacketResult
Handle_vFile_Open(StringExtractorGDBRemote & packet)501 GDBRemoteCommunicationServerCommon::Handle_vFile_Open(
502     StringExtractorGDBRemote &packet) {
503   packet.SetFilePos(::strlen("vFile:open:"));
504   std::string path;
505   packet.GetHexByteStringTerminatedBy(path, ',');
506   if (!path.empty()) {
507     if (packet.GetChar() == ',') {
508       auto flags = File::OpenOptions(packet.GetHexMaxU32(false, 0));
509       if (packet.GetChar() == ',') {
510         mode_t mode = packet.GetHexMaxU32(false, 0600);
511         FileSpec path_spec(path);
512         FileSystem::Instance().Resolve(path_spec);
513         // Do not close fd.
514         auto file = FileSystem::Instance().Open(path_spec, flags, mode, false);
515 
516         StreamString response;
517         response.PutChar('F');
518 
519         int descriptor = File::kInvalidDescriptor;
520         if (file) {
521           descriptor = file.get()->GetDescriptor();
522           response.Printf("%x", descriptor);
523         } else {
524           response.PutCString("-1");
525           std::error_code code = errorToErrorCode(file.takeError());
526           if (code.category() == std::system_category()) {
527             response.Printf(",%x", code.value());
528           }
529         }
530 
531         return SendPacketNoLock(response.GetString());
532       }
533     }
534   }
535   return SendErrorResponse(18);
536 }
537 
system_errno_to_gdb(int err)538 static GDBErrno system_errno_to_gdb(int err) {
539   switch (err) {
540 #define HANDLE_ERRNO(name, value)                                              \
541   case name:                                                                   \
542     return GDB_##name;
543 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
544   default:
545     return GDB_EUNKNOWN;
546   }
547 }
548 
549 GDBRemoteCommunication::PacketResult
Handle_vFile_Close(StringExtractorGDBRemote & packet)550 GDBRemoteCommunicationServerCommon::Handle_vFile_Close(
551     StringExtractorGDBRemote &packet) {
552   packet.SetFilePos(::strlen("vFile:close:"));
553   int fd = packet.GetS32(-1, 16);
554   int err = -1;
555   int save_errno = 0;
556   if (fd >= 0) {
557     NativeFile file(fd, File::OpenOptions(0), true);
558     Status error = file.Close();
559     err = 0;
560     save_errno = error.GetError();
561   } else {
562     save_errno = EINVAL;
563   }
564   StreamString response;
565   response.PutChar('F');
566   response.Printf("%x", err);
567   if (save_errno)
568     response.Printf(",%x", system_errno_to_gdb(save_errno));
569   return SendPacketNoLock(response.GetString());
570 }
571 
572 GDBRemoteCommunication::PacketResult
Handle_vFile_pRead(StringExtractorGDBRemote & packet)573 GDBRemoteCommunicationServerCommon::Handle_vFile_pRead(
574     StringExtractorGDBRemote &packet) {
575   StreamGDBRemote response;
576   packet.SetFilePos(::strlen("vFile:pread:"));
577   int fd = packet.GetS32(-1, 16);
578   if (packet.GetChar() == ',') {
579     size_t count = packet.GetHexMaxU64(false, SIZE_MAX);
580     if (packet.GetChar() == ',') {
581       off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
582       if (count == SIZE_MAX) {
583         response.Printf("F-1:%x", EINVAL);
584         return SendPacketNoLock(response.GetString());
585       }
586 
587       std::string buffer(count, 0);
588       NativeFile file(fd, File::eOpenOptionReadOnly, false);
589       Status error = file.Read(static_cast<void *>(&buffer[0]), count, offset);
590       const int save_errno = error.GetError();
591       response.PutChar('F');
592       if (error.Success()) {
593         response.Printf("%zx", count);
594         response.PutChar(';');
595         response.PutEscapedBytes(&buffer[0], count);
596       } else {
597         response.PutCString("-1");
598         if (save_errno)
599           response.Printf(",%x", system_errno_to_gdb(save_errno));
600       }
601       return SendPacketNoLock(response.GetString());
602     }
603   }
604   return SendErrorResponse(21);
605 }
606 
607 GDBRemoteCommunication::PacketResult
Handle_vFile_pWrite(StringExtractorGDBRemote & packet)608 GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite(
609     StringExtractorGDBRemote &packet) {
610   packet.SetFilePos(::strlen("vFile:pwrite:"));
611 
612   StreamGDBRemote response;
613   response.PutChar('F');
614 
615   int fd = packet.GetS32(-1, 16);
616   if (packet.GetChar() == ',') {
617     off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
618     if (packet.GetChar() == ',') {
619       std::string buffer;
620       if (packet.GetEscapedBinaryData(buffer)) {
621         NativeFile file(fd, File::eOpenOptionWriteOnly, false);
622         size_t count = buffer.size();
623         Status error =
624             file.Write(static_cast<const void *>(&buffer[0]), count, offset);
625         const int save_errno = error.GetError();
626         if (error.Success())
627           response.Printf("%zx", count);
628         else {
629           response.PutCString("-1");
630           if (save_errno)
631             response.Printf(",%x", system_errno_to_gdb(save_errno));
632         }
633       } else {
634         response.Printf("-1,%x", EINVAL);
635       }
636       return SendPacketNoLock(response.GetString());
637     }
638   }
639   return SendErrorResponse(27);
640 }
641 
642 GDBRemoteCommunication::PacketResult
Handle_vFile_Size(StringExtractorGDBRemote & packet)643 GDBRemoteCommunicationServerCommon::Handle_vFile_Size(
644     StringExtractorGDBRemote &packet) {
645   packet.SetFilePos(::strlen("vFile:size:"));
646   std::string path;
647   packet.GetHexByteString(path);
648   if (!path.empty()) {
649     uint64_t Size;
650     if (llvm::sys::fs::file_size(path, Size))
651       return SendErrorResponse(5);
652     StreamString response;
653     response.PutChar('F');
654     response.PutHex64(Size);
655     if (Size == UINT64_MAX) {
656       response.PutChar(',');
657       response.PutHex64(Size); // TODO: replace with Host::GetSyswideErrorCode()
658     }
659     return SendPacketNoLock(response.GetString());
660   }
661   return SendErrorResponse(22);
662 }
663 
664 GDBRemoteCommunication::PacketResult
Handle_vFile_Mode(StringExtractorGDBRemote & packet)665 GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(
666     StringExtractorGDBRemote &packet) {
667   packet.SetFilePos(::strlen("vFile:mode:"));
668   std::string path;
669   packet.GetHexByteString(path);
670   if (!path.empty()) {
671     FileSpec file_spec(path);
672     FileSystem::Instance().Resolve(file_spec);
673     std::error_code ec;
674     const uint32_t mode = FileSystem::Instance().GetPermissions(file_spec, ec);
675     StreamString response;
676     if (mode != llvm::sys::fs::perms_not_known)
677       response.Printf("F%x", mode);
678     else
679       response.Printf("F-1,%x", (int)Status(ec).GetError());
680     return SendPacketNoLock(response.GetString());
681   }
682   return SendErrorResponse(23);
683 }
684 
685 GDBRemoteCommunication::PacketResult
Handle_vFile_Exists(StringExtractorGDBRemote & packet)686 GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
687     StringExtractorGDBRemote &packet) {
688   packet.SetFilePos(::strlen("vFile:exists:"));
689   std::string path;
690   packet.GetHexByteString(path);
691   if (!path.empty()) {
692     bool retcode = llvm::sys::fs::exists(path);
693     StreamString response;
694     response.PutChar('F');
695     response.PutChar(',');
696     if (retcode)
697       response.PutChar('1');
698     else
699       response.PutChar('0');
700     return SendPacketNoLock(response.GetString());
701   }
702   return SendErrorResponse(24);
703 }
704 
705 GDBRemoteCommunication::PacketResult
Handle_vFile_symlink(StringExtractorGDBRemote & packet)706 GDBRemoteCommunicationServerCommon::Handle_vFile_symlink(
707     StringExtractorGDBRemote &packet) {
708   packet.SetFilePos(::strlen("vFile:symlink:"));
709   std::string dst, src;
710   packet.GetHexByteStringTerminatedBy(dst, ',');
711   packet.GetChar(); // Skip ',' char
712   packet.GetHexByteString(src);
713 
714   FileSpec src_spec(src);
715   FileSystem::Instance().Resolve(src_spec);
716   Status error = FileSystem::Instance().Symlink(src_spec, FileSpec(dst));
717 
718   StreamString response;
719   response.Printf("F%x,%x", error.GetError(), error.GetError());
720   return SendPacketNoLock(response.GetString());
721 }
722 
723 GDBRemoteCommunication::PacketResult
Handle_vFile_unlink(StringExtractorGDBRemote & packet)724 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
725     StringExtractorGDBRemote &packet) {
726   packet.SetFilePos(::strlen("vFile:unlink:"));
727   std::string path;
728   packet.GetHexByteString(path);
729   Status error(llvm::sys::fs::remove(path));
730   StreamString response;
731   response.Printf("F%x,%x", error.GetError(), error.GetError());
732   return SendPacketNoLock(response.GetString());
733 }
734 
735 GDBRemoteCommunication::PacketResult
Handle_qPlatform_shell(StringExtractorGDBRemote & packet)736 GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
737     StringExtractorGDBRemote &packet) {
738   packet.SetFilePos(::strlen("qPlatform_shell:"));
739   std::string path;
740   std::string working_dir;
741   packet.GetHexByteStringTerminatedBy(path, ',');
742   if (!path.empty()) {
743     if (packet.GetChar() == ',') {
744       // FIXME: add timeout to qPlatform_shell packet
745       // uint32_t timeout = packet.GetHexMaxU32(false, 32);
746       if (packet.GetChar() == ',')
747         packet.GetHexByteString(working_dir);
748       int status, signo;
749       std::string output;
750       FileSpec working_spec(working_dir);
751       FileSystem::Instance().Resolve(working_spec);
752       Status err =
753           Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
754                                 &output, std::chrono::seconds(10));
755       StreamGDBRemote response;
756       if (err.Fail()) {
757         response.PutCString("F,");
758         response.PutHex32(UINT32_MAX);
759       } else {
760         response.PutCString("F,");
761         response.PutHex32(status);
762         response.PutChar(',');
763         response.PutHex32(signo);
764         response.PutChar(',');
765         response.PutEscapedBytes(output.c_str(), output.size());
766       }
767       return SendPacketNoLock(response.GetString());
768     }
769   }
770   return SendErrorResponse(24);
771 }
772 
773 template <typename T, typename U>
fill_clamp(T & dest,U src,typename T::value_type fallback)774 static void fill_clamp(T &dest, U src, typename T::value_type fallback) {
775   static_assert(std::is_unsigned<typename T::value_type>::value,
776                 "Destination type must be unsigned.");
777   using UU = typename std::make_unsigned<U>::type;
778   constexpr auto T_max = std::numeric_limits<typename T::value_type>::max();
779   dest = src >= 0 && static_cast<UU>(src) <= T_max ? src : fallback;
780 }
781 
782 GDBRemoteCommunication::PacketResult
Handle_vFile_FStat(StringExtractorGDBRemote & packet)783 GDBRemoteCommunicationServerCommon::Handle_vFile_FStat(
784     StringExtractorGDBRemote &packet) {
785   StreamGDBRemote response;
786   packet.SetFilePos(::strlen("vFile:fstat:"));
787   int fd = packet.GetS32(-1, 16);
788 
789   struct stat file_stats;
790   if (::fstat(fd, &file_stats) == -1) {
791     const int save_errno = errno;
792     response.Printf("F-1,%x", system_errno_to_gdb(save_errno));
793     return SendPacketNoLock(response.GetString());
794   }
795 
796   GDBRemoteFStatData data;
797   fill_clamp(data.gdb_st_dev, file_stats.st_dev, 0);
798   fill_clamp(data.gdb_st_ino, file_stats.st_ino, 0);
799   data.gdb_st_mode = file_stats.st_mode;
800   fill_clamp(data.gdb_st_nlink, file_stats.st_nlink, UINT32_MAX);
801   fill_clamp(data.gdb_st_uid, file_stats.st_uid, 0);
802   fill_clamp(data.gdb_st_gid, file_stats.st_gid, 0);
803   fill_clamp(data.gdb_st_rdev, file_stats.st_rdev, 0);
804   data.gdb_st_size = file_stats.st_size;
805 #if !defined(_WIN32)
806   data.gdb_st_blksize = file_stats.st_blksize;
807   data.gdb_st_blocks = file_stats.st_blocks;
808 #else
809   data.gdb_st_blksize = 0;
810   data.gdb_st_blocks = 0;
811 #endif
812   fill_clamp(data.gdb_st_atime, file_stats.st_atime, 0);
813   fill_clamp(data.gdb_st_mtime, file_stats.st_mtime, 0);
814   fill_clamp(data.gdb_st_ctime, file_stats.st_ctime, 0);
815 
816   response.Printf("F%zx;", sizeof(data));
817   response.PutEscapedBytes(&data, sizeof(data));
818   return SendPacketNoLock(response.GetString());
819 }
820 
821 GDBRemoteCommunication::PacketResult
Handle_vFile_Stat(StringExtractorGDBRemote & packet)822 GDBRemoteCommunicationServerCommon::Handle_vFile_Stat(
823     StringExtractorGDBRemote &packet) {
824   return SendUnimplementedResponse(
825       "GDBRemoteCommunicationServerCommon::Handle_vFile_Stat() unimplemented");
826 }
827 
828 GDBRemoteCommunication::PacketResult
Handle_vFile_MD5(StringExtractorGDBRemote & packet)829 GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
830     StringExtractorGDBRemote &packet) {
831   packet.SetFilePos(::strlen("vFile:MD5:"));
832   std::string path;
833   packet.GetHexByteString(path);
834   if (!path.empty()) {
835     StreamGDBRemote response;
836     auto Result = llvm::sys::fs::md5_contents(path);
837     if (!Result) {
838       response.PutCString("F,");
839       response.PutCString("x");
840     } else {
841       response.PutCString("F,");
842       response.PutHex64(Result->low());
843       response.PutHex64(Result->high());
844     }
845     return SendPacketNoLock(response.GetString());
846   }
847   return SendErrorResponse(25);
848 }
849 
850 GDBRemoteCommunication::PacketResult
Handle_qPlatform_mkdir(StringExtractorGDBRemote & packet)851 GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir(
852     StringExtractorGDBRemote &packet) {
853   packet.SetFilePos(::strlen("qPlatform_mkdir:"));
854   mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
855   if (packet.GetChar() == ',') {
856     std::string path;
857     packet.GetHexByteString(path);
858     Status error(llvm::sys::fs::create_directory(path, mode));
859 
860     StreamGDBRemote response;
861     response.Printf("F%x", error.GetError());
862 
863     return SendPacketNoLock(response.GetString());
864   }
865   return SendErrorResponse(20);
866 }
867 
868 GDBRemoteCommunication::PacketResult
Handle_qPlatform_chmod(StringExtractorGDBRemote & packet)869 GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod(
870     StringExtractorGDBRemote &packet) {
871   packet.SetFilePos(::strlen("qPlatform_chmod:"));
872 
873   auto perms =
874       static_cast<llvm::sys::fs::perms>(packet.GetHexMaxU32(false, UINT32_MAX));
875   if (packet.GetChar() == ',') {
876     std::string path;
877     packet.GetHexByteString(path);
878     Status error(llvm::sys::fs::setPermissions(path, perms));
879 
880     StreamGDBRemote response;
881     response.Printf("F%x", error.GetError());
882 
883     return SendPacketNoLock(response.GetString());
884   }
885   return SendErrorResponse(19);
886 }
887 
888 GDBRemoteCommunication::PacketResult
Handle_qSupported(StringExtractorGDBRemote & packet)889 GDBRemoteCommunicationServerCommon::Handle_qSupported(
890     StringExtractorGDBRemote &packet) {
891   // Parse client-indicated features.
892   llvm::SmallVector<llvm::StringRef, 4> client_features;
893   packet.GetStringRef().split(client_features, ';');
894   return SendPacketNoLock(llvm::join(HandleFeatures(client_features), ";"));
895 }
896 
897 GDBRemoteCommunication::PacketResult
Handle_QSetDetachOnError(StringExtractorGDBRemote & packet)898 GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError(
899     StringExtractorGDBRemote &packet) {
900   packet.SetFilePos(::strlen("QSetDetachOnError:"));
901   if (packet.GetU32(0))
902     m_process_launch_info.GetFlags().Set(eLaunchFlagDetachOnError);
903   else
904     m_process_launch_info.GetFlags().Clear(eLaunchFlagDetachOnError);
905   return SendOKResponse();
906 }
907 
908 GDBRemoteCommunication::PacketResult
Handle_QStartNoAckMode(StringExtractorGDBRemote & packet)909 GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode(
910     StringExtractorGDBRemote &packet) {
911   // Send response first before changing m_send_acks to we ack this packet
912   PacketResult packet_result = SendOKResponse();
913   m_send_acks = false;
914   return packet_result;
915 }
916 
917 GDBRemoteCommunication::PacketResult
Handle_QSetSTDIN(StringExtractorGDBRemote & packet)918 GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN(
919     StringExtractorGDBRemote &packet) {
920   packet.SetFilePos(::strlen("QSetSTDIN:"));
921   FileAction file_action;
922   std::string path;
923   packet.GetHexByteString(path);
924   const bool read = true;
925   const bool write = false;
926   if (file_action.Open(STDIN_FILENO, FileSpec(path), read, write)) {
927     m_process_launch_info.AppendFileAction(file_action);
928     return SendOKResponse();
929   }
930   return SendErrorResponse(15);
931 }
932 
933 GDBRemoteCommunication::PacketResult
Handle_QSetSTDOUT(StringExtractorGDBRemote & packet)934 GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT(
935     StringExtractorGDBRemote &packet) {
936   packet.SetFilePos(::strlen("QSetSTDOUT:"));
937   FileAction file_action;
938   std::string path;
939   packet.GetHexByteString(path);
940   const bool read = false;
941   const bool write = true;
942   if (file_action.Open(STDOUT_FILENO, FileSpec(path), read, write)) {
943     m_process_launch_info.AppendFileAction(file_action);
944     return SendOKResponse();
945   }
946   return SendErrorResponse(16);
947 }
948 
949 GDBRemoteCommunication::PacketResult
Handle_QSetSTDERR(StringExtractorGDBRemote & packet)950 GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR(
951     StringExtractorGDBRemote &packet) {
952   packet.SetFilePos(::strlen("QSetSTDERR:"));
953   FileAction file_action;
954   std::string path;
955   packet.GetHexByteString(path);
956   const bool read = false;
957   const bool write = true;
958   if (file_action.Open(STDERR_FILENO, FileSpec(path), read, write)) {
959     m_process_launch_info.AppendFileAction(file_action);
960     return SendOKResponse();
961   }
962   return SendErrorResponse(17);
963 }
964 
965 GDBRemoteCommunication::PacketResult
Handle_qLaunchSuccess(StringExtractorGDBRemote & packet)966 GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess(
967     StringExtractorGDBRemote &packet) {
968   if (m_process_launch_error.Success())
969     return SendOKResponse();
970   StreamString response;
971   response.PutChar('E');
972   response.PutCString(m_process_launch_error.AsCString("<unknown error>"));
973   return SendPacketNoLock(response.GetString());
974 }
975 
976 GDBRemoteCommunication::PacketResult
Handle_QEnvironment(StringExtractorGDBRemote & packet)977 GDBRemoteCommunicationServerCommon::Handle_QEnvironment(
978     StringExtractorGDBRemote &packet) {
979   packet.SetFilePos(::strlen("QEnvironment:"));
980   const uint32_t bytes_left = packet.GetBytesLeft();
981   if (bytes_left > 0) {
982     m_process_launch_info.GetEnvironment().insert(packet.Peek());
983     return SendOKResponse();
984   }
985   return SendErrorResponse(12);
986 }
987 
988 GDBRemoteCommunication::PacketResult
Handle_QEnvironmentHexEncoded(StringExtractorGDBRemote & packet)989 GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded(
990     StringExtractorGDBRemote &packet) {
991   packet.SetFilePos(::strlen("QEnvironmentHexEncoded:"));
992   const uint32_t bytes_left = packet.GetBytesLeft();
993   if (bytes_left > 0) {
994     std::string str;
995     packet.GetHexByteString(str);
996     m_process_launch_info.GetEnvironment().insert(str);
997     return SendOKResponse();
998   }
999   return SendErrorResponse(12);
1000 }
1001 
1002 GDBRemoteCommunication::PacketResult
Handle_QLaunchArch(StringExtractorGDBRemote & packet)1003 GDBRemoteCommunicationServerCommon::Handle_QLaunchArch(
1004     StringExtractorGDBRemote &packet) {
1005   packet.SetFilePos(::strlen("QLaunchArch:"));
1006   const uint32_t bytes_left = packet.GetBytesLeft();
1007   if (bytes_left > 0) {
1008     const char *arch_triple = packet.Peek();
1009     m_process_launch_info.SetArchitecture(
1010         HostInfo::GetAugmentedArchSpec(arch_triple));
1011     return SendOKResponse();
1012   }
1013   return SendErrorResponse(13);
1014 }
1015 
1016 GDBRemoteCommunication::PacketResult
Handle_A(StringExtractorGDBRemote & packet)1017 GDBRemoteCommunicationServerCommon::Handle_A(StringExtractorGDBRemote &packet) {
1018   // The 'A' packet is the most over designed packet ever here with redundant
1019   // argument indexes, redundant argument lengths and needed hex encoded
1020   // argument string values. Really all that is needed is a comma separated hex
1021   // encoded argument value list, but we will stay true to the documented
1022   // version of the 'A' packet here...
1023 
1024   Log *log = GetLog(LLDBLog::Process);
1025   int actual_arg_index = 0;
1026 
1027   packet.SetFilePos(1); // Skip the 'A'
1028   bool success = true;
1029   while (success && packet.GetBytesLeft() > 0) {
1030     // Decode the decimal argument string length. This length is the number of
1031     // hex nibbles in the argument string value.
1032     const uint32_t arg_len = packet.GetU32(UINT32_MAX);
1033     if (arg_len == UINT32_MAX)
1034       success = false;
1035     else {
1036       // Make sure the argument hex string length is followed by a comma
1037       if (packet.GetChar() != ',')
1038         success = false;
1039       else {
1040         // Decode the argument index. We ignore this really because who would
1041         // really send down the arguments in a random order???
1042         const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
1043         if (arg_idx == UINT32_MAX)
1044           success = false;
1045         else {
1046           // Make sure the argument index is followed by a comma
1047           if (packet.GetChar() != ',')
1048             success = false;
1049           else {
1050             // Decode the argument string value from hex bytes back into a UTF8
1051             // string and make sure the length matches the one supplied in the
1052             // packet
1053             std::string arg;
1054             if (packet.GetHexByteStringFixedLength(arg, arg_len) !=
1055                 (arg_len / 2))
1056               success = false;
1057             else {
1058               // If there are any bytes left
1059               if (packet.GetBytesLeft()) {
1060                 if (packet.GetChar() != ',')
1061                   success = false;
1062               }
1063 
1064               if (success) {
1065                 if (arg_idx == 0)
1066                   m_process_launch_info.GetExecutableFile().SetFile(
1067                       arg, FileSpec::Style::native);
1068                 m_process_launch_info.GetArguments().AppendArgument(arg);
1069                 LLDB_LOGF(log, "LLGSPacketHandler::%s added arg %d: \"%s\"",
1070                           __FUNCTION__, actual_arg_index, arg.c_str());
1071                 ++actual_arg_index;
1072               }
1073             }
1074           }
1075         }
1076       }
1077     }
1078   }
1079 
1080   if (success) {
1081     m_process_launch_error = LaunchProcess();
1082     if (m_process_launch_error.Success())
1083       return SendOKResponse();
1084     LLDB_LOG(log, "failed to launch exe: {0}", m_process_launch_error);
1085   }
1086   return SendErrorResponse(8);
1087 }
1088 
1089 GDBRemoteCommunication::PacketResult
Handle_qEcho(StringExtractorGDBRemote & packet)1090 GDBRemoteCommunicationServerCommon::Handle_qEcho(
1091     StringExtractorGDBRemote &packet) {
1092   // Just echo back the exact same packet for qEcho...
1093   return SendPacketNoLock(packet.GetStringRef());
1094 }
1095 
1096 GDBRemoteCommunication::PacketResult
Handle_qModuleInfo(StringExtractorGDBRemote & packet)1097 GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
1098     StringExtractorGDBRemote &packet) {
1099   packet.SetFilePos(::strlen("qModuleInfo:"));
1100 
1101   std::string module_path;
1102   packet.GetHexByteStringTerminatedBy(module_path, ';');
1103   if (module_path.empty())
1104     return SendErrorResponse(1);
1105 
1106   if (packet.GetChar() != ';')
1107     return SendErrorResponse(2);
1108 
1109   std::string triple;
1110   packet.GetHexByteString(triple);
1111 
1112   ModuleSpec matched_module_spec = GetModuleInfo(module_path, triple);
1113   if (!matched_module_spec.GetFileSpec())
1114     return SendErrorResponse(3);
1115 
1116   const auto file_offset = matched_module_spec.GetObjectOffset();
1117   const auto file_size = matched_module_spec.GetObjectSize();
1118   const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1119 
1120   StreamGDBRemote response;
1121 
1122   if (uuid_str.empty()) {
1123     auto Result = llvm::sys::fs::md5_contents(
1124         matched_module_spec.GetFileSpec().GetPath());
1125     if (!Result)
1126       return SendErrorResponse(5);
1127     response.PutCString("md5:");
1128     response.PutStringAsRawHex8(Result->digest());
1129   } else {
1130     response.PutCString("uuid:");
1131     response.PutStringAsRawHex8(uuid_str);
1132   }
1133   response.PutChar(';');
1134 
1135   const auto &module_arch = matched_module_spec.GetArchitecture();
1136   response.PutCString("triple:");
1137   response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
1138   response.PutChar(';');
1139 
1140   response.PutCString("file_path:");
1141   response.PutStringAsRawHex8(matched_module_spec.GetFileSpec().GetCString());
1142   response.PutChar(';');
1143   response.PutCString("file_offset:");
1144   response.PutHex64(file_offset);
1145   response.PutChar(';');
1146   response.PutCString("file_size:");
1147   response.PutHex64(file_size);
1148   response.PutChar(';');
1149 
1150   return SendPacketNoLock(response.GetString());
1151 }
1152 
1153 GDBRemoteCommunication::PacketResult
Handle_jModulesInfo(StringExtractorGDBRemote & packet)1154 GDBRemoteCommunicationServerCommon::Handle_jModulesInfo(
1155     StringExtractorGDBRemote &packet) {
1156   namespace json = llvm::json;
1157 
1158   packet.SetFilePos(::strlen("jModulesInfo:"));
1159 
1160   StructuredData::ObjectSP object_sp = StructuredData::ParseJSON(packet.Peek());
1161   if (!object_sp)
1162     return SendErrorResponse(1);
1163 
1164   StructuredData::Array *packet_array = object_sp->GetAsArray();
1165   if (!packet_array)
1166     return SendErrorResponse(2);
1167 
1168   json::Array response_array;
1169   for (size_t i = 0; i < packet_array->GetSize(); ++i) {
1170     StructuredData::Dictionary *query =
1171         packet_array->GetItemAtIndex(i)->GetAsDictionary();
1172     if (!query)
1173       continue;
1174     llvm::StringRef file, triple;
1175     if (!query->GetValueForKeyAsString("file", file) ||
1176         !query->GetValueForKeyAsString("triple", triple))
1177       continue;
1178 
1179     ModuleSpec matched_module_spec = GetModuleInfo(file, triple);
1180     if (!matched_module_spec.GetFileSpec())
1181       continue;
1182 
1183     const auto file_offset = matched_module_spec.GetObjectOffset();
1184     const auto file_size = matched_module_spec.GetObjectSize();
1185     const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1186     if (uuid_str.empty())
1187       continue;
1188     const auto triple_str =
1189         matched_module_spec.GetArchitecture().GetTriple().getTriple();
1190     const auto file_path = matched_module_spec.GetFileSpec().GetPath();
1191 
1192     json::Object response{{"uuid", uuid_str},
1193                           {"triple", triple_str},
1194                           {"file_path", file_path},
1195                           {"file_offset", static_cast<int64_t>(file_offset)},
1196                           {"file_size", static_cast<int64_t>(file_size)}};
1197     response_array.push_back(std::move(response));
1198   }
1199 
1200   StreamString response;
1201   response.AsRawOstream() << std::move(response_array);
1202   StreamGDBRemote escaped_response;
1203   escaped_response.PutEscapedBytes(response.GetString().data(),
1204                                    response.GetSize());
1205   return SendPacketNoLock(escaped_response.GetString());
1206 }
1207 
CreateProcessInfoResponse(const ProcessInstanceInfo & proc_info,StreamString & response)1208 void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
1209     const ProcessInstanceInfo &proc_info, StreamString &response) {
1210   response.Printf(
1211       "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
1212       proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1213       proc_info.GetUserID(), proc_info.GetGroupID(),
1214       proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
1215   response.PutCString("name:");
1216   response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetCString());
1217 
1218   response.PutChar(';');
1219   response.PutCString("args:");
1220   response.PutStringAsRawHex8(proc_info.GetArg0());
1221   for (auto &arg : proc_info.GetArguments()) {
1222     response.PutChar('-');
1223     response.PutStringAsRawHex8(arg.ref());
1224   }
1225 
1226   response.PutChar(';');
1227   const ArchSpec &proc_arch = proc_info.GetArchitecture();
1228   if (proc_arch.IsValid()) {
1229     const llvm::Triple &proc_triple = proc_arch.GetTriple();
1230     response.PutCString("triple:");
1231     response.PutStringAsRawHex8(proc_triple.getTriple());
1232     response.PutChar(';');
1233   }
1234 }
1235 
1236 void GDBRemoteCommunicationServerCommon::
CreateProcessInfoResponse_DebugServerStyle(const ProcessInstanceInfo & proc_info,StreamString & response)1237     CreateProcessInfoResponse_DebugServerStyle(
1238         const ProcessInstanceInfo &proc_info, StreamString &response) {
1239   response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64
1240                   ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
1241                   proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1242                   proc_info.GetUserID(), proc_info.GetGroupID(),
1243                   proc_info.GetEffectiveUserID(),
1244                   proc_info.GetEffectiveGroupID());
1245 
1246   const ArchSpec &proc_arch = proc_info.GetArchitecture();
1247   if (proc_arch.IsValid()) {
1248     const llvm::Triple &proc_triple = proc_arch.GetTriple();
1249 #if defined(__APPLE__)
1250     // We'll send cputype/cpusubtype.
1251     const uint32_t cpu_type = proc_arch.GetMachOCPUType();
1252     if (cpu_type != 0)
1253       response.Printf("cputype:%" PRIx32 ";", cpu_type);
1254 
1255     const uint32_t cpu_subtype = proc_arch.GetMachOCPUSubType();
1256     if (cpu_subtype != 0)
1257       response.Printf("cpusubtype:%" PRIx32 ";", cpu_subtype);
1258 
1259     const std::string vendor = proc_triple.getVendorName().str();
1260     if (!vendor.empty())
1261       response.Printf("vendor:%s;", vendor.c_str());
1262 #else
1263     // We'll send the triple.
1264     response.PutCString("triple:");
1265     response.PutStringAsRawHex8(proc_triple.getTriple());
1266     response.PutChar(';');
1267 #endif
1268     std::string ostype = std::string(proc_triple.getOSName());
1269     // Adjust so ostype reports ios for Apple/ARM and Apple/ARM64.
1270     if (proc_triple.getVendor() == llvm::Triple::Apple) {
1271       switch (proc_triple.getArch()) {
1272       case llvm::Triple::arm:
1273       case llvm::Triple::thumb:
1274       case llvm::Triple::aarch64:
1275       case llvm::Triple::aarch64_32:
1276         ostype = "ios";
1277         break;
1278       default:
1279         // No change.
1280         break;
1281       }
1282     }
1283     response.Printf("ostype:%s;", ostype.c_str());
1284 
1285     switch (proc_arch.GetByteOrder()) {
1286     case lldb::eByteOrderLittle:
1287       response.PutCString("endian:little;");
1288       break;
1289     case lldb::eByteOrderBig:
1290       response.PutCString("endian:big;");
1291       break;
1292     case lldb::eByteOrderPDP:
1293       response.PutCString("endian:pdp;");
1294       break;
1295     default:
1296       // Nothing.
1297       break;
1298     }
1299     // In case of MIPS64, pointer size is depend on ELF ABI For N32 the pointer
1300     // size is 4 and for N64 it is 8
1301     std::string abi = proc_arch.GetTargetABI();
1302     if (!abi.empty())
1303       response.Printf("elf_abi:%s;", abi.c_str());
1304     response.Printf("ptrsize:%d;", proc_arch.GetAddressByteSize());
1305   }
1306 }
1307 
FindModuleFile(const std::string & module_path,const ArchSpec & arch)1308 FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
1309     const std::string &module_path, const ArchSpec &arch) {
1310 #ifdef __ANDROID__
1311   return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
1312 #else
1313   FileSpec file_spec(module_path);
1314   FileSystem::Instance().Resolve(file_spec);
1315   return file_spec;
1316 #endif
1317 }
1318 
1319 ModuleSpec
GetModuleInfo(llvm::StringRef module_path,llvm::StringRef triple)1320 GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
1321                                                   llvm::StringRef triple) {
1322   ArchSpec arch(triple);
1323 
1324   FileSpec req_module_path_spec(module_path);
1325   FileSystem::Instance().Resolve(req_module_path_spec);
1326 
1327   const FileSpec module_path_spec =
1328       FindModuleFile(req_module_path_spec.GetPath(), arch);
1329   const ModuleSpec module_spec(module_path_spec, arch);
1330 
1331   ModuleSpecList module_specs;
1332   if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
1333                                            module_specs))
1334     return ModuleSpec();
1335 
1336   ModuleSpec matched_module_spec;
1337   if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
1338     return ModuleSpec();
1339 
1340   return matched_module_spec;
1341 }
1342 
HandleFeatures(const llvm::ArrayRef<llvm::StringRef> client_features)1343 std::vector<std::string> GDBRemoteCommunicationServerCommon::HandleFeatures(
1344     const llvm::ArrayRef<llvm::StringRef> client_features) {
1345   // 128KBytes is a reasonable max packet size--debugger can always use less.
1346   constexpr uint32_t max_packet_size = 128 * 1024;
1347 
1348   // Features common to platform server and llgs.
1349   return {
1350       llvm::formatv("PacketSize={0}", max_packet_size),
1351       "QStartNoAckMode+",
1352       "qEcho+",
1353       "native-signals+",
1354   };
1355 }
1356