X-Git-Url: https://git.wh0rd.org/?p=dump.git;a=blobdiff_plain;f=dump%2Ftraverse.c;h=147df5b60e11486f3ce80a0f72fbe2aea274ec96;hp=6d4f00b3e910219257a3bd44ce6aff3b5997328c;hb=dba36a3e9b1fb9e7c207ab8b5f7cb7f502867780;hpb=a18d599791e977f3e3d26123031e6ed4e64d6d08

diff --git a/dump/traverse.c b/dump/traverse.c
index 6d4f00b..147df5b 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.64 2004/12/15 09:31:49 stelian Exp $";
 #endif /* not lint */
 
 #include <config.h>
@@ -134,6 +130,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 +202,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) {
@@ -756,7 +771,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;
@@ -825,7 +840,7 @@ dumpino(struct dinode *dp, dump_ino_t ino, int metaonly)
 	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);
+		msg("ACLs in inode #%ld won't be dumped\n", (long)ino);
 	memmove(&spcl.c_dinode, &nbi, sizeof(nbi));
 #else	/* __linux__ */
 	spcl.c_dinode = *dp;
@@ -970,6 +985,12 @@ convert_dir(struct ext2_dir_entry *dirent, UNUSED(int offset),
 	struct direct *dp;
 	int reclen;
 
+	/* do not save entries to excluded inodes */
+	if (TSTINO(dirent->inode, dumpinomap) == 0 &&
+	    TSTINO(dirent->inode, dumpdirmap) == 0 &&
+	    TSTINO(dirent->inode, usedinomap) == 0)
+		return 0;
+
 	p = (struct convert_dir_context *)private;
 
 	reclen = EXT2_DIR_REC_LEN((dirent->name_len & 0xFF) + 1);
@@ -983,6 +1004,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;
@@ -1057,7 +1104,7 @@ dumpdirino(struct dinode *dp, dump_ino_t ino)
 	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);
+		msg("ACLs in inode #%ld won't be dumped\n", (long)ino);
 	memmove(&spcl.c_dinode, &nbi, sizeof(nbi));
 #else	/* __linux__ */
 	spcl.c_dinode = *dp;
@@ -1157,9 +1204,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 +1247,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
 
@@ -1278,20 +1326,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 +1368,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 +1385,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))