2 * dump.c --- dump the contents of an inode out to a file
4 * Copyright (C) 1994 Theodore Ts'o. This file may be redistributed
5 * under the terms of the GNU Public License.
9 #define _GNU_SOURCE /* for O_LARGEFILE */
22 #include <sys/types.h>
40 * The mode_xlate function translates a linux mode into a native-OS mode_t.
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 },
58 static mode_t mode_xlate(__u16 lmode)
63 for (i=0; mode_table[i].lmask; i++) {
64 if (lmode & mode_table[i].lmask)
65 mode |= mode_table[i].mask;
70 static void fix_perms(const char *cmd, const struct ext2_inode *inode,
71 int fd, const char *name)
77 i = fchmod(fd, mode_xlate(inode->i_mode));
79 i = chmod(name, mode_xlate(inode->i_mode));
81 com_err(cmd, errno, "while setting permissions of %s", name);
84 i = chown(name, inode_uid(*inode), inode_gid(*inode));
87 i = fchown(fd, inode_uid(*inode), inode_gid(*inode));
89 i = chown(name, inode_uid(*inode), inode_gid(*inode));
92 com_err(cmd, errno, "while changing ownership of %s", name);
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);
100 static void dump_file(const char *cmdname, ext2_ino_t ino, int fd,
101 int preserve, char *outname)
104 struct ext2_inode inode;
108 unsigned int got, blocksize = current_fs->blocksize;
110 if (debugfs_read_inode(ino, &inode, cmdname))
113 retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
115 com_err(cmdname, retval, "while opening ext2 file");
118 retval = ext2fs_get_mem(blocksize, &buf);
120 com_err(cmdname, retval, "while allocating memory");
124 retval = ext2fs_file_read(e2_file, buf, blocksize, &got);
126 com_err(cmdname, retval, "while reading ext2 file");
129 nbytes = write(fd, buf, got);
130 if ((unsigned) nbytes != got)
131 com_err(cmdname, errno, "while writing file");
134 ext2fs_free_mem(&buf);
135 retval = ext2fs_file_close(e2_file);
137 com_err(cmdname, retval, "while closing ext2 file");
142 fix_perms("dump_file", &inode, fd, outname);
147 void do_dump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
148 void *infop EXT2FS_ATTR((unused)))
154 char *in_fn, *out_fn;
157 while ((c = getopt (argc, argv, "p")) != EOF) {
164 com_err(argv[0], 0, "Usage: dump_inode [-p] "
165 "<file> <output_file>");
169 if (optind != argc-2)
172 if (check_fs_open(argv[0]))
175 in_fn = argv[optind];
176 out_fn = argv[optind+1];
178 inode = string_to_inode(in_fn);
182 fd = open(out_fn, O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE, 0666);
184 com_err(argv[0], errno, "while opening %s for dump_inode",
189 dump_file(argv[0], inode, fd, preserve, out_fn);
190 if (close(fd) != 0) {
191 com_err(argv[0], errno, "while closing %s for dump_inode",
199 static void rdump_symlink(ext2_ino_t ino, struct ext2_inode *inode,
200 const char *fullname)
206 buf = malloc(inode->i_size + 1);
208 com_err("rdump", errno, "while allocating for symlink");
212 if (ext2fs_is_fast_symlink(inode))
213 strcpy(buf, (char *) inode->i_block);
215 unsigned bytes = inode->i_size;
217 retval = ext2fs_file_open(current_fs, ino, 0, &e2_file);
219 com_err("rdump", retval, "while opening symlink");
224 retval = ext2fs_file_read(e2_file, p, bytes, &got);
226 com_err("rdump", retval, "while reading symlink");
231 if (got == 0 || bytes == 0)
234 buf[inode->i_size] = 0;
235 retval = ext2fs_file_close(e2_file);
237 com_err("rdump", retval, "while closing symlink");
240 if (symlink(buf, fullname) == -1) {
241 com_err("rdump", errno, "while creating symlink %s -> %s", buf, fullname);
249 static int rdump_dirent(struct ext2_dir_entry *, int, int, char *, void *);
251 static void rdump_inode(ext2_ino_t ino, struct ext2_inode *inode,
252 const char *name, const char *dumproot)
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);
260 com_err("rdump", errno, "while allocating memory");
263 sprintf(fullname, "%s/%s", dumproot, name);
265 if (LINUX_S_ISLNK(inode->i_mode))
266 rdump_symlink(ino, inode, fullname);
267 else if (LINUX_S_ISREG(inode->i_mode)) {
269 fd = open(fullname, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, S_IRWXU);
271 com_err("rdump", errno, "while opening %s", fullname);
274 dump_file("rdump", ino, fd, 1, fullname);
275 if (close(fd) != 0) {
276 com_err("rdump", errno, "while closing %s", fullname);
280 else if (LINUX_S_ISDIR(inode->i_mode) && strcmp(name, ".") && strcmp(name, "..")) {
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. */
286 if (name[0] && mkdir(fullname, S_IRWXU) == -1) {
287 com_err("rdump", errno, "while making directory %s", fullname);
291 retval = ext2fs_dir_iterate(current_fs, ino, 0, 0,
292 rdump_dirent, (void *) fullname);
294 com_err("rdump", retval, "while dumping %s", fullname);
296 fix_perms("rdump", inode, -1, fullname);
298 /* else do nothing (don't dump device files, sockets, fifos, etc.) */
304 static int rdump_dirent(struct ext2_dir_entry *dirent,
305 int offset EXT2FS_ATTR((unused)),
306 int blocksize EXT2FS_ATTR((unused)),
307 char *buf EXT2FS_ATTR((unused)), void *private)
309 char name[EXT2_NAME_LEN + 1];
311 const char *dumproot = private;
312 struct ext2_inode inode;
314 thislen = ext2fs_dirent_name_len(dirent);
315 strncpy(name, dirent->name, thislen);
318 if (debugfs_read_inode(dirent->inode, &inode, name))
321 rdump_inode(dirent->inode, &inode, name, dumproot);
326 void do_rdump(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
327 void *infop EXT2FS_ATTR((unused)))
333 if (common_args_process(argc, argv, 3, INT_MAX, "rdump",
334 "<directory>... <native directory>", 0))
337 /* Pull out last argument */
338 dest_dir = argv[argc - 1];
341 /* Ensure last arg is a directory. */
342 if (stat(dest_dir, &st) == -1) {
343 com_err("rdump", errno, "while statting %s", dest_dir);
346 if (!S_ISDIR(st.st_mode)) {
347 com_err("rdump", 0, "%s is not a directory", dest_dir);
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);
358 if (debugfs_read_inode(ino, &inode, arg))
361 basename = strrchr(arg, '/');
367 rdump_inode(ino, &inode, basename, dest_dir);
371 void do_cat(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
372 void *infop EXT2FS_ATTR((unused)))
376 if (common_inode_args_process(argc, argv, &inode, 0))
381 dump_file(argv[0], inode, 1, 0, argv[2]);