ra8_fs_fat_exfat_label.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_fs.h"
#include "ra8_fs_fat_internal.h"
#include "ra8_fs_meta.h"

RA8_INTERNAL
static ra8_err_t internal_exfat_locate_label(const ra8_fs_mount_t* m,
                                             exfat_setpos_t*       out_pos,
                                             uint8_t*              out_entry,
                                             bool*                 out_present)
{
  const uint8_t label_type =
    (uint8_t)((uint32_t)k_exfat_entry_label & (uint32_t)~(uint32_t)k_exfat_inuse_bit);
  exfat_dir_t root = {};
  priv_exfat_dir_root(m, &root);
  exfat_cursor_t cur = {};
  priv_exfat_cursor_init(&root, &cur);
  while (cur.scanned < (uint32_t)k_exfat_scan_limit) {
    const exfat_setpos_t at = {.cluster = cur.cluster, .index = cur.entry_in_cluster};
    uint8_t              e[k_exfat_entry_bytes] = {};
    const ra8_err_t      err                    = priv_exfat_next_entry(m, &cur, e);
    if (err != k_ra8_ok) {
      return err;
    }
    if (e[0] == (uint8_t)k_exfat_entry_eod) {
      *out_pos     = at;
      *out_present = false;
      return k_ra8_ok;
    }
    if ((uint8_t)(e[0] & (uint8_t)~(uint8_t)k_exfat_inuse_bit) == label_type) {
      *out_pos = at;
      priv_byte_copy(out_entry, e, (uint32_t)k_exfat_entry_bytes);
      *out_present = true;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}

RA8_INTERNAL
static void internal_exfat_label_decode(const uint8_t* entry, char* out, uint32_t out_len)
{
  uint32_t n = (uint32_t)entry[k_exfat_de_lbl_cnt];
  if (n > (uint32_t)k_exfat_fmt_label_max) {
    n = (uint32_t)k_exfat_fmt_label_max;
  }
  uint32_t w = 0U;
  for (uint32_t i = 0U; i < n; i++) {
    if ((w + 1U) >= out_len) {
      break;
    }
    out[w] = (char)entry[(uint32_t)k_exfat_de_lbl_name + (i * 2U)];
    w++;
  }
  out[w] = '\0';
}
 
/* `priv_exfat_get_label()`: see header for the documented contract. */
ra8_err_t priv_exfat_get_label(const ra8_fs_mount_t* m, char* out, uint32_t out_len)
{
  exfat_setpos_t  pos                        = {};
  uint8_t         entry[k_exfat_entry_bytes] = {};
  bool            present                    = false;
  const ra8_err_t err = internal_exfat_locate_label(m, &pos, entry, &present);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!present || (entry[0] != (uint8_t)k_exfat_entry_label)) {
    out[0] = '\0'; /* no entry, or a cleared (0x03) one: unlabelled */
    return k_ra8_ok;
  }
  internal_exfat_label_decode(entry, out, out_len);
  return k_ra8_ok;
}
 
/* `priv_exfat_set_label()`: see header for the documented contract. */
ra8_err_t priv_exfat_set_label(const ra8_fs_mount_t* m, const char* label)
{
  exfat_setpos_t  pos                        = {};
  uint8_t         found[k_exfat_entry_bytes] = {};
  bool            present                    = false;
  const ra8_err_t err = internal_exfat_locate_label(m, &pos, found, &present);
  if (err != k_ra8_ok) {
    return err;
  }
  uint8_t entry[k_exfat_entry_bytes] = {};
  entry[0]                           = (uint8_t)k_exfat_entry_label;
  uint32_t n                         = 0U;
  if (label != nullptr) {
    while (n < (uint32_t)k_exfat_fmt_label_max) {
      if (label[n] == '\0') {
        break;
      }
      entry[(uint32_t)k_exfat_de_lbl_name + (n * 2U)] = (uint8_t)label[n];
      n++;
    }
  }
  entry[k_exfat_de_lbl_cnt] = (uint8_t)n;
  return priv_exfat_write_dir_set(m, pos.cluster, pos.index, entry, (uint32_t)k_exfat_entry_bytes);
}