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