main.c

Go to the documentation of this file.

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "fw_if_fs_posix.h"
#include "mdl_app.h"
#include "mdl_cli_internal.h"
#include "mdl_compose_internal.h"
#include "mdl_host_credentials_internal.h"
#include "mdl_sanitize.h"
#include "mdl_stream_internal.h"
#include "ra8_attributes.h"
#include "ra8_io_stream_posix.h"

typedef struct {
  alignas(max_align_t) uint8_t bytes[k_export_arena_bytes]; 
} export_arena_storage_t;

typedef struct {
  alignas(max_align_t) uint8_t bytes[k_storage_work_bytes]; 
} storage_workspace_t;

typedef struct {
  alignas(max_align_t) uint8_t bytes[k_mdl_storage_io_bytes]; 
} directory_workspace_t;

typedef enum : size_t {
  k_cookie_input_capacity = 64U * 1024U,  
  k_ca_pem_input_capacity = 512U * 1024U, 
} credential_input_capacity_t;

static export_arena_storage_t s_export_arena;
static fw_fs_t             s_fs;
static fw_fs_posix_state_t s_fs_posix = {.root_fd = -1};
static storage_workspace_t s_fs_file_work;
static storage_workspace_t s_fs_transaction_work;
static directory_workspace_t s_fs_directory_work;
static uint8_t s_fs_io_buffer[k_mdl_storage_io_bytes];
static char s_config_path[PATH_MAX];
static char s_library_path[PATH_MAX];
static char s_cache_path[PATH_MAX];
static char s_mode_path[PATH_MAX];
static uint8_t s_cookie_input[k_cookie_input_capacity];
static uint8_t s_ca_pem_input[k_ca_pem_input_capacity];
static mdl_app_context_t s_app;
static ra8_io_stream_t s_output;
static ra8_io_stream_t s_diagnostic;
static ra8_io_stream_posix_state_t s_output_posix;
static ra8_io_stream_posix_state_t s_diagnostic_posix;

RA8_INTERNAL static ra8_err_t internal_output_init(void)
{
  struct sigaction action = {.sa_handler = SIG_IGN};
  if ((sigemptyset(&action.sa_mask) != 0) || (sigaction(SIGPIPE, &action, nullptr) != 0)) {
    return k_ra8_err_comm_error;
  }
  ra8_err_t err = ra8_io_stream_posix_init(&s_output, &s_output_posix, STDOUT_FILENO);
  if (err == k_ra8_ok) {
    err = ra8_io_stream_posix_init(&s_diagnostic, &s_diagnostic_posix, STDERR_FILENO);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_diagnostic(const char* message)
{
  return ra8_io_stream_puts(&s_diagnostic, message);
}

RA8_INTERNAL static ra8_err_t
internal_read_credential(int fd, const struct stat* before, uint8_t* destination, size_t length)
{
  size_t offset = 0U;
  while (offset < length) {
    ssize_t received = pread(fd, destination + offset, length - offset, (off_t)offset);
    if ((received < 0) && (errno == EINTR)) {
      continue;
    }
    if (received <= 0) {
      return k_ra8_err_access_denied;
    }
    offset += (size_t)received;
  }
  uint8_t extra    = 0U;
  ssize_t overflow = 0;
  do {
    overflow = pread(fd, &extra, 1U, (off_t)length);
  } while ((overflow < 0) && (errno == EINTR));
  struct stat after = {};
  if ((overflow != 0) || (fstat(fd, &after) != 0) ||
      !priv_mdl_host_credential_stat_unchanged(before, &after)) {
    return k_ra8_err_access_denied;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_load_credential(const char* path,
                                                       uint8_t*    destination,
                                                       size_t      supplied,
                                                       size_t*     required,
                                                       size_t*     used)
{
  *required    = 0U;
  *used        = 0U;
  const int fd = open(path, O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK);
  if (fd < 0) {
    return k_ra8_err_access_denied;
  }
  struct stat before = {};
  ra8_err_t   error  = k_ra8_ok;
  if ((fstat(fd, &before) != 0) || (before.st_size < 0)) {
    error = k_ra8_err_access_denied;
  } else if (!S_ISREG(before.st_mode)) {
    error = k_ra8_err_invalid_arg;
  } else if ((uintmax_t)before.st_size > (uintmax_t)SIZE_MAX) {
    *required = SIZE_MAX;
    error     = k_ra8_err_invalid_size;
  } else {
    *required = (size_t)before.st_size;
    error = (*required > supplied) ? k_ra8_err_invalid_size
                                   : internal_read_credential(fd, &before, destination, *required);
  }
  if ((close(fd) != 0) && (error == k_ra8_ok)) {
    error = k_ra8_err_access_denied;
  }
  if (error == k_ra8_ok) {
    *used = *required;
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_credential_capacity_error(ra8_io_stream_t* diagnostic,
                                                                 const char*      option,
                                                                 size_t           required,
                                                                 size_t           supplied)
{
  ra8_err_t error = priv_mdl_stream_text(k_ra8_ok, diagnostic, "mdl: ");
  error           = priv_mdl_stream_text(error, diagnostic, option);
  error = priv_mdl_stream_text(error, diagnostic, " input exceeds credential capacity (required ");
  error = priv_mdl_stream_u64(error, diagnostic, required);
  error = priv_mdl_stream_text(error, diagnostic, ", supplied ");
  error = priv_mdl_stream_u64(error, diagnostic, supplied);
  return priv_mdl_stream_text(error, diagnostic, ")\n");
}

RA8_INTERNAL static ra8_err_t internal_prepare_credentials(const mdl_args_t* args,
                                                           mdl_net_policy_t* policy,
                                                           ra8_io_stream_t*  diagnostic)
{
  mdl_net_bytes_t cookies  = {};
  size_t          required = 0U;
  size_t          used     = 0U;
  policy->cookies          = (mdl_net_bytes_t){};
  policy->ca_pem           = (mdl_net_bytes_t){};
  if (args->cookie_file != nullptr) {
    ra8_err_t error = internal_load_credential(args->cookie_file,
                                               s_cookie_input,
                                               sizeof(s_cookie_input),
                                               &required,
                                               &used);
    if (error == k_ra8_err_invalid_size) {
      (void)internal_credential_capacity_error(diagnostic,
                                               "--cookie-file",
                                               required,
                                               sizeof(s_cookie_input));
    } else if (error != k_ra8_ok) {
      (void)ra8_io_stream_puts(diagnostic, "mdl: could not load safe --cookie-file input\n");
    }
    if (error != k_ra8_ok) {
      return error;
    }
    cookies = (used == 0U) ? (mdl_net_bytes_t){}
                           : (mdl_net_bytes_t){.data = s_cookie_input, .length = used};
  }
  if (args->ca_file == nullptr) {
    policy->cookies = cookies;
    return k_ra8_ok;
  }
  const ra8_err_t error = internal_load_credential(args->ca_file,
                                                   s_ca_pem_input,
                                                   sizeof(s_ca_pem_input),
                                                   &required,
                                                   &used);
  if (error == k_ra8_err_invalid_size) {
    (void)
      internal_credential_capacity_error(diagnostic, "--ca-file", required, sizeof(s_ca_pem_input));
  } else if ((error != k_ra8_ok) || (used == 0U)) {
    (void)ra8_io_stream_puts(diagnostic, "mdl: could not load safe nonempty --ca-file input\n");
  }
  if ((error != k_ra8_ok) || (used == 0U)) {
    return (error == k_ra8_ok) ? k_ra8_err_invalid_arg : error;
  }
  policy->cookies = cookies;
  policy->ca_pem  = (mdl_net_bytes_t){.data = s_ca_pem_input, .length = used};
  return k_ra8_ok;
}

RA8_INTERNAL static int internal_exit_from_error(ra8_err_t err, bool usage_error)
{
  if (err == k_ra8_ok) {
    return 0;
  }
  return (usage_error && (err == k_ra8_err_invalid_arg)) ? 2 : 1;
}

RA8_INTERNAL static ra8_err_t internal_storage_init(void)
{
  const fw_fs_posix_cfg_t cfg = {.root_path = "/", .removable_media = false};
  ra8_err_t               err = fw_fs_posix_init(&s_fs, &s_fs_posix, &cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  err = mdl_storage_init(&s_app.storage,
                         &s_fs,
                         s_fs_file_work.bytes,
                         sizeof(s_fs_file_work.bytes),
                         s_fs_transaction_work.bytes,
                         sizeof(s_fs_transaction_work.bytes),
                         s_fs_io_buffer,
                         sizeof(s_fs_io_buffer));
  if (err == k_ra8_ok) {
    err = mdl_library_workspace_init(&s_app.library_workspace,
                                     s_fs_directory_work.bytes,
                                     (uint32_t)sizeof(s_fs_directory_work.bytes));
  }
  if (err != k_ra8_ok) {
    (void)fw_fs_posix_deinit(&s_fs_posix);
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_resolve_config_path(mdl_args_t* args)
{
  if (args->cfg == nullptr) {
    return k_ra8_ok;
  }
  if (realpath(args->cfg, s_config_path) == nullptr) {
    return k_ra8_err_not_found;
  }
  if (strlen(s_config_path) >= (size_t)k_fw_fs_path_cap) {
    return k_ra8_err_invalid_size;
  }
  args->cfg = s_config_path;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_resolve_one_leaf(const char* input, char* destination, size_t capacity)
{
  if (realpath(input, destination) != nullptr) {
    if ((strlen(destination) >= capacity) || (strlen(destination) >= (size_t)k_fw_fs_path_cap)) {
      return k_ra8_err_invalid_size;
    }
    return k_ra8_ok;
  }
  const char* slash = strrchr(input, '/');
  const char* leaf  = (slash == nullptr) ? input : slash + 1;
  if ((leaf[0] == '\0') || (strcmp(leaf, ".") == 0) || (strcmp(leaf, "..") == 0)) {
    return k_ra8_err_invalid_arg;
  }
  char parent[PATH_MAX];
  if (slash == nullptr) {
    (void)memcpy(parent, ".", 2U);
  } else if (slash == input) {
    (void)memcpy(parent, "/", 2U);
  } else {
    const size_t parent_bytes = (size_t)(slash - input);
    if (parent_bytes >= sizeof(parent)) {
      return k_ra8_err_invalid_size;
    }
    memcpy(parent, input, parent_bytes);
    parent[parent_bytes] = '\0';
  }
  char canonical_parent[PATH_MAX];
  if (realpath(parent, canonical_parent) == nullptr) {
    return k_ra8_err_not_found;
  }
  if (!mdl_path_join(canonical_parent, leaf, destination, capacity)) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_resolve_output_path(mdl_args_t* args)
{
  const ra8_err_t error =
    internal_resolve_one_leaf(args->out, s_library_path, sizeof(s_library_path));
  if (error != k_ra8_ok) {
    return error;
  }
  args->out = s_library_path;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_resolve_cache_path(mdl_args_t* args)
{
  ra8_err_t error = k_ra8_ok;
  if (args->cache_dir == nullptr) {
    if (!mdl_path_join(args->out, ".mdl_cache", s_cache_path, sizeof(s_cache_path))) {
      return k_ra8_err_invalid_size;
    }
  } else {
    error = internal_resolve_one_leaf(args->cache_dir, s_cache_path, sizeof(s_cache_path));
  }
  if (error == k_ra8_ok) {
    args->cache_dir = s_cache_path;
  }
  return error;
}

RA8_INTERNAL static bool internal_uses_output_path(mdl_cli_mode_t mode)
{
  return (mode == k_mdl_cli_mode_series) || (mode == k_mdl_cli_mode_search) ||
         (mode == k_mdl_cli_mode_browse) || (mode == k_mdl_cli_mode_list) ||
         (mode == k_mdl_cli_mode_update_all) || (mode == k_mdl_cli_mode_remove) ||
         (mode == k_mdl_cli_mode_artifact) || (mode == k_mdl_cli_mode_page);
}

RA8_INTERNAL static bool internal_uses_cache_path(mdl_cli_mode_t mode)
{
  return (mode == k_mdl_cli_mode_series) || (mode == k_mdl_cli_mode_search) ||
         (mode == k_mdl_cli_mode_browse) || (mode == k_mdl_cli_mode_update_all);
}

RA8_INTERNAL static ra8_err_t internal_resolve_pack_path(mdl_args_t* args)
{
  if (realpath(args->pack, s_mode_path) == nullptr) {
    return k_ra8_err_not_found;
  }
  if (strlen(s_mode_path) >= (size_t)k_fw_fs_path_cap) {
    return k_ra8_err_invalid_size;
  }
  args->pack = s_mode_path;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_resolve_verify_path(mdl_args_t* args)
{
  const char* const saved_out = args->out;
  if (args->verify_dir != nullptr) {
    args->out = args->verify_dir;
  }
  const ra8_err_t error = internal_resolve_output_path(args);
  if (args->verify_dir != nullptr) {
    if (error == k_ra8_ok) {
      args->verify_dir = args->out;
    }
    args->out = saved_out;
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_resolve_descriptor_path(mdl_args_t* args)
{
  if (realpath(".", s_mode_path) == nullptr) {
    return k_ra8_err_not_found;
  }
  if (strlen(s_mode_path) >= (size_t)k_fw_fs_path_cap) {
    return k_ra8_err_invalid_size;
  }
  char sites[k_fw_fs_path_cap];
  if (!mdl_path_join(s_mode_path, "sites", sites, sizeof(sites))) {
    return k_ra8_err_invalid_size;
  }
  struct stat status = {};
  if (lstat(sites, &status) == 0) {
    if (S_ISDIR(status.st_mode) && !S_ISLNK(status.st_mode)) {
      (void)memcpy(s_mode_path, sites, strlen(sites) + 1U);
    }
  } else if (errno != ENOENT) {
    return k_ra8_err_access_denied;
  }
  args->out = s_mode_path;
  return k_ra8_ok;
}

RA8_INTERNAL static int
internal_prepare_args(mdl_args_t* args, mdl_cli_mode_t mode, ra8_io_stream_t* diagnostic)
{
  if (args->out == nullptr) {
    args->out = "downloads";
  }
  if (args->attr == nullptr) {
    args->attr = "data-src";
  }
  if (internal_resolve_config_path(args) != k_ra8_ok) {
    (void)ra8_io_stream_puts(diagnostic, "mdl: could not resolve config path\n");
    return 1;
  }
  ra8_err_t path_error = k_ra8_ok;
  if (internal_uses_output_path(mode)) {
    path_error = internal_resolve_output_path(args);
  } else if (mode == k_mdl_cli_mode_verify) {
    path_error = internal_resolve_verify_path(args);
  } else if (mode == k_mdl_cli_mode_pack) {
    path_error = internal_resolve_pack_path(args);
  } else if (mode == k_mdl_cli_mode_init_site) {
    path_error = internal_resolve_descriptor_path(args);
  }
  if (path_error != k_ra8_ok) {
    (void)ra8_io_stream_puts(diagnostic, "mdl: could not resolve portable command path\n");
    return 1;
  }
  if (internal_uses_cache_path(mode) && (internal_resolve_cache_path(args) != k_ra8_ok)) {
    (void)ra8_io_stream_puts(diagnostic, "mdl: could not resolve persistent cache path\n");
    return 1;
  }
  if (args->ignore_robots) {
    (void)ra8_io_stream_puts(diagnostic,
                             "mdl: WARNING: --ignore-robots set; "
                             "robots.txt will NOT be honoured\n");
  }
  return 0;
}

RA8_INTERNAL static int
internal_prepare_run_policy(const mdl_args_t* args, mdl_run_opts_t* opts, mdl_format_t* format)
{
  *format = mdl_format_from_str(args->format);
  if (*format == k_mdl_format_invalid) {
    const char* const parts[] = {"mdl: bad --format '",
                                 args->format,
                                 "' (loose|cbz|cbt|cbt.gz|epub|jof|rabook)\n"};
    const ra8_err_t   error =
      priv_mdl_cli_reject_parts(&s_diagnostic, parts, sizeof(parts) / sizeof(parts[0]));
    return internal_exit_from_error(error, true);
  }
  return (internal_prepare_credentials(args, &opts->policy, &s_diagnostic) == k_ra8_ok) ? 0 : 1;
}

RA8_INTERNAL static int internal_main_init(int argc, char** argv, mdl_args_t* a)
{
  if (internal_output_init() != k_ra8_ok) {
    return 1;
  }
  s_app.output     = &s_output;
  s_app.diagnostic = &s_diagnostic;
  s_app.io_error   = k_ra8_ok;
  mdl_export_workspace_init(&s_app.export_ws, s_export_arena.bytes, sizeof(s_export_arena.bytes));
  mdl_app_bind(&s_app);
  mdl_cli_parse(argc, argv, a);
  return 0;
}

RA8_INTERNAL static int internal_main_run(const mdl_args_t*     a,
                                          mdl_cli_mode_t        mode,
                                          mdl_format_t          format,
                                          const mdl_run_opts_t* opts,
                                          const mdl_nums_t*     nums)
{
  const mdl_series_run_t run = priv_mdl_compose_build_run(a, format, opts, nums);
  if (internal_storage_init() != k_ra8_ok) {
    (void)internal_diagnostic("mdl: could not initialize portable filesystem binding\n");
    return 1;
  }
  const int result = priv_mdl_compose_dispatch(a, mode, format, opts, nums, &run);
  if (fw_fs_posix_deinit(&s_fs_posix) != k_ra8_ok) {
    (void)internal_diagnostic("mdl: filesystem shutdown failed\n");
    return 1;
  }
  return result;
}

int main(int argc, char** argv)
{
  mdl_args_t a = {};
  if (internal_main_init(argc, argv, &a) != 0) {
    return 1;
  }
  mdl_cli_mode_t mode    = k_mdl_cli_mode_invalid;
  ra8_err_t      cli_err = mdl_cli_validate(&a, &s_diagnostic, &mode);
  if (cli_err != k_ra8_ok) {
    if ((cli_err == k_ra8_err_invalid_arg) && (mdl_cli_usage(&s_diagnostic, argv[0]) != k_ra8_ok)) {
      return 1;
    }
    return internal_exit_from_error(cli_err, true);
  }
  if (mode == k_mdl_cli_mode_help) {
    return internal_exit_from_error(mdl_cli_usage(&s_diagnostic, argv[0]), false);
  }
  if (mode == k_mdl_cli_mode_version) {
    return internal_exit_from_error(ra8_io_stream_puts(&s_output, "mdl 0.1.0\n"), false);
  }
  if (internal_prepare_args(&a, mode, &s_diagnostic) != 0) {
    return 1;
  }
 
  mdl_nums_t nums = {};
  cli_err         = mdl_cli_parse_nums(&a, &s_diagnostic, &nums);
  if (cli_err != k_ra8_ok) {
    return internal_exit_from_error(cli_err, true);
  }
  mdl_run_opts_t opts = mdl_cli_run_opts(&a);
  /* The one place this build form's transport is chosen. */
  opts.net                   = priv_mdl_compose_net_provider();
  mdl_format_t format        = k_mdl_format_invalid;
  const int    policy_status = internal_prepare_run_policy(&a, &opts, &format);
  if (policy_status != 0) {
    return policy_status;
  }
 
  return internal_main_run(&a, mode, format, &opts, &nums);
}