//===-- PlatformPOSIX.cpp ---------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "PlatformPOSIX.h"

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes

#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Host/File.h"
#include "lldb/Host/FileCache.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h"
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/ProcessLaunchInfo.h"
#include "lldb/Target/Thread.h"

using namespace lldb;
using namespace lldb_private;


//------------------------------------------------------------------
/// Default Constructor
//------------------------------------------------------------------
PlatformPOSIX::PlatformPOSIX (bool is_host) :
Platform(is_host),  // This is the local host platform
m_option_group_platform_rsync(new OptionGroupPlatformRSync()),
m_option_group_platform_ssh(new OptionGroupPlatformSSH()),
m_option_group_platform_caching(new OptionGroupPlatformCaching()),
m_remote_platform_sp ()
{
}

//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance.
//------------------------------------------------------------------
PlatformPOSIX::~PlatformPOSIX()
{
}

bool
PlatformPOSIX::GetModuleSpec (const FileSpec& module_file_spec,
                              const ArchSpec& arch,
                              ModuleSpec &module_spec)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetModuleSpec (module_file_spec, arch, module_spec);

    return Platform::GetModuleSpec (module_file_spec, arch, module_spec);
}

lldb_private::OptionGroupOptions*
PlatformPOSIX::GetConnectionOptions (lldb_private::CommandInterpreter& interpreter)
{
    auto iter = m_options.find(&interpreter), end = m_options.end();
    if (iter == end)
    {
        std::unique_ptr<lldb_private::OptionGroupOptions> options(new OptionGroupOptions(interpreter));
        options->Append(m_option_group_platform_rsync.get());
        options->Append(m_option_group_platform_ssh.get());
        options->Append(m_option_group_platform_caching.get());
        m_options[&interpreter] = std::move(options);
    }
    
    return m_options.at(&interpreter).get();
}

bool
PlatformPOSIX::IsConnected () const
{
    if (IsHost())
        return true;
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->IsConnected();
    return false;
}

lldb_private::Error
PlatformPOSIX::RunShellCommand(const char *command,           // Shouldn't be NULL
                               const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
                               int *status_ptr,               // Pass NULL if you don't want the process exit status
                               int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                               std::string *command_output,   // Pass NULL if you don't want the command output
                               uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
{
    if (IsHost())
        return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
    else
    {
        if (m_remote_platform_sp)
            return m_remote_platform_sp->RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
        else
            return Error("unable to run a remote command without a platform");
    }
}

Error
PlatformPOSIX::MakeDirectory(const FileSpec &file_spec, uint32_t file_permissions)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
    else
        return Platform::MakeDirectory(file_spec ,file_permissions);
}

Error
PlatformPOSIX::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetFilePermissions(file_spec, file_permissions);
    else
        return Platform::GetFilePermissions(file_spec ,file_permissions);
}

Error
PlatformPOSIX::SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->SetFilePermissions(file_spec, file_permissions);
    else
        return Platform::SetFilePermissions(file_spec, file_permissions);
}

lldb::user_id_t
PlatformPOSIX::OpenFile (const FileSpec& file_spec,
                         uint32_t flags,
                         uint32_t mode,
                         Error &error)
{
    if (IsHost())
        return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
    else
        return Platform::OpenFile(file_spec, flags, mode, error);
}

bool
PlatformPOSIX::CloseFile (lldb::user_id_t fd, Error &error)
{
    if (IsHost())
        return FileCache::GetInstance().CloseFile(fd, error);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->CloseFile(fd, error);
    else
        return Platform::CloseFile(fd, error);
}

uint64_t
PlatformPOSIX::ReadFile (lldb::user_id_t fd,
                         uint64_t offset,
                         void *dst,
                         uint64_t dst_len,
                         Error &error)
{
    if (IsHost())
        return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
    else
        return Platform::ReadFile(fd, offset, dst, dst_len, error);
}

uint64_t
PlatformPOSIX::WriteFile (lldb::user_id_t fd,
                          uint64_t offset,
                          const void* src,
                          uint64_t src_len,
                          Error &error)
{
    if (IsHost())
        return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
    else
        return Platform::WriteFile(fd, offset, src, src_len, error);
}

static uint32_t
chown_file(Platform *platform,
           const char* path,
           uint32_t uid = UINT32_MAX,
           uint32_t gid = UINT32_MAX)
{
    if (!platform || !path || *path == 0)
        return UINT32_MAX;
    
    if (uid == UINT32_MAX && gid == UINT32_MAX)
        return 0;   // pretend I did chown correctly - actually I just didn't care
    
    StreamString command;
    command.PutCString("chown ");
    if (uid != UINT32_MAX)
        command.Printf("%d",uid);
    if (gid != UINT32_MAX)
        command.Printf(":%d",gid);
    command.Printf("%s",path);
    int status;
    platform->RunShellCommand(command.GetData(),
                              NULL,
                              &status,
                              NULL,
                              NULL,
                              10);
    return status;
}

lldb_private::Error
PlatformPOSIX::PutFile (const lldb_private::FileSpec& source,
                         const lldb_private::FileSpec& destination,
                         uint32_t uid,
                         uint32_t gid)
{
    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));

    if (IsHost())
    {
        if (FileSpec::Equal(source, destination, true))
            return Error();
        // cp src dst
        // chown uid:gid dst
        std::string src_path (source.GetPath());
        if (src_path.empty())
            return Error("unable to get file path for source");
        std::string dst_path (destination.GetPath());
        if (dst_path.empty())
            return Error("unable to get file path for destination");
        StreamString command;
        command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
        int status;
        RunShellCommand(command.GetData(),
                        NULL,
                        &status,
                        NULL,
                        NULL,
                        10);
        if (status != 0)
            return Error("unable to perform copy");
        if (uid == UINT32_MAX && gid == UINT32_MAX)
            return Error();
        if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
            return Error("unable to perform chown");
        return Error();
    }
    else if (m_remote_platform_sp)
    {
        if (GetSupportsRSync())
        {
            std::string src_path (source.GetPath());
            if (src_path.empty())
                return Error("unable to get file path for source");
            std::string dst_path (destination.GetPath());
            if (dst_path.empty())
                return Error("unable to get file path for destination");
            StreamString command;
            if (GetIgnoresRemoteHostname())
            {
                if (!GetRSyncPrefix())
                    command.Printf("rsync %s %s %s",
                                   GetRSyncOpts(),
                                   src_path.c_str(),
                                   dst_path.c_str());
                else
                    command.Printf("rsync %s %s %s%s",
                                   GetRSyncOpts(),
                                   src_path.c_str(),
                                   GetRSyncPrefix(),
                                   dst_path.c_str());
            }
            else
                command.Printf("rsync %s %s %s:%s",
                               GetRSyncOpts(),
                               src_path.c_str(),
                               GetHostname(),
                               dst_path.c_str());
            if (log)
                log->Printf("[PutFile] Running command: %s\n", command.GetData());
            int retcode;
            Host::RunShellCommand(command.GetData(),
                                  NULL,
                                  &retcode,
                                  NULL,
                                  NULL,
                                  60);
            if (retcode == 0)
            {
                // Don't chown a local file for a remote system
//                if (chown_file(this,dst_path.c_str(),uid,gid) != 0)
//                    return Error("unable to perform chown");
                return Error();
            }
            // if we are still here rsync has failed - let's try the slow way before giving up
        }
    }
    return Platform::PutFile(source,destination,uid,gid);
}

lldb::user_id_t
PlatformPOSIX::GetFileSize (const FileSpec& file_spec)
{
    if (IsHost())
        return FileSystem::GetFileSize(file_spec);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->GetFileSize(file_spec);
    else
        return Platform::GetFileSize(file_spec);
}

Error
PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst)
{
    if (IsHost())
        return FileSystem::Symlink(src, dst);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->CreateSymlink(src, dst);
    else
        return Platform::CreateSymlink(src, dst);
}

bool
PlatformPOSIX::GetFileExists (const FileSpec& file_spec)
{
    if (IsHost())
        return file_spec.Exists();
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->GetFileExists(file_spec);
    else
        return Platform::GetFileExists(file_spec);
}

Error
PlatformPOSIX::Unlink(const FileSpec &file_spec)
{
    if (IsHost())
        return FileSystem::Unlink(file_spec);
    else if (m_remote_platform_sp)
        return m_remote_platform_sp->Unlink(file_spec);
    else
        return Platform::Unlink(file_spec);
}

lldb_private::Error
PlatformPOSIX::GetFile(const lldb_private::FileSpec &source,      // remote file path
                       const lldb_private::FileSpec &destination) // local file path
{
    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));

    // Check the args, first.
    std::string src_path (source.GetPath());
    if (src_path.empty())
        return Error("unable to get file path for source");
    std::string dst_path (destination.GetPath());
    if (dst_path.empty())
        return Error("unable to get file path for destination");
    if (IsHost())
    {
        if (FileSpec::Equal(source, destination, true))
            return Error("local scenario->source and destination are the same file path: no operation performed");
        // cp src dst
        StreamString cp_command;
        cp_command.Printf("cp %s %s", src_path.c_str(), dst_path.c_str());
        int status;
        RunShellCommand(cp_command.GetData(),
                        NULL,
                        &status,
                        NULL,
                        NULL,
                        10);
        if (status != 0)
            return Error("unable to perform copy");
        return Error();
    }
    else if (m_remote_platform_sp)
    {
        if (GetSupportsRSync())
        {
            StreamString command;
            if (GetIgnoresRemoteHostname())
            {
                if (!GetRSyncPrefix())
                    command.Printf("rsync %s %s %s",
                                   GetRSyncOpts(),
                                   src_path.c_str(),
                                   dst_path.c_str());
                else
                    command.Printf("rsync %s %s%s %s",
                                   GetRSyncOpts(),
                                   GetRSyncPrefix(),
                                   src_path.c_str(),
                                   dst_path.c_str());
            }
            else
                command.Printf("rsync %s %s:%s %s",
                               GetRSyncOpts(),
                               m_remote_platform_sp->GetHostname(),
                               src_path.c_str(),
                               dst_path.c_str());
            if (log)
                log->Printf("[GetFile] Running command: %s\n", command.GetData());
            int retcode;
            Host::RunShellCommand(command.GetData(),
                                  NULL,
                                  &retcode,
                                  NULL,
                                  NULL,
                                  60);
            if (retcode == 0)
                return Error();
            // If we are here, rsync has failed - let's try the slow way before giving up
        }
        // open src and dst
        // read/write, read/write, read/write, ...
        // close src
        // close dst
        if (log)
            log->Printf("[GetFile] Using block by block transfer....\n");
        Error error;
        user_id_t fd_src = OpenFile (source,
                                     File::eOpenOptionRead,
                                     lldb::eFilePermissionsFileDefault,
                                     error);

        if (fd_src == UINT64_MAX)
            return Error("unable to open source file");

        uint32_t permissions = 0;
        error = GetFilePermissions(source, permissions);

        if (permissions == 0)
            permissions = lldb::eFilePermissionsFileDefault;

        user_id_t fd_dst = FileCache::GetInstance().OpenFile(
            destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite | File::eOpenOptionTruncate, permissions,
            error);

        if (fd_dst == UINT64_MAX)
        {
            if (error.Success())
                error.SetErrorString("unable to open destination file");
        }

        if (error.Success())
        {
            lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
            uint64_t offset = 0;
            error.Clear();
            while (error.Success())
            {
                const uint64_t n_read = ReadFile (fd_src,
                                                  offset,
                                                  buffer_sp->GetBytes(),
                                                  buffer_sp->GetByteSize(),
                                                  error);
                if (error.Fail())
                    break;
                if (n_read == 0)
                    break;
                if (FileCache::GetInstance().WriteFile(fd_dst, offset, buffer_sp->GetBytes(), n_read, error) != n_read)
                {
                    if (!error.Fail())
                        error.SetErrorString("unable to write to destination file");
                    break;
                }
                offset += n_read;
            }
        }
        // Ignore the close error of src.
        if (fd_src != UINT64_MAX)
            CloseFile(fd_src, error);
        // And close the dst file descriptot.
        if (fd_dst != UINT64_MAX && !FileCache::GetInstance().CloseFile(fd_dst, error))
        {
            if (!error.Fail())
                error.SetErrorString("unable to close destination file");

        }
        return error;
    }
    return Platform::GetFile(source,destination);
}

std::string
PlatformPOSIX::GetPlatformSpecificConnectionInformation()
{
    StreamString stream;
    if (GetSupportsRSync())
    {
        stream.PutCString("rsync");
        if ( (GetRSyncOpts() && *GetRSyncOpts()) ||
             (GetRSyncPrefix() && *GetRSyncPrefix()) ||
             GetIgnoresRemoteHostname())
        {
            stream.Printf(", options: ");
            if (GetRSyncOpts() && *GetRSyncOpts())
                stream.Printf("'%s' ",GetRSyncOpts());
            stream.Printf(", prefix: ");
            if (GetRSyncPrefix() && *GetRSyncPrefix())
                stream.Printf("'%s' ",GetRSyncPrefix());
            if (GetIgnoresRemoteHostname())
                stream.Printf("ignore remote-hostname ");
        }
    }
    if (GetSupportsSSH())
    {
        stream.PutCString("ssh");
        if (GetSSHOpts() && *GetSSHOpts())
            stream.Printf(", options: '%s' ",GetSSHOpts());
    }
    if (GetLocalCacheDirectory() && *GetLocalCacheDirectory())
        stream.Printf("cache dir: %s",GetLocalCacheDirectory());
    if (stream.GetSize())
        return stream.GetData();
    else
        return "";
}

bool
PlatformPOSIX::CalculateMD5 (const FileSpec& file_spec,
                            uint64_t &low,
                            uint64_t &high)
{
    if (IsHost())
        return Platform::CalculateMD5 (file_spec, low, high);
    if (m_remote_platform_sp)
        return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
    return false;
}

const lldb::UnixSignalsSP &
PlatformPOSIX::GetRemoteUnixSignals() {
    if (IsRemote() && m_remote_platform_sp)
        return m_remote_platform_sp->GetRemoteUnixSignals();
    return Platform::GetRemoteUnixSignals();
}


FileSpec
PlatformPOSIX::GetRemoteWorkingDirectory()
{
    if (IsRemote() && m_remote_platform_sp)
        return m_remote_platform_sp->GetRemoteWorkingDirectory();
    else
        return Platform::GetRemoteWorkingDirectory();
}

bool
PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir)
{
    if (IsRemote() && m_remote_platform_sp)
        return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
    else
        return Platform::SetRemoteWorkingDirectory(working_dir);
}

bool
PlatformPOSIX::GetRemoteOSVersion ()
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetOSVersion (m_major_os_version,
                                                   m_minor_os_version,
                                                   m_update_os_version);
    return false;
}

bool
PlatformPOSIX::GetRemoteOSBuildString (std::string &s)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetRemoteOSBuildString (s);
    s.clear();
    return false;
}

size_t
PlatformPOSIX::GetEnvironment (StringList &env)
{
    if (IsRemote())
    {
        if (m_remote_platform_sp)
            return m_remote_platform_sp->GetEnvironment(env);
        return 0;
    }
    return Host::GetEnvironment(env);
}

bool
PlatformPOSIX::GetRemoteOSKernelDescription (std::string &s)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetRemoteOSKernelDescription (s);
    s.clear();
    return false;
}

// Remote Platform subclasses need to override this function
ArchSpec
PlatformPOSIX::GetRemoteSystemArchitecture ()
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetRemoteSystemArchitecture ();
    return ArchSpec();
}

const char *
PlatformPOSIX::GetHostname ()
{
    if (IsHost())
        return Platform::GetHostname();

    if (m_remote_platform_sp)
        return m_remote_platform_sp->GetHostname ();
    return NULL;
}

const char *
PlatformPOSIX::GetUserName (uint32_t uid)
{
    // Check the cache in Platform in case we have already looked this uid up
    const char *user_name = Platform::GetUserName(uid);
    if (user_name)
        return user_name;

    if (IsRemote() && m_remote_platform_sp)
        return m_remote_platform_sp->GetUserName(uid);
    return NULL;
}

const char *
PlatformPOSIX::GetGroupName (uint32_t gid)
{
    const char *group_name = Platform::GetGroupName(gid);
    if (group_name)
        return group_name;

    if (IsRemote() && m_remote_platform_sp)
        return m_remote_platform_sp->GetGroupName(gid);
    return NULL;
}

Error
PlatformPOSIX::ConnectRemote (Args& args)
{
    Error error;
    if (IsHost())
    {
        error.SetErrorStringWithFormat ("can't connect to the host platform '%s', always connected", GetPluginName().GetCString());
    }
    else
    {
        if (!m_remote_platform_sp)
            m_remote_platform_sp = Platform::Create (ConstString("remote-gdb-server"), error);

        if (m_remote_platform_sp && error.Success())
            error = m_remote_platform_sp->ConnectRemote (args);
        else
            error.SetErrorString ("failed to create a 'remote-gdb-server' platform");

        if (error.Fail())
            m_remote_platform_sp.reset();
    }

    if (error.Success() && m_remote_platform_sp)
    {
        if (m_option_group_platform_rsync.get() && m_option_group_platform_ssh.get() && m_option_group_platform_caching.get())
        {
            if (m_option_group_platform_rsync->m_rsync)
            {
                SetSupportsRSync(true);
                SetRSyncOpts(m_option_group_platform_rsync->m_rsync_opts.c_str());
                SetRSyncPrefix(m_option_group_platform_rsync->m_rsync_prefix.c_str());
                SetIgnoresRemoteHostname(m_option_group_platform_rsync->m_ignores_remote_hostname);
            }
            if (m_option_group_platform_ssh->m_ssh)
            {
                SetSupportsSSH(true);
                SetSSHOpts(m_option_group_platform_ssh->m_ssh_opts.c_str());
            }
            SetLocalCacheDirectory(m_option_group_platform_caching->m_cache_dir.c_str());
        }
    }

    return error;
}

Error
PlatformPOSIX::DisconnectRemote ()
{
    Error error;

    if (IsHost())
    {
        error.SetErrorStringWithFormat ("can't disconnect from the host platform '%s', always connected", GetPluginName().GetCString());
    }
    else
    {
        if (m_remote_platform_sp)
            error = m_remote_platform_sp->DisconnectRemote ();
        else
            error.SetErrorString ("the platform is not currently connected");
    }
    return error;
}

Error
PlatformPOSIX::LaunchProcess (ProcessLaunchInfo &launch_info)
{
    Error error;

    if (IsHost())
    {
        error = Platform::LaunchProcess (launch_info);
    }
    else
    {
        if (m_remote_platform_sp)
            error = m_remote_platform_sp->LaunchProcess (launch_info);
        else
            error.SetErrorString ("the platform is not currently connected");
    }
    return error;
}

lldb_private::Error
PlatformPOSIX::KillProcess (const lldb::pid_t pid)
{
    if (IsHost())
        return Platform::KillProcess (pid);

    if (m_remote_platform_sp)
        return m_remote_platform_sp->KillProcess (pid);

    return Error ("the platform is not currently connected");
}

lldb::ProcessSP
PlatformPOSIX::Attach (ProcessAttachInfo &attach_info,
                       Debugger &debugger,
                       Target *target,
                       Error &error)
{
    lldb::ProcessSP process_sp;
    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));

    if (IsHost())
    {
        if (target == NULL)
        {
            TargetSP new_target_sp;

            error = debugger.GetTargetList().CreateTarget (debugger,
                                                           NULL,
                                                           NULL,
                                                           false,
                                                           NULL,
                                                           new_target_sp);
            target = new_target_sp.get();
            if (log)
                log->Printf ("PlatformPOSIX::%s created new target", __FUNCTION__);
        }
        else
        {
            error.Clear();
            if (log)
                log->Printf ("PlatformPOSIX::%s target already existed, setting target", __FUNCTION__);
        }

        if (target && error.Success())
        {
            debugger.GetTargetList().SetSelectedTarget(target);
            if (log)
            {
                ModuleSP exe_module_sp = target->GetExecutableModule ();
                log->Printf("PlatformPOSIX::%s set selected target to %p %s", __FUNCTION__, (void *)target,
                            exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str() : "<null>");
            }


            process_sp = target->CreateProcess (attach_info.GetListenerForProcess(debugger), attach_info.GetProcessPluginName(), NULL);

            if (process_sp)
            {
                ListenerSP listener_sp = attach_info.GetHijackListener();
                if (listener_sp == nullptr)
                {
                    listener_sp = Listener::MakeListener("lldb.PlatformPOSIX.attach.hijack");
                    attach_info.SetHijackListener(listener_sp);
                }
                process_sp->HijackProcessEvents(listener_sp);
                error = process_sp->Attach (attach_info);
            }
        }
    }
    else
    {
        if (m_remote_platform_sp)
            process_sp = m_remote_platform_sp->Attach (attach_info, debugger, target, error);
        else
            error.SetErrorString ("the platform is not currently connected");
    }
    return process_sp;
}

lldb::ProcessSP
PlatformPOSIX::DebugProcess (ProcessLaunchInfo &launch_info,
                              Debugger &debugger,
                              Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                              Error &error)
{
    ProcessSP process_sp;

    if (IsHost())
    {
        // We are going to hand this process off to debugserver which will be in charge of setting the exit status.
        // We still need to reap it from lldb but if we let the monitor thread also set the exit status, we set up a
        // race between debugserver & us for who will find out about the debugged process's death.
        launch_info.GetFlags().Set(eLaunchFlagDontSetExitStatus);
        process_sp = Platform::DebugProcess (launch_info, debugger, target, error);
    }
    else
    {
        if (m_remote_platform_sp)
            process_sp = m_remote_platform_sp->DebugProcess (launch_info, debugger, target, error);
        else
            error.SetErrorString ("the platform is not currently connected");
    }
    return process_sp;

}

void
PlatformPOSIX::CalculateTrapHandlerSymbolNames ()
{
    m_trap_handlers.push_back (ConstString ("_sigtramp"));
}

Error
PlatformPOSIX::EvaluateLibdlExpression(lldb_private::Process* process,
                                       const char* expr_cstr,
                                       const char* expr_prefix,
                                       lldb::ValueObjectSP& result_valobj_sp)
{
    DynamicLoader *loader = process->GetDynamicLoader();
    if (loader)
    {
        Error error = loader->CanLoadImage();
        if (error.Fail())
            return error;
    }

    ThreadSP thread_sp(process->GetThreadList().GetExpressionExecutionThread());
    if (!thread_sp)
        return Error("Selected thread isn't valid");

    StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
    if (!frame_sp)
        return Error("Frame 0 isn't valid");

    ExecutionContext exe_ctx;
    frame_sp->CalculateExecutionContext(exe_ctx);
    EvaluateExpressionOptions expr_options;
    expr_options.SetUnwindOnError(true);
    expr_options.SetIgnoreBreakpoints(true);
    expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
    expr_options.SetLanguage(eLanguageTypeC_plus_plus);
    expr_options.SetTimeoutUsec(2000000); // 2 seconds

    Error expr_error;
    UserExpression::Evaluate(exe_ctx,
                             expr_options,
                             expr_cstr,
                             expr_prefix,
                             result_valobj_sp,
                             expr_error);
    if (result_valobj_sp->GetError().Fail())
        return result_valobj_sp->GetError();
    return Error();
}

uint32_t
PlatformPOSIX::DoLoadImage(lldb_private::Process* process,
                           const lldb_private::FileSpec& remote_file,
                           lldb_private::Error& error)
{
    char path[PATH_MAX];
    remote_file.GetPath(path, sizeof(path));

    StreamString expr;
    expr.Printf(R"(
                   struct __lldb_dlopen_result { void *image_ptr; const char *error_str; } the_result;
                   the_result.image_ptr = dlopen ("%s", 2);
                   if (the_result.image_ptr == (void *) 0x0)
                   {
                       the_result.error_str = dlerror();
                   }
                   else
                   {
                       the_result.error_str = (const char *) 0x0;
                   }
                   the_result;
                  )",
                  path);
    const char *prefix = GetLibdlFunctionDeclarations();
    lldb::ValueObjectSP result_valobj_sp;
    error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
    if (error.Fail())
        return LLDB_INVALID_IMAGE_TOKEN;

    error = result_valobj_sp->GetError();
    if (error.Fail())
        return LLDB_INVALID_IMAGE_TOKEN;

    Scalar scalar;
    ValueObjectSP image_ptr_sp = result_valobj_sp->GetChildAtIndex(0, true);
    if (!image_ptr_sp || !image_ptr_sp->ResolveValue(scalar))
    {
        error.SetErrorStringWithFormat("unable to load '%s'", path);
        return LLDB_INVALID_IMAGE_TOKEN;
    }

    addr_t image_ptr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
    if (image_ptr != 0 && image_ptr != LLDB_INVALID_ADDRESS)
        return process->AddImageToken(image_ptr);

    if (image_ptr == 0)
    {
        ValueObjectSP error_str_sp = result_valobj_sp->GetChildAtIndex(1, true);
        if (error_str_sp)
        {
            DataBufferSP buffer_sp(new DataBufferHeap(10240,0));
            size_t num_chars = error_str_sp->ReadPointedString (buffer_sp, error, 10240).first;
            if (error.Success() && num_chars > 0)
                error.SetErrorStringWithFormat("dlopen error: %s", buffer_sp->GetBytes());
            else
                error.SetErrorStringWithFormat("dlopen failed for unknown reasons.");
            return LLDB_INVALID_IMAGE_TOKEN;
        }
    }
    error.SetErrorStringWithFormat("unable to load '%s'", path);
    return LLDB_INVALID_IMAGE_TOKEN;
}

Error
PlatformPOSIX::UnloadImage (lldb_private::Process* process, uint32_t image_token)
{
    const addr_t image_addr = process->GetImagePtrFromToken(image_token);
    if (image_addr == LLDB_INVALID_ADDRESS)
        return Error("Invalid image token");

    StreamString expr;
    expr.Printf("dlclose((void *)0x%" PRIx64 ")", image_addr);
    const char *prefix = GetLibdlFunctionDeclarations();
    lldb::ValueObjectSP result_valobj_sp;
    Error error = EvaluateLibdlExpression(process, expr.GetData(), prefix, result_valobj_sp);
    if (error.Fail())
        return error;

    if (result_valobj_sp->GetError().Fail())
        return result_valobj_sp->GetError();

    Scalar scalar;
    if (result_valobj_sp->ResolveValue(scalar))
    {
        if (scalar.UInt(1))
            return Error("expression failed: \"%s\"", expr.GetData());
        process->ResetImageToken(image_token);
    }
    return Error();
}   

lldb::ProcessSP
PlatformPOSIX::ConnectProcess (const char* connect_url,
                               const char* plugin_name,
                               lldb_private::Debugger &debugger,
                               lldb_private::Target *target,
                               lldb_private::Error &error)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->ConnectProcess(connect_url,
                                                    plugin_name,
                                                    debugger,
                                                    target,
                                                    error);

    return Platform::ConnectProcess(connect_url, plugin_name, debugger, target, error);
}

const char*
PlatformPOSIX::GetLibdlFunctionDeclarations() const
{
    return R"(
              extern "C" void* dlopen(const char*, int);
              extern "C" void* dlsym(void*, const char*);
              extern "C" int   dlclose(void*);
              extern "C" char* dlerror(void);
             )";
}

size_t
PlatformPOSIX::ConnectToWaitingProcesses(Debugger& debugger, Error& error)
{
    if (m_remote_platform_sp)
        return m_remote_platform_sp->ConnectToWaitingProcesses(debugger, error);
    return Platform::ConnectToWaitingProcesses(debugger, error);
}