* 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.
*
#ifndef lint
static const char rcsid[] =
- "$Id: tape.c,v 1.61 2002/05/06 08:45:41 stelian Exp $";
+ "$Id: tape.c,v 1.74 2003/03/31 09:42:59 stelian Exp $";
#endif /* not lint */
#include <config.h>
#include <bzlib.h>
#endif /* HAVE_BZLIB */
+#ifdef HAVE_LZO
+#include <minilzo.h>
+#endif /* HAVE_LZO */
+
#include "restore.h"
#include "extern.h"
#include "pathnames.h"
static char *tapebuf; /* input buffer for read */
static int bufsize; /* buffer size without prefix */
static char *tbufptr = NULL; /* active tape buffer */
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
static char *comprbuf; /* uncompress work buf */
static size_t comprlen; /* size including prefix */
#endif
static void findinode __P((struct s_spcl *));
static void findtapeblksize __P((void));
static int gethead __P((struct s_spcl *));
+static int converthead __P((struct s_spcl *));
+static void converttapebuf __P((struct tapebuf *));
static void readtape __P((char *));
static void setdumpnum __P((void));
static u_int swabi __P((u_int));
static void xtrskip __P((char *, size_t));
static void setmagtapein __P((void));
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
static void newcomprbuf __P((int));
static void (*readtape_func) __P((char *));
static void readtape_set __P((char *));
tapebufsize = size;
}
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
static void
newcomprbuf(int size)
{
if (comprbuf == NULL)
errx(1, "Cannot allocate space for decompress buffer");
}
-#endif /* HAVE_ZLIB || HAVE_BZLIB */
+#endif /* HAVE_ZLIB || HAVE_BZLIB || HAVE_LZO */
/*
* Verify that the tape drive can be accessed and
temptape = magtape;
#ifdef RRESTORE
- if (host)
- mt = rmtopen(temptape, 0);
+ if (!Afile && host)
+ mt = rmtopen(temptape, O_RDONLY);
else
#endif
if (pipein)
else
mt = OPEN(temptape, O_RDONLY, 0);
if (mt < 0)
- err(1, "%s", magtape);
+ err(1, "%s", temptape);
if (!Afile) {
volno = 1;
setmagtapein();
setdumpnum();
}
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
readtape_func = readtape_set;
+#if defined(HAVE_LZO)
+ if (lzo_init() != LZO_E_OK) {
+ msg("internal error - lzo_init failed \n");
+ exit(1);
+ }
+#endif
#endif
FLUSHTAPEBUF();
findtapeblksize();
if (zflag) {
fprintf(stderr, "Dump tape is compressed.\n");
-#if !defined(HAVE_ZLIB) && !defined(HAVE_BZLIB)
+#if !defined(HAVE_ZLIB) && !defined(HAVE_BZLIB) && !defined(HAVE_LZO)
errx(1,"This restore version doesn't support decompression");
#endif /* !HAVE_ZLIB && !HAVE_BZLIB */
}
if (vflag || command == 't' || command == 'C')
printdumpinfo();
#ifdef USE_QFA
- if (tapeposflag && spcl.c_date != qfadumpdate)
+ if (tapeposflag && (unsigned long)spcl.c_date != qfadumpdate)
errx(1, "different QFA/dumpdates detected\n");
#endif
if (filesys[0] == '\0') {
getfile(xtrmap, xtrmapskip);
while (spcl.c_type == TS_ADDR) {
/* Recompute maxino and the map */
- char *oldmap = usedinomap;
dump_ino_t oldmaxino = maxino;
maxino += (spcl.c_count * TP_BSIZE * NBBY) + 1;
- map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
- if (map == NULL)
- errx(1, "no memory for active inode map");
- usedinomap = map;
- memcpy(usedinomap, oldmap, howmany(oldmaxino, NBBY));
- free(oldmap);
+ resizemaps(oldmaxino, maxino);
spcl.c_dinode.di_size = spcl.c_count * TP_BSIZE;
getfile(xtrmap, xtrmapskip);
return;
}
closemt();
+
+ /*
+ * if using an archive file, reset its name so readtape()
+ * could properly use remote access.
+ */
+ Afile = NULL;
+
if (Mflag) {
snprintf(magtape, MAXPATHLEN, "%s%03ld", magtapeprefix, newvol);
magtape[MAXPATHLEN - 1] = '\0';
}
#ifdef RRESTORE
if (host)
- mt = rmtopen(magtape, 0);
+ mt = rmtopen(magtape, O_RDONLY);
else
#endif
mt = OPEN(magtape, O_RDONLY, 0);
}
gethdr:
setmagtapein();
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
readtape_func = readtape_set;
#endif
volno = newvol;
*/
if (zflag) {
fprintf(stderr, "Dump tape is compressed.\n");
-#if !defined(HAVE_ZLIB) && !defined(HAVE_BZLIB)
+#if !defined(HAVE_ZLIB) && !defined(HAVE_BZLIB) && !defined(HAVE_LZO)
errx(1,"This restore version doesn't support decompression");
#endif /* !HAVE_ZLIB && !HAVE_BZLIB */
}
if (volinfo[1] == ROOTINO) {
printf("Starting inode numbers by volume:\n");
- for (i = 1; i < TP_NINOS && volinfo[i] != 0; ++i)
+ for (i = 1; i < (int)TP_NINOS && volinfo[i] != 0; ++i)
printf("\tVolume %d: %lu\n", i, (unsigned long)volinfo[i]);
}
}
*/
/* ARGSUSED */
static void
-xtrskip(char *buf, size_t size)
+xtrskip(UNUSED(char *buf), size_t size)
{
- if (LSEEK(ofile, (off_t)size, SEEK_CUR) == -1)
+ if (LSEEK(ofile, (OFF_T)size, SEEK_CUR) == -1)
err(1, "seek error extracting inode %lu, name %s\nlseek",
(unsigned long)curfile.ino, curfile.name);
}
*/
/* ARGSUSED */
static void
-xtrlnkskip(char *buf, size_t size)
+xtrlnkskip(UNUSED(char *buf), UNUSED(size_t size))
{
errx(1, "unallocated block in symbolic link %s", curfile.name);
*/
/* ARGSUSED */
static void
-xtrmapskip(char *buf, size_t size)
+xtrmapskip(UNUSED(char *buf), size_t size)
{
panic("hole in map\n");
*/
/* ARGSUSED */
void
-xtrnull(char *buf, size_t size)
+xtrnull(UNUSED(char *buf), UNUSED(size_t size))
{
return;
if (cmperror)
return;
- if (read(ifile, cmpbuf, size) != size) {
+ if (read(ifile, cmpbuf, size) != (ssize_t)size) {
fprintf(stderr, "%s: size has changed.\n",
curfile.name);
cmperror = 1;
* Skip over a hole in a file.
*/
static void
-xtrcmpskip(char *buf, size_t size)
+xtrcmpskip(UNUSED(char *buf), size_t size)
{
static char cmpbuf[MAXBSIZE];
int i;
if (cmperror)
return;
- if (read(ifile, cmpbuf, size) != size) {
+ if (read(ifile, cmpbuf, size) != (ssize_t)size) {
fprintf(stderr, "%s: size has changed.\n",
curfile.name);
cmperror = 1;
return;
}
- for (i = 0; i < size; ++i)
+ for (i = 0; i < (int)size; ++i)
if (cmpbuf[i] != '\0') {
fprintf(stderr, "%s: tape and disk copies are different\n",
curfile.name);
void
comparefile(char *name)
{
- int mode;
+ unsigned int mode;
struct STAT sb;
int r;
#if !COMPARE_ONTHEFLY
struct STAT stemp;
#endif
+ curfile.name = name;
+ curfile.action = USING;
+ mode = curfile.dip->di_mode;
+
+ if ((mode & IFMT) == IFSOCK) {
+ Vprintf(stdout, "skipped socket %s\n", name);
+ skipfile();
+ return;
+ }
+
if ((r = LSTAT(name, &sb)) != 0) {
warn("%s: does not exist (%d)", name, r);
do_compare_error;
return;
}
- curfile.name = name;
- curfile.action = USING;
- mode = curfile.dip->di_mode;
-
Vprintf(stdout, "comparing %s (size: %ld, mode: 0%o)\n", name,
(long)sb.st_size, mode);
return;
}
- if (sb.st_rdev != (int)curfile.dip->di_rdev) {
+ if (sb.st_rdev != (dev_t)curfile.dip->di_rdev) {
fprintf(stderr,
"%s: device changed from %d,%d to %d,%d.\n",
name,
/* NOTREACHED */
}
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
static void (*readtape_func)(char *) = readtape_set;
/*
readtape(buf);
}
-#endif /* HAVE_ZLIB || HAVE_BZLIB */
+#endif /* HAVE_ZLIB || HAVE_BZLIB || HAVE_LZO */
/*
* This is the original readtape(), it's used for reading uncompressed input.
* Handle read errors, and end of media.
*/
static void
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
readtape_uncompr(char *buf)
#else
readtape(char *buf)
#endif
getmore:
#ifdef RRESTORE
- if (host)
+ if (!Afile && host)
i = rmtread(&tapebuf[rd], cnt);
else
#endif
i = ntrec * TP_BSIZE;
memset(tapebuf, 0, (size_t)i);
#ifdef RRESTORE
- if (host)
+ if (!Afile && host)
seek_failed = (rmtseek(i, 1) < 0);
else
#endif
- seek_failed = (LSEEK(mt, i, SEEK_CUR) == (off_t)-1);
+ seek_failed = (LSEEK(mt, i, SEEK_CUR) == (OFF_T)-1);
if (seek_failed) {
warn("continuation failed");
tpblksread++;
}
-#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB)
+#if defined(HAVE_ZLIB) || defined(HAVE_BZLIB) || defined(HAVE_LZO)
/*
* Read a compressed format block from a file or pipe and uncompress it.
/* read the block prefix */
ret = read_a_block(mt, tapebuf, PREFIXSIZE, &rl);
+ converttapebuf(tpb);
- if (Vflag && (ret == 0 || rl < PREFIXSIZE || tpb->length == 0))
+ if (Vflag && (ret == 0 || rl < (int)PREFIXSIZE || tpb->length == 0))
ret = 0;
if (ret <= 0)
goto readerr;
if (ret <= 0)
goto readerr;
+ converttapebuf(tpb);
tbufptr = decompress_tapebuf(tpb, rl);
if (tbufptr == NULL) {
msg_read_error("Tape decompression error while");
/* build a length error message */
blocklen = tpbin->length;
- if (readsize < blocklen + PREFIXSIZE)
+ if (readsize < blocklen + (int)PREFIXSIZE)
lengtherr = "short";
else
- if (readsize > blocklen + PREFIXSIZE)
+ if (readsize > blocklen + (int)PREFIXSIZE)
lengtherr = "long";
worklen = comprlen;
cresult = 0;
#endif /* HAVE_BZLIB */
}
+ if (tpbin->flags == COMPRESS_LZO) {
+#ifndef HAVE_LZO
+ errx(1,"This restore version doesn't support lzo decompression");
+#else
+ cresult = lzo1x_decompress(tpbin->buf, blocklen,
+ comprbuf, (lzo_uintp) &worklen,NULL);
+ output = comprbuf;
+ switch (cresult) {
+ case LZO_E_OK:
+ break;
+ case LZO_E_ERROR:
+ case LZO_E_EOF_NOT_FOUND:
+ reason = "data error";
+ break;
+ default:
+ reason = "unknown";
+ }
+ if (cresult == LZO_E_OK)
+ cresult = 1;
+ else
+ cresult = 0;
+#endif /* HAVE_LZO */
+ }
}
else {
output = tpbin->buf;
break;
}
}
-#endif /* HAVE_ZLIB || HAVE_BZLIB */
+#endif /* HAVE_ZLIB || HAVE_BZLIB || HAVE_LZO */
/*
* Read the first block and get the blocksize from it. Test
long i;
size_t len;
struct tapebuf *tpb = (struct tapebuf *) tapebuf;
- struct s_spcl *spclpt = (struct s_spcl *) tapebuf;
+ struct s_spcl spclpt;
for (i = 0; i < ntrec; i++)
((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
if (read_a_block(mt, tapebuf, len, &i) <= 0)
errx(1, "Tape read error on first record");
+ memcpy(&spclpt, tapebuf, TP_BSIZE);
+ if (converthead(&spclpt) == FAIL) {
+ cvtflag++;
+ if (converthead(&spclpt) == FAIL) {
+ /* Special case for old compressed tapes with prefix */
+ if (magtapein && (i % TP_BSIZE != 0))
+ goto oldformat;
+ errx(1, "Tape is not a dump tape");
+ }
+ fprintf(stderr, "Converting to new file system format.\n");
+ }
/*
* If the input is from a file or a pipe, we read TP_BSIZE
* bytes looking for a dump header. If the dump is compressed
* dump is not compressed and does not have a prefix.
*/
if (!magtapein) {
- if (spclpt->c_type == TS_TAPE
- && spclpt->c_flags & DR_COMPRESSED) {
+ if (spclpt.c_type == TS_TAPE
+ && spclpt.c_flags & DR_COMPRESSED) {
/* It's a compressed dump file, read in the */
- /* rest of the block based on spclpt->c_ntrec. */
- if (spclpt->c_ntrec > ntrec)
+ /* rest of the block based on spclpt.c_ntrec. */
+ if (spclpt.c_ntrec > ntrec)
errx(1, "Tape blocksize is too large, use "
- "\'-b %d\' ", spclpt->c_ntrec);
- ntrec = spclpt->c_ntrec;
+ "\'-b %d\' ", spclpt.c_ntrec);
+ ntrec = spclpt.c_ntrec;
len = (ntrec - 1) * TP_BSIZE;
zflag = 1;
}
len = bufsize - TP_BSIZE;
}
if (read_a_block(mt, tapebuf+TP_BSIZE, len, &i) < 0
- || (i != len && i % TP_BSIZE != 0))
+ || (i != (long)len && i % TP_BSIZE != 0))
errx(1,"Error reading dump file header");
tbufptr = tapebuf;
numtrec = ntrec;
* what we asked for; adjust the value of ntrec and test for
* a compressed dump tape.
*/
-
if (i % TP_BSIZE != 0) {
+oldformat:
/* may be old format compressed dump tape with a prefix */
- spclpt = (struct s_spcl *) tpb->buf;
+ memcpy(&spclpt, tpb->buf, TP_BSIZE);
+ cvtflag = 0;
+ if (converthead(&spclpt) == FAIL) {
+ cvtflag++;
+ if (converthead(&spclpt) == FAIL)
+ errx(1, "Tape is not a dump tape");
+ fprintf(stderr, "Converting to new file system format.\n");
+ }
if (i % TP_BSIZE == PREFIXSIZE
&& tpb->compressed == 0
- && spclpt->c_type == TS_TAPE
- && spclpt->c_flags & DR_COMPRESSED) {
+ && spclpt.c_type == TS_TAPE
+ && spclpt.c_flags & DR_COMPRESSED) {
zflag = 1;
tbufptr = tpb->buf;
if (tpb->length > bufsize)
i, TP_BSIZE);
}
ntrec = i / TP_BSIZE;
- if (spclpt->c_type == TS_TAPE) {
- if (spclpt->c_flags & DR_COMPRESSED)
+ if (spclpt.c_type == TS_TAPE) {
+ if (spclpt.c_flags & DR_COMPRESSED)
zflag = 1;
- if (spclpt->c_ntrec > ntrec)
+ if (spclpt.c_ntrec > ntrec)
errx(1, "Tape blocksize is too large, use "
- "\'-b %d\' ", spclpt->c_ntrec);
+ "\'-b %d\' ", spclpt.c_ntrec);
}
numtrec = ntrec;
Vprintf(stdout, "Tape block size is %ld\n", ntrec);
size = len;
while (size > 0) {
#ifdef RRESTORE
- if (host)
+ if (!Afile && host)
i = rmtread(buf, size);
else
#endif
if (mt < 0)
return;
#ifdef RRESTORE
- if (host)
+ if (!Afile && host)
rmtclose();
else
#endif
magtapein = ioctl(mt, MTIOCGET, (char *)&mt_stat) == 0;
}
- Vprintf(stdout,"Input is from %s\n",
+ Vprintf(stdout,"Input is from a %s %s\n",
+ host ? "remote" : "local",
magtapein ? "tape" :
Vflag ? "multi-volume (no tape)" : "file/pipe");
}
*/
static int
gethead(struct s_spcl *buf)
+{
+ readtape((char *)buf);
+ return converthead(buf);
+}
+
+static int
+converthead(struct s_spcl *buf)
{
int32_t i;
union {
} u_ospcl;
if (!cvtflag) {
- readtape((char *)buf);
if (buf->c_magic != NFS_MAGIC) {
if (swabi(buf->c_magic) != NFS_MAGIC)
return (FAIL);
if (checksum((int *)buf) == FAIL)
return (FAIL);
if (Bcvt)
- swabst((u_char *)"8i4s31i528bi192b2i", (u_char *)buf);
+ swabst((u_char *)"8i4s31i528bi192b3i", (u_char *)buf);
goto good;
}
- readtape((char *)(&u_ospcl.s_ospcl));
+ memcpy(&u_ospcl.s_ospcl, buf, TP_BSIZE);
memset((char *)buf, 0, (long)TP_BSIZE);
buf->c_type = u_ospcl.s_ospcl.c_type;
buf->c_date = u_ospcl.s_ospcl.c_date;
return(GOOD);
}
+static void
+converttapebuf(struct tapebuf *tpb)
+{
+ if (Bcvt) {
+ struct tb {
+ unsigned int length:28;
+ unsigned int flags:3;
+ unsigned int compressed:1;
+ } tb;
+ swabst((u_char *)"i", (u_char *)tpb);
+ memcpy(&tb, tpb, 4);
+ tpb->length = tb.length;
+ tpb->flags = tb.flags;
+ tpb->compressed = tb.compressed;
+ }
+}
+
/*
* Check that a header is where it belongs and predict the next header
*/
#ifdef RDUMP
if (host)
- err = (rmtseek((long)pos, SEEK_SET) < 0);
+ err = (rmtseek(pos, SEEK_SET) < 0);
else
#endif
{
do {
cntloop++;
gethead(&spcl);
- } while (!(spcl.c_inumber == theino && spcl.c_type == TS_INODE && spcl.c_date == dumpdate) && (cntloop < 32));
+ } while (!(spcl.c_inumber == theino && spcl.c_type == TS_INODE && spcl.c_date == dumpdate) && (cntloop < ntrec));
#ifdef DEBUG_QFA
fprintf(stderr, "%ld reads\n", cntloop);
- if (cntloop == 32) {
+ if (cntloop == ntrec) {
fprintf(stderr, "DEBUG: bufsize %d\n", bufsize);
fprintf(stderr, "DEBUG: ntrec %ld\n", ntrec);
- fprintf(stderr, "DEBUG: %ld reads\n", cntloop);
}
#endif
findinode(&spcl);
git.wh0rd.org / dump.git / blobdiff