debugfs: add filefrag command

[tools/e2fsprogs.git] / lib / ext2fs / dir_iterate.c

diff --git a/lib/ext2fs/dir_iterate.c b/lib/ext2fs/dir_iterate.c
index 1f8cf8f..5125d19 100644 (file)
--- a/lib/ext2fs/dir_iterate.c
+++ b/lib/ext2fs/dir_iterate.c
@@ -4,11 +4,12 @@
  * Copyright (C) 1993, 1994, 1994, 1995, 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
+ * This file may be redistributed under the terms of the GNU Library
+ * General Public License, version 2.
  * %End-Header%
  */
 
+#include "config.h"
 #include <stdio.h>
 #include <string.h>
 #if HAVE_UNISTD_H
@@ -21,6 +22,43 @@
 #include "ext2_fs.h"
 #include "ext2fsP.h"
 
+#define EXT4_MAX_REC_LEN               ((1<<16)-1)
+
+errcode_t ext2fs_get_rec_len(ext2_filsys fs,
+                            struct ext2_dir_entry *dirent,
+                            unsigned int *rec_len)
+{
+       unsigned int len = dirent->rec_len;
+
+       if (fs->blocksize < 65536)
+               *rec_len = len;
+       else if (len == EXT4_MAX_REC_LEN || len == 0)
+               *rec_len = fs->blocksize;
+       else 
+               *rec_len = (len & 65532) | ((len & 3) << 16);
+       return 0;
+}
+
+errcode_t ext2fs_set_rec_len(ext2_filsys fs,
+                            unsigned int len,
+                            struct ext2_dir_entry *dirent)
+{
+       if ((len > fs->blocksize) || (fs->blocksize > (1 << 18)) || (len & 3))
+               return EINVAL;
+       if (len < 65536) {
+               dirent->rec_len = len;
+               return 0;
+       }
+       if (len == fs->blocksize) {
+               if (fs->blocksize == 65536)
+                       dirent->rec_len = EXT4_MAX_REC_LEN;
+               else 
+                       dirent->rec_len = 0;
+       } else
+               dirent->rec_len = (len & 65532) | ((len >> 16) & 3);
+       return 0;
+}
+
 /*
  * This function checks to see whether or not a potential deleted
  * directory entry looks valid.  What we do is check the deleted entry
@@ -29,20 +67,23 @@
  * undeleted entry.  Returns 1 if the deleted entry looks valid, zero
  * if not valid.
  */
-static int ext2fs_validate_entry(ext2_filsys fs, char *buf, int offset,
-                                int final_offset)
+static int ext2fs_validate_entry(ext2_filsys fs, char *buf,
+                                unsigned int offset,
+                                unsigned int final_offset)
 {
        struct ext2_dir_entry *dirent;
-       int     rec_len;
+       unsigned int rec_len;
+#define DIRENT_MIN_LENGTH 12
 
-       while (offset < final_offset) {
+       while ((offset < final_offset) &&
+              (offset <= fs->blocksize - DIRENT_MIN_LENGTH)) {
                dirent = (struct ext2_dir_entry *)(buf + offset);
-               rec_len = (dirent->rec_len || fs->blocksize < 65536) ?
-                       dirent->rec_len : 65536;
+               if (ext2fs_get_rec_len(fs, dirent, &rec_len))
+                       return 0;
                offset += rec_len;
                if ((rec_len < 8) ||
                    ((rec_len % 4) != 0) ||
-                   (((dirent->name_len & 0xFF)+8) > rec_len))
+                   ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len))
                        return 0;
        }
        return (offset == final_offset);
@@ -82,7 +123,7 @@ errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
        ctx.func = func;
        ctx.priv_data = priv_data;
        ctx.errcode = 0;
-       retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_READ_ONLY, 0,
+       retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY, 0,
                                       ext2fs_process_dir_block, &ctx);
        if (!block_buf)
                ext2fs_free_mem(&ctx.buf);
@@ -136,9 +177,9 @@ extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
  * ext2fs_dir_iterate() and ext2fs_dblist_dir_iterate()
  */
 int ext2fs_process_dir_block(ext2_filsys fs,
-                            blk_t      *blocknr,
+                            blk64_t    *blocknr,
                             e2_blkcnt_t blockcnt,
-                            blk_t      ref_block EXT2FS_ATTR((unused)),
+                            blk64_t    ref_block EXT2FS_ATTR((unused)),
                             int        ref_offset EXT2FS_ATTR((unused)),
                             void       *priv_data)
 {
@@ -148,7 +189,8 @@ int ext2fs_process_dir_block(ext2_filsys fs,
        int             ret = 0;
        int             changed = 0;
        int             do_abort = 0;
-       int             rec_len, entry, size;
+       unsigned int    rec_len, size;
+       int             entry;
        struct ext2_dir_entry *dirent;
 
        if (blockcnt < 0)
@@ -156,18 +198,18 @@ int ext2fs_process_dir_block(ext2_filsys fs,
 
        entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE;
 
-       ctx->errcode = ext2fs_read_dir_block(fs, *blocknr, ctx->buf);
+       ctx->errcode = ext2fs_read_dir_block3(fs, *blocknr, ctx->buf, 0);
        if (ctx->errcode)
                return BLOCK_ABORT;
 
        while (offset < fs->blocksize) {
                dirent = (struct ext2_dir_entry *) (ctx->buf + offset);
-               rec_len = (dirent->rec_len || fs->blocksize < 65536) ?
-                       dirent->rec_len : 65536;
+               if (ext2fs_get_rec_len(fs, dirent, &rec_len))
+                       return BLOCK_ABORT;
                if (((offset + rec_len) > fs->blocksize) ||
                    (rec_len < 8) ||
                    ((rec_len % 4) != 0) ||
-                   (((dirent->name_len & 0xFF)+8) > rec_len)) {
+                   ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) {
                        ctx->errcode = EXT2_ET_DIR_CORRUPTED;
                        return BLOCK_ABORT;
                }
@@ -185,8 +227,8 @@ int ext2fs_process_dir_block(ext2_filsys fs,
                        entry++;
 
                if (ret & DIRENT_CHANGED) {
-                       rec_len = (dirent->rec_len || fs->blocksize < 65536) ?
-                               dirent->rec_len : 65536;
+                       if (ext2fs_get_rec_len(fs, dirent, &rec_len))
+                               return BLOCK_ABORT;
                        changed++;
                }
                if (ret & DIRENT_ABORT) {
@@ -217,7 +259,8 @@ next:
        }
 
        if (changed) {
-               ctx->errcode = ext2fs_write_dir_block(fs, *blocknr, ctx->buf);
+               ctx->errcode = ext2fs_write_dir_block3(fs, *blocknr, ctx->buf,
+                                                      0);
                if (ctx->errcode)
                        return BLOCK_ABORT;
        }