//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// system_utils_posix.cpp: Implementation of POSIX OS-specific functions.

#include "common/debug.h"
#include "system_utils.h"

#include <array>
#include <iostream>

#include <dlfcn.h>
#include <grp.h>
#include <inttypes.h>
#include <pwd.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include "common/string_utils.h"

#ifdef ANGLE_PLATFORM_FUCHSIA
#    include <zircon/process.h>
#    include <zircon/syscalls.h>
#else
#    include <sys/resource.h>
#endif

namespace angle
{

namespace
{
std::string GetModulePath(void *moduleOrSymbol)
{
    Dl_info dlInfo;
    if (dladdr(moduleOrSymbol, &dlInfo) == 0)
    {
        return "";
    }

#ifdef ANGLE_PLATFORM_LINUX
    // Chrome changes process title on Linux that causes dladdr returns wrong module
    // file name for executable binary, so return GetExecutablePath() if dli_fname
    // doesn't exist.
    struct stat buf;
    if (stat(dlInfo.dli_fname, &buf) != 0)
    {
        return GetExecutablePath();
    }
#endif

    return dlInfo.dli_fname;
}

void *OpenPosixLibrary(const std::string &fullPath, int extraFlags, std::string *errorOut)
{
    void *module = dlopen(fullPath.c_str(), RTLD_NOW | extraFlags);
    if (module)
    {
        if (errorOut)
        {
            *errorOut = fullPath;
        }
    }
    else if (errorOut)
    {
        *errorOut = "dlopen(";
        *errorOut += fullPath;
        *errorOut += ") failed with error: ";
        *errorOut += dlerror();
        struct stat sfile;
        if (-1 == stat(fullPath.c_str(), &sfile))
        {
            *errorOut += ", stat() call failed.";
        }
        else
        {
            *errorOut += ", stat() info: ";
            struct passwd *pwuser = getpwuid(sfile.st_uid);
            if (pwuser)
            {
                *errorOut += "owner: ";
                *errorOut += pwuser->pw_name;
                *errorOut += ", ";
            }
            struct group *grpnam = getgrgid(sfile.st_gid);
            if (grpnam)
            {
                *errorOut += "group: ";
                *errorOut += grpnam->gr_name;
                *errorOut += ", ";
            }
            *errorOut += "perms: ";
            *errorOut += std::to_string(sfile.st_mode);
            *errorOut += ", links: ";
            *errorOut += std::to_string(sfile.st_nlink);
            *errorOut += ", size: ";
            *errorOut += std::to_string(sfile.st_size);
        }
    }
    return module;
}
}  // namespace

Optional<std::string> GetCWD()
{
    std::array<char, 4096> pathBuf;
    char *result = getcwd(pathBuf.data(), pathBuf.size());
    if (result == nullptr)
    {
        return Optional<std::string>::Invalid();
    }
    return std::string(pathBuf.data());
}

bool SetCWD(const char *dirName)
{
    return (chdir(dirName) == 0);
}

bool UnsetEnvironmentVar(const char *variableName)
{
    return (unsetenv(variableName) == 0);
}

bool SetEnvironmentVar(const char *variableName, const char *value)
{
    return (setenv(variableName, value, 1) == 0);
}

std::string GetEnvironmentVar(const char *variableName)
{
    const char *value = getenv(variableName);
    return (value == nullptr ? std::string() : std::string(value));
}

const char *GetPathSeparatorForEnvironmentVar()
{
    return ":";
}

std::string GetModuleDirectoryAndGetError(std::string *errorOut)
{
    std::string directory;
    static int placeholderSymbol = 0;
    std::string moduleName       = GetModulePath(&placeholderSymbol);
    if (!moduleName.empty())
    {
        directory = moduleName.substr(0, moduleName.find_last_of('/') + 1);
    }

    // Ensure we return the full path to the module, not the relative path
    if (!IsFullPath(directory))
    {
        if (errorOut)
        {
            *errorOut += "Directory: '";
            *errorOut += directory;
            *errorOut += "' is not full path";
        }
        Optional<std::string> cwd = GetCWD();
        if (cwd.valid())
        {
            directory = ConcatenatePath(cwd.value(), directory);
            if (errorOut)
            {
                *errorOut += ", so it has been modified to: '";
                *errorOut += directory;
                *errorOut += "'. ";
            }
        }
        else if (errorOut)
        {
            *errorOut += " and getcwd was invalid. ";
        }
    }
    return directory;
}

std::string GetModuleDirectory()
{
    return GetModuleDirectoryAndGetError(nullptr);
}

void *OpenSystemLibraryWithExtensionAndGetError(const char *libraryName,
                                                SearchType searchType,
                                                std::string *errorOut)
{
    std::string directory;
    if (searchType == SearchType::ModuleDir)
    {
#if ANGLE_PLATFORM_IOS_FAMILY
        // On iOS, shared libraries must be loaded from within the app bundle.
        directory = GetExecutableDirectory() + "/Frameworks/";
#elif ANGLE_PLATFORM_FUCHSIA
        // On Fuchsia the dynamic loader always looks up libraries in /pkg/lib
        // and disallows loading of libraries via absolute paths.
        directory = "";
#else
        directory = GetModuleDirectoryAndGetError(errorOut);
#endif
    }

    int extraFlags = 0;
    if (searchType == SearchType::AlreadyLoaded)
    {
        extraFlags = RTLD_NOLOAD;
    }

    std::string fullPath = directory + libraryName;
    return OpenPosixLibrary(fullPath, extraFlags, errorOut);
}

void *GetLibrarySymbol(void *libraryHandle, const char *symbolName)
{
    if (!libraryHandle)
    {
        return nullptr;
    }

    return dlsym(libraryHandle, symbolName);
}

std::string GetLibraryPath(void *libraryHandle)
{
    if (!libraryHandle)
    {
        return "";
    }

    return GetModulePath(libraryHandle);
}

void CloseSystemLibrary(void *libraryHandle)
{
    if (libraryHandle)
    {
        dlclose(libraryHandle);
    }
}

bool IsDirectory(const char *filename)
{
    struct stat st;
    int result = stat(filename, &st);
    return result == 0 && ((st.st_mode & S_IFDIR) == S_IFDIR);
}

bool IsDebuggerAttached()
{
    // This could have a fuller implementation.
    // See https://cs.chromium.org/chromium/src/base/debug/debugger_posix.cc
    return false;
}

void BreakDebugger()
{
    // This could have a fuller implementation.
    // See https://cs.chromium.org/chromium/src/base/debug/debugger_posix.cc
    abort();
}

const char *GetExecutableExtension()
{
    return "";
}

char GetPathSeparator()
{
    return '/';
}

std::string GetRootDirectory()
{
    return "/";
}

bool CreateDirectories(const std::string &path)
{
    // First sanitize path so we can use "/" as universal path separator
    std::string sanitizedPath(path);
    MakeForwardSlashThePathSeparator(sanitizedPath);

    size_t pos = 0;
    do
    {
        pos = sanitizedPath.find("/", pos);
        std::string checkPath(sanitizedPath.substr(0, pos));
        if (!checkPath.empty() && !IsDirectory(checkPath.c_str()))
        {
            if (mkdir(checkPath.c_str(), S_IRWXU | S_IRWXG | S_IRWXO) == -1)
            {
                return false;
            }
        }
        if (pos == std::string::npos)
        {
            break;
        }
        ++pos;
    } while (true);
    return true;
}

void MakeForwardSlashThePathSeparator(std::string &path)
{
    // Nothing to do here for *nix side
    return;
}

Optional<std::string> GetTempDirectory()
{
    const char *tmp = getenv("TMPDIR");
    if (tmp != nullptr)
    {
        return std::string(tmp);
    }

#if defined(ANGLE_PLATFORM_ANDROID)
    // Not used right now in the ANGLE test runner.
    // return PathService::Get(DIR_CACHE, path);
    return Optional<std::string>::Invalid();
#else
    return std::string("/tmp");
#endif
}

Optional<std::string> CreateTemporaryFileInDirectory(const std::string &directory)
{
    return CreateTemporaryFileInDirectoryWithExtension(directory, std::string());
}

Optional<std::string> CreateTemporaryFileInDirectoryWithExtension(const std::string &directory,
                                                                  const std::string &extension)
{
    std::string tempFileTemplate = directory + "/.angle.XXXXXX" + extension;

    int fd = mkstemps(&tempFileTemplate[0], static_cast<int>(extension.size()));
    close(fd);

    if (fd != -1)
    {
        return tempFileTemplate;
    }

    return Optional<std::string>::Invalid();
}

double GetCurrentProcessCpuTime()
{
#ifdef ANGLE_PLATFORM_FUCHSIA
    static zx_handle_t me = zx_process_self();
    zx_info_task_runtime_t task_runtime;
    zx_object_get_info(me, ZX_INFO_TASK_RUNTIME, &task_runtime, sizeof(task_runtime), nullptr,
                       nullptr);
    return static_cast<double>(task_runtime.cpu_time) * 1e-9;
#else
    // We could also have used /proc/stat, but that requires us to read the
    // filesystem and convert from jiffies. /proc/stat also relies on jiffies
    // (lower resolution) while getrusage can potentially use a sched_clock()
    // underneath that has higher resolution.
    struct rusage usage;
    getrusage(RUSAGE_SELF, &usage);
    double userTime   = usage.ru_utime.tv_sec + usage.ru_utime.tv_usec * 1e-6;
    double systemTime = usage.ru_stime.tv_sec + usage.ru_stime.tv_usec * 1e-6;
    return userTime + systemTime;
#endif
}

namespace
{
bool SetMemoryProtection(uintptr_t start, size_t size, int protections)
{
    int ret = mprotect(reinterpret_cast<void *>(start), size, protections);
    if (ret < 0)
    {
        perror("mprotect failed");
    }
    return ret == 0;
}

class PosixPageFaultHandler : public PageFaultHandler
{
  public:
    PosixPageFaultHandler(PageFaultCallback callback) : PageFaultHandler(callback) {}
    ~PosixPageFaultHandler() override {}

    bool enable() override;
    bool disable() override;
    void handle(int sig, siginfo_t *info, void *unused);

  private:
    struct sigaction mDefaultBusAction  = {};
    struct sigaction mDefaultSegvAction = {};
};

PosixPageFaultHandler *gPosixPageFaultHandler = nullptr;
void SegfaultHandlerFunction(int sig, siginfo_t *info, void *unused)
{
    gPosixPageFaultHandler->handle(sig, info, unused);
}

void PosixPageFaultHandler::handle(int sig, siginfo_t *info, void *unused)
{
    bool found = false;
    if ((sig == SIGSEGV || sig == SIGBUS) &&
        (info->si_code == SEGV_ACCERR || info->si_code == SEGV_MAPERR))
    {
        found = mCallback(reinterpret_cast<uintptr_t>(info->si_addr)) ==
                PageFaultHandlerRangeType::InRange;
    }

    // Fall back to default signal handler
    if (!found)
    {
        if (sig == SIGSEGV)
        {
            mDefaultSegvAction.sa_sigaction(sig, info, unused);
        }
        else if (sig == SIGBUS)
        {
            mDefaultBusAction.sa_sigaction(sig, info, unused);
        }
        else
        {
            UNREACHABLE();
        }
    }
}

bool PosixPageFaultHandler::disable()
{
    return sigaction(SIGSEGV, &mDefaultSegvAction, nullptr) == 0 &&
           sigaction(SIGBUS, &mDefaultBusAction, nullptr) == 0;
}

bool PosixPageFaultHandler::enable()
{
    struct sigaction sigAction = {};
    sigAction.sa_flags         = SA_SIGINFO;
    sigAction.sa_sigaction     = &SegfaultHandlerFunction;
    sigemptyset(&sigAction.sa_mask);

    // Some POSIX implementations use SIGBUS for mprotect faults
    return sigaction(SIGSEGV, &sigAction, &mDefaultSegvAction) == 0 &&
           sigaction(SIGBUS, &sigAction, &mDefaultBusAction) == 0;
}
}  // namespace

// Set write protection
bool ProtectMemory(uintptr_t start, size_t size)
{
    return SetMemoryProtection(start, size, PROT_READ);
}

// Allow reading and writing
bool UnprotectMemory(uintptr_t start, size_t size)
{
    return SetMemoryProtection(start, size, PROT_READ | PROT_WRITE);
}

size_t GetPageSize()
{
    long pageSize = sysconf(_SC_PAGE_SIZE);
    if (pageSize < 0)
    {
        perror("Could not get sysconf page size");
        return 0;
    }
    return static_cast<size_t>(pageSize);
}

PageFaultHandler *CreatePageFaultHandler(PageFaultCallback callback)
{
    gPosixPageFaultHandler = new PosixPageFaultHandler(callback);
    return gPosixPageFaultHandler;
}

uint64_t GetProcessMemoryUsageKB()
{
    FILE *file = fopen("/proc/self/status", "r");

    if (!file)
    {
        return 0;
    }

    const char *kSearchString           = "VmRSS:";
    constexpr size_t kMaxLineSize       = 100;
    std::array<char, kMaxLineSize> line = {};

    uint64_t kb = 0;

    while (fgets(line.data(), line.size(), file) != nullptr)
    {
        if (strncmp(line.data(), kSearchString, strlen(kSearchString)) == 0)
        {
            std::vector<std::string> strings;
            SplitStringAlongWhitespace(line.data(), &strings);

            sscanf(strings[1].c_str(), "%" SCNu64, &kb);
            break;
        }
    }
    fclose(file);

    return kb;
}
}  // namespace angle