fs/ext2/ext2fs.c

   1 /*
   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 #include <ext2fs.h>
  28 #include <malloc.h>
  29 #include <asm/byteorder.h>
  30
  31 extern int ext2fs_devread (int sector, int byte_offset, int byte_len,
  32                            char *buf);
  33
  34 /* Magic value used to identify an ext2 filesystem.  */
  35 #define EXT2_MAGIC              0xEF53
  36 /* Amount of indirect blocks in an inode.  */
  37 #define INDIRECT_BLOCKS         12
  38 /* Maximum lenght of a pathname.  */
  39 #define EXT2_PATH_MAX           4096
  40 /* Maximum nesting of symlinks, used to prevent a loop.  */
  41 #define EXT2_MAX_SYMLINKCNT     8
  42
  43 /* Filetype used in directory entry.  */
  44 #define FILETYPE_UNKNOWN        0
  45 #define FILETYPE_REG            1
  46 #define FILETYPE_DIRECTORY      2
  47 #define FILETYPE_SYMLINK        7
  48
  49 /* Filetype information as used in inodes.  */
  50 #define FILETYPE_INO_MASK       0170000
  51 #define FILETYPE_INO_REG        0100000
  52 #define FILETYPE_INO_DIRECTORY  0040000
  53 #define FILETYPE_INO_SYMLINK    0120000
  54
  55 /* Bits used as offset in sector */
  56 #define DISK_SECTOR_BITS        9
  57
  58 /* Log2 size of ext2 block in 512 blocks.  */
  59 #define LOG2_EXT2_BLOCK_SIZE(data) (__le32_to_cpu (data->sblock.log2_block_size) + 1)
  60
  61 /* Log2 size of ext2 block in bytes.  */
  62 #define LOG2_BLOCK_SIZE(data)      (__le32_to_cpu (data->sblock.log2_block_size) + 10)
  63
  64 /* The size of an ext2 block in bytes.  */
  65 #define EXT2_BLOCK_SIZE(data)      (1 << LOG2_BLOCK_SIZE(data))
  66
  67 /* The ext2 superblock.  */
  68 struct ext2_sblock {
  69         uint32_t total_inodes;
  70         uint32_t total_blocks;
  71         uint32_t reserved_blocks;
  72         uint32_t free_blocks;
  73         uint32_t free_inodes;
  74         uint32_t first_data_block;
  75         uint32_t log2_block_size;
  76         uint32_t log2_fragment_size;
  77         uint32_t blocks_per_group;
  78         uint32_t fragments_per_group;
  79         uint32_t inodes_per_group;
  80         uint32_t mtime;
  81         uint32_t utime;
  82         uint16_t mnt_count;
  83         uint16_t max_mnt_count;
  84         uint16_t magic;
  85         uint16_t fs_state;
  86         uint16_t error_handling;
  87         uint16_t minor_revision_level;
  88         uint32_t lastcheck;
  89         uint32_t checkinterval;
  90         uint32_t creator_os;
  91         uint32_t revision_level;
  92         uint16_t uid_reserved;
  93         uint16_t gid_reserved;
  94         uint32_t first_inode;
  95         uint16_t inode_size;
  96         uint16_t block_group_number;
  97         uint32_t feature_compatibility;
  98         uint32_t feature_incompat;
  99         uint32_t feature_ro_compat;
 100         uint32_t unique_id[4];
 101         char volume_name[16];
 102         char last_mounted_on[64];
 103         uint32_t compression_info;
 104 };
 105
 106 /* The ext2 blockgroup.  */
 107 struct ext2_block_group {
 108         uint32_t block_id;
 109         uint32_t inode_id;
 110         uint32_t inode_table_id;
 111         uint16_t free_blocks;
 112         uint16_t free_inodes;
 113         uint16_t used_dir_cnt;
 114         uint32_t reserved[3];
 115 };
 116
 117 /* The ext2 inode.  */
 118 struct ext2_inode {
 119         uint16_t mode;
 120         uint16_t uid;
 121         uint32_t size;
 122         uint32_t atime;
 123         uint32_t ctime;
 124         uint32_t mtime;
 125         uint32_t dtime;
 126         uint16_t gid;
 127         uint16_t nlinks;
 128         uint32_t blockcnt;      /* Blocks of 512 bytes!! */
 129         uint32_t flags;
 130         uint32_t osd1;
 131         union {
 132                 struct datablocks {
 133                         uint32_t dir_blocks[INDIRECT_BLOCKS];
 134                         uint32_t indir_block;
 135                         uint32_t double_indir_block;
 136                         uint32_t tripple_indir_block;
 137                 } blocks;
 138                 char symlink[60];
 139         } b;
 140         uint32_t version;
 141         uint32_t acl;
 142         uint32_t dir_acl;
 143         uint32_t fragment_addr;
 144         uint32_t osd2[3];
 145 };
 146
 147 /* The header of an ext2 directory entry.  */
 148 struct ext2_dirent {
 149         uint32_t inode;
 150         uint16_t direntlen;
 151         uint8_t namelen;
 152         uint8_t filetype;
 153 };
 154
 155 struct ext2fs_node {
 156         struct ext2_data *data;
 157         struct ext2_inode inode;
 158         int ino;
 159         int inode_read;
 160 };
 161
 162 /* Information about a "mounted" ext2 filesystem.  */
 163 struct ext2_data {
 164         struct ext2_sblock sblock;
 165         struct ext2_inode *inode;
 166         struct ext2fs_node diropen;
 167 };
 168
 169
 170 typedef struct ext2fs_node *ext2fs_node_t;
 171
 172 struct ext2_data *ext2fs_root = NULL;
 173 ext2fs_node_t ext2fs_file = NULL;
 174 int symlinknest = 0;
 175 uint32_t *indir1_block = NULL;
 176 int indir1_size = 0;
 177 int indir1_blkno = -1;
 178 uint32_t *indir2_block = NULL;
 179 int indir2_size = 0;
 180 int indir2_blkno = -1;
 181 static unsigned int inode_size;
 182
 183
 184 static int ext2fs_blockgroup
 185         (struct ext2_data *data, int group, struct ext2_block_group *blkgrp) {
 186         unsigned int blkno;
 187         unsigned int blkoff;
 188         unsigned int desc_per_blk;
 189
 190         desc_per_blk = EXT2_BLOCK_SIZE(data) / sizeof(struct ext2_block_group);
 191
 192         blkno = __le32_to_cpu(data->sblock.first_data_block) + 1 +
 193         group / desc_per_blk;
 194         blkoff = (group % desc_per_blk) * sizeof(struct ext2_block_group);
 195 #ifdef DEBUG
 196         printf ("ext2fs read %d group descriptor (blkno %d blkoff %d)\n",
 197                 group, blkno, blkoff);
 198 #endif
 199         return (ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE(data),
 200                 blkoff, sizeof(struct ext2_block_group), (char *)blkgrp));
 201
 202 }
 203
 204
 205 static int ext2fs_read_inode
 206         (struct ext2_data *data, int ino, struct ext2_inode *inode) {
 207         struct ext2_block_group blkgrp;
 208         struct ext2_sblock *sblock = &data->sblock;
 209         int inodes_per_block;
 210         int status;
 211
 212         unsigned int blkno;
 213         unsigned int blkoff;
 214
 215 #ifdef DEBUG
 216         printf ("ext2fs read inode %d, inode_size %d\n", ino, inode_size);
 217 #endif
 218         /* It is easier to calculate if the first inode is 0.  */
 219         ino--;
 220         status = ext2fs_blockgroup (data, ino / __le32_to_cpu
 221                                     (sblock->inodes_per_group), &blkgrp);
 222         if (status == 0) {
 223                 return (0);
 224         }
 225
 226         inodes_per_block = EXT2_BLOCK_SIZE(data) / inode_size;
 227
 228         blkno = __le32_to_cpu (blkgrp.inode_table_id) +
 229                 (ino % __le32_to_cpu (sblock->inodes_per_group))
 230                 / inodes_per_block;
 231         blkoff = (ino % inodes_per_block) * inode_size;
 232 #ifdef DEBUG
 233         printf ("ext2fs read inode blkno %d blkoff %d\n", blkno, blkoff);
 234 #endif
 235         /* Read the inode.  */
 236         status = ext2fs_devread (blkno << LOG2_EXT2_BLOCK_SIZE (data), blkoff,
 237                                  sizeof (struct ext2_inode), (char *) inode);
 238         if (status == 0) {
 239                 return (0);
 240         }
 241
 242         return (1);
 243 }
 244
 245
 246 void ext2fs_free_node (ext2fs_node_t node, ext2fs_node_t currroot) {
 247         if ((node != &ext2fs_root->diropen) && (node != currroot)) {
 248                 free (node);
 249         }
 250 }
 251
 252
 253 static int ext2fs_read_block (ext2fs_node_t node, int fileblock) {
 254         struct ext2_data *data = node->data;
 255         struct ext2_inode *inode = &node->inode;
 256         int blknr;
 257         int blksz = EXT2_BLOCK_SIZE (data);
 258         int log2_blksz = LOG2_EXT2_BLOCK_SIZE (data);
 259         int status;
 260
 261         /* Direct blocks.  */
 262         if (fileblock < INDIRECT_BLOCKS) {
 263                 blknr = __le32_to_cpu (inode->b.blocks.dir_blocks[fileblock]);
 264         }
 265         /* Indirect.  */
 266         else if (fileblock < (INDIRECT_BLOCKS + (blksz / 4))) {
 267                 if (indir1_block == NULL) {
 268                         indir1_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 269                                                              blksz);
 270                         if (indir1_block == NULL) {
 271                                 printf ("** ext2fs read block (indir 1) malloc failed. **\n");
 272                                 return (-1);
 273                         }
 274                         indir1_size = blksz;
 275                         indir1_blkno = -1;
 276                 }
 277                 if (blksz != indir1_size) {
 278                         free (indir1_block);
 279                         indir1_block = NULL;
 280                         indir1_size = 0;
 281                         indir1_blkno = -1;
 282                         indir1_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 283                                                              blksz);
 284                         if (indir1_block == NULL) {
 285                                 printf ("** ext2fs read block (indir 1) malloc failed. **\n");
 286                                 return (-1);
 287                         }
 288                         indir1_size = blksz;
 289                 }
 290                 if ((__le32_to_cpu (inode->b.blocks.indir_block) <<
 291                      log2_blksz) != indir1_blkno) {
 292                         status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.indir_block) << log2_blksz,
 293                                                  0, blksz,
 294                                                  (char *) indir1_block);
 295                         if (status == 0) {
 296                                 printf ("** ext2fs read block (indir 1) failed. **\n");
 297                                 return (0);
 298                         }
 299                         indir1_blkno =
 300                                 __le32_to_cpu (inode->b.blocks.
 301                                                indir_block) << log2_blksz;
 302                 }
 303                 blknr = __le32_to_cpu (indir1_block
 304                                        [fileblock - INDIRECT_BLOCKS]);
 305         }
 306         /* Double indirect.  */
 307         else if (fileblock <
 308                  (INDIRECT_BLOCKS + (blksz / 4 * (blksz / 4 + 1)))) {
 309                 unsigned int perblock = blksz / 4;
 310                 unsigned int rblock = fileblock - (INDIRECT_BLOCKS
 311                                                    + blksz / 4);
 312
 313                 if (indir1_block == NULL) {
 314                         indir1_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 315                                                              blksz);
 316                         if (indir1_block == NULL) {
 317                                 printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
 318                                 return (-1);
 319                         }
 320                         indir1_size = blksz;
 321                         indir1_blkno = -1;
 322                 }
 323                 if (blksz != indir1_size) {
 324                         free (indir1_block);
 325                         indir1_block = NULL;
 326                         indir1_size = 0;
 327                         indir1_blkno = -1;
 328                         indir1_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 329                                                              blksz);
 330                         if (indir1_block == NULL) {
 331                                 printf ("** ext2fs read block (indir 2 1) malloc failed. **\n");
 332                                 return (-1);
 333                         }
 334                         indir1_size = blksz;
 335                 }
 336                 if ((__le32_to_cpu (inode->b.blocks.double_indir_block) <<
 337                      log2_blksz) != indir1_blkno) {
 338                         status = ext2fs_devread (__le32_to_cpu(inode->b.blocks.double_indir_block) << log2_blksz,
 339                                                 0, blksz,
 340                                                 (char *) indir1_block);
 341                         if (status == 0) {
 342                                 printf ("** ext2fs read block (indir 2 1) failed. **\n");
 343                                 return (-1);
 344                         }
 345                         indir1_blkno =
 346                                 __le32_to_cpu (inode->b.blocks.double_indir_block) << log2_blksz;
 347                 }
 348
 349                 if (indir2_block == NULL) {
 350                         indir2_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 351                                                              blksz);
 352                         if (indir2_block == NULL) {
 353                                 printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
 354                                 return (-1);
 355                         }
 356                         indir2_size = blksz;
 357                         indir2_blkno = -1;
 358                 }
 359                 if (blksz != indir2_size) {
 360                         free (indir2_block);
 361                         indir2_block = NULL;
 362                         indir2_size = 0;
 363                         indir2_blkno = -1;
 364                         indir2_block = (uint32_t *) memalign(ARCH_DMA_MINALIGN,
 365                                                              blksz);
 366                         if (indir2_block == NULL) {
 367                                 printf ("** ext2fs read block (indir 2 2) malloc failed. **\n");
 368                                 return (-1);
 369                         }
 370                         indir2_size = blksz;
 371                 }
 372                 if ((__le32_to_cpu (indir1_block[rblock / perblock]) <<
 373                      log2_blksz) != indir2_blkno) {
 374                         status = ext2fs_devread (__le32_to_cpu(indir1_block[rblock / perblock]) << log2_blksz,
 375                                                  0, blksz,
 376                                                  (char *) indir2_block);
 377                         if (status == 0) {
 378                                 printf ("** ext2fs read block (indir 2 2) failed. **\n");
 379                                 return (-1);
 380                         }
 381                         indir2_blkno =
 382                                 __le32_to_cpu (indir1_block[rblock / perblock]) << log2_blksz;
 383                 }
 384                 blknr = __le32_to_cpu (indir2_block[rblock % perblock]);
 385         }
 386         /* Tripple indirect.  */
 387         else {
 388                 printf ("** ext2fs doesn't support tripple indirect blocks. **\n");
 389                 return (-1);
 390         }
 391 #ifdef DEBUG
 392         printf ("ext2fs_read_block %08x\n", blknr);
 393 #endif
 394         return (blknr);
 395 }
 396
 397
 398 int ext2fs_read_file
 399         (ext2fs_node_t node, int pos, unsigned int len, char *buf) {
 400         int i;
 401         int blockcnt;
 402         int log2blocksize = LOG2_EXT2_BLOCK_SIZE (node->data);
 403         int blocksize = 1 << (log2blocksize + DISK_SECTOR_BITS);
 404         unsigned int filesize = __le32_to_cpu(node->inode.size);
 405
 406         /* Adjust len so it we can't read past the end of the file.  */
 407         if (len > filesize) {
 408                 len = filesize;
 409         }
 410         blockcnt = ((len + pos) + blocksize - 1) / blocksize;
 411
 412         for (i = pos / blocksize; i < blockcnt; i++) {
 413                 int blknr;
 414                 int blockoff = pos % blocksize;
 415                 int blockend = blocksize;
 416
 417                 int skipfirst = 0;
 418
 419                 blknr = ext2fs_read_block (node, i);
 420                 if (blknr < 0) {
 421                         return (-1);
 422                 }
 423
 424                 /* Last block.  */
 425                 if (i == blockcnt - 1) {
 426                         blockend = (len + pos) % blocksize;
 427
 428                         /* The last portion is exactly blocksize.  */
 429                         if (!blockend) {
 430                                 blockend = blocksize;
 431                         }
 432                 }
 433
 434                 /* First block.  */
 435                 if (i == pos / blocksize) {
 436                         skipfirst = blockoff;
 437                         blockend -= skipfirst;
 438                 }
 439
 440                 /* grab middle blocks in one go */
 441                 if (i != pos / blocksize && i < blockcnt - 1 && blockcnt > 3) {
 442                         int oldblk = blknr;
 443                         int blocknxt = ext2fs_read_block(node, i + 1);
 444                         while (i < blockcnt - 1) {
 445                                 if (blocknxt == (oldblk + 1)) {
 446                                         oldblk = blocknxt;
 447                                         i++;
 448                                 } else {
 449                                         blocknxt = ext2fs_read_block(node, i);
 450                                         break;
 451                                 }
 452                                 blocknxt = ext2fs_read_block(node, i);
 453                         }
 454
 455                         if (oldblk == blknr)
 456                                 blockend = blocksize;
 457                         else
 458                                 blockend = (1 + blocknxt - blknr) * blocksize;
 459                 }
 460
 461                 blknr = blknr << log2blocksize;
 462
 463                 /* If the block number is 0 this block is not stored on disk but
 464                    is zero filled instead.  */
 465                 if (blknr) {
 466                         int status;
 467
 468                         status = ext2fs_devread (blknr, skipfirst, blockend, buf);
 469                         if (status == 0) {
 470                                 return (-1);
 471                         }
 472                 } else {
 473                         memset (buf, 0, blocksize - skipfirst);
 474                 }
 475                 buf += blockend - skipfirst;
 476         }
 477         return (len);
 478 }
 479
 480
 481 static int ext2fs_iterate_dir (ext2fs_node_t dir, char *name, ext2fs_node_t * fnode, int *ftype)
 482 {
 483         unsigned int fpos = 0;
 484         int status;
 485         struct ext2fs_node *diro = (struct ext2fs_node *) dir;
 486
 487 #ifdef DEBUG
 488         if (name != NULL)
 489                 printf ("Iterate dir %s\n", name);
 490 #endif /* of DEBUG */
 491         if (!diro->inode_read) {
 492                 status = ext2fs_read_inode (diro->data, diro->ino,
 493                                             &diro->inode);
 494                 if (status == 0) {
 495                         return (0);
 496                 }
 497         }
 498         /* Search the file.  */
 499         while (fpos < __le32_to_cpu (diro->inode.size)) {
 500                 struct ext2_dirent dirent;
 501
 502                 status = ext2fs_read_file (diro, fpos,
 503                                            sizeof (struct ext2_dirent),
 504                                            (char *) &dirent);
 505                 if (status < 1) {
 506                         return (0);
 507                 }
 508                 if (dirent.namelen != 0) {
 509                         char filename[dirent.namelen + 1];
 510                         ext2fs_node_t fdiro;
 511                         int type = FILETYPE_UNKNOWN;
 512
 513                         status = ext2fs_read_file (diro,
 514                                                    fpos + sizeof (struct ext2_dirent),
 515                                                    dirent.namelen, filename);
 516                         if (status < 1) {
 517                                 return (0);
 518                         }
 519                         fdiro = malloc (sizeof (struct ext2fs_node));
 520                         if (!fdiro) {
 521                                 return (0);
 522                         }
 523
 524                         fdiro->data = diro->data;
 525                         fdiro->ino = __le32_to_cpu (dirent.inode);
 526
 527                         filename[dirent.namelen] = '\0';
 528
 529                         if (dirent.filetype != FILETYPE_UNKNOWN) {
 530                                 fdiro->inode_read = 0;
 531
 532                                 if (dirent.filetype == FILETYPE_DIRECTORY) {
 533                                         type = FILETYPE_DIRECTORY;
 534                                 } else if (dirent.filetype ==
 535                                            FILETYPE_SYMLINK) {
 536                                         type = FILETYPE_SYMLINK;
 537                                 } else if (dirent.filetype == FILETYPE_REG) {
 538                                         type = FILETYPE_REG;
 539                                 }
 540                         } else {
 541                                 /* The filetype can not be read from the dirent, get it from inode */
 542
 543                                 status = ext2fs_read_inode (diro->data,
 544                                                             __le32_to_cpu(dirent.inode),
 545                                                             &fdiro->inode);
 546                                 if (status == 0) {
 547                                         free (fdiro);
 548                                         return (0);
 549                                 }
 550                                 fdiro->inode_read = 1;
 551
 552                                 if ((__le16_to_cpu (fdiro->inode.mode) &
 553                                      FILETYPE_INO_MASK) ==
 554                                     FILETYPE_INO_DIRECTORY) {
 555                                         type = FILETYPE_DIRECTORY;
 556                                 } else if ((__le16_to_cpu (fdiro->inode.mode)
 557                                             & FILETYPE_INO_MASK) ==
 558                                            FILETYPE_INO_SYMLINK) {
 559                                         type = FILETYPE_SYMLINK;
 560                                 } else if ((__le16_to_cpu (fdiro->inode.mode)
 561                                             & FILETYPE_INO_MASK) ==
 562                                            FILETYPE_INO_REG) {
 563                                         type = FILETYPE_REG;
 564                                 }
 565                         }
 566 #ifdef DEBUG
 567                         printf ("iterate >%s<\n", filename);
 568 #endif /* of DEBUG */
 569                         if ((name != NULL) && (fnode != NULL)
 570                             && (ftype != NULL)) {
 571                                 if (strcmp (filename, name) == 0) {
 572                                         *ftype = type;
 573                                         *fnode = fdiro;
 574                                         return (1);
 575                                 }
 576                         } else {
 577                                 if (fdiro->inode_read == 0) {
 578                                         status = ext2fs_read_inode (diro->data,
 579                                                             __le32_to_cpu (dirent.inode),
 580                                                             &fdiro->inode);
 581                                         if (status == 0) {
 582                                                 free (fdiro);
 583                                                 return (0);
 584                                         }
 585                                         fdiro->inode_read = 1;
 586                                 }
 587                                 switch (type) {
 588                                 case FILETYPE_DIRECTORY:
 589                                         printf ("<DIR> ");
 590                                         break;
 591                                 case FILETYPE_SYMLINK:
 592                                         printf ("<SYM> ");
 593                                         break;
 594                                 case FILETYPE_REG:
 595                                         printf ("      ");
 596                                         break;
 597                                 default:
 598                                         printf ("< ? > ");
 599                                         break;
 600                                 }
 601                                 printf ("%10d %s\n",
 602                                         __le32_to_cpu (fdiro->inode.size),
 603                                         filename);
 604                         }
 605                         free (fdiro);
 606                 }
 607                 fpos += __le16_to_cpu (dirent.direntlen);
 608         }
 609         return (0);
 610 }
 611
 612
 613 static char *ext2fs_read_symlink (ext2fs_node_t node) {
 614         char *symlink;
 615         struct ext2fs_node *diro = node;
 616         int status;
 617
 618         if (!diro->inode_read) {
 619                 status = ext2fs_read_inode (diro->data, diro->ino,
 620                                             &diro->inode);
 621                 if (status == 0) {
 622                         return (0);
 623                 }
 624         }
 625         symlink = malloc (__le32_to_cpu (diro->inode.size) + 1);
 626         if (!symlink) {
 627                 return (0);
 628         }
 629         /* If the filesize of the symlink is bigger than
 630            60 the symlink is stored in a separate block,
 631            otherwise it is stored in the inode.  */
 632         if (__le32_to_cpu (diro->inode.size) <= 60) {
 633                 strncpy (symlink, diro->inode.b.symlink,
 634                          __le32_to_cpu (diro->inode.size));
 635         } else {
 636                 status = ext2fs_read_file (diro, 0,
 637                                            __le32_to_cpu (diro->inode.size),
 638                                            symlink);
 639                 if (status == 0) {
 640                         free (symlink);
 641                         return (0);
 642                 }
 643         }
 644         symlink[__le32_to_cpu (diro->inode.size)] = '\0';
 645         return (symlink);
 646 }
 647
 648
 649 int ext2fs_find_file1
 650         (const char *currpath,
 651          ext2fs_node_t currroot, ext2fs_node_t * currfound, int *foundtype) {
 652         char fpath[strlen (currpath) + 1];
 653         char *name = fpath;
 654         char *next;
 655         int status;
 656         int type = FILETYPE_DIRECTORY;
 657         ext2fs_node_t currnode = currroot;
 658         ext2fs_node_t oldnode = currroot;
 659
 660         strncpy (fpath, currpath, strlen (currpath) + 1);
 661
 662         /* Remove all leading slashes.  */
 663         while (*name == '/') {
 664                 name++;
 665         }
 666         if (!*name) {
 667                 *currfound = currnode;
 668                 return (1);
 669         }
 670
 671         for (;;) {
 672                 int found;
 673
 674                 /* Extract the actual part from the pathname.  */
 675                 next = strchr (name, '/');
 676                 if (next) {
 677                         /* Remove all leading slashes.  */
 678                         while (*next == '/') {
 679                                 *(next++) = '\0';
 680                         }
 681                 }
 682
 683                 /* At this point it is expected that the current node is a directory, check if this is true.  */
 684                 if (type != FILETYPE_DIRECTORY) {
 685                         ext2fs_free_node (currnode, currroot);
 686                         return (0);
 687                 }
 688
 689                 oldnode = currnode;
 690
 691                 /* Iterate over the directory.  */
 692                 found = ext2fs_iterate_dir (currnode, name, &currnode, &type);
 693                 if (found == 0) {
 694                         return (0);
 695                 }
 696                 if (found == -1) {
 697                         break;
 698                 }
 699
 700                 /* Read in the symlink and follow it.  */
 701                 if (type == FILETYPE_SYMLINK) {
 702                         char *symlink;
 703
 704                         /* Test if the symlink does not loop.  */
 705                         if (++symlinknest == 8) {
 706                                 ext2fs_free_node (currnode, currroot);
 707                                 ext2fs_free_node (oldnode, currroot);
 708                                 return (0);
 709                         }
 710
 711                         symlink = ext2fs_read_symlink (currnode);
 712                         ext2fs_free_node (currnode, currroot);
 713
 714                         if (!symlink) {
 715                                 ext2fs_free_node (oldnode, currroot);
 716                                 return (0);
 717                         }
 718 #ifdef DEBUG
 719                         printf ("Got symlink >%s<\n", symlink);
 720 #endif /* of DEBUG */
 721                         /* The symlink is an absolute path, go back to the root inode.  */
 722                         if (symlink[0] == '/') {
 723                                 ext2fs_free_node (oldnode, currroot);
 724                                 oldnode = &ext2fs_root->diropen;
 725                         }
 726
 727                         /* Lookup the node the symlink points to.  */
 728                         status = ext2fs_find_file1 (symlink, oldnode,
 729                                                     &currnode, &type);
 730
 731                         free (symlink);
 732
 733                         if (status == 0) {
 734                                 ext2fs_free_node (oldnode, currroot);
 735                                 return (0);
 736                         }
 737                 }
 738
 739                 ext2fs_free_node (oldnode, currroot);
 740
 741                 /* Found the node!  */
 742                 if (!next || *next == '\0') {
 743                         *currfound = currnode;
 744                         *foundtype = type;
 745                         return (1);
 746                 }
 747                 name = next;
 748         }
 749         return (-1);
 750 }
 751
 752
 753 int ext2fs_find_file
 754         (const char *path,
 755          ext2fs_node_t rootnode, ext2fs_node_t * foundnode, int expecttype) {
 756         int status;
 757         int foundtype = FILETYPE_DIRECTORY;
 758
 759
 760         symlinknest = 0;
 761         if (!path) {
 762                 return (0);
 763         }
 764
 765         status = ext2fs_find_file1 (path, rootnode, foundnode, &foundtype);
 766         if (status == 0) {
 767                 return (0);
 768         }
 769         /* Check if the node that was found was of the expected type.  */
 770         if ((expecttype == FILETYPE_REG) && (foundtype != expecttype)) {
 771                 return (0);
 772         } else if ((expecttype == FILETYPE_DIRECTORY)
 773                    && (foundtype != expecttype)) {
 774                 return (0);
 775         }
 776         return (1);
 777 }
 778
 779
 780 int ext2fs_ls (const char *dirname) {
 781         ext2fs_node_t dirnode;
 782         int status;
 783
 784         if (ext2fs_root == NULL) {
 785                 return (0);
 786         }
 787
 788         status = ext2fs_find_file (dirname, &ext2fs_root->diropen, &dirnode,
 789                                    FILETYPE_DIRECTORY);
 790         if (status != 1) {
 791                 printf ("** Can not find directory. **\n");
 792                 return (1);
 793         }
 794         ext2fs_iterate_dir (dirnode, NULL, NULL, NULL);
 795         ext2fs_free_node (dirnode, &ext2fs_root->diropen);
 796         return (0);
 797 }
 798
 799
 800 int ext2fs_open (const char *filename) {
 801         ext2fs_node_t fdiro = NULL;
 802         int status;
 803         int len;
 804
 805         if (ext2fs_root == NULL) {
 806                 return (-1);
 807         }
 808         ext2fs_file = NULL;
 809         status = ext2fs_find_file (filename, &ext2fs_root->diropen, &fdiro,
 810                                    FILETYPE_REG);
 811         if (status == 0) {
 812                 goto fail;
 813         }
 814         if (!fdiro->inode_read) {
 815                 status = ext2fs_read_inode (fdiro->data, fdiro->ino,
 816                                             &fdiro->inode);
 817                 if (status == 0) {
 818                         goto fail;
 819                 }
 820         }
 821         len = __le32_to_cpu (fdiro->inode.size);
 822         ext2fs_file = fdiro;
 823         return (len);
 824
 825 fail:
 826         ext2fs_free_node (fdiro, &ext2fs_root->diropen);
 827         return (-1);
 828 }
 829
 830
 831 int ext2fs_close (void
 832         ) {
 833         if ((ext2fs_file != NULL) && (ext2fs_root != NULL)) {
 834                 ext2fs_free_node (ext2fs_file, &ext2fs_root->diropen);
 835                 ext2fs_file = NULL;
 836         }
 837         if (ext2fs_root != NULL) {
 838                 free (ext2fs_root);
 839                 ext2fs_root = NULL;
 840         }
 841         if (indir1_block != NULL) {
 842                 free (indir1_block);
 843                 indir1_block = NULL;
 844                 indir1_size = 0;
 845                 indir1_blkno = -1;
 846         }
 847         if (indir2_block != NULL) {
 848                 free (indir2_block);
 849                 indir2_block = NULL;
 850                 indir2_size = 0;
 851                 indir2_blkno = -1;
 852         }
 853         return (0);
 854 }
 855
 856
 857 int ext2fs_read (char *buf, unsigned len) {
 858         int status;
 859
 860         if (ext2fs_root == NULL) {
 861                 return (0);
 862         }
 863
 864         if (ext2fs_file == NULL) {
 865                 return (0);
 866         }
 867
 868         status = ext2fs_read_file (ext2fs_file, 0, len, buf);
 869         return (status);
 870 }
 871
 872
 873 int ext2fs_mount (unsigned part_length) {
 874         struct ext2_data *data;
 875         int status;
 876
 877         data = malloc (sizeof (struct ext2_data));
 878         if (!data) {
 879                 return (0);
 880         }
 881         /* Read the superblock.  */
 882         status = ext2fs_devread (1 * 2, 0, sizeof (struct ext2_sblock),
 883                                  (char *) &data->sblock);
 884         if (status == 0) {
 885                 goto fail;
 886         }
 887         /* Make sure this is an ext2 filesystem.  */
 888         if (__le16_to_cpu (data->sblock.magic) != EXT2_MAGIC) {
 889                 goto fail;
 890         }
 891         if (__le32_to_cpu(data->sblock.revision_level == 0)) {
 892                 inode_size = 128;
 893         } else {
 894                 inode_size = __le16_to_cpu(data->sblock.inode_size);
 895         }
 896 #ifdef DEBUG
 897         printf("EXT2 rev %d, inode_size %d\n",
 898                         __le32_to_cpu(data->sblock.revision_level), inode_size);
 899 #endif
 900         data->diropen.data = data;
 901         data->diropen.ino = 2;
 902         data->diropen.inode_read = 1;
 903         data->inode = &data->diropen.inode;
 904
 905         status = ext2fs_read_inode (data, 2, data->inode);
 906         if (status == 0) {
 907                 goto fail;
 908         }
 909
 910         ext2fs_root = data;
 911
 912         return (1);
 913
 914 fail:
 915         printf ("Failed to mount ext2 filesystem...\n");
 916         free (data);
 917         ext2fs_root = NULL;
 918         return (0);
 919 }