mdl_sanitize.c

Go to the documentation of this file.

#include "mdl_sanitize.h"
 
#include <stdio.h>
#include <string.h>
 
#include "ra8_attributes.h"

typedef enum : uint8_t {
  k_reserved_base_max = 8, 
  k_reserved_len      = 4, 
  k_reserved_digit_at = 3, 
} mdl_sanitize_size_t;

static const char* const s_fallback_name = "item";

static const char* const s_reserved_exact[] = {"con", "prn", "aux", "nul"};
static const char* const s_reserved_numbered[] = {"com", "lpt"};

RA8_INTERNAL static char internal_lower_ascii(char c)
{
  return (char)(((c >= 'A') && (c <= 'Z')) ? (c + ('a' - 'A')) : c);
}

RA8_INTERNAL static bool internal_is_allowed_char(char c)
{
  return ((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9')) ||
         (c == '.') || (c == '-') || (c == '_');
}

RA8_INTERNAL static bool internal_is_dot_segment(const char* name)
{
  return (name[0] == '\0') || (strcmp(name, ".") == 0) || (strcmp(name, "..") == 0);
}

RA8_INTERNAL static void internal_base_of(const char* name, char* base, size_t cap)
{
  size_t i = 0U;
  while ((name[i] != '\0') && (name[i] != '.') && ((i + 1U) < cap)) {
    base[i] = internal_lower_ascii(name[i]);
    ++i;
  }
  base[i] = '\0';
}

RA8_INTERNAL static bool internal_is_reserved_base(const char* name)
{
  char base[k_reserved_base_max];
  internal_base_of(name, base, sizeof(base));
  for (size_t i = 0U; i < (sizeof(s_reserved_exact) / sizeof(s_reserved_exact[0])); ++i) {
    if (strcmp(base, s_reserved_exact[i]) == 0) {
      return true;
    }
  }
  if ((strlen(base) == (size_t)k_reserved_len) && (base[k_reserved_digit_at] >= '1') &&
      (base[k_reserved_digit_at] <= '9')) {
    for (size_t i = 0U; i < (sizeof(s_reserved_numbered) / sizeof(s_reserved_numbered[0])); ++i) {
      if (strncmp(base, s_reserved_numbered[i], strlen(s_reserved_numbered[i])) == 0) {
        return true;
      }
    }
  }
  return false;
}

RA8_INTERNAL static bool
internal_copy_sanitised(const char* raw, char* out, size_t cap, size_t* out_len)
{
  bool   clean = true;
  size_t n     = 0U;
  if (raw != nullptr) {
    size_t i = 0U;
    while ((raw[i] != '\0') && ((n + 1U) < cap)) {
      if (internal_is_allowed_char(raw[i])) {
        out[n] = raw[i];
      } else {
        out[n] = '_';
        clean  = false;
      }
      ++n;
      ++i;
    }
    if (raw[i] != '\0') {
      clean = false; /* input did not fit: truncated */
    }
  }
  out[n]   = '\0';
  *out_len = n;
  return clean;
}

RA8_INTERNAL static void internal_prepend_underscore(char* out, size_t cap, size_t len)
{
  size_t keep = len;
  if ((keep + 2U) > cap) {
    keep = cap - 2U; /* drop the tail that no longer fits after the prefix */
  }
  memmove(out + 1, out, keep);
  out[0]        = '_';
  out[keep + 1] = '\0';
}
 
bool mdl_sanitize_segment(const char* raw, char* out, size_t cap)
{
  if ((out == nullptr) || (cap < 2U)) {
    return false;
  }
  size_t len   = 0U;
  bool   clean = internal_copy_sanitised(raw, out, cap, &len);
  if (internal_is_dot_segment(out)) {
    (void)snprintf(out, cap, "%s", s_fallback_name);
    return false;
  }
  if (internal_is_reserved_base(out)) {
    internal_prepend_underscore(out, cap, len);
    return false;
  }
  return clean;
}
 
bool mdl_path_contained(const char* parent, const char* candidate)
{
  if ((parent == nullptr) || (candidate == nullptr)) {
    return false;
  }
  size_t plen = strlen(parent);
  while ((plen > 0U) && (parent[plen - 1U] == '/')) {
    --plen;
  }
  if (plen == 0U) {
    return false;
  }
  if (strncmp(candidate, parent, plen) != 0) {
    return false;
  }
  const char sep = candidate[plen];
  return (sep == '/') || (sep == '\0');
}

RA8_INTERNAL static bool internal_has_separator(const char* seg)
{
  return strchr(seg, '/') != nullptr;
}
 
bool mdl_path_join(const char* parent, const char* seg, char* out, size_t cap)
{
  if ((out == nullptr) || (cap == 0U)) {
    return false;
  }
  out[0] = '\0';
  if ((parent == nullptr) || (seg == nullptr)) {
    return false;
  }
  if (internal_is_dot_segment(seg) || internal_has_separator(seg)) {
    return false; /* empty, `.`, `..`, or a `/`-bearing/absolute segment */
  }
  const size_t plen = strlen(parent);
  const size_t slen = strlen(seg);
  const size_t need = plen + 1U + slen + 1U; /* parent + '/' + seg + NUL */
  if (need > cap) {
    return false; /* refuse a truncated (thus different) path */
  }
  memcpy(out, parent, plen);
  out[plen] = '/';
  memcpy(out + plen + 1U, seg, slen);
  out[plen + 1U + slen] = '\0';
  return true;
}

RA8_INTERNAL static const char* internal_xml_entity(char c)
{
  switch (c) {
    case '&':
      return "&amp;";
    case '<':
      return "&lt;";
    case '>':
      return "&gt;";
    case '"':
      return "&quot;";
    case '\'':
      return "&apos;";
    default:
      return nullptr;
  }
}
 
bool mdl_xml_escape(const char* src, char* out, size_t cap)
{
  if ((out == nullptr) || (cap == 0U)) {
    return false;
  }
  out[0] = '\0';
  if (src == nullptr) {
    return false;
  }
  size_t n = 0U;
  for (size_t i = 0U; src[i] != '\0'; ++i) {
    const char*  ent  = internal_xml_entity(src[i]);
    const size_t need = (ent != nullptr) ? strlen(ent) : 1U;
    if ((n + need + 1U) > cap) {
      out[0] = '\0';
      return false;
    }
    if (ent != nullptr) {
      memcpy(out + n, ent, need);
    } else {
      out[n] = src[i];
    }
    n += need;
  }
  out[n] = '\0';
  return true;
}