blob: 9cf2fb7ba494499a1afe38a63f6c6fb378895cf1 [file] [log] [blame]
stroese2b918712004-12-16 17:26:24 +00001/*
2 * (C) Copyright 2004
3 * esd gmbh <www.esd-electronics.com>
4 * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
5 *
6 * based on code from grub2 fs/ext2.c and fs/fshelp.c by
7 *
8 * GRUB -- GRand Unified Bootloader
9 * Copyright (C) 2003, 2004 Free Software Foundation, Inc.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26#include <common.h>
27
28#if (CONFIG_COMMANDS & CFG_CMD_EXT2)
29#include <ext2fs.h>
30#include <malloc.h>
31#include <asm/byteorder.h>
32
wdenkefe2a4d2004-12-16 21:44:03 +000033extern int ext2fs_devread (int sector, int byte_offset, int byte_len,
34 char *buf);
stroese2b918712004-12-16 17:26:24 +000035
36/* Magic value used to identify an ext2 filesystem. */
37#define EXT2_MAGIC 0xEF53
38/* Amount of indirect blocks in an inode. */
39#define INDIRECT_BLOCKS 12
40/* Maximum lenght of a pathname. */
41#define EXT2_PATH_MAX 4096
42/* Maximum nesting of symlinks, used to prevent a loop. */
43#define EXT2_MAX_SYMLINKCNT 8
44
45/* Filetype used in directory entry. */
46#define FILETYPE_UNKNOWN 0
47#define FILETYPE_REG 1
48#define FILETYPE_DIRECTORY 2
49#define FILETYPE_SYMLINK 7
50
51/* Filetype information as used in inodes. */
52#define FILETYPE_INO_MASK 0170000
53#define FILETYPE_INO_REG 0100000
54#define FILETYPE_INO_DIRECTORY 0040000
55#define FILETYPE_INO_SYMLINK 0120000
56
57/* Bits used as offset in sector */
58#define DISK_SECTOR_BITS 9
59
60/* Log2 size of ext2 block in 512 blocks. */
61#define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1)
62
63/* Log2 size of ext2 block in bytes. */
64#define LOG2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 10)
65
66/* The size of an ext2 block in bytes. */
67#define EXT2_BLOCK_SIZE(data) (1 << LOG2_BLOCK_SIZE(data))
68
69/* The ext2 superblock. */
wdenkefe2a4d2004-12-16 21:44:03 +000070struct ext2_sblock {
stroese2b918712004-12-16 17:26:24 +000071 uint32_t total_inodes;
72 uint32_t total_blocks;
73 uint32_t reserved_blocks;
74 uint32_t free_blocks;
75 uint32_t free_inodes;
76 uint32_t first_data_block;
77 uint32_t log2_block_size;
78 uint32_t log2_fragment_size;
79 uint32_t blocks_per_group;
80 uint32_t fragments_per_group;
81 uint32_t inodes_per_group;
82 uint32_t mtime;
83 uint32_t utime;
84 uint16_t mnt_count;
85 uint16_t max_mnt_count;
86 uint16_t magic;
87 uint16_t fs_state;
88 uint16_t error_handling;
89 uint16_t minor_revision_level;
90 uint32_t lastcheck;
91 uint32_t checkinterval;
92 uint32_t creator_os;
93 uint32_t revision_level;
94 uint16_t uid_reserved;
95 uint16_t gid_reserved;
96 uint32_t first_inode;
97 uint16_t inode_size;
98 uint16_t block_group_number;
99 uint32_t feature_compatibility;
100 uint32_t feature_incompat;
101 uint32_t feature_ro_compat;
102 uint32_t unique_id[4];
103 char volume_name[16];
104 char last_mounted_on[64];
105 uint32_t compression_info;
106};
107
108/* The ext2 blockgroup. */
wdenkefe2a4d2004-12-16 21:44:03 +0000109struct ext2_block_group {
stroese2b918712004-12-16 17:26:24 +0000110 uint32_t block_id;
111 uint32_t inode_id;
112 uint32_t inode_table_id;
113 uint16_t free_blocks;
114 uint16_t free_inodes;
115 uint16_t pad;
116 uint32_t reserved[3];
117};
118
119/* The ext2 inode. */
wdenkefe2a4d2004-12-16 21:44:03 +0000120struct ext2_inode {
stroese2b918712004-12-16 17:26:24 +0000121 uint16_t mode;
122 uint16_t uid;
123 uint32_t size;
124 uint32_t atime;
125 uint32_t ctime;
126 uint32_t mtime;
127 uint32_t dtime;
128 uint16_t gid;
129 uint16_t nlinks;
wdenkefe2a4d2004-12-16 21:44:03 +0000130 uint32_t blockcnt; /* Blocks of 512 bytes!! */
stroese2b918712004-12-16 17:26:24 +0000131 uint32_t flags;
132 uint32_t osd1;
wdenkefe2a4d2004-12-16 21:44:03 +0000133 union {
134 struct datablocks {
stroese2b918712004-12-16 17:26:24 +0000135 uint32_t dir_blocks[INDIRECT_BLOCKS];
136 uint32_t indir_block;
137 uint32_t double_indir_block;
138 uint32_t tripple_indir_block;
139 } blocks;
140 char symlink[60];
wdenkefe2a4d2004-12-16 21:44:03 +0000141 } b;
stroese2b918712004-12-16 17:26:24 +0000142 uint32_t version;
143 uint32_t acl;
144 uint32_t dir_acl;
145 uint32_t fragment_addr;
146 uint32_t osd2[3];
147};
148
149/* The header of an ext2 directory entry. */
wdenkefe2a4d2004-12-16 21:44:03 +0000150struct ext2_dirent {
stroese2b918712004-12-16 17:26:24 +0000151 uint32_t inode;
152 uint16_t direntlen;
wdenkefe2a4d2004-12-16 21:44:03 +0000153 uint8_t namelen;
154 uint8_t filetype;
stroese2b918712004-12-16 17:26:24 +0000155};
156
wdenkefe2a4d2004-12-16 21:44:03 +0000157struct ext2fs_node {
stroese2b918712004-12-16 17:26:24 +0000158 struct ext2_data *data;
159 struct ext2_inode inode;
wdenkefe2a4d2004-12-16 21:44:03 +0000160 int ino;
161 int inode_read;
stroese2b918712004-12-16 17:26:24 +0000162};
163
164/* Information about a "mounted" ext2 filesystem. */
wdenkefe2a4d2004-12-16 21:44:03 +0000165struct ext2_data {
stroese2b918712004-12-16 17:26:24 +0000166 struct ext2_sblock sblock;
167 struct ext2_inode *inode;
168 struct ext2fs_node diropen;
169};
170
171
172typedef struct ext2fs_node *ext2fs_node_t;
173
wdenkefe2a4d2004-12-16 21:44:03 +0000174struct ext2_data *ext2fs_root = NULL;
175ext2fs_node_t ext2fs_file = NULL;
176int symlinknest = 0;
177uint32_t *indir1_block = NULL;
178int indir1_size = 0;
179int indir1_blkno = -1;
180uint32_t *indir2_block = NULL;
181int indir2_size = 0;
182int indir2_blkno = -1;
stroese2b918712004-12-16 17:26:24 +0000183
184
185static int ext2fs_blockgroup
wdenkefe2a4d2004-12-16 21:44:03 +0000186 (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
stroese2b918712004-12-16 17:26:24 +0000187#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000188 printf ("ext2fs read blockgroup\n");
stroese2b918712004-12-16 17:26:24 +0000189#endif
wdenkefe2a4d2004-12-16 21:44:03 +0000190 return (ext2fs_devread
191 (((__le32_to_cpu (data->sblock.first_data_block) +
192 1) << LOG2_EXT2_BLOCK_SIZE (data)),
193 group * sizeof (struct ext2_block_group),
194 sizeof (struct ext2_block_group), (char *) blkgrp));
stroese2b918712004-12-16 17:26:24 +0000195}
196
197
198static int ext2fs_read_inode
wdenkefe2a4d2004-12-16 21:44:03 +0000199 (struct ext2_data *data, int ino, struct ext2_inode *inode) {
200 struct ext2_block_group blkgrp;
201 struct ext2_sblock *sblock = &data->sblock;
202 int inodes_per_block;
203 int status;
stroese2b918712004-12-16 17:26:24 +0000204
wdenkefe2a4d2004-12-16 21:44:03 +0000205 unsigned int blkno;
206 unsigned int blkoff;
stroese2b918712004-12-16 17:26:24 +0000207
208 /* It is easier to calculate if the first inode is 0. */
209 ino--;
210#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000211 printf ("ext2fs read inode %d\n", ino);
stroese2b918712004-12-16 17:26:24 +0000212#endif
wdenkefe2a4d2004-12-16 21:44:03 +0000213 status = ext2fs_blockgroup (data,
214 ino /
215 __le32_to_cpu (sblock->inodes_per_group),
216 &blkgrp);
217 if (status == 0) {
218 return (0);
stroese2b918712004-12-16 17:26:24 +0000219 }
220 inodes_per_block = EXT2_BLOCK_SIZE (data) / 128;
wdenkefe2a4d2004-12-16 21:44:03 +0000221 blkno = (ino % __le32_to_cpu (sblock->inodes_per_group)) /
222 inodes_per_block;
223 blkoff = (ino % __le32_to_cpu (sblock->inodes_per_group)) %
224 inodes_per_block;
stroese2b918712004-12-16 17:26:24 +0000225#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000226 printf ("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);
stroese2b918712004-12-16 17:26:24 +0000227#endif
228 /* Read the inode. */
wdenkefe2a4d2004-12-16 21:44:03 +0000229 status = ext2fs_devread (((__le32_to_cpu (blkgrp.inode_table_id) +
230 blkno) << LOG2_EXT2_BLOCK_SIZE (data)),
231 sizeof (struct ext2_inode) * blkoff,
232 sizeof (struct ext2_inode), (char *) inode);
233 if (status == 0) {
234 return (0);
stroese2b918712004-12-16 17:26:24 +0000235 }
wdenkefe2a4d2004-12-16 21:44:03 +0000236 return (1);
stroese2b918712004-12-16 17:26:24 +0000237}
238
239
wdenkefe2a4d2004-12-16 21:44:03 +0000240void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) {
241 if ((node != &ext2fs_root->diropen) && (node != currroot)) {
stroese2b918712004-12-16 17:26:24 +0000242 free (node);
243 }
244}
245
246
wdenkefe2a4d2004-12-16 21:44:03 +0000247static int ext2fs_read_block (ext2fs_node_t node, int fileblock) {
248 struct ext2_data *data = node->data;
249 struct ext2_inode *inode = &node->inode;
250 int blknr;
251 int blksz = EXT2_BLOCK_SIZE (data);
252 int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
253 int status;
stroese2b918712004-12-16 17:26:24 +0000254
255 /* Direct blocks. */
wdenkefe2a4d2004-12-16 21:44:03 +0000256 if (fileblock < INDIRECT_BLOCKS) {
stroese2b918712004-12-16 17:26:24 +0000257 blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
wdenkefe2a4d2004-12-16 21:44:03 +0000258 }
stroese2b918712004-12-16 17:26:24 +0000259 /* Indirect. */
wdenkefe2a4d2004-12-16 21:44:03 +0000260 else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
261 if (indir1_block == NULL) {
262 indir1_block = (uint32_t *) malloc (blksz);
263 if (indir1_block == NULL) {
264 printf ("** ext2fs read block (indir 1) malloc failed. **\n");
265 return (-1);
stroese2b918712004-12-16 17:26:24 +0000266 }
wdenkefe2a4d2004-12-16 21:44:03 +0000267 indir1_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000268 indir1_blkno = -1;
269 }
wdenkefe2a4d2004-12-16 21:44:03 +0000270 if (blksz != indir1_size) {
271 free (indir1_block);
stroese2b918712004-12-16 17:26:24 +0000272 indir1_block = NULL;
wdenkefe2a4d2004-12-16 21:44:03 +0000273 indir1_size = 0;
stroese2b918712004-12-16 17:26:24 +0000274 indir1_blkno = -1;
wdenkefe2a4d2004-12-16 21:44:03 +0000275 indir1_block = (uint32_t *) malloc (blksz);
276 if (indir1_block == NULL) {
277 printf ("** ext2fs read block (indir 1) malloc failed. **\n");
278 return (-1);
stroese2b918712004-12-16 17:26:24 +0000279 }
wdenkefe2a4d2004-12-16 21:44:03 +0000280 indir1_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000281 }
wdenkefe2a4d2004-12-16 21:44:03 +0000282 if ((__le32_to_cpu (inode->b.blocks.indir_block) <<
283 log2_blksz) != indir1_blkno) {
284 status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz,
285 0, blksz,
286 (char *) indir1_block);
287 if (status == 0) {
288 printf ("** ext2fs read block (indir 1) failed. **\n");
289 return (0);
stroese2b918712004-12-16 17:26:24 +0000290 }
wdenkefe2a4d2004-12-16 21:44:03 +0000291 indir1_blkno =
292 __le32_to_cpu (inode->b.blocks.
293 indir_block) << log2_blksz;
stroese2b918712004-12-16 17:26:24 +0000294 }
wdenkefe2a4d2004-12-16 21:44:03 +0000295 blknr = __le32_to_cpu (indir1_block
296 [fileblock - INDIRECT_BLOCKS]);
stroese2b918712004-12-16 17:26:24 +0000297 }
298 /* Double indirect. */
wdenkefe2a4d2004-12-16 21:44:03 +0000299 else if (fileblock <
300 (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
stroese2b918712004-12-16 17:26:24 +0000301 unsigned int perblock = blksz / 4;
302 unsigned int rblock = fileblock - (INDIRECT_BLOCKS
303 + blksz / 4);
304
wdenkefe2a4d2004-12-16 21:44:03 +0000305 if (indir1_block == NULL) {
306 indir1_block = (uint32_t *) malloc (blksz);
307 if (indir1_block == NULL) {
308 printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
309 return (-1);
stroese2b918712004-12-16 17:26:24 +0000310 }
wdenkefe2a4d2004-12-16 21:44:03 +0000311 indir1_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000312 indir1_blkno = -1;
313 }
wdenkefe2a4d2004-12-16 21:44:03 +0000314 if (blksz != indir1_size) {
315 free (indir1_block);
stroese2b918712004-12-16 17:26:24 +0000316 indir1_block = NULL;
wdenkefe2a4d2004-12-16 21:44:03 +0000317 indir1_size = 0;
stroese2b918712004-12-16 17:26:24 +0000318 indir1_blkno = -1;
wdenkefe2a4d2004-12-16 21:44:03 +0000319 indir1_block = (uint32_t *) malloc (blksz);
320 if (indir1_block == NULL) {
321 printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
322 return (-1);
stroese2b918712004-12-16 17:26:24 +0000323 }
wdenkefe2a4d2004-12-16 21:44:03 +0000324 indir1_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000325 }
wdenkefe2a4d2004-12-16 21:44:03 +0000326 if ((__le32_to_cpu (inode->b.blocks.double_indir_block) <<
327 log2_blksz) != indir1_blkno) {
328 status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz,
329 0, blksz,
330 (char *) indir1_block);
331 if (status == 0) {
332 printf ("** ext2fs read block (indir 2 1) failed. **\n");
333 return (-1);
stroese2b918712004-12-16 17:26:24 +0000334 }
wdenkefe2a4d2004-12-16 21:44:03 +0000335 indir1_blkno =
336 __le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz;
stroese2b918712004-12-16 17:26:24 +0000337 }
338
wdenkefe2a4d2004-12-16 21:44:03 +0000339 if (indir2_block == NULL) {
340 indir2_block = (uint32_t *) malloc (blksz);
341 if (indir2_block == NULL) {
342 printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
343 return (-1);
stroese2b918712004-12-16 17:26:24 +0000344 }
wdenkefe2a4d2004-12-16 21:44:03 +0000345 indir2_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000346 indir2_blkno = -1;
347 }
wdenkefe2a4d2004-12-16 21:44:03 +0000348 if (blksz != indir2_size) {
349 free (indir2_block);
stroese2b918712004-12-16 17:26:24 +0000350 indir2_block = NULL;
wdenkefe2a4d2004-12-16 21:44:03 +0000351 indir2_size = 0;
stroese2b918712004-12-16 17:26:24 +0000352 indir2_blkno = -1;
wdenkefe2a4d2004-12-16 21:44:03 +0000353 indir2_block = (uint32_t *) malloc (blksz);
354 if (indir2_block == NULL) {
355 printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
356 return (-1);
stroese2b918712004-12-16 17:26:24 +0000357 }
wdenkefe2a4d2004-12-16 21:44:03 +0000358 indir2_size = blksz;
stroese2b918712004-12-16 17:26:24 +0000359 }
wdenkefe2a4d2004-12-16 21:44:03 +0000360 if ((__le32_to_cpu (indir1_block[rblock / perblock]) <<
361 log2_blksz) != indir1_blkno) {
362 status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz,
363 0, blksz,
364 (char *) indir2_block);
365 if (status == 0) {
366 printf ("** ext2fs read block (indir 2 2) failed. **\n");
367 return (-1);
stroese2b918712004-12-16 17:26:24 +0000368 }
wdenkefe2a4d2004-12-16 21:44:03 +0000369 indir2_blkno =
370 __le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz;
stroese2b918712004-12-16 17:26:24 +0000371 }
wdenkefe2a4d2004-12-16 21:44:03 +0000372 blknr = __le32_to_cpu (indir2_block[rblock % perblock]);
stroese2b918712004-12-16 17:26:24 +0000373 }
374 /* Tripple indirect. */
wdenkefe2a4d2004-12-16 21:44:03 +0000375 else {
376 printf ("** ext2fs doesn't support tripple indirect blocks. **\n");
377 return (-1);
378 }
stroese2b918712004-12-16 17:26:24 +0000379#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000380 printf ("ext2fs_read_block %08x\n", blknr);
stroese2b918712004-12-16 17:26:24 +0000381#endif
wdenkefe2a4d2004-12-16 21:44:03 +0000382 return (blknr);
stroese2b918712004-12-16 17:26:24 +0000383}
384
385
386int ext2fs_read_file
wdenkefe2a4d2004-12-16 21:44:03 +0000387 (ext2fs_node_t node, int pos, unsigned int len, char *buf) {
388 int i;
389 int blockcnt;
390 int log2blocksize = LOG2_EXT2_BLOCK_SIZE (node->data);
391 int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
Stefan Roesea7b9fb92006-01-18 20:05:34 +0100392 unsigned int filesize = __le32_to_cpu(node->inode.size);
stroese2b918712004-12-16 17:26:24 +0000393
394 /* Adjust len so it we can't read past the end of the file. */
wdenkefe2a4d2004-12-16 21:44:03 +0000395 if (len > filesize) {
stroese2b918712004-12-16 17:26:24 +0000396 len = filesize;
397 }
wdenkefe2a4d2004-12-16 21:44:03 +0000398 blockcnt = ((len + pos) + blocksize - 1) / blocksize;
stroese2b918712004-12-16 17:26:24 +0000399
wdenkefe2a4d2004-12-16 21:44:03 +0000400 for (i = pos / blocksize; i < blockcnt; i++) {
stroese2b918712004-12-16 17:26:24 +0000401 int blknr;
402 int blockoff = pos % blocksize;
403 int blockend = blocksize;
404
405 int skipfirst = 0;
406
wdenkefe2a4d2004-12-16 21:44:03 +0000407 blknr = ext2fs_read_block (node, i);
408 if (blknr < 0) {
409 return (-1);
stroese2b918712004-12-16 17:26:24 +0000410 }
411 blknr = blknr << log2blocksize;
412
413 /* Last block. */
wdenkefe2a4d2004-12-16 21:44:03 +0000414 if (i == blockcnt - 1) {
stroese2b918712004-12-16 17:26:24 +0000415 blockend = (len + pos) % blocksize;
416
417 /* The last portion is exactly blocksize. */
wdenkefe2a4d2004-12-16 21:44:03 +0000418 if (!blockend) {
stroese2b918712004-12-16 17:26:24 +0000419 blockend = blocksize;
420 }
421 }
422
423 /* First block. */
wdenkefe2a4d2004-12-16 21:44:03 +0000424 if (i == pos / blocksize) {
stroese2b918712004-12-16 17:26:24 +0000425 skipfirst = blockoff;
426 blockend -= skipfirst;
427 }
428
429 /* If the block number is 0 this block is not stored on disk but
430 is zero filled instead. */
wdenkefe2a4d2004-12-16 21:44:03 +0000431 if (blknr) {
stroese2b918712004-12-16 17:26:24 +0000432 int status;
433
434 status = ext2fs_devread (blknr, skipfirst, blockend, buf);
wdenkefe2a4d2004-12-16 21:44:03 +0000435 if (status == 0) {
436 return (-1);
stroese2b918712004-12-16 17:26:24 +0000437 }
wdenkefe2a4d2004-12-16 21:44:03 +0000438 } else {
stroese2b918712004-12-16 17:26:24 +0000439 memset (buf, blocksize - skipfirst, 0);
440 }
441 buf += blocksize - skipfirst;
wdenkefe2a4d2004-12-16 21:44:03 +0000442 }
443 return (len);
stroese2b918712004-12-16 17:26:24 +0000444}
445
446
wdenkefe2a4d2004-12-16 21:44:03 +0000447static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t * fnode, int *ftype)
stroese2b918712004-12-16 17:26:24 +0000448{
449 unsigned int fpos = 0;
wdenkefe2a4d2004-12-16 21:44:03 +0000450 int status;
stroese2b918712004-12-16 17:26:24 +0000451 struct ext2fs_node *diro = (struct ext2fs_node *) dir;
wdenkefe2a4d2004-12-16 21:44:03 +0000452
stroese2b918712004-12-16 17:26:24 +0000453#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000454 if (name != NULL)
455 printf ("Iterate dir %s\n", name);
stroese2b918712004-12-16 17:26:24 +0000456#endif /* of DEBUG */
wdenkefe2a4d2004-12-16 21:44:03 +0000457 if (!diro->inode_read) {
458 status = ext2fs_read_inode (diro->data, diro->ino,
459 &diro->inode);
460 if (status == 0) {
461 return (0);
stroese2b918712004-12-16 17:26:24 +0000462 }
463 }
464 /* Search the file. */
wdenkefe2a4d2004-12-16 21:44:03 +0000465 while (fpos < __le32_to_cpu (diro->inode.size)) {
stroese2b918712004-12-16 17:26:24 +0000466 struct ext2_dirent dirent;
467
wdenkefe2a4d2004-12-16 21:44:03 +0000468 status = ext2fs_read_file (diro, fpos,
469 sizeof (struct ext2_dirent),
470 (char *) &dirent);
471 if (status < 1) {
472 return (0);
stroese2b918712004-12-16 17:26:24 +0000473 }
wdenkefe2a4d2004-12-16 21:44:03 +0000474 if (dirent.namelen != 0) {
475 char filename[dirent.namelen + 1];
476 ext2fs_node_t fdiro;
477 int type = FILETYPE_UNKNOWN;
stroese2b918712004-12-16 17:26:24 +0000478
wdenkefe2a4d2004-12-16 21:44:03 +0000479 status = ext2fs_read_file (diro,
480 fpos + sizeof (struct ext2_dirent),
481 dirent.namelen, filename);
482 if (status < 1) {
483 return (0);
stroese2b918712004-12-16 17:26:24 +0000484 }
485 fdiro = malloc (sizeof (struct ext2fs_node));
wdenkefe2a4d2004-12-16 21:44:03 +0000486 if (!fdiro) {
487 return (0);
stroese2b918712004-12-16 17:26:24 +0000488 }
489
490 fdiro->data = diro->data;
wdenkefe2a4d2004-12-16 21:44:03 +0000491 fdiro->ino = __le32_to_cpu (dirent.inode);
stroese2b918712004-12-16 17:26:24 +0000492
493 filename[dirent.namelen] = '\0';
494
wdenkefe2a4d2004-12-16 21:44:03 +0000495 if (dirent.filetype != FILETYPE_UNKNOWN) {
stroese2b918712004-12-16 17:26:24 +0000496 fdiro->inode_read = 0;
497
wdenkefe2a4d2004-12-16 21:44:03 +0000498 if (dirent.filetype == FILETYPE_DIRECTORY) {
stroese2b918712004-12-16 17:26:24 +0000499 type = FILETYPE_DIRECTORY;
wdenkefe2a4d2004-12-16 21:44:03 +0000500 } else if (dirent.filetype ==
501 FILETYPE_SYMLINK) {
stroese2b918712004-12-16 17:26:24 +0000502 type = FILETYPE_SYMLINK;
wdenkefe2a4d2004-12-16 21:44:03 +0000503 } else if (dirent.filetype == FILETYPE_REG) {
504 type = FILETYPE_REG;
stroese2b918712004-12-16 17:26:24 +0000505 }
wdenkefe2a4d2004-12-16 21:44:03 +0000506 } else {
stroese2b918712004-12-16 17:26:24 +0000507 /* The filetype can not be read from the dirent, get it from inode */
508
wdenkefe2a4d2004-12-16 21:44:03 +0000509 status = ext2fs_read_inode (diro->data,
510 __le32_to_cpu(dirent.inode),
511 &fdiro->inode);
512 if (status == 0) {
513 free (fdiro);
514 return (0);
stroese2b918712004-12-16 17:26:24 +0000515 }
516 fdiro->inode_read = 1;
517
wdenkefe2a4d2004-12-16 21:44:03 +0000518 if ((__le16_to_cpu (fdiro->inode.mode) &
519 FILETYPE_INO_MASK) ==
520 FILETYPE_INO_DIRECTORY) {
stroese2b918712004-12-16 17:26:24 +0000521 type = FILETYPE_DIRECTORY;
wdenkefe2a4d2004-12-16 21:44:03 +0000522 } else if ((__le16_to_cpu (fdiro->inode.mode)
523 & FILETYPE_INO_MASK) ==
524 FILETYPE_INO_SYMLINK) {
stroese2b918712004-12-16 17:26:24 +0000525 type = FILETYPE_SYMLINK;
wdenkefe2a4d2004-12-16 21:44:03 +0000526 } else if ((__le16_to_cpu (fdiro->inode.mode)
527 & FILETYPE_INO_MASK) ==
528 FILETYPE_INO_REG) {
stroese2b918712004-12-16 17:26:24 +0000529 type = FILETYPE_REG;
530 }
531 }
532#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000533 printf ("iterate >%s<\n", filename);
stroese2b918712004-12-16 17:26:24 +0000534#endif /* of DEBUG */
wdenkefe2a4d2004-12-16 21:44:03 +0000535 if ((name != NULL) && (fnode != NULL)
536 && (ftype != NULL)) {
537 if (strcmp (filename, name) == 0) {
stroese2b918712004-12-16 17:26:24 +0000538 *ftype = type;
539 *fnode = fdiro;
wdenkefe2a4d2004-12-16 21:44:03 +0000540 return (1);
stroese2b918712004-12-16 17:26:24 +0000541 }
wdenkefe2a4d2004-12-16 21:44:03 +0000542 } else {
543 if (fdiro->inode_read == 0) {
544 status = ext2fs_read_inode (diro->data,
545 __le32_to_cpu (dirent.inode),
546 &fdiro->inode);
547 if (status == 0) {
548 free (fdiro);
549 return (0);
stroese2b918712004-12-16 17:26:24 +0000550 }
551 fdiro->inode_read = 1;
552 }
wdenkefe2a4d2004-12-16 21:44:03 +0000553 switch (type) {
stroese2b918712004-12-16 17:26:24 +0000554 case FILETYPE_DIRECTORY:
wdenkefe2a4d2004-12-16 21:44:03 +0000555 printf ("<DIR> ");
stroese2b918712004-12-16 17:26:24 +0000556 break;
557 case FILETYPE_SYMLINK:
wdenkefe2a4d2004-12-16 21:44:03 +0000558 printf ("<SYM> ");
stroese2b918712004-12-16 17:26:24 +0000559 break;
560 case FILETYPE_REG:
wdenkefe2a4d2004-12-16 21:44:03 +0000561 printf (" ");
stroese2b918712004-12-16 17:26:24 +0000562 break;
563 default:
wdenkec0aee72004-12-19 09:58:11 +0000564 printf ("< ? > ");
stroese2b918712004-12-16 17:26:24 +0000565 break;
566 }
wdenkefe2a4d2004-12-16 21:44:03 +0000567 printf ("%10d %s\n",
568 __le32_to_cpu (fdiro->inode.size),
569 filename);
stroese2b918712004-12-16 17:26:24 +0000570 }
wdenkefe2a4d2004-12-16 21:44:03 +0000571 free (fdiro);
stroese2b918712004-12-16 17:26:24 +0000572 }
573 fpos += __le16_to_cpu (dirent.direntlen);
574 }
wdenkefe2a4d2004-12-16 21:44:03 +0000575 return (0);
stroese2b918712004-12-16 17:26:24 +0000576}
577
578
wdenkefe2a4d2004-12-16 21:44:03 +0000579static char *ext2fs_read_symlink (ext2fs_node_t node) {
580 char *symlink;
stroese2b918712004-12-16 17:26:24 +0000581 struct ext2fs_node *diro = node;
wdenkefe2a4d2004-12-16 21:44:03 +0000582 int status;
stroese2b918712004-12-16 17:26:24 +0000583
wdenkefe2a4d2004-12-16 21:44:03 +0000584 if (!diro->inode_read) {
585 status = ext2fs_read_inode (diro->data, diro->ino,
586 &diro->inode);
587 if (status == 0) {
588 return (0);
stroese2b918712004-12-16 17:26:24 +0000589 }
590 }
591 symlink = malloc (__le32_to_cpu (diro->inode.size) + 1);
wdenkefe2a4d2004-12-16 21:44:03 +0000592 if (!symlink) {
593 return (0);
stroese2b918712004-12-16 17:26:24 +0000594 }
595 /* If the filesize of the symlink is bigger than
596 60 the symlink is stored in a separate block,
597 otherwise it is stored in the inode. */
wdenkefe2a4d2004-12-16 21:44:03 +0000598 if (__le32_to_cpu (diro->inode.size) <= 60) {
599 strncpy (symlink, diro->inode.b.symlink,
600 __le32_to_cpu (diro->inode.size));
601 } else {
602 status = ext2fs_read_file (diro, 0,
603 __le32_to_cpu (diro->inode.size),
604 symlink);
605 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000606 free (symlink);
wdenkefe2a4d2004-12-16 21:44:03 +0000607 return (0);
stroese2b918712004-12-16 17:26:24 +0000608 }
609 }
610 symlink[__le32_to_cpu (diro->inode.size)] = '\0';
wdenkefe2a4d2004-12-16 21:44:03 +0000611 return (symlink);
stroese2b918712004-12-16 17:26:24 +0000612}
613
614
615int ext2fs_find_file1
wdenkefe2a4d2004-12-16 21:44:03 +0000616 (const char *currpath,
617 ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) {
618 char fpath[strlen (currpath) + 1];
619 char *name = fpath;
620 char *next;
621 int status;
622 int type = FILETYPE_DIRECTORY;
623 ext2fs_node_t currnode = currroot;
624 ext2fs_node_t oldnode = currroot;
stroese2b918712004-12-16 17:26:24 +0000625
626 strncpy (fpath, currpath, strlen (currpath) + 1);
627
628 /* Remove all leading slashes. */
wdenkefe2a4d2004-12-16 21:44:03 +0000629 while (*name == '/') {
stroese2b918712004-12-16 17:26:24 +0000630 name++;
wdenkefe2a4d2004-12-16 21:44:03 +0000631 }
632 if (!*name) {
stroese2b918712004-12-16 17:26:24 +0000633 *currfound = currnode;
wdenkefe2a4d2004-12-16 21:44:03 +0000634 return (1);
stroese2b918712004-12-16 17:26:24 +0000635 }
636
wdenkefe2a4d2004-12-16 21:44:03 +0000637 for (;;) {
stroese2b918712004-12-16 17:26:24 +0000638 int found;
639
640 /* Extract the actual part from the pathname. */
641 next = strchr (name, '/');
wdenkefe2a4d2004-12-16 21:44:03 +0000642 if (next) {
stroese2b918712004-12-16 17:26:24 +0000643 /* Remove all leading slashes. */
wdenkefe2a4d2004-12-16 21:44:03 +0000644 while (*next == '/') {
stroese2b918712004-12-16 17:26:24 +0000645 *(next++) = '\0';
646 }
647 }
648
649 /* At this point it is expected that the current node is a directory, check if this is true. */
wdenkefe2a4d2004-12-16 21:44:03 +0000650 if (type != FILETYPE_DIRECTORY) {
stroese2b918712004-12-16 17:26:24 +0000651 ext2fs_free_node (currnode, currroot);
wdenkefe2a4d2004-12-16 21:44:03 +0000652 return (0);
stroese2b918712004-12-16 17:26:24 +0000653 }
654
655 oldnode = currnode;
656
657 /* Iterate over the directory. */
658 found = ext2fs_iterate_dir (currnode, name, &currnode, &type);
wdenkefe2a4d2004-12-16 21:44:03 +0000659 if (found == 0) {
660 return (0);
stroese2b918712004-12-16 17:26:24 +0000661 }
wdenkefe2a4d2004-12-16 21:44:03 +0000662 if (found == -1) {
stroese2b918712004-12-16 17:26:24 +0000663 break;
664 }
665
666 /* Read in the symlink and follow it. */
wdenkefe2a4d2004-12-16 21:44:03 +0000667 if (type == FILETYPE_SYMLINK) {
stroese2b918712004-12-16 17:26:24 +0000668 char *symlink;
669
670 /* Test if the symlink does not loop. */
wdenkefe2a4d2004-12-16 21:44:03 +0000671 if (++symlinknest == 8) {
stroese2b918712004-12-16 17:26:24 +0000672 ext2fs_free_node (currnode, currroot);
wdenkefe2a4d2004-12-16 21:44:03 +0000673 ext2fs_free_node (oldnode, currroot);
674 return (0);
stroese2b918712004-12-16 17:26:24 +0000675 }
676
677 symlink = ext2fs_read_symlink (currnode);
678 ext2fs_free_node (currnode, currroot);
679
wdenkefe2a4d2004-12-16 21:44:03 +0000680 if (!symlink) {
stroese2b918712004-12-16 17:26:24 +0000681 ext2fs_free_node (oldnode, currroot);
wdenkefe2a4d2004-12-16 21:44:03 +0000682 return (0);
stroese2b918712004-12-16 17:26:24 +0000683 }
684#ifdef DEBUG
wdenkefe2a4d2004-12-16 21:44:03 +0000685 printf ("Got symlink >%s<\n", symlink);
stroese2b918712004-12-16 17:26:24 +0000686#endif /* of DEBUG */
687 /* The symlink is an absolute path, go back to the root inode. */
wdenkefe2a4d2004-12-16 21:44:03 +0000688 if (symlink[0] == '/') {
stroese2b918712004-12-16 17:26:24 +0000689 ext2fs_free_node (oldnode, currroot);
690 oldnode = &ext2fs_root->diropen;
691 }
692
693 /* Lookup the node the symlink points to. */
wdenkefe2a4d2004-12-16 21:44:03 +0000694 status = ext2fs_find_file1 (symlink, oldnode,
695 &currnode, &type);
stroese2b918712004-12-16 17:26:24 +0000696
697 free (symlink);
698
wdenkefe2a4d2004-12-16 21:44:03 +0000699 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000700 ext2fs_free_node (oldnode, currroot);
wdenkefe2a4d2004-12-16 21:44:03 +0000701 return (0);
stroese2b918712004-12-16 17:26:24 +0000702 }
703 }
704
705 ext2fs_free_node (oldnode, currroot);
706
707 /* Found the node! */
wdenkefe2a4d2004-12-16 21:44:03 +0000708 if (!next || *next == '\0') {
stroese2b918712004-12-16 17:26:24 +0000709 *currfound = currnode;
710 *foundtype = type;
wdenkefe2a4d2004-12-16 21:44:03 +0000711 return (1);
stroese2b918712004-12-16 17:26:24 +0000712 }
713 name = next;
714 }
wdenkefe2a4d2004-12-16 21:44:03 +0000715 return (-1);
stroese2b918712004-12-16 17:26:24 +0000716}
717
718
719int ext2fs_find_file
wdenkefe2a4d2004-12-16 21:44:03 +0000720 (const char *path,
721 ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) {
stroese2b918712004-12-16 17:26:24 +0000722 int status;
723 int foundtype = FILETYPE_DIRECTORY;
724
725
726 symlinknest = 0;
wdenk20a80412005-02-04 15:02:06 +0000727 if (!path) {
wdenkefe2a4d2004-12-16 21:44:03 +0000728 return (0);
stroese2b918712004-12-16 17:26:24 +0000729 }
730
wdenkefe2a4d2004-12-16 21:44:03 +0000731 status = ext2fs_find_file1 (path, rootnode, foundnode, &foundtype);
732 if (status == 0) {
733 return (0);
stroese2b918712004-12-16 17:26:24 +0000734 }
735 /* Check if the node that was found was of the expected type. */
wdenkefe2a4d2004-12-16 21:44:03 +0000736 if ((expecttype == FILETYPE_REG) && (foundtype != expecttype)) {
737 return (0);
738 } else if ((expecttype == FILETYPE_DIRECTORY)
739 && (foundtype != expecttype)) {
740 return (0);
stroese2b918712004-12-16 17:26:24 +0000741 }
wdenkefe2a4d2004-12-16 21:44:03 +0000742 return (1);
stroese2b918712004-12-16 17:26:24 +0000743}
744
745
wdenkefe2a4d2004-12-16 21:44:03 +0000746int ext2fs_ls (char *dirname) {
stroese2b918712004-12-16 17:26:24 +0000747 ext2fs_node_t dirnode;
wdenkefe2a4d2004-12-16 21:44:03 +0000748 int status;
stroese2b918712004-12-16 17:26:24 +0000749
wdenkefe2a4d2004-12-16 21:44:03 +0000750 if (ext2fs_root == NULL) {
751 return (0);
stroese2b918712004-12-16 17:26:24 +0000752 }
753
wdenkefe2a4d2004-12-16 21:44:03 +0000754 status = ext2fs_find_file (dirname, &ext2fs_root->diropen, &dirnode,
755 FILETYPE_DIRECTORY);
756 if (status != 1) {
757 printf ("** Can not find directory. **\n");
758 return (1);
759 }
760 ext2fs_iterate_dir (dirnode, NULL, NULL, NULL);
761 ext2fs_free_node (dirnode, &ext2fs_root->diropen);
762 return (0);
stroese2b918712004-12-16 17:26:24 +0000763}
764
765
wdenkefe2a4d2004-12-16 21:44:03 +0000766int ext2fs_open (char *filename) {
767 ext2fs_node_t fdiro = NULL;
768 int status;
769 int len;
stroese2b918712004-12-16 17:26:24 +0000770
wdenkefe2a4d2004-12-16 21:44:03 +0000771 if (ext2fs_root == NULL) {
wdenk20a80412005-02-04 15:02:06 +0000772 return (-1);
stroese2b918712004-12-16 17:26:24 +0000773 }
774 ext2fs_file = NULL;
wdenkefe2a4d2004-12-16 21:44:03 +0000775 status = ext2fs_find_file (filename, &ext2fs_root->diropen, &fdiro,
776 FILETYPE_REG);
777 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000778 goto fail;
779 }
wdenkefe2a4d2004-12-16 21:44:03 +0000780 if (!fdiro->inode_read) {
781 status = ext2fs_read_inode (fdiro->data, fdiro->ino,
782 &fdiro->inode);
783 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000784 goto fail;
785 }
786 }
787 len = __le32_to_cpu (fdiro->inode.size);
788 ext2fs_file = fdiro;
wdenkefe2a4d2004-12-16 21:44:03 +0000789 return (len);
stroese2b918712004-12-16 17:26:24 +0000790
wdenk20a80412005-02-04 15:02:06 +0000791fail:
wdenkefe2a4d2004-12-16 21:44:03 +0000792 ext2fs_free_node (fdiro, &ext2fs_root->diropen);
wdenk20a80412005-02-04 15:02:06 +0000793 return (-1);
stroese2b918712004-12-16 17:26:24 +0000794}
795
796
wdenkefe2a4d2004-12-16 21:44:03 +0000797int ext2fs_close (void
798 ) {
799 if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) {
800 ext2fs_free_node (ext2fs_file, &ext2fs_root->diropen);
stroese2b918712004-12-16 17:26:24 +0000801 ext2fs_file = NULL;
802 }
wdenkefe2a4d2004-12-16 21:44:03 +0000803 if (ext2fs_root != NULL) {
804 free (ext2fs_root);
805 ext2fs_root = NULL;
stroese2b918712004-12-16 17:26:24 +0000806 }
wdenkefe2a4d2004-12-16 21:44:03 +0000807 if (indir1_block != NULL) {
808 free (indir1_block);
809 indir1_block = NULL;
810 indir1_size = 0;
811 indir1_blkno = -1;
stroese2b918712004-12-16 17:26:24 +0000812 }
wdenkefe2a4d2004-12-16 21:44:03 +0000813 if (indir2_block != NULL) {
814 free (indir2_block);
815 indir2_block = NULL;
816 indir2_size = 0;
817 indir2_blkno = -1;
stroese2b918712004-12-16 17:26:24 +0000818 }
wdenkefe2a4d2004-12-16 21:44:03 +0000819 return (0);
stroese2b918712004-12-16 17:26:24 +0000820}
821
822
wdenkefe2a4d2004-12-16 21:44:03 +0000823int ext2fs_read (char *buf, unsigned len) {
stroese2b918712004-12-16 17:26:24 +0000824 int status;
825
wdenkefe2a4d2004-12-16 21:44:03 +0000826 if (ext2fs_root == NULL) {
827 return (0);
stroese2b918712004-12-16 17:26:24 +0000828 }
829
wdenkefe2a4d2004-12-16 21:44:03 +0000830 if (ext2fs_file == NULL) {
831 return (0);
stroese2b918712004-12-16 17:26:24 +0000832 }
833
wdenkefe2a4d2004-12-16 21:44:03 +0000834 status = ext2fs_read_file (ext2fs_file, 0, len, buf);
835 return (status);
stroese2b918712004-12-16 17:26:24 +0000836}
837
838
wdenkefe2a4d2004-12-16 21:44:03 +0000839int ext2fs_mount (unsigned part_length) {
stroese2b918712004-12-16 17:26:24 +0000840 struct ext2_data *data;
wdenkefe2a4d2004-12-16 21:44:03 +0000841 int status;
stroese2b918712004-12-16 17:26:24 +0000842
843 data = malloc (sizeof (struct ext2_data));
wdenkefe2a4d2004-12-16 21:44:03 +0000844 if (!data) {
845 return (0);
stroese2b918712004-12-16 17:26:24 +0000846 }
847 /* Read the superblock. */
wdenkefe2a4d2004-12-16 21:44:03 +0000848 status = ext2fs_devread (1 * 2, 0, sizeof (struct ext2_sblock),
849 (char *) &data->sblock);
850 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000851 goto fail;
852 }
853 /* Make sure this is an ext2 filesystem. */
wdenkefe2a4d2004-12-16 21:44:03 +0000854 if (__le16_to_cpu (data->sblock.magic) != EXT2_MAGIC) {
stroese2b918712004-12-16 17:26:24 +0000855 goto fail;
856 }
wdenkefe2a4d2004-12-16 21:44:03 +0000857 data->diropen.data = data;
858 data->diropen.ino = 2;
859 data->diropen.inode_read = 1;
860 data->inode = &data->diropen.inode;
stroese2b918712004-12-16 17:26:24 +0000861
862 status = ext2fs_read_inode (data, 2, data->inode);
wdenkefe2a4d2004-12-16 21:44:03 +0000863 if (status == 0) {
stroese2b918712004-12-16 17:26:24 +0000864 goto fail;
865 }
866
867 ext2fs_root = data;
868
wdenkefe2a4d2004-12-16 21:44:03 +0000869 return (1);
stroese2b918712004-12-16 17:26:24 +0000870
wdenkefe2a4d2004-12-16 21:44:03 +0000871fail:
872 printf ("Failed to mount ext2 filesystem...\n");
873 free (data);
stroese2b918712004-12-16 17:26:24 +0000874 ext2fs_root = NULL;
wdenkefe2a4d2004-12-16 21:44:03 +0000875 return (0);
stroese2b918712004-12-16 17:26:24 +0000876}
877
878#endif /* CFG_CMD_EXT2FS */