//===-- PlatformAndroid.cpp -----------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "lldb/Core/Module.h"

#include "lldb/Core/PluginManager.h"

#include "lldb/Core/Section.h"

#include "lldb/Core/ValueObject.h"

#include "lldb/Host/HostInfo.h"

#include "lldb/Utility/LLDBLog.h"

#include "lldb/Utility/Log.h"

#include "lldb/Utility/Scalar.h"

#include "lldb/Utility/UriParser.h"

#include "AdbClient.h"

#include "PlatformAndroid.h"

#include "PlatformAndroidRemoteGDBServer.h"

#include "lldb/Target/Target.h"

#include <optional>

using namespace lldb;

using namespace lldb_private;

using namespace lldb_private::platform_android;

using namespace std::chrono;

LLDB_PLUGIN_DEFINE(PlatformAndroid)

namespace {

#define LLDB_PROPERTIES_android

#include "PlatformAndroidProperties.inc"

enum {

#define LLDB_PROPERTIES_android

#include "PlatformAndroidPropertiesEnum.inc"

};

class PluginProperties : public Properties {

public:

  PluginProperties() {

    m_collection_sp = std::make_shared<OptionValueProperties>(

        PlatformAndroid::GetPluginNameStatic(false));

    m_collection_sp->Initialize(g_android_properties);

  }

};

static PluginProperties &GetGlobalProperties() {

  static PluginProperties g_settings;

  return g_settings;

}

uint32_t g_initialize_count = 0;

const unsigned int g_android_default_cache_size =

    2048; // Fits inside 4k adb packet.

} // end of anonymous namespace

void PlatformAndroid::Initialize() {

  PlatformLinux::Initialize();

  if (g_initialize_count++ == 0) {

#if defined(__ANDROID__)

    PlatformSP default_platform_sp(new PlatformAndroid(true));

    default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());

    Platform::SetHostPlatform(default_platform_sp);

#endif

    PluginManager::RegisterPlugin(

        PlatformAndroid::GetPluginNameStatic(false),

        PlatformAndroid::GetPluginDescriptionStatic(false),

        PlatformAndroid::CreateInstance, PlatformAndroid::DebuggerInitialize);

  }

}

void PlatformAndroid::Terminate() {

  if (g_initialize_count > 0) {

    if (--g_initialize_count == 0) {

      PluginManager::UnregisterPlugin(PlatformAndroid::CreateInstance);

    }

  }

  PlatformLinux::Terminate();

}

PlatformSP PlatformAndroid::CreateInstance(bool force, const ArchSpec *arch) {

  Log *log = GetLog(LLDBLog::Platform);

  if (log) {

    const char *arch_name;

    if (arch && arch->GetArchitectureName())

      arch_name = arch->GetArchitectureName();

    else

      arch_name = "<null>";

    const char *triple_cstr =

        arch ? arch->GetTriple().getTriple().c_str() : "<null>";

    LLDB_LOGF(log, "PlatformAndroid::%s(force=%s, arch={%s,%s})", __FUNCTION__,

              force ? "true" : "false", arch_name, triple_cstr);

  }

  bool create = force;

  if (!create && 
arch233
 && 
arch->IsValid()233
) {

    const llvm::Triple &triple = arch->GetTriple();

    switch (triple.getVendor()) {

    case llvm::Triple::PC:

      create = true;

      break;

#if defined(__ANDROID__)

    // Only accept "unknown" for the vendor if the host is android and if

    // "unknown" wasn't specified (it was just returned because it was NOT

    // specified).

    case llvm::Triple::VendorType::UnknownVendor:

      create = !arch->TripleVendorWasSpecified();

      break;

#endif

    default:

      break;

    }

    if (create) {

      switch (triple.getEnvironment()) {

      case llvm::Triple::Android:

        break;

#if defined(__ANDROID__)

      // Only accept "unknown" for the OS if the host is android and it

      // "unknown" wasn't specified (it was just returned because it was NOT

      // specified)

      case llvm::Triple::EnvironmentType::UnknownEnvironment:

        create = !arch->TripleEnvironmentWasSpecified();

        break;

#endif

      default:

        create = false;

        break;

      }

    }

  }

  if (create) {

    LLDB_LOGF(log, "PlatformAndroid::%s() creating remote-android platform",

              __FUNCTION__);

    return PlatformSP(new PlatformAndroid(false));

  }

  LLDB_LOGF(

      log, "PlatformAndroid::%s() aborting creation of remote-android platform",

      __FUNCTION__);

  return PlatformSP();

}

void PlatformAndroid::DebuggerInitialize(Debugger &debugger) {

  if (!PluginManager::GetSettingForPlatformPlugin(debugger,

                                                  GetPluginNameStatic(false))) {

    PluginManager::CreateSettingForPlatformPlugin(

        debugger, GetGlobalProperties().GetValueProperties(),

        "Properties for the Android platform plugin.",

        /*is_global_property=*/true);

  }

}

PlatformAndroid::PlatformAndroid(bool is_host)

    : PlatformLinux(is_host), m_sdk_version(0) {}

llvm::StringRef PlatformAndroid::GetPluginDescriptionStatic(bool is_host) {

  if (is_host)

    return "Local Android user platform plug-in.";

  return "Remote Android user platform plug-in.";

}

Status PlatformAndroid::ConnectRemote(Args &args) {

  m_device_id.clear();

  if (IsHost())

    return Status("can't connect to the host platform, always connected");

  if (!m_remote_platform_sp)

    m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer());

  const char *url = args.GetArgumentAtIndex(0);

  if (!url)

    return Status("URL is null.");

  std::optional<URI> parsed_url = URI::Parse(url);

  if (!parsed_url)

    return Status("Invalid URL: %s", url);

  if (parsed_url->hostname != "localhost")

    m_device_id = parsed_url->hostname.str();

  auto error = PlatformLinux::ConnectRemote(args);

  if (error.Success()) {

    AdbClient adb;

    error = AdbClient::CreateByDeviceID(m_device_id, adb);

    if (error.Fail())

      return error;

    m_device_id = adb.GetDeviceID();

  }

  return error;

}

Status PlatformAndroid::GetFile(const FileSpec &source,

                                const FileSpec &destination) {

  if (IsHost() || !m_remote_platform_sp)

    return PlatformLinux::GetFile(source, destination);

  FileSpec source_spec(source.GetPath(false), FileSpec::Style::posix);

  if (source_spec.IsRelative())

    source_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(

        source_spec.GetPathAsConstString(false).GetStringRef());

  Status error;

  auto sync_service = GetSyncService(error);

  if (error.Fail())

    return error;

  uint32_t mode = 0, size = 0, mtime = 0;

  error = sync_service->Stat(source_spec, mode, size, mtime);

  if (error.Fail())

    return error;

  if (mode != 0)

    return sync_service->PullFile(source_spec, destination);

  std::string source_file = source_spec.GetPath(false);

  Log *log = GetLog(LLDBLog::Platform);

  LLDB_LOGF(log, "Got mode == 0 on '%s': try to get file via 'shell cat'",

            source_file.c_str());

  if (strchr(source_file.c_str(), '\'') != nullptr)

    return Status("Doesn't support single-quotes in filenames");

  // mode == 0 can signify that adbd cannot access the file due security

  // constraints - try "cat ..." as a fallback.

  AdbClientUP adb(GetAdbClient(error));

  if (error.Fail())

    return error;

  char cmd[PATH_MAX];

  snprintf(cmd, sizeof(cmd), "%scat '%s'", GetRunAs().c_str(),

           source_file.c_str());

  return adb->ShellToFile(cmd, minutes(1), destination);

}

Status PlatformAndroid::PutFile(const FileSpec &source,

                                const FileSpec &destination, uint32_t uid,

                                uint32_t gid) {

  if (IsHost() || !m_remote_platform_sp)

    return PlatformLinux::PutFile(source, destination, uid, gid);

  FileSpec destination_spec(destination.GetPath(false), FileSpec::Style::posix);

  if (destination_spec.IsRelative())

    destination_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(

        destination_spec.GetPath(false));

  // TODO: Set correct uid and gid on remote file.

  Status error;

  auto sync_service = GetSyncService(error);

  if (error.Fail())

    return error;

  return sync_service->PushFile(source, destination_spec);

}

const char *PlatformAndroid::GetCacheHostname() { return m_device_id.c_str(); }

Status PlatformAndroid::DownloadModuleSlice(const FileSpec &src_file_spec,

                                            const uint64_t src_offset,

                                            const uint64_t src_size,

                                            const FileSpec &dst_file_spec) {

  // In Android API level 23 and above, dynamic loader is able to load .so

  // file directly from APK. In that case, src_offset will be an non-zero.

  if (src_offset == 0) // Use GetFile for a normal file.

    return GetFile(src_file_spec, dst_file_spec);

  std::string source_file = src_file_spec.GetPath(false);

  if (source_file.find('\'') != std::string::npos)

    return Status("Doesn't support single-quotes in filenames");

  // For zip .so file, src_file_spec will be "zip_path!/so_path".

  // Extract "zip_path" from the source_file.

  static constexpr llvm::StringLiteral k_zip_separator("!/");

  size_t pos = source_file.find(k_zip_separator);

  if (pos != std::string::npos)

    source_file = source_file.substr(0, pos);

  Status error;

  AdbClientUP adb(GetAdbClient(error));

  if (error.Fail())

    return error;

  // Use 'shell dd' to download the file slice with the offset and size.

  char cmd[PATH_MAX];

  snprintf(cmd, sizeof(cmd),

           "%sdd if='%s' iflag=skip_bytes,count_bytes "

           "skip=%" PRIu64 " count=%" PRIu64 " status=none",

           GetRunAs().c_str(), source_file.c_str(), src_offset, src_size);

  return adb->ShellToFile(cmd, minutes(1), dst_file_spec);

}

Status PlatformAndroid::DisconnectRemote() {

  Status error = PlatformLinux::DisconnectRemote();

  if (error.Success()) {

    m_device_id.clear();

    m_sdk_version = 0;

  }

  return error;

}

uint32_t PlatformAndroid::GetDefaultMemoryCacheLineSize() {

  return g_android_default_cache_size;

}

uint32_t PlatformAndroid::GetSdkVersion() {

  if (!IsConnected())

    return 0;

  if (m_sdk_version != 0)

    return m_sdk_version;

  std::string version_string;

  Status error;

  AdbClientUP adb(GetAdbClient(error));

  if (error.Fail())

    return 0;

  error =

      adb->Shell("getprop ro.build.version.sdk", seconds(5), &version_string);

  version_string = llvm::StringRef(version_string).trim().str();

  if (error.Fail() || version_string.empty()) {

    Log *log = GetLog(LLDBLog::Platform);

    LLDB_LOGF(log, "Get SDK version failed. (error: %s, output: %s)",

              error.AsCString(), version_string.c_str());

    return 0;

  }

  // FIXME: improve error handling

  llvm::to_integer(version_string, m_sdk_version);

  return m_sdk_version;

}

Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,

                                           const FileSpec &dst_file_spec) {

  // For oat file we can try to fetch additional debug info from the device

  llvm::StringRef extension = module_sp->GetFileSpec().GetFileNameExtension();

  if (extension != ".oat" && extension != ".odex")

    return Status(

        "Symbol file downloading only supported for oat and odex files");

  // If we have no information about the platform file we can't execute oatdump

  if (!module_sp->GetPlatformFileSpec())

    return Status("No platform file specified");

  // Symbolizer isn't available before SDK version 23

  if (GetSdkVersion() < 23)

    return Status("Symbol file generation only supported on SDK 23+");

  // If we already have symtab then we don't have to try and generate one

  if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) !=

      nullptr)

    return Status("Symtab already available in the module");

  Status error;

  AdbClientUP adb(GetAdbClient(error));

  if (error.Fail())

    return error;

  std::string tmpdir;

  error = adb->Shell("mktemp --directory --tmpdir /data/local/tmp", seconds(5),

                     &tmpdir);

  if (error.Fail() || tmpdir.empty())

    return Status("Failed to generate temporary directory on the device (%s)",

                  error.AsCString());

  tmpdir = llvm::StringRef(tmpdir).trim().str();

  // Create file remover for the temporary directory created on the device

  std::unique_ptr<std::string, std::function<void(std::string *)>>

      tmpdir_remover(&tmpdir, [&adb](std::string *s) {

        StreamString command;

        command.Printf("rm -rf %s", s->c_str());

        Status error = adb->Shell(command.GetData(), seconds(5), nullptr);

        Log *log = GetLog(LLDBLog::Platform);

        if (log && error.Fail())

          LLDB_LOGF(log, "Failed to remove temp directory: %s",

                    error.AsCString());

      });

  FileSpec symfile_platform_filespec(tmpdir);

  symfile_platform_filespec.AppendPathComponent("symbolized.oat");

  // Execute oatdump on the remote device to generate a file with symtab

  StreamString command;

  command.Printf("oatdump --symbolize=%s --output=%s",

                 module_sp->GetPlatformFileSpec().GetPath(false).c_str(),

                 symfile_platform_filespec.GetPath(false).c_str());

  error = adb->Shell(command.GetData(), minutes(1), nullptr);

  if (error.Fail())

    return Status("Oatdump failed: %s", error.AsCString());

  // Download the symbolfile from the remote device

  return GetFile(symfile_platform_filespec, dst_file_spec);

}

bool PlatformAndroid::GetRemoteOSVersion() {

  m_os_version = llvm::VersionTuple(GetSdkVersion());

  return !m_os_version.empty();

}

llvm::StringRef

PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {

  SymbolContextList matching_symbols;

  std::vector<const char *> dl_open_names = {"__dl_dlopen", "dlopen"};

  const char *dl_open_name = nullptr;

  Target &target = process->GetTarget();

  for (auto name : dl_open_names) {

    target.GetImages().FindFunctionSymbols(

        ConstString(name), eFunctionNameTypeFull, matching_symbols);

    if (matching_symbols.GetSize()) {

      dl_open_name = name;

      break;

    }

  }

  // Older platform versions have the dl function symbols mangled

  if (dl_open_name == dl_open_names[0])

    return R"(

              extern "C" void* dlopen(const char*, int) asm("__dl_dlopen");

              extern "C" void* dlsym(void*, const char*) asm("__dl_dlsym");

              extern "C" int   dlclose(void*) asm("__dl_dlclose");

              extern "C" char* dlerror(void) asm("__dl_dlerror");

             )";

  return PlatformPOSIX::GetLibdlFunctionDeclarations(process);

}

PlatformAndroid::AdbClientUP PlatformAndroid::GetAdbClient(Status &error) {

  AdbClientUP adb(std::make_unique<AdbClient>(m_device_id));

  if (adb)

    error.Clear();

  else

    error = Status("Failed to create AdbClient");

  return adb;

}

llvm::StringRef PlatformAndroid::GetPropertyPackageName() {

  return GetGlobalProperties().GetPropertyAtIndexAs<llvm::StringRef>(

      ePropertyPlatformPackageName, "");

}

std::string PlatformAndroid::GetRunAs() {

  llvm::StringRef run_as = GetPropertyPackageName();

  if (!run_as.empty()) {

    // When LLDB fails to pull file from a package directory due to security

    // constraint, user needs to set the package name to

    // 'platform.plugin.remote-android.package-name' property in order to run

    // shell commands as the package user using 'run-as' (e.g. to get file with

    // 'cat' and 'dd').

    // https://cs.android.com/android/platform/superproject/+/master:

    // system/core/run-as/run-as.cpp;l=39-61;

    // drc=4a77a84a55522a3b122f9c63ef0d0b8a6a131627

    return std::string("run-as '") + run_as.str() + "' ";

  }

  return run_as.str();

}

AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {

  if (m_adb_sync_svc && 
m_adb_sync_svc->IsConnected()0
)

    return m_adb_sync_svc.get();

  AdbClientUP adb(GetAdbClient(error));

  if (error.Fail())

    return nullptr;

  m_adb_sync_svc = adb->GetSyncService(error);

  return (error.Success()) ? m_adb_sync_svc.get() : 
nullptr0
;

}