/*
* 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 <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"
-struct dump_block_struct {
- int fd;
- char *buf;
- errcode_t errcode;
+#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 int dump_block(ext2_filsys fs, blk_t *blocknr, int blockcnt,
- void *private)
+static mode_t mode_xlate(__u16 lmode)
{
- ssize_t nbytes;
-
- struct dump_block_struct *rec = (struct dump_block_struct *) private;
-
- if (blockcnt < 0)
- return 0;
+ mode_t mode = 0;
+ int i;
- if (*blocknr) {
- rec->errcode = io_channel_read_blk(fs->io, *blocknr,
- 1, rec->buf);
- if (rec->errcode)
- return BLOCK_ABORT;
- } else
- memset(rec->buf, 0, fs->blocksize);
-
-retry_write:
- nbytes = write(rec->fd, rec->buf, fs->blocksize);
- if (nbytes == -1) {
- if (errno == EINTR)
- goto retry_write;
- rec->errcode = errno;
- return BLOCK_ABORT;
- }
- if (nbytes != fs->blocksize) {
- /* XXX not quite right, but good enough */
- rec->errcode = EXT2_ET_SHORT_WRITE;
- return BLOCK_ABORT;
+ for (i=0; mode_table[i].lmask; i++) {
+ if (lmode & mode_table[i].lmask)
+ mode |= mode_table[i].mask;
}
- return 0;
+ return mode;
}
-static void dump_file(char *cmdname, ino_t inode, int fd, char *outname)
+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 dump_block_struct rec;
+ struct ext2_inode inode;
+ char *buf = 0;
+ ext2_file_t e2_file;
+ int nbytes;
+ unsigned int got, blocksize = current_fs->blocksize;
- rec.fd = fd;
- rec.errcode = 0;
- rec.buf = malloc(fs->blocksize);
+ if (debugfs_read_inode(ino, &inode, cmdname))
+ return;
- if (rec.buf == 0) {
- com_err(cmdname, ENOMEM, "while allocating block buffer for dump_inode");
+ retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
+ if (retval) {
+ com_err(cmdname, retval, "while opening ext2 file");
return;
}
-
- retval = ext2fs_block_iterate(fs, inode, 0, NULL,
- dump_block, &rec);
+ retval = ext2fs_get_mem(blocksize, &buf);
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:
- free(rec.buf);
+ 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)
+void do_dump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
+ void *infop EXT2FS_ATTR((unused)))
{
- ino_t inode;
- int fd;
+ ext2_ino_t inode;
+ int fd;
+ int c;
+ int preserve = 0;
+ char *in_fn, *out_fn;
- if (argc != 3) {
- com_err(argv[0], 0, "Usage: dump_inode <file> <output_file>");
- return;
+ 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;
- inode = string_to_inode(argv[1]);
- if (!inode)
+ in_fn = argv[optind];
+ out_fn = argv[optind+1];
+
+ inode = string_to_inode(in_fn);
+ if (!inode)
return;
- fd = open(argv[2], O_CREAT | O_WRONLY | O_TRUNC, 0666);
+ 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",
- argv[2]);
+ out_fn);
return;
}
- dump_file(argv[0], inode, fd, argv[2]);
+ 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;
+ }
- close(fd);
return;
}
-void do_cat(int argc, char **argv)
+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)
{
- ino_t inode;
+ char *fullname;
- if (argc != 2) {
- com_err(argv[0], 0, "Usage: cat <file>");
+ /* 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 (check_fs_open(argv[0]))
+ 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;
- inode = string_to_inode(argv[1]);
- if (!inode)
+ if (common_inode_args_process(argc, argv, &inode, 0))
return;
- dump_file(argv[0], inode, 0, argv[2]);
+ fflush(stdout);
+ fflush(stderr);
+ dump_file(argv[0], inode, 1, 0, argv[2]);
return;
}
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff