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#include <optional>
20
21#include "lldb/Core/ModuleSpec.h"
22#include "lldb/Host/Config.h"
23#include "lldb/Host/File.h"
24#include "lldb/Host/FileAction.h"
25#include "lldb/Host/FileSystem.h"
26#include "lldb/Host/Host.h"
27#include "lldb/Host/HostInfo.h"
28#include "lldb/Host/SafeMachO.h"
29#include "lldb/Interpreter/OptionArgParser.h"
30#include "lldb/Symbol/ObjectFile.h"
31#include "lldb/Target/Platform.h"
32#include "lldb/Utility/Endian.h"
33#include "lldb/Utility/GDBRemote.h"
34#include "lldb/Utility/LLDBLog.h"
35#include "lldb/Utility/Log.h"
36#include "lldb/Utility/StreamString.h"
37#include "lldb/Utility/StructuredData.h"
38#include "llvm/ADT/StringSwitch.h"
39#include "llvm/Support/JSON.h"
40#include "llvm/TargetParser/Triple.h"
41
42#include "ProcessGDBRemoteLog.h"
43#include "lldb/Utility/StringExtractorGDBRemote.h"
44
45#ifdef __ANDROID__
46#include "lldb/Host/android/HostInfoAndroid.h"
47#include "lldb/Host/common/ZipFileResolver.h"
48#endif
49
50using namespace lldb;
51using namespace lldb_private::process_gdb_remote;
52using namespace lldb_private;
53
54#ifdef __ANDROID__
55const static uint32_t g_default_packet_timeout_sec = 20; // seconds
56#else
57const static uint32_t g_default_packet_timeout_sec = 0; // not specified
58#endif
59
60// GDBRemoteCommunicationServerCommon constructor
61GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon()
62    : GDBRemoteCommunicationServer(), m_process_launch_info(),
63      m_process_launch_error(), m_proc_infos(), 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
174GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() =
175    default;
176
177GDBRemoteCommunication::PacketResult
178GDBRemoteCommunicationServerCommon::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  llvm::StringRef distribution_id = HostInfo::GetDistributionId();
191  if (!distribution_id.empty()) {
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  if (std::optional<std::string> s = HostInfo::GetOSBuildString()) {
271    response.PutCString("os_build:");
272    response.PutStringAsRawHex8(*s);
273    response.PutChar(';');
274  }
275  if (std::optional<std::string> s = HostInfo::GetOSKernelDescription()) {
276    response.PutCString("os_kernel:");
277    response.PutStringAsRawHex8(*s);
278    response.PutChar(';');
279  }
280
281  std::string s;
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  // coverity[unsigned_compare]
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
313GDBRemoteCommunication::PacketResult
314GDBRemoteCommunicationServerCommon::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
330GDBRemoteCommunication::PacketResult
331GDBRemoteCommunicationServerCommon::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
413GDBRemoteCommunication::PacketResult
414GDBRemoteCommunicationServerCommon::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
425GDBRemoteCommunication::PacketResult
426GDBRemoteCommunicationServerCommon::Handle_qUserName(
427    StringExtractorGDBRemote &packet) {
428#if LLDB_ENABLE_POSIX
429  Log *log = GetLog(LLDBLog::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 (std::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
448GDBRemoteCommunication::PacketResult
449GDBRemoteCommunicationServerCommon::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 (std::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
467GDBRemoteCommunication::PacketResult
468GDBRemoteCommunicationServerCommon::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
499GDBRemoteCommunication::PacketResult
500GDBRemoteCommunicationServerCommon::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
537static GDBErrno system_errno_to_gdb(int err) {
538  switch (err) {
539#define HANDLE_ERRNO(name, value)                                              \
540  case name:                                                                   \
541    return GDB_##name;
542#include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
543  default:
544    return GDB_EUNKNOWN;
545  }
546}
547
548GDBRemoteCommunication::PacketResult
549GDBRemoteCommunicationServerCommon::Handle_vFile_Close(
550    StringExtractorGDBRemote &packet) {
551  packet.SetFilePos(::strlen("vFile:close:"));
552  int fd = packet.GetS32(-1, 16);
553  int err = -1;
554  int save_errno = 0;
555  if (fd >= 0) {
556    NativeFile file(fd, File::OpenOptions(0), true);
557    Status error = file.Close();
558    err = 0;
559    save_errno = error.GetError();
560  } else {
561    save_errno = EINVAL;
562  }
563  StreamString response;
564  response.PutChar('F');
565  response.Printf("%x", err);
566  if (save_errno)
567    response.Printf(",%x", system_errno_to_gdb(save_errno));
568  return SendPacketNoLock(response.GetString());
569}
570
571GDBRemoteCommunication::PacketResult
572GDBRemoteCommunicationServerCommon::Handle_vFile_pRead(
573    StringExtractorGDBRemote &packet) {
574  StreamGDBRemote response;
575  packet.SetFilePos(::strlen("vFile:pread:"));
576  int fd = packet.GetS32(-1, 16);
577  if (packet.GetChar() == ',') {
578    size_t count = packet.GetHexMaxU64(false, SIZE_MAX);
579    if (packet.GetChar() == ',') {
580      off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
581      if (count == SIZE_MAX) {
582        response.Printf("F-1:%x", EINVAL);
583        return SendPacketNoLock(response.GetString());
584      }
585
586      std::string buffer(count, 0);
587      NativeFile file(fd, File::eOpenOptionReadOnly, false);
588      Status error = file.Read(static_cast<void *>(&buffer[0]), count, offset);
589      const int save_errno = error.GetError();
590      response.PutChar('F');
591      if (error.Success()) {
592        response.Printf("%zx", count);
593        response.PutChar(';');
594        response.PutEscapedBytes(&buffer[0], count);
595      } else {
596        response.PutCString("-1");
597        if (save_errno)
598          response.Printf(",%x", system_errno_to_gdb(save_errno));
599      }
600      return SendPacketNoLock(response.GetString());
601    }
602  }
603  return SendErrorResponse(21);
604}
605
606GDBRemoteCommunication::PacketResult
607GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite(
608    StringExtractorGDBRemote &packet) {
609  packet.SetFilePos(::strlen("vFile:pwrite:"));
610
611  StreamGDBRemote response;
612  response.PutChar('F');
613
614  int fd = packet.GetS32(-1, 16);
615  if (packet.GetChar() == ',') {
616    off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
617    if (packet.GetChar() == ',') {
618      std::string buffer;
619      if (packet.GetEscapedBinaryData(buffer)) {
620        NativeFile file(fd, File::eOpenOptionWriteOnly, false);
621        size_t count = buffer.size();
622        Status error =
623            file.Write(static_cast<const void *>(&buffer[0]), count, offset);
624        const int save_errno = error.GetError();
625        if (error.Success())
626          response.Printf("%zx", count);
627        else {
628          response.PutCString("-1");
629          if (save_errno)
630            response.Printf(",%x", system_errno_to_gdb(save_errno));
631        }
632      } else {
633        response.Printf("-1,%x", EINVAL);
634      }
635      return SendPacketNoLock(response.GetString());
636    }
637  }
638  return SendErrorResponse(27);
639}
640
641GDBRemoteCommunication::PacketResult
642GDBRemoteCommunicationServerCommon::Handle_vFile_Size(
643    StringExtractorGDBRemote &packet) {
644  packet.SetFilePos(::strlen("vFile:size:"));
645  std::string path;
646  packet.GetHexByteString(path);
647  if (!path.empty()) {
648    uint64_t Size;
649    if (llvm::sys::fs::file_size(path, Size))
650      return SendErrorResponse(5);
651    StreamString response;
652    response.PutChar('F');
653    response.PutHex64(Size);
654    if (Size == UINT64_MAX) {
655      response.PutChar(',');
656      response.PutHex64(Size); // TODO: replace with Host::GetSyswideErrorCode()
657    }
658    return SendPacketNoLock(response.GetString());
659  }
660  return SendErrorResponse(22);
661}
662
663GDBRemoteCommunication::PacketResult
664GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(
665    StringExtractorGDBRemote &packet) {
666  packet.SetFilePos(::strlen("vFile:mode:"));
667  std::string path;
668  packet.GetHexByteString(path);
669  if (!path.empty()) {
670    FileSpec file_spec(path);
671    FileSystem::Instance().Resolve(file_spec);
672    std::error_code ec;
673    const uint32_t mode = FileSystem::Instance().GetPermissions(file_spec, ec);
674    StreamString response;
675    if (mode != llvm::sys::fs::perms_not_known)
676      response.Printf("F%x", mode);
677    else
678      response.Printf("F-1,%x", (int)Status(ec).GetError());
679    return SendPacketNoLock(response.GetString());
680  }
681  return SendErrorResponse(23);
682}
683
684GDBRemoteCommunication::PacketResult
685GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
686    StringExtractorGDBRemote &packet) {
687  packet.SetFilePos(::strlen("vFile:exists:"));
688  std::string path;
689  packet.GetHexByteString(path);
690  if (!path.empty()) {
691    bool retcode = llvm::sys::fs::exists(path);
692    StreamString response;
693    response.PutChar('F');
694    response.PutChar(',');
695    if (retcode)
696      response.PutChar('1');
697    else
698      response.PutChar('0');
699    return SendPacketNoLock(response.GetString());
700  }
701  return SendErrorResponse(24);
702}
703
704GDBRemoteCommunication::PacketResult
705GDBRemoteCommunicationServerCommon::Handle_vFile_symlink(
706    StringExtractorGDBRemote &packet) {
707  packet.SetFilePos(::strlen("vFile:symlink:"));
708  std::string dst, src;
709  packet.GetHexByteStringTerminatedBy(dst, ',');
710  packet.GetChar(); // Skip ',' char
711  packet.GetHexByteString(src);
712
713  FileSpec src_spec(src);
714  FileSystem::Instance().Resolve(src_spec);
715  Status error = FileSystem::Instance().Symlink(src_spec, FileSpec(dst));
716
717  StreamString response;
718  response.Printf("F%x,%x", error.GetError(), error.GetError());
719  return SendPacketNoLock(response.GetString());
720}
721
722GDBRemoteCommunication::PacketResult
723GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
724    StringExtractorGDBRemote &packet) {
725  packet.SetFilePos(::strlen("vFile:unlink:"));
726  std::string path;
727  packet.GetHexByteString(path);
728  Status error(llvm::sys::fs::remove(path));
729  StreamString response;
730  response.Printf("F%x,%x", error.GetError(), error.GetError());
731  return SendPacketNoLock(response.GetString());
732}
733
734GDBRemoteCommunication::PacketResult
735GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
736    StringExtractorGDBRemote &packet) {
737  packet.SetFilePos(::strlen("qPlatform_shell:"));
738  std::string path;
739  std::string working_dir;
740  packet.GetHexByteStringTerminatedBy(path, ',');
741  if (!path.empty()) {
742    if (packet.GetChar() == ',') {
743      // FIXME: add timeout to qPlatform_shell packet
744      // uint32_t timeout = packet.GetHexMaxU32(false, 32);
745      if (packet.GetChar() == ',')
746        packet.GetHexByteString(working_dir);
747      int status, signo;
748      std::string output;
749      FileSpec working_spec(working_dir);
750      FileSystem::Instance().Resolve(working_spec);
751      Status err =
752          Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
753                                &output, std::chrono::seconds(10));
754      StreamGDBRemote response;
755      if (err.Fail()) {
756        response.PutCString("F,");
757        response.PutHex32(UINT32_MAX);
758      } else {
759        response.PutCString("F,");
760        response.PutHex32(status);
761        response.PutChar(',');
762        response.PutHex32(signo);
763        response.PutChar(',');
764        response.PutEscapedBytes(output.c_str(), output.size());
765      }
766      return SendPacketNoLock(response.GetString());
767    }
768  }
769  return SendErrorResponse(24);
770}
771
772template <typename T, typename U>
773static void fill_clamp(T &dest, U src, typename T::value_type fallback) {
774  static_assert(std::is_unsigned<typename T::value_type>::value,
775                "Destination type must be unsigned.");
776  using UU = std::make_unsigned_t<U>;
777  constexpr auto T_max = std::numeric_limits<typename T::value_type>::max();
778  dest = src >= 0 && static_cast<UU>(src) <= T_max ? src : fallback;
779}
780
781GDBRemoteCommunication::PacketResult
782GDBRemoteCommunicationServerCommon::Handle_vFile_FStat(
783    StringExtractorGDBRemote &packet) {
784  StreamGDBRemote response;
785  packet.SetFilePos(::strlen("vFile:fstat:"));
786  int fd = packet.GetS32(-1, 16);
787
788  struct stat file_stats;
789  if (::fstat(fd, &file_stats) == -1) {
790    const int save_errno = errno;
791    response.Printf("F-1,%x", system_errno_to_gdb(save_errno));
792    return SendPacketNoLock(response.GetString());
793  }
794
795  GDBRemoteFStatData data;
796  fill_clamp(data.gdb_st_dev, file_stats.st_dev, 0);
797  fill_clamp(data.gdb_st_ino, file_stats.st_ino, 0);
798  data.gdb_st_mode = file_stats.st_mode;
799  fill_clamp(data.gdb_st_nlink, file_stats.st_nlink, UINT32_MAX);
800  fill_clamp(data.gdb_st_uid, file_stats.st_uid, 0);
801  fill_clamp(data.gdb_st_gid, file_stats.st_gid, 0);
802  fill_clamp(data.gdb_st_rdev, file_stats.st_rdev, 0);
803  data.gdb_st_size = file_stats.st_size;
804#if !defined(_WIN32)
805  data.gdb_st_blksize = file_stats.st_blksize;
806  data.gdb_st_blocks = file_stats.st_blocks;
807#else
808  data.gdb_st_blksize = 0;
809  data.gdb_st_blocks = 0;
810#endif
811  fill_clamp(data.gdb_st_atime, file_stats.st_atime, 0);
812  fill_clamp(data.gdb_st_mtime, file_stats.st_mtime, 0);
813  fill_clamp(data.gdb_st_ctime, file_stats.st_ctime, 0);
814
815  response.Printf("F%zx;", sizeof(data));
816  response.PutEscapedBytes(&data, sizeof(data));
817  return SendPacketNoLock(response.GetString());
818}
819
820GDBRemoteCommunication::PacketResult
821GDBRemoteCommunicationServerCommon::Handle_vFile_Stat(
822    StringExtractorGDBRemote &packet) {
823  return SendUnimplementedResponse(
824      "GDBRemoteCommunicationServerCommon::Handle_vFile_Stat() unimplemented");
825}
826
827GDBRemoteCommunication::PacketResult
828GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
829    StringExtractorGDBRemote &packet) {
830  packet.SetFilePos(::strlen("vFile:MD5:"));
831  std::string path;
832  packet.GetHexByteString(path);
833  if (!path.empty()) {
834    StreamGDBRemote response;
835    auto Result = llvm::sys::fs::md5_contents(path);
836    if (!Result) {
837      response.PutCString("F,");
838      response.PutCString("x");
839    } else {
840      response.PutCString("F,");
841      response.PutHex64(Result->low());
842      response.PutHex64(Result->high());
843    }
844    return SendPacketNoLock(response.GetString());
845  }
846  return SendErrorResponse(25);
847}
848
849GDBRemoteCommunication::PacketResult
850GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir(
851    StringExtractorGDBRemote &packet) {
852  packet.SetFilePos(::strlen("qPlatform_mkdir:"));
853  mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
854  if (packet.GetChar() == ',') {
855    std::string path;
856    packet.GetHexByteString(path);
857    Status error(llvm::sys::fs::create_directory(path, mode));
858
859    StreamGDBRemote response;
860    response.Printf("F%x", error.GetError());
861
862    return SendPacketNoLock(response.GetString());
863  }
864  return SendErrorResponse(20);
865}
866
867GDBRemoteCommunication::PacketResult
868GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod(
869    StringExtractorGDBRemote &packet) {
870  packet.SetFilePos(::strlen("qPlatform_chmod:"));
871
872  auto perms =
873      static_cast<llvm::sys::fs::perms>(packet.GetHexMaxU32(false, UINT32_MAX));
874  if (packet.GetChar() == ',') {
875    std::string path;
876    packet.GetHexByteString(path);
877    Status error(llvm::sys::fs::setPermissions(path, perms));
878
879    StreamGDBRemote response;
880    response.Printf("F%x", error.GetError());
881
882    return SendPacketNoLock(response.GetString());
883  }
884  return SendErrorResponse(19);
885}
886
887GDBRemoteCommunication::PacketResult
888GDBRemoteCommunicationServerCommon::Handle_qSupported(
889    StringExtractorGDBRemote &packet) {
890  // Parse client-indicated features.
891  llvm::SmallVector<llvm::StringRef, 4> client_features;
892  packet.GetStringRef().split(client_features, ';');
893  return SendPacketNoLock(llvm::join(HandleFeatures(client_features), ";"));
894}
895
896GDBRemoteCommunication::PacketResult
897GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError(
898    StringExtractorGDBRemote &packet) {
899  packet.SetFilePos(::strlen("QSetDetachOnError:"));
900  if (packet.GetU32(0))
901    m_process_launch_info.GetFlags().Set(eLaunchFlagDetachOnError);
902  else
903    m_process_launch_info.GetFlags().Clear(eLaunchFlagDetachOnError);
904  return SendOKResponse();
905}
906
907GDBRemoteCommunication::PacketResult
908GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode(
909    StringExtractorGDBRemote &packet) {
910  // Send response first before changing m_send_acks to we ack this packet
911  PacketResult packet_result = SendOKResponse();
912  m_send_acks = false;
913  return packet_result;
914}
915
916GDBRemoteCommunication::PacketResult
917GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN(
918    StringExtractorGDBRemote &packet) {
919  packet.SetFilePos(::strlen("QSetSTDIN:"));
920  FileAction file_action;
921  std::string path;
922  packet.GetHexByteString(path);
923  const bool read = true;
924  const bool write = false;
925  if (file_action.Open(STDIN_FILENO, FileSpec(path), read, write)) {
926    m_process_launch_info.AppendFileAction(file_action);
927    return SendOKResponse();
928  }
929  return SendErrorResponse(15);
930}
931
932GDBRemoteCommunication::PacketResult
933GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT(
934    StringExtractorGDBRemote &packet) {
935  packet.SetFilePos(::strlen("QSetSTDOUT:"));
936  FileAction file_action;
937  std::string path;
938  packet.GetHexByteString(path);
939  const bool read = false;
940  const bool write = true;
941  if (file_action.Open(STDOUT_FILENO, FileSpec(path), read, write)) {
942    m_process_launch_info.AppendFileAction(file_action);
943    return SendOKResponse();
944  }
945  return SendErrorResponse(16);
946}
947
948GDBRemoteCommunication::PacketResult
949GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR(
950    StringExtractorGDBRemote &packet) {
951  packet.SetFilePos(::strlen("QSetSTDERR:"));
952  FileAction file_action;
953  std::string path;
954  packet.GetHexByteString(path);
955  const bool read = false;
956  const bool write = true;
957  if (file_action.Open(STDERR_FILENO, FileSpec(path), read, write)) {
958    m_process_launch_info.AppendFileAction(file_action);
959    return SendOKResponse();
960  }
961  return SendErrorResponse(17);
962}
963
964GDBRemoteCommunication::PacketResult
965GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess(
966    StringExtractorGDBRemote &packet) {
967  if (m_process_launch_error.Success())
968    return SendOKResponse();
969  StreamString response;
970  response.PutChar('E');
971  response.PutCString(m_process_launch_error.AsCString("<unknown error>"));
972  return SendPacketNoLock(response.GetString());
973}
974
975GDBRemoteCommunication::PacketResult
976GDBRemoteCommunicationServerCommon::Handle_QEnvironment(
977    StringExtractorGDBRemote &packet) {
978  packet.SetFilePos(::strlen("QEnvironment:"));
979  const uint32_t bytes_left = packet.GetBytesLeft();
980  if (bytes_left > 0) {
981    m_process_launch_info.GetEnvironment().insert(packet.Peek());
982    return SendOKResponse();
983  }
984  return SendErrorResponse(12);
985}
986
987GDBRemoteCommunication::PacketResult
988GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded(
989    StringExtractorGDBRemote &packet) {
990  packet.SetFilePos(::strlen("QEnvironmentHexEncoded:"));
991  const uint32_t bytes_left = packet.GetBytesLeft();
992  if (bytes_left > 0) {
993    std::string str;
994    packet.GetHexByteString(str);
995    m_process_launch_info.GetEnvironment().insert(str);
996    return SendOKResponse();
997  }
998  return SendErrorResponse(12);
999}
1000
1001GDBRemoteCommunication::PacketResult
1002GDBRemoteCommunicationServerCommon::Handle_QLaunchArch(
1003    StringExtractorGDBRemote &packet) {
1004  packet.SetFilePos(::strlen("QLaunchArch:"));
1005  const uint32_t bytes_left = packet.GetBytesLeft();
1006  if (bytes_left > 0) {
1007    const char *arch_triple = packet.Peek();
1008    m_process_launch_info.SetArchitecture(
1009        HostInfo::GetAugmentedArchSpec(arch_triple));
1010    return SendOKResponse();
1011  }
1012  return SendErrorResponse(13);
1013}
1014
1015GDBRemoteCommunication::PacketResult
1016GDBRemoteCommunicationServerCommon::Handle_A(StringExtractorGDBRemote &packet) {
1017  // The 'A' packet is the most over designed packet ever here with redundant
1018  // argument indexes, redundant argument lengths and needed hex encoded
1019  // argument string values. Really all that is needed is a comma separated hex
1020  // encoded argument value list, but we will stay true to the documented
1021  // version of the 'A' packet here...
1022
1023  Log *log = GetLog(LLDBLog::Process);
1024  int actual_arg_index = 0;
1025
1026  packet.SetFilePos(1); // Skip the 'A'
1027  bool success = true;
1028  while (success && packet.GetBytesLeft() > 0) {
1029    // Decode the decimal argument string length. This length is the number of
1030    // hex nibbles in the argument string value.
1031    const uint32_t arg_len = packet.GetU32(UINT32_MAX);
1032    if (arg_len == UINT32_MAX)
1033      success = false;
1034    else {
1035      // Make sure the argument hex string length is followed by a comma
1036      if (packet.GetChar() != ',')
1037        success = false;
1038      else {
1039        // Decode the argument index. We ignore this really because who would
1040        // really send down the arguments in a random order???
1041        const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
1042        if (arg_idx == UINT32_MAX)
1043          success = false;
1044        else {
1045          // Make sure the argument index is followed by a comma
1046          if (packet.GetChar() != ',')
1047            success = false;
1048          else {
1049            // Decode the argument string value from hex bytes back into a UTF8
1050            // string and make sure the length matches the one supplied in the
1051            // packet
1052            std::string arg;
1053            if (packet.GetHexByteStringFixedLength(arg, arg_len) !=
1054                (arg_len / 2))
1055              success = false;
1056            else {
1057              // If there are any bytes left
1058              if (packet.GetBytesLeft()) {
1059                if (packet.GetChar() != ',')
1060                  success = false;
1061              }
1062
1063              if (success) {
1064                if (arg_idx == 0)
1065                  m_process_launch_info.GetExecutableFile().SetFile(
1066                      arg, FileSpec::Style::native);
1067                m_process_launch_info.GetArguments().AppendArgument(arg);
1068                LLDB_LOGF(log, "LLGSPacketHandler::%s added arg %d: \"%s\"",
1069                          __FUNCTION__, actual_arg_index, arg.c_str());
1070                ++actual_arg_index;
1071              }
1072            }
1073          }
1074        }
1075      }
1076    }
1077  }
1078
1079  if (success) {
1080    m_process_launch_error = LaunchProcess();
1081    if (m_process_launch_error.Success())
1082      return SendOKResponse();
1083    LLDB_LOG(log, "failed to launch exe: {0}", m_process_launch_error);
1084  }
1085  return SendErrorResponse(8);
1086}
1087
1088GDBRemoteCommunication::PacketResult
1089GDBRemoteCommunicationServerCommon::Handle_qEcho(
1090    StringExtractorGDBRemote &packet) {
1091  // Just echo back the exact same packet for qEcho...
1092  return SendPacketNoLock(packet.GetStringRef());
1093}
1094
1095GDBRemoteCommunication::PacketResult
1096GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
1097    StringExtractorGDBRemote &packet) {
1098  packet.SetFilePos(::strlen("qModuleInfo:"));
1099
1100  std::string module_path;
1101  packet.GetHexByteStringTerminatedBy(module_path, ';');
1102  if (module_path.empty())
1103    return SendErrorResponse(1);
1104
1105  if (packet.GetChar() != ';')
1106    return SendErrorResponse(2);
1107
1108  std::string triple;
1109  packet.GetHexByteString(triple);
1110
1111  ModuleSpec matched_module_spec = GetModuleInfo(module_path, triple);
1112  if (!matched_module_spec.GetFileSpec())
1113    return SendErrorResponse(3);
1114
1115  const auto file_offset = matched_module_spec.GetObjectOffset();
1116  const auto file_size = matched_module_spec.GetObjectSize();
1117  const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1118
1119  StreamGDBRemote response;
1120
1121  if (uuid_str.empty()) {
1122    auto Result = llvm::sys::fs::md5_contents(
1123        matched_module_spec.GetFileSpec().GetPath());
1124    if (!Result)
1125      return SendErrorResponse(5);
1126    response.PutCString("md5:");
1127    response.PutStringAsRawHex8(Result->digest());
1128  } else {
1129    response.PutCString("uuid:");
1130    response.PutStringAsRawHex8(uuid_str);
1131  }
1132  response.PutChar(';');
1133
1134  const auto &module_arch = matched_module_spec.GetArchitecture();
1135  response.PutCString("triple:");
1136  response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
1137  response.PutChar(';');
1138
1139  response.PutCString("file_path:");
1140  response.PutStringAsRawHex8(
1141      matched_module_spec.GetFileSpec().GetPath().c_str());
1142  response.PutChar(';');
1143  response.PutCString("file_offset:");
1144  response.PutHex64(file_offset);
1145  response.PutChar(';');
1146  response.PutCString("file_size:");
1147  response.PutHex64(file_size);
1148  response.PutChar(';');
1149
1150  return SendPacketNoLock(response.GetString());
1151}
1152
1153GDBRemoteCommunication::PacketResult
1154GDBRemoteCommunicationServerCommon::Handle_jModulesInfo(
1155    StringExtractorGDBRemote &packet) {
1156  namespace json = llvm::json;
1157
1158  packet.SetFilePos(::strlen("jModulesInfo:"));
1159
1160  StructuredData::ObjectSP object_sp = StructuredData::ParseJSON(packet.Peek());
1161  if (!object_sp)
1162    return SendErrorResponse(1);
1163
1164  StructuredData::Array *packet_array = object_sp->GetAsArray();
1165  if (!packet_array)
1166    return SendErrorResponse(2);
1167
1168  json::Array response_array;
1169  for (size_t i = 0; i < packet_array->GetSize(); ++i) {
1170    StructuredData::Dictionary *query =
1171        packet_array->GetItemAtIndex(i)->GetAsDictionary();
1172    if (!query)
1173      continue;
1174    llvm::StringRef file, triple;
1175    if (!query->GetValueForKeyAsString("file", file) ||
1176        !query->GetValueForKeyAsString("triple", triple))
1177      continue;
1178
1179    ModuleSpec matched_module_spec = GetModuleInfo(file, triple);
1180    if (!matched_module_spec.GetFileSpec())
1181      continue;
1182
1183    const auto file_offset = matched_module_spec.GetObjectOffset();
1184    const auto file_size = matched_module_spec.GetObjectSize();
1185    const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1186    if (uuid_str.empty())
1187      continue;
1188    const auto triple_str =
1189        matched_module_spec.GetArchitecture().GetTriple().getTriple();
1190    const auto file_path = matched_module_spec.GetFileSpec().GetPath();
1191
1192    json::Object response{{"uuid", uuid_str},
1193                          {"triple", triple_str},
1194                          {"file_path", file_path},
1195                          {"file_offset", static_cast<int64_t>(file_offset)},
1196                          {"file_size", static_cast<int64_t>(file_size)}};
1197    response_array.push_back(std::move(response));
1198  }
1199
1200  StreamString response;
1201  response.AsRawOstream() << std::move(response_array);
1202  StreamGDBRemote escaped_response;
1203  escaped_response.PutEscapedBytes(response.GetString().data(),
1204                                   response.GetSize());
1205  return SendPacketNoLock(escaped_response.GetString());
1206}
1207
1208void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
1209    const ProcessInstanceInfo &proc_info, StreamString &response) {
1210  response.Printf(
1211      "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
1212      proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1213      proc_info.GetUserID(), proc_info.GetGroupID(),
1214      proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
1215  response.PutCString("name:");
1216  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath().c_str());
1217
1218  response.PutChar(';');
1219  response.PutCString("args:");
1220  response.PutStringAsRawHex8(proc_info.GetArg0());
1221  for (auto &arg : proc_info.GetArguments()) {
1222    response.PutChar('-');
1223    response.PutStringAsRawHex8(arg.ref());
1224  }
1225
1226  response.PutChar(';');
1227  const ArchSpec &proc_arch = proc_info.GetArchitecture();
1228  if (proc_arch.IsValid()) {
1229    const llvm::Triple &proc_triple = proc_arch.GetTriple();
1230    response.PutCString("triple:");
1231    response.PutStringAsRawHex8(proc_triple.getTriple());
1232    response.PutChar(';');
1233  }
1234}
1235
1236void GDBRemoteCommunicationServerCommon::
1237    CreateProcessInfoResponse_DebugServerStyle(
1238        const ProcessInstanceInfo &proc_info, StreamString &response) {
1239  response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64
1240                  ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
1241                  proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1242                  proc_info.GetUserID(), proc_info.GetGroupID(),
1243                  proc_info.GetEffectiveUserID(),
1244                  proc_info.GetEffectiveGroupID());
1245
1246  const ArchSpec &proc_arch = proc_info.GetArchitecture();
1247  if (proc_arch.IsValid()) {
1248    const llvm::Triple &proc_triple = proc_arch.GetTriple();
1249#if defined(__APPLE__)
1250    // We'll send cputype/cpusubtype.
1251    const uint32_t cpu_type = proc_arch.GetMachOCPUType();
1252    if (cpu_type != 0)
1253      response.Printf("cputype:%" PRIx32 ";", cpu_type);
1254
1255    const uint32_t cpu_subtype = proc_arch.GetMachOCPUSubType();
1256    if (cpu_subtype != 0)
1257      response.Printf("cpusubtype:%" PRIx32 ";", cpu_subtype);
1258
1259    const std::string vendor = proc_triple.getVendorName().str();
1260    if (!vendor.empty())
1261      response.Printf("vendor:%s;", vendor.c_str());
1262#else
1263    // We'll send the triple.
1264    response.PutCString("triple:");
1265    response.PutStringAsRawHex8(proc_triple.getTriple());
1266    response.PutChar(';');
1267#endif
1268    std::string ostype = std::string(proc_triple.getOSName());
1269    // Adjust so ostype reports ios for Apple/ARM and Apple/ARM64.
1270    if (proc_triple.getVendor() == llvm::Triple::Apple) {
1271      switch (proc_triple.getArch()) {
1272      case llvm::Triple::arm:
1273      case llvm::Triple::thumb:
1274      case llvm::Triple::aarch64:
1275      case llvm::Triple::aarch64_32:
1276        ostype = "ios";
1277        break;
1278      default:
1279        // No change.
1280        break;
1281      }
1282    }
1283    response.Printf("ostype:%s;", ostype.c_str());
1284
1285    switch (proc_arch.GetByteOrder()) {
1286    case lldb::eByteOrderLittle:
1287      response.PutCString("endian:little;");
1288      break;
1289    case lldb::eByteOrderBig:
1290      response.PutCString("endian:big;");
1291      break;
1292    case lldb::eByteOrderPDP:
1293      response.PutCString("endian:pdp;");
1294      break;
1295    default:
1296      // Nothing.
1297      break;
1298    }
1299    // In case of MIPS64, pointer size is depend on ELF ABI For N32 the pointer
1300    // size is 4 and for N64 it is 8
1301    std::string abi = proc_arch.GetTargetABI();
1302    if (!abi.empty())
1303      response.Printf("elf_abi:%s;", abi.c_str());
1304    response.Printf("ptrsize:%d;", proc_arch.GetAddressByteSize());
1305  }
1306}
1307
1308FileSpec GDBRemoteCommunicationServerCommon::FindModuleFile(
1309    const std::string &module_path, const ArchSpec &arch) {
1310#ifdef __ANDROID__
1311  return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
1312#else
1313  FileSpec file_spec(module_path);
1314  FileSystem::Instance().Resolve(file_spec);
1315  return file_spec;
1316#endif
1317}
1318
1319ModuleSpec
1320GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
1321                                                  llvm::StringRef triple) {
1322  ArchSpec arch(triple);
1323
1324  FileSpec req_module_path_spec(module_path);
1325  FileSystem::Instance().Resolve(req_module_path_spec);
1326
1327  const FileSpec module_path_spec =
1328      FindModuleFile(req_module_path_spec.GetPath(), arch);
1329
1330  lldb::offset_t file_offset = 0;
1331  lldb::offset_t file_size = 0;
1332#ifdef __ANDROID__
1333  // In Android API level 23 and above, dynamic loader is able to load .so file
1334  // directly from zip file. In that case, module_path will be
1335  // "zip_path!/so_path". Resolve the zip file path, .so file offset and size.
1336  ZipFileResolver::FileKind file_kind = ZipFileResolver::eFileKindInvalid;
1337  std::string file_path;
1338  if (!ZipFileResolver::ResolveSharedLibraryPath(
1339          module_path_spec, file_kind, file_path, file_offset, file_size)) {
1340    return ModuleSpec();
1341  }
1342  lldbassert(file_kind != ZipFileResolver::eFileKindInvalid);
1343  // For zip .so file, this file_path will contain only the actual zip file
1344  // path for the object file processing. Otherwise it is the same as
1345  // module_path.
1346  const FileSpec actual_module_path_spec(file_path);
1347#else
1348  // It is just module_path_spec reference for other platforms.
1349  const FileSpec &actual_module_path_spec = module_path_spec;
1350#endif
1351
1352  const ModuleSpec module_spec(actual_module_path_spec, arch);
1353
1354  ModuleSpecList module_specs;
1355  if (!ObjectFile::GetModuleSpecifications(actual_module_path_spec, file_offset,
1356                                           file_size, module_specs))
1357    return ModuleSpec();
1358
1359  ModuleSpec matched_module_spec;
1360  if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
1361    return ModuleSpec();
1362
1363#ifdef __ANDROID__
1364  if (file_kind == ZipFileResolver::eFileKindZip) {
1365    // For zip .so file, matched_module_spec contains only the actual zip file
1366    // path for the object file processing. Overwrite the matched_module_spec
1367    // file spec with the original module_path_spec to pass "zip_path!/so_path"
1368    // through to PlatformAndroid::DownloadModuleSlice.
1369    *matched_module_spec.GetFileSpecPtr() = module_path_spec;
1370  }
1371#endif
1372
1373  return matched_module_spec;
1374}
1375
1376std::vector<std::string> GDBRemoteCommunicationServerCommon::HandleFeatures(
1377    const llvm::ArrayRef<llvm::StringRef> client_features) {
1378  // 128KBytes is a reasonable max packet size--debugger can always use less.
1379  constexpr uint32_t max_packet_size = 128 * 1024;
1380
1381  // Features common to platform server and llgs.
1382  return {
1383      llvm::formatv("PacketSize={0}", max_packet_size),
1384      "QStartNoAckMode+",
1385      "qEcho+",
1386      "native-signals+",
1387  };
1388}
1389