unarch_tar_fields.c

Go to the documentation of this file.

#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "unarch_tar_internal.h"

static const char* const s_tag_tar_f = "unarch_tar";
 
/* The pax extended-header record parser walks length-prefixed key=value records
 * with a fail-closed guard at every step: the parse body clears clang-tidy's
 * statement/nesting/cognitive thresholds while staying within the 60-line NASA
 * Rule 4 gate. Same disposition as the other decode state machines in the tree
 * (ra8_jpeg_sw_encode, ra8_rmac_phy). */

typedef enum : uint32_t {
  k_tar_octal_base    = 8U,            
  k_tar_decimal_base  = 10U,           
  k_tar_b256_flag     = 0x80U,         
  k_tar_b256_negative = 0x40U,         
  k_tar_b256_payload  = 0x7FU,         
  k_tar_b256_fit      = 8U,            
  k_tar_shift_byte    = 8U,            
  k_tar_pax_len_max   = 7U,            
  k_tar_chksum_space  = (uint32_t)' ', 
} tar_field_const_t;

RA8_INTERNAL
static ra8_err_t internal_octal(const uint8_t* field, size_t len, uint64_t* out)
{
  size_t i = 0U;
  while (i < len) { /* bound: len */
    if (field[i] != (uint8_t)' ') {
      break;
    }
    i += 1U;
  }
  uint64_t v      = 0U;
  size_t   digits = 0U;
  while ((i < len) && (field[i] != 0U) && (field[i] != (uint8_t)' ')) { /* bound: len */
    const uint8_t c = field[i];
    if (c < (uint8_t)'0') {
      return k_ra8_err_validation_failed;
    }
    if (c > (uint8_t)'7') {
      return k_ra8_err_validation_failed;
    }
    const uint64_t d = (uint64_t)c - (uint64_t)(uint8_t)'0';
    if (v > ((UINT64_MAX - d) / (uint64_t)k_tar_octal_base)) {
      return k_ra8_err_validation_failed; /* would overflow uint64 */
    }
    v = (v * (uint64_t)k_tar_octal_base) + d;
    digits += 1U;
    i += 1U;
  }
  if (digits == 0U) {
    return k_ra8_err_validation_failed; /* empty field */
  }
  *out = v;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_base256(const uint8_t* field, size_t len, uint64_t* out)
{
  if ((field[0] & (uint8_t)k_tar_b256_negative) != 0U) {
    return k_ra8_err_validation_failed; /* negative size: hostile */
  }
  if ((field[0] & (uint8_t)k_tar_b256_payload) != 0U) {
    return k_ra8_err_validation_failed; /* > 2^(8*(len-1)) - way over uint64 */
  }
  uint64_t v = 0U;
  for (size_t i = 1U; i < len; ++i) { /* bound: len */
    const size_t remaining = len - i;
    if (remaining > (size_t)k_tar_b256_fit) {
      if (field[i] != 0U) {
        return k_ra8_err_validation_failed; /* over 64 bits */
      }
      continue;
    }
    v = (v << (uint64_t)k_tar_shift_byte) | (uint64_t)field[i];
  }
  *out = v;
  return k_ra8_ok;
}
 
RA8_PRIV ra8_err_t priv_unarch_tar_num(const uint8_t* field, size_t len, uint64_t* out)
{
  RA8_CHECK_NULL_PTR(field, s_tag_tar_f, "num: null field");
  RA8_CHECK_NULL_PTR(out, s_tag_tar_f, "num: null out");
  *out = 0U;
  if (len == 0U) {
    return k_ra8_err_validation_failed;
  }
  if ((field[0] & (uint8_t)k_tar_b256_flag) != 0U) {
    return internal_base256(field, len, out);
  }
  return internal_octal(field, len, out);
}
 
RA8_PRIV bool priv_unarch_tar_block_zero(const uint8_t* block)
{
  for (uint32_t i = 0U; i < (uint32_t)k_unarch_tar_block; ++i) { /* bound: block size */
    if (block[i] != 0U) {
      return false;
    }
  }
  return true;
}
 
RA8_PRIV bool priv_unarch_tar_checksum_ok(const uint8_t* block)
{
  uint32_t sum = 0U;
  for (uint32_t i = 0U; i < (uint32_t)k_unarch_tar_block; ++i) { /* bound: block size */
    const bool in_chksum = (i >= (uint32_t)k_ra8_tar_off_chksum) &&
                           (i < ((uint32_t)k_ra8_tar_off_chksum + (uint32_t)k_ra8_tar_len_chksum));
    sum += in_chksum ? (uint32_t)k_tar_chksum_space : (uint32_t)block[i];
  }
  uint64_t stored = 0U;
  if (internal_octal(&block[k_ra8_tar_off_chksum], (size_t)k_ra8_tar_len_chksum, &stored) !=
      k_ra8_ok) {
    return false;
  }
  return stored == (uint64_t)sum;
}
 
RA8_PRIV bool priv_unarch_tar_magic_ok(const uint8_t* block)
{
  static const uint8_t magic[] = {'u', 's', 't', 'a', 'r'};
  for (size_t i = 0U; i < sizeof(magic); ++i) {
    if (block[(size_t)k_ra8_tar_off_magic + i] != magic[i]) {
      return false;
    }
  }
  const uint8_t term = block[k_ra8_tar_off_magic_term];
  return (term == 0U) || (term == (uint8_t)' ');
}
 
RA8_PRIV ra8_tar_type_t priv_unarch_tar_classify(uint8_t typeflag)
{
  if (typeflag == (uint8_t)'0') {
    return k_ra8_tar_type_file;
  }
  if (typeflag == 0U) {
    return k_ra8_tar_type_file; /* pre-POSIX regular-file flag */
  }
  if (typeflag == (uint8_t)'5') {
    return k_ra8_tar_type_dir;
  }
  if (typeflag == (uint8_t)'x') {
    return k_ra8_tar_type_pax;
  }
  if (typeflag == (uint8_t)'g') {
    return k_ra8_tar_type_meta;
  }
  if (typeflag == (uint8_t)'K') {
    return k_ra8_tar_type_meta;
  }
  if (typeflag == (uint8_t)'L') {
    return k_ra8_tar_type_longname;
  }
  return k_ra8_tar_type_other;
}

RA8_INTERNAL
static ra8_err_t internal_pax_reclen(const uint8_t* data, size_t len, size_t* reclen, size_t* body)
{
  uint64_t v      = 0U;
  size_t   digits = 0U;
  size_t   i      = 0U;
  while (i < len) { /* bound: len */
    const uint8_t c = data[i];
    if (c == (uint8_t)' ') {
      break;
    }
    if (c < (uint8_t)'0') {
      return k_ra8_err_validation_failed;
    }
    if (c > (uint8_t)'9') {
      return k_ra8_err_validation_failed;
    }
    if (digits >= (size_t)k_tar_pax_len_max) {
      return k_ra8_err_validation_failed; /* absurd length prefix */
    }
    v = (v * (uint64_t)k_tar_decimal_base) + ((uint64_t)c - (uint64_t)(uint8_t)'0');
    digits += 1U;
    i += 1U;
  }
  if (digits == 0U) {
    return k_ra8_err_validation_failed; /* no digits before the space */
  }
  if (i >= len) {
    return k_ra8_err_validation_failed; /* ran out before the space */
  }
  *reclen = (size_t)v;
  *body   = i + 1U;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_pax_size_value(const uint8_t* val, size_t len, uint64_t* out)
{
  if (len == 0U) {
    return k_ra8_err_validation_failed;
  }
  uint64_t v = 0U;
  for (size_t i = 0U; i < len; ++i) { /* bound: len */
    const uint8_t c = val[i];
    if (c < (uint8_t)'0') {
      return k_ra8_err_validation_failed;
    }
    if (c > (uint8_t)'9') {
      return k_ra8_err_validation_failed;
    }
    const uint64_t d = (uint64_t)c - (uint64_t)(uint8_t)'0';
    if (v > ((UINT64_MAX - d) / (uint64_t)k_tar_decimal_base)) {
      return k_ra8_err_validation_failed; /* would overflow uint64 */
    }
    v = (v * (uint64_t)k_tar_decimal_base) + d;
  }
  *out = v;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_pax_apply(const uint8_t* key,
                                    size_t         key_len,
                                    const uint8_t* val,
                                    size_t         val_len,
                                    char*          name_buf,
                                    uint16_t       name_cap,
                                    uint16_t*      name_len,
                                    bool*          have_path,
                                    uint64_t*      size_ovr,
                                    bool*          have_size)
{
  static const uint8_t key_path[] = {'p', 'a', 't', 'h'};
  static const uint8_t key_size[] = {'s', 'i', 'z', 'e'};
  bool                 is_path    = key_len == sizeof(key_path);
  for (size_t i = 0U; is_path && (i < sizeof(key_path)); ++i) {
    is_path = key[i] == key_path[i];
  }
  if (is_path) {
    const size_t want = (val_len > (size_t)name_cap) ? (size_t)name_cap : val_len;
    if (want > 0U) {
      (void)memcpy(name_buf, val, want);
    }
    *name_len  = (uint16_t)want;
    *have_path = true;
    return k_ra8_ok;
  }
  bool is_size = key_len == sizeof(key_size);
  for (size_t i = 0U; is_size && (i < sizeof(key_size)); ++i) {
    is_size = key[i] == key_size[i];
  }
  if (is_size) {
    const ra8_err_t verr = internal_pax_size_value(val, val_len, size_ovr);
    if (verr != k_ra8_ok) {
      return verr;
    }
    *have_size = true;
  }
  return k_ra8_ok;
}
// NOLINTNEXTLINE(readability-function-size,readability-function-cognitive-complexity) -- keyed pax record state machine: length, key and value share one bounded cursor, so splitting it would duplicate that cursor state across helpers.
RA8_PRIV ra8_err_t priv_unarch_tar_pax_parse(const uint8_t* data,
                                             size_t         len,
                                             char*          name_buf,
                                             uint16_t       name_cap,
                                             uint16_t*      name_len,
                                             bool*          have_path,
                                             uint64_t*      size_ovr,
                                             bool*          have_size)
{
  RA8_CHECK_NULL_PTR(data, s_tag_tar_f, "pax: null data");
  RA8_CHECK_NULL_PTR(name_len, s_tag_tar_f, "pax: null name_len");
  RA8_CHECK_NULL_PTR(have_path, s_tag_tar_f, "pax: null have_path");
  RA8_CHECK_NULL_PTR(size_ovr, s_tag_tar_f, "pax: null size_ovr");
  RA8_CHECK_NULL_PTR(have_size, s_tag_tar_f, "pax: null have_size");
  if (name_cap > 0U) {
    RA8_CHECK_NULL_PTR(name_buf, s_tag_tar_f, "pax: null name_buf");
  }
  size_t off = 0U;
  while (off < len) { /* bound: every record advances by reclen >= body + 1 */
    size_t          reclen = 0U;
    size_t          body   = 0U;
    const ra8_err_t lerr   = internal_pax_reclen(&data[off], len - off, &reclen, &body);
    if (lerr != k_ra8_ok) {
      return lerr;
    }
    if (reclen <= body) {
      return k_ra8_err_validation_failed; /* length cannot cover its prefix */
    }
    if (reclen > (len - off)) {
      return k_ra8_err_validation_failed; /* record overruns the data */
    }
    if (data[off + reclen - 1U] != (uint8_t)'\n') {
      return k_ra8_err_validation_failed; /* record must end in newline */
    }
    const uint8_t* kv      = &data[off + body];
    const size_t   kv_len  = reclen - body - 1U; /* strip the newline */
    size_t         key_len = 0U;
    while ((key_len < kv_len) && (kv[key_len] != (uint8_t)'=')) {
      key_len += 1U;
    }
    if (key_len == kv_len) {
      return k_ra8_err_validation_failed; /* no key/value delimiter */
    }
    const ra8_err_t aerr = internal_pax_apply(kv,
                                              key_len,
                                              &kv[key_len + 1U],
                                              kv_len - key_len - 1U,
                                              name_buf,
                                              name_cap,
                                              name_len,
                                              have_path,
                                              size_ovr,
                                              have_size);
    if (aerr != k_ra8_ok) {
      return aerr;
    }
    off += reclen;
  }
  return k_ra8_ok;
}