mdl_cli.c

Go to the documentation of this file.

#include "mdl_cli.h"
 
#include <stdlib.h>
#include <string.h>
 
#include "mdl_cli_internal.h"
#include "ra8_attributes.h"

typedef enum : uint8_t {
  k_cli_dec_base = 10, 
} mdl_cli_run_parse_t;

typedef enum : uint64_t {
  k_max_response_bytes_def = 64ULL * 1024ULL * 1024ULL, 
} mdl_cli_cap_t;

RA8_INTERNAL static bool internal_is_option_value(const char* flag, const char* value)
{
  if (value == nullptr) {
    return false;
  }
  if (value[0] != '-') {
    return true;
  }
  if (strcmp(flag, "--from") != 0) {
    return false;
  }
  if ((value[1] >= '0') && (value[1] <= '9')) {
    return true;
  }
  return value[1] == '.';
}

RA8_INTERNAL static bool
internal_take_opt(char** argv, int argc, int* i, const char* flag, const char** dst, bool* bad)
{
  if ((argv[*i] == nullptr) || (strcmp(argv[*i], flag) != 0)) {
    return false;
  }
  if (((*i + 1) < argc) && internal_is_option_value(flag, argv[*i + 1])) {
    *i += 1;
    if (*dst != nullptr) {
      *bad = true;
    }
    *dst = argv[*i];
  } else {
    *bad = true;
  }
  return true;
}

RA8_INTERNAL static bool internal_take_flag(const char* arg, const char* flag, bool* dst, bool* bad)
{
  if ((arg != nullptr) && (strcmp(arg, flag) == 0)) {
    if (*dst) {
      *bad = true;
    }
    *dst = true;
    return true;
  }
  return false;
}

RA8_INTERNAL static bool internal_parse_bool_flags(const char* arg, mdl_args_t* a)
{
  return internal_take_flag(arg, "--help", &a->help, &a->bad) ||
         internal_take_flag(arg, "-h", &a->help, &a->bad) ||
         internal_take_flag(arg, "--version", &a->version, &a->bad) ||
         internal_take_flag(arg, "--separate", &a->separate, &a->bad) ||
         internal_take_flag(arg, "--update", &a->update, &a->bad) ||
         internal_take_flag(arg, "--list", &a->list, &a->bad) ||
         internal_take_flag(arg, "--update-all", &a->update_all, &a->bad) ||
         internal_take_flag(arg, "--browse", &a->browse, &a->bad) ||
         internal_take_flag(arg, "--polite", &a->polite, &a->bad) ||
         internal_take_flag(arg, "--ignore-robots", &a->ignore_robots, &a->bad) ||
         internal_take_flag(arg, "--allow-private", &a->allow_private, &a->bad) ||
         internal_take_flag(arg, "--cross-host", &a->cross_host, &a->bad) ||
         internal_take_flag(arg, "--allow-incomplete", &a->allow_incomplete, &a->bad) ||
         internal_take_flag(arg, "--progress", &a->progress, &a->bad) ||
         internal_take_flag(arg, "--refetch", &a->refetch, &a->bad);
}

RA8_INTERNAL static bool internal_parse_verify_opt(int argc, char** argv, int* i, mdl_args_t* a)
{
  if ((argv[*i] == nullptr) || (strcmp(argv[*i], "--verify") != 0)) {
    return false;
  }
  if (a->verify) {
    a->bad = true;
  }
  a->verify = true;
  if (((*i + 1) < argc) && (argv[*i + 1] != nullptr) && (argv[*i + 1][0] != '-')) {
    *i += 1;
    a->verify_dir = argv[*i];
  }
  return true;
}

RA8_INTERNAL static bool internal_parse_value_opt(int argc, char** argv, int* i, mdl_args_t* a)
{
  const struct {
    const char*  flag; 
    const char** dst;  
  } opts[] = {
    {"--config", &a->cfg},
    {"--series", &a->series},
    {"--out", &a->out},
    {"--cache-dir", &a->cache_dir},
    {"--attr", &a->attr},
    {"--chapters", &a->chapters},
    {"--from", &a->from},
    {"--max", &a->max},
    {"--seed", &a->seed},
    {"--timeout", &a->timeout},
    {"--format", &a->format},
    {"--pack", &a->pack},
    {"--contact", &a->contact},
    {"--max-bytes", &a->max_bytes},
    {"--remove", &a->remove_series},
    {"--search", &a->search},
    {"--pick", &a->pick},
    {"--proxy", &a->proxy},
    {"--socks5", &a->socks5},
    {"--cookie-file", &a->cookie_file},
    {"--ca-file", &a->ca_file},
    {"--init-site", &a->init_site_url},
  };
  for (size_t k = 0U; k < (sizeof(opts) / sizeof(opts[0])); ++k) {
    if (internal_take_opt(argv, argc, i, opts[k].flag, opts[k].dst, &a->bad)) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static void internal_parse_positional_or_bad(const char* arg, mdl_args_t* a)
{
  if ((arg != nullptr) && (arg[0] != '-')) {
    if (a->page_url != nullptr) {
      a->bad = true;
    }
    a->page_url = arg;
    return;
  }
  a->bad = true;
}
 
void mdl_cli_parse(int argc, char** argv, mdl_args_t* a)
{
  for (int i = 1; i < argc; ++i) {
    if (internal_parse_bool_flags(argv[i], a) || internal_parse_verify_opt(argc, argv, &i, a) ||
        internal_parse_value_opt(argc, argv, &i, a)) {
      continue;
    }
    internal_parse_positional_or_bad(argv[i], a);
  }
}

typedef enum : uint64_t {
  k_arg_cfg              = 1ULL << 0U,  
  k_arg_series           = 1ULL << 1U,  
  k_arg_page             = 1ULL << 2U,  
  k_arg_out              = 1ULL << 3U,  
  k_arg_attr             = 1ULL << 4U,  
  k_arg_chapters         = 1ULL << 5U,  
  k_arg_from             = 1ULL << 6U,  
  k_arg_max              = 1ULL << 7U,  
  k_arg_seed             = 1ULL << 8U,  
  k_arg_timeout          = 1ULL << 9U,  
  k_arg_format           = 1ULL << 10U, 
  k_arg_pack             = 1ULL << 11U, 
  k_arg_contact          = 1ULL << 12U, 
  k_arg_max_bytes        = 1ULL << 13U, 
  k_arg_remove           = 1ULL << 14U, 
  k_arg_search           = 1ULL << 15U, 
  k_arg_pick             = 1ULL << 16U, 
  k_arg_proxy            = 1ULL << 17U, 
  k_arg_socks5           = 1ULL << 18U, 
  k_arg_cookie           = 1ULL << 19U, 
  k_arg_verify_dir       = 1ULL << 20U, 
  k_arg_init             = 1ULL << 21U, 
  k_arg_browse           = 1ULL << 22U, 
  k_arg_separate         = 1ULL << 23U, 
  k_arg_update           = 1ULL << 24U, 
  k_arg_list             = 1ULL << 25U, 
  k_arg_update_all       = 1ULL << 26U, 
  k_arg_polite           = 1ULL << 27U, 
  k_arg_ignore_robots    = 1ULL << 28U, 
  k_arg_allow_private    = 1ULL << 29U, 
  k_arg_cross_host       = 1ULL << 30U, 
  k_arg_allow_incomplete = 1ULL << 31U, 
  k_arg_progress         = 1ULL << 32U, 
  k_arg_refetch          = 1ULL << 33U, 
  k_arg_verify           = 1ULL << 34U, 
  k_arg_help             = 1ULL << 35U, 
  k_arg_version          = 1ULL << 36U, 
  k_arg_ca_file          = 1ULL << 37U, 
  k_arg_cache_dir        = 1ULL << 38U, 
} mdl_cli_arg_bit_t;

RA8_INTERNAL static uint64_t internal_value_bit(const void* value, uint64_t bit)
{
  return (value != nullptr) ? bit : 0U;
}

RA8_INTERNAL static uint64_t internal_flag_bit(bool value, uint64_t bit)
{
  return value ? bit : 0U;
}

RA8_INTERNAL static uint64_t internal_args_mask(const mdl_args_t* a)
{
  return internal_value_bit(a->cfg, k_arg_cfg) | internal_value_bit(a->series, k_arg_series) |
         internal_value_bit(a->page_url, k_arg_page) | internal_value_bit(a->out, k_arg_out) |
         internal_value_bit(a->cache_dir, k_arg_cache_dir) |
         internal_value_bit(a->attr, k_arg_attr) | internal_value_bit(a->chapters, k_arg_chapters) |
         internal_value_bit(a->from, k_arg_from) | internal_value_bit(a->max, k_arg_max) |
         internal_value_bit(a->seed, k_arg_seed) | internal_value_bit(a->timeout, k_arg_timeout) |
         internal_value_bit(a->format, k_arg_format) | internal_value_bit(a->pack, k_arg_pack) |
         internal_value_bit(a->contact, k_arg_contact) |
         internal_value_bit(a->max_bytes, k_arg_max_bytes) |
         internal_value_bit(a->remove_series, k_arg_remove) |
         internal_value_bit(a->search, k_arg_search) | internal_value_bit(a->pick, k_arg_pick) |
         internal_value_bit(a->proxy, k_arg_proxy) | internal_value_bit(a->socks5, k_arg_socks5) |
         internal_value_bit(a->cookie_file, k_arg_cookie) |
         internal_value_bit(a->ca_file, k_arg_ca_file) |
         internal_value_bit(a->verify_dir, k_arg_verify_dir) |
         internal_value_bit(a->init_site_url, k_arg_init) |
         internal_flag_bit(a->browse, k_arg_browse) |
         internal_flag_bit(a->separate, k_arg_separate) |
         internal_flag_bit(a->update, k_arg_update) | internal_flag_bit(a->list, k_arg_list) |
         internal_flag_bit(a->update_all, k_arg_update_all) |
         internal_flag_bit(a->polite, k_arg_polite) |
         internal_flag_bit(a->ignore_robots, k_arg_ignore_robots) |
         internal_flag_bit(a->allow_private, k_arg_allow_private) |
         internal_flag_bit(a->cross_host, k_arg_cross_host) |
         internal_flag_bit(a->allow_incomplete, k_arg_allow_incomplete) |
         internal_flag_bit(a->progress, k_arg_progress) |
         internal_flag_bit(a->refetch, k_arg_refetch) | internal_flag_bit(a->verify, k_arg_verify) |
         internal_flag_bit(a->help, k_arg_help) | internal_flag_bit(a->version, k_arg_version);
}
 
const char* mdl_cli_mode_name(mdl_cli_mode_t mode)
{
  static const char* const names[] = {"invalid",
                                      "series",
                                      "search",
                                      "browse",
                                      "list",
                                      "update-all",
                                      "remove",
                                      "verify",
                                      "init-site",
                                      "pack",
                                      "artifact",
                                      "page",
                                      "help",
                                      "version"};
  return ((unsigned)mode < (sizeof(names) / sizeof(names[0]))) ? names[mode] : names[0];
}

RA8_INTERNAL static ra8_err_t internal_cli_invalid(ra8_io_stream_t* diagnostic, const char* message)
{
  const char* const parts[] = {"mdl: ", message, "\n"};
  return priv_mdl_cli_reject_parts(diagnostic, parts, sizeof(parts) / sizeof(parts[0]));
}

RA8_INTERNAL static void
internal_record_mode(bool condition, mdl_cli_mode_t candidate, mdl_cli_mode_t* mode, size_t* count)
{
  if (condition) {
    *mode = candidate;
    *count += 1U;
  }
}

RA8_INTERNAL static bool internal_cli_ends_ci(const char* text, const char* suffix)
{
  const size_t tl = strlen(text);
  const size_t sl = strlen(suffix);
  if (sl > tl) {
    return false;
  }
  for (size_t i = 0U; i < sl; ++i) {
    char a = text[tl - sl + i];
    char b = suffix[i];
    if ((a >= 'A') && (a <= 'Z')) {
      a = (char)(a + ('a' - 'A'));
    }
    if ((b >= 'A') && (b <= 'Z')) {
      b = (char)(b + ('a' - 'A'));
    }
    if (a != b) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_cli_artifact_url(const char* url)
{
  if (url == nullptr) {
    return false;
  }
  const size_t path_len = strcspn(url, "?#");
  char         path[1024];
  if ((path_len == 0U) || (path_len >= sizeof(path))) {
    return false;
  }
  memcpy(path, url, path_len);
  path[path_len] = '\0';
  static const char* const suffixes[] =
    {".cbt.gz", ".cbt.xz", ".rabook", ".epub", ".cbz", ".cbr", ".cbt", ".jof"};
  for (size_t i = 0U; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
    if (internal_cli_ends_ci(path, suffixes[i])) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static mdl_cli_mode_t internal_resolve_mode(const mdl_args_t* a, size_t* count)
{
  mdl_cli_mode_t mode = k_mdl_cli_mode_invalid;
  internal_record_mode(a->series != nullptr, k_mdl_cli_mode_series, &mode, count);
  internal_record_mode(a->search != nullptr, k_mdl_cli_mode_search, &mode, count);
  internal_record_mode(a->browse, k_mdl_cli_mode_browse, &mode, count);
  internal_record_mode(a->list, k_mdl_cli_mode_list, &mode, count);
  internal_record_mode(a->update_all, k_mdl_cli_mode_update_all, &mode, count);
  internal_record_mode(a->remove_series != nullptr, k_mdl_cli_mode_remove, &mode, count);
  internal_record_mode(a->verify, k_mdl_cli_mode_verify, &mode, count);
  internal_record_mode(a->init_site_url != nullptr, k_mdl_cli_mode_init_site, &mode, count);
  internal_record_mode(a->pack != nullptr, k_mdl_cli_mode_pack, &mode, count);
  const bool artifact = internal_cli_artifact_url(a->page_url);
  internal_record_mode((a->page_url != nullptr) && artifact, k_mdl_cli_mode_artifact, &mode, count);
  internal_record_mode((a->page_url != nullptr) && !artifact, k_mdl_cli_mode_page, &mode, count);
  internal_record_mode(a->help, k_mdl_cli_mode_help, &mode, count);
  internal_record_mode(a->version, k_mdl_cli_mode_version, &mode, count);
  return mode;
}
 
RA8_INTERNAL static const char* internal_option_name(uint64_t bit)
{
  static const struct {
    uint64_t    bit;  
    const char* name; 
  } names[] = {{k_arg_cfg, "--config"},
               {k_arg_series, "--series"},
               {k_arg_page, "URL"},
               {k_arg_out, "--out"},
               {k_arg_cache_dir, "--cache-dir"},
               {k_arg_attr, "--attr"},
               {k_arg_chapters, "--chapters"},
               {k_arg_from, "--from"},
               {k_arg_max, "--max"},
               {k_arg_seed, "--seed"},
               {k_arg_timeout, "--timeout"},
               {k_arg_format, "--format"},
               {k_arg_pack, "--pack"},
               {k_arg_contact, "--contact"},
               {k_arg_max_bytes, "--max-bytes"},
               {k_arg_remove, "--remove"},
               {k_arg_search, "--search"},
               {k_arg_pick, "--pick"},
               {k_arg_proxy, "--proxy"},
               {k_arg_socks5, "--socks5"},
               {k_arg_cookie, "--cookie-file"},
               {k_arg_ca_file, "--ca-file"},
               {k_arg_verify_dir, "DIR"},
               {k_arg_init, "--init-site"},
               {k_arg_browse, "--browse"},
               {k_arg_separate, "--separate"},
               {k_arg_update, "--update"},
               {k_arg_list, "--list"},
               {k_arg_update_all, "--update-all"},
               {k_arg_polite, "--polite"},
               {k_arg_ignore_robots, "--ignore-robots"},
               {k_arg_allow_private, "--allow-private"},
               {k_arg_cross_host, "--cross-host"},
               {k_arg_allow_incomplete, "--allow-incomplete"},
               {k_arg_progress, "--progress"},
               {k_arg_refetch, "--refetch"},
               {k_arg_verify, "--verify"},
               {k_arg_help, "--help"},
               {k_arg_version, "--version"}};
  for (size_t i = 0U; i < (sizeof(names) / sizeof(names[0])); ++i) {
    if ((bit & names[i].bit) != 0U) {
      return names[i].name;
    }
  }
  return "option";
}

RA8_INTERNAL static bool
internal_cli_allowed_args(const mdl_args_t* a, mdl_cli_mode_t selected, uint64_t* allowed)
{
  const uint64_t net = k_arg_seed | k_arg_timeout | k_arg_contact | k_arg_max_bytes | k_arg_proxy |
                       k_arg_socks5 | k_arg_cookie | k_arg_ca_file | k_arg_polite |
                       k_arg_ignore_robots | k_arg_allow_private | k_arg_cross_host;
  const uint64_t download = k_arg_out | k_arg_cache_dir | k_arg_chapters | k_arg_from |
                            k_arg_format | k_arg_separate | k_arg_update | k_arg_allow_incomplete |
                            k_arg_progress | k_arg_refetch;
  switch (selected) {
    case k_mdl_cli_mode_series:
      *allowed = k_arg_series | k_arg_cfg | net | download;
      return true;
    case k_mdl_cli_mode_search:
      *allowed =
        k_arg_search | k_arg_cfg | k_arg_pick | net | ((a->pick != nullptr) ? download : 0U);
      return true;
    case k_mdl_cli_mode_browse:
      *allowed =
        k_arg_browse | k_arg_cfg | k_arg_pick | net | ((a->pick != nullptr) ? download : 0U);
      return true;
    case k_mdl_cli_mode_list:
      *allowed = k_arg_list | k_arg_out;
      return true;
    case k_mdl_cli_mode_update_all:
      *allowed = k_arg_update_all | k_arg_cfg | k_arg_out | k_arg_cache_dir | k_arg_format |
                 k_arg_separate | k_arg_allow_incomplete | k_arg_progress | k_arg_refetch | net;
      return true;
    case k_mdl_cli_mode_remove:
      *allowed = k_arg_remove | k_arg_out;
      return true;
    case k_mdl_cli_mode_verify:
      *allowed = k_arg_verify | k_arg_verify_dir | k_arg_out;
      return true;
    case k_mdl_cli_mode_init_site:
      *allowed = k_arg_init;
      return true;
    case k_mdl_cli_mode_pack:
      *allowed = k_arg_pack | k_arg_format;
      return true;
    case k_mdl_cli_mode_artifact:
      *allowed = k_arg_page | k_arg_out | net;
      return true;
    case k_mdl_cli_mode_page:
      *allowed = k_arg_page | k_arg_out | k_arg_attr | k_arg_max | net;
      return true;
    case k_mdl_cli_mode_help:
      *allowed = k_arg_help;
      return true;
    case k_mdl_cli_mode_version:
      *allowed = k_arg_version;
      return true;
    default:
      return false;
  }
}

RA8_INTERNAL static ra8_err_t internal_validate_allowed_args(const mdl_args_t* a,
                                                             ra8_io_stream_t*  diagnostic,
                                                             mdl_cli_mode_t    selected)
{
  uint64_t allowed = 0U;
  if (!internal_cli_allowed_args(a, selected, &allowed)) {
    return internal_cli_invalid(diagnostic, "invalid command mode");
  }
  const uint64_t disallowed = internal_args_mask(a) & ~allowed;
  if (disallowed == 0U) {
    return k_ra8_ok;
  }
  const char* const parts[] = {"mdl: ",
                               internal_option_name(disallowed),
                               " is not valid in ",
                               mdl_cli_mode_name(selected),
                               " mode\n"};
  return priv_mdl_cli_reject_parts(diagnostic, parts, sizeof(parts) / sizeof(parts[0]));
}

RA8_INTERNAL static ra8_err_t internal_validate_mode_fields(const mdl_args_t* a,
                                                            ra8_io_stream_t*  diagnostic,
                                                            mdl_cli_mode_t    selected)
{
  const bool config_mode =
    (selected == k_mdl_cli_mode_series) || (selected == k_mdl_cli_mode_search) ||
    (selected == k_mdl_cli_mode_browse) || (selected == k_mdl_cli_mode_update_all);
  if (config_mode && ((a->cfg == nullptr) || (a->cfg[0] == '\0'))) {
    return internal_cli_invalid(diagnostic, "this mode requires --config SITE.conf");
  }
  if ((selected == k_mdl_cli_mode_search) && (a->search[0] == '\0')) {
    return internal_cli_invalid(diagnostic, "--search requires a non-empty term");
  }
  if ((selected == k_mdl_cli_mode_pack) && (a->format == nullptr)) {
    return internal_cli_invalid(diagnostic, "--pack requires an explicit --format");
  }
  if ((selected == k_mdl_cli_mode_verify) && (a->verify_dir != nullptr) && (a->out != nullptr)) {
    return internal_cli_invalid(
      diagnostic,
      "--verify DIR and --out DIR are alternate directory spellings; use one");
  }
  if ((selected == k_mdl_cli_mode_artifact) &&
      (strncmp(a->page_url, "https://", strlen("https://")) != 0)) {
    return internal_cli_invalid(diagnostic, "direct artifact downloads require an https:// URL");
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_validate_network_args(const mdl_args_t* a,
                                                             ra8_io_stream_t*  diagnostic)
{
  if ((a->proxy != nullptr) && (a->socks5 != nullptr)) {
    return internal_cli_invalid(diagnostic, "--proxy and --socks5 are mutually exclusive");
  }
  if (((a->proxy != nullptr) || (a->socks5 != nullptr)) && !a->allow_private) {
    return internal_cli_invalid(diagnostic, "--proxy/--socks5 requires --allow-private");
  }
  if ((a->attr != nullptr) && (strcmp(a->attr, "data-src") != 0) && (strcmp(a->attr, "src") != 0)) {
    return internal_cli_invalid(diagnostic, "--attr expects data-src or src");
  }
  return k_ra8_ok;
}
 
ra8_err_t mdl_cli_validate(const mdl_args_t* a, ra8_io_stream_t* diagnostic, mdl_cli_mode_t* mode)
{
  if ((a == nullptr) || (diagnostic == nullptr) || (mode == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *mode = k_mdl_cli_mode_invalid;
  if (a->bad) {
    return internal_cli_invalid(diagnostic, "unknown, duplicate, or missing-value option");
  }
  size_t               primary_count = 0U;
  const mdl_cli_mode_t selected      = internal_resolve_mode(a, &primary_count);
  if (primary_count == 0U) {
    return internal_cli_invalid(diagnostic, "exactly one command mode is required");
  }
  if (primary_count != 1U) {
    return internal_cli_invalid(diagnostic, "command modes are mutually exclusive");
  }
  ra8_err_t err = internal_validate_allowed_args(a, diagnostic, selected);
  if (err == k_ra8_ok) {
    err = internal_validate_mode_fields(a, diagnostic, selected);
  }
  if (err == k_ra8_ok) {
    err = internal_validate_network_args(a, diagnostic);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  *mode = selected;
  return k_ra8_ok;
}
mdl_run_opts_t mdl_cli_run_opts(const mdl_args_t* a)
{
  const uint64_t max_bytes = (a->max_bytes == nullptr)
                               ? (uint64_t)k_max_response_bytes_def
                               : strtoull(a->max_bytes, nullptr, k_cli_dec_base);
  return (mdl_run_opts_t){
    .policy           = {.allow_private_hosts       = a->allow_private,
                         .allow_cross_host_redirect = a->cross_host,
                         .max_response_bytes        = max_bytes,
                         .proxy                     = a->proxy,
                         .socks5                    = a->socks5},
    .contact          = a->contact,
    .honor_robots     = !a->ignore_robots,
    .polite           = a->polite,
    .allow_incomplete = a->allow_incomplete,
    .progress         = a->progress,
    .refetch          = a->refetch,
  };
}