ra8_rar.c

Go to the documentation of this file.

#include "ra8_rar.h"
 
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_rar5.h"

static const char* const s_tag_rar = "ra8_rar";

RA8_INTERNAL static void internal_copy_object(void* dst, const void* src, size_t len)
{
  (void)memcpy(dst, src, len);
}

RA8_INTERNAL static bool internal_bytes_equal(const void* lhs, const void* rhs, size_t len)
{
  return memcmp(lhs, rhs, len) == 0;
}

typedef enum : uint8_t {
  k_rar_vint_data = 0x7FU, 
  k_rar_vint_cont = 0x80U, 
  k_rar_vint_bits = 7U,    
} rar_vint_bits_t;

typedef enum : uint16_t {
  k_rar4_off_type       = 2U,  
  k_rar4_off_flags      = 3U,  
  k_rar4_off_size       = 5U,  
  k_rar4_off_add        = 7U,  
  k_rar4_base_len       = 7U,  
  k_rar4_off_unp        = 11U, 
  k_rar4_off_method     = 25U, 
  k_rar4_off_namesz     = 26U, 
  k_rar4_off_attr       = 28U, 
  k_rar4_off_name       = 32U, 
  k_rar4_off_name_large = 40U, 
} rar4_layout_t;

typedef enum : uint16_t {
  k_rar4_flag_long   = 0x8000U, 
  k_rar4_flag_large  = 0x0100U, 
  k_rar4_flag_dirmsk = 0x00E0U, 
  k_rar4_type_file   = 0x0074U, 
  k_rar4_method_stor = 0x0030U, 
} rar4_bits_t;

typedef enum : uint8_t {
  k_rar5_type_file    = 2U,    
  k_rar5_hflag_extra  = 0x01U, 
  k_rar5_hflag_data   = 0x02U, 
  k_rar5_fflag_dir    = 0x01U, 
  k_rar5_fflag_mtime  = 0x02U, 
  k_rar5_fflag_crc    = 0x04U, 
  k_rar5_method_shift = 7U,    
  k_rar5_method_mask  = 0x07U, 
  k_rar5_fixed_field  = 4U,    
} rar5_bits_t;

typedef enum : uint8_t {
  k_rar_w16   = 2U,  
  k_rar_w32   = 4U,  
  k_rar_hi_sh = 32U, 
} rar_word_t;

RA8_INTERNAL
static uint16_t internal_le16(const uint8_t* p)
{
  uint16_t v = 0U;
  internal_copy_object(&v, p, sizeof(v));
  return v;
}

RA8_INTERNAL
static uint32_t internal_le32(const uint8_t* p)
{
  uint32_t v = 0U;
  internal_copy_object(&v, p, sizeof(v));
  return v;
}

RA8_INTERNAL
static bool internal_vint(const uint8_t* buf, size_t len, size_t* pos, uint64_t* val)
{
  uint32_t       words[2] = {0U, 0U}; /* [0] = low 32 bits, [1] = high 32 bits */
  uint32_t       shift    = 0U;
  const uint32_t hi_bit   = (uint32_t)k_rar_hi_sh;                             /* 32         */
  const uint32_t straddle = (uint32_t)k_rar_hi_sh - (uint32_t)k_rar_vint_bits; /* 25         */
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_rar_vint_max; ++i) {               /* <=10 bytes */
    if (*pos >= len) {
      return false;
    }
    const uint8_t b = buf[*pos];
    *pos += 1U;
    const uint32_t d = (uint32_t)b & (uint32_t)k_rar_vint_data;
    if (shift < hi_bit) {
      words[0] |= (uint32_t)(d << shift);
      if (shift > straddle) { /* this 7-bit group straddles the 32-bit boundary */
        words[1] |= (uint32_t)(d >> (hi_bit - shift));
      }
    } else {
      words[1] |= (uint32_t)(d << (shift - hi_bit));
    }
    if ((b & (uint8_t)k_rar_vint_cont) == 0U) {
      internal_copy_object(val, words, sizeof(*val)); /* LE host + target: word[0] low */
      return true;
    }
    shift += (uint32_t)k_rar_vint_bits;
  }
  return false;
}

RA8_INTERNAL
static uint16_t internal_copy_name(const ra8_rar_t* rar,
                                   uint64_t         name_abs,
                                   const uint8_t*   scratch,
                                   size_t           n,
                                   size_t           in_pos,
                                   uint64_t         name_len,
                                   char*            name_buf,
                                   uint16_t         name_cap)
{
  if (name_buf == nullptr) {
    return 0U;
  }
  if (name_cap == 0U) {
    return 0U;
  }
  const uint16_t want = (name_len > (uint64_t)name_cap) ? name_cap : (uint16_t)name_len;
  if ((in_pos + (size_t)want) <= n) {
    (void)memcpy(name_buf, &scratch[in_pos], (size_t)want);
    return want;
  }
  const size_t got = rar->read(rar->ctx, name_abs, name_buf, (size_t)want);
  return (uint16_t)got;
}

RA8_INTERNAL
static bool internal_rar4_file(const ra8_rar_t* rar,
                               uint64_t         off,
                               const uint8_t*   scratch,
                               size_t           n,
                               uint16_t         flags,
                               uint16_t         hsize,
                               char*            nbuf,
                               uint16_t         ncap,
                               ra8_rar_entry_t* out)
{
  const bool   large   = (flags & (uint16_t)k_rar4_flag_large) != 0U;
  const size_t needfix = large ? (size_t)k_rar4_off_name_large : (size_t)k_rar4_off_name;
  if (n < needfix) {
    return false;
  }
  uint64_t       pack   = (uint64_t)internal_le32(&scratch[k_rar4_off_add]);
  uint64_t       unp    = (uint64_t)internal_le32(&scratch[k_rar4_off_unp]);
  const uint8_t  method = scratch[k_rar4_off_method];
  const uint16_t namesz = internal_le16(&scratch[k_rar4_off_namesz]);
  size_t         pos    = (size_t)k_rar4_off_name;
  if (large) {
    pack |= (uint64_t)internal_le32(&scratch[k_rar4_off_name]) << (uint32_t)k_rar_hi_sh;
    unp |= (uint64_t)internal_le32(&scratch[(size_t)k_rar4_off_name + (size_t)k_rar_w32])
           << (uint32_t)k_rar_hi_sh;
    pos = (size_t)k_rar4_off_name_large;
  }
  out->is_file = 1U;
  out->is_dir  = ((flags & (uint16_t)k_rar4_flag_dirmsk) == (uint16_t)k_rar4_flag_dirmsk) ? 1U : 0U;
  out->method  = (method == (uint8_t)k_rar4_method_stor) ? (uint8_t)k_ra8_rar_method_store
                                                         : (uint8_t)k_ra8_rar_method_compressed;
  out->pack_size = pack;
  out->unp_size  = unp;
  out->data_off  = off + (uint64_t)hsize;
  out->next_off  = off + (uint64_t)hsize + pack;
  out->name_len =
    internal_copy_name(rar, off + (uint64_t)pos, scratch, n, pos, (uint64_t)namesz, nbuf, ncap);
  return true;
}

RA8_INTERNAL
static ra8_err_t internal_rar4_block(const ra8_rar_t* rar,
                                     uint64_t         off,
                                     char*            nbuf,
                                     uint16_t         ncap,
                                     ra8_rar_entry_t* out)
{
  uint8_t      scratch[k_ra8_rar_hdr_scratch] = {};
  const size_t n                              = rar->read(rar->ctx, off, scratch, sizeof(scratch));
  if (n < (size_t)k_rar4_base_len) {
    return k_ra8_err_validation_failed;
  }
  const uint8_t  type  = scratch[k_rar4_off_type];
  const uint16_t flags = internal_le16(&scratch[k_rar4_off_flags]);
  const uint16_t hsize = internal_le16(&scratch[k_rar4_off_size]);
  if (hsize < (uint16_t)k_rar4_base_len) {
    return k_ra8_err_validation_failed;
  }
  const bool islong = (flags & (uint16_t)k_rar4_flag_long) != 0U;
  uint64_t   add    = 0U;
  if (islong) {
    if (n >= ((size_t)k_rar4_off_add + (size_t)k_rar_w32)) {
      add = (uint64_t)internal_le32(&scratch[k_rar4_off_add]);
    }
  }
  if (type == (uint8_t)k_rar4_type_file) {
    if (!internal_rar4_file(rar, off, scratch, n, flags, hsize, nbuf, ncap, out)) {
      return k_ra8_err_validation_failed;
    }
  } else {
    out->next_off = off + (uint64_t)hsize + add;
  }
  if (out->next_off <= off) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static bool internal_rar5_file_vints(const uint8_t* scratch,
                                     size_t         n,
                                     size_t*        pos,
                                     uint64_t*      fflags,
                                     uint64_t*      unp,
                                     uint64_t*      cinfo,
                                     uint64_t*      namesz)
{
  uint64_t attr   = 0U;
  uint64_t hostos = 0U;
  if (!internal_vint(scratch, n, pos, fflags)) {
    return false;
  }
  if (!internal_vint(scratch, n, pos, unp)) {
    return false;
  }
  if (!internal_vint(scratch, n, pos, &attr)) {
    return false;
  }
  if ((*fflags & (uint64_t)k_rar5_fflag_mtime) != 0U) {
    *pos += (size_t)k_rar5_fixed_field;
  }
  if ((*fflags & (uint64_t)k_rar5_fflag_crc) != 0U) {
    *pos += (size_t)k_rar5_fixed_field;
  }
  if (!internal_vint(scratch, n, pos, cinfo)) {
    return false;
  }
  if (!internal_vint(scratch, n, pos, &hostos)) {
    return false;
  }
  if (!internal_vint(scratch, n, pos, namesz)) {
    return false;
  }
  (void)attr;   /* decoded to advance the vint stream; value unused here */
  (void)hostos; /* decoded to advance the vint stream; value unused here */
  return true;
}

RA8_INTERNAL
static bool internal_rar5_file(const ra8_rar_t* rar,
                               uint64_t         off,
                               const uint8_t*   scratch,
                               size_t           n,
                               size_t           pos,
                               uint64_t         data_off,
                               uint64_t         dsize,
                               char*            nbuf,
                               uint16_t         ncap,
                               ra8_rar_entry_t* out)
{
  uint64_t fflags = 0U;
  uint64_t unp    = 0U;
  uint64_t cinfo  = 0U;
  uint64_t namesz = 0U;
  if (!internal_rar5_file_vints(scratch, n, &pos, &fflags, &unp, &cinfo, &namesz)) {
    return false;
  }
  const uint8_t method =
    (uint8_t)((cinfo >> (uint64_t)k_rar5_method_shift) & (uint64_t)k_rar5_method_mask);
  out->is_file = 1U;
  out->is_dir  = ((fflags & (uint64_t)k_rar5_fflag_dir) != 0U) ? 1U : 0U;
  out->method =
    (method == 0U) ? (uint8_t)k_ra8_rar_method_store : (uint8_t)k_ra8_rar_method_compressed;
  out->unp_size  = unp;
  out->pack_size = dsize;
  out->data_off  = data_off;
  out->name_len = internal_copy_name(rar, off + (uint64_t)pos, scratch, n, pos, namesz, nbuf, ncap);
  return true;
}

RA8_INTERNAL
static ra8_err_t internal_rar5_block(const ra8_rar_t* rar,
                                     uint64_t         off,
                                     char*            nbuf,
                                     uint16_t         ncap,
                                     ra8_rar_entry_t* out)
{
  uint8_t      scratch[k_ra8_rar_hdr_scratch] = {};
  const size_t n                              = rar->read(rar->ctx, off, scratch, sizeof(scratch));
  size_t       pos   = (size_t)k_rar_w32; /* skip the 4-byte header CRC32 */
  uint64_t     hsize = 0U;
  if (!internal_vint(scratch, n, &pos, &hsize)) {
    return k_ra8_err_validation_failed;
  }
  const uint64_t data_off = off + (uint64_t)pos + hsize; /* header data ends here */
  uint64_t       htype    = 0U;
  uint64_t       hflags   = 0U;
  if (!internal_vint(scratch, n, &pos, &htype)) {
    return k_ra8_err_validation_failed;
  }
  if (!internal_vint(scratch, n, &pos, &hflags)) {
    return k_ra8_err_validation_failed;
  }
  uint64_t extra = 0U;
  if ((hflags & (uint64_t)k_rar5_hflag_extra) != 0U) {
    if (!internal_vint(scratch, n, &pos, &extra)) {
      return k_ra8_err_validation_failed;
    }
  }
  (void)extra; /* extra-area length is skipped via the header-size vint */
  uint64_t dsize = 0U;
  if ((hflags & (uint64_t)k_rar5_hflag_data) != 0U) {
    if (!internal_vint(scratch, n, &pos, &dsize)) {
      return k_ra8_err_validation_failed;
    }
  }
  out->next_off = data_off + dsize;
  if (htype == (uint64_t)k_rar5_type_file) {
    if (!internal_rar5_file(rar, off, scratch, n, pos, data_off, dsize, nbuf, ncap, out)) {
      return k_ra8_err_validation_failed;
    }
  }
  if (out->next_off <= off) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_rar_match_signature(const uint8_t* hdr, size_t got, ra8_rar_t* rar)
{
  static const char k_sig5[] = "Rar!\x1A\x07\x01"; /* + implicit NUL = 8-byte RAR5 sig    */
  static const char k_sig4[] = "Rar!\x1A\x07";     /* + implicit NUL = 7-byte RAR4 marker */
  static_assert(sizeof(k_sig5) == (size_t)k_ra8_rar_sig5_len, "RAR5 signature length");
  static_assert(sizeof(k_sig4) == (size_t)k_ra8_rar_sig4_len, "RAR4 marker length");
  if (got >= (size_t)k_ra8_rar_sig5_len) {
    if (internal_bytes_equal(hdr, k_sig5, (size_t)k_ra8_rar_sig5_len)) {
      rar->version   = k_ra8_rar_ver_5;
      rar->first_off = (uint64_t)k_ra8_rar_sig5_len;
      return;
    }
  }
  if (internal_bytes_equal(hdr, k_sig4, (size_t)k_ra8_rar_sig4_len)) {
    rar->version   = k_ra8_rar_ver_4;
    rar->first_off = (uint64_t)k_ra8_rar_sig4_len;
  }
}
 
ra8_err_t ra8_rar_open(ra8_rar_t* rar, ra8_rar_read_fn read, void* ctx, uint64_t size)
{
  RA8_CHECK_NULL_PTR(rar, s_tag_rar, "open: null rar");
  RA8_CHECK_NULL_PTR(read, s_tag_rar, "open: null read");
  *rar = (ra8_rar_t){};
  if (size < (uint64_t)k_ra8_rar_sig4_len) {
    return k_ra8_err_invalid_size;
  }
  uint8_t      hdr[k_ra8_rar_sig5_len] = {};
  const size_t got                     = read(ctx, 0U, hdr, sizeof(hdr));
  if (got < (size_t)k_ra8_rar_sig4_len) {
    return k_ra8_err_invalid_size;
  }
  internal_rar_match_signature(hdr, got, rar);
  if (rar->version == k_ra8_rar_ver_none) {
    return k_ra8_err_not_supported;
  }
  rar->read = read;
  rar->ctx  = ctx;
  rar->size = size;
  return k_ra8_ok;
}
 
ra8_err_t ra8_rar_next(const ra8_rar_t* rar,
                       uint64_t         off,
                       char*            name_buf,
                       uint16_t         name_cap,
                       ra8_rar_entry_t* out)
{
  RA8_CHECK_NULL_PTR(rar, s_tag_rar, "next: null rar");
  RA8_CHECK_NULL_PTR(out, s_tag_rar, "next: null out");
  *out = (ra8_rar_entry_t){};
  if (rar->version == k_ra8_rar_ver_none) {
    return k_ra8_err_invalid_state;
  }
  if (off >= rar->size) {
    return k_ra8_err_invalid_arg;
  }
  if (rar->version == k_ra8_rar_ver_5) {
    return internal_rar5_block(rar, off, name_buf, name_cap, out);
  }
  return internal_rar4_block(rar, off, name_buf, name_cap, out);
}

RA8_INTERNAL
static ra8_err_t
internal_rar_check_stored(const ra8_rar_t* rar, const ra8_rar_entry_t* ent, size_t cap)
{
  if (rar->version == k_ra8_rar_ver_none) {
    return k_ra8_err_invalid_state;
  }
  if (ent->is_file == 0U) {
    return k_ra8_err_not_supported;
  }
  if (ent->is_dir != 0U) {
    return k_ra8_err_not_supported;
  }
  if (ent->method != (uint8_t)k_ra8_rar_method_store) {
    return k_ra8_err_not_supported;
  }
  if (ent->unp_size > (uint64_t)cap) {
    return k_ra8_err_no_mem;
  }
  if ((ent->data_off + ent->unp_size) > rar->size) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static bool
internal_rar_read_exact(const ra8_rar_t* rar, uint64_t data_off, uint64_t need, uint8_t* buf)
{
  size_t total = 0U;
  while ((uint64_t)total < need) { /* bound: need fixed; each pass reads >=1 or breaks */
    const size_t chunk = (size_t)(need - (uint64_t)total);
    const size_t r     = rar->read(rar->ctx, data_off + (uint64_t)total, &buf[total], chunk);
    if (r == 0U) {
      break;
    }
    total += r;
  }
  return (uint64_t)total == need;
}
 
ra8_err_t ra8_rar_extract_stored(const ra8_rar_t*       rar,
                                 const ra8_rar_entry_t* ent,
                                 uint8_t*               buf,
                                 size_t                 cap,
                                 size_t*                got)
{
  RA8_CHECK_NULL_PTR(rar, s_tag_rar, "extract: null rar");
  RA8_CHECK_NULL_PTR(ent, s_tag_rar, "extract: null ent");
  RA8_CHECK_NULL_PTR(buf, s_tag_rar, "extract: null buf");
  RA8_CHECK_NULL_PTR(got, s_tag_rar, "extract: null got");
  *got                   = 0U;
  const ra8_err_t vcheck = internal_rar_check_stored(rar, ent, cap);
  if (vcheck != k_ra8_ok) {
    return vcheck;
  }
  if (!internal_rar_read_exact(rar, ent->data_off, ent->unp_size, buf)) {
    return k_ra8_err_invalid_size;
  }
  *got = (size_t)ent->unp_size;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_rar_extract_reject_null(const ra8_rar_t*       rar,
                                                  const ra8_rar_entry_t* ent,
                                                  const uint8_t*         buf,
                                                  const size_t*          got)
{
  RA8_CHECK_NULL_PTR(rar, s_tag_rar, "extract: null rar");
  RA8_CHECK_NULL_PTR(ent, s_tag_rar, "extract: null ent");
  RA8_CHECK_NULL_PTR(buf, s_tag_rar, "extract: null buf");
  RA8_CHECK_NULL_PTR(got, s_tag_rar, "extract: null got");
  return k_ra8_ok;
}
 
ra8_err_t ra8_rar_extract(const ra8_rar_t*       rar,
                          const ra8_rar_entry_t* ent,
                          uint8_t*               buf,
                          size_t                 cap,
                          ra8_rar5_state_t*      st,
                          size_t*                got)
{
  const ra8_err_t nchk = internal_rar_extract_reject_null(rar, ent, buf, got);
  if (nchk != k_ra8_ok) {
    return nchk;
  }
  *got = 0U;
  if (rar->version == k_ra8_rar_ver_none) {
    return k_ra8_err_invalid_state;
  }
  if ((ent->is_file == 0U) || (ent->is_dir != 0U)) {
    return k_ra8_err_not_supported;
  }
  if (ent->method == (uint8_t)k_ra8_rar_method_store) {
    return ra8_rar_extract_stored(rar, ent, buf, cap, got);
  }
  if (rar->version != k_ra8_rar_ver_5) {
    return k_ra8_err_not_supported; /* RAR4 legacy codec is out of scope */
  }
  RA8_CHECK_NULL_PTR(st, s_tag_rar, "extract: null st for compressed");
  return ra8_rar5_decompress(rar, ent->data_off, ent->pack_size, buf, cap, ent->unp_size, st, got);
}