fw_if_fs_dir.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "fw_if_fs.h"
#include "fw_if_fs_backend.h"
#include "ra8_attributes.h"
#include "ra8_err.h"

RA8_INTERNAL static ra8_err_t internal_cursor_names(const fw_fs_namespace_t* names)
{
  if (names == nullptr) {
    return k_ra8_err_null_ptr;
  }
  return (names->iface == nullptr) ? k_ra8_err_not_initialized : k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_cursor_workspace(void* workspace, uint32_t bytes, uint32_t need, uint8_t align)
{
  if (workspace == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (bytes < need) {
    return k_ra8_err_no_mem;
  }
  if ((align == 0U) || (((uint32_t)align & ((uint32_t)align - 1U)) != 0U)) {
    return k_ra8_err_invalid_state;
  }
  return (((uintptr_t)workspace % (uintptr_t)align) == 0U) ? k_ra8_ok : k_ra8_err_invalid_arg;
}

RA8_INTERNAL static ra8_err_t internal_cursor_handle(const fw_fs_dir_t* directory)
{
  if (directory == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!directory->is_open) {
    return k_ra8_err_invalid_state;
  }
  return (directory->iface == nullptr) ? k_ra8_err_not_initialized : k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cursor_entry(const fw_fs_caps_t*         caps,
                                                    const fw_fs_dirent_value_t* entry)
{
  if ((entry->name_bytes == 0U) || (entry->name_bytes > caps->name_max_bytes) ||
      (entry->name_bytes >= (uint16_t)k_fw_fs_path_cap)) {
    return k_ra8_err_invalid_state;
  }
  if ((entry->name[entry->name_bytes] != '\0') ||
      (strnlen(entry->name, (size_t)k_fw_fs_path_cap) != (size_t)entry->name_bytes)) {
    return k_ra8_err_invalid_state;
  }
  if ((entry->type == k_fw_fs_node_none) ||
      ((uint32_t)entry->type > (uint32_t)k_fw_fs_node_other) ||
      ((entry->type == k_fw_fs_node_directory) && (entry->size_bytes != 0U))) {
    return k_ra8_err_invalid_state;
  }
  char path[k_fw_fs_path_cap] = {'/'};
  (void)memcpy(&path[1], entry->name, (size_t)entry->name_bytes + 1U);
  return (fw_fs_path_validate(caps, path) == k_ra8_ok) ? k_ra8_ok : k_ra8_err_invalid_state;
}
 
ra8_err_t fw_fs_dir_open(const fw_fs_namespace_t* names,
                         const char*              path,
                         fw_fs_dir_t*             directory,
                         void*                    workspace,
                         uint32_t                 workspace_size)
{
  const ra8_err_t valid = internal_cursor_names(names);
  if (valid != k_ra8_ok) {
    return valid;
  }
  if (directory == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (directory->is_open) {
    return k_ra8_err_busy;
  }
  const ra8_err_t path_err = fw_fs_path_validate(&names->caps, path);
  if (path_err != k_ra8_ok) {
    return path_err;
  }
  const ra8_err_t work = internal_cursor_workspace(workspace,
                                                   workspace_size,
                                                   names->caps.directory_workspace_bytes,
                                                   names->caps.directory_workspace_align);
  if (work != k_ra8_ok) {
    return work;
  }
  const ra8_err_t opened = names->iface->dir_open(names->ctx, path, workspace, workspace_size);
  if (opened != k_ra8_ok) {
    return opened;
  }
  *directory = (fw_fs_dir_t){.iface       = names->iface,
                             .ctx         = names->ctx,
                             .state       = workspace,
                             .state_bytes = workspace_size,
                             .caps        = names->caps,
                             .is_open     = true};
  return k_ra8_ok;
}
 
ra8_err_t fw_fs_dir_next(fw_fs_dir_t* directory, fw_fs_dirent_value_t* out, bool* out_entry)
{
  const ra8_err_t valid = internal_cursor_handle(directory);
  if (valid != k_ra8_ok) {
    return valid;
  }
  if ((out == nullptr) || (out_entry == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out                           = (fw_fs_dirent_value_t){};
  *out_entry                     = false;
  fw_fs_dirent_value_t candidate = {};
  bool                 present   = false;
  const ra8_err_t      result =
    directory->iface->dir_next(directory->ctx, directory->state, &candidate, &present);
  if ((result != k_ra8_ok) || !present) {
    return result;
  }
  const ra8_err_t coherent = internal_cursor_entry(&directory->caps, &candidate);
  if (coherent != k_ra8_ok) {
    return coherent;
  }
  *out       = candidate;
  *out_entry = true;
  return k_ra8_ok;
}
 
ra8_err_t fw_fs_dir_close(fw_fs_dir_t* directory)
{
  const ra8_err_t valid = internal_cursor_handle(directory);
  if (valid != k_ra8_ok) {
    return valid;
  }
  const ra8_err_t closed = directory->iface->dir_close(directory->ctx, directory->state);
  *directory             = (fw_fs_dir_t){};
  return closed;
}