Check for the e2fsprogs header <ext2fs/ext2_fs.h> instead of the kernel header if...

[dump.git] / dump / tape.c

diff --git a/dump/tape.c b/dump/tape.c
index cf1f5fbc4c6287eb02693aca60382d06d7acbddd..f846221b502578587e38ea5f508735ca24514bc5 100644 (file)
--- a/dump/tape.c
+++ b/dump/tape.c
@@ -41,10 +41,11 @@
 
 #ifndef lint
 static const char rcsid[] =
-       "$Id: tape.c,v 1.44 2001/04/24 10:59:12 stelian Exp $";
+       "$Id: tape.c,v 1.47 2001/06/18 10:58:28 stelian Exp $";
 #endif /* not lint */
 
 #include <config.h>
+#include <compatlfs.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <setjmp.h>
@@ -62,7 +63,6 @@ int    write(), read();
 #ifdef __linux__
 #include <sys/types.h>
 #include <time.h>
-#include <linux/types.h>
 #endif
 #include <sys/param.h>
 #include <sys/socket.h>
@@ -70,7 +70,11 @@ int    write(), read();
 #include <sys/wait.h>
 #include <sys/mtio.h>
 #ifdef __linux__
+#ifdef HAVE_EXT2FS_EXT2_FS_H
+#include <ext2fs/ext2_fs.h>
+#else
 #include <linux/ext2_fs.h>
+#endif
 #include <ext2fs/ext2fs.h>
 #include <bsdcompat.h>
 #elif defined sunos
@@ -547,7 +551,7 @@ trewind(void)
 #endif
                {
                        (void) close(tapefd);
-                       while ((f = open(tape, 0)) < 0)
+                       while ((f = OPEN(tape, 0)) < 0)
                                sleep (10);
                        (void) close(f);
                }
@@ -861,10 +865,10 @@ restore_check_point:
 #ifdef RDUMP
                while ((tapefd = (host ? rmtopen(tape, 2) : pipeout ? 
                        fileno(stdout) : 
-                       open(tape, O_WRONLY|O_CREAT, 0666))) < 0)
+                       OPEN(tape, O_WRONLY|O_CREAT, 0666))) < 0)
 #else
                while ((tapefd = (pipeout ? fileno(stdout) :
-                                 open(tape, O_RDWR|O_CREAT, 0666))) < 0)
+                                 OPEN(tape, O_RDWR|O_CREAT, 0666))) < 0)
 #endif
                    {
                        msg("Cannot open output \"%s\".\n", tape);
@@ -887,6 +891,7 @@ restore_check_point:
                spcl.c_volume++;
                spcl.c_type = TS_TAPE;
                spcl.c_flags |= DR_NEWHEADER;
+               spcl.c_ntrec = ntrec;
                if (compressed)
                        spcl.c_flags |= DR_COMPRESSED;
                writeheader((dump_ino_t)slp->inode);
@@ -1045,7 +1050,7 @@ doslave(int cmd, int slave_number)
        char *buffer;
 #ifdef HAVE_ZLIB
        struct tapebuf *comp_buf = NULL;
-       int compresult, do_compress = 0;
+       int compresult, do_compress = slave_number > 0;
        unsigned long worklen;
 #endif /* HAVE_ZLIB */
        struct slave_results returns;
@@ -1062,7 +1067,7 @@ doslave(int cmd, int slave_number)
         * Need our own seek pointer.
         */
        (void) close(diskfd);
-       if ((diskfd = open(disk, O_RDONLY)) < 0)
+       if ((diskfd = OPEN(disk, O_RDONLY)) < 0)
                quit("slave couldn't reopen disk: %s\n", strerror(errno));
 #ifdef __linux__
        ext2fs_close(fs);
@@ -1118,24 +1123,24 @@ doslave(int cmd, int slave_number)
 
 #ifdef HAVE_ZLIB
                /* 
-                * When writing a compressed dump, each block is
-                * written from struct tapebuf with an 4 byte prefix
+                * When writing a compressed dump, each block except
+                * the first one on each tape is written
+                * from struct tapebuf with an 4 byte prefix
                 * followed by the data. This can be less than
                 * writesize. Restore, on a short read, can compare the
                 * length read to the compressed length in the header
                 * to verify that the read was good. Blocks which don't
                 * compress well are written uncompressed.
-                * The first block written by each slave is not compressed.
+                * The first block written by each slave is not compressed
+                * and does not have a prefix.
                 */
 
-               if (compressed) {
+               if (compressed && do_compress) {
                        comp_buf->length = bufsize;
                        worklen = TP_BSIZE + writesize;
-                       compresult = Z_DATA_ERROR;
-                       if (do_compress)
-                               compresult = compress2(comp_buf->buf, &worklen,
-                                       (char *)slp->tblock[0], writesize, compressed);
-                       if (compresult == Z_OK && worklen <= writesize-32) {
+                       compresult = compress2(comp_buf->buf, &worklen,
+                               (char *)slp->tblock[0], writesize, compressed);
+                       if (compresult == Z_OK && worklen <= (writesize - 16)) {
                                /* write the compressed buffer */
                                comp_buf->length = worklen;
                                comp_buf->compressed = 1;
@@ -1152,7 +1157,7 @@ doslave(int cmd, int slave_number)
                                memcpy(comp_buf->buf, (char *)slp->tblock[0], writesize);
                        }
                }
-               /* compress the remaining blocks */
+               /* compress the remaining blocks if we're compressing */
                do_compress = compressed;
 #endif /* HAVE_ZLIB */