debugfs/dump.c

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