mdl_library.c

Go to the documentation of this file.

#include "mdl_library.h"
 
#include <stdint.h>
#include <string.h>
 
#include "mdl_sanitize.h"
#include "ra8_attributes.h"

static const char s_state_basename[] = ".mdl_state";

typedef struct {
  mdl_storage_t* storage;      
  const char*    root;         
  mdl_state_t*   state;        
  mdl_library_fn callback;     
  void*          callback_ctx; 
} mdl_library_enumeration_t;
 
mdl_library_policy_t mdl_library_policy_default(void)
{
  return (mdl_library_policy_t){.max_entries    = (uint32_t)k_mdl_library_entry_limit,
                                .max_operations = (uint32_t)k_mdl_library_operation_limit,
                                .max_depth      = (uint16_t)k_mdl_library_depth_limit};
}
 
ra8_err_t mdl_library_workspace_init(mdl_library_workspace_t* workspace,
                                     void*                    directory_workspace,
                                     uint32_t                 directory_workspace_bytes)
{
  if ((workspace == nullptr) || (directory_workspace == nullptr) ||
      (directory_workspace_bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  *workspace = (mdl_library_workspace_t){.directory_workspace       = directory_workspace,
                                         .directory_workspace_bytes = directory_workspace_bytes};
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_library_workspace_reset(mdl_library_workspace_t* workspace)
{
  workspace->entries          = 0U;
  workspace->required_entries = 0U;
  workspace->entry_limit      = 0U;
  workspace->operations       = 0U;
  workspace->depth            = 0U;
  memset(workspace->paths, 0, sizeof(workspace->paths));
}

RA8_INTERNAL static ra8_err_t internal_library_policy(const mdl_library_policy_t* policy)
{
  if ((policy == nullptr) || (policy->max_entries == 0U) || (policy->max_operations == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  if ((policy->max_entries > (uint32_t)k_mdl_library_entry_limit) ||
      (policy->max_operations > (uint32_t)k_mdl_library_operation_limit) ||
      (policy->max_depth > (uint16_t)k_mdl_library_depth_limit)) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_library_leaf(const mdl_storage_t*        storage,
                                                    const fw_fs_dirent_value_t* entry,
                                                    size_t*                     out_length)
{
  if (entry->name_bytes == 0U) {
    return k_ra8_err_invalid_state;
  }
  const size_t length = strnlen(entry->name, (size_t)k_fw_fs_path_cap);
  if ((length >= (size_t)k_fw_fs_path_cap) || (length != (size_t)entry->name_bytes) ||
      (length > (size_t)storage->fs->caps.name_max_bytes)) {
    return k_ra8_err_invalid_state;
  }
  if ((strcmp(entry->name, ".") == 0) || (strcmp(entry->name, "..") == 0) ||
      (strpbrk(entry->name, "/\\") != nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  *out_length = length;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_library_visit(mdl_library_enumeration_t*  walk,
                                                     const fw_fs_dirent_value_t* entry,
                                                     bool*                       out_continue)
{
  *out_continue = true;
  if (entry->type != k_fw_fs_node_directory) {
    return k_ra8_ok;
  }
  char series[k_fw_fs_path_cap];
  char state[k_fw_fs_path_cap];
  if (!mdl_path_join(walk->root, entry->name, series, sizeof(series)) ||
      !mdl_path_join(series, s_state_basename, state, sizeof(state))) {
    return k_ra8_err_invalid_size;
  }
  ra8_err_t    err  = k_ra8_ok;
  fw_fs_stat_t node = {};
  err               = fw_fs_stat(&walk->storage->fs->names, series, &node);
  if (err != k_ra8_ok) {
    return err;
  }
  if (!node.exists || (node.type != entry->type)) {
    return k_ra8_err_invalid_state;
  }
  bool tracked = false;
  err          = mdl_state_probe(walk->storage, state, &tracked);
  if ((err != k_ra8_ok) || !tracked) {
    *out_continue = !tracked && (err == k_ra8_ok);
    return err;
  }
  err = mdl_state_load_authenticated(walk->storage, state, walk->state);
  if (err != k_ra8_ok) {
    return err;
  }
  bool user_continue = false;
  err = walk->callback(series, state, walk->state, walk->callback_ctx, &user_continue);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_continue = user_continue;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_library_close(fw_fs_dir_t* directory, ra8_err_t first)
{
  if (!directory->is_open) {
    return first;
  }
  const ra8_err_t closed = fw_fs_dir_close(directory);
  return (first == k_ra8_ok) ? closed : first;
}

RA8_INTERNAL static ra8_err_t
internal_library_root(mdl_storage_t* storage, const char* root_path, bool* out_exists)
{
  *out_exists          = false;
  fw_fs_stat_t    root = {};
  const ra8_err_t err  = fw_fs_stat(&storage->fs->names, root_path, &root);
  if ((err != k_ra8_ok) || !root.exists) {
    return err;
  }
  if (root.type == k_fw_fs_node_symlink) {
    return k_ra8_err_access_denied;
  }
  *out_exists = root.type == k_fw_fs_node_directory;
  return *out_exists ? k_ra8_ok : k_ra8_err_invalid_arg;
}

RA8_INTERNAL static ra8_err_t internal_library_enumerate(mdl_library_enumeration_t*  walk,
                                                         const mdl_library_policy_t* policy,
                                                         mdl_library_workspace_t*    workspace)
{
  fw_fs_dir_t directory = {};
  ra8_err_t   err       = fw_fs_dir_open(&walk->storage->fs->names,
                                         walk->root,
                                         &directory,
                                         workspace->directory_workspace,
                                         workspace->directory_workspace_bytes);
  while (err == k_ra8_ok) {
    fw_fs_dirent_value_t entry   = {};
    bool                 present = false;
    err                          = fw_fs_dir_next(&directory, &entry, &present);
    if ((err != k_ra8_ok) || !present) {
      break;
    }
    ++workspace->required_entries;
    if (workspace->required_entries > policy->max_entries) {
      err = k_ra8_err_invalid_size;
      break;
    }
    ++workspace->entries;
    bool keep_going = false;
    err             = internal_library_visit(walk, &entry, &keep_going);
    if ((err != k_ra8_ok) || !keep_going) {
      break;
    }
  }
  return internal_library_close(&directory, err);
}
 
ra8_err_t mdl_library_for_each(mdl_storage_t*              storage,
                               const char*                 out_dir,
                               mdl_state_t*                state_scratch,
                               mdl_library_workspace_t*    workspace,
                               const mdl_library_policy_t* policy,
                               mdl_library_fn              callback,
                               void*                       callback_ctx)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (out_dir == nullptr) ||
      (state_scratch == nullptr) || (workspace == nullptr) || (callback == nullptr) ||
      (workspace->directory_workspace == nullptr) || (workspace->directory_workspace_bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = internal_library_policy(policy);
  internal_library_workspace_reset(workspace);
  workspace->entry_limit = (policy != nullptr) ? policy->max_entries : 0U;
  bool root_exists       = false;
  if (err == k_ra8_ok) {
    err = internal_library_root(storage, out_dir, &root_exists);
  }
  if ((err != k_ra8_ok) || !root_exists) {
    return err;
  }
  mdl_library_enumeration_t walk = {.storage      = storage,
                                    .root         = out_dir,
                                    .state        = state_scratch,
                                    .callback     = callback,
                                    .callback_ctx = callback_ctx};
  return internal_library_enumerate(&walk, policy, workspace);
}

RA8_INTERNAL static ra8_err_t internal_library_take_operation(const mdl_library_policy_t* policy,
                                                              mdl_library_workspace_t*    workspace)
{
  if (workspace->operations >= policy->max_operations) {
    return k_ra8_err_invalid_size;
  }
  ++workspace->operations;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_library_first_child(mdl_storage_t*              storage,
                                                           const char*                 path,
                                                           const mdl_library_policy_t* policy,
                                                           mdl_library_workspace_t*    workspace,
                                                           fw_fs_dirent_value_t*       out,
                                                           bool*                       out_present)
{
  const uint32_t remaining = policy->max_operations - workspace->operations;
  if (remaining < 3U) {
    return k_ra8_err_invalid_size;
  }
  workspace->operations += 3U;
  fw_fs_dir_t directory = {};
  ra8_err_t   err       = fw_fs_dir_open(&storage->fs->names,
                                         path,
                                         &directory,
                                         workspace->directory_workspace,
                                         workspace->directory_workspace_bytes);
  if (err != k_ra8_ok) {
    workspace->operations -= 2U;
    return err;
  }
  err = fw_fs_dir_next(&directory, out, out_present);
  return internal_library_close(&directory, err);
}

RA8_INTERNAL static ra8_err_t internal_library_act_on_node(mdl_storage_t*              storage,
                                                           const mdl_library_policy_t* policy,
                                                           mdl_library_workspace_t*    workspace,
                                                           const char*                 path,
                                                           fw_fs_stat_t                node)
{
  if (node.type == k_fw_fs_node_directory) {
    if (workspace->depth >= policy->max_depth) {
      return k_ra8_err_invalid_size;
    }
    ++workspace->depth;
    memcpy(workspace->paths[workspace->depth], path, strlen(path) + 1U);
    return k_ra8_ok;
  }
  if (node.type == k_fw_fs_node_symlink) {
    return k_ra8_err_access_denied;
  }
  if (node.type != k_fw_fs_node_file) {
    return k_ra8_err_invalid_arg;
  }
  const ra8_err_t err = internal_library_take_operation(policy, workspace);
  return (err == k_ra8_ok) ? fw_fs_unlink(&storage->fs->names, path) : err;
}

RA8_INTERNAL static ra8_err_t internal_library_remove_child(mdl_storage_t*              storage,
                                                            const mdl_library_policy_t* policy,
                                                            mdl_library_workspace_t*    workspace,
                                                            const fw_fs_dirent_value_t* child)
{
  size_t    length = 0U;
  ra8_err_t err    = internal_library_leaf(storage, child, &length);
  (void)length;
  if (err != k_ra8_ok) {
    return err;
  }
  ++workspace->required_entries;
  if (workspace->required_entries > policy->max_entries) {
    return k_ra8_err_invalid_size;
  }
  ++workspace->entries;
  char path[k_fw_fs_path_cap];
  if (!mdl_path_join(workspace->paths[workspace->depth], child->name, path, sizeof(path))) {
    return k_ra8_err_invalid_size;
  }
  err               = internal_library_take_operation(policy, workspace);
  fw_fs_stat_t node = {};
  if (err == k_ra8_ok) {
    err = fw_fs_stat(&storage->fs->names, path, &node);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  if (!node.exists || (node.type != child->type)) {
    return k_ra8_err_invalid_state;
  }
  return internal_library_act_on_node(storage, policy, workspace, path, node);
}

RA8_INTERNAL static ra8_err_t internal_library_remove_root(mdl_storage_t*              storage,
                                                           const char*                 dir,
                                                           const mdl_library_policy_t* policy,
                                                           mdl_library_workspace_t*    workspace)
{
  internal_library_workspace_reset(workspace);
  workspace->entry_limit = policy->max_entries;
  if ((dir[0] == '/') && (dir[1] == '\0')) {
    return k_ra8_err_access_denied;
  }
  ra8_err_t    err  = internal_library_take_operation(policy, workspace);
  fw_fs_stat_t root = {};
  if (err == k_ra8_ok) {
    err = fw_fs_stat(&storage->fs->names, dir, &root);
  }
  if ((err != k_ra8_ok) || !root.exists) {
    return err;
  }
  if (root.type == k_fw_fs_node_symlink) {
    return k_ra8_err_access_denied;
  }
  if (root.type != k_fw_fs_node_directory) {
    return k_ra8_err_invalid_arg;
  }
  const size_t root_length = strnlen(dir, sizeof(workspace->paths[0]));
  if (root_length >= sizeof(workspace->paths[0])) {
    return k_ra8_err_invalid_size;
  }
  memcpy(workspace->paths[0], dir, root_length + 1U);
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_library_remove_walk(mdl_storage_t*              storage,
                                                           const mdl_library_policy_t* policy,
                                                           mdl_library_workspace_t*    workspace)
{
  for (;;) {
    fw_fs_dirent_value_t child   = {};
    bool                 present = false;
    ra8_err_t            err     = internal_library_first_child(storage,
                                                                workspace->paths[workspace->depth],
                                                                policy,
                                                                workspace,
                                                                &child,
                                                                &present);
    if (err != k_ra8_ok) {
      return err;
    }
    if (present) {
      err = internal_library_remove_child(storage, policy, workspace, &child);
      if (err != k_ra8_ok) {
        return err;
      }
      continue;
    }
    err = internal_library_take_operation(policy, workspace);
    if (err == k_ra8_ok) {
      err = fw_fs_rmdir(&storage->fs->names, workspace->paths[workspace->depth]);
    }
    if ((err != k_ra8_ok) || (workspace->depth == 0U)) {
      return err;
    }
    --workspace->depth;
  }
}
 
ra8_err_t mdl_library_remove_tree(mdl_storage_t*              storage,
                                  const char*                 dir,
                                  const mdl_library_policy_t* policy,
                                  mdl_library_workspace_t*    workspace)
{
  if ((storage == nullptr) || (storage->fs == nullptr) || (dir == nullptr) ||
      (workspace == nullptr) || (workspace->directory_workspace == nullptr) ||
      (workspace->directory_workspace_bytes == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = internal_library_policy(policy);
  if (err == k_ra8_ok) {
    err = internal_library_remove_root(storage, dir, policy, workspace);
  }
  return ((err == k_ra8_ok) && (workspace->paths[0][0] != '\0'))
           ? internal_library_remove_walk(storage, policy, workspace)
           : err;
}