mdl_urlname.c

Go to the documentation of this file.

#include "mdl_urlname.h"
 
#include <stdint.h>
#include <string.h>
 
#include "mdl_sanitize.h"
#include "ra8_attributes.h"

typedef enum : uint16_t {
  k_urlname_raw_bytes   = 256,  
  k_urlname_case_gap    = 32,   
  k_urlname_scan_max    = 2048, 
  k_urlname_magic_bytes = 16,   
  k_urlname_read_calls  = 17,   
} mdl_urlname_const_t;

typedef enum : uint32_t {
  k_chapter_whole_max = 999999999U, 
  k_chapter_frac_max  = 6U,         
  k_chapter_radix     = 10U,        
} mdl_chapter_num_limit_t;

static const double s_chapter_fraction_step = 0.1;

typedef enum : uint8_t {
  k_webp_sig_bytes = 12U, 
  k_webp_e_offset  = 9U,  
  k_webp_b_offset  = 10U, 
  k_webp_p_offset  = 11U, 
  k_gif_a_offset   = 5U,  
} mdl_image_signature_offset_t;

typedef enum : uint8_t {
  k_jpeg_marker_byte = 0xFFU, 
  k_jpeg_soi_byte    = 0xD8U, 
  k_png_lead_byte    = 0x89U, 
} mdl_image_signature_byte_t;

RA8_INTERNAL static size_t internal_urlname_path_end(const char* url)
{
  const char* q = strpbrk(url, "?#");
  return (q == nullptr) ? strlen(url) : (size_t)(q - url);
}
 
void mdl_urlname_last_segment(const char* url, char* out, size_t cap)
{
  if ((url == nullptr) || (out == nullptr) || (cap < 2U)) {
    if ((out != nullptr) && (cap > 0U)) {
      out[0] = '\0';
    }
    return;
  }
  size_t end = internal_urlname_path_end(url);
  while ((end > 0U) && (url[end - 1U] == '/')) {
    --end; /* trim trailing slashes */
  }
  size_t start = end;
  while ((start > 0U) && (url[start - 1U] != '/')) {
    --start;
  }
  char   raw[k_urlname_raw_bytes];
  size_t n = 0U;
  for (size_t i = start; (i < end) && (n + 1U < sizeof(raw)); ++i) {
    raw[n] = url[i];
    ++n;
  }
  raw[n] = '\0';
  (void)mdl_sanitize_segment(raw, out, cap);
}

RA8_INTERNAL static size_t internal_urlname_path_start(const char* url, size_t end)
{
  const char* scheme = strstr(url, "://");
  if ((scheme == nullptr) || ((size_t)(scheme - url) >= end)) {
    return 0U; /* Relative URL: its entire prefix is a path. */
  }
  const size_t authority = (size_t)(scheme - url) + strlen("://");
  const char*  slash     = memchr(url + authority, '/', end - authority);
  return (slash == nullptr) ? end : (size_t)(slash - url);
}

RA8_INTERNAL static const char*
internal_urlname_last_path_marker(const char* url, size_t begin, size_t end, const char* marker)
{
  const size_t marker_len = strlen(marker);
  const char*  found      = nullptr;
  if (marker_len > (end - begin)) {
    return nullptr;
  }
  for (size_t i = begin; i <= (end - marker_len); ++i) {
    if (memcmp(url + i, marker, marker_len) == 0) {
      found = url + i;
    }
  }
  return found;
}

RA8_INTERNAL static bool internal_urlname_parse_chapter_digits(const char*  start,
                                                               const char*  end,
                                                               double*      out,
                                                               const char** out_next)
{
  if ((start >= end) || (*start < '0') || (*start > '9')) {
    return false;
  }
  uint32_t whole = 0U;
  while ((start < end) && (*start >= '0') && (*start <= '9')) {
    const uint32_t digit = (uint32_t)(*start - '0');
    if (whole > (((uint32_t)k_chapter_whole_max - digit) / (uint32_t)k_chapter_radix)) {
      return false;
    }
    whole = (whole * (uint32_t)k_chapter_radix) + digit;
    ++start;
  }
  double value = (double)whole;
  if ((start < end) && ((*start == '-') || (*start == '.')) && ((start + 1) < end) &&
      (start[1] >= '0') && (start[1] <= '9')) {
    ++start;
    double   scale  = s_chapter_fraction_step;
    uint32_t digits = 0U;
    while ((start < end) && (*start >= '0') && (*start <= '9')) {
      if (digits >= (uint32_t)k_chapter_frac_max) {
        return false;
      }
      value += (double)(*start - '0') * scale;
      scale *= s_chapter_fraction_step;
      ++digits;
      ++start;
    }
  }
  *out = value;
  if (out_next != nullptr) {
    *out_next = start;
  }
  return true;
}
 
bool mdl_urlname_chapter_parse(const char* url, double* out)
{
  if (out != nullptr) {
    *out = 0.0;
  }
  if ((url == nullptr) || (out == nullptr)) {
    return false;
  }
  const size_t bounded = strnlen(url, (size_t)k_urlname_scan_max);
  if (bounded == (size_t)k_urlname_scan_max) {
    return false;
  }
  const size_t             end       = internal_urlname_path_end(url);
  const size_t             begin     = internal_urlname_path_start(url, end);
  static const char* const markers[] = {"chapter-", "/ch-", "/ep"};
  const char*              found     = nullptr;
  size_t                   skip      = 0U;
  for (size_t i = 0U; i < (sizeof(markers) / sizeof(markers[0])); ++i) {
    const char* candidate = internal_urlname_last_path_marker(url, begin, end, markers[i]);
    if ((candidate != nullptr) && ((found == nullptr) || (candidate > found))) {
      found = candidate;
      skip  = strlen(markers[i]);
    }
  }
  return (found != nullptr) &&
         internal_urlname_parse_chapter_digits(found + skip, url + end, out, nullptr);
}
 
bool mdl_urlname_chapter_text_parse(const char* text, double* out)
{
  if (out != nullptr) {
    *out = 0.0;
  }
  if ((text == nullptr) || (out == nullptr)) {
    return false;
  }
  const size_t bounded = strnlen(text, (size_t)k_urlname_scan_max);
  if (bounded == (size_t)k_urlname_scan_max) {
    return false;
  }
  const char* begin = text;
  const char* end   = text + bounded;
  while ((begin < end) && ((*begin == ' ') || (*begin == '\t') || (*begin == '\r') ||
                           (*begin == '\n') || (*begin == '\f') || (*begin == '\v'))) {
    ++begin;
  }
  while ((end > begin) && ((end[-1] == ' ') || (end[-1] == '\t') || (end[-1] == '\r') ||
                           (end[-1] == '\n') || (end[-1] == '\f') || (end[-1] == '\v'))) {
    --end;
  }
  const char* next   = nullptr;
  double      parsed = 0.0;
  if (!internal_urlname_parse_chapter_digits(begin, end, &parsed, &next) || (next != end)) {
    return false;
  }
  *out = parsed;
  return true;
}
 
double mdl_urlname_chapter_value(const char* url)
{
  double value = 0.0;
  (void)mdl_urlname_chapter_parse(url, &value);
  return value;
}
 
long mdl_urlname_chapter_number(const char* url)
{
  return (long)mdl_urlname_chapter_value(url);
}

RA8_INTERNAL static char internal_urlname_to_lower_ascii(char c)
{
  const int lowered = ((c >= 'A') && (c <= 'Z')) ? (c + (int)k_urlname_case_gap) : (int)c;
  return (char)lowered;
}

RA8_INTERNAL static bool internal_urlname_is_known_ext(const char* ext)
{
  static const char* const known[] = {"jpg", "jpeg", "png", "gif", "webp", "bmp"};
  for (size_t i = 0U; i < (sizeof(known) / sizeof(known[0])); ++i) {
    if (strcmp(ext, known[i]) == 0) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static void internal_urlname_copy(char* out, size_t capacity, const char* value)
{
  if ((out == nullptr) || (capacity == 0U)) {
    return;
  }
  size_t length = strnlen(value, capacity - 1U);
  memcpy(out, value, length);
  out[length] = '\0';
}
 
void mdl_urlname_ext(const char* url, char* out, size_t cap)
{
  if ((out == nullptr) || (cap == 0U)) {
    return;
  }
  internal_urlname_copy(out, cap, "jpg");
  if (url == nullptr) {
    return;
  }
  const size_t pend  = internal_urlname_path_end(url);
  size_t       start = pend;
  while ((start > 0U) && (url[start - 1U] != '/')) {
    --start; /* isolate the last path segment */
  }
  size_t dot = pend;
  for (size_t i = start; i < pend; ++i) {
    if (url[i] == '.') {
      dot = i;
    }
  }
  if (dot >= pend) {
    return; /* no '.' in the segment -> keep the default */
  }
  char   ext[8];
  size_t n = 0U;
  for (size_t i = dot + 1U; (i < pend) && (n + 1U < sizeof(ext)); ++i) {
    ext[n++] = internal_urlname_to_lower_ascii(url[i]);
  }
  ext[n] = '\0';
  if (internal_urlname_is_known_ext(ext)) {
    internal_urlname_copy(out, cap, ext);
  }
}

RA8_INTERNAL static bool
internal_sniff_magic_image(const void* buf, size_t buf_len, const char** ext, const char** mime)
{
  if ((buf == nullptr) || (buf_len < 2U)) {
    return false;
  }
  const uint8_t* b = (const uint8_t*)buf;
  if ((buf_len >= 3U) && (b[0] == (uint8_t)k_jpeg_marker_byte) &&
      (b[1] == (uint8_t)k_jpeg_soi_byte) && (b[2] == (uint8_t)k_jpeg_marker_byte)) {
    *ext  = "jpg";
    *mime = "image/jpeg";
    return true;
  }
  if ((b[0] == (uint8_t)'B') && (b[1] == (uint8_t)'M')) {
    *ext  = "bmp";
    *mime = "image/bmp";
    return true;
  }
  if ((buf_len >= 4U) && (b[0] == (uint8_t)k_png_lead_byte) && (b[1] == (uint8_t)'P') &&
      (b[2] == (uint8_t)'N') && (b[3] == (uint8_t)'G')) {
    *ext  = "png";
    *mime = "image/png";
    return true;
  }
  if ((buf_len >= (size_t)k_webp_sig_bytes) && (b[0] == 'R') && (b[1] == 'I') && (b[2] == 'F') &&
      (b[3] == 'F') && (b[8] == 'W') && (b[k_webp_e_offset] == 'E') &&
      (b[k_webp_b_offset] == 'B') && (b[k_webp_p_offset] == 'P')) {
    *ext  = "webp";
    *mime = "image/webp";
    return true;
  }
  if ((buf_len >= 6U) && (b[0] == 'G') && (b[1] == 'I') && (b[2] == 'F') && (b[3] == '8') &&
      ((b[4] == '7') || (b[4] == '9')) && (b[k_gif_a_offset] == 'a')) {
    *ext  = "gif";
    *mime = "image/gif";
    return true;
  }
  return false;
}

RA8_INTERNAL static bool
internal_sniff_content_type(const char* content_type, const char** ext, const char** mime)
{
  if ((content_type == nullptr) || (content_type[0] == '\0')) {
    return false;
  }
  char   ct_lower[128];
  size_t i = 0U;
  for (; (content_type[i] != '\0') && (i + 1U < sizeof(ct_lower)); ++i) {
    ct_lower[i] = internal_urlname_to_lower_ascii(content_type[i]);
  }
  ct_lower[i] = '\0';
  if ((strstr(ct_lower, "image/jpeg") != nullptr) || (strstr(ct_lower, "image/jpg") != nullptr)) {
    *ext  = "jpg";
    *mime = "image/jpeg";
  } else if (strstr(ct_lower, "image/png") != nullptr) {
    *ext  = "png";
    *mime = "image/png";
  } else if (strstr(ct_lower, "image/webp") != nullptr) {
    *ext  = "webp";
    *mime = "image/webp";
  } else if (strstr(ct_lower, "image/gif") != nullptr) {
    *ext  = "gif";
    *mime = "image/gif";
  } else if (strstr(ct_lower, "image/bmp") != nullptr) {
    *ext  = "bmp";
    *mime = "image/bmp";
  } else {
    return false;
  }
  return true;
}

RA8_INTERNAL static void internal_copy_image_type(const char* ext,
                                                  const char* mime,
                                                  char*       out_ext,
                                                  size_t      ext_cap,
                                                  char*       out_mime,
                                                  size_t      mime_cap)
{
  if ((out_ext != nullptr) && (ext_cap > 0U)) {
    internal_urlname_copy(out_ext, ext_cap, ext);
  }
  if ((out_mime != nullptr) && (mime_cap > 0U)) {
    internal_urlname_copy(out_mime, mime_cap, mime);
  }
}
 
bool mdl_urlname_sniff_image_type(const void* buf,
                                  size_t      buf_len,
                                  const char* content_type,
                                  char*       out_ext,
                                  size_t      ext_cap,
                                  char*       out_mime,
                                  size_t      mime_cap)
{
  const char* ext  = nullptr;
  const char* mime = nullptr;
  if (!internal_sniff_magic_image(buf, buf_len, &ext, &mime) &&
      !internal_sniff_content_type(content_type, &ext, &mime)) {
    return false;
  }
  internal_copy_image_type(ext, mime, out_ext, ext_cap, out_mime, mime_cap);
  return true;
}
ra8_err_t mdl_urlname_sniff_file(mdl_storage_t* storage,
                                 const char*    file_path,
                                 const char*    content_type,
                                 char*          out_ext,
                                 size_t         ext_cap,
                                 char*          out_mime,
                                 size_t         mime_cap)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (storage->file_workspace == nullptr) ||
      (file_path == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  fw_fs_file_t file = {};
  ra8_err_t    err  = fw_fs_open(&storage->fs->streams,
                                 file_path,
                                 k_fw_fs_open_read,
                                 &file,
                                 storage->file_workspace,
                                 storage->file_workspace_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
 
  uint8_t  header[k_urlname_magic_bytes] = {};
  uint32_t length                        = 0U;
  uint32_t calls                         = 0U;
  while ((length < sizeof(header)) && (err == k_ra8_ok)) {
    if (calls >= (uint32_t)k_urlname_read_calls) {
      err = k_ra8_err_invalid_size;
      break;
    }
    uint32_t count = 0U;
    err            = fw_fs_read(&file, header + length, (uint32_t)sizeof(header) - length, &count);
    ++calls;
    if ((err == k_ra8_ok) && (count == 0U)) {
      break;
    }
    length += count;
  }
  const ra8_err_t close_err = fw_fs_close(&file);
  if (close_err != k_ra8_ok) {
    return close_err;
  }
  if (err != k_ra8_ok) {
    return err;
  }
  return mdl_urlname_sniff_image_type(header,
                                      length,
                                      content_type,
                                      out_ext,
                                      ext_cap,
                                      out_mime,
                                      mime_cap)
           ? k_ra8_ok
           : k_ra8_err_validation_failed;
}