1 //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBPlatform.h"
11 #include "lldb/API/SBError.h"
12 #include "lldb/API/SBFileSpec.h"
13 #include "lldb/API/SBLaunchInfo.h"
14 #include "lldb/API/SBUnixSignals.h"
15 #include "lldb/Core/ArchSpec.h"
16 #include "lldb/Core/Error.h"
17 #include "lldb/Host/File.h"
18 #include "lldb/Interpreter/Args.h"
19 #include "lldb/Target/Platform.h"
20 #include "lldb/Target/Target.h"
21 
22 #include <functional>
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 //----------------------------------------------------------------------
28 // PlatformConnectOptions
29 //----------------------------------------------------------------------
30 struct PlatformConnectOptions {
31   PlatformConnectOptions(const char *url = NULL)
32       : m_url(), m_rsync_options(), m_rsync_remote_path_prefix(),
33         m_rsync_enabled(false), m_rsync_omit_hostname_from_remote_path(false),
34         m_local_cache_directory() {
35     if (url && url[0])
36       m_url = url;
37   }
38 
39   ~PlatformConnectOptions() {}
40 
41   std::string m_url;
42   std::string m_rsync_options;
43   std::string m_rsync_remote_path_prefix;
44   bool m_rsync_enabled;
45   bool m_rsync_omit_hostname_from_remote_path;
46   ConstString m_local_cache_directory;
47 };
48 
49 //----------------------------------------------------------------------
50 // PlatformShellCommand
51 //----------------------------------------------------------------------
52 struct PlatformShellCommand {
53   PlatformShellCommand(const char *shell_command = NULL)
54       : m_command(), m_working_dir(), m_status(0), m_signo(0),
55         m_timeout_sec(UINT32_MAX) {
56     if (shell_command && shell_command[0])
57       m_command = shell_command;
58   }
59 
60   ~PlatformShellCommand() {}
61 
62   std::string m_command;
63   std::string m_working_dir;
64   std::string m_output;
65   int m_status;
66   int m_signo;
67   uint32_t m_timeout_sec;
68 };
69 //----------------------------------------------------------------------
70 // SBPlatformConnectOptions
71 //----------------------------------------------------------------------
72 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
73     : m_opaque_ptr(new PlatformConnectOptions(url)) {}
74 
75 SBPlatformConnectOptions::SBPlatformConnectOptions(
76     const SBPlatformConnectOptions &rhs)
77     : m_opaque_ptr(new PlatformConnectOptions()) {
78   *m_opaque_ptr = *rhs.m_opaque_ptr;
79 }
80 
81 SBPlatformConnectOptions::~SBPlatformConnectOptions() { delete m_opaque_ptr; }
82 
83 void SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs) {
84   *m_opaque_ptr = *rhs.m_opaque_ptr;
85 }
86 
87 const char *SBPlatformConnectOptions::GetURL() {
88   if (m_opaque_ptr->m_url.empty())
89     return NULL;
90   return m_opaque_ptr->m_url.c_str();
91 }
92 
93 void SBPlatformConnectOptions::SetURL(const char *url) {
94   if (url && url[0])
95     m_opaque_ptr->m_url = url;
96   else
97     m_opaque_ptr->m_url.clear();
98 }
99 
100 bool SBPlatformConnectOptions::GetRsyncEnabled() {
101   return m_opaque_ptr->m_rsync_enabled;
102 }
103 
104 void SBPlatformConnectOptions::EnableRsync(
105     const char *options, const char *remote_path_prefix,
106     bool omit_hostname_from_remote_path) {
107   m_opaque_ptr->m_rsync_enabled = true;
108   m_opaque_ptr->m_rsync_omit_hostname_from_remote_path =
109       omit_hostname_from_remote_path;
110   if (remote_path_prefix && remote_path_prefix[0])
111     m_opaque_ptr->m_rsync_remote_path_prefix = remote_path_prefix;
112   else
113     m_opaque_ptr->m_rsync_remote_path_prefix.clear();
114 
115   if (options && options[0])
116     m_opaque_ptr->m_rsync_options = options;
117   else
118     m_opaque_ptr->m_rsync_options.clear();
119 }
120 
121 void SBPlatformConnectOptions::DisableRsync() {
122   m_opaque_ptr->m_rsync_enabled = false;
123 }
124 
125 const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
126   return m_opaque_ptr->m_local_cache_directory.GetCString();
127 }
128 
129 void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
130   if (path && path[0])
131     m_opaque_ptr->m_local_cache_directory.SetCString(path);
132   else
133     m_opaque_ptr->m_local_cache_directory = ConstString();
134 }
135 
136 //----------------------------------------------------------------------
137 // SBPlatformShellCommand
138 //----------------------------------------------------------------------
139 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
140     : m_opaque_ptr(new PlatformShellCommand(shell_command)) {}
141 
142 SBPlatformShellCommand::SBPlatformShellCommand(
143     const SBPlatformShellCommand &rhs)
144     : m_opaque_ptr(new PlatformShellCommand()) {
145   *m_opaque_ptr = *rhs.m_opaque_ptr;
146 }
147 
148 SBPlatformShellCommand::~SBPlatformShellCommand() { delete m_opaque_ptr; }
149 
150 void SBPlatformShellCommand::Clear() {
151   m_opaque_ptr->m_output = std::string();
152   m_opaque_ptr->m_status = 0;
153   m_opaque_ptr->m_signo = 0;
154 }
155 
156 const char *SBPlatformShellCommand::GetCommand() {
157   if (m_opaque_ptr->m_command.empty())
158     return NULL;
159   return m_opaque_ptr->m_command.c_str();
160 }
161 
162 void SBPlatformShellCommand::SetCommand(const char *shell_command) {
163   if (shell_command && shell_command[0])
164     m_opaque_ptr->m_command = shell_command;
165   else
166     m_opaque_ptr->m_command.clear();
167 }
168 
169 const char *SBPlatformShellCommand::GetWorkingDirectory() {
170   if (m_opaque_ptr->m_working_dir.empty())
171     return NULL;
172   return m_opaque_ptr->m_working_dir.c_str();
173 }
174 
175 void SBPlatformShellCommand::SetWorkingDirectory(const char *path) {
176   if (path && path[0])
177     m_opaque_ptr->m_working_dir = path;
178   else
179     m_opaque_ptr->m_working_dir.clear();
180 }
181 
182 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
183   return m_opaque_ptr->m_timeout_sec;
184 }
185 
186 void SBPlatformShellCommand::SetTimeoutSeconds(uint32_t sec) {
187   m_opaque_ptr->m_timeout_sec = sec;
188 }
189 
190 int SBPlatformShellCommand::GetSignal() { return m_opaque_ptr->m_signo; }
191 
192 int SBPlatformShellCommand::GetStatus() { return m_opaque_ptr->m_status; }
193 
194 const char *SBPlatformShellCommand::GetOutput() {
195   if (m_opaque_ptr->m_output.empty())
196     return NULL;
197   return m_opaque_ptr->m_output.c_str();
198 }
199 
200 //----------------------------------------------------------------------
201 // SBPlatform
202 //----------------------------------------------------------------------
203 SBPlatform::SBPlatform() : m_opaque_sp() {}
204 
205 SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
206   Error error;
207   if (platform_name && platform_name[0])
208     m_opaque_sp = Platform::Create(ConstString(platform_name), error);
209 }
210 
211 SBPlatform::~SBPlatform() {}
212 
213 bool SBPlatform::IsValid() const { return m_opaque_sp.get() != NULL; }
214 
215 void SBPlatform::Clear() { m_opaque_sp.reset(); }
216 
217 const char *SBPlatform::GetName() {
218   PlatformSP platform_sp(GetSP());
219   if (platform_sp)
220     return platform_sp->GetName().GetCString();
221   return NULL;
222 }
223 
224 lldb::PlatformSP SBPlatform::GetSP() const { return m_opaque_sp; }
225 
226 void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
227   m_opaque_sp = platform_sp;
228 }
229 
230 const char *SBPlatform::GetWorkingDirectory() {
231   PlatformSP platform_sp(GetSP());
232   if (platform_sp)
233     return platform_sp->GetWorkingDirectory().GetCString();
234   return NULL;
235 }
236 
237 bool SBPlatform::SetWorkingDirectory(const char *path) {
238   PlatformSP platform_sp(GetSP());
239   if (platform_sp) {
240     if (path)
241       platform_sp->SetWorkingDirectory(FileSpec{path, false});
242     else
243       platform_sp->SetWorkingDirectory(FileSpec{});
244     return true;
245   }
246   return false;
247 }
248 
249 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
250   SBError sb_error;
251   PlatformSP platform_sp(GetSP());
252   if (platform_sp && connect_options.GetURL()) {
253     Args args;
254     args.AppendArgument(
255         llvm::StringRef::withNullAsEmpty(connect_options.GetURL()));
256     sb_error.ref() = platform_sp->ConnectRemote(args);
257   } else {
258     sb_error.SetErrorString("invalid platform");
259   }
260   return sb_error;
261 }
262 
263 void SBPlatform::DisconnectRemote() {
264   PlatformSP platform_sp(GetSP());
265   if (platform_sp)
266     platform_sp->DisconnectRemote();
267 }
268 
269 bool SBPlatform::IsConnected() {
270   PlatformSP platform_sp(GetSP());
271   if (platform_sp)
272     platform_sp->IsConnected();
273   return false;
274 }
275 
276 const char *SBPlatform::GetTriple() {
277   PlatformSP platform_sp(GetSP());
278   if (platform_sp) {
279     ArchSpec arch(platform_sp->GetSystemArchitecture());
280     if (arch.IsValid()) {
281       // Const-ify the string so we don't need to worry about the lifetime of
282       // the string
283       return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
284     }
285   }
286   return NULL;
287 }
288 
289 const char *SBPlatform::GetOSBuild() {
290   PlatformSP platform_sp(GetSP());
291   if (platform_sp) {
292     std::string s;
293     if (platform_sp->GetOSBuildString(s)) {
294       if (!s.empty()) {
295         // Const-ify the string so we don't need to worry about the lifetime of
296         // the string
297         return ConstString(s.c_str()).GetCString();
298       }
299     }
300   }
301   return NULL;
302 }
303 
304 const char *SBPlatform::GetOSDescription() {
305   PlatformSP platform_sp(GetSP());
306   if (platform_sp) {
307     std::string s;
308     if (platform_sp->GetOSKernelDescription(s)) {
309       if (!s.empty()) {
310         // Const-ify the string so we don't need to worry about the lifetime of
311         // the string
312         return ConstString(s.c_str()).GetCString();
313       }
314     }
315   }
316   return NULL;
317 }
318 
319 const char *SBPlatform::GetHostname() {
320   PlatformSP platform_sp(GetSP());
321   if (platform_sp)
322     return platform_sp->GetHostname();
323   return NULL;
324 }
325 
326 uint32_t SBPlatform::GetOSMajorVersion() {
327   uint32_t major, minor, update;
328   PlatformSP platform_sp(GetSP());
329   if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
330     return major;
331   return UINT32_MAX;
332 }
333 
334 uint32_t SBPlatform::GetOSMinorVersion() {
335   uint32_t major, minor, update;
336   PlatformSP platform_sp(GetSP());
337   if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
338     return minor;
339   return UINT32_MAX;
340 }
341 
342 uint32_t SBPlatform::GetOSUpdateVersion() {
343   uint32_t major, minor, update;
344   PlatformSP platform_sp(GetSP());
345   if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
346     return update;
347   return UINT32_MAX;
348 }
349 
350 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
351   SBError sb_error;
352   PlatformSP platform_sp(GetSP());
353   if (platform_sp) {
354     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
355   } else {
356     sb_error.SetErrorString("invalid platform");
357   }
358   return sb_error;
359 }
360 
361 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
362   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
363     if (src.Exists()) {
364       uint32_t permissions = src.ref().GetPermissions();
365       if (permissions == 0) {
366         if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory)
367           permissions = eFilePermissionsDirectoryDefault;
368         else
369           permissions = eFilePermissionsFileDefault;
370       }
371 
372       return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
373     }
374 
375     Error error;
376     error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
377                                    src.ref().GetPath().c_str());
378     return error;
379   });
380 }
381 
382 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
383   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
384     if (src.Exists())
385       return platform_sp->Install(src.ref(), dst.ref());
386 
387     Error error;
388     error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'",
389                                    src.ref().GetPath().c_str());
390     return error;
391   });
392 }
393 
394 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
395   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
396     const char *command = shell_command.GetCommand();
397     if (!command)
398       return Error("invalid shell command (empty)");
399 
400     const char *working_dir = shell_command.GetWorkingDirectory();
401     if (working_dir == NULL) {
402       working_dir = platform_sp->GetWorkingDirectory().GetCString();
403       if (working_dir)
404         shell_command.SetWorkingDirectory(working_dir);
405     }
406     return platform_sp->RunShellCommand(
407         command, FileSpec{working_dir, false},
408         &shell_command.m_opaque_ptr->m_status,
409         &shell_command.m_opaque_ptr->m_signo,
410         &shell_command.m_opaque_ptr->m_output,
411         shell_command.m_opaque_ptr->m_timeout_sec);
412   });
413 }
414 
415 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
416   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
417     return platform_sp->LaunchProcess(launch_info.ref());
418   });
419 }
420 
421 SBError SBPlatform::Kill(const lldb::pid_t pid) {
422   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
423     return platform_sp->KillProcess(pid);
424   });
425 }
426 
427 SBError SBPlatform::ExecuteConnected(
428     const std::function<Error(const lldb::PlatformSP &)> &func) {
429   SBError sb_error;
430   const auto platform_sp(GetSP());
431   if (platform_sp) {
432     if (platform_sp->IsConnected())
433       sb_error.ref() = func(platform_sp);
434     else
435       sb_error.SetErrorString("not connected");
436   } else
437     sb_error.SetErrorString("invalid platform");
438 
439   return sb_error;
440 }
441 
442 SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
443   SBError sb_error;
444   PlatformSP platform_sp(GetSP());
445   if (platform_sp) {
446     sb_error.ref() =
447         platform_sp->MakeDirectory(FileSpec{path, false}, file_permissions);
448   } else {
449     sb_error.SetErrorString("invalid platform");
450   }
451   return sb_error;
452 }
453 
454 uint32_t SBPlatform::GetFilePermissions(const char *path) {
455   PlatformSP platform_sp(GetSP());
456   if (platform_sp) {
457     uint32_t file_permissions = 0;
458     platform_sp->GetFilePermissions(FileSpec{path, false}, file_permissions);
459     return file_permissions;
460   }
461   return 0;
462 }
463 
464 SBError SBPlatform::SetFilePermissions(const char *path,
465                                        uint32_t file_permissions) {
466   SBError sb_error;
467   PlatformSP platform_sp(GetSP());
468   if (platform_sp) {
469     sb_error.ref() = platform_sp->SetFilePermissions(FileSpec{path, false},
470                                                      file_permissions);
471   } else {
472     sb_error.SetErrorString("invalid platform");
473   }
474   return sb_error;
475 }
476 
477 SBUnixSignals SBPlatform::GetUnixSignals() const {
478   if (auto platform_sp = GetSP())
479     return SBUnixSignals{platform_sp};
480 
481   return {};
482 }
483