--- /dev/null
+/*
+ * (C) Copyright 2004
+ * esd gmbh <www.esd-electronics.com>
+ * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
+ *
+ * based on code of fs/reiserfs/dev.c by
+ *
+ * (C) Copyright 2003 - 2004
+ * Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com>
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <common.h>
+#if (CONFIG_COMMANDS & CFG_CMD_EXT2)
+
+#include <config.h>
+#include <ext2fs.h>
+
+static block_dev_desc_t *ext2fs_block_dev_desc;
+static disk_partition_t part_info;
+
+#undef DEBUG
+int ext2fs_set_blk_dev
+ (
+ block_dev_desc_t *rbdd,
+ int part
+ )
+ {
+ ext2fs_block_dev_desc = rbdd;
+
+ if (part == 0)
+ {
+ /* disk doesn't use partition table */
+ part_info.start = 0;
+ part_info.size = rbdd->lba;
+ part_info.blksz = rbdd->blksz;
+ }
+ else
+ {
+ if (get_partition_info (ext2fs_block_dev_desc, part, &part_info))
+ {
+ return 0;
+ }
+ }
+ return (part_info.size);
+ }
+
+
+int ext2fs_devread
+ (
+ int sector,
+ int byte_offset,
+ int byte_len,
+ char *buf
+ )
+ {
+ char sec_buf[SECTOR_SIZE];
+ unsigned block_len;
+/*
+ * Check partition boundaries
+ */
+ if ((sector < 0) || ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS)) >= part_info.size))
+ {
+/* errnum = ERR_OUTSIDE_PART; */
+ printf (" ** ext2fs_devread() read outside partition sector %d\n", sector);
+ return(0);
+ }
+
+/*
+ * Get the read to the beginning of a partition.
+ */
+ sector += byte_offset >> SECTOR_BITS;
+ byte_offset &= SECTOR_SIZE - 1;
+
+#if defined(DEBUG)
+ printf (" <%d, %d, %d>\n", sector, byte_offset, byte_len);
+#endif
+
+ if (ext2fs_block_dev_desc == NULL)
+ {
+ printf("** Invalid Block Device Descriptor (NULL)\n");
+ return(0);
+ }
+
+ if (byte_offset != 0)
+ {
+/* read first part which isn't aligned with start of sector */
+ if (ext2fs_block_dev_desc->block_read(ext2fs_block_dev_desc->dev, part_info.start+sector, 1, (unsigned long *)sec_buf) != 1)
+ {
+ printf (" ** ext2fs_devread() read error **\n");
+ return(0);
+ }
+ memcpy(buf, sec_buf+byte_offset, min(SECTOR_SIZE-byte_offset, byte_len));
+ buf+=min(SECTOR_SIZE-byte_offset, byte_len);
+ byte_len-=min(SECTOR_SIZE-byte_offset, byte_len);
+ sector++;
+ }
+
+/* read sector aligned part */
+ block_len = byte_len & ~(SECTOR_SIZE-1);
+ if (ext2fs_block_dev_desc->block_read(ext2fs_block_dev_desc->dev,
+ part_info.start+sector,
+ block_len/SECTOR_SIZE,
+ (unsigned long *)buf) != block_len/SECTOR_SIZE)
+ {
+ printf (" ** ext2fs_devread() read error - block\n");
+ return(0);
+ }
+ buf+=block_len;
+ byte_len-=block_len;
+ sector+= block_len/SECTOR_SIZE;
+
+ if (byte_len != 0)
+ {
+/* read rest of data which are not in whole sector */
+ if (ext2fs_block_dev_desc->block_read(ext2fs_block_dev_desc->dev,
+ part_info.start+sector,
+ 1,
+ (unsigned long *)sec_buf) != 1)
+ {
+ printf (" ** ext2fs_devread() read error - last part\n");
+ return(0);
+ }
+ memcpy(buf, sec_buf, byte_len);
+ }
+ return(1);
+ }
+#endif /* CFG_CMD_EXT2FS */
--- /dev/null
+/*
+ * (C) Copyright 2004
+ * esd gmbh <www.esd-electronics.com>
+ * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
+ *
+ * based on code from grub2 fs/ext2.c and fs/fshelp.c by
+ *
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <common.h>
+
+#if (CONFIG_COMMANDS & CFG_CMD_EXT2)
+#include <ext2fs.h>
+#include <malloc.h>
+#include <asm/byteorder.h>
+
+extern int ext2fs_devread (int sector, int byte_offset, int byte_len, char *buf);
+
+/* Magic value used to identify an ext2 filesystem. */
+#define EXT2_MAGIC 0xEF53
+/* Amount of indirect blocks in an inode. */
+#define INDIRECT_BLOCKS 12
+/* Maximum lenght of a pathname. */
+#define EXT2_PATH_MAX 4096
+/* Maximum nesting of symlinks, used to prevent a loop. */
+#define EXT2_MAX_SYMLINKCNT 8
+
+/* Filetype used in directory entry. */
+#define FILETYPE_UNKNOWN 0
+#define FILETYPE_REG 1
+#define FILETYPE_DIRECTORY 2
+#define FILETYPE_SYMLINK 7
+
+/* Filetype information as used in inodes. */
+#define FILETYPE_INO_MASK 0170000
+#define FILETYPE_INO_REG 0100000
+#define FILETYPE_INO_DIRECTORY 0040000
+#define FILETYPE_INO_SYMLINK 0120000
+
+/* Bits used as offset in sector */
+#define DISK_SECTOR_BITS 9
+
+/* Log2 size of ext2 block in 512 blocks. */
+#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1)
+
+/* Log2 size of ext2 block in bytes. */
+#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 10)
+
+/* The size of an ext2 block in bytes. */
+#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data))
+
+/* The ext2 superblock. */
+struct ext2_sblock
+{
+ uint32_t total_inodes;
+ uint32_t total_blocks;
+ uint32_t reserved_blocks;
+ uint32_t free_blocks;
+ uint32_t free_inodes;
+ uint32_t first_data_block;
+ uint32_t log2_block_size;
+ uint32_t log2_fragment_size;
+ uint32_t blocks_per_group;
+ uint32_t fragments_per_group;
+ uint32_t inodes_per_group;
+ uint32_t mtime;
+ uint32_t utime;
+ uint16_t mnt_count;
+ uint16_t max_mnt_count;
+ uint16_t magic;
+ uint16_t fs_state;
+ uint16_t error_handling;
+ uint16_t minor_revision_level;
+ uint32_t lastcheck;
+ uint32_t checkinterval;
+ uint32_t creator_os;
+ uint32_t revision_level;
+ uint16_t uid_reserved;
+ uint16_t gid_reserved;
+ uint32_t first_inode;
+ uint16_t inode_size;
+ uint16_t block_group_number;
+ uint32_t feature_compatibility;
+ uint32_t feature_incompat;
+ uint32_t feature_ro_compat;
+ uint32_t unique_id[4];
+ char volume_name[16];
+ char last_mounted_on[64];
+ uint32_t compression_info;
+};
+
+/* The ext2 blockgroup. */
+struct ext2_block_group
+{
+ uint32_t block_id;
+ uint32_t inode_id;
+ uint32_t inode_table_id;
+ uint16_t free_blocks;
+ uint16_t free_inodes;
+ uint16_t pad;
+ uint32_t reserved[3];
+};
+
+/* The ext2 inode. */
+struct ext2_inode
+{
+ uint16_t mode;
+ uint16_t uid;
+ uint32_t size;
+ uint32_t atime;
+ uint32_t ctime;
+ uint32_t mtime;
+ uint32_t dtime;
+ uint16_t gid;
+ uint16_t nlinks;
+ uint32_t blockcnt; /* Blocks of 512 bytes!! */
+ uint32_t flags;
+ uint32_t osd1;
+ union
+ {
+ struct datablocks
+ {
+ uint32_t dir_blocks[INDIRECT_BLOCKS];
+ uint32_t indir_block;
+ uint32_t double_indir_block;
+ uint32_t tripple_indir_block;
+ } blocks;
+ char symlink[60];
+ } b;
+ uint32_t version;
+ uint32_t acl;
+ uint32_t dir_acl;
+ uint32_t fragment_addr;
+ uint32_t osd2[3];
+};
+
+/* The header of an ext2 directory entry. */
+struct ext2_dirent
+{
+ uint32_t inode;
+ uint16_t direntlen;
+ uint8_t namelen;
+ uint8_t filetype;
+};
+
+struct ext2fs_node
+{
+ struct ext2_data *data;
+ struct ext2_inode inode;
+ int ino;
+ int inode_read;
+};
+
+/* Information about a "mounted" ext2 filesystem. */
+struct ext2_data
+{
+ struct ext2_sblock sblock;
+ struct ext2_inode *inode;
+ struct ext2fs_node diropen;
+};
+
+
+typedef struct ext2fs_node *ext2fs_node_t;
+
+struct ext2_data *ext2fs_root = NULL;
+ext2fs_node_t ext2fs_file = NULL;
+int symlinknest = 0;
+uint32_t *indir1_block = NULL;
+int indir1_size = 0;
+int indir1_blkno = -1;
+uint32_t *indir2_block = NULL;
+int indir2_size = 0;
+int indir2_blkno = -1;
+
+
+static int ext2fs_blockgroup
+(
+ struct ext2_data *data,
+ int group,
+ struct ext2_block_group *blkgrp
+ )
+{
+#ifdef DEBUG
+ printf("ext2fs read blockgroup\n");
+#endif
+ return(ext2fs_devread (((__le32_to_cpu (data->sblock.first_data_block) + 1) << LOG2_EXT2_BLOCK_SIZE (data)),
+ group * sizeof (struct ext2_block_group),
+ sizeof (struct ext2_block_group),
+ (char *) blkgrp));
+}
+
+
+static int ext2fs_read_inode
+(
+ struct ext2_data *data,
+ int ino,
+ struct ext2_inode *inode
+ )
+{
+ struct ext2_block_group blkgrp;
+ struct ext2_sblock *sblock = &data->sblock;
+ int inodes_per_block;
+ int status;
+
+ unsigned int blkno;
+ unsigned int blkoff;
+
+ /* It is easier to calculate if the first inode is 0. */
+ ino--;
+#ifdef DEBUG
+ printf("ext2fs read inode %d\n", ino);
+#endif
+ status = ext2fs_blockgroup (data, ino / __le32_to_cpu(sblock->inodes_per_group), &blkgrp);
+ if (status == 0)
+ {
+ return(0);
+ }
+ inodes_per_block = EXT2_BLOCK_SIZE (data) / 128;
+ blkno = (ino % __le32_to_cpu (sblock->inodes_per_group)) / inodes_per_block;
+ blkoff = (ino % __le32_to_cpu (sblock->inodes_per_group)) % inodes_per_block;
+#ifdef DEBUG
+ printf("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);
+#endif
+ /* Read the inode. */
+ status = ext2fs_devread(((__le32_to_cpu (blkgrp.inode_table_id) + blkno) << LOG2_EXT2_BLOCK_SIZE (data)),
+ sizeof (struct ext2_inode) * blkoff,
+ sizeof (struct ext2_inode),
+ (char *) inode);
+ if (status == 0)
+ {
+ return(0);
+ }
+ return(1);
+}
+
+
+void ext2fs_free_node
+(
+ ext2fs_node_t node,
+ ext2fs_node_t currroot
+ )
+{
+ if ((node != &ext2fs_root->diropen) && (node != currroot))
+ {
+ free (node);
+ }
+}
+
+
+static int ext2fs_read_block
+(
+ ext2fs_node_t node,
+ int fileblock
+ )
+{
+ struct ext2_data *data = node->data;
+ struct ext2_inode *inode = &node->inode;
+ int blknr;
+ int blksz = EXT2_BLOCK_SIZE (data);
+ int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
+ int status;
+
+ /* Direct blocks. */
+ if (fileblock < INDIRECT_BLOCKS)
+ {
+ blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
+ }
+ /* Indirect. */
+ else if (fileblock < (INDIRECT_BLOCKS + (blksz/4)))
+ {
+ if (indir1_block == NULL)
+ {
+ indir1_block = (uint32_t *) malloc(blksz);
+ if (indir1_block == NULL)
+ {
+ printf("** ext2fs read block (indir 1) malloc failed. **\n");
+ return(-1);
+ }
+ indir1_size = blksz;
+ indir1_blkno = -1;
+ }
+ if (blksz != indir1_size)
+ {
+ free(indir1_block);
+ indir1_block = NULL;
+ indir1_size = 0;
+ indir1_blkno = -1;
+ indir1_block = (uint32_t *) malloc(blksz);
+ if (indir1_block == NULL)
+ {
+ printf("** ext2fs read block (indir 1) malloc failed. **\n");
+ return(-1);
+ }
+ indir1_size = blksz;
+ }
+ if ((__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz) != indir1_blkno)
+ {
+ status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz, 0, blksz, (char *) indir1_block);
+ if (status == 0)
+ {
+ printf("** ext2fs read block (indir 1) failed. **\n");
+ return(0);
+ }
+ indir1_blkno = __le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz;
+ }
+ blknr = __le32_to_cpu(indir1_block[fileblock - INDIRECT_BLOCKS]);
+ }
+ /* Double indirect. */
+ else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1))))
+ {
+ unsigned int perblock = blksz / 4;
+ unsigned int rblock = fileblock - (INDIRECT_BLOCKS
+ + blksz / 4);
+
+ if (indir1_block == NULL)
+ {
+ indir1_block = (uint32_t *) malloc(blksz);
+ if (indir1_block == NULL)
+ {
+ printf("** ext2fs read block (indir 2 1) malloc failed. **\n");
+ return(-1);
+ }
+ indir1_size = blksz;
+ indir1_blkno = -1;
+ }
+ if (blksz != indir1_size)
+ {
+ free(indir1_block);
+ indir1_block = NULL;
+ indir1_size = 0;
+ indir1_blkno = -1;
+ indir1_block = (uint32_t *) malloc(blksz);
+ if (indir1_block == NULL)
+ {
+ printf("** ext2fs read block (indir 2 1) malloc failed. **\n");
+ return(-1);
+ }
+ indir1_size = blksz;
+ }
+ if ((__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz) != indir1_blkno)
+ {
+ status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz, 0, blksz, (char *) indir1_block);
+ if (status == 0)
+ {
+ printf("** ext2fs read block (indir 2 1) failed. **\n");
+ return(-1);
+ }
+ indir1_blkno = __le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz;
+ }
+
+ if (indir2_block == NULL)
+ {
+ indir2_block = (uint32_t *) malloc(blksz);
+ if (indir2_block == NULL)
+ {
+ printf("** ext2fs read block (indir 2 2) malloc failed. **\n");
+ return(-1);
+ }
+ indir2_size = blksz;
+ indir2_blkno = -1;
+ }
+ if (blksz != indir2_size)
+ {
+ free(indir2_block);
+ indir2_block = NULL;
+ indir2_size = 0;
+ indir2_blkno = -1;
+ indir2_block = (uint32_t *) malloc(blksz);
+ if (indir2_block == NULL)
+ {
+ printf("** ext2fs read block (indir 2 2) malloc failed. **\n");
+ return(-1);
+ }
+ indir2_size = blksz;
+ }
+ if ((__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz) != indir1_blkno)
+ {
+ status = ext2fs_devread(__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz, 0, blksz, (char *) indir2_block);
+ if (status == 0)
+ {
+ printf("** ext2fs read block (indir 2 2) failed. **\n");
+ return(-1);
+ }
+ indir2_blkno = __le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz;
+ }
+ blknr = __le32_to_cpu(indir2_block[rblock % perblock]);
+ }
+ /* Tripple indirect. */
+ else
+ {
+ printf("** ext2fs doesn't support tripple indirect blocks. **\n");
+ return(-1);
+ }
+#ifdef DEBUG
+ printf("ext2fs_read_block %08x\n", blknr);
+#endif
+ return(blknr);
+}
+
+
+int ext2fs_read_file
+(
+ ext2fs_node_t node,
+ int pos,
+ unsigned int len,
+ char *buf
+ )
+{
+ int i;
+ int blockcnt;
+ int log2blocksize = LOG2_EXT2_BLOCK_SIZE (node->data);
+ int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
+ unsigned int filesize = node->inode.size;
+
+ /* Adjust len so it we can't read past the end of the file. */
+ if (len > filesize)
+ {
+ len = filesize;
+ }
+ blockcnt = ((len + pos) + blocksize - 1) / blocksize;
+
+ for (i = pos / blocksize; i < blockcnt; i++)
+ {
+ int blknr;
+ int blockoff = pos % blocksize;
+ int blockend = blocksize;
+
+ int skipfirst = 0;
+
+ blknr = ext2fs_read_block(node, i);
+ if (blknr < 0)
+ {
+ return(-1);
+ }
+ blknr = blknr << log2blocksize;
+
+ /* Last block. */
+ if (i == blockcnt - 1)
+ {
+ blockend = (len + pos) % blocksize;
+
+ /* The last portion is exactly blocksize. */
+ if (!blockend)
+ {
+ blockend = blocksize;
+ }
+ }
+
+ /* First block. */
+ if (i == pos / blocksize)
+ {
+ skipfirst = blockoff;
+ blockend -= skipfirst;
+ }
+
+ /* If the block number is 0 this block is not stored on disk but
+ is zero filled instead. */
+ if (blknr)
+ {
+ int status;
+
+ status = ext2fs_devread (blknr, skipfirst, blockend, buf);
+ if (status == 0)
+ {
+ return(-1);
+ }
+ }
+ else
+ {
+ memset (buf, blocksize - skipfirst, 0);
+ }
+ buf += blocksize - skipfirst;
+ }
+ return(len);
+}
+
+
+static int ext2fs_iterate_dir
+(
+ ext2fs_node_t dir,
+ char *name,
+ ext2fs_node_t *fnode,
+ int *ftype
+ )
+{
+ unsigned int fpos = 0;
+ int status;
+ struct ext2fs_node *diro = (struct ext2fs_node *) dir;
+#ifdef DEBUG
+ if (name != NULL) printf("Iterate dir %s\n", name);
+#endif /* of DEBUG */
+ if (!diro->inode_read)
+ {
+ status = ext2fs_read_inode (diro->data, diro->ino, &diro->inode);
+ if (status == 0)
+ {
+ return(0);
+ }
+ }
+ /* Search the file. */
+ while (fpos < __le32_to_cpu (diro->inode.size))
+ {
+ struct ext2_dirent dirent;
+
+ status = ext2fs_read_file (diro, fpos, sizeof (struct ext2_dirent), (char *) &dirent);
+ if (status < 1)
+ {
+ return(0);
+ }
+ if (dirent.namelen != 0)
+ {
+ char filename[dirent.namelen + 1];
+ ext2fs_node_t fdiro;
+ int type = FILETYPE_UNKNOWN;
+
+ status = ext2fs_read_file (diro, fpos + sizeof (struct ext2_dirent), dirent.namelen, filename);
+ if (status < 1)
+ {
+ return(0);
+ }
+ fdiro = malloc (sizeof (struct ext2fs_node));
+ if (!fdiro)
+ {
+ return(0);
+ }
+
+ fdiro->data = diro->data;
+ fdiro->ino = __le32_to_cpu(dirent.inode);
+
+ filename[dirent.namelen] = '\0';
+
+ if (dirent.filetype != FILETYPE_UNKNOWN)
+ {
+ fdiro->inode_read = 0;
+
+ if (dirent.filetype == FILETYPE_DIRECTORY)
+ {
+ type = FILETYPE_DIRECTORY;
+ }
+ else if (dirent.filetype == FILETYPE_SYMLINK)
+ {
+ type = FILETYPE_SYMLINK;
+ }
+ else if (dirent.filetype == FILETYPE_REG)
+ {
+ type = FILETYPE_REG;
+ }
+ }
+ else
+ {
+ /* The filetype can not be read from the dirent, get it from inode */
+
+ status = ext2fs_read_inode (diro->data, __le32_to_cpu (dirent.inode), &fdiro->inode);
+ if (status == 0)
+ {
+ free(fdiro);
+ return(0);
+ }
+ fdiro->inode_read = 1;
+
+ if ((__le16_to_cpu (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_DIRECTORY)
+ {
+ type = FILETYPE_DIRECTORY;
+ }
+ else if ((__le16_to_cpu (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_SYMLINK)
+ {
+ type = FILETYPE_SYMLINK;
+ }
+ else if ((__le16_to_cpu (fdiro->inode.mode) & FILETYPE_INO_MASK) == FILETYPE_INO_REG)
+ {
+ type = FILETYPE_REG;
+ }
+ }
+#ifdef DEBUG
+ printf("iterate >%s<\n", filename);
+#endif /* of DEBUG */
+ if ((name != NULL) && (fnode != NULL) && (ftype != NULL))
+ {
+ if(strcmp(filename, name) == 0)
+ {
+ *ftype = type;
+ *fnode = fdiro;
+ return(1);
+ }
+ }
+ else
+ {
+ if (fdiro->inode_read == 0)
+ {
+ status = ext2fs_read_inode (diro->data, __le32_to_cpu (dirent.inode), &fdiro->inode);
+ if (status == 0)
+ {
+ free(fdiro);
+ return(0);
+ }
+ fdiro->inode_read = 1;
+ }
+ switch(type)
+ {
+ case FILETYPE_DIRECTORY:
+ printf("<DIR> ");
+ break;
+ case FILETYPE_SYMLINK:
+ printf("<SYM> ");
+ break;
+ case FILETYPE_REG:
+ printf(" ");
+ break;
+ default:
+ printf("<???> ");
+ break;
+ }
+ printf("%10d %s\n", __le32_to_cpu(fdiro->inode.size), filename);
+ }
+ free(fdiro);
+ }
+ fpos += __le16_to_cpu (dirent.direntlen);
+ }
+ return(0);
+}
+
+
+static char *ext2fs_read_symlink
+(
+ ext2fs_node_t node
+ )
+{
+ char *symlink;
+ struct ext2fs_node *diro = node;
+ int status;
+
+ if (!diro->inode_read)
+ {
+ status = ext2fs_read_inode (diro->data, diro->ino, &diro->inode);
+ if (status == 0)
+ {
+ return(0);
+ }
+ }
+ symlink = malloc (__le32_to_cpu (diro->inode.size) + 1);
+ if (!symlink)
+ {
+ return(0);
+ }
+ /* If the filesize of the symlink is bigger than
+ 60 the symlink is stored in a separate block,
+ otherwise it is stored in the inode. */
+ if (__le32_to_cpu (diro->inode.size) <= 60)
+ {
+ strncpy (symlink, diro->inode.b.symlink, __le32_to_cpu (diro->inode.size));
+ }
+ else
+ {
+ status = ext2fs_read_file (diro, 0, __le32_to_cpu (diro->inode.size), symlink);
+ if (status == 0)
+ {
+ free (symlink);
+ return(0);
+ }
+ }
+ symlink[__le32_to_cpu (diro->inode.size)] = '\0';
+ return(symlink);
+}
+
+
+int ext2fs_find_file1
+(
+ const char *currpath,
+ ext2fs_node_t currroot,
+ ext2fs_node_t *currfound,
+ int *foundtype
+ )
+{
+ char fpath[strlen (currpath) + 1];
+ char *name = fpath;
+ char *next;
+ int status;
+ int type = FILETYPE_DIRECTORY;
+ ext2fs_node_t currnode = currroot;
+ ext2fs_node_t oldnode = currroot;
+
+ strncpy (fpath, currpath, strlen (currpath) + 1);
+
+ /* Remove all leading slashes. */
+ while (*name == '/')
+ {
+ name++;
+ }
+ if (!*name)
+ {
+ *currfound = currnode;
+ return(1);
+ }
+
+ for (;;)
+ {
+ int found;
+
+ /* Extract the actual part from the pathname. */
+ next = strchr (name, '/');
+ if (next)
+ {
+ /* Remove all leading slashes. */
+ while (*next == '/')
+ {
+ *(next++) = '\0';
+ }
+ }
+
+ /* At this point it is expected that the current node is a directory, check if this is true. */
+ if (type != FILETYPE_DIRECTORY)
+ {
+ ext2fs_free_node (currnode, currroot);
+ return(0);
+ }
+
+ oldnode = currnode;
+
+ /* Iterate over the directory. */
+ found = ext2fs_iterate_dir (currnode, name, &currnode, &type);
+ if (found == 0)
+ {
+ return(0);
+ }
+ if (found == -1)
+ {
+ break;
+ }
+
+ /* Read in the symlink and follow it. */
+ if (type == FILETYPE_SYMLINK)
+ {
+ char *symlink;
+
+ /* Test if the symlink does not loop. */
+ if (++symlinknest == 8)
+ {
+ ext2fs_free_node (currnode, currroot);
+ ext2fs_free_node (oldnode, currroot);
+ return(0);
+ }
+
+ symlink = ext2fs_read_symlink (currnode);
+ ext2fs_free_node (currnode, currroot);
+
+ if (!symlink)
+ {
+ ext2fs_free_node (oldnode, currroot);
+ return(0);
+ }
+#ifdef DEBUG
+ printf("Got symlink >%s<\n",symlink);
+#endif /* of DEBUG */
+ /* The symlink is an absolute path, go back to the root inode. */
+ if (symlink[0] == '/')
+ {
+ ext2fs_free_node (oldnode, currroot);
+ oldnode = &ext2fs_root->diropen;
+ }
+
+ /* Lookup the node the symlink points to. */
+ status = ext2fs_find_file1 (symlink, oldnode, &currnode, &type);
+
+ free (symlink);
+
+ if (status == 0)
+ {
+ ext2fs_free_node (oldnode, currroot);
+ return(0);
+ }
+ }
+
+ ext2fs_free_node (oldnode, currroot);
+
+ /* Found the node! */
+ if (!next || *next == '\0')
+ {
+ *currfound = currnode;
+ *foundtype = type;
+ return(1);
+ }
+ name = next;
+ }
+ return(-1);
+}
+
+
+int ext2fs_find_file
+(
+ const char *path,
+ ext2fs_node_t rootnode,
+ ext2fs_node_t *foundnode,
+ int expecttype
+ )
+{
+ int status;
+ int foundtype = FILETYPE_DIRECTORY;
+
+
+ symlinknest = 0;
+ if (!path || path[0] != '/')
+ {
+ return(0);
+ }
+
+ status = ext2fs_find_file1(path, rootnode, foundnode, &foundtype);
+ if (status == 0)
+ {
+ return(0);
+ }
+ /* Check if the node that was found was of the expected type. */
+ if ((expecttype == FILETYPE_REG) && (foundtype != expecttype))
+ {
+ return(0);
+ }
+ else if ((expecttype == FILETYPE_DIRECTORY) && (foundtype != expecttype))
+ {
+ return(0);
+ }
+ return(1);
+}
+
+
+int ext2fs_ls
+(
+ char *dirname
+ )
+{
+ ext2fs_node_t dirnode;
+ int status;
+
+ if (ext2fs_root == NULL)
+ {
+ return(0);
+ }
+
+ status = ext2fs_find_file(dirname, &ext2fs_root->diropen, &dirnode, FILETYPE_DIRECTORY);
+ if (status != 1)
+ {
+ printf("** Can not find directory. **\n");
+ return(1);
+ }
+ ext2fs_iterate_dir(dirnode, NULL, NULL, NULL);
+ ext2fs_free_node(dirnode, &ext2fs_root->diropen);
+ return(0);
+}
+
+
+int ext2fs_open
+(
+ char *filename
+ )
+{
+ ext2fs_node_t fdiro = NULL;
+ int status;
+ int len;
+
+ if (ext2fs_root == NULL)
+ {
+ return(0);
+ }
+ ext2fs_file = NULL;
+ status = ext2fs_find_file (filename, &ext2fs_root->diropen, &fdiro, FILETYPE_REG);
+ if (status == 0)
+ {
+ goto fail;
+ }
+ if (!fdiro->inode_read)
+ {
+ status = ext2fs_read_inode (fdiro->data, fdiro->ino, &fdiro->inode);
+ if (status == 0)
+ {
+ goto fail;
+ }
+ }
+ len = __le32_to_cpu (fdiro->inode.size);
+ ext2fs_file = fdiro;
+ return(len);
+
+ fail:
+ ext2fs_free_node(fdiro, &ext2fs_root->diropen);
+ return(0);
+}
+
+
+int ext2fs_close
+(
+ void
+ )
+{
+ if ((ext2fs_file != NULL) && (ext2fs_root != NULL))
+ {
+ ext2fs_free_node(ext2fs_file, &ext2fs_root->diropen);
+ ext2fs_file = NULL;
+ }
+ if (ext2fs_root != NULL)
+ {
+ free(ext2fs_root);
+ ext2fs_root = NULL;
+ }
+ if (indir1_block != NULL)
+ {
+ free(indir1_block);
+ indir1_block = NULL;
+ indir1_size = 0;
+ indir1_blkno = -1;
+ }
+ if (indir2_block != NULL)
+ {
+ free(indir2_block);
+ indir2_block = NULL;
+ indir2_size = 0;
+ indir2_blkno = -1;
+ }
+ return(0);
+}
+
+
+int ext2fs_read
+(
+ char *buf,
+ unsigned len
+ )
+{
+ int status;
+
+ if (ext2fs_root == NULL)
+ {
+ return(0);
+ }
+
+ if (ext2fs_file == NULL)
+ {
+ return(0);
+ }
+
+ status = ext2fs_read_file(ext2fs_file, 0, len, buf);
+ return(status);
+}
+
+
+int ext2fs_mount
+(
+ unsigned part_length
+ )
+{
+ struct ext2_data *data;
+ int status;
+
+ data = malloc (sizeof (struct ext2_data));
+ if (!data)
+ {
+ return(0);
+ }
+ /* Read the superblock. */
+ status = ext2fs_devread (1 * 2, 0, sizeof (struct ext2_sblock), (char *) &data->sblock);
+ if (status == 0)
+ {
+ goto fail;
+ }
+ /* Make sure this is an ext2 filesystem. */
+ if (__le16_to_cpu (data->sblock.magic) != EXT2_MAGIC)
+ {
+ goto fail;
+ }
+ data->diropen.data = data;
+ data->diropen.ino = 2;
+ data->diropen.inode_read = 1;
+ data->inode = &data->diropen.inode;
+
+ status = ext2fs_read_inode (data, 2, data->inode);
+ if (status == 0)
+ {
+ goto fail;
+ }
+
+ ext2fs_root = data;
+
+ return(1);
+
+ fail:
+ printf("Failed to mount ext2 filesystem...\n");
+ free(data);
+ ext2fs_root = NULL;
+ return(0);
+}
+
+#endif /* CFG_CMD_EXT2FS */
projects / karo-tx-uboot.git / commitdiff