summaryrefslogtreecommitdiffstats
path: root/grub-core/fs/fshelp.c
diff options
context:
space:
mode:
Diffstat (limited to 'grub-core/fs/fshelp.c')
-rw-r--r--grub-core/fs/fshelp.c441
1 files changed, 441 insertions, 0 deletions
diff --git a/grub-core/fs/fshelp.c b/grub-core/fs/fshelp.c
new file mode 100644
index 0000000..a2d0d29
--- /dev/null
+++ b/grub-core/fs/fshelp.c
@@ -0,0 +1,441 @@
+/* fshelp.c -- Filesystem helper functions */
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2004,2005,2006,2007,2008 Free Software Foundation, Inc.
+ *
+ * GRUB is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GRUB is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/err.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/disk.h>
+#include <grub/fshelp.h>
+#include <grub/dl.h>
+#include <grub/i18n.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+typedef int (*iterate_dir_func) (grub_fshelp_node_t dir,
+ grub_fshelp_iterate_dir_hook_t hook,
+ void *data);
+typedef grub_err_t (*lookup_file_func) (grub_fshelp_node_t dir,
+ const char *name,
+ grub_fshelp_node_t *foundnode,
+ enum grub_fshelp_filetype *foundtype);
+typedef char *(*read_symlink_func) (grub_fshelp_node_t node);
+
+struct stack_element {
+ struct stack_element *parent;
+ grub_fshelp_node_t node;
+ enum grub_fshelp_filetype type;
+};
+
+/* Context for grub_fshelp_find_file. */
+struct grub_fshelp_find_file_ctx
+{
+ /* Inputs. */
+ const char *path;
+ grub_fshelp_node_t rootnode;
+
+ /* Global options. */
+ int symlinknest;
+
+ /* Current file being traversed and its parents. */
+ struct stack_element *currnode;
+};
+
+/* Helper for find_file_iter. */
+static void
+free_node (grub_fshelp_node_t node, struct grub_fshelp_find_file_ctx *ctx)
+{
+ if (node != ctx->rootnode)
+ grub_free (node);
+}
+
+static void
+pop_element (struct grub_fshelp_find_file_ctx *ctx)
+{
+ struct stack_element *el;
+ el = ctx->currnode;
+ ctx->currnode = el->parent;
+ free_node (el->node, ctx);
+ grub_free (el);
+}
+
+static void
+free_stack (struct grub_fshelp_find_file_ctx *ctx)
+{
+ while (ctx->currnode)
+ pop_element (ctx);
+}
+
+static void
+go_up_a_level (struct grub_fshelp_find_file_ctx *ctx)
+{
+ if (!ctx->currnode->parent)
+ return;
+ pop_element (ctx);
+}
+
+static grub_err_t
+push_node (struct grub_fshelp_find_file_ctx *ctx, grub_fshelp_node_t node, enum grub_fshelp_filetype filetype)
+{
+ struct stack_element *nst;
+ nst = grub_malloc (sizeof (*nst));
+ if (!nst)
+ return grub_errno;
+ nst->node = node;
+ nst->type = filetype & ~GRUB_FSHELP_CASE_INSENSITIVE;
+ nst->parent = ctx->currnode;
+ ctx->currnode = nst;
+ return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+go_to_root (struct grub_fshelp_find_file_ctx *ctx)
+{
+ free_stack (ctx);
+ return push_node (ctx, ctx->rootnode, GRUB_FSHELP_DIR);
+}
+
+struct grub_fshelp_find_file_iter_ctx
+{
+ const char *name;
+ grub_fshelp_node_t *foundnode;
+ enum grub_fshelp_filetype *foundtype;
+};
+
+/* Helper for grub_fshelp_find_file. */
+static int
+find_file_iter (const char *filename, enum grub_fshelp_filetype filetype,
+ grub_fshelp_node_t node, void *data)
+{
+ struct grub_fshelp_find_file_iter_ctx *ctx = data;
+
+ if (filetype == GRUB_FSHELP_UNKNOWN ||
+ ((filetype & GRUB_FSHELP_CASE_INSENSITIVE)
+ ? grub_strcasecmp (ctx->name, filename)
+ : grub_strcmp (ctx->name, filename)))
+ {
+ grub_free (node);
+ return 0;
+ }
+
+ /* The node is found, stop iterating over the nodes. */
+ *ctx->foundnode = node;
+ *ctx->foundtype = filetype;
+ return 1;
+}
+
+static grub_err_t
+directory_find_file (grub_fshelp_node_t node, const char *name, grub_fshelp_node_t *foundnode,
+ enum grub_fshelp_filetype *foundtype, iterate_dir_func iterate_dir)
+{
+ int found;
+ struct grub_fshelp_find_file_iter_ctx ctx = {
+ .foundnode = foundnode,
+ .foundtype = foundtype,
+ .name = name
+ };
+ found = iterate_dir (node, find_file_iter, &ctx);
+ if (! found)
+ {
+ if (grub_errno)
+ return grub_errno;
+ }
+ return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+find_file (char *currpath,
+ iterate_dir_func iterate_dir, lookup_file_func lookup_file,
+ read_symlink_func read_symlink,
+ struct grub_fshelp_find_file_ctx *ctx)
+{
+ char *name, *next;
+ grub_err_t err;
+ for (name = currpath; ; name = next)
+ {
+ char c;
+ grub_fshelp_node_t foundnode = NULL;
+ enum grub_fshelp_filetype foundtype = 0;
+
+ /* Remove all leading slashes. */
+ while (*name == '/')
+ name++;
+
+ /* Found the node! */
+ if (! *name)
+ return 0;
+
+ /* Extract the actual part from the pathname. */
+ for (next = name; *next && *next != '/'; next++);
+
+ /* At this point it is expected that the current node is a
+ directory, check if this is true. */
+ if (ctx->currnode->type != GRUB_FSHELP_DIR)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
+
+ /* Don't rely on fs providing actual . in the listing. */
+ if (next - name == 1 && name[0] == '.')
+ continue;
+
+ /* Don't rely on fs providing actual .. in the listing. */
+ if (next - name == 2 && name[0] == '.' && name[1] == '.')
+ {
+ go_up_a_level (ctx);
+ continue;
+ }
+
+ /* Iterate over the directory. */
+ c = *next;
+ *next = '\0';
+ if (lookup_file)
+ err = lookup_file (ctx->currnode->node, name, &foundnode, &foundtype);
+ else
+ err = directory_find_file (ctx->currnode->node, name, &foundnode, &foundtype, iterate_dir);
+ *next = c;
+
+ if (err)
+ return err;
+
+ if (!foundnode)
+ break;
+
+ push_node (ctx, foundnode, foundtype);
+
+ /* Read in the symlink and follow it. */
+ if (ctx->currnode->type == GRUB_FSHELP_SYMLINK)
+ {
+ char *symlink;
+
+ /* Test if the symlink does not loop. */
+ if (++ctx->symlinknest == 8)
+ return grub_error (GRUB_ERR_SYMLINK_LOOP,
+ N_("too deep nesting of symlinks"));
+
+ symlink = read_symlink (ctx->currnode->node);
+
+ if (!symlink)
+ return grub_errno;
+
+ /* The symlink is an absolute path, go back to the root inode. */
+ if (symlink[0] == '/')
+ {
+ err = go_to_root (ctx);
+ if (err)
+ return err;
+ }
+ else
+ {
+ /* Get from symlink to containing directory. */
+ go_up_a_level (ctx);
+ }
+
+
+ /* Lookup the node the symlink points to. */
+ find_file (symlink, iterate_dir, lookup_file, read_symlink, ctx);
+ grub_free (symlink);
+
+ if (grub_errno)
+ return grub_errno;
+ }
+ }
+
+ return grub_error (GRUB_ERR_FILE_NOT_FOUND, N_("file `%s' not found"),
+ ctx->path);
+}
+
+static grub_err_t
+grub_fshelp_find_file_real (const char *path, grub_fshelp_node_t rootnode,
+ grub_fshelp_node_t *foundnode,
+ iterate_dir_func iterate_dir,
+ lookup_file_func lookup_file,
+ read_symlink_func read_symlink,
+ enum grub_fshelp_filetype expecttype)
+{
+ struct grub_fshelp_find_file_ctx ctx = {
+ .path = path,
+ .rootnode = rootnode,
+ .symlinknest = 0,
+ .currnode = 0
+ };
+ grub_err_t err;
+ enum grub_fshelp_filetype foundtype;
+ char *duppath;
+
+ if (!path || path[0] != '/')
+ {
+ return grub_error (GRUB_ERR_BAD_FILENAME, N_("invalid file name `%s'"), path);
+ }
+
+ err = go_to_root (&ctx);
+ if (err)
+ return err;
+
+ duppath = grub_strdup (path);
+ if (!duppath)
+ return grub_errno;
+ err = find_file (duppath, iterate_dir, lookup_file, read_symlink, &ctx);
+ grub_free (duppath);
+ if (err)
+ {
+ free_stack (&ctx);
+ return err;
+ }
+
+ *foundnode = ctx.currnode->node;
+ foundtype = ctx.currnode->type;
+ /* Avoid the node being freed. */
+ ctx.currnode->node = 0;
+ free_stack (&ctx);
+
+ /* Check if the node that was found was of the expected type. */
+ if (expecttype == GRUB_FSHELP_REG && foundtype != expecttype)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a regular file"));
+ else if (expecttype == GRUB_FSHELP_DIR && foundtype != expecttype)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, N_("not a directory"));
+
+ return 0;
+}
+
+/* Lookup the node PATH. The node ROOTNODE describes the root of the
+ directory tree. The node found is returned in FOUNDNODE, which is
+ either a ROOTNODE or a new malloc'ed node. ITERATE_DIR is used to
+ iterate over all directory entries in the current node.
+ READ_SYMLINK is used to read the symlink if a node is a symlink.
+ EXPECTTYPE is the type node that is expected by the called, an
+ error is generated if the node is not of the expected type. */
+grub_err_t
+grub_fshelp_find_file (const char *path, grub_fshelp_node_t rootnode,
+ grub_fshelp_node_t *foundnode,
+ iterate_dir_func iterate_dir,
+ read_symlink_func read_symlink,
+ enum grub_fshelp_filetype expecttype)
+{
+ return grub_fshelp_find_file_real (path, rootnode, foundnode,
+ iterate_dir, NULL,
+ read_symlink, expecttype);
+
+}
+
+grub_err_t
+grub_fshelp_find_file_lookup (const char *path, grub_fshelp_node_t rootnode,
+ grub_fshelp_node_t *foundnode,
+ lookup_file_func lookup_file,
+ read_symlink_func read_symlink,
+ enum grub_fshelp_filetype expecttype)
+{
+ return grub_fshelp_find_file_real (path, rootnode, foundnode,
+ NULL, lookup_file,
+ read_symlink, expecttype);
+
+}
+
+/* Read LEN bytes from the file NODE on disk DISK into the buffer BUF,
+ beginning with the block POS. READ_HOOK should be set before
+ reading a block from the file. READ_HOOK_DATA is passed through as
+ the DATA argument to READ_HOOK. GET_BLOCK is used to translate
+ file blocks to disk blocks. The file is FILESIZE bytes big and the
+ blocks have a size of LOG2BLOCKSIZE (in log2). */
+grub_ssize_t
+grub_fshelp_read_file (grub_disk_t disk, grub_fshelp_node_t node,
+ grub_disk_read_hook_t read_hook, void *read_hook_data,
+ grub_off_t pos, grub_size_t len, char *buf,
+ grub_disk_addr_t (*get_block) (grub_fshelp_node_t node,
+ grub_disk_addr_t block),
+ grub_off_t filesize, int log2blocksize,
+ grub_disk_addr_t blocks_start)
+{
+ grub_disk_addr_t i, blockcnt;
+ int blocksize = 1 << (log2blocksize + GRUB_DISK_SECTOR_BITS);
+
+ /*
+ * Catch blatantly invalid log2blocksize. We could be a lot stricter, but
+ * this is the most permissive we can be before we start to see integer
+ * overflow/underflow issues.
+ */
+ if (log2blocksize + GRUB_DISK_SECTOR_BITS >= 31)
+ {
+ grub_error (GRUB_ERR_OUT_OF_RANGE,
+ N_("blocksize too large"));
+ return -1;
+ }
+
+ if (pos > filesize)
+ {
+ grub_error (GRUB_ERR_OUT_OF_RANGE,
+ N_("attempt to read past the end of file"));
+ return -1;
+ }
+
+ /* Adjust LEN so it we can't read past the end of the file. */
+ if (pos + len > filesize)
+ len = filesize - pos;
+
+ blockcnt = ((len + pos) + blocksize - 1) >> (log2blocksize + GRUB_DISK_SECTOR_BITS);
+
+ for (i = pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS); i < blockcnt; i++)
+ {
+ grub_disk_addr_t blknr;
+ int blockoff = pos & (blocksize - 1);
+ int blockend = blocksize;
+
+ int skipfirst = 0;
+
+ blknr = get_block (node, i);
+ if (grub_errno)
+ return -1;
+
+ blknr = blknr << log2blocksize;
+
+ /* Last block. */
+ if (i == blockcnt - 1)
+ {
+ blockend = (len + pos) & (blocksize - 1);
+
+ /* The last portion is exactly blocksize. */
+ if (! blockend)
+ blockend = blocksize;
+ }
+
+ /* First block. */
+ if (i == (pos >> (log2blocksize + GRUB_DISK_SECTOR_BITS)))
+ {
+ skipfirst = blockoff;
+ blockend -= skipfirst;
+ }
+
+ /* If the block number is 0 this block is not stored on disk but
+ is zero filled instead. */
+ if (blknr)
+ {
+ disk->read_hook = read_hook;
+ disk->read_hook_data = read_hook_data;
+
+ grub_disk_read (disk, blknr + blocks_start, skipfirst,
+ blockend, buf);
+ disk->read_hook = 0;
+ if (grub_errno)
+ return -1;
+ }
+ else
+ grub_memset (buf, 0, blockend);
+
+ buf += blocksize - skipfirst;
+ }
+
+ return len;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-05 01:40:52 +0000