mdl_config.c

Go to the documentation of this file.

#include "mdl_config.h"
 
#include <string.h>
 
#include "mdl_politeness.h"
#include "ra8_attributes.h"

typedef enum : uint16_t {
  k_line_max = 512, 
} mdl_parse_limits_t;

typedef enum : uint32_t {
  k_config_file_max   = 64U * 1024U,            
  k_config_read_calls = k_config_file_max + 1U, 
  k_config_dec_base   = 10U,                    
} mdl_config_io_limit_t;

typedef struct {
  mdl_storage_t* storage;    
  fw_fs_file_t   file;       
  uint32_t       position;   
  uint32_t       available;  
  uint32_t       read_calls; 
  bool           eof;        
} internal_config_reader_t;

typedef enum : uint8_t {
  k_kv_unknown = 0, 
  k_kv_applied = 1, 
  k_kv_invalid = 2, 
} mdl_kv_result_t;

typedef enum : uint16_t {
  k_def_img_delay_min     = 500,  
  k_def_img_delay_max     = 1200, 
  k_def_chapter_delay_min = 1500, 
  k_def_chapter_delay_max = 3000, 
} mdl_config_defaults_t;

typedef enum : uint16_t {
  k_polite_img_min_ms  = 2000,  
  k_polite_img_max_ms  = 4000,  
  k_polite_chap_min_ms = 5000,  
  k_polite_chap_max_ms = 10000, 
} mdl_config_polite_floor_t;

RA8_INTERNAL static char* internal_config_trim(char* s)
{
  while ((*s == ' ') || (*s == '\t') || (*s == '\r') || (*s == '\n')) {
    ++s;
  }
  size_t n = strlen(s);
  while ((n > 0U) && ((s[n - 1U] == ' ') || (s[n - 1U] == '\t') || (s[n - 1U] == '\r') ||
                      (s[n - 1U] == '\n'))) {
    s[n - 1U] = '\0';
    --n;
  }
  return s;
}

RA8_INTERNAL static bool internal_config_set_str(char* dst, size_t cap, const char* val)
{
  const size_t len = strlen(val);
  if (len >= cap) {
    return false;
  }
  memcpy(dst, val, len + 1U);
  return true;
}

RA8_INTERNAL static mdl_kv_result_t
internal_config_apply_string(mdl_site_t* s, const char* key, const char* val)
{
  const struct {
    const char* key; 
    char*       dst; 
    size_t      cap; 
  } fields[] = {
    {"name", s->name, sizeof(s->name)},
    {"host", s->host, sizeof(s->host)},
    {"kind", s->kind, sizeof(s->kind)},
    {"contact", s->contact, sizeof(s->contact)},
    {"chapter_url_contains", s->chapter_url_contains, sizeof(s->chapter_url_contains)},
    {"chapter_url_prefix", s->chapter_url_prefix, sizeof(s->chapter_url_prefix)},
    {"page_img_attr", s->page_img_attr, sizeof(s->page_img_attr)},
    {"page_img_url_contains", s->page_img_url_contains, sizeof(s->page_img_url_contains)},
    {"search_url", s->search_url, sizeof(s->search_url)},
    {"search_result_contains", s->search_result_contains, sizeof(s->search_result_contains)},
    {"browse_url", s->browse_url, sizeof(s->browse_url)},
    {"series_title_selector", s->series_title_selector, sizeof(s->series_title_selector)},
    {"series_summary_selector", s->series_summary_selector, sizeof(s->series_summary_selector)},
    {"series_author_selector", s->series_author_selector, sizeof(s->series_author_selector)},
    {"series_artist_selector", s->series_artist_selector, sizeof(s->series_artist_selector)},
    {"series_cover_selector", s->series_cover_selector, sizeof(s->series_cover_selector)},
    {"chapter_title_selector", s->chapter_title_selector, sizeof(s->chapter_title_selector)},
    {"chapter_number_selector", s->chapter_number_selector, sizeof(s->chapter_number_selector)},
    {"language", s->language, sizeof(s->language)},
    {"reading_direction", s->reading_direction, sizeof(s->reading_direction)},
  };
  for (size_t i = 0U; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
    if (strcmp(key, fields[i].key) == 0) {
      return internal_config_set_str(fields[i].dst, fields[i].cap, val) ? k_kv_applied
                                                                        : k_kv_invalid;
    }
  }
  return k_kv_unknown;
}

RA8_INTERNAL static bool internal_config_parse_u32(const char* val, uint32_t* out)
{
  if ((val[0] == '\0') || (val[0] == '+') || (val[0] == '-')) {
    return false;
  }
  uint32_t parsed = 0U;
  for (size_t index = 0U; val[index] != '\0'; ++index) {
    if ((val[index] < '0') || (val[index] > '9')) {
      return false;
    }
    const uint32_t digit = (uint32_t)(val[index] - '0');
    if (parsed > ((UINT32_MAX - digit) / (uint32_t)k_config_dec_base)) {
      return false;
    }
    parsed = (parsed * (uint32_t)k_config_dec_base) + digit;
  }
  *out = parsed;
  return true;
}

RA8_INTERNAL static mdl_kv_result_t
internal_config_apply_u32(mdl_site_t* s, const char* key, const char* val)
{
  const struct {
    const char* key; 
    uint32_t*   dst; 
  } fields[] = {
    {"img_delay_min", &s->img_delay_min},
    {"img_delay_max", &s->img_delay_max},
    {"chapter_delay_min", &s->chapter_delay_min},
    {"chapter_delay_max", &s->chapter_delay_max},
    {"rate_per_min", &s->rate_per_min},
    {"burst", &s->burst},
    {"backoff_base_ms", &s->backoff_base_ms},
    {"backoff_max_ms", &s->backoff_max_ms},
    {"max_inflight", &s->max_inflight},
  };
  for (size_t i = 0U; i < (sizeof(fields) / sizeof(fields[0])); ++i) {
    if (strcmp(key, fields[i].key) == 0) {
      return internal_config_parse_u32(val, fields[i].dst) ? k_kv_applied : k_kv_invalid;
    }
  }
  return k_kv_unknown;
}

RA8_INTERNAL static bool internal_config_parse_order(const char* val, mdl_chapter_order_t* out)
{
  if (strcmp(val, "reverse") == 0) {
    *out = k_mdl_order_reverse;
    return true;
  }
  if (strcmp(val, "asc") == 0) {
    *out = k_mdl_order_asc;
    return true;
  }
  if (strcmp(val, "doc") == 0) {
    *out = k_mdl_order_doc;
    return true;
  }
  return false;
}

RA8_INTERNAL static bool internal_config_apply_pair(mdl_site_t* s, const char* key, const char* val)
{
  const mdl_kv_result_t str_result = internal_config_apply_string(s, key, val);
  if (str_result != k_kv_unknown) {
    return str_result == k_kv_applied;
  }
  const mdl_kv_result_t int_result = internal_config_apply_u32(s, key, val);
  if (int_result != k_kv_unknown) {
    return int_result == k_kv_applied;
  }
  if (strcmp(key, "chapter_order") == 0) {
    return internal_config_parse_order(val, &s->chapter_order);
  }
  return false;
}

RA8_INTERNAL static void internal_config_set_defaults(mdl_site_t* out)
{
  *out = (mdl_site_t){};
  (void)internal_config_set_str(out->name, sizeof(out->name), "site");
  (void)internal_config_set_str(out->kind, sizeof(out->kind), "manhwa");
  (void)internal_config_set_str(out->chapter_url_contains,
                                sizeof(out->chapter_url_contains),
                                "chapter");
  (void)internal_config_set_str(out->page_img_attr, sizeof(out->page_img_attr), "data-src");
  (void)internal_config_set_str(out->language, sizeof(out->language), "en");
  (void)internal_config_set_str(out->reading_direction, sizeof(out->reading_direction), "ltr");
  out->chapter_order     = k_mdl_order_asc;
  out->img_delay_min     = (uint32_t)k_def_img_delay_min;
  out->img_delay_max     = (uint32_t)k_def_img_delay_max;
  out->chapter_delay_min = (uint32_t)k_def_chapter_delay_min;
  out->chapter_delay_max = (uint32_t)k_def_chapter_delay_max;
 
  /* Governor bounds default to the conservative single source of truth. */
  const mdl_gov_cfg_t gov = mdl_gov_cfg_default();
  out->rate_per_min       = gov.rate_per_min;
  out->burst              = gov.burst;
  out->backoff_base_ms    = gov.backoff_base_ms;
  out->backoff_max_ms     = gov.backoff_max_ms;
  out->max_inflight       = (uint32_t)gov.max_inflight;
}

RA8_INTERNAL static ra8_err_t
internal_config_next(internal_config_reader_t* reader, uint8_t* out_byte, bool* out_eof)
{
  *out_eof = false;
  while (reader->position == reader->available) {
    if (reader->eof) {
      *out_eof = true;
      return k_ra8_ok;
    }
    if (reader->read_calls >= (uint32_t)k_config_read_calls) {
      return k_ra8_err_invalid_size;
    }
    uint32_t        count = 0U;
    const ra8_err_t err   = fw_fs_read(&reader->file,
                                       reader->storage->io_buffer,
                                       reader->storage->io_buffer_bytes,
                                       &count);
    ++reader->read_calls;
    if (err != k_ra8_ok) {
      return err;
    }
    reader->position  = 0U;
    reader->available = count;
    reader->eof       = count == 0U;
  }
  *out_byte = reader->storage->io_buffer[reader->position];
  ++reader->position;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_config_read_line(internal_config_reader_t* reader,
                                                        char*                     line,
                                                        uint32_t                  capacity,
                                                        bool*                     out_present)
{
  uint32_t length = 0U;
  *out_present    = false;
  for (;;) {
    uint8_t   byte = 0U;
    bool      eof  = false;
    ra8_err_t err  = internal_config_next(reader, &byte, &eof);
    if (err != k_ra8_ok) {
      return err;
    }
    if (eof) {
      line[length] = '\0';
      *out_present = length > 0U;
      return k_ra8_ok;
    }
    *out_present = true;
    if (byte == (uint8_t)'\n') {
      line[length] = '\0';
      return k_ra8_ok;
    }
    if ((length + 1U) >= capacity) {
      return k_ra8_err_invalid_state;
    }
    line[length] = (char)byte;
    ++length;
  }
}

RA8_INTERNAL static ra8_err_t internal_config_apply_line(mdl_site_t* site, char* line)
{
  char* text = internal_config_trim(line);
  if ((text[0] == '\0') || (text[0] == '#') || (text[0] == '[')) {
    return k_ra8_ok;
  }
  char* equals = strchr(text, '=');
  if (equals == nullptr) {
    return k_ra8_err_invalid_state;
  }
  *equals         = '\0';
  const char* key = internal_config_trim(text);
  const char* val = internal_config_trim(equals + 1);
  return ((key[0] != '\0') && internal_config_apply_pair(site, key, val)) ? k_ra8_ok
                                                                          : k_ra8_err_invalid_state;
}

RA8_INTERNAL static ra8_err_t internal_config_parse(internal_config_reader_t* reader,
                                                    mdl_site_t*               out)
{
  for (;;) {
    char      line[k_line_max];
    bool      present = false;
    ra8_err_t err     = internal_config_read_line(reader, line, sizeof(line), &present);
    if ((err != k_ra8_ok) || !present) {
      return err;
    }
    err = internal_config_apply_line(out, line);
    if (err != k_ra8_ok) {
      return err;
    }
  }
}

RA8_INTERNAL static bool internal_config_valid(const mdl_site_t* site)
{
  const char* selectors[] = {site->series_title_selector,
                             site->series_summary_selector,
                             site->series_author_selector,
                             site->series_artist_selector,
                             site->series_cover_selector,
                             site->chapter_title_selector,
                             site->chapter_number_selector};
  for (size_t i = 0U; i < (sizeof(selectors) / sizeof(selectors[0])); ++i) {
    const char* selector = selectors[i];
    if (selector[0] == '\0') {
      continue;
    }
    const char* prefixes[] = {"meta:", "class:", "label:", "literal:"};
    bool        valid      = false;
    for (size_t prefix_index = 0U; prefix_index < (sizeof(prefixes) / sizeof(prefixes[0]));
         ++prefix_index) {
      const size_t prefix_len = strlen(prefixes[prefix_index]);
      if ((strncmp(selector, prefixes[prefix_index], prefix_len) == 0) &&
          (selector[prefix_len] != '\0')) {
        valid = true;
        break;
      }
    }
    if (!valid) {
      return false;
    }
  }
  return (site->host[0] != '\0') && (site->language[0] != '\0') &&
         ((strcmp(site->reading_direction, "ltr") == 0) ||
          (strcmp(site->reading_direction, "rtl") == 0)) &&
         (site->img_delay_min <= site->img_delay_max) &&
         (site->chapter_delay_min <= site->chapter_delay_max) && (site->burst > 0U) &&
         (site->max_inflight > 0U) && (site->backoff_base_ms <= site->backoff_max_ms);
}
 
ra8_err_t mdl_config_load(mdl_storage_t* storage, const char* path, mdl_site_t* out)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (storage->file_workspace == nullptr) ||
      (storage->io_buffer == nullptr) || (storage->io_buffer_bytes == 0U) || (path == nullptr) ||
      (out == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  internal_config_set_defaults(out);
 
  internal_config_reader_t reader = {.storage = storage};
  ra8_err_t                err    = fw_fs_open(&storage->fs->streams,
                                               path,
                                               k_fw_fs_open_read,
                                               &reader.file,
                                               storage->file_workspace,
                                               storage->file_workspace_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
  uint64_t file_bytes = 0U;
  err                 = fw_fs_file_size(&reader.file, &file_bytes);
  if ((err == k_ra8_ok) && (file_bytes > (uint64_t)k_config_file_max)) {
    err = k_ra8_err_invalid_size;
  }
  if (err == k_ra8_ok) {
    err = internal_config_parse(&reader, out);
  }
  const ra8_err_t close_err = fw_fs_close(&reader.file);
  if (close_err != k_ra8_ok) {
    return close_err;
  }
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_config_valid(out) ? k_ra8_ok : k_ra8_err_invalid_state;
}
 
mdl_gov_cfg_t mdl_config_gov_cfg(const mdl_site_t* site)
{
  mdl_gov_cfg_t cfg   = mdl_gov_cfg_default();
  cfg.rate_per_min    = site->rate_per_min;
  cfg.burst           = site->burst;
  cfg.backoff_base_ms = site->backoff_base_ms;
  cfg.backoff_max_ms  = site->backoff_max_ms;
  cfg.max_inflight    = (uint16_t)site->max_inflight;
  return cfg;
}

RA8_INTERNAL static uint32_t internal_config_max_u32(uint32_t a, uint32_t b)
{
  return (a > b) ? a : b;
}
 
void mdl_config_apply_polite(mdl_site_t* site)
{
  site->img_delay_min = internal_config_max_u32(site->img_delay_min, (uint32_t)k_polite_img_min_ms);
  site->img_delay_max = internal_config_max_u32(site->img_delay_max, (uint32_t)k_polite_img_max_ms);
  site->chapter_delay_min =
    internal_config_max_u32(site->chapter_delay_min, (uint32_t)k_polite_chap_min_ms);
  site->chapter_delay_max =
    internal_config_max_u32(site->chapter_delay_max, (uint32_t)k_polite_chap_max_ms);
}