child.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <fcntl.h>
#include <string>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <unistd.h>
 
#include "../std/expected.hpp"
#include "../lib/linux.hpp"
#include "../lib/env.hpp"
#include "../lib/subprocess.hpp"
#include "../db/portal/message.hpp"
#include "../db/portal/daemon.hpp"
#include "config.hpp"
 
namespace fs = std::filesystem;

namespace ns_portal::ns_child
{
 
namespace ns_daemon = ns_db::ns_portal::ns_daemon;
namespace ns_message = ns_db::ns_portal::ns_message;
 

[[nodiscard]] inline Value<void> write_fifo(int const value, fs::path const& path_fifo)
{
  // Write to fifo
  ssize_t bytes_written = ns_linux::open_write_with_timeout(path_fifo
    , std::chrono::seconds(SECONDS_TIMEOUT)
    , std::span<pid_t const>(&value, 1)
  );
  // Check success with number of written bytes
  return_if(bytes_written != sizeof(value), Error("E::Failed to write pid: {}", strerror(errno)));
  return {};
}

[[nodiscard]] inline Value<void> spawn(std::vector<std::string> const& vec_argv
  , ns_db::ns_portal::ns_message::Message const& message)
{
  using ns_subprocess::ArgsCallbackParent;
  using ns_subprocess::ArgsCallbackChild;
  // Split cmd / args
  fs::path command = ({
    auto program = Try(vec_argv.at(0));
    auto path_bin_program = ns_env::search_path(program);
    if(not path_bin_program)
    {
      write_fifo(-1, message.get_pid()).discard("C::Failed to write pid to fifo");
      write_fifo(1, message.get_exit()).discard("C::Failed to write exit code to fifo");
      return Error("E::Could not find program '{}'", program);
    }
    path_bin_program.value();
  });
  std::vector<std::string> args(vec_argv.begin()+1, vec_argv.end());
  // Spawn child with a callback to open and redirect FIFOs
  auto child = ns_subprocess::Subprocess(command)
    .with_args(args)
    .with_env(message.get_environment())
    .with_die_on_pid(getpid())
    .with_callback_child([&message]([[maybe_unused]] ns_subprocess::ArgsCallbackChild args) {
      // Open stdin FIFO for reading and redirect to stdin (FD 0)
      int fd_stdin = ns_linux::open_with_timeout(message.get_stdin()
        , std::chrono::seconds(SECONDS_TIMEOUT)
        , O_RDONLY
      );
      if (fd_stdin < 0 or dup2(fd_stdin, STDIN_FILENO) < 0) {
        logger("E::Failed to open/redirect stdin FIFO: {}", strerror(errno));
        _exit(1);
      }
      if (fd_stdin != STDIN_FILENO) close(fd_stdin);
 
      // Open stdout FIFO for writing and redirect to stdout (FD 1)
      int fd_stdout = ns_linux::open_with_timeout(message.get_stdout()
        , std::chrono::seconds(SECONDS_TIMEOUT)
        , O_WRONLY
      );
      if (fd_stdout < 0 or dup2(fd_stdout, STDOUT_FILENO) < 0) {
        logger("E::Failed to open/redirect stdout FIFO: {}", strerror(errno));
        _exit(1);
      }
      if (fd_stdout != STDOUT_FILENO) close(fd_stdout);
 
      // Open stderr FIFO for writing and redirect to stderr (FD 2)
      int fd_stderr = ns_linux::open_with_timeout(message.get_stderr()
        , std::chrono::seconds(SECONDS_TIMEOUT)
        , O_WRONLY
      );
      if (fd_stderr < 0 or dup2(fd_stderr, STDERR_FILENO) < 0) {
        logger("E::Failed to open/redirect stderr FIFO: {}", strerror(errno));
        _exit(1);
      }
      if (fd_stderr != STDERR_FILENO) close(fd_stderr);
    })
    .spawn();
 
  // Write pid to fifo
  pid_t pid_child = child->get_pid().value_or(-1);
  write_fifo(pid_child, message.get_pid()).discard("C::Failed to write pid to fifo");
  // Wait for child to finish
  int code = Pop(child->wait(), "E::Child exited abnormally");
  logger("D::Exit code: {}", code);
  // Send exit code of child through a fifo
  write_fifo(code, message.get_exit()).discard("C::Failed to write exit code to fifo");
  return {};
}

[[nodiscard]] inline Value<void> spawn(ns_daemon::ns_log::Logs logs, ns_message::Message const& message)
{
  // Setup child logging
  fs::path path_file_log = ns_fs::placeholders_replace(logs.get_path_file_child(), getpid());
  Try(fs::create_directories(path_file_log.parent_path()));
  ns_log::set_sink_file(ns_fs::placeholders_replace(path_file_log, getpid()));
  // Get command from message
  auto vec_argv = message.get_command();
  // Ignore on empty command
  if ( vec_argv.empty() ) { return Error("E::Empty command"); }
  // Perform execve
  Pop(spawn(vec_argv, message));
  return {};
}
 
} // namespace ns_portal::ns_child