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
28 extern int optind;
29 extern 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 */
41 static 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
mode_xlate(__u16 lmode)57 static 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
fix_perms(const char * cmd,const struct ext2_inode * inode,int fd,const char * name)69 static 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
dump_file(const char * cmdname,ext2_ino_t ino,int fd,int preserve,char * outname)102 static 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
do_dump(int argc,char ** argv)149 void 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
rdump_symlink(ext2_ino_t ino,struct ext2_inode * inode,const char * fullname)200 static 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
248 errout:
249 free(buf);
250 }
251
252 static int rdump_dirent(struct ext2_dir_entry *, int, int, char *, void *);
253
rdump_inode(ext2_ino_t ino,struct ext2_inode * inode,const char * name,const char * dumproot)254 static 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
303 errout:
304 free(fullname);
305 }
306
rdump_dirent(struct ext2_dir_entry * dirent,int offset EXT2FS_ATTR ((unused)),int blocksize EXT2FS_ATTR ((unused)),char * buf EXT2FS_ATTR ((unused)),void * private)307 static 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
do_rdump(int argc,char ** argv)329 void 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
do_cat(int argc,char ** argv)368 void 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