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

#include "src/developer/debug/debug_agent/linux_binary_launcher.h"

#include <fcntl.h>
#include <sys/ptrace.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <unistd.h>
#include <zircon/errors.h>

#include "src/developer/debug/debug_agent/linux_process_handle.h"
#include "src/developer/debug/debug_agent/linux_task.h"
#include "src/developer/debug/debug_agent/linux_utils.h"
#include "src/developer/debug/debug_agent/posix/dir_reader_linux.h"
#include "src/developer/debug/debug_agent/posix/eintr_wrapper.h"
#include "src/developer/debug/debug_agent/posix/file_descriptor_shuffle.h"
#include "src/lib/fxl/strings/string_printf.h"

namespace debug_agent {

namespace {

static const rlim_t kSystemDefaultMaxFds = 8192;
static const char kFDDir[] = "/proc/self/fd";

size_t GetMaxFds() {
  rlim_t max_fds;
  struct rlimit nofile;
  if (getrlimit(RLIMIT_NOFILE, &nofile)) {
    // getrlimit failed. Take a best guess.
    max_fds = kSystemDefaultMaxFds;
  } else {
    max_fds = nofile.rlim_cur;
  }

  if (max_fds > INT_MAX)
    max_fds = INT_MAX;

  return static_cast<size_t>(max_fds);
}

void CloseSuperfluousFds(const posix::InjectiveMultimap& saved_mapping) {
  // DANGER: no calls to malloc or locks are allowed from now on:
  // http://crbug.com/36678

  // Get the maximum number of FDs possible.
  size_t max_fds = GetMaxFds();

  ::linux::DirReaderLinux fd_dir(kFDDir);
  if (!fd_dir.IsValid()) {
    // Fallback case: Try every possible fd.
    for (size_t i = 0; i < max_fds; ++i) {
      const int fd = static_cast<int>(i);
      if (fd == STDIN_FILENO || fd == STDOUT_FILENO || fd == STDERR_FILENO)
        continue;
      // Cannot use STL iterators here, since debug iterators use locks.
      size_t j;
      for (j = 0; j < saved_mapping.size(); j++) {
        if (fd == saved_mapping[j].dest)
          break;
      }
      if (j < saved_mapping.size())
        continue;

      // Since we're just trying to close anything we can find, ignore any error return values of
      // close().
      close(fd);
    }
    return;
  }

  const int dir_fd = fd_dir.fd();

  for (; fd_dir.Next();) {
    // Skip . and .. entries.
    if (fd_dir.name()[0] == '.')
      continue;

    char* endptr;
    errno = 0;
    const long int fd = strtol(fd_dir.name(), &endptr, 10);
    if (fd_dir.name()[0] == 0 || *endptr || fd < 0 || errno ||
        fd > static_cast<decltype(fd)>(std::numeric_limits<int>::max())) {
      continue;
    }
    if (fd == STDIN_FILENO || fd == STDOUT_FILENO || fd == STDERR_FILENO)
      continue;
    // Cannot use STL iterators here, since debug iterators use locks.
    size_t i;
    for (i = 0; i < saved_mapping.size(); i++) {
      if (fd == saved_mapping[i].dest)
        break;
    }
    if (i < saved_mapping.size())
      continue;
    if (fd == dir_fd)
      continue;

    int ret = IGNORE_EINTR(close(static_cast<int>(fd)));
    FX_DCHECK(ret == 0);
  }
}

}  // namespace

debug::Status LinuxBinaryLauncher::Setup(const std::vector<std::string>& argv) {
  if (argv.empty())
    return debug::Status("No program specified");

  // Create the pipes to redirect stdout and stderr. Note: [0] = read, [1] = write
  int stdout_pipe[2] = {0, 0};
  if (pipe2(stdout_pipe, 0) != 0) {
    return debug::Status("Could not create pipe for stdout.");
  }
  int stderr_pipe[2] = {0, 0};
  if (pipe2(stderr_pipe, 0) != 0) {
    return debug::Status("Could not create pipe for stdout.");
  }

  // For redirecting stdin, stdout, and stderr. This needs to be allocated before forking to avoid
  // allocating in the child. We need two copies because one will be destructively modified.
  posix::InjectiveMultimap fd_shuffle1;
  posix::InjectiveMultimap fd_shuffle2;
  fd_shuffle1.reserve(3);
  fd_shuffle2.reserve(3);

  // Construct the parameter array.
  std::vector<char*> ptrs;
  for (const auto& arg : argv)
    ptrs.push_back(const_cast<char*>(arg.c_str()));
  ptrs.push_back(nullptr);

  pid_ = fork();
  if (pid_ == 0) {
    // DANGER: fork() rule: in the child, if you don't end up doing exec*(), you call _exit()
    // instead of exit(). This is because _exit() does not call any previously-registered (in the
    // parent) exit handlers, which might do things like block waiting for threads that don't even
    // exist in the child.

    // Map /dev/null to stdin so programs waiting for input (as for readline) don't hang.
    {
      int null_fd = HANDLE_EINTR(open("/dev/null", O_RDONLY));
      if (null_fd == -1) {
        _exit(127);
      }

      int new_null_fd = HANDLE_EINTR(dup2(null_fd, STDIN_FILENO));
      if (new_null_fd != STDIN_FILENO) {
        _exit(127);
      }
      IGNORE_EINTR(close(null_fd));
    }

    // Redirect output to our pipes (for both copies of the shuffle structure).
    fd_shuffle1.push_back(posix::InjectionArc(stdout_pipe[1], STDOUT_FILENO, false));
    fd_shuffle2.push_back(posix::InjectionArc(stdout_pipe[1], STDOUT_FILENO, false));
    fd_shuffle1.push_back(posix::InjectionArc(stderr_pipe[1], STDERR_FILENO, false));
    fd_shuffle2.push_back(posix::InjectionArc(stderr_pipe[1], STDERR_FILENO, false));

    // NOTE: fd_shuffle1 is destructively mutated by this call: it can not be used after this.
    if (!posix::ShuffleFileDescriptors(&fd_shuffle1)) {
      _exit(127);
    }

    CloseSuperfluousFds(fd_shuffle2);

    ptrace(PTRACE_TRACEME, 0, nullptr, nullptr);

    // Child process. Execve returns only on failure.
    execv(argv[0].c_str(), &ptrs[0]);
    _exit(1);
  } else {
    // Close our copy of the write end of the stdio handles.
    IGNORE_EINTR(close(stdout_pipe[1]));
    IGNORE_EINTR(close(stderr_pipe[1]));

    // Make our read end of the pipes non-blocking (expected by the handle watching system).
    int flags = fcntl(stdout_pipe[0], F_GETFL);
    if (flags != -1 && (flags & O_NONBLOCK) == 0) {
      fcntl(stdout_pipe[0], F_SETFL, flags | O_NONBLOCK);
    }
    flags = fcntl(stderr_pipe[0], F_GETFL);
    if (flags != -1 && (flags & O_NONBLOCK) == 0) {
      fcntl(stderr_pipe[0], F_SETFL, flags | O_NONBLOCK);
    }

    stdio_handles_.out = OwnedStdioHandle(stdout_pipe[0]);
    stdio_handles_.err = OwnedStdioHandle(stderr_pipe[0]);
  }

  // The execv will issue a trap just after setting up the new process. To ensure the new process is
  // set up by the time we return, block on that signal.
  int status = 0;
  if (waitpid(pid_, &status, 0) < 0)
    return debug::ErrnoStatus(errno, "Can't create process.");

  if (WIFEXITED(status)) {
    // If it exits before we got a stop signal, that means exec failed and the process exited.
    return debug::Status(fxl::StringPrintf("Can't launch '%s'.", argv[0].c_str()));
  }

  if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP) {
    DEBUG_LOG(Process) << "Unexpected first signal from the child.";
    return debug::Status("Unexpected signal " + std::to_string(status));
  }

  task_ = fxl::MakeRefCounted<LinuxTask>(pid_, true);

  // The process is now stopped. We need to track this suspension such that later parts of the
  // initialization can use SuspendHandles without resuming the process when those go out-of-scope.
  //
  // As a result, we manually take a suspend reference count to account for the current stop.
  task_->suspend_count_++;
  holding_initial_suspend_ = true;

  return debug::Status();
}

StdioHandles LinuxBinaryLauncher::ReleaseStdioHandles() { return std::move(stdio_handles_); }

std::unique_ptr<ProcessHandle> LinuxBinaryLauncher::GetProcess() const {
  return std::make_unique<LinuxProcessHandle>(task_);
}

debug::Status LinuxBinaryLauncher::Start() {
  // Continue from the first trap caught in Setup(). Decrement the suspend count using the official
  // Task::DecrementSuspendCount() function because we want this to actually resume the task
  // (assuming that the suspend count is going to 0).
  FX_DCHECK(holding_initial_suspend_);
  holding_initial_suspend_ = false;
  task_->DecrementSuspendCount();
  return debug::Status();
}

}  // namespace debug_agent