aboutsummaryrefslogtreecommitdiff
path: root/lib/sqfs/src/dir_reader
diff options
context:
space:
mode:
Diffstat (limited to 'lib/sqfs/src/dir_reader')
-rw-r--r--lib/sqfs/src/dir_reader/dir_reader.c366
-rw-r--r--lib/sqfs/src/dir_reader/get_path.c81
-rw-r--r--lib/sqfs/src/dir_reader/internal.h52
-rw-r--r--lib/sqfs/src/dir_reader/read_tree.c288
4 files changed, 787 insertions, 0 deletions
diff --git a/lib/sqfs/src/dir_reader/dir_reader.c b/lib/sqfs/src/dir_reader/dir_reader.c
new file mode 100644
index 0000000..d70f729
--- /dev/null
+++ b/lib/sqfs/src/dir_reader/dir_reader.c
@@ -0,0 +1,366 @@
+/* SPDX-License-Identifier: LGPL-3.0-or-later */
+/*
+ * fs_reader.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#define SQFS_BUILDING_DLL
+#include "internal.h"
+
+static int inode_copy(const sqfs_inode_generic_t *inode,
+ sqfs_inode_generic_t **out)
+{
+ *out = alloc_flex(sizeof(*inode), 1, inode->payload_bytes_used);
+ if (*out == NULL)
+ return SQFS_ERROR_ALLOC;
+
+ memcpy(*out, inode, sizeof(*inode) + inode->payload_bytes_used);
+ return 0;
+}
+
+static int dcache_key_compare(const void *ctx, const void *l, const void *r)
+{
+ sqfs_u32 lhs = *((const sqfs_u32 *)l), rhs = *((const sqfs_u32 *)r);
+ (void)ctx;
+
+ return lhs < rhs ? -1 : (lhs > rhs ? 1 : 0);
+}
+
+static int dcache_add(sqfs_dir_reader_t *rd,
+ const sqfs_inode_generic_t *inode, sqfs_u64 ref)
+{
+ sqfs_u32 inum = inode->base.inode_number;
+
+ if (!(rd->flags & SQFS_DIR_READER_DOT_ENTRIES))
+ return 0;
+
+ if (inode->base.type != SQFS_INODE_DIR &&
+ inode->base.type != SQFS_INODE_EXT_DIR) {
+ return 0;
+ }
+
+ if (rbtree_lookup(&rd->dcache, &inum) != NULL)
+ return 0;
+
+ return rbtree_insert(&rd->dcache, &inum, &ref);
+}
+
+static int dcache_find(sqfs_dir_reader_t *rd, sqfs_u32 inode, sqfs_u64 *ref)
+{
+ rbtree_node_t *node;
+
+ if (!(rd->flags & SQFS_DIR_READER_DOT_ENTRIES))
+ return SQFS_ERROR_NO_ENTRY;
+
+ node = rbtree_lookup(&rd->dcache, &inode);
+ if (node == NULL)
+ return SQFS_ERROR_NO_ENTRY;
+
+ *ref = *((sqfs_u64 *)rbtree_node_value(node));
+ return 0;
+}
+
+static void dir_reader_destroy(sqfs_object_t *obj)
+{
+ sqfs_dir_reader_t *rd = (sqfs_dir_reader_t *)obj;
+
+ if (rd->flags & SQFS_DIR_READER_DOT_ENTRIES)
+ rbtree_cleanup(&rd->dcache);
+
+ sqfs_drop(rd->meta_inode);
+ sqfs_drop(rd->meta_dir);
+ free(rd);
+}
+
+static sqfs_object_t *dir_reader_copy(const sqfs_object_t *obj)
+{
+ const sqfs_dir_reader_t *rd = (const sqfs_dir_reader_t *)obj;
+ sqfs_dir_reader_t *copy = malloc(sizeof(*copy));
+
+ if (copy == NULL)
+ return NULL;
+
+ memcpy(copy, rd, sizeof(*copy));
+
+ if (rd->flags & SQFS_DIR_READER_DOT_ENTRIES) {
+ if (rbtree_copy(&rd->dcache, &copy->dcache))
+ goto fail_cache;
+ }
+
+ copy->meta_inode = sqfs_copy(rd->meta_inode);
+ if (copy->meta_inode == NULL)
+ goto fail_mino;
+
+ copy->meta_dir = sqfs_copy(rd->meta_dir);
+ if (copy->meta_dir == NULL)
+ goto fail_mdir;
+
+ return (sqfs_object_t *)copy;
+fail_mdir:
+ sqfs_drop(copy->meta_inode);
+fail_mino:
+ if (copy->flags & SQFS_DIR_READER_DOT_ENTRIES)
+ rbtree_cleanup(&copy->dcache);
+fail_cache:
+ free(copy);
+ return NULL;
+}
+
+sqfs_dir_reader_t *sqfs_dir_reader_create(const sqfs_super_t *super,
+ sqfs_compressor_t *cmp,
+ sqfs_file_t *file,
+ sqfs_u32 flags)
+{
+ sqfs_dir_reader_t *rd;
+ sqfs_u64 start, limit;
+ int ret;
+
+ if (flags & ~SQFS_DIR_READER_ALL_FLAGS)
+ return NULL;
+
+ rd = calloc(1, sizeof(*rd));
+ if (rd == NULL)
+ return NULL;
+
+ sqfs_object_init(rd, dir_reader_destroy, dir_reader_copy);
+
+ if (flags & SQFS_DIR_READER_DOT_ENTRIES) {
+ ret = rbtree_init(&rd->dcache, sizeof(sqfs_u32),
+ sizeof(sqfs_u64), dcache_key_compare);
+
+ if (ret != 0)
+ goto fail_dcache;
+ }
+
+ start = super->inode_table_start;
+ limit = super->directory_table_start;
+
+ rd->meta_inode = sqfs_meta_reader_create(file, cmp, start, limit);
+ if (rd->meta_inode == NULL)
+ goto fail_mino;
+
+ start = super->directory_table_start;
+ limit = super->id_table_start;
+
+ if (super->fragment_table_start < limit)
+ limit = super->fragment_table_start;
+
+ if (super->export_table_start < limit)
+ limit = super->export_table_start;
+
+ rd->meta_dir = sqfs_meta_reader_create(file, cmp, start, limit);
+ if (rd->meta_dir == NULL)
+ goto fail_mdir;
+
+ rd->super = *super;
+ rd->flags = flags;
+ rd->state = DIR_STATE_NONE;
+ return rd;
+fail_mdir:
+ sqfs_drop(rd->meta_inode);
+fail_mino:
+ if (flags & SQFS_DIR_READER_DOT_ENTRIES)
+ rbtree_cleanup(&rd->dcache);
+fail_dcache:
+ free(rd);
+ return NULL;
+}
+
+int sqfs_dir_reader_open_dir(sqfs_dir_reader_t *rd,
+ const sqfs_inode_generic_t *inode,
+ sqfs_u32 flags)
+{
+ sqfs_u32 parent;
+ int ret;
+
+ if (flags & (~SQFS_DIR_OPEN_ALL_FLAGS))
+ return SQFS_ERROR_UNSUPPORTED;
+
+ ret = sqfs_readdir_state_init(&rd->it, &rd->super, inode);
+ if (ret)
+ return ret;
+
+ if ((rd->flags & SQFS_DIR_READER_DOT_ENTRIES) &&
+ !(flags & SQFS_DIR_OPEN_NO_DOT_ENTRIES)) {
+ if (inode->base.type == SQFS_INODE_EXT_DIR) {
+ parent = inode->data.dir_ext.parent_inode;
+ } else {
+ parent = inode->data.dir.parent_inode;
+ }
+
+ if (dcache_find(rd, inode->base.inode_number, &rd->cur_ref))
+ return SQFS_ERROR_NO_ENTRY;
+
+ if (rd->cur_ref == rd->super.root_inode_ref) {
+ rd->parent_ref = rd->cur_ref;
+ } else if (dcache_find(rd, parent, &rd->parent_ref)) {
+ return SQFS_ERROR_NO_ENTRY;
+ }
+
+ rd->state = DIR_STATE_OPENED;
+ } else {
+ rd->state = DIR_STATE_ENTRIES;
+ }
+
+ rd->start_state = rd->state;
+ return 0;
+}
+
+static int mk_dummy_entry(const char *str, sqfs_dir_entry_t **out)
+{
+ size_t len = strlen(str);
+ sqfs_dir_entry_t *ent;
+
+ ent = calloc(1, sizeof(sqfs_dir_entry_t) + len + 1);
+ if (ent == NULL)
+ return SQFS_ERROR_ALLOC;
+
+ ent->type = SQFS_INODE_DIR;
+ ent->size = len - 1;
+
+ strcpy((char *)ent->name, str);
+
+ *out = ent;
+ return 0;
+}
+
+int sqfs_dir_reader_read(sqfs_dir_reader_t *rd, sqfs_dir_entry_t **out)
+{
+ int err;
+
+ switch (rd->state) {
+ case DIR_STATE_OPENED:
+ err = mk_dummy_entry(".", out);
+ if (err == 0) {
+ rd->state = DIR_STATE_DOT;
+ rd->ent_ref = rd->cur_ref;
+ }
+ return err;
+ case DIR_STATE_DOT:
+ err = mk_dummy_entry("..", out);
+ if (err == 0) {
+ rd->state = DIR_STATE_ENTRIES;
+ rd->ent_ref = rd->parent_ref;
+ }
+ return err;
+ case DIR_STATE_ENTRIES:
+ break;
+ default:
+ return SQFS_ERROR_SEQUENCE;
+ }
+
+ return sqfs_meta_reader_readdir(rd->meta_dir, &rd->it,
+ out, NULL, &rd->ent_ref);
+}
+
+int sqfs_dir_reader_rewind(sqfs_dir_reader_t *rd)
+{
+ if (rd->state == DIR_STATE_NONE)
+ return SQFS_ERROR_SEQUENCE;
+
+ sqfs_readdir_state_reset(&rd->it);
+ rd->state = rd->start_state;
+ return 0;
+}
+
+int sqfs_dir_reader_find(sqfs_dir_reader_t *rd, const char *name)
+{
+ sqfs_dir_entry_t *ent;
+ int ret;
+
+ ret = sqfs_dir_reader_rewind(rd);
+ if (ret != 0)
+ return ret;
+
+ do {
+ ret = sqfs_dir_reader_read(rd, &ent);
+ if (ret < 0)
+ return ret;
+ if (ret > 0)
+ return SQFS_ERROR_NO_ENTRY;
+
+ ret = strcmp((const char *)ent->name, name);
+ free(ent);
+ } while (ret < 0);
+
+ return ret == 0 ? 0 : SQFS_ERROR_NO_ENTRY;
+}
+
+int sqfs_dir_reader_get_inode(sqfs_dir_reader_t *rd,
+ sqfs_inode_generic_t **inode)
+{
+ int ret;
+
+ ret = sqfs_meta_reader_read_inode(rd->meta_inode, &rd->super,
+ rd->ent_ref >> 16,
+ rd->ent_ref & 0x0FFFF, inode);
+ if (ret != 0)
+ return ret;
+
+ return dcache_add(rd, *inode, rd->ent_ref);
+}
+
+int sqfs_dir_reader_get_root_inode(sqfs_dir_reader_t *rd,
+ sqfs_inode_generic_t **inode)
+{
+ sqfs_u64 block_start = rd->super.root_inode_ref >> 16;
+ sqfs_u16 offset = rd->super.root_inode_ref & 0xFFFF;
+ int ret;
+
+ ret = sqfs_meta_reader_read_inode(rd->meta_inode, &rd->super,
+ block_start, offset, inode);
+ if (ret != 0)
+ return ret;
+
+ return dcache_add(rd, *inode, rd->super.root_inode_ref);
+}
+
+int sqfs_dir_reader_find_by_path(sqfs_dir_reader_t *rd,
+ const sqfs_inode_generic_t *start,
+ const char *path, sqfs_inode_generic_t **out)
+{
+ sqfs_inode_generic_t *inode;
+ const char *ptr;
+ int ret = 0;
+ char *name;
+
+ if (start == NULL) {
+ ret = sqfs_dir_reader_get_root_inode(rd, &inode);
+ } else {
+ ret = inode_copy(start, &inode);
+ }
+
+ if (ret)
+ return ret;
+
+ for (; *path != '\0'; path = ptr) {
+ if (*path == '/') {
+ for (ptr = path; *ptr == '/'; ++ptr)
+ ;
+ continue;
+ }
+
+ ret = sqfs_dir_reader_open_dir(rd, inode, 0);
+ free(inode);
+ if (ret)
+ return ret;
+
+ ptr = strchrnul(path, '/');
+
+ name = strndup(path, ptr - path);
+ if (name == NULL)
+ return SQFS_ERROR_ALLOC;
+
+ ret = sqfs_dir_reader_find(rd, name);
+ free(name);
+ if (ret)
+ return ret;
+
+ ret = sqfs_dir_reader_get_inode(rd, &inode);
+ if (ret)
+ return ret;
+ }
+
+ *out = inode;
+ return 0;
+}
diff --git a/lib/sqfs/src/dir_reader/get_path.c b/lib/sqfs/src/dir_reader/get_path.c
new file mode 100644
index 0000000..847bfd3
--- /dev/null
+++ b/lib/sqfs/src/dir_reader/get_path.c
@@ -0,0 +1,81 @@
+/* SPDX-License-Identifier: LGPL-3.0-or-later */
+/*
+ * get_path.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#define SQFS_BUILDING_DLL
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+int sqfs_tree_node_get_path(const sqfs_tree_node_t *node, char **out)
+{
+ const sqfs_tree_node_t *it;
+ size_t clen, len = 0;
+ char *str, *ptr;
+
+ *out = NULL;
+
+ if (node == NULL)
+ return SQFS_ERROR_ARG_INVALID;
+
+ for (it = node; it->parent != NULL; it = it->parent) {
+ if (it->parent == node)
+ return SQFS_ERROR_LINK_LOOP;
+
+ /* non-root nodes must have a valid name */
+ clen = strlen((const char *)it->name);
+
+ if (clen == 0)
+ return SQFS_ERROR_CORRUPTED;
+
+ if (strchr((const char *)it->name, '/') != NULL)
+ return SQFS_ERROR_CORRUPTED;
+
+ if (it->name[0] == '.') {
+ if (clen == 1 || (clen == 2 && it->name[1] == '.'))
+ return SQFS_ERROR_CORRUPTED;
+ }
+
+ /* compute total path length */
+ if (SZ_ADD_OV(clen, 1, &clen))
+ return SQFS_ERROR_OVERFLOW;
+
+ if (SZ_ADD_OV(len, clen, &len))
+ return SQFS_ERROR_OVERFLOW;
+ }
+
+ /* root node must not have a name */
+ if (it->name[0] != '\0')
+ return SQFS_ERROR_ARG_INVALID;
+
+ /* generate the path */
+ if (node->parent == NULL) {
+ str = strdup("/");
+ if (str == NULL)
+ return SQFS_ERROR_ALLOC;
+ } else {
+ if (SZ_ADD_OV(len, 1, &len))
+ return SQFS_ERROR_OVERFLOW;
+
+ str = malloc(len);
+ if (str == NULL)
+ return SQFS_ERROR_ALLOC;
+
+ ptr = str + len - 1;
+ *ptr = '\0';
+
+ for (it = node; it->parent != NULL; it = it->parent) {
+ len = strlen((const char *)it->name);
+ ptr -= len;
+
+ memcpy(ptr, (const char *)it->name, len);
+ *(--ptr) = '/';
+ }
+ }
+
+ *out = str;
+ return 0;
+}
diff --git a/lib/sqfs/src/dir_reader/internal.h b/lib/sqfs/src/dir_reader/internal.h
new file mode 100644
index 0000000..471d197
--- /dev/null
+++ b/lib/sqfs/src/dir_reader/internal.h
@@ -0,0 +1,52 @@
+/* SPDX-License-Identifier: LGPL-3.0-or-later */
+/*
+ * internal.h
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#ifndef DIR_READER_INTERNAL_H
+#define DIR_READER_INTERNAL_H
+
+#include "config.h"
+
+#include "sqfs/meta_reader.h"
+#include "sqfs/dir_reader.h"
+#include "sqfs/compressor.h"
+#include "sqfs/id_table.h"
+#include "sqfs/super.h"
+#include "sqfs/inode.h"
+#include "sqfs/error.h"
+#include "sqfs/dir.h"
+#include "util/rbtree.h"
+#include "util/util.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+enum {
+ DIR_STATE_NONE = 0,
+ DIR_STATE_OPENED = 1,
+ DIR_STATE_DOT = 2,
+ DIR_STATE_ENTRIES = 3,
+};
+
+struct sqfs_dir_reader_t {
+ sqfs_object_t base;
+
+ sqfs_meta_reader_t *meta_dir;
+ sqfs_meta_reader_t *meta_inode;
+ sqfs_super_t super;
+
+ sqfs_readdir_state_t it;
+
+ sqfs_u32 flags;
+
+ int start_state;
+ int state;
+ sqfs_u64 parent_ref;
+ sqfs_u64 cur_ref;
+ sqfs_u64 ent_ref;
+ rbtree_t dcache;
+};
+
+#endif /* DIR_READER_INTERNAL_H */
diff --git a/lib/sqfs/src/dir_reader/read_tree.c b/lib/sqfs/src/dir_reader/read_tree.c
new file mode 100644
index 0000000..91cc2c0
--- /dev/null
+++ b/lib/sqfs/src/dir_reader/read_tree.c
@@ -0,0 +1,288 @@
+/* SPDX-License-Identifier: LGPL-3.0-or-later */
+/*
+ * read_tree.c
+ *
+ * Copyright (C) 2019 David Oberhollenzer <goliath@infraroot.at>
+ */
+#define SQFS_BUILDING_DLL
+#include "internal.h"
+
+static int should_skip(int type, unsigned int flags)
+{
+ switch (type) {
+ case SQFS_INODE_BDEV:
+ case SQFS_INODE_CDEV:
+ case SQFS_INODE_EXT_CDEV:
+ case SQFS_INODE_EXT_BDEV:
+ return (flags & SQFS_TREE_NO_DEVICES);
+ case SQFS_INODE_SLINK:
+ case SQFS_INODE_EXT_SLINK:
+ return (flags & SQFS_TREE_NO_SLINKS);
+ case SQFS_INODE_SOCKET:
+ case SQFS_INODE_EXT_SOCKET:
+ return(flags & SQFS_TREE_NO_SOCKETS);
+ case SQFS_INODE_FIFO:
+ case SQFS_INODE_EXT_FIFO:
+ return (flags & SQFS_TREE_NO_FIFO);
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static bool would_be_own_parent(sqfs_tree_node_t *parent, sqfs_tree_node_t *n)
+{
+ sqfs_u32 inum = n->inode->base.inode_number;
+
+ while (parent != NULL) {
+ if (parent->inode->base.inode_number == inum)
+ return true;
+
+ parent = parent->parent;
+ }
+
+ return false;
+}
+
+static sqfs_tree_node_t *create_node(sqfs_inode_generic_t *inode,
+ const char *name)
+{
+ sqfs_tree_node_t *n;
+
+ n = alloc_flex(sizeof(*n), 1, strlen(name) + 1);
+ if (n == NULL)
+ return NULL;
+
+ n->inode = inode;
+ strcpy((char *)n->name, name);
+ return n;
+}
+
+static int fill_dir(sqfs_dir_reader_t *dr, sqfs_tree_node_t *root,
+ unsigned int flags)
+{
+ sqfs_tree_node_t *n, *prev, **tail;
+ sqfs_inode_generic_t *inode;
+ sqfs_dir_entry_t *ent;
+ int err;
+
+ tail = &root->children;
+
+ for (;;) {
+ err = sqfs_dir_reader_read(dr, &ent);
+ if (err > 0)
+ break;
+ if (err < 0)
+ return err;
+
+ if (should_skip(ent->type, flags)) {
+ free(ent);
+ continue;
+ }
+
+ err = sqfs_dir_reader_get_inode(dr, &inode);
+ if (err) {
+ free(ent);
+ return err;
+ }
+
+ n = create_node(inode, (const char *)ent->name);
+ free(ent);
+
+ if (n == NULL) {
+ free(inode);
+ return SQFS_ERROR_ALLOC;
+ }
+
+ if (would_be_own_parent(root, n)) {
+ free(n);
+ free(inode);
+ return SQFS_ERROR_LINK_LOOP;
+ }
+
+ *tail = n;
+ tail = &n->next;
+ n->parent = root;
+ }
+
+ n = root->children;
+ prev = NULL;
+
+ while (n != NULL) {
+ if (n->inode->base.type == SQFS_INODE_DIR ||
+ n->inode->base.type == SQFS_INODE_EXT_DIR) {
+ if (!(flags & SQFS_TREE_NO_RECURSE)) {
+ err = sqfs_dir_reader_open_dir(dr, n->inode,
+ SQFS_DIR_OPEN_NO_DOT_ENTRIES);
+ if (err)
+ return err;
+
+ err = fill_dir(dr, n, flags);
+ if (err)
+ return err;
+ }
+
+ if (n->children == NULL &&
+ (flags & SQFS_TREE_NO_EMPTY)) {
+ free(n->inode);
+ if (prev == NULL) {
+ root->children = root->children->next;
+ free(n);
+ n = root->children;
+ } else {
+ prev->next = n->next;
+ free(n);
+ n = prev->next;
+ }
+ continue;
+ }
+ }
+
+ prev = n;
+ n = n->next;
+ }
+
+ return 0;
+}
+
+static int resolve_ids(sqfs_tree_node_t *root, const sqfs_id_table_t *idtbl)
+{
+ sqfs_tree_node_t *it;
+ int err;
+
+ for (it = root->children; it != NULL; it = it->next)
+ resolve_ids(it, idtbl);
+
+ err = sqfs_id_table_index_to_id(idtbl, root->inode->base.uid_idx,
+ &root->uid);
+ if (err)
+ return err;
+
+ return sqfs_id_table_index_to_id(idtbl, root->inode->base.gid_idx,
+ &root->gid);
+}
+
+void sqfs_dir_tree_destroy(sqfs_tree_node_t *root)
+{
+ sqfs_tree_node_t *it;
+
+ if (!root)
+ return;
+
+ while (root->children != NULL) {
+ it = root->children;
+ root->children = it->next;
+
+ sqfs_dir_tree_destroy(it);
+ }
+
+ free(root->inode);
+ free(root);
+}
+
+int sqfs_dir_reader_get_full_hierarchy(sqfs_dir_reader_t *rd,
+ const sqfs_id_table_t *idtbl,
+ const char *path, unsigned int flags,
+ sqfs_tree_node_t **out)
+{
+ sqfs_tree_node_t *root, *tail, *new;
+ sqfs_inode_generic_t *inode;
+ sqfs_dir_entry_t *ent;
+ const char *ptr;
+ int ret;
+
+ if (flags & ~SQFS_TREE_ALL_FLAGS)
+ return SQFS_ERROR_UNSUPPORTED;
+
+ ret = sqfs_dir_reader_get_root_inode(rd, &inode);
+ if (ret)
+ return ret;
+
+ root = tail = create_node(inode, "");
+ if (root == NULL) {
+ free(inode);
+ return SQFS_ERROR_ALLOC;
+ }
+ inode = NULL;
+
+ while (path != NULL && *path != '\0') {
+ if (*path == '/') {
+ while (*path == '/')
+ ++path;
+ continue;
+ }
+
+ ret = sqfs_dir_reader_open_dir(rd, tail->inode,
+ SQFS_DIR_OPEN_NO_DOT_ENTRIES);
+ if (ret)
+ goto fail;
+
+ ptr = strchrnul(path, '/');
+
+ for (;;) {
+ ret = sqfs_dir_reader_read(rd, &ent);
+ if (ret < 0)
+ goto fail;
+ if (ret > 0) {
+ ret = SQFS_ERROR_NO_ENTRY;
+ goto fail;
+ }
+
+ ret = strncmp((const char *)ent->name,
+ path, ptr - path);
+ if (ret == 0 && ent->name[ptr - path] == '\0')
+ break;
+ free(ent);
+ }
+
+ ret = sqfs_dir_reader_get_inode(rd, &inode);
+ if (ret) {
+ free(ent);
+ goto fail;
+ }
+
+ new = create_node(inode, (const char *)ent->name);
+ free(ent);
+
+ if (new == NULL) {
+ free(inode);
+ ret = SQFS_ERROR_ALLOC;
+ goto fail;
+ }
+
+ inode = NULL;
+ path = ptr;
+
+ if (flags & SQFS_TREE_STORE_PARENTS) {
+ tail->children = new;
+ new->parent = tail;
+ tail = new;
+ } else {
+ sqfs_dir_tree_destroy(root);
+ root = tail = new;
+ }
+ }
+
+ if (tail->inode->base.type == SQFS_INODE_DIR ||
+ tail->inode->base.type == SQFS_INODE_EXT_DIR) {
+ ret = sqfs_dir_reader_open_dir(rd, tail->inode,
+ SQFS_DIR_OPEN_NO_DOT_ENTRIES);
+ if (ret)
+ goto fail;
+
+ ret = fill_dir(rd, tail, flags);
+ if (ret)
+ goto fail;
+ }
+
+ ret = resolve_ids(root, idtbl);
+ if (ret)
+ goto fail;
+
+ *out = root;
+ return 0;
+fail:
+ sqfs_dir_tree_destroy(root);
+ return ret;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-30 12:34:29 +0000