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