e2fsprogs/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.
 */

#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
#ifdef HAVE_OPTRESET
extern int optreset;		/* defined by BSD, but not others */
#endif

#include "debugfs.h"

/*
 * 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;
}

struct dump_block_struct {
	int		fd;
	char		*buf;
	int		left;
	errcode_t	errcode;
};

static int dump_block(ext2_filsys fs, blk_t *blocknr, int blockcnt,
		      void *private)
{
	int nbytes, left;
	off_t	ret_off;
	
	struct dump_block_struct *rec = (struct dump_block_struct *) private;
	
	if (blockcnt < 0)
		return 0;

	if (*blocknr) {
		rec->errcode = io_channel_read_blk(fs->io, *blocknr,
						   1, rec->buf);
		if (rec->errcode)
			return BLOCK_ABORT;
	} else {
		/*
		 * OK, the file has a hole.  Let's try to seek past
		 * the hole in the destination file, so that the
		 * destination file has a hole too.
		 */
		ret_off = lseek(rec->fd, fs->blocksize, SEEK_CUR);
		if (ret_off >= 0)
			return 0;
		memset(rec->buf, 0, fs->blocksize);
	}

	left = (rec->left > fs->blocksize) ? fs->blocksize : rec->left;
	rec->left -= left;
	
	while (left > 0) {
		nbytes = write(rec->fd, rec->buf, left);
		if (nbytes == -1) {
			if (errno == EINTR)
				continue;
			rec->errcode = errno;
			return BLOCK_ABORT;
		}
		left -= nbytes;
	}
	if (rec->left <= 0)
		return BLOCK_ABORT;
	return 0;
}

static void dump_file(char *cmdname, ino_t ino, int fd, int preserve,
		      char *outname)
{
	errcode_t retval;
	struct dump_block_struct rec;
	struct ext2_inode	inode;
	struct utimbuf	ut;

	retval = ext2fs_read_inode(current_fs, ino, &inode);
	if (retval) {
		com_err(cmdname, retval,
			"while reading inode %u in dump_file", ino);
		return;
	}

	rec.fd = fd;
	rec.errcode = 0;
	rec.buf = malloc(current_fs->blocksize);
	rec.left = inode.i_size;

	if (rec.buf == 0) {
		com_err(cmdname, ENOMEM,
			"while allocating block buffer for dump_inode");
		return;
	}
	
	retval = ext2fs_block_iterate(current_fs, ino,
				      BLOCK_FLAG_HOLE|BLOCK_FLAG_DATA_ONLY,
				      NULL, dump_block, &rec);
	if (retval) {
		com_err(cmdname, retval, "while iterating over blocks in %s",
			outname);
		goto cleanup;
	}
	if (rec.errcode) {
		com_err(cmdname, retval, "in dump_block while dumping %s",
			outname);
		goto cleanup;
	}
	
cleanup:
	if (preserve) {
#ifdef HAVE_FCHOWN
		if (fchown(fd, inode.i_uid, inode.i_gid) < 0)
			com_err("dump_file", errno,
				"while changing ownership of %s", outname);
#else
		if (chown(outname, inode.i_uid, inode.i_gid) < 0)
			com_err("dump_file", errno,
				"while changing ownership of %s", outname);
			
#endif
		if (fchmod(fd, mode_xlate(inode.i_mode)) < 0)
			com_err("dump_file", errno,
				"while setting permissions of %s", outname);
		ut.actime = inode.i_atime;
		ut.modtime = inode.i_mtime;
		close(fd);
		if (utime(outname, &ut) < 0)
			com_err("dump_file", errno,
				"while setting times on %s", outname);
	} else if (fd != 1)
		close(fd);
				    
	free(rec.buf);
	return;
}

void do_dump(int argc, char **argv)
{
	ino_t	inode;
	int	fd;
	int	c;
	int	preserve = 0;
	const char *dump_usage = "Usage: dump_inode [-p] <file> <output_file>";
	char	*in_fn, *out_fn;
	
	optind = 0;
#ifdef HAVE_OPTRESET
	optreset = 1;		/* Makes BSD getopt happy */
#endif
	while ((c = getopt (argc, argv, "p")) != EOF) {
		switch (c) {
		case 'p':
			preserve++;
			break;
		default:
			com_err(argv[0], 0, dump_usage);
			return;
		}
	}
	if (optind != argc-2) {
		com_err(argv[0], 0, dump_usage);
		return;
	}

	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, 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);

	return;
}

void do_cat(int argc, char **argv)
{
	ino_t	inode;

	if (argc != 2) {
		com_err(argv[0], 0, "Usage: cat <file>");
		return;
	}

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

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

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

	return;
}