mdl_state_codec.c

Go to the documentation of this file.

#include <limits.h>
#include <math.h>
#include <stdint.h>
#include <string.h>
 
#include "mdl_state.h"
#include "mdl_state_internal.h"
#include "ra8_attributes.h"
 
static_assert(sizeof(long) <= sizeof(int64_t), "legacy state requires long no wider than int64");

typedef enum : uint16_t {
  k_state_max_flds           = 10,  
  k_state_hex_base           = 16,  
  k_state_dec_base           = 10,  
  k_state_hex_alpha_base     = 10,  
  k_state_decimal_digits_max = 17,  
  k_state_decimal_exp_max    = 400, 
} mdl_state_parse_t;

typedef enum : uint8_t {
  k_c_id        = 1,  
  k_c_known     = 2,  
  k_c_number    = 3,  
  k_c_done      = 4,  
  k_c_pages     = 5,  
  k_c_ready     = 6,  
  k_c_epoch     = 7,  
  k_c_url       = 8,  
  k_c_title     = 9,  
  k_c_fields_v2 = 10, 
  k_c_v1_number = 2,  
  k_c_v1_done   = 3,  
  k_c_v1_pages  = 4,  
  k_c_v1_ready  = 5,  
  k_c_v1_epoch  = 6,  
  k_c_v1_url    = 7,  
  k_c_fields_v1 = 8,  
} mdl_c_col_t;

typedef enum : uint8_t {
  k_p_urlhash   = 1, 
  k_p_content   = 2, 
  k_p_relpath   = 3, 
  k_p_etag      = 4, 
  k_p_lastmod   = 5, 
  k_p_epoch     = 6, 
  k_p_status    = 7, 
  k_p_fields    = 4, 
  k_p_fields_v4 = 8, 
} mdl_p_col_t;
 
/* ---- parsing ------------------------------------------------------------- */

RA8_INTERNAL static size_t internal_mdl_state_split_tabs(char* line, char* fld[], size_t max)
{
  size_t n = 0U;
  fld[n]   = line;
  ++n;
  for (char* c = line; (*c != '\0') && (n < max); ++c) {
    if (*c == '\t') {
      *c     = '\0';
      fld[n] = c + 1;
      ++n;
    }
  }
  if ((n == max) && (strchr(fld[max - 1U], '\t') != nullptr)) {
    return max + 1U;
  }
  return n;
}

RA8_INTERNAL static bool internal_mdl_state_digit(char byte, int base, uint8_t* out)
{
  uint8_t digit = UINT8_MAX;
  if ((byte >= '0') && (byte <= '9')) {
    digit = (uint8_t)(byte - '0');
  } else if ((byte >= 'a') && (byte <= 'f')) {
    digit = (uint8_t)(k_state_hex_alpha_base + (byte - 'a'));
  }
  if ((digit == UINT8_MAX) || ((int)digit >= base)) {
    return false;
  }
  *out = digit;
  return true;
}

RA8_INTERNAL static bool
internal_mdl_state_parse_u64_field(const char* text, int base, uint64_t* out)
{
  if ((text == nullptr) || (text[0] == '\0') ||
      ((base != (int)k_state_dec_base) && (base != (int)k_state_hex_base))) {
    return false;
  }
  uint64_t value = 0U;
  for (const char* p = text; *p != '\0'; ++p) {
    uint8_t digit = 0U;
    if (!internal_mdl_state_digit(*p, base, &digit) ||
        (value > ((UINT64_MAX - (uint64_t)digit) / (uint64_t)base))) {
      return false;
    }
    value = (value * (uint64_t)base) + (uint64_t)digit;
  }
  *out = value;
  return true;
}

RA8_INTERNAL static bool internal_mdl_state_parse_i64_field(const char* text, int64_t* out)
{
  if ((text == nullptr) || (text[0] == '\0') || (text[0] == '+')) {
    return false;
  }
  const bool  negative = text[0] == '-';
  const char* digits   = negative ? &text[1] : text;
  if (digits[0] == '\0') {
    return false;
  }
  uint64_t magnitude = 0U;
  if (!internal_mdl_state_parse_u64_field(digits, (int)k_state_dec_base, &magnitude)) {
    return false;
  }
  const uint64_t limit = negative ? ((uint64_t)INT64_MAX + 1U) : (uint64_t)INT64_MAX;
  if (magnitude > limit) {
    return false;
  }
  if (negative && (magnitude == limit)) {
    *out = INT64_MIN;
  } else {
    *out = negative ? -(int64_t)magnitude : (int64_t)magnitude;
  }
  return true;
}

RA8_INTERNAL static bool internal_mdl_state_parse_long_field(const char* text, long* out)
{
  int64_t value = 0;
  if (!internal_mdl_state_parse_i64_field(text, &value) || (value < (int64_t)LONG_MIN) ||
      (value > (int64_t)LONG_MAX)) {
    return false;
  }
  *out = (long)value;
  return true;
}

RA8_INTERNAL static bool internal_mdl_state_parse_decimal_exp(const char** cursor, int32_t* out_exp)
{
  const char* p     = *cursor;
  bool        neg   = false;
  int32_t     value = 0;
  if ((*p == '+') || (*p == '-')) {
    neg = *p == '-';
    ++p;
  }
  if ((*p < '0') || (*p > '9')) {
    return false;
  }
  while ((*p >= '0') && (*p <= '9')) {
    if (value > (int32_t)k_state_decimal_exp_max) {
      return false;
    }
    value = (value * (int32_t)k_state_dec_base) + (int32_t)(*p - '0');
    ++p;
  }
  if ((value > (int32_t)k_state_decimal_exp_max) || (*p != '\0')) {
    return false;
  }
  *cursor  = p;
  *out_exp = neg ? -value : value;
  return true;
}

RA8_INTERNAL static bool internal_mdl_state_scan_mantissa(const char** cursor,
                                                          uint64_t*    out_mantissa,
                                                          int32_t*     out_fractional,
                                                          bool*        out_digit)
{
  const char* p           = *cursor;
  uint64_t    mantissa    = 0U;
  int32_t     fractional  = 0;
  bool        digit       = false;
  bool        nonzero     = false;
  bool        decimal     = false;
  uint8_t     significant = 0U;
  while (((*p >= '0') && (*p <= '9')) || ((*p == '.') && !decimal)) {
    if (*p == '.') {
      decimal = true;
    } else {
      digit   = true;
      nonzero = nonzero || (*p != '0');
      significant += nonzero ? 1U : 0U;
      if (significant > (uint8_t)k_state_decimal_digits_max) {
        return false;
      }
      mantissa = (mantissa * (uint64_t)k_state_dec_base) + (uint64_t)(*p - '0');
      fractional += decimal ? 1 : 0;
      if (fractional > (int32_t)k_state_decimal_exp_max) {
        return false;
      }
    }
    ++p;
  }
  *cursor         = p;
  *out_mantissa   = mantissa;
  *out_fractional = fractional;
  *out_digit      = digit;
  return true;
}

RA8_INTERNAL static bool internal_mdl_state_parse_double_field(const char* text, double* out)
{
  if ((text == nullptr) || (text[0] == '\0')) {
    return false;
  }
  const char* p        = text;
  const bool  negative = *p == '-';
  if (*p == '-') {
    ++p;
  }
  uint64_t mantissa   = 0U;
  int32_t  fractional = 0;
  bool     digit      = false;
  if (!internal_mdl_state_scan_mantissa(&p, &mantissa, &fractional, &digit)) {
    return false;
  }
  int32_t exponent = 0;
  if ((*p == 'e') || (*p == 'E')) {
    ++p;
    if (!internal_mdl_state_parse_decimal_exp(&p, &exponent)) {
      return false;
    }
  }
  const int32_t scale = exponent - fractional;
  return digit && (*p == '\0') && (scale >= -(int32_t)k_state_decimal_exp_max) &&
         (scale <= (int32_t)k_state_decimal_exp_max) &&
         priv_mdl_state_decimal_to_binary64(mantissa, scale, negative, out);
}

RA8_INTERNAL static bool internal_mdl_state_parse_binary64(const char* text, double* out)
{
  if ((text == nullptr) || (strlen(text) != 16U)) {
    return false;
  }
  for (size_t i = 0U; i < 16U; ++i) {
    const bool digit = (text[i] >= '0') && (text[i] <= '9');
    const bool lower = (text[i] >= 'a') && (text[i] <= 'f');
    if (!digit && !lower) {
      return false;
    }
  }
  uint64_t bits = 0U;
  if (!internal_mdl_state_parse_u64_field(text, (int)k_state_hex_base, &bits)) {
    return false;
  }
  memcpy(out, &bits, sizeof(bits));
  return isfinite(*out);
}

RA8_INTERNAL static bool internal_mdl_state_apply_chapter_values(mdl_state_t* st,
                                                                 char*        fld[],
                                                                 double       number,
                                                                 bool         number_known,
                                                                 uint64_t     done,
                                                                 uint64_t     pages,
                                                                 uint64_t     ready,
                                                                 int64_t      epoch,
                                                                 size_t       url_col,
                                                                 const char*  title)
{
  if ((done > 1U) || (pages > UINT16_MAX) || (ready > UINT16_MAX) || (ready > pages) ||
      ((done != 0U) && ((pages == 0U) || (ready != pages))) ||
      (mdl_state_find_chapter(st, fld[k_c_id]) != nullptr)) {
    return false;
  }
  mdl_chapter_rec_t* rec =
    mdl_state_add_chapter_numbered(st, fld[k_c_id], fld[url_col], number, number_known);
  if ((rec == nullptr) || !mdl_state_set_chapter_metadata(rec, title, number, number_known)) {
    return false;
  }
  rec->complete   = done != 0U;
  rec->page_count = (uint16_t)pages;
  rec->pages_done = (uint16_t)ready;
  rec->fetched_at = epoch;
  return true;
}

RA8_INTERNAL static bool
internal_mdl_state_apply_chapter_v1(mdl_state_t* st, char* fld[], size_t nf)
{
  if (nf != (size_t)k_c_fields_v1) {
    return false;
  }
  long     number = 0L;
  uint64_t done   = 0U;
  uint64_t pages  = 0U;
  uint64_t ready  = 0U;
  int64_t  epoch  = 0;
  if (!internal_mdl_state_parse_long_field(fld[k_c_v1_number], &number) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_v1_done], (int)k_state_dec_base, &done) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_v1_pages], (int)k_state_dec_base, &pages) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_v1_ready], (int)k_state_dec_base, &ready) ||
      !internal_mdl_state_parse_i64_field(fld[k_c_v1_epoch], &epoch)) {
    return false;
  }
  return internal_mdl_state_apply_chapter_values(st,
                                                 fld,
                                                 (double)number,
                                                 number != 0L,
                                                 done,
                                                 pages,
                                                 ready,
                                                 epoch,
                                                 (size_t)k_c_v1_url,
                                                 "");
}

RA8_INTERNAL static bool
internal_mdl_state_apply_chapter_v2(mdl_state_t* st, char* fld[], size_t nf)
{
  if (nf != (size_t)k_c_fields_v2) {
    return false;
  }
  uint64_t known  = 0U;
  double   number = 0.0;
  uint64_t done   = 0U;
  uint64_t pages  = 0U;
  uint64_t ready  = 0U;
  int64_t  epoch  = 0;
  if (!internal_mdl_state_parse_u64_field(fld[k_c_known], (int)k_state_dec_base, &known) ||
      !internal_mdl_state_parse_double_field(fld[k_c_number], &number) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_done], (int)k_state_dec_base, &done) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_pages], (int)k_state_dec_base, &pages) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_ready], (int)k_state_dec_base, &ready) ||
      !internal_mdl_state_parse_i64_field(fld[k_c_epoch], &epoch) || (known > 1U)) {
    return false;
  }
  return internal_mdl_state_apply_chapter_values(st,
                                                 fld,
                                                 number,
                                                 known != 0U,
                                                 done,
                                                 pages,
                                                 ready,
                                                 epoch,
                                                 (size_t)k_c_url,
                                                 fld[k_c_title]);
}

RA8_INTERNAL static bool
internal_mdl_state_apply_chapter_v3(mdl_state_t* st, char* fld[], size_t nf)
{
  if (nf != (size_t)k_c_fields_v2) {
    return false;
  }
  uint64_t known  = 0U;
  double   number = 0.0;
  uint64_t done   = 0U;
  uint64_t pages  = 0U;
  uint64_t ready  = 0U;
  int64_t  epoch  = 0;
  if (!internal_mdl_state_parse_u64_field(fld[k_c_known], (int)k_state_dec_base, &known) ||
      !internal_mdl_state_parse_binary64(fld[k_c_number], &number) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_done], (int)k_state_dec_base, &done) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_pages], (int)k_state_dec_base, &pages) ||
      !internal_mdl_state_parse_u64_field(fld[k_c_ready], (int)k_state_dec_base, &ready) ||
      !internal_mdl_state_parse_i64_field(fld[k_c_epoch], &epoch) || (known > 1U)) {
    return false;
  }
  return internal_mdl_state_apply_chapter_values(st,
                                                 fld,
                                                 number,
                                                 known != 0U,
                                                 done,
                                                 pages,
                                                 ready,
                                                 epoch,
                                                 (size_t)k_c_url,
                                                 fld[k_c_title]);
}

RA8_INTERNAL static bool
internal_mdl_state_apply_page(mdl_state_t* st, char* fld[], size_t nf, uint16_t schema_version)
{
  const bool current = schema_version == (uint16_t)k_mdl_state_version;
  if ((current && (nf != (size_t)k_p_fields_v4)) ||
      (!current && ((nf < (size_t)k_p_fields) || (nf > ((size_t)k_p_lastmod + 1U))))) {
    return false;
  }
  uint64_t uh = 0U;
  uint64_t ch = 0U;
  if (!internal_mdl_state_parse_u64_field(fld[k_p_urlhash], (int)k_state_hex_base, &uh) ||
      !internal_mdl_state_parse_u64_field(fld[k_p_content], (int)k_state_hex_base, &ch)) {
    return false;
  }
  const char* etag    = (nf > (size_t)k_p_etag) ? fld[k_p_etag] : "";
  const char* lastmod = (nf > (size_t)k_p_lastmod) ? fld[k_p_lastmod] : "";
  int64_t     epoch   = 0;
  uint64_t    status  = 0U;
  if (current &&
      (!internal_mdl_state_parse_i64_field(fld[k_p_epoch], &epoch) ||
       !internal_mdl_state_parse_u64_field(fld[k_p_status], (int)k_state_dec_base, &status) ||
       (status > UINT16_MAX))) {
    return false;
  }
  return mdl_state_add_page(st, uh, ch, fld[k_p_relpath], etag, lastmod, epoch, (uint16_t)status);
}

RA8_INTERNAL static bool internal_mdl_state_apply_kv(char* dst, size_t cap, char* fld[], size_t nf)
{
  if ((nf != 2U) || !priv_mdl_state_field_valid(fld[1], cap)) {
    return false;
  }
  priv_mdl_state_set_opt(dst, cap, fld[1]);
  return true;
}

RA8_INTERNAL static bool
internal_mdl_state_apply_metadata(mdl_state_t* st, char type, char* fld[], size_t nf)
{
  switch (type) {
    case 'D':
      return internal_mdl_state_apply_kv(st->summary, sizeof(st->summary), fld, nf);
    case 'W':
      return internal_mdl_state_apply_kv(st->writer, sizeof(st->writer), fld, nf);
    case 'A':
      return internal_mdl_state_apply_kv(st->artist, sizeof(st->artist), fld, nf);
    case 'O':
      return internal_mdl_state_apply_kv(st->cover_url, sizeof(st->cover_url), fld, nf);
    case 'K':
      return (nf == 2U) && priv_mdl_state_relative_path_valid(fld[1], sizeof(st->cover_path)) &&
             internal_mdl_state_apply_kv(st->cover_path, sizeof(st->cover_path), fld, nf);
    case 'L':
      return internal_mdl_state_apply_kv(st->language, sizeof(st->language), fld, nf);
    default:
      return false;
  }
}

RA8_INTERNAL static bool
internal_mdl_state_apply_version(char* fld[], size_t nf, uint16_t* schema_version)
{
  uint64_t version = 0U;
  if ((fld[0][0] != 'V') || (nf != 2U) ||
      !internal_mdl_state_parse_u64_field(fld[1], (int)k_state_dec_base, &version) ||
      ((version != (uint64_t)k_mdl_state_version_v1) &&
       (version != (uint64_t)k_mdl_state_version_v2) &&
       (version != (uint64_t)k_mdl_state_version_v3) &&
       (version != (uint64_t)k_mdl_state_version))) {
    return false;
  }
  *schema_version = (uint16_t)version;
  return true;
}

RA8_INTERNAL static bool
internal_mdl_state_apply_line(mdl_state_t* st, char* fld[], size_t nf, uint16_t* schema_version)
{
  const char type = fld[0][0];
  if ((fld[0][1] != '\0')) {
    return false; /* a record type is exactly one character */
  }
  if (*schema_version == 0U) {
    return internal_mdl_state_apply_version(fld, nf, schema_version);
  }
  switch (type) {
    case 'V':
      return false; /* duplicate headers make corruption/concatenation visible */
    case 'S':
      return internal_mdl_state_apply_kv(st->series_url, sizeof(st->series_url), fld, nf);
    case 'T':
      return internal_mdl_state_apply_kv(st->series_title, sizeof(st->series_title), fld, nf);
    case 'N':
      return internal_mdl_state_apply_kv(st->site_name, sizeof(st->site_name), fld, nf);
    case 'H':
      return internal_mdl_state_apply_kv(st->site_host, sizeof(st->site_host), fld, nf);
    case 'G':
      return internal_mdl_state_apply_kv(st->config_path, sizeof(st->config_path), fld, nf);
    case 'D':
    case 'W':
    case 'A':
    case 'O':
    case 'K':
    case 'L':
      return (*schema_version != (uint16_t)k_mdl_state_version_v1) &&
             internal_mdl_state_apply_metadata(st, type, fld, nf);
    case 'R': {
      uint64_t direction = 0U;
      if ((*schema_version == (uint16_t)k_mdl_state_version_v1) || (nf != 2U) ||
          !internal_mdl_state_parse_u64_field(fld[1], (int)k_state_dec_base, &direction) ||
          (direction > (uint64_t)k_mdl_state_read_rtl)) {
        return false;
      }
      st->reading_direction = (mdl_state_reading_direction_t)direction;
      return true;
    }
    case 'C':
      if (*schema_version == (uint16_t)k_mdl_state_version_v1) {
        return internal_mdl_state_apply_chapter_v1(st, fld, nf);
      }
      return (*schema_version == (uint16_t)k_mdl_state_version_v2)
               ? internal_mdl_state_apply_chapter_v2(st, fld, nf)
               : internal_mdl_state_apply_chapter_v3(st, fld, nf);
    case 'P':
      return internal_mdl_state_apply_page(st, fld, nf, *schema_version);
    default:
      return false;
  }
}

typedef struct {
  mdl_storage_t* storage;   
  fw_fs_file_t*  file;      
  uint64_t       remaining; 
  uint32_t       cursor;    
  uint32_t       available; 
} mdl_state_reader_t;

RA8_INTERNAL static ra8_err_t internal_mdl_state_reader_refill(mdl_state_reader_t* reader)
{
  if (reader->remaining == 0U) {
    reader->cursor    = 0U;
    reader->available = 0U;
    return k_ra8_ok;
  }
  const uint32_t  wanted = (reader->remaining < (uint64_t)reader->storage->io_buffer_bytes)
                             ? (uint32_t)reader->remaining
                             : reader->storage->io_buffer_bytes;
  uint32_t        count  = 0U;
  const ra8_err_t err    = fw_fs_read(reader->file, reader->storage->io_buffer, wanted, &count);
  if (err != k_ra8_ok) {
    return err;
  }
  if (count == 0U) {
    return k_ra8_err_invalid_state;
  }
  reader->remaining -= count;
  reader->cursor    = 0U;
  reader->available = count;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_mdl_state_reader_byte(mdl_state_reader_t* reader, uint8_t* out, bool* out_eof)
{
  if (reader->cursor == reader->available) {
    const ra8_err_t err = internal_mdl_state_reader_refill(reader);
    if (err != k_ra8_ok) {
      return err;
    }
    if (reader->available == 0U) {
      *out_eof = true;
      return k_ra8_ok;
    }
  }
  *out     = reader->storage->io_buffer[reader->cursor];
  *out_eof = false;
  reader->cursor += 1U;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_mdl_state_reader_line(mdl_state_reader_t* reader,
                                                             char*               line,
                                                             size_t              capacity,
                                                             bool*               out_has_line)
{
  size_t used = 0U;
  for (;;) {
    uint8_t   byte = 0U;
    bool      eof  = false;
    ra8_err_t err  = internal_mdl_state_reader_byte(reader, &byte, &eof);
    if (err != k_ra8_ok) {
      return err;
    }
    if (eof || (byte == (uint8_t)'\n')) {
      if ((used > 0U) && (line[used - 1U] == '\r')) {
        --used;
      }
      line[used]    = '\0';
      *out_has_line = !eof || (used > 0U);
      return k_ra8_ok;
    }
    if ((used + 1U) >= capacity) {
      return k_ra8_err_invalid_state;
    }
    line[used] = (char)byte;
    ++used;
  }
}

RA8_INTERNAL static bool
internal_mdl_state_parse_record(mdl_state_t* st, char* line, uint16_t* schema_version)
{
  if ((line[0] == '\0') || (line[0] == '#')) {
    return true;
  }
  char*        fields[k_state_max_flds];
  const size_t count = internal_mdl_state_split_tabs(line, fields, (size_t)k_state_max_flds);
  return (count <= (size_t)k_state_max_flds) &&
         internal_mdl_state_apply_line(st, fields, count, schema_version);
}
 
RA8_PRIV ra8_err_t priv_mdl_state_parse_file(mdl_storage_t* storage,
                                             fw_fs_file_t*  file,
                                             uint64_t       offset,
                                             uint64_t       length,
                                             uint16_t       max_schema_version,
                                             mdl_state_t*   st)
{
  if ((storage == nullptr) || (file == nullptr) || (st == nullptr) ||
      (storage->io_buffer == nullptr) || (storage->io_buffer_bytes == 0U) ||
      (max_schema_version == 0U) || (max_schema_version > (uint16_t)k_mdl_state_version)) {
    return k_ra8_err_invalid_arg;
  }
  mdl_state_init(st);
  ra8_err_t err = fw_fs_seek(file, offset);
  if (err != k_ra8_ok) {
    return err;
  }
  mdl_state_reader_t reader = {.storage   = storage,
                               .file      = file,
                               .remaining = length,
                               .cursor    = 0U,
                               .available = 0U};
  char               line[k_mdl_state_line_max];
  uint16_t           schema_version = 0U;
  bool               has_line       = true;
  while ((err == k_ra8_ok) && has_line) {
    err = internal_mdl_state_reader_line(&reader, line, sizeof(line), &has_line);
    if ((err == k_ra8_ok) && has_line &&
        !internal_mdl_state_parse_record(st, line, &schema_version)) {
      err = k_ra8_err_invalid_state;
    }
  }
  if ((err == k_ra8_ok) && ((schema_version == 0U) || (schema_version > max_schema_version) ||
                            !priv_mdl_state_valid(st))) {
    err = k_ra8_err_invalid_state;
  }
  if (err != k_ra8_ok) {
    mdl_state_init(st);
  }
  return err;
}
 
/* ---- coverage ------------------------------------------------------------ */