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