X-Git-Url: https://git.wh0rd.org/?p=dump.git;a=blobdiff_plain;f=dump%2Ftraverse.c;h=64c32a5b75fc253e0ef4864c58f9c9c1b3fe81e3;hp=6d4f00b3e910219257a3bd44ce6aff3b5997328c;hb=cca7148b36e60b4671518602ff9a7c2d0c22a7b2;hpb=a18d599791e977f3e3d26123031e6ed4e64d6d08 diff --git a/dump/traverse.c b/dump/traverse.c index 6d4f00b..64c32a5 100644 --- a/dump/traverse.c +++ b/dump/traverse.c @@ -18,11 +18,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors + * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * @@ -41,7 +37,7 @@ #ifndef lint static const char rcsid[] = - "$Id: traverse.c,v 1.49 2002/07/19 14:57:39 stelian Exp $"; + "$Id: traverse.c,v 1.66 2005/05/02 15:10:46 stelian Exp $"; #endif /* not lint */ #include @@ -104,6 +100,7 @@ static void dmpindir __P((dump_ino_t ino, daddr_t blk, int level, fsizeT *size)) static int searchdir __P((dump_ino_t ino, daddr_t blkno, long size, long filesize)); #endif static void mapfileino __P((dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskipped)); +static void dump_xattr __P((dump_ino_t ino, struct dinode *dp)); #ifdef HAVE_EXT2_JOURNAL_INUM #define ext2_journal_ino(sb) (sb->s_journal_inum) @@ -134,6 +131,17 @@ typedef ino_t ext2_ino_t; #ifndef EXT2_RESIZE_INO #define EXT2_RESIZE_INO 7 #endif +#ifndef EXT2_FT_UNKNOWN +#define EXT2_FT_UNKNOWN 0 +#define EXT2_FT_REG_FILE 1 +#define EXT2_FT_DIR 2 +#define EXT2_FT_CHRDEV 3 +#define EXT2_FT_BLKDEV 4 +#define EXT2_FT_FIFO 5 +#define EXT2_FT_SOCK 6 +#define EXT2_FT_SYMLINK 7 +#define EXT2_FT_MAX 8 +#endif int dump_fs_open(const char *disk, ext2_filsys *fs) { @@ -195,17 +203,25 @@ blockest(struct dinode const *dp) * dump blocks (sizeest vs. blkest in the indirect block * calculation). */ - blkest = howmany((u_quad_t)dp->di_blocks*fs->blocksize, TP_BSIZE); + blkest = howmany((u_quad_t)dp->di_blocks * 512, fs->blocksize) * (fs->blocksize / TP_BSIZE); i_size = dp->di_size + ((u_quad_t) dp->di_size_high << 32); - sizeest = howmany(i_size, TP_BSIZE); + sizeest = howmany(i_size, fs->blocksize) * (fs->blocksize / TP_BSIZE); if (blkest > sizeest) blkest = sizeest; #ifdef __linux__ + if ((dp->di_mode & IFMT) == IFDIR) { + /* + * for directories, assume only half of space is filled + * with entries. + */ + blkest = blkest / 2; + sizeest = sizeest / 2; + } if (i_size > (u_quad_t)fs->blocksize * NDADDR) { /* calculate the number of indirect blocks on the dump tape */ blkest += howmany(sizeest - NDADDR * fs->blocksize / TP_BSIZE, - NINDIR(sblock) * EXT2_FRAGS_PER_BLOCK(fs->super)); + TP_NINDIR); } #else if (i_size > sblock->fs_bsize * NDADDR) { @@ -268,6 +284,9 @@ mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskip */ SETINO(ino, usedinomap); + if (NODUMP_FLAG(dp)) + do_exclude_ino(ino, "nodump attribute"); + if (mode == IFDIR) SETINO(ino, dumpdirmap); if (WANTTODUMP(dp, ino)) { @@ -281,7 +300,7 @@ mapfileino(dump_ino_t ino, struct dinode const *dp, long *tapesize, int *dirskip return; } if (mode == IFDIR) { - if ( NODUMP_FLAG(dp) || exclude_ino(ino) ) + if (exclude_ino(ino)) CLRINO(ino, usedinomap); *dirskipped = 1; } @@ -756,7 +775,7 @@ dumponeblock(UNUSED(ext2_filsys fs), blk_t *blocknr, e2_blkcnt_t blockcnt, UNUSED(blk_t ref_block), UNUSED(int ref_offset), void * private) { struct block_context *p; - int i; + e2_blkcnt_t i; if (blockcnt < NDADDR) return 0; @@ -778,6 +797,68 @@ dumponeblock(UNUSED(ext2_filsys fs), blk_t *blocknr, e2_blkcnt_t blockcnt, } #endif +static void +dump_xattr(dump_ino_t ino, struct dinode *dp) { + + if (dp->di_extraisize != 0) { +#ifdef HAVE_EXT2FS_READ_INODE_FULL + char inode[EXT2_INODE_SIZE(fs->super)]; + errcode_t err; + u_int32_t *magic; + + memset(inode, 0, EXT2_INODE_SIZE(fs->super)); + err = ext2fs_read_inode_full(fs, (ext2_ino_t)ino, + (struct ext2_inode *) inode, + EXT2_INODE_SIZE(fs->super)); + if (err) { + com_err(disk, err, "while reading inode #%ld\n", (long)ino); + exit(X_ABORT); + } + + magic = (void *)inode + EXT2_GOOD_OLD_INODE_SIZE + dp->di_extraisize; + if (*magic == EXT2_XATTR_MAGIC) { + char xattr[EXT2_INODE_SIZE(fs->super)]; + int i; + char *cp; + + if (vflag) + msg("dumping EA (inode) in inode #%ld\n", (long)ino); + memset(xattr, 0, EXT2_INODE_SIZE(fs->super)); + memcpy(xattr, (void *)magic, + EXT2_INODE_SIZE(fs->super) - + (EXT2_GOOD_OLD_INODE_SIZE + dp->di_extraisize)); + magic = (u_int32_t *)xattr; + *magic = EXT2_XATTR_MAGIC2; + + spcl.c_type = TS_INODE; + spcl.c_dinode.di_size = EXT2_INODE_SIZE(fs->super); + spcl.c_flags |= DR_EXTATTRIBUTES; + spcl.c_extattributes = EXT_XATTR; + spcl.c_count = howmany(EXT2_INODE_SIZE(fs->super), TP_BSIZE); + writeheader(ino); + for (i = 0, cp = xattr; i < spcl.c_count; i++, cp += TP_BSIZE) + writerec(cp, 0); + spcl.c_flags &= ~DR_EXTATTRIBUTES; + spcl.c_extattributes = 0; + } +#endif + } + + if (dp->di_file_acl) { + + if (vflag) + msg("dumping EA (block) in inode #%ld\n", (long)ino); + + spcl.c_type = TS_INODE; + spcl.c_dinode.di_size = sblock->fs_bsize; + spcl.c_flags |= DR_EXTATTRIBUTES; + spcl.c_extattributes = EXT_XATTR; + blksout(&dp->di_file_acl, EXT2_FRAGS_PER_BLOCK(fs->super), ino); + spcl.c_flags &= ~DR_EXTATTRIBUTES; + spcl.c_extattributes = 0; + } +} + /* * Dump passes 3 and 4. * @@ -824,8 +905,6 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) nbi.di_gen = dp->di_gen; nbi.di_uid = (((int32_t)dp->di_uidhigh) << 16) | dp->di_uid; nbi.di_gid = (((int32_t)dp->di_gidhigh) << 16) | dp->di_gid; - if (dp->di_file_acl) - warn("ACLs in inode #%ld won't be dumped", (long)ino); memmove(&spcl.c_dinode, &nbi, sizeof(nbi)); #else /* __linux__ */ spcl.c_dinode = *dp; @@ -838,6 +917,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) spcl.c_count = 0; writeheader(ino); spcl.c_flags &= ~DR_METAONLY; + dump_xattr(ino, dp); return; } @@ -868,6 +948,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) memmove(buf, dp->di_db, (u_long)dp->di_size); buf[dp->di_size] = '\0'; writerec(buf, 0); + dump_xattr(ino, dp); return; } #endif /* __linux__ */ @@ -898,6 +979,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) case S_IFCHR: case S_IFBLK: writeheader(ino); + dump_xattr(ino, dp); return; default: @@ -913,8 +995,10 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) else cnt = howmany(i_size, sblock->fs_fsize); blksout(&dp->di_db[0], cnt, ino); - if ((quad_t) (size = i_size - NDADDR * sblock->fs_bsize) <= 0) + if ((quad_t) (size = i_size - NDADDR * sblock->fs_bsize) <= 0) { + dump_xattr(ino, dp); return; + } #ifdef __linux__ bc.max = NINDIR(sblock) * EXT2_FRAGS_PER_BLOCK(fs->super); bc.buf = (int *)malloc (bc.max * sizeof (int)); @@ -938,6 +1022,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly) blksout (bc.buf, bc.cnt, bc.ino); } free(bc.buf); + dump_xattr(ino, dp); #else for (ind_level = 0; ind_level < NIADDR; ind_level++) { dmpindir(ino, dp->di_ib[ind_level], ind_level, &size); @@ -970,6 +1055,10 @@ convert_dir(struct ext2_dir_entry *dirent, UNUSED(int offset), struct direct *dp; int reclen; + /* do not save entries to excluded inodes */ + if (exclude_ino(dirent->inode)) + return 0; + p = (struct convert_dir_context *)private; reclen = EXT2_DIR_REC_LEN((dirent->name_len & 0xFF) + 1); @@ -983,6 +1072,32 @@ convert_dir(struct ext2_dir_entry *dirent, UNUSED(int offset), dp->d_ino = dirent->inode; dp->d_reclen = reclen; dp->d_namlen = dirent->name_len & 0xFF; + switch ((dirent->name_len & 0xFF00) >> 8) { + default: + dp->d_type = DT_UNKNOWN; + break; + case EXT2_FT_REG_FILE: + dp->d_type = DT_REG; + break; + case EXT2_FT_DIR: + dp->d_type = DT_DIR; + break; + case EXT2_FT_CHRDEV: + dp->d_type = DT_CHR; + break; + case EXT2_FT_BLKDEV: + dp->d_type = DT_BLK; + break; + case EXT2_FT_FIFO: + dp->d_type = DT_FIFO; + break; + case EXT2_FT_SOCK: + dp->d_type = DT_SOCK; + break; + case EXT2_FT_SYMLINK: + dp->d_type = DT_LNK; + break; + } strncpy(dp->d_name, dirent->name, dp->d_namlen); dp->d_name[dp->d_namlen] = '\0'; p->prev_offset = p->offset; @@ -1056,8 +1171,6 @@ dumpdirino(struct dinode *dp, dump_ino_t ino) nbi.di_gen = dp->di_gen; nbi.di_uid = (((int32_t)dp->di_uidhigh) << 16) | dp->di_uid; nbi.di_gid = (((int32_t)dp->di_gidhigh) << 16) | dp->di_gid; - if (dp->di_file_acl) - warn("ACLs in inode #%ld won't be dumped", (long)ino); memmove(&spcl.c_dinode, &nbi, sizeof(nbi)); #else /* __linux__ */ spcl.c_dinode = *dp; @@ -1094,6 +1207,7 @@ dumpdirino(struct dinode *dp, dump_ino_t ino) } (void)free(cdc.buf); + dump_xattr(ino, dp); } #endif /* __linux__ */ @@ -1157,9 +1271,9 @@ dmpindir(dump_ino_t ino, daddr_t blk, int ind_level, fsizeT *size) * Collect up the data into tape record sized buffers and output them. */ void -blksout(daddr_t *blkp, int frags, dump_ino_t ino) +blksout(blk_t *blkp, int frags, dump_ino_t ino) { - daddr_t *bp; + blk_t *bp; int i, j, count, blks, tbperdb; blks = howmany(frags * sblock->fs_fsize, TP_BSIZE); @@ -1200,12 +1314,13 @@ dumpmap(char *map, int type, dump_ino_t ino) spcl.c_type = type; spcl.c_count = howmany(mapsize * sizeof(char), TP_BSIZE); + spcl.c_dinode.di_size = mapsize; writeheader(ino); for (i = 0, cp = map; i < spcl.c_count; i++, cp += TP_BSIZE) writerec(cp, 0); } -#if defined __linux__ && !defined(int32_t) +#if defined(__linux__) && !defined(int32_t) #define int32_t __s32 #endif @@ -1250,7 +1365,11 @@ getino(dump_ino_t inum) errcode_t err; curino = inum; +#ifdef HAVE_EXT2FS_READ_INODE_FULL + err = ext2fs_read_inode_full(fs, (ext2_ino_t)inum, (struct ext2_inode *) &dinode, sizeof(struct dinode)); +#else err = ext2fs_read_inode(fs, (ext2_ino_t)inum, (struct ext2_inode *) &dinode); +#endif if (err) { com_err(disk, err, "while reading inode #%ld\n", (long)inum); exit(X_ABORT); @@ -1278,20 +1397,20 @@ getino(dump_ino_t inum) /* * Read a chunk of data from the disk. * Try to recover from hard errors by reading in sector sized pieces. - * Error recovery is attempted at most breademax times before seeking + * Error recovery is attempted at most BREADEMAX times before seeking * consent from the operator to continue. */ int breaderrors = 0; void -bread(daddr_t blkno, char *buf, int size) +bread(ext2_loff_t blkno, char *buf, int size) { int cnt, i; loop: #ifdef __linux__ - if (ext2fs_llseek(diskfd, (((ext2_loff_t)blkno) << dev_bshift), 0) != - (((ext2_loff_t)blkno) << dev_bshift)) + if (ext2fs_llseek(diskfd, (blkno << dev_bshift), 0) != + (blkno << dev_bshift)) #else if (lseek(diskfd, ((off_t)blkno << dev_bshift), 0) != ((off_t)blkno << dev_bshift)) @@ -1320,7 +1439,7 @@ loop: else msg("short read error from %s: [block %d, ext2blk %d]: count=%d, got=%d\n", disk, blkno, dbtofsb(sblock, blkno), size, cnt); - if (++breaderrors > breademax) { + if (breademax && ++breaderrors > breademax) { msg("More than %d block read errors from %d\n", breademax, disk); broadcast("DUMP IS AILING!\n"); @@ -1337,8 +1456,8 @@ loop: memset(buf, 0, size); for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) { #ifdef __linux__ - if (ext2fs_llseek(diskfd, (((ext2_loff_t)blkno) << dev_bshift), 0) != - (((ext2_loff_t)blkno) << dev_bshift)) + if (ext2fs_llseek(diskfd, (blkno << dev_bshift), 0) != + (blkno << dev_bshift)) #else if (lseek(diskfd, ((off_t)blkno << dev_bshift), 0) != ((off_t)blkno << dev_bshift))