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

/*
 * dump.c --- dump the contents of an inode out to a file
 *
 * Copyright (C) 1994 Theodore Ts'o.  This file may be redistributed
 * under the terms of the GNU Public License.
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* for O_LARGEFILE */
#endif

#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>
#include <sys/stat.h>
#include <fcntl.h>
#include <utime.h>
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern int optind;
extern char *optarg;
#endif

#include "debugfs.h"

#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif

/*
 * The mode_xlate function translates a linux mode into a native-OS mode_t.
 */
static struct {
	__u16 lmask;
	mode_t mask;
} mode_table[] = {
	{ LINUX_S_IRUSR, S_IRUSR },
	{ LINUX_S_IWUSR, S_IWUSR },
	{ LINUX_S_IXUSR, S_IXUSR },
	{ LINUX_S_IRGRP, S_IRGRP },
	{ LINUX_S_IWGRP, S_IWGRP },
	{ LINUX_S_IXGRP, S_IXGRP },
	{ LINUX_S_IROTH, S_IROTH },
	{ LINUX_S_IWOTH, S_IWOTH },
	{ LINUX_S_IXOTH, S_IXOTH },
	{ 0, 0 }
};

static mode_t mode_xlate(__u16 lmode)
{
	mode_t	mode = 0;
	int	i;

	for (i=0; mode_table[i].lmask; i++) {
		if (lmode & mode_table[i].lmask)
			mode |= mode_table[i].mask;
	}
	return mode;
}

static void fix_perms(const char *cmd, const struct ext2_inode *inode,
		      int fd, const char *name)
{
	struct utimbuf ut;
	int i;

	if (fd != -1)
		i = fchmod(fd, mode_xlate(inode->i_mode));
	else
		i = chmod(name, mode_xlate(inode->i_mode));
	if (i == -1)
		com_err(cmd, errno, "while setting permissions of %s", name);

#ifndef HAVE_FCHOWN
	i = chown(name, inode->i_uid, inode->i_gid);
#else
	if (fd != -1)
		i = fchown(fd, inode->i_uid, inode->i_gid);
	else
		i = chown(name, inode->i_uid, inode->i_gid);
#endif
	if (i == -1)
		com_err(cmd, errno, "while changing ownership of %s", name);

	ut.actime = inode->i_atime;
	ut.modtime = inode->i_mtime;
	if (utime(name, &ut) == -1)
		com_err(cmd, errno, "while setting times of %s", name);
}

static void dump_file(const char *cmdname, ext2_ino_t ino, int fd,
		      int preserve, char *outname)
{
	errcode_t retval;
	struct ext2_inode	inode;
	char		*buf = 0;
	ext2_file_t	e2_file;
	int		nbytes;
	unsigned int	got, blocksize = current_fs->blocksize;

	if (debugfs_read_inode(ino, &inode, cmdname))
		return;

	retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
	if (retval) {
		com_err(cmdname, retval, "while opening ext2 file");
		return;
	}
	retval = ext2fs_get_mem(blocksize, &buf);
	if (retval) {
		com_err(cmdname, retval, "while allocating memory");
		return;
	}
	while (1) {
		retval = ext2fs_file_read(e2_file, buf, blocksize, &got);
		if (retval)
			com_err(cmdname, retval, "while reading ext2 file");
		if (got == 0)
			break;
		nbytes = write(fd, buf, got);
		if ((unsigned) nbytes != got)
			com_err(cmdname, errno, "while writing file");
	}
	if (buf)
		ext2fs_free_mem(&buf);
	retval = ext2fs_file_close(e2_file);
	if (retval) {
		com_err(cmdname, retval, "while closing ext2 file");
		return;
	}

	if (preserve)
		fix_perms("dump_file", &inode, fd, outname);

	return;
}

void do_dump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
	     void *infop EXT2FS_ATTR((unused)))
{
	ext2_ino_t	inode;
	int		fd;
	int		c;
	int		preserve = 0;
	char		*in_fn, *out_fn;

	reset_getopt();
	while ((c = getopt (argc, argv, "p")) != EOF) {
		switch (c) {
		case 'p':
			preserve++;
			break;
		default:
		print_usage:
			com_err(argv[0], 0, "Usage: dump_inode [-p] "
				"<file> <output_file>");
			return;
		}
	}
	if (optind != argc-2)
		goto print_usage;

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

	in_fn = argv[optind];
	out_fn = argv[optind+1];

	inode = string_to_inode(in_fn);
	if (!inode)
		return;

	fd = open(out_fn, O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE, 0666);
	if (fd < 0) {
		com_err(argv[0], errno, "while opening %s for dump_inode",
			out_fn);
		return;
	}

	dump_file(argv[0], inode, fd, preserve, out_fn);
	if (close(fd) != 0) {
		com_err(argv[0], errno, "while closing %s for dump_inode",
			out_fn);
		return;
	}

	return;
}

static void rdump_symlink(ext2_ino_t ino, struct ext2_inode *inode,
			  const char *fullname)
{
	ext2_file_t e2_file;
	char *buf;
	errcode_t retval;

	buf = malloc(inode->i_size + 1);
	if (!buf) {
		com_err("rdump", errno, "while allocating for symlink");
		goto errout;
	}

	if (ext2fs_is_fast_symlink(inode))
		strcpy(buf, (char *) inode->i_block);
	else {
		unsigned bytes = inode->i_size;
		char *p = buf;
		retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
		if (retval) {
			com_err("rdump", retval, "while opening symlink");
			goto errout;
		}
		for (;;) {
			unsigned int got;
			retval = ext2fs_file_read(e2_file, p, bytes, &got);
			if (retval) {
				com_err("rdump", retval, "while reading symlink");
				goto errout;
			}
			bytes -= got;
			p += got;
			if (got == 0 || bytes == 0)
				break;
		}
		buf[inode->i_size] = 0;
		retval = ext2fs_file_close(e2_file);
		if (retval)
			com_err("rdump", retval, "while closing symlink");
	}

	if (symlink(buf, fullname) == -1) {
		com_err("rdump", errno, "while creating symlink %s -> %s", buf, fullname);
		goto errout;
	}

errout:
	free(buf);
}

static int rdump_dirent(struct ext2_dir_entry *, int, int, char *, void *);

static void rdump_inode(ext2_ino_t ino, struct ext2_inode *inode,
			const char *name, const char *dumproot)
{
	char *fullname;

	/* There are more efficient ways to do this, but this method
	 * requires only minimal debugging. */
	fullname = malloc(strlen(dumproot) + strlen(name) + 2);
	if (!fullname) {
		com_err("rdump", errno, "while allocating memory");
		return;
	}
	sprintf(fullname, "%s/%s", dumproot, name);

	if (LINUX_S_ISLNK(inode->i_mode))
		rdump_symlink(ino, inode, fullname);
	else if (LINUX_S_ISREG(inode->i_mode)) {
		int fd;
		fd = open(fullname, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, S_IRWXU);
		if (fd == -1) {
			com_err("rdump", errno, "while opening %s", fullname);
			goto errout;
		}
		dump_file("rdump", ino, fd, 1, fullname);
		if (close(fd) != 0) {
			com_err("rdump", errno, "while closing %s", fullname);
			goto errout;
		}
	}
	else if (LINUX_S_ISDIR(inode->i_mode) && strcmp(name, ".") && strcmp(name, "..")) {
		errcode_t retval;

		/* Create the directory with 0700 permissions, because we
		 * expect to have to create entries it.  Then fix its perms
		 * once we've done the traversal. */
		if (name[0] && mkdir(fullname, S_IRWXU) == -1) {
			com_err("rdump", errno, "while making directory %s", fullname);
			goto errout;
		}

		retval = ext2fs_dir_iterate(current_fs, ino, 0, 0,
					    rdump_dirent, (void *) fullname);
		if (retval)
			com_err("rdump", retval, "while dumping %s", fullname);

		fix_perms("rdump", inode, -1, fullname);
	}
	/* else do nothing (don't dump device files, sockets, fifos, etc.) */

errout:
	free(fullname);
}

static int rdump_dirent(struct ext2_dir_entry *dirent,
			int offset EXT2FS_ATTR((unused)),
			int blocksize EXT2FS_ATTR((unused)),
			char *buf EXT2FS_ATTR((unused)), void *private)
{
	char name[EXT2_NAME_LEN + 1];
	int thislen;
	const char *dumproot = private;
	struct ext2_inode inode;

	thislen = ext2fs_dirent_name_len(dirent);
	strncpy(name, dirent->name, thislen);
	name[thislen] = 0;

	if (debugfs_read_inode(dirent->inode, &inode, name))
		return 0;

	rdump_inode(dirent->inode, &inode, name, dumproot);

	return 0;
}

void do_rdump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
	      void *infop EXT2FS_ATTR((unused)))
{
	struct stat st;
	char *dest_dir;
	int i;

	if (common_args_process(argc, argv, 3, INT_MAX, "rdump",
				"<directory>... <native directory>", 0))
		return;

	/* Pull out last argument */
	dest_dir = argv[argc - 1];
	argc--;

	/* Ensure last arg is a directory. */
	if (stat(dest_dir, &st) == -1) {
		com_err("rdump", errno, "while statting %s", dest_dir);
		return;
	}
	if (!S_ISDIR(st.st_mode)) {
		com_err("rdump", 0, "%s is not a directory", dest_dir);
		return;
	}

	for (i = 1; i < argc; i++) {
		char *arg = argv[i], *basename;
		struct ext2_inode inode;
		ext2_ino_t ino = string_to_inode(arg);
		if (!ino)
			continue;

		if (debugfs_read_inode(ino, &inode, arg))
			continue;

		basename = strrchr(arg, '/');
		if (basename)
			basename++;
		else
			basename = arg;

		rdump_inode(ino, &inode, basename, dest_dir);
	}
}

void do_cat(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
	    void *infop EXT2FS_ATTR((unused)))
{
	ext2_ino_t	inode;

	if (common_inode_args_process(argc, argv, &inode, 0))
		return;

	fflush(stdout);
	fflush(stderr);
	dump_file(argv[0], inode, 1, 0, argv[2]);

	return;
}
Commit	Line	Data
f3db3566 TT	1	/*
f3db3566 TT	2	* dump.c --- dump the contents of an inode out to a file
efc6f628	3	*
f3db3566 TT	4	* Copyright (C) 1994 Theodore Ts'o. This file may be redistributed
	5	* under the terms of the GNU Public License.
	6	*/
	7
cf5301d7	8	#ifndef _GNU_SOURCE
efac5a7f	9	#define _GNU_SOURCE /* for O_LARGEFILE */
cf5301d7	10	#endif
efac5a7f	11
d1154eb4	12	#include "config.h"
f3db3566 TT	13	#include <stdio.h>
	14	#include <unistd.h>
	15	#include <stdlib.h>
	16	#include <ctype.h>
	17	#include <string.h>
	18	#include <time.h>
50e1e10f TT	19	#ifdef HAVE_ERRNO_H
	20	#include <errno.h>
	21	#endif
f3db3566 TT	22	#include <sys/types.h>
	23	#include <sys/stat.h>
	24	#include <fcntl.h>
fc6d9d51 TT	25	#include <utime.h>
	26	#ifdef HAVE_GETOPT_H
	27	#include <getopt.h>
efc6f628	28	#else
fc6d9d51 TT	29	extern int optind;
	30	extern char *optarg;
	31	#endif
f3db3566 TT	32
	33	#include "debugfs.h"
	34
819157db TT	35	#ifndef O_LARGEFILE
	36	#define O_LARGEFILE 0
	37	#endif
	38
fc6d9d51 TT	39	/*
	40	* The mode_xlate function translates a linux mode into a native-OS mode_t.
	41	*/
	42	static struct {
	43	__u16 lmask;
	44	mode_t mask;
	45	} mode_table[] = {
	46	{ LINUX_S_IRUSR, S_IRUSR },
	47	{ LINUX_S_IWUSR, S_IWUSR },
	48	{ LINUX_S_IXUSR, S_IXUSR },
	49	{ LINUX_S_IRGRP, S_IRGRP },
	50	{ LINUX_S_IWGRP, S_IWGRP },
	51	{ LINUX_S_IXGRP, S_IXGRP },
	52	{ LINUX_S_IROTH, S_IROTH },
	53	{ LINUX_S_IWOTH, S_IWOTH },
	54	{ LINUX_S_IXOTH, S_IXOTH },
	55	{ 0, 0 }
	56	};
efc6f628	57
fc6d9d51 TT	58	static mode_t mode_xlate(__u16 lmode)
	59	{
	60	mode_t mode = 0;
	61	int i;
	62
	63	for (i=0; mode_table[i].lmask; i++) {
	64	if (lmode & mode_table[i].lmask)
	65	mode \|= mode_table[i].mask;
	66	}
	67	return mode;
	68	}
	69
2e8d40d5 TT	70	static void fix_perms(const char cmd, const struct ext2_inode inode,
	71	int fd, const char *name)
	72	{
	73	struct utimbuf ut;
	74	int i;
	75
	76	if (fd != -1)
	77	i = fchmod(fd, mode_xlate(inode->i_mode));
	78	else
	79	i = chmod(name, mode_xlate(inode->i_mode));
	80	if (i == -1)
	81	com_err(cmd, errno, "while setting permissions of %s", name);
	82
	83	#ifndef HAVE_FCHOWN
c5de1d4a	84	i = chown(name, inode->i_uid, inode->i_gid);
2e8d40d5 TT	85	#else
	86	if (fd != -1)
	87	i = fchown(fd, inode->i_uid, inode->i_gid);
	88	else
	89	i = chown(name, inode->i_uid, inode->i_gid);
	90	#endif
	91	if (i == -1)
	92	com_err(cmd, errno, "while changing ownership of %s", name);
	93
2e8d40d5 TT	94	ut.actime = inode->i_atime;
	95	ut.modtime = inode->i_mtime;
	96	if (utime(name, &ut) == -1)
	97	com_err(cmd, errno, "while setting times of %s", name);
	98	}
	99
b044c2e0 TT	100	static void dump_file(const char *cmdname, ext2_ino_t ino, int fd,
b044c2e0 TT	101	int preserve, char *outname)
f3db3566 TT	102	{
f3db3566 TT	103	errcode_t retval;
fc6d9d51	104	struct ext2_inode inode;
d3b4de41	105	char *buf = 0;
5a51384e	106	ext2_file_t e2_file;
4a31c48b	107	int nbytes;
d3b4de41	108	unsigned int got, blocksize = current_fs->blocksize;
efc6f628	109
e1018eea	110	if (debugfs_read_inode(ino, &inode, cmdname))
fc6d9d51	111	return;
f3db3566	112
5a51384e TT	113	retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
	114	if (retval) {
	115	com_err(cmdname, retval, "while opening ext2 file");
f3db3566 TT	116	return;
f3db3566 TT	117	}
d3b4de41 ZL	118	retval = ext2fs_get_mem(blocksize, &buf);
	119	if (retval) {
	120	com_err(cmdname, retval, "while allocating memory");
	121	return;
	122	}
5a51384e	123	while (1) {
d3b4de41	124	retval = ext2fs_file_read(e2_file, buf, blocksize, &got);
efc6f628	125	if (retval)
5a51384e TT	126	com_err(cmdname, retval, "while reading ext2 file");
	127	if (got == 0)
	128	break;
	129	nbytes = write(fd, buf, got);
54434927	130	if ((unsigned) nbytes != got)
5a51384e	131	com_err(cmdname, errno, "while writing file");
f3db3566	132	}
d3b4de41 ZL	133	if (buf)
d3b4de41 ZL	134	ext2fs_free_mem(&buf);
5a51384e TT	135	retval = ext2fs_file_close(e2_file);
	136	if (retval) {
	137	com_err(cmdname, retval, "while closing ext2 file");
	138	return;
f3db3566	139	}
efc6f628	140
2e8d40d5 TT	141	if (preserve)
2e8d40d5 TT	142	fix_perms("dump_file", &inode, fd, outname);
efc6f628	143
f3db3566 TT	144	return;
	145	}
	146
2fcbcb1b TT	147	void do_dump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b TT	148	void *infop EXT2FS_ATTR((unused)))
f3db3566	149	{
b044c2e0 TT	150	ext2_ino_t inode;
	151	int fd;
	152	int c;
	153	int preserve = 0;
b044c2e0	154	char in_fn, out_fn;
efc6f628	155
88494bb6	156	reset_getopt();
fc6d9d51 TT	157	while ((c = getopt (argc, argv, "p")) != EOF) {
	158	switch (c) {
	159	case 'p':
	160	preserve++;
	161	break;
	162	default:
5299580c TT	163	print_usage:
	164	com_err(argv[0], 0, "Usage: dump_inode [-p] "
	165	"<file> <output_file>");
fc6d9d51 TT	166	return;
	167	}
	168	}
5299580c TT	169	if (optind != argc-2)
5299580c TT	170	goto print_usage;
f3db3566 TT	171
	172	if (check_fs_open(argv[0]))
	173	return;
	174
fc6d9d51 TT	175	in_fn = argv[optind];
	176	out_fn = argv[optind+1];
	177
	178	inode = string_to_inode(in_fn);
efc6f628	179	if (!inode)
f3db3566 TT	180	return;
f3db3566 TT	181
819157db	182	fd = open(out_fn, O_CREAT \| O_WRONLY \| O_TRUNC \| O_LARGEFILE, 0666);
f3db3566 TT	183	if (fd < 0) {
f3db3566 TT	184	com_err(argv[0], errno, "while opening %s for dump_inode",
fc6d9d51	185	out_fn);
f3db3566 TT	186	return;
	187	}
	188
fc6d9d51	189	dump_file(argv[0], inode, fd, preserve, out_fn);
ddbe7852 DW	190	if (close(fd) != 0) {
	191	com_err(argv[0], errno, "while closing %s for dump_inode",
	192	out_fn);
	193	return;
	194	}
f3db3566	195
f3db3566 TT	196	return;
	197	}
	198
b044c2e0	199	static void rdump_symlink(ext2_ino_t ino, struct ext2_inode *inode,
2e8d40d5 TT	200	const char *fullname)
	201	{
	202	ext2_file_t e2_file;
	203	char *buf;
	204	errcode_t retval;
	205
	206	buf = malloc(inode->i_size + 1);
	207	if (!buf) {
	208	com_err("rdump", errno, "while allocating for symlink");
	209	goto errout;
	210	}
	211
cf0be234	212	if (ext2fs_is_fast_symlink(inode))
2e8d40d5 TT	213	strcpy(buf, (char *) inode->i_block);
	214	else {
	215	unsigned bytes = inode->i_size;
	216	char *p = buf;
	217	retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
	218	if (retval) {
	219	com_err("rdump", retval, "while opening symlink");
	220	goto errout;
	221	}
	222	for (;;) {
	223	unsigned int got;
	224	retval = ext2fs_file_read(e2_file, p, bytes, &got);
	225	if (retval) {
	226	com_err("rdump", retval, "while reading symlink");
	227	goto errout;
	228	}
	229	bytes -= got;
	230	p += got;
	231	if (got == 0 \|\| bytes == 0)
	232	break;
	233	}
	234	buf[inode->i_size] = 0;
	235	retval = ext2fs_file_close(e2_file);
	236	if (retval)
	237	com_err("rdump", retval, "while closing symlink");
	238	}
	239
	240	if (symlink(buf, fullname) == -1) {
	241	com_err("rdump", errno, "while creating symlink %s -> %s", buf, fullname);
	242	goto errout;
	243	}
	244
	245	errout:
	246	free(buf);
	247	}
	248
	249	static int rdump_dirent(struct ext2_dir_entry , int, int, char , void *);
	250
b044c2e0	251	static void rdump_inode(ext2_ino_t ino, struct ext2_inode *inode,
2e8d40d5 TT	252	const char name, const char dumproot)
	253	{
	254	char *fullname;
2e8d40d5 TT	255
	256	/* There are more efficient ways to do this, but this method
	257	* requires only minimal debugging. */
	258	fullname = malloc(strlen(dumproot) + strlen(name) + 2);
	259	if (!fullname) {
	260	com_err("rdump", errno, "while allocating memory");
	261	return;
	262	}
	263	sprintf(fullname, "%s/%s", dumproot, name);
	264
	265	if (LINUX_S_ISLNK(inode->i_mode))
	266	rdump_symlink(ino, inode, fullname);
	267	else if (LINUX_S_ISREG(inode->i_mode)) {
	268	int fd;
efac5a7f	269	fd = open(fullname, O_WRONLY \| O_CREAT \| O_TRUNC \| O_LARGEFILE, S_IRWXU);
2e8d40d5	270	if (fd == -1) {
09727a07	271	com_err("rdump", errno, "while opening %s", fullname);
2e8d40d5 TT	272	goto errout;
	273	}
	274	dump_file("rdump", ino, fd, 1, fullname);
ddbe7852	275	if (close(fd) != 0) {
09727a07	276	com_err("rdump", errno, "while closing %s", fullname);
ddbe7852 DW	277	goto errout;
ddbe7852 DW	278	}
2e8d40d5 TT	279	}
	280	else if (LINUX_S_ISDIR(inode->i_mode) && strcmp(name, ".") && strcmp(name, "..")) {
	281	errcode_t retval;
	282
	283	/* Create the directory with 0700 permissions, because we
	284	* expect to have to create entries it. Then fix its perms
	285	* once we've done the traversal. */
ebb8b1aa	286	if (name[0] && mkdir(fullname, S_IRWXU) == -1) {
2e8d40d5 TT	287	com_err("rdump", errno, "while making directory %s", fullname);
	288	goto errout;
	289	}
	290
	291	retval = ext2fs_dir_iterate(current_fs, ino, 0, 0,
	292	rdump_dirent, (void *) fullname);
	293	if (retval)
	294	com_err("rdump", retval, "while dumping %s", fullname);
	295
	296	fix_perms("rdump", inode, -1, fullname);
	297	}
	298	/* else do nothing (don't dump device files, sockets, fifos, etc.) */
	299
	300	errout:
	301	free(fullname);
	302	}
	303
efc6f628	304	static int rdump_dirent(struct ext2_dir_entry *dirent,
54434927 TT	305	int offset EXT2FS_ATTR((unused)),
	306	int blocksize EXT2FS_ATTR((unused)),
	307	char buf EXT2FS_ATTR((unused)), void private)
2e8d40d5	308	{
b772900b	309	char name[EXT2_NAME_LEN + 1];
2e8d40d5 TT	310	int thislen;
	311	const char *dumproot = private;
	312	struct ext2_inode inode;
2e8d40d5	313
70f4632b	314	thislen = ext2fs_dirent_name_len(dirent);
2e8d40d5 TT	315	strncpy(name, dirent->name, thislen);
	316	name[thislen] = 0;
	317
e1018eea	318	if (debugfs_read_inode(dirent->inode, &inode, name))
2e8d40d5	319	return 0;
2e8d40d5 TT	320
	321	rdump_inode(dirent->inode, &inode, name, dumproot);
	322
	323	return 0;
	324	}
	325
2fcbcb1b TT	326	void do_rdump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b TT	327	void *infop EXT2FS_ATTR((unused)))
2e8d40d5	328	{
2e8d40d5	329	struct stat st;
b6edbf6b	330	char *dest_dir;
2e8d40d5	331	int i;
2e8d40d5	332
b6edbf6b AC	333	if (common_args_process(argc, argv, 3, INT_MAX, "rdump",
b6edbf6b AC	334	"<directory>... <native directory>", 0))
2e8d40d5 TT	335	return;
2e8d40d5 TT	336
850fe1ac AC	337	/* Pull out last argument */
	338	dest_dir = argv[argc - 1];
	339	argc--;
2e8d40d5	340
850fe1ac AC	341	/* Ensure last arg is a directory. */
	342	if (stat(dest_dir, &st) == -1) {
	343	com_err("rdump", errno, "while statting %s", dest_dir);
2e8d40d5 TT	344	return;
	345	}
	346	if (!S_ISDIR(st.st_mode)) {
850fe1ac	347	com_err("rdump", 0, "%s is not a directory", dest_dir);
2e8d40d5 TT	348	return;
	349	}
	350
b6edbf6b AC	351	for (i = 1; i < argc; i++) {
	352	char arg = argv[i], basename;
	353	struct ext2_inode inode;
	354	ext2_ino_t ino = string_to_inode(arg);
	355	if (!ino)
	356	continue;
2e8d40d5	357
b6edbf6b AC	358	if (debugfs_read_inode(ino, &inode, arg))
b6edbf6b AC	359	continue;
2e8d40d5	360
b6edbf6b AC	361	basename = strrchr(arg, '/');
	362	if (basename)
	363	basename++;
	364	else
	365	basename = arg;
	366
	367	rdump_inode(ino, &inode, basename, dest_dir);
	368	}
2e8d40d5 TT	369	}
2e8d40d5 TT	370
2fcbcb1b TT	371	void do_cat(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
2fcbcb1b TT	372	void *infop EXT2FS_ATTR((unused)))
f3db3566	373	{
b044c2e0	374	ext2_ino_t inode;
f3db3566	375
e1018eea	376	if (common_inode_args_process(argc, argv, &inode, 0))
f3db3566 TT	377	return;
f3db3566 TT	378
fc6d9d51 TT	379	fflush(stdout);
fc6d9d51 TT	380	fflush(stderr);
efc6f628	381	dump_file(argv[0], inode, 1, 0, argv[2]);
f3db3566 TT	382
	383	return;
	384	}
	385