contrib/llvm/tools/lldb/source/API/SBPlatform.cpp

   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/Core/ArchSpec.h"
  14 #include "lldb/Core/Error.h"
  15 #include "lldb/Host/File.h"
  16 #include "lldb/Interpreter/Args.h"
  17 #include "lldb/Target/Target.h"
  18 #include "lldb/Target/Platform.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22
  23 //----------------------------------------------------------------------
  24 // PlatformConnectOptions
  25 //----------------------------------------------------------------------
  26 struct PlatformConnectOptions {
  27     PlatformConnectOptions(const char *url = NULL) :
  28         m_url(),
  29         m_rsync_options(),
  30         m_rsync_remote_path_prefix(),
  31         m_rsync_enabled(false),
  32         m_rsync_omit_hostname_from_remote_path(false),
  33         m_local_cache_directory ()
  34     {
  35         if (url && url[0])
  36             m_url = url;
  37     }
  38
  39     ~PlatformConnectOptions()
  40     {
  41     }
  42
  43     std::string m_url;
  44     std::string m_rsync_options;
  45     std::string m_rsync_remote_path_prefix;
  46     bool m_rsync_enabled;
  47     bool m_rsync_omit_hostname_from_remote_path;
  48     ConstString m_local_cache_directory;
  49 };
  50
  51 //----------------------------------------------------------------------
  52 // PlatformShellCommand
  53 //----------------------------------------------------------------------
  54 struct PlatformShellCommand {
  55     PlatformShellCommand(const char *shell_command = NULL) :
  56         m_command(),
  57         m_working_dir(),
  58         m_status(0),
  59         m_signo(0),
  60         m_timeout_sec(UINT32_MAX)
  61     {
  62         if (shell_command && shell_command[0])
  63             m_command = shell_command;
  64     }
  65
  66     ~PlatformShellCommand()
  67     {
  68     }
  69
  70     std::string m_command;
  71     std::string m_working_dir;
  72     std::string m_output;
  73     int m_status;
  74     int m_signo;
  75     uint32_t m_timeout_sec;
  76 };
  77 //----------------------------------------------------------------------
  78 // SBPlatformConnectOptions
  79 //----------------------------------------------------------------------
  80 SBPlatformConnectOptions::SBPlatformConnectOptions (const char *url) :
  81     m_opaque_ptr(new PlatformConnectOptions(url))
  82 {
  83
  84 }
  85
  86 SBPlatformConnectOptions::SBPlatformConnectOptions(const SBPlatformConnectOptions &rhs) :
  87     m_opaque_ptr(new PlatformConnectOptions())
  88 {
  89     *m_opaque_ptr = *rhs.m_opaque_ptr;
  90 }
  91
  92 SBPlatformConnectOptions::~SBPlatformConnectOptions ()
  93 {
  94     delete m_opaque_ptr;
  95 }
  96
  97 void
  98 SBPlatformConnectOptions::operator=(const SBPlatformConnectOptions &rhs)
  99 {
 100     *m_opaque_ptr = *rhs.m_opaque_ptr;
 101 }
 102
 103 const char *
 104 SBPlatformConnectOptions::GetURL()
 105 {
 106     if (m_opaque_ptr->m_url.empty())
 107         return NULL;
 108     return m_opaque_ptr->m_url.c_str();
 109 }
 110
 111 void
 112 SBPlatformConnectOptions::SetURL(const char *url)
 113 {
 114     if (url && url[0])
 115         m_opaque_ptr->m_url = url;
 116     else
 117         m_opaque_ptr->m_url.clear();
 118 }
 119
 120 bool
 121 SBPlatformConnectOptions::GetRsyncEnabled()
 122 {
 123     return m_opaque_ptr->m_rsync_enabled;
 124 }
 125
 126 void
 127 SBPlatformConnectOptions::EnableRsync (const char *options,
 128                                        const char *remote_path_prefix,
 129                                        bool omit_hostname_from_remote_path)
 130 {
 131     m_opaque_ptr->m_rsync_enabled = true;
 132     m_opaque_ptr->m_rsync_omit_hostname_from_remote_path = omit_hostname_from_remote_path;
 133     if (remote_path_prefix && remote_path_prefix[0])
 134         m_opaque_ptr->m_rsync_remote_path_prefix = remote_path_prefix;
 135     else
 136         m_opaque_ptr->m_rsync_remote_path_prefix.clear();
 137
 138     if (options && options[0])
 139         m_opaque_ptr->m_rsync_options = options;
 140     else
 141         m_opaque_ptr->m_rsync_options.clear();
 142
 143 }
 144
 145 void
 146 SBPlatformConnectOptions::DisableRsync ()
 147 {
 148     m_opaque_ptr->m_rsync_enabled = false;
 149 }
 150
 151 const char *
 152 SBPlatformConnectOptions::GetLocalCacheDirectory()
 153 {
 154     return m_opaque_ptr->m_local_cache_directory.GetCString();
 155 }
 156
 157 void
 158 SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path)
 159 {
 160     if (path && path[0])
 161         m_opaque_ptr->m_local_cache_directory.SetCString(path);
 162     else
 163         m_opaque_ptr->m_local_cache_directory = ConstString();
 164 }
 165
 166 //----------------------------------------------------------------------
 167 // SBPlatformShellCommand
 168 //----------------------------------------------------------------------
 169 SBPlatformShellCommand::SBPlatformShellCommand (const char *shell_command) :
 170     m_opaque_ptr(new PlatformShellCommand(shell_command))
 171 {
 172 }
 173
 174 SBPlatformShellCommand::SBPlatformShellCommand (const SBPlatformShellCommand &rhs) :
 175     m_opaque_ptr(new PlatformShellCommand())
 176 {
 177     *m_opaque_ptr = *rhs.m_opaque_ptr;
 178 }
 179
 180 SBPlatformShellCommand::~SBPlatformShellCommand()
 181 {
 182     delete m_opaque_ptr;
 183 }
 184
 185 void
 186 SBPlatformShellCommand::Clear()
 187 {
 188     m_opaque_ptr->m_output = std::move(std::string());
 189     m_opaque_ptr->m_status = 0;
 190     m_opaque_ptr->m_signo = 0;
 191 }
 192
 193 const char *
 194 SBPlatformShellCommand::GetCommand()
 195 {
 196     if (m_opaque_ptr->m_command.empty())
 197         return NULL;
 198     return m_opaque_ptr->m_command.c_str();
 199 }
 200
 201 void
 202 SBPlatformShellCommand::SetCommand(const char *shell_command)
 203 {
 204     if (shell_command && shell_command[0])
 205         m_opaque_ptr->m_command = shell_command;
 206     else
 207         m_opaque_ptr->m_command.clear();
 208 }
 209
 210 const char *
 211 SBPlatformShellCommand::GetWorkingDirectory ()
 212 {
 213     if (m_opaque_ptr->m_working_dir.empty())
 214         return NULL;
 215     return m_opaque_ptr->m_working_dir.c_str();
 216 }
 217
 218 void
 219 SBPlatformShellCommand::SetWorkingDirectory (const char *path)
 220 {
 221     if (path && path[0])
 222         m_opaque_ptr->m_working_dir = path;
 223     else
 224         m_opaque_ptr->m_working_dir.clear();
 225 }
 226
 227 uint32_t
 228 SBPlatformShellCommand::GetTimeoutSeconds ()
 229 {
 230     return m_opaque_ptr->m_timeout_sec;
 231 }
 232
 233 void
 234 SBPlatformShellCommand::SetTimeoutSeconds (uint32_t sec)
 235 {
 236     m_opaque_ptr->m_timeout_sec = sec;
 237 }
 238
 239 int
 240 SBPlatformShellCommand::GetSignal ()
 241 {
 242     return m_opaque_ptr->m_signo;
 243 }
 244
 245 int
 246 SBPlatformShellCommand::GetStatus ()
 247 {
 248     return m_opaque_ptr->m_status;
 249 }
 250
 251 const char *
 252 SBPlatformShellCommand::GetOutput ()
 253 {
 254     if (m_opaque_ptr->m_output.empty())
 255         return NULL;
 256     return m_opaque_ptr->m_output.c_str();
 257 }
 258
 259 //----------------------------------------------------------------------
 260 // SBPlatform
 261 //----------------------------------------------------------------------
 262 SBPlatform::SBPlatform () :
 263     m_opaque_sp ()
 264 {
 265
 266 }
 267
 268 SBPlatform::SBPlatform (const char *platform_name) :
 269     m_opaque_sp ()
 270 {
 271     Error error;
 272     m_opaque_sp = Platform::Create (platform_name, error);
 273 }
 274
 275 SBPlatform::~SBPlatform()
 276 {
 277 }
 278
 279 bool
 280 SBPlatform::IsValid () const
 281 {
 282     return m_opaque_sp.get() != NULL;
 283 }
 284
 285 void
 286 SBPlatform::Clear ()
 287 {
 288     m_opaque_sp.reset();
 289 }
 290
 291 const char *
 292 SBPlatform::GetName ()
 293 {
 294     PlatformSP platform_sp(GetSP());
 295     if (platform_sp)
 296         return platform_sp->GetName().GetCString();
 297     return NULL;
 298 }
 299
 300 lldb::PlatformSP
 301 SBPlatform::GetSP () const
 302 {
 303     return m_opaque_sp;
 304 }
 305
 306 void
 307 SBPlatform::SetSP (const lldb::PlatformSP& platform_sp)
 308 {
 309     m_opaque_sp = platform_sp;
 310 }
 311
 312 const char *
 313 SBPlatform::GetWorkingDirectory()
 314 {
 315     PlatformSP platform_sp(GetSP());
 316     if (platform_sp)
 317         return platform_sp->GetWorkingDirectory().GetCString();
 318     return NULL;
 319 }
 320
 321 bool
 322 SBPlatform::SetWorkingDirectory(const char *path)
 323 {
 324     PlatformSP platform_sp(GetSP());
 325     if (platform_sp)
 326     {
 327         if (path)
 328             platform_sp->SetWorkingDirectory(ConstString(path));
 329         else
 330             platform_sp->SetWorkingDirectory(ConstString());
 331         return true;
 332     }
 333     return false;
 334 }
 335
 336 SBError
 337 SBPlatform::ConnectRemote (SBPlatformConnectOptions &connect_options)
 338 {
 339     SBError sb_error;
 340     PlatformSP platform_sp(GetSP());
 341     if (platform_sp && connect_options.GetURL())
 342     {
 343         Args args;
 344         args.AppendArgument(connect_options.GetURL());
 345         sb_error.ref() = platform_sp->ConnectRemote(args);
 346     }
 347     else
 348     {
 349         sb_error.SetErrorString("invalid platform");
 350     }
 351     return sb_error;
 352 }
 353
 354 void
 355 SBPlatform::DisconnectRemote ()
 356 {
 357     PlatformSP platform_sp(GetSP());
 358     if (platform_sp)
 359         platform_sp->DisconnectRemote();
 360 }
 361
 362 bool
 363 SBPlatform::IsConnected()
 364 {
 365     PlatformSP platform_sp(GetSP());
 366     if (platform_sp)
 367         platform_sp->IsConnected();
 368     return false;
 369 }
 370
 371 const char *
 372 SBPlatform::GetTriple()
 373 {
 374     PlatformSP platform_sp(GetSP());
 375     if (platform_sp)
 376     {
 377         ArchSpec arch(platform_sp->GetRemoteSystemArchitecture());
 378         if (arch.IsValid())
 379         {
 380             // Const-ify the string so we don't need to worry about the lifetime of the string
 381             return ConstString(arch.GetTriple().getTriple().c_str()).GetCString();
 382         }
 383     }
 384     return NULL;
 385 }
 386
 387 const char *
 388 SBPlatform::GetOSBuild()
 389 {
 390     PlatformSP platform_sp(GetSP());
 391     if (platform_sp)
 392     {
 393         std::string s;
 394         if (platform_sp->GetOSBuildString(s))
 395         {
 396             if (!s.empty())
 397             {
 398                 // Const-ify the string so we don't need to worry about the lifetime of the string
 399                 return ConstString(s.c_str()).GetCString();
 400             }
 401         }
 402     }
 403     return NULL;
 404 }
 405
 406 const char *
 407 SBPlatform::GetOSDescription()
 408 {
 409     PlatformSP platform_sp(GetSP());
 410     if (platform_sp)
 411     {
 412         std::string s;
 413         if (platform_sp->GetOSKernelDescription(s))
 414         {
 415             if (!s.empty())
 416             {
 417                 // Const-ify the string so we don't need to worry about the lifetime of the string
 418                 return ConstString(s.c_str()).GetCString();
 419             }
 420         }
 421     }
 422     return NULL;
 423 }
 424
 425 const char *
 426 SBPlatform::GetHostname ()
 427 {
 428     PlatformSP platform_sp(GetSP());
 429     if (platform_sp)
 430         return platform_sp->GetHostname();
 431     return NULL;
 432 }
 433
 434 uint32_t
 435 SBPlatform::GetOSMajorVersion ()
 436 {
 437     uint32_t major, minor, update;
 438     PlatformSP platform_sp(GetSP());
 439     if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
 440         return major;
 441     return UINT32_MAX;
 442
 443 }
 444
 445 uint32_t
 446 SBPlatform::GetOSMinorVersion ()
 447 {
 448     uint32_t major, minor, update;
 449     PlatformSP platform_sp(GetSP());
 450     if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
 451         return minor;
 452     return UINT32_MAX;
 453 }
 454
 455 uint32_t
 456 SBPlatform::GetOSUpdateVersion ()
 457 {
 458     uint32_t major, minor, update;
 459     PlatformSP platform_sp(GetSP());
 460     if (platform_sp && platform_sp->GetOSVersion(major, minor, update))
 461         return update;
 462     return UINT32_MAX;
 463 }
 464
 465 SBError
 466 SBPlatform::Get (SBFileSpec &src,
 467                  SBFileSpec &dst)
 468 {
 469     SBError sb_error;
 470     PlatformSP platform_sp(GetSP());
 471     if (platform_sp)
 472     {
 473         sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());
 474     }
 475     else
 476     {
 477         sb_error.SetErrorString("invalid platform");
 478     }
 479     return sb_error;
 480 }
 481
 482 SBError
 483 SBPlatform::Put (SBFileSpec &src,
 484                  SBFileSpec &dst)
 485 {
 486     SBError sb_error;
 487
 488     PlatformSP platform_sp(GetSP());
 489     if (platform_sp)
 490     {
 491         if (src.Exists())
 492         {
 493             uint32_t permissions = src.ref().GetPermissions();
 494             if (permissions == 0)
 495             {
 496                 if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory)
 497                     permissions = eFilePermissionsDirectoryDefault;
 498                 else
 499                     permissions = eFilePermissionsFileDefault;
 500             }
 501
 502             sb_error.ref() = platform_sp->PutFile(src.ref(),
 503                                                   dst.ref(),
 504                                                   permissions);
 505         }
 506         else
 507         {
 508             sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
 509         }
 510     }
 511     else
 512     {
 513         sb_error.SetErrorString("invalid platform");
 514     }
 515     return sb_error;
 516 }
 517
 518 SBError
 519 SBPlatform::Install (SBFileSpec &src,
 520                      SBFileSpec &dst)
 521 {
 522     SBError sb_error;
 523     PlatformSP platform_sp(GetSP());
 524     if (platform_sp)
 525     {
 526         if (src.Exists())
 527         {
 528             sb_error.ref() = platform_sp->Install(src.ref(), dst.ref());
 529         }
 530         else
 531         {
 532             sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
 533         }
 534     }
 535     else
 536     {
 537         sb_error.SetErrorString("invalid platform");
 538     }
 539     return sb_error;
 540 }
 541
 542
 543 SBError
 544 SBPlatform::Run (SBPlatformShellCommand &shell_command)
 545 {
 546     SBError sb_error;
 547     PlatformSP platform_sp(GetSP());
 548     if (platform_sp)
 549     {
 550         if (platform_sp->IsConnected())
 551         {
 552             const char *command = shell_command.GetCommand();
 553             if (command)
 554             {
 555                 const char *working_dir = shell_command.GetWorkingDirectory();
 556                 if (working_dir == NULL)
 557                 {
 558                     working_dir = platform_sp->GetWorkingDirectory().GetCString();
 559                     if (working_dir)
 560                         shell_command.SetWorkingDirectory(working_dir);
 561                 }
 562                 sb_error.ref() = platform_sp->RunShellCommand(command,
 563                                                               working_dir,
 564                                                               &shell_command.m_opaque_ptr->m_status,
 565                                                               &shell_command.m_opaque_ptr->m_signo,
 566                                                               &shell_command.m_opaque_ptr->m_output,
 567                                                               shell_command.m_opaque_ptr->m_timeout_sec);
 568             }
 569             else
 570             {
 571                 sb_error.SetErrorString("invalid shell command (empty)");
 572             }
 573         }
 574         else
 575         {
 576             sb_error.SetErrorString("not connected");
 577         }
 578     }
 579     else
 580     {
 581         sb_error.SetErrorString("invalid platform");
 582     }
 583     return sb_error;
 584 }
 585
 586 SBError
 587 SBPlatform::MakeDirectory (const char *path, uint32_t file_permissions)
 588 {
 589     SBError sb_error;
 590     PlatformSP platform_sp(GetSP());
 591     if (platform_sp)
 592     {
 593         sb_error.ref() = platform_sp->MakeDirectory(path, file_permissions);
 594     }
 595     else
 596     {
 597         sb_error.SetErrorString("invalid platform");
 598     }
 599     return sb_error;
 600 }
 601
 602 uint32_t
 603 SBPlatform::GetFilePermissions (const char *path)
 604 {
 605     PlatformSP platform_sp(GetSP());
 606     if (platform_sp)
 607     {
 608         uint32_t file_permissions = 0;
 609         platform_sp->GetFilePermissions(path, file_permissions);
 610         return file_permissions;
 611     }
 612     return 0;
 613
 614 }
 615
 616 SBError
 617 SBPlatform::SetFilePermissions (const char *path, uint32_t file_permissions)
 618 {
 619     SBError sb_error;
 620     PlatformSP platform_sp(GetSP());
 621     if (platform_sp)
 622     {
 623         sb_error.ref() = platform_sp->SetFilePermissions(path, file_permissions);
 624     }
 625     else
 626     {
 627         sb_error.SetErrorString("invalid platform");
 628     }
 629     return sb_error;
 630
 631 }
 632