[thirdparty/e2fsprogs.git] / debugfs / htree.c

/*
 * htree.c --- hash tree routines
 *
 * Copyright (C) 2002 Theodore Ts'o.  This file may be redistributed
 * under the terms of the GNU Public License.
 */

#include "config.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#include <sys/types.h>
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern int optind;
extern char *optarg;
#endif

#include "debugfs.h"
#include "uuid/uuid.h"
#include "e2p/e2p.h"

static FILE *pager;

static void htree_dump_leaf_node(ext2_filsys fs, ext2_ino_t ino,
				 struct ext2_inode *inode,
				 struct ext2_dx_root_info * rootnode,
				 blk64_t blk, char *buf)
{
	errcode_t	errcode;
	struct ext2_dir_entry *dirent;
	int		thislen, col = 0;
	unsigned int	offset = 0;
	char		name[EXT2_NAME_LEN + 1];
	char		tmp[EXT2_NAME_LEN + 16];
	blk64_t		pblk;
	ext2_dirhash_t 	hash, minor_hash;
	unsigned int	rec_len;
	int		hash_alg;

	errcode = ext2fs_bmap2(fs, ino, inode, buf, 0, blk, 0, &pblk);
	if (errcode) {
		com_err("htree_dump_leaf_node", errcode,
			"while mapping logical block %llu\n", blk);
		return;
	}

	printf("Reading directory block %llu, phys %llu\n", blk, pblk);
	errcode = ext2fs_read_dir_block2(current_fs, pblk, buf, 0);
	if (errcode) {
		com_err("htree_dump_leaf_node", errcode,
			"while reading block %llu (%llu)\n",
			blk, pblk);
		return;
	}
	hash_alg = rootnode->hash_version;
	if ((hash_alg <= EXT2_HASH_TEA) &&
	    (fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
		hash_alg += 3;

	while (offset < fs->blocksize) {
		dirent = (struct ext2_dir_entry *) (buf + offset);
		errcode = ext2fs_get_rec_len(fs, dirent, &rec_len);
		if (errcode) {
			com_err("htree_dump_leaf_inode", errcode,
				"while getting rec_len for block %lu",
				(unsigned long) blk);
			return;
		}
		if (((offset + rec_len) > fs->blocksize) ||
		    (rec_len < 8) ||
		    ((rec_len % 4) != 0) ||
		    ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) {
			fprintf(pager, "Corrupted directory block (%llu)!\n",
				blk);
			break;
		}
		thislen = dirent->name_len & 0xFF;
		strncpy(name, dirent->name, thislen);
		name[thislen] = '\0';
		errcode = ext2fs_dirhash(hash_alg, name,
					 thislen, fs->super->s_hash_seed,
					 &hash, &minor_hash);
		if (errcode)
			com_err("htree_dump_leaf_node", errcode,
				"while calculating hash");
		sprintf(tmp, "%u 0x%08x-%08x (%d) %s   ", dirent->inode,
			hash, minor_hash, rec_len, name);
		thislen = strlen(tmp);
		if (col + thislen > 80) {
			fprintf(pager, "\n");
			col = 0;
		}
		fprintf(pager, "%s", tmp);
		col += thislen;
		offset += rec_len;
	}
	fprintf(pager, "\n");
}


static void htree_dump_int_block(ext2_filsys fs, ext2_ino_t ino,
				 struct ext2_inode *inode,
				 struct ext2_dx_root_info * rootnode,
				 blk64_t blk, char *buf, int level);


static void htree_dump_int_node(ext2_filsys fs, ext2_ino_t ino,
				struct ext2_inode *inode,
				struct ext2_dx_root_info * rootnode,
				struct ext2_dx_entry *ent,
				char *buf, int level)
{
	struct ext2_dx_countlimit	limit;
	struct ext2_dx_entry		e;
	int				hash, i;


	limit = *((struct ext2_dx_countlimit *) ent);
	limit.count = ext2fs_le16_to_cpu(limit.count);
	limit.limit = ext2fs_le16_to_cpu(limit.limit);

	fprintf(pager, "Number of entries (count): %d\n", limit.count);
	fprintf(pager, "Number of entries (limit): %d\n", limit.limit);

	for (i=0; i < limit.count; i++) {
		hash = i ? ext2fs_le32_to_cpu(ent[i].hash) : 0;
		fprintf(pager, "Entry #%d: Hash 0x%08x%s, block %u\n", i,
			hash, (hash & 1) ? " (**)" : "",
			ext2fs_le32_to_cpu(ent[i].block));
		}

	fprintf(pager, "\n");

	for (i=0; i < limit.count; i++) {
		e.hash = ext2fs_le32_to_cpu(ent[i].hash);
		e.block = ext2fs_le32_to_cpu(ent[i].block);
		fprintf(pager, "Entry #%d: Hash 0x%08x, block %u\n", i,
		       i ? e.hash : 0, e.block);
		if (level)
			htree_dump_int_block(fs, ino, inode, rootnode,
					     e.block, buf, level-1);
		else
			htree_dump_leaf_node(fs, ino, inode, rootnode,
					     e.block, buf);
	}

	fprintf(pager, "---------------------\n");
}

static void htree_dump_int_block(ext2_filsys fs, ext2_ino_t ino,
				 struct ext2_inode *inode,
				 struct ext2_dx_root_info * rootnode,
				 blk64_t blk, char *buf, int level)
{
	char		*cbuf;
	errcode_t	errcode;
	blk64_t		pblk;

	cbuf = malloc(fs->blocksize);
	if (!cbuf) {
		fprintf(pager, "Couldn't allocate child block.\n");
		return;
	}

	errcode = ext2fs_bmap2(fs, ino, inode, buf, 0, blk, 0, &pblk);
	if (errcode) {
		com_err("htree_dump_int_block", errcode,
			"while mapping logical block %llu\n", blk);
		goto errout;
	}

	errcode = io_channel_read_blk64(current_fs->io, pblk, 1, buf);
	if (errcode) {
		com_err("htree_dump_int_block", errcode,
			"while 	reading block %llu\n", blk);
		goto errout;
	}

	htree_dump_int_node(fs, ino, inode, rootnode,
			    (struct ext2_dx_entry *) (buf+8),
			    cbuf, level);
errout:
	free(cbuf);
}


void do_htree_dump(int argc, char *argv[])
{
	ext2_ino_t	ino;
	struct ext2_inode inode;
	blk64_t		blk;
	char		*buf = NULL;
	struct 		ext2_dx_root_info  *rootnode;
	struct 		ext2_dx_entry *ent;
	struct		ext2_dx_countlimit *limit;
	errcode_t	errcode;

	if (check_fs_open(argv[0]))
		return;

	pager = open_pager();

	if (common_inode_args_process(argc, argv, &ino, 0))
		goto errout;

	if (debugfs_read_inode(ino, &inode, argv[1]))
		goto errout;

	if (!LINUX_S_ISDIR(inode.i_mode)) {
		com_err(argv[0], 0, "Not a directory");
		goto errout;
	}

	if ((inode.i_flags & EXT2_BTREE_FL) == 0) {
		com_err(argv[0], 0, "Not a hash-indexed directory");
		goto errout;
	}

	buf = malloc(2*current_fs->blocksize);
	if (!buf) {
		com_err(argv[0], 0, "Couldn't allocate htree buffer");
		goto errout;
	}

	errcode = ext2fs_bmap2(current_fs, ino, &inode, buf, 0, 0, 0, &blk);
	if (errcode) {
		com_err("do_htree_block", errcode,
			"while mapping logical block 0\n");
		goto errout;
	}

	errcode = io_channel_read_blk64(current_fs->io, blk,
					1, buf);
	if (errcode) {
		com_err(argv[0], errcode, "Error reading root node");
		goto errout;
	}

	rootnode = (struct ext2_dx_root_info *) (buf + 24);

	fprintf(pager, "Root node dump:\n");
	fprintf(pager, "\t Reserved zero: %u\n", rootnode->reserved_zero);
	fprintf(pager, "\t Hash Version: %d\n", rootnode->hash_version);
	fprintf(pager, "\t Info length: %d\n", rootnode->info_length);
	fprintf(pager, "\t Indirect levels: %d\n", rootnode->indirect_levels);
	fprintf(pager, "\t Flags: %d\n", rootnode->unused_flags);

	ent = (struct ext2_dx_entry *) (buf + 24 + rootnode->info_length);
	limit = (struct ext2_dx_countlimit *) ent;

	htree_dump_int_node(current_fs, ino, &inode, rootnode, ent,
			    buf + current_fs->blocksize,
			    rootnode->indirect_levels);

errout:
	free(buf);
	close_pager(pager);
}

/*
 * This function prints the hash of a given file.
 */
void do_dx_hash(int argc, char *argv[])
{
	ext2_dirhash_t hash, minor_hash;
	errcode_t	err;
	int		c;
	int		hash_version = 0;
	__u32		hash_seed[4];

	hash_seed[0] = hash_seed[1] = hash_seed[2] = hash_seed[3] = 0;

	reset_getopt();
	while ((c = getopt (argc, argv, "h:s:")) != EOF) {
		switch (c) {
		case 'h':
			hash_version = e2p_string2hash(optarg);
			if (hash_version < 0)
				hash_version = atoi(optarg);
			break;
		case 's':
			if (uuid_parse(optarg, (unsigned char *) hash_seed)) {
				fprintf(stderr, "Invalid UUID format: %s\n",
					optarg);
				return;
			}
			break;
		default:
			goto print_usage;
		}
	}
	if (optind != argc-1) {
	print_usage:
		com_err(argv[0], 0, "usage: dx_hash [-h hash_alg] "
			"[-s hash_seed] filename");
		return;
	}
	err = ext2fs_dirhash(hash_version, argv[optind], strlen(argv[optind]),
			     hash_seed, &hash, &minor_hash);
	if (err) {
		com_err(argv[0], err, "while caclulating hash");
		return;
	}
	printf("Hash of %s is 0x%0x (minor 0x%0x)\n", argv[optind],
	       hash, minor_hash);
}

/*
 * Search for particular directory entry (useful for debugging very
 * large hash tree directories that have lost some blocks from the
 * btree index).
 */
struct process_block_struct {
	char	*search_name;
	char	*buf;
	int	len;
};

static int search_dir_block(ext2_filsys fs, blk64_t *blocknr,
			    e2_blkcnt_t blockcnt, blk64_t ref_blk,
			    int ref_offset, void *priv_data);

void do_dirsearch(int argc, char *argv[])
{
	ext2_ino_t	inode;
	struct process_block_struct pb;

	if (check_fs_open(argv[0]))
		return;

	if (argc != 3) {
		com_err(0, 0, "Usage: dirsearch dir filename");
		return;
	}

	inode = string_to_inode(argv[1]);
	if (!inode)
		return;

	pb.buf = malloc(current_fs->blocksize);
	if (!pb.buf) {
		com_err("dirsearch", 0, "Couldn't allocate buffer");
		return;
	}
	pb.search_name = argv[2];
	pb.len = strlen(pb.search_name);

	ext2fs_block_iterate3(current_fs, inode, BLOCK_FLAG_READ_ONLY, 0,
			      search_dir_block, &pb);

	free(pb.buf);
}


static int search_dir_block(ext2_filsys fs, blk64_t *blocknr,
			    e2_blkcnt_t blockcnt,
			    blk64_t ref_blk EXT2FS_ATTR((unused)),
			    int ref_offset EXT2FS_ATTR((unused)),
			    void *priv_data)
{
	struct process_block_struct *p;
	struct ext2_dir_entry *dirent;
	errcode_t	       	errcode;
	unsigned int		offset = 0;
	unsigned int		rec_len;

	if (blockcnt < 0)
		return 0;

	p = (struct process_block_struct *) priv_data;

	errcode = io_channel_read_blk64(current_fs->io, *blocknr, 1, p->buf);
	if (errcode) {
		com_err("search_dir_block", errcode,
			"while reading block %lu", (unsigned long) *blocknr);
		return BLOCK_ABORT;
	}

	while (offset < fs->blocksize) {
		dirent = (struct ext2_dir_entry *) (p->buf + offset);
		errcode = ext2fs_get_rec_len(fs, dirent, &rec_len);
		if (errcode) {
			com_err("htree_dump_leaf_inode", errcode,
				"while getting rec_len for block %lu",
				(unsigned long) *blocknr);
			return BLOCK_ABORT;
		}
		if (dirent->inode &&
		    p->len == (dirent->name_len & 0xFF) &&
		    strncmp(p->search_name, dirent->name,
			    p->len) == 0) {
			printf("Entry found at logical block %lld, "
			       "phys %llu, offset %u\n", (long long)blockcnt,
			       *blocknr, offset);
			printf("offset %u\n", offset);
			return BLOCK_ABORT;
		}
		offset += rec_len;
	}
	return 0;
}
Commit	Line	Data
df614db6 TT	1	/*
df614db6 TT	2	* htree.c --- hash tree routines
efc6f628	3	*
df614db6 TT	4	* Copyright (C) 2002 Theodore Ts'o. This file may be redistributed
	5	* under the terms of the GNU Public License.
	6	*/
	7
d1154eb4	8	#include "config.h"
df614db6 TT	9	#include <stdio.h>
	10	#include <unistd.h>
	11	#include <stdlib.h>
	12	#include <ctype.h>
	13	#include <string.h>
	14	#include <time.h>
	15	#ifdef HAVE_ERRNO_H
	16	#include <errno.h>
	17	#endif
	18	#include <sys/types.h>
	19	#ifdef HAVE_GETOPT_H
	20	#include <getopt.h>
efc6f628	21	#else
df614db6 TT	22	extern int optind;
	23	extern char *optarg;
	24	#endif
df614db6 TT	25
df614db6 TT	26	#include "debugfs.h"
42080a86 TT	27	#include "uuid/uuid.h"
42080a86 TT	28	#include "e2p/e2p.h"
df614db6 TT	29
	30	static FILE *pager;
	31
df614db6 TT	32	static void htree_dump_leaf_node(ext2_filsys fs, ext2_ino_t ino,
df614db6 TT	33	struct ext2_inode *inode,
3e699064	34	struct ext2_dx_root_info * rootnode,
048786d7	35	blk64_t blk, char *buf)
df614db6 TT	36	{
	37	errcode_t errcode;
	38	struct ext2_dir_entry *dirent;
54434927 TT	39	int thislen, col = 0;
54434927 TT	40	unsigned int offset = 0;
b772900b	41	char name[EXT2_NAME_LEN + 1];
df614db6	42	char tmp[EXT2_NAME_LEN + 16];
048786d7	43	blk64_t pblk;
226515df	44	ext2_dirhash_t hash, minor_hash;
8a480350 TT	45	unsigned int rec_len;
8a480350 TT	46	int hash_alg;
efc6f628	47
048786d7	48	errcode = ext2fs_bmap2(fs, ino, inode, buf, 0, blk, 0, &pblk);
df614db6 TT	49	if (errcode) {
df614db6 TT	50	com_err("htree_dump_leaf_node", errcode,
048786d7	51	"while mapping logical block %llu\n", blk);
df614db6 TT	52	return;
	53	}
	54
048786d7	55	printf("Reading directory block %llu, phys %llu\n", blk, pblk);
8132d840	56	errcode = ext2fs_read_dir_block2(current_fs, pblk, buf, 0);
df614db6 TT	57	if (errcode) {
df614db6 TT	58	com_err("htree_dump_leaf_node", errcode,
048786d7 VAH	59	"while reading block %llu (%llu)\n",
048786d7 VAH	60	blk, pblk);
df614db6 TT	61	return;
df614db6 TT	62	}
f77704e4 TT	63	hash_alg = rootnode->hash_version;
	64	if ((hash_alg <= EXT2_HASH_TEA) &&
	65	(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
	66	hash_alg += 3;
df614db6 TT	67
	68	while (offset < fs->blocksize) {
	69	dirent = (struct ext2_dir_entry *) (buf + offset);
8a480350 TT	70	errcode = ext2fs_get_rec_len(fs, dirent, &rec_len);
	71	if (errcode) {
	72	com_err("htree_dump_leaf_inode", errcode,
	73	"while getting rec_len for block %lu",
	74	(unsigned long) blk);
	75	return;
	76	}
5dd77dbe TT	77	if (((offset + rec_len) > fs->blocksize) \|\|
	78	(rec_len < 8) \|\|
	79	((rec_len % 4) != 0) \|\|
42080a86	80	((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) {
048786d7 VAH	81	fprintf(pager, "Corrupted directory block (%llu)!\n",
048786d7 VAH	82	blk);
df614db6 TT	83	break;
df614db6 TT	84	}
11ba79b3	85	thislen = dirent->name_len & 0xFF;
df614db6 TT	86	strncpy(name, dirent->name, thislen);
df614db6 TT	87	name[thislen] = '\0';
f77704e4	88	errcode = ext2fs_dirhash(hash_alg, name,
3e699064	89	thislen, fs->super->s_hash_seed,
226515df	90	&hash, &minor_hash);
52783e0c TT	91	if (errcode)
	92	com_err("htree_dump_leaf_node", errcode,
	93	"while calculating hash");
226515df	94	sprintf(tmp, "%u 0x%08x-%08x (%d) %s ", dirent->inode,
5dd77dbe	95	hash, minor_hash, rec_len, name);
df614db6 TT	96	thislen = strlen(tmp);
	97	if (col + thislen > 80) {
	98	fprintf(pager, "\n");
	99	col = 0;
	100	}
	101	fprintf(pager, "%s", tmp);
	102	col += thislen;
5dd77dbe	103	offset += rec_len;
df614db6 TT	104	}
	105	fprintf(pager, "\n");
	106	}
	107
	108
	109	static void htree_dump_int_block(ext2_filsys fs, ext2_ino_t ino,
	110	struct ext2_inode *inode,
3e699064	111	struct ext2_dx_root_info * rootnode,
048786d7	112	blk64_t blk, char *buf, int level);
df614db6 TT	113
	114
	115	static void htree_dump_int_node(ext2_filsys fs, ext2_ino_t ino,
	116	struct ext2_inode *inode,
3e699064	117	struct ext2_dx_root_info * rootnode,
efc6f628	118	struct ext2_dx_entry *ent,
df614db6 TT	119	char *buf, int level)
df614db6 TT	120	{
621732c9 TT	121	struct ext2_dx_countlimit limit;
621732c9 TT	122	struct ext2_dx_entry e;
42e5b5f9	123	int hash, i;
efc6f628	124
df614db6	125
621732c9 TT	126	limit = ((struct ext2_dx_countlimit ) ent);
	127	limit.count = ext2fs_le16_to_cpu(limit.count);
	128	limit.limit = ext2fs_le16_to_cpu(limit.limit);
df614db6	129
621732c9 TT	130	fprintf(pager, "Number of entries (count): %d\n", limit.count);
621732c9 TT	131	fprintf(pager, "Number of entries (limit): %d\n", limit.limit);
df614db6	132
42e5b5f9 TT	133	for (i=0; i < limit.count; i++) {
42e5b5f9 TT	134	hash = i ? ext2fs_le32_to_cpu(ent[i].hash) : 0;
d0ff90d5	135	fprintf(pager, "Entry #%d: Hash 0x%08x%s, block %u\n", i,
42e5b5f9	136	hash, (hash & 1) ? " (**)" : "",
621732c9	137	ext2fs_le32_to_cpu(ent[i].block));
42e5b5f9	138	}
df614db6 TT	139
	140	fprintf(pager, "\n");
	141
621732c9 TT	142	for (i=0; i < limit.count; i++) {
	143	e.hash = ext2fs_le32_to_cpu(ent[i].hash);
	144	e.block = ext2fs_le32_to_cpu(ent[i].block);
8deb80a5	145	fprintf(pager, "Entry #%d: Hash 0x%08x, block %u\n", i,
621732c9	146	i ? e.hash : 0, e.block);
df614db6	147	if (level)
3e699064	148	htree_dump_int_block(fs, ino, inode, rootnode,
621732c9	149	e.block, buf, level-1);
df614db6	150	else
3e699064	151	htree_dump_leaf_node(fs, ino, inode, rootnode,
621732c9	152	e.block, buf);
df614db6 TT	153	}
	154
	155	fprintf(pager, "---------------------\n");
	156	}
	157
	158	static void htree_dump_int_block(ext2_filsys fs, ext2_ino_t ino,
	159	struct ext2_inode *inode,
3e699064	160	struct ext2_dx_root_info * rootnode,
048786d7	161	blk64_t blk, char *buf, int level)
df614db6 TT	162	{
	163	char *cbuf;
	164	errcode_t errcode;
048786d7	165	blk64_t pblk;
df614db6 TT	166
	167	cbuf = malloc(fs->blocksize);
	168	if (!cbuf) {
	169	fprintf(pager, "Couldn't allocate child block.\n");
	170	return;
	171	}
efc6f628	172
048786d7	173	errcode = ext2fs_bmap2(fs, ino, inode, buf, 0, blk, 0, &pblk);
df614db6 TT	174	if (errcode) {
df614db6 TT	175	com_err("htree_dump_int_block", errcode,
048786d7	176	"while mapping logical block %llu\n", blk);
89456558	177	goto errout;
df614db6 TT	178	}
df614db6 TT	179
24a117ab	180	errcode = io_channel_read_blk64(current_fs->io, pblk, 1, buf);
df614db6 TT	181	if (errcode) {
df614db6 TT	182	com_err("htree_dump_int_block", errcode,
048786d7	183	"while reading block %llu\n", blk);
89456558	184	goto errout;
df614db6 TT	185	}
df614db6 TT	186
3e699064	187	htree_dump_int_node(fs, ino, inode, rootnode,
503f9e7f	188	(struct ext2_dx_entry *) (buf+8),
df614db6	189	cbuf, level);
89456558	190	errout:
df614db6 TT	191	free(cbuf);
	192	}
	193
	194
	195
	196	void do_htree_dump(int argc, char *argv[])
	197	{
	198	ext2_ino_t ino;
	199	struct ext2_inode inode;
048786d7	200	blk64_t blk;
3e699064 TT	201	char *buf = NULL;
3e699064 TT	202	struct ext2_dx_root_info *rootnode;
df614db6 TT	203	struct ext2_dx_entry *ent;
	204	struct ext2_dx_countlimit *limit;
	205	errcode_t errcode;
	206
	207	if (check_fs_open(argv[0]))
	208	return;
	209
	210	pager = open_pager();
	211
1ec5d104	212	if (common_inode_args_process(argc, argv, &ino, 0))
155f577b	213	goto errout;
df614db6 TT	214
df614db6 TT	215	if (debugfs_read_inode(ino, &inode, argv[1]))
155f577b	216	goto errout;
df614db6 TT	217
	218	if (!LINUX_S_ISDIR(inode.i_mode)) {
	219	com_err(argv[0], 0, "Not a directory");
155f577b	220	goto errout;
df614db6	221	}
efc6f628	222
df614db6 TT	223	if ((inode.i_flags & EXT2_BTREE_FL) == 0) {
df614db6 TT	224	com_err(argv[0], 0, "Not a hash-indexed directory");
155f577b	225	goto errout;
df614db6 TT	226	}
	227
	228	buf = malloc(2*current_fs->blocksize);
	229	if (!buf) {
	230	com_err(argv[0], 0, "Couldn't allocate htree buffer");
155f577b	231	goto errout;
df614db6 TT	232	}
df614db6 TT	233
048786d7	234	errcode = ext2fs_bmap2(current_fs, ino, &inode, buf, 0, 0, 0, &blk);
226515df TT	235	if (errcode) {
	236	com_err("do_htree_block", errcode,
	237	"while mapping logical block 0\n");
	238	goto errout;
	239	}
	240
24a117ab VAH	241	errcode = io_channel_read_blk64(current_fs->io, blk,
24a117ab VAH	242	1, buf);
df614db6 TT	243	if (errcode) {
	244	com_err(argv[0], errcode, "Error reading root node");
	245	goto errout;
	246	}
	247
3e699064	248	rootnode = (struct ext2_dx_root_info *) (buf + 24);
df614db6 TT	249
df614db6 TT	250	fprintf(pager, "Root node dump:\n");
8deb80a5	251	fprintf(pager, "\t Reserved zero: %u\n", rootnode->reserved_zero);
3e699064 TT	252	fprintf(pager, "\t Hash Version: %d\n", rootnode->hash_version);
	253	fprintf(pager, "\t Info length: %d\n", rootnode->info_length);
	254	fprintf(pager, "\t Indirect levels: %d\n", rootnode->indirect_levels);
	255	fprintf(pager, "\t Flags: %d\n", rootnode->unused_flags);
df614db6	256
3e699064	257	ent = (struct ext2_dx_entry *) (buf + 24 + rootnode->info_length);
df614db6 TT	258	limit = (struct ext2_dx_countlimit *) ent;
df614db6 TT	259
3e699064	260	htree_dump_int_node(current_fs, ino, &inode, rootnode, ent,
df614db6	261	buf + current_fs->blocksize,
3e699064	262	rootnode->indirect_levels);
df614db6 TT	263
df614db6 TT	264	errout:
45e338f5	265	free(buf);
df614db6 TT	266	close_pager(pager);
	267	}
	268
	269	/*
	270	* This function prints the hash of a given file.
	271	*/
	272	void do_dx_hash(int argc, char *argv[])
	273	{
503f9e7f	274	ext2_dirhash_t hash, minor_hash;
52783e0c	275	errcode_t err;
503f9e7f TT	276	int c;
	277	int hash_version = 0;
	278	__u32 hash_seed[4];
efc6f628	279
503f9e7f	280	hash_seed[0] = hash_seed[1] = hash_seed[2] = hash_seed[3] = 0;
88494bb6 TT	281
88494bb6 TT	282	reset_getopt();
f8bd5516	283	while ((c = getopt (argc, argv, "h:s:")) != EOF) {
503f9e7f TT	284	switch (c) {
503f9e7f TT	285	case 'h':
f8bd5516 TT	286	hash_version = e2p_string2hash(optarg);
	287	if (hash_version < 0)
	288	hash_version = atoi(optarg);
	289	break;
	290	case 's':
42080a86	291	if (uuid_parse(optarg, (unsigned char *) hash_seed)) {
f8bd5516 TT	292	fprintf(stderr, "Invalid UUID format: %s\n",
	293	optarg);
	294	return;
	295	}
503f9e7f	296	break;
49c6b4e9 TT	297	default:
49c6b4e9 TT	298	goto print_usage;
503f9e7f TT	299	}
	300	}
	301	if (optind != argc-1) {
49c6b4e9	302	print_usage:
f8bd5516 TT	303	com_err(argv[0], 0, "usage: dx_hash [-h hash_alg] "
f8bd5516 TT	304	"[-s hash_seed] filename");
df614db6 TT	305	return;
df614db6 TT	306	}
503f9e7f TT	307	err = ext2fs_dirhash(hash_version, argv[optind], strlen(argv[optind]),
503f9e7f TT	308	hash_seed, &hash, &minor_hash);
52783e0c TT	309	if (err) {
	310	com_err(argv[0], err, "while caclulating hash");
	311	return;
	312	}
503f9e7f TT	313	printf("Hash of %s is 0x%0x (minor 0x%0x)\n", argv[optind],
503f9e7f TT	314	hash, minor_hash);
df614db6 TT	315	}
	316
	317	/*
	318	* Search for particular directory entry (useful for debugging very
	319	* large hash tree directories that have lost some blocks from the
	320	* btree index).
	321	*/
	322	struct process_block_struct {
	323	char *search_name;
	324	char *buf;
	325	int len;
	326	};
	327
048786d7 VAH	328	static int search_dir_block(ext2_filsys fs, blk64_t *blocknr,
048786d7 VAH	329	e2_blkcnt_t blockcnt, blk64_t ref_blk,
df614db6 TT	330	int ref_offset, void *priv_data);
	331
	332	void do_dirsearch(int argc, char *argv[])
	333	{
	334	ext2_ino_t inode;
df614db6	335	struct process_block_struct pb;
efc6f628	336
df614db6 TT	337	if (check_fs_open(argv[0]))
	338	return;
	339
	340	if (argc != 3) {
	341	com_err(0, 0, "Usage: dirsearch dir filename");
	342	return;
	343	}
	344
	345	inode = string_to_inode(argv[1]);
	346	if (!inode)
	347	return;
	348
	349	pb.buf = malloc(current_fs->blocksize);
	350	if (!pb.buf) {
	351	com_err("dirsearch", 0, "Couldn't allocate buffer");
	352	return;
	353	}
	354	pb.search_name = argv[2];
	355	pb.len = strlen(pb.search_name);
efc6f628	356
048786d7	357	ext2fs_block_iterate3(current_fs, inode, BLOCK_FLAG_READ_ONLY, 0,
43323be9	358	search_dir_block, &pb);
df614db6 TT	359
	360	free(pb.buf);
	361	}
	362
	363
048786d7	364	static int search_dir_block(ext2_filsys fs, blk64_t *blocknr,
efc6f628	365	e2_blkcnt_t blockcnt,
048786d7	366	blk64_t ref_blk EXT2FS_ATTR((unused)),
54434927 TT	367	int ref_offset EXT2FS_ATTR((unused)),
54434927 TT	368	void *priv_data)
df614db6 TT	369	{
	370	struct process_block_struct *p;
	371	struct ext2_dir_entry *dirent;
	372	errcode_t errcode;
54434927	373	unsigned int offset = 0;
8a480350	374	unsigned int rec_len;
df614db6 TT	375
	376	if (blockcnt < 0)
	377	return 0;
	378
	379	p = (struct process_block_struct *) priv_data;
	380
24a117ab	381	errcode = io_channel_read_blk64(current_fs->io, *blocknr, 1, p->buf);
df614db6 TT	382	if (errcode) {
df614db6 TT	383	com_err("search_dir_block", errcode,
54434927	384	"while reading block %lu", (unsigned long) *blocknr);
df614db6 TT	385	return BLOCK_ABORT;
	386	}
	387
	388	while (offset < fs->blocksize) {
	389	dirent = (struct ext2_dir_entry *) (p->buf + offset);
8a480350 TT	390	errcode = ext2fs_get_rec_len(fs, dirent, &rec_len);
	391	if (errcode) {
	392	com_err("htree_dump_leaf_inode", errcode,
	393	"while getting rec_len for block %lu",
	394	(unsigned long) *blocknr);
42080a86	395	return BLOCK_ABORT;
8a480350	396	}
df614db6	397	if (dirent->inode &&
efc6f628	398	p->len == (dirent->name_len & 0xFF) &&
df614db6 TT	399	strncmp(p->search_name, dirent->name,
	400	p->len) == 0) {
	401	printf("Entry found at logical block %lld, "
048786d7	402	"phys %llu, offset %u\n", (long long)blockcnt,
df614db6	403	*blocknr, offset);
8deb80a5	404	printf("offset %u\n", offset);
df614db6 TT	405	return BLOCK_ABORT;
df614db6 TT	406	}
5dd77dbe	407	offset += rec_len;
df614db6 TT	408	}
	409	return 0;
	410	}
	411