]> git.wh0rd.org - dump.git/blob - restore/tape.c
git.wh0rd.org / dump.git / blob
? search:


4e1713042931a764e8b3259fa9f8984b201ac05a
[dump.git] / restore / tape.c
1 /*
2 * Ported to Linux's Second Extended File System as part of the
3 * dump and restore backup suit
4 * Remy Card <card@Linux.EU.Org>, 1994-1997
5 * Stelian Pop <pop@noos.fr>, 1999-2000
6 * Stelian Pop <pop@noos.fr> - Alcôve <www.alcove.fr>, 2000
7 */
8
9 /*
10 * Copyright (c) 1983, 1993
11 * The Regents of the University of California. All rights reserved.
12 * (c) UNIX System Laboratories, Inc.
13 * All or some portions of this file are derived from material licensed
14 * to the University of California by American Telephone and Telegraph
15 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
16 * the permission of UNIX System Laboratories, Inc.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 3. All advertising materials mentioning features or use of this software
27 * must display the following acknowledgement:
28 * This product includes software developed by the University of
29 * California, Berkeley and its contributors.
30 * 4. Neither the name of the University nor the names of its contributors
31 * may be used to endorse or promote products derived from this software
32 * without specific prior written permission.
33 *
34 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
35 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44 * SUCH DAMAGE.
45 */
46
47 #ifndef lint
48 static const char rcsid[] =
49 "$Id: tape.c,v 1.22 2000/12/21 11:14:54 stelian Exp $";
50 #endif /* not lint */
51
52 #include <config.h>
53 #include <sys/param.h>
54 #include <sys/file.h>
55 #include <sys/mtio.h>
56 #include <sys/stat.h>
57
58 #ifdef __linux__
59 #include <sys/time.h>
60 #include <linux/ext2_fs.h>
61 #include <bsdcompat.h>
62 #else /* __linux__ */
63 #include <ufs/ufs/dinode.h>
64 #endif /* __linux__ */
65 #include <protocols/dumprestore.h>
66
67 #include <errno.h>
68 #include <compaterr.h>
69 #include <setjmp.h>
70 #include <stdio.h>
71 #include <stdlib.h>
72 #include <string.h>
73 #include <unistd.h>
74
75 #ifdef __linux__
76 #include <ext2fs/ext2fs.h>
77 #endif
78
79 #include "restore.h"
80 #include "extern.h"
81 #include "pathnames.h"
82
83 static long fssize = MAXBSIZE;
84 static int mt = -1;
85 static int pipein = 0;
86 static char magtape[MAXPATHLEN];
87 static char magtapeprefix[MAXPATHLEN];
88 static int blkcnt;
89 static int numtrec;
90 static char *tapebuf;
91 static union u_spcl endoftapemark;
92 static long blksread; /* blocks read since last header */
93 static long tpblksread = 0; /* TP_BSIZE blocks read */
94 static long tapesread;
95 static sigjmp_buf restart;
96 static int gettingfile = 0; /* restart has a valid frame */
97 static char *host = NULL;
98
99 static int ofile;
100 static char *map;
101 static char lnkbuf[MAXPATHLEN + 1];
102 static int pathlen;
103
104 int oldinofmt; /* old inode format conversion required */
105 int Bcvt; /* Swap Bytes (for CCI or sun) */
106 static int Qcvt; /* Swap quads (for sun) */
107
108 #define FLUSHTAPEBUF() blkcnt = ntrec + 1
109
110 static void accthdr __P((struct s_spcl *));
111 static int checksum __P((int *));
112 static void findinode __P((struct s_spcl *));
113 static void findtapeblksize __P((void));
114 static int gethead __P((struct s_spcl *));
115 static void readtape __P((char *));
116 static void setdumpnum __P((void));
117 static u_int swabi __P((u_int));
118 static u_long swabl __P((u_long));
119 static u_char *swab64 __P((u_char *, int));
120 static u_char *swab32 __P((u_char *, int));
121 static u_char *swab16 __P((u_char *, int));
122 static void terminateinput __P((void));
123 static void xtrfile __P((char *, size_t));
124 static void xtrlnkfile __P((char *, size_t));
125 static void xtrlnkskip __P((char *, size_t));
126 static void xtrmap __P((char *, size_t));
127 static void xtrmapskip __P((char *, size_t));
128 static void xtrskip __P((char *, size_t));
129
130 #define COMPARE_ONTHEFLY 1
131
132 #if COMPARE_ONTHEFLY
133 static int ifile; /* input file for compare */
134 static int cmperror; /* compare error */
135 static void xtrcmpfile __P((char *, size_t));
136 static void xtrcmpskip __P((char *, size_t));
137 #endif
138
139 static int readmapflag;
140
141 /*
142 * Set up an input source
143 */
144 void
145 setinput(char *source)
146 {
147 FLUSHTAPEBUF();
148 if (bflag)
149 newtapebuf(ntrec);
150 else
151 newtapebuf(NTREC > HIGHDENSITYTREC ? NTREC : HIGHDENSITYTREC);
152 terminal = stdin;
153
154 #ifdef RRESTORE
155 if (strchr(source, ':')) {
156 host = source;
157 source = strchr(host, ':');
158 *source++ = '\0';
159 if (rmthost(host) == 0)
160 exit(1);
161 } else
162 #endif
163 if (strcmp(source, "-") == 0) {
164 /*
165 * Since input is coming from a pipe we must establish
166 * our own connection to the terminal.
167 */
168 terminal = fopen(_PATH_TTY, "r");
169 if (terminal == NULL) {
170 warn("cannot open %s", _PATH_TTY);
171 terminal = fopen(_PATH_DEVNULL, "r");
172 if (terminal == NULL)
173 err(1, "cannot open %s", _PATH_DEVNULL);
174 }
175 pipein++;
176 }
177 setuid(getuid()); /* no longer need or want root privileges */
178 if (Mflag) {
179 strncpy(magtapeprefix, source, MAXPATHLEN);
180 magtapeprefix[MAXPATHLEN-1] = '\0';
181 snprintf(magtape, MAXPATHLEN, "%s%03d", source, 1);
182 }
183 else
184 strncpy(magtape, source, MAXPATHLEN);
185 magtape[MAXPATHLEN - 1] = '\0';
186 }
187
188 void
189 newtapebuf(long size)
190 {
191 static int tapebufsize = -1;
192
193 ntrec = size;
194 if (size <= tapebufsize)
195 return;
196 if (tapebuf != NULL)
197 free(tapebuf);
198 tapebuf = malloc(size * TP_BSIZE);
199 if (tapebuf == NULL)
200 errx(1, "Cannot allocate space for tape buffer");
201 tapebufsize = size;
202 }
203
204 /*
205 * Verify that the tape drive can be accessed and
206 * that it actually is a dump tape.
207 */
208 void
209 setup(void)
210 {
211 int i, j, *ip;
212 struct stat stbuf;
213
214 Vprintf(stdout, "Verify tape and initialize maps\n");
215 #ifdef RRESTORE
216 if (host)
217 mt = rmtopen(magtape, 0);
218 else
219 #endif
220 if (pipein)
221 mt = 0;
222 else
223 mt = open(magtape, O_RDONLY, 0);
224 if (mt < 0)
225 err(1, "%s", magtape);
226 volno = 1;
227 setdumpnum();
228 FLUSHTAPEBUF();
229 if (!pipein && !bflag)
230 findtapeblksize();
231 if (gethead(&spcl) == FAIL) {
232 blkcnt--; /* push back this block */
233 blksread--;
234 tpblksread--;
235 cvtflag++;
236 if (gethead(&spcl) == FAIL)
237 errx(1, "Tape is not a dump tape");
238 fprintf(stderr, "Converting to new file system format.\n");
239 }
240 if (pipein) {
241 endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC;
242 endoftapemark.s_spcl.c_type = TS_END;
243 ip = (int *)&endoftapemark;
244 j = sizeof(union u_spcl) / sizeof(int);
245 i = 0;
246 do
247 i += *ip++;
248 while (--j);
249 endoftapemark.s_spcl.c_checksum = CHECKSUM - i;
250 }
251 if (vflag || command == 't' || command == 'C')
252 printdumpinfo();
253 if (filesys[0] == '\0') {
254 char *dirptr;
255 strncpy(filesys, spcl.c_filesys, NAMELEN);
256 filesys[NAMELEN - 1] = '\0';
257 dirptr = strstr(filesys, " (dir");
258 if (dirptr != NULL)
259 *dirptr = '\0';
260 }
261 dumptime = spcl.c_ddate;
262 dumpdate = spcl.c_date;
263 if (stat(".", &stbuf) < 0)
264 err(1, "cannot stat .");
265 if (stbuf.st_blksize > 0 && stbuf.st_blksize < TP_BSIZE )
266 fssize = TP_BSIZE;
267 if (stbuf.st_blksize >= TP_BSIZE && stbuf.st_blksize <= MAXBSIZE)
268 fssize = stbuf.st_blksize;
269 if (((fssize - 1) & fssize) != 0)
270 errx(1, "bad block size %ld", fssize);
271 if (spcl.c_volume != 1)
272 errx(1, "Tape is not volume 1 of the dump");
273 if (gethead(&spcl) == FAIL) {
274 Dprintf(stdout, "header read failed at %ld blocks\n", (long)blksread);
275 panic("no header after volume mark!\n");
276 }
277 findinode(&spcl);
278 if (spcl.c_type != TS_CLRI)
279 errx(1, "Cannot find file removal list");
280 maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
281 Dprintf(stdout, "maxino = %ld\n", (long)maxino);
282 map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
283 if (map == NULL)
284 errx(1, "no memory for active inode map");
285 usedinomap = map;
286 curfile.action = USING;
287 getfile(xtrmap, xtrmapskip);
288 if (spcl.c_type != TS_BITS)
289 errx(1, "Cannot find file dump list");
290 map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
291 if (map == (char *)NULL)
292 errx(1, "no memory for file dump list");
293 dumpmap = map;
294 curfile.action = USING;
295 getfile(xtrmap, xtrmapskip);
296 /*
297 * If there may be whiteout entries on the tape, pretend that the
298 * whiteout inode exists, so that the whiteout entries can be
299 * extracted.
300 */
301 if (oldinofmt == 0)
302 SETINO(WINO, dumpmap);
303 }
304
305 /*
306 * Prompt user to load a new dump volume.
307 * "Nextvol" is the next suggested volume to use.
308 * This suggested volume is enforced when doing full
309 * or incremental restores, but can be overridden by
310 * the user when only extracting a subset of the files.
311 */
312 void
313 getvol(long nextvol)
314 {
315 long newvol = 0, savecnt = 0, wantnext = 0, i;
316 union u_spcl tmpspcl;
317 # define tmpbuf tmpspcl.s_spcl
318 char buf[TP_BSIZE];
319 int haderror = 0;
320
321 if (nextvol == 1) {
322 tapesread = 0;
323 gettingfile = 0;
324 }
325 if (pipein) {
326 if (nextvol != 1)
327 panic("Changing volumes on pipe input?\n");
328 if (volno == 1)
329 return;
330 goto gethdr;
331 }
332 savecnt = blksread;
333 again:
334 if (pipein)
335 exit(1); /* pipes do not get a second chance */
336 if (command == 'R' || command == 'r' || curfile.action != SKIP) {
337 newvol = nextvol;
338 wantnext = 1;
339 } else {
340 newvol = 0;
341 wantnext = 0;
342 }
343 while (newvol <= 0) {
344 if (tapesread == 0) {
345 fprintf(stderr, "%s%s%s%s%s",
346 "You have not read any tapes yet.\n",
347 "Unless you know which volume your",
348 " file(s) are on you should start\n",
349 "with the last volume and work",
350 " towards the first.\n");
351 } else {
352 fprintf(stderr, "You have read volumes");
353 strcpy(buf, ": ");
354 for (i = 1; i < 32; i++)
355 if (tapesread & (1 << i)) {
356 fprintf(stderr, "%s%ld", buf, (long)i);
357 strcpy(buf, ", ");
358 }
359 fprintf(stderr, "\n");
360 }
361 do {
362 fprintf(stderr, "Specify next volume #: ");
363 (void) fflush(stderr);
364 (void) fgets(buf, TP_BSIZE, terminal);
365 } while (!feof(terminal) && buf[0] == '\n');
366 if (feof(terminal))
367 exit(1);
368 newvol = atoi(buf);
369 if (newvol <= 0) {
370 fprintf(stderr,
371 "Volume numbers are positive numerics\n");
372 }
373 }
374 if (newvol == volno) {
375 tapesread |= 1 << volno;
376 return;
377 }
378 closemt();
379 if (Mflag) {
380 snprintf(magtape, MAXPATHLEN, "%s%03ld", magtapeprefix, newvol);
381 magtape[MAXPATHLEN - 1] = '\0';
382 }
383 if (!Mflag || haderror) {
384 haderror = 0;
385 fprintf(stderr, "Mount tape volume %ld\n", (long)newvol);
386 fprintf(stderr, "Enter ``none'' if there are no more tapes\n");
387 fprintf(stderr, "otherwise enter tape name (default: %s) ", magtape);
388 (void) fflush(stderr);
389 (void) fgets(buf, TP_BSIZE, terminal);
390 if (feof(terminal))
391 exit(1);
392 if (!strcmp(buf, "none\n")) {
393 terminateinput();
394 return;
395 }
396 if (buf[0] != '\n') {
397 (void) strcpy(magtape, buf);
398 magtape[strlen(magtape) - 1] = '\0';
399 }
400 }
401 #ifdef RRESTORE
402 if (host)
403 mt = rmtopen(magtape, 0);
404 else
405 #endif
406 mt = open(magtape, O_RDONLY, 0);
407
408 if (mt == -1) {
409 fprintf(stderr, "Cannot open %s\n", magtape);
410 volno = -1;
411 haderror = 1;
412 goto again;
413 }
414 gethdr:
415 volno = newvol;
416 setdumpnum();
417 FLUSHTAPEBUF();
418 if (gethead(&tmpbuf) == FAIL) {
419 Dprintf(stdout, "header read failed at %ld blocks\n", (long)blksread);
420 fprintf(stderr, "tape is not dump tape\n");
421 volno = 0;
422 haderror = 1;
423 goto again;
424 }
425 if (tmpbuf.c_volume != volno) {
426 fprintf(stderr, "Wrong volume (%d)\n", tmpbuf.c_volume);
427 volno = 0;
428 haderror = 1;
429 goto again;
430 }
431 if (tmpbuf.c_date != dumpdate || tmpbuf.c_ddate != dumptime) {
432 #ifdef __linux__
433 fprintf(stderr, "Wrong dump date\n\tgot: %s",
434 ctime4(&tmpbuf.c_date));
435 fprintf(stderr, "\twanted: %s", ctime4(&dumpdate));
436 #else
437 fprintf(stderr, "Wrong dump date\n\tgot: %s",
438 ctime(&tmpbuf.c_date));
439 fprintf(stderr, "\twanted: %s", ctime(&dumpdate));
440 #endif
441 volno = 0;
442 haderror = 1;
443 goto again;
444 }
445 tapesread |= 1 << volno;
446 blksread = savecnt;
447 /*
448 * If continuing from the previous volume, skip over any
449 * blocks read already at the end of the previous volume.
450 *
451 * If coming to this volume at random, skip to the beginning
452 * of the next record.
453 */
454 Dprintf(stdout, "read %ld recs, tape starts with %ld\n",
455 tpblksread, (long)tmpbuf.c_firstrec);
456 if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER)) {
457 if (!wantnext) {
458 tpblksread = tmpbuf.c_firstrec;
459 for (i = tmpbuf.c_count; i > 0; i--)
460 readtape(buf);
461 } else if (tmpbuf.c_firstrec > 0 &&
462 tmpbuf.c_firstrec < tpblksread - 1) {
463 /*
464 * -1 since we've read the volume header
465 */
466 i = tpblksread - tmpbuf.c_firstrec - 1;
467 Dprintf(stderr, "Skipping %ld duplicate record%s.\n",
468 (long)i, i > 1 ? "s" : "");
469 while (--i >= 0)
470 readtape(buf);
471 }
472 }
473 if (curfile.action == USING) {
474 if (volno == 1)
475 panic("active file into volume 1\n");
476 return;
477 }
478 /*
479 * Skip up to the beginning of the next record
480 */
481 if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER))
482 for (i = tmpbuf.c_count; i > 0; i--)
483 readtape(buf);
484 (void) gethead(&spcl);
485 findinode(&spcl);
486 if (gettingfile) {
487 gettingfile = 0;
488 siglongjmp(restart, 1);
489 }
490 }
491
492 /*
493 * Handle unexpected EOF.
494 */
495 static void
496 terminateinput(void)
497 {
498
499 if (gettingfile && curfile.action == USING) {
500 printf("Warning: %s %s\n",
501 "End-of-input encountered while extracting", curfile.name);
502 }
503 curfile.name = "<name unknown>";
504 curfile.action = UNKNOWN;
505 curfile.dip = NULL;
506 curfile.ino = maxino;
507 if (gettingfile) {
508 gettingfile = 0;
509 siglongjmp(restart, 1);
510 }
511 }
512
513 /*
514 * handle multiple dumps per tape by skipping forward to the
515 * appropriate one.
516 */
517 static void
518 setdumpnum(void)
519 {
520 struct mtop tcom;
521
522 if (dumpnum == 1 || volno != 1)
523 return;
524 if (pipein)
525 errx(1, "Cannot have multiple dumps on pipe input");
526 tcom.mt_op = MTFSF;
527 tcom.mt_count = dumpnum - 1;
528 #ifdef RRESTORE
529 if (host)
530 rmtioctl(MTFSF, dumpnum - 1);
531 else
532 #endif
533 if (ioctl(mt, (int)MTIOCTOP, (char *)&tcom) < 0)
534 warn("ioctl MTFSF");
535 }
536
537 void
538 printdumpinfo(void)
539 {
540 #ifdef __linux__
541 fprintf(stdout, "Dump date: %s", ctime4(&spcl.c_date));
542 fprintf(stdout, "Dumped from: %s",
543 (spcl.c_ddate == 0) ? "the epoch\n" : ctime4(&spcl.c_ddate));
544 #else
545 fprintf(stdout, "Dump date: %s", ctime(&spcl.c_date));
546 fprintf(stdout, "Dumped from: %s",
547 (spcl.c_ddate == 0) ? "the epoch\n" : ctime(&spcl.c_ddate));
548 #endif
549 if (spcl.c_host[0] == '\0')
550 return;
551 fprintf(stdout, "Level %d dump of %s on %s:%s\n",
552 spcl.c_level, spcl.c_filesys, spcl.c_host, spcl.c_dev);
553 fprintf(stdout, "Label: %s\n", spcl.c_label);
554 }
555
556 int
557 extractfile(char *name)
558 {
559 unsigned int flags;
560 mode_t mode;
561 struct timeval timep[2];
562 struct entry *ep;
563
564 curfile.name = name;
565 curfile.action = USING;
566 #ifdef __linux__
567 timep[0].tv_sec = curfile.dip->di_atime.tv_sec;
568 timep[0].tv_usec = curfile.dip->di_atime.tv_usec;
569 timep[1].tv_sec = curfile.dip->di_mtime.tv_sec;
570 timep[1].tv_usec = curfile.dip->di_mtime.tv_usec;
571 #else /* __linux__ */
572 timep[0].tv_sec = curfile.dip->di_atime;
573 timep[0].tv_usec = curfile.dip->di_atimensec / 1000;
574 timep[1].tv_sec = curfile.dip->di_mtime;
575 timep[1].tv_usec = curfile.dip->di_mtimensec / 1000;
576 #endif /* __linux__ */
577 mode = curfile.dip->di_mode;
578 flags = curfile.dip->di_flags;
579 switch (mode & IFMT) {
580
581 default:
582 fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode);
583 skipfile();
584 return (FAIL);
585
586 case IFSOCK:
587 Vprintf(stdout, "skipped socket %s\n", name);
588 skipfile();
589 return (GOOD);
590
591 case IFDIR:
592 if (mflag) {
593 ep = lookupname(name);
594 if (ep == NULL || ep->e_flags & EXTRACT)
595 panic("unextracted directory %s\n", name);
596 skipfile();
597 return (GOOD);
598 }
599 Vprintf(stdout, "extract file %s\n", name);
600 return (genliteraldir(name, curfile.ino));
601
602 case IFLNK:
603 {
604 #ifdef HAVE_LCHOWN
605 uid_t luid = curfile.dip->di_uid;
606 gid_t lgid = curfile.dip->di_gid;
607 #endif
608 lnkbuf[0] = '\0';
609 pathlen = 0;
610 getfile(xtrlnkfile, xtrlnkskip);
611 if (pathlen == 0) {
612 Vprintf(stdout,
613 "%s: zero length symbolic link (ignored)\n", name);
614 return (GOOD);
615 }
616 if (linkit(lnkbuf, name, SYMLINK) == FAIL)
617 return (FAIL);
618 #ifdef HAVE_LCHOWN
619 (void) lchown(name, luid, lgid);
620 #endif
621 return (GOOD);
622 }
623
624 case IFIFO:
625 Vprintf(stdout, "extract fifo %s\n", name);
626 if (Nflag) {
627 skipfile();
628 return (GOOD);
629 }
630 if (uflag && !Nflag)
631 (void)unlink(name);
632 if (mkfifo(name, mode) < 0) {
633 warn("%s: cannot create fifo", name);
634 skipfile();
635 return (FAIL);
636 }
637 (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
638 (void) chmod(name, mode);
639 if (flags)
640 #ifdef __linux__
641 (void) fsetflags(name, flags);
642 #else
643 (void) chflags(name, flags);
644 #endif
645 skipfile();
646 utimes(name, timep);
647 return (GOOD);
648
649 case IFCHR:
650 case IFBLK:
651 Vprintf(stdout, "extract special file %s\n", name);
652 if (Nflag) {
653 skipfile();
654 return (GOOD);
655 }
656 if (uflag)
657 (void)unlink(name);
658 if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) {
659 warn("%s: cannot create special file", name);
660 skipfile();
661 return (FAIL);
662 }
663 (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
664 (void) chmod(name, mode);
665 if (flags)
666 #ifdef __linux__
667 {
668 warn("%s: fsetflags called on a special file", name);
669 (void) fsetflags(name, flags);
670 }
671 #else
672 (void) chflags(name, flags);
673 #endif
674 skipfile();
675 utimes(name, timep);
676 return (GOOD);
677
678 case IFREG:
679 Vprintf(stdout, "extract file %s\n", name);
680 if (Nflag) {
681 skipfile();
682 return (GOOD);
683 }
684 if (uflag)
685 (void)unlink(name);
686 if ((ofile = open(name, O_WRONLY | O_CREAT | O_TRUNC,
687 0666)) < 0) {
688 warn("%s: cannot create file", name);
689 skipfile();
690 return (FAIL);
691 }
692 (void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid);
693 (void) fchmod(ofile, mode);
694 if (flags)
695 #ifdef __linux__
696 (void) setflags(ofile, flags);
697 #else
698 (void) fchflags(ofile, flags);
699 #endif
700 getfile(xtrfile, xtrskip);
701 (void) close(ofile);
702 utimes(name, timep);
703 return (GOOD);
704 }
705 /* NOTREACHED */
706 }
707
708 /*
709 * skip over bit maps on the tape
710 */
711 void
712 skipmaps(void)
713 {
714
715 while (spcl.c_type == TS_BITS || spcl.c_type == TS_CLRI)
716 skipfile();
717 }
718
719 /*
720 * skip over a file on the tape
721 */
722 void
723 skipfile(void)
724 {
725
726 curfile.action = SKIP;
727 getfile(xtrnull, xtrnull);
728 }
729
730 /*
731 * Extract a file from the tape.
732 * When an allocated block is found it is passed to the fill function;
733 * when an unallocated block (hole) is found, a zeroed buffer is passed
734 * to the skip function.
735 */
736 void
737 getfile(void (*fill) __P((char *, size_t)), void (*skip) __P((char *, size_t)))
738 {
739 register int i;
740 volatile int curblk = 0;
741 volatile quad_t size = spcl.c_dinode.di_size;
742 volatile int last_write_was_hole = 0;
743 quad_t origsize = size;
744 static char clearedbuf[MAXBSIZE];
745 char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE];
746 char junk[TP_BSIZE];
747
748 if (spcl.c_type == TS_END)
749 panic("ran off end of tape\n");
750 if (spcl.c_magic != NFS_MAGIC)
751 panic("not at beginning of a file\n");
752 if (!gettingfile && setjmp(restart) != 0)
753 return;
754 gettingfile++;
755 loop:
756 for (i = 0; i < spcl.c_count; i++) {
757 if (readmapflag || spcl.c_addr[i]) {
758 readtape(&buf[curblk++][0]);
759 if (curblk == fssize / TP_BSIZE) {
760 (*fill)((char *)buf, (size_t)(size > TP_BSIZE ?
761 fssize : (curblk - 1) * TP_BSIZE + size));
762 curblk = 0;
763 last_write_was_hole = 0;
764 }
765 } else {
766 if (curblk > 0) {
767 (*fill)((char *)buf, (size_t)(size > TP_BSIZE ?
768 curblk * TP_BSIZE :
769 (curblk - 1) * TP_BSIZE + size));
770 curblk = 0;
771 }
772 (*skip)(clearedbuf, (long)(size > TP_BSIZE ?
773 TP_BSIZE : size));
774 last_write_was_hole = 1;
775 }
776 if ((size -= TP_BSIZE) <= 0) {
777 for (i++; i < spcl.c_count; i++)
778 if (readmapflag || spcl.c_addr[i])
779 readtape(junk);
780 break;
781 }
782 }
783 if (gethead(&spcl) == GOOD && size > 0) {
784 if (spcl.c_type == TS_ADDR)
785 goto loop;
786 Dprintf(stdout,
787 "Missing address (header) block for %s at %ld blocks\n",
788 curfile.name, (long)blksread);
789 }
790 if (curblk > 0) {
791 (*fill)((char *)buf, (size_t)(curblk * TP_BSIZE) + size);
792 last_write_was_hole = 0;
793 }
794 if (last_write_was_hole) {
795 ftruncate(ofile, origsize);
796 }
797 findinode(&spcl);
798 gettingfile = 0;
799 }
800
801 /*
802 * Write out the next block of a file.
803 */
804 static void
805 xtrfile(char *buf, size_t size)
806 {
807
808 if (Nflag)
809 return;
810 if (write(ofile, buf, (int) size) == -1)
811 err(1, "write error extracting inode %lu, name %s\nwrite",
812 (unsigned long)curfile.ino, curfile.name);
813 }
814
815 /*
816 * Skip over a hole in a file.
817 */
818 /* ARGSUSED */
819 static void
820 xtrskip(char *buf, size_t size)
821 {
822
823 if (lseek(ofile, (off_t)size, SEEK_CUR) == -1)
824 err(1, "seek error extracting inode %lu, name %s\nlseek",
825 (unsigned long)curfile.ino, curfile.name);
826 }
827
828 /*
829 * Collect the next block of a symbolic link.
830 */
831 static void
832 xtrlnkfile(char *buf, size_t size)
833 {
834
835 pathlen += size;
836 if (pathlen > MAXPATHLEN)
837 errx(1, "symbolic link name: %s->%s%s; too long %d",
838 curfile.name, lnkbuf, buf, pathlen);
839 (void) strcat(lnkbuf, buf);
840 }
841
842 /*
843 * Skip over a hole in a symbolic link (should never happen).
844 */
845 /* ARGSUSED */
846 static void
847 xtrlnkskip(char *buf, size_t size)
848 {
849
850 errx(1, "unallocated block in symbolic link %s", curfile.name);
851 }
852
853 /*
854 * Collect the next block of a bit map.
855 */
856 static void
857 xtrmap(char *buf, size_t size)
858 {
859
860 memmove(map, buf, size);
861 map += size;
862 }
863
864 /*
865 * Skip over a hole in a bit map (should never happen).
866 */
867 /* ARGSUSED */
868 static void
869 xtrmapskip(char *buf, size_t size)
870 {
871
872 panic("hole in map\n");
873 map += size;
874 }
875
876 /*
877 * Noop, when an extraction function is not needed.
878 */
879 /* ARGSUSED */
880 void
881 xtrnull(char *buf, size_t size)
882 {
883
884 return;
885 }
886
887 #if COMPARE_ONTHEFLY
888 /*
889 * Compare the next block of a file.
890 */
891 static void
892 xtrcmpfile(char *buf, size_t size)
893 {
894 static char cmpbuf[MAXBSIZE];
895
896 if (cmperror)
897 return;
898
899 if (read(ifile, cmpbuf, size) != size) {
900 fprintf(stderr, "%s: size has changed.\n",
901 curfile.name);
902 cmperror = 1;
903 return;
904 }
905
906 if (memcmp(buf, cmpbuf, size) != 0) {
907 fprintf(stderr, "%s: tape and disk copies are different\n",
908 curfile.name);
909 cmperror = 1;
910 return;
911 }
912 }
913
914 /*
915 * Skip over a hole in a file.
916 */
917 static void
918 xtrcmpskip(char *buf, size_t size)
919 {
920 static char cmpbuf[MAXBSIZE];
921 int i;
922
923 if (cmperror)
924 return;
925
926 if (read(ifile, cmpbuf, size) != size) {
927 fprintf(stderr, "%s: size has changed.\n",
928 curfile.name);
929 cmperror = 1;
930 return;
931 }
932
933 for (i = 0; i < size; ++i)
934 if (cmpbuf[i] != '\0') {
935 fprintf(stderr, "%s: tape and disk copies are different\n",
936 curfile.name);
937 cmperror = 1;
938 return;
939 }
940 }
941 #endif /* COMPARE_ONTHEFLY */
942
943 #if !COMPARE_ONTHEFLY
944 static int
945 do_cmpfiles(int fd_tape, int fd_disk, long size)
946 {
947 static char buf_tape[BUFSIZ];
948 static char buf_disk[BUFSIZ];
949 ssize_t n_tape;
950 ssize_t n_disk;
951
952 while (size > 0) {
953 if ((n_tape = read(fd_tape, buf_tape, sizeof(buf_tape))) < 1) {
954 close(fd_tape), close(fd_disk);
955 panic("do_cmpfiles: unexpected EOF[1]");
956 }
957 if ((n_disk = read(fd_disk, buf_disk, sizeof(buf_tape))) < 1) {
958 close(fd_tape), close(fd_disk);
959 panic("do_cmpfiles: unexpected EOF[2]");
960 }
961 if (n_tape != n_disk) {
962 close(fd_tape), close(fd_disk);
963 panic("do_cmpfiles: sizes different!");
964 }
965 if (memcmp(buf_tape, buf_disk, (size_t)n_tape) != 0) return (1);
966 size -= n_tape;
967 }
968 return (0);
969 }
970
971 /* for debugging compare problems */
972 #undef COMPARE_FAIL_KEEP_FILE
973
974 static
975 #ifdef COMPARE_FAIL_KEEP_FILE
976 /* return true if tapefile should be unlinked after compare */
977 int
978 #else
979 void
980 #endif
981 cmpfiles(char *tapefile, char *diskfile, struct stat *sbuf_disk)
982 {
983 struct stat sbuf_tape;
984 int fd_tape, fd_disk;
985
986 if (stat(tapefile, &sbuf_tape) != 0) {
987 panic("Can't lstat tmp file %s: %s\n", tapefile,
988 strerror(errno));
989 compare_errors = 1;
990 }
991
992 if (sbuf_disk->st_size != sbuf_tape.st_size) {
993 fprintf(stderr,
994 "%s: size changed from %ld to %ld.\n",
995 diskfile, (long)sbuf_tape.st_size, (long)sbuf_disk->st_size);
996 compare_errors = 1;
997 #ifdef COMPARE_FAIL_KEEP_FILE
998 return (0);
999 #else
1000 return;
1001 #endif
1002 }
1003
1004 if ((fd_tape = open(tapefile, O_RDONLY)) < 0) {
1005 panic("Can't open %s: %s\n", tapefile, strerror(errno));
1006 compare_errors = 1;
1007 }
1008 if ((fd_disk = open(diskfile, O_RDONLY)) < 0) {
1009 close(fd_tape);
1010 panic("Can't open %s: %s\n", diskfile, strerror(errno));
1011 compare_errors = 1;
1012 }
1013
1014 if (do_cmpfiles(fd_tape, fd_disk, sbuf_tape.st_size)) {
1015 fprintf(stderr, "%s: tape and disk copies are different\n",
1016 diskfile);
1017 close(fd_tape);
1018 close(fd_disk);
1019 compare_errors = 1;
1020 #ifdef COMPARE_FAIL_KEEP_FILE
1021 /* rename the file to live in /tmp */
1022 /* rename `tapefile' to /tmp/<basename of diskfile> */
1023 {
1024 char *p = strrchr(diskfile, '/');
1025 char newname[MAXPATHLEN];
1026 if (!p) {
1027 panic("can't find / in %s\n", diskfile);
1028 }
1029 snprintf(newname, sizeof(newname), "%s/debug/%s", tmpdir, p + 1);
1030 if (rename(tapefile, newname)) {
1031 panic("rename from %s to %s failed: %s\n",
1032 tapefile, newname,
1033 strerror(errno));
1034 } else {
1035 fprintf(stderr, "*** %s saved to %s\n",
1036 tapefile, newname);
1037 }
1038 }
1039
1040 /* don't unlink the file (it's not there anymore */
1041 /* anyway) */
1042 return (0);
1043 #else
1044 return;
1045 #endif
1046 }
1047 close(fd_tape);
1048 close(fd_disk);
1049 #ifdef COMPARE_FAIL_KEEP_FILE
1050 return (1);
1051 #endif
1052 }
1053 #endif /* !COMPARE_ONTHEFLY */
1054
1055 #if !COMPARE_ONTHEFLY
1056 static char tmpfilename[MAXPATHLEN];
1057 #endif
1058
1059 void
1060 comparefile(char *name)
1061 {
1062 int mode;
1063 struct stat sb;
1064 int r;
1065 #if !COMPARE_ONTHEFLY
1066 static char *tmpfile = NULL;
1067 struct stat stemp;
1068 #endif
1069
1070 if ((r = lstat(name, &sb)) != 0) {
1071 warn("%s: does not exist (%d)", name, r);
1072 compare_errors = 1;
1073 skipfile();
1074 return;
1075 }
1076
1077 curfile.name = name;
1078 curfile.action = USING;
1079 mode = curfile.dip->di_mode;
1080
1081 Vprintf(stdout, "comparing %s (size: %ld, mode: 0%o)\n", name,
1082 (long)sb.st_size, mode);
1083
1084 if (sb.st_mode != mode) {
1085 fprintf(stderr, "%s: mode changed from 0%o to 0%o.\n",
1086 name, mode & 07777, sb.st_mode & 07777);
1087 compare_errors = 1;
1088 }
1089 switch (mode & IFMT) {
1090 default:
1091 skipfile();
1092 return;
1093
1094 case IFSOCK:
1095 skipfile();
1096 return;
1097
1098 case IFDIR:
1099 skipfile();
1100 return;
1101
1102 case IFLNK: {
1103 char lbuf[MAXPATHLEN + 1];
1104 int lsize;
1105
1106 if (!(sb.st_mode & S_IFLNK)) {
1107 fprintf(stderr, "%s: is no longer a symbolic link\n",
1108 name);
1109 compare_errors = 1;
1110 return;
1111 }
1112 lnkbuf[0] = '\0';
1113 pathlen = 0;
1114 getfile(xtrlnkfile, xtrlnkskip);
1115 if (pathlen == 0) {
1116 fprintf(stderr,
1117 "%s: zero length symbolic link (ignored)\n",
1118 name);
1119 compare_errors = 1;
1120 return;
1121 }
1122 if ((lsize = readlink(name, lbuf, MAXPATHLEN)) < 0) {
1123 panic("readlink of %s failed: %s", name,
1124 strerror(errno));
1125 compare_errors = 1;
1126 }
1127 lbuf[lsize] = 0;
1128 if (strcmp(lbuf, lnkbuf) != 0) {
1129 fprintf(stderr,
1130 "%s: symbolic link changed from %s to %s.\n",
1131 name, lnkbuf, lbuf);
1132 compare_errors = 1;
1133 return;
1134 }
1135 return;
1136 }
1137
1138 case IFCHR:
1139 case IFBLK:
1140 if (!(sb.st_mode & (S_IFCHR|S_IFBLK))) {
1141 fprintf(stderr, "%s: no longer a special file\n",
1142 name);
1143 compare_errors = 1;
1144 skipfile();
1145 return;
1146 }
1147
1148 if (sb.st_rdev != (int)curfile.dip->di_rdev) {
1149 fprintf(stderr,
1150 "%s: device changed from %d,%d to %d,%d.\n",
1151 name,
1152 ((int)curfile.dip->di_rdev >> 8) & 0xff,
1153 (int)curfile.dip->di_rdev & 0xff,
1154 ((int)sb.st_rdev >> 8) & 0xff,
1155 (int)sb.st_rdev & 0xff);
1156 compare_errors = 1;
1157 }
1158 skipfile();
1159 return;
1160
1161 case IFREG:
1162 #if COMPARE_ONTHEFLY
1163 if ((ifile = open(name, O_RDONLY)) < 0) {
1164 panic("Can't open %s: %s\n", name, strerror(errno));
1165 skipfile();
1166 compare_errors = 1;
1167 }
1168 else {
1169 cmperror = 0;
1170 getfile(xtrcmpfile, xtrcmpskip);
1171 if (!cmperror) {
1172 char c;
1173 if (read(ifile, &c, 1) != 0) {
1174 fprintf(stderr, "%s: size has changed.\n",
1175 name);
1176 cmperror = 1;
1177 }
1178 }
1179 if (cmperror)
1180 compare_errors = 1;
1181 close(ifile);
1182 }
1183 #else
1184 if (tmpfile == NULL) {
1185 /* argument to mktemp() must not be in RO space: */
1186 snprintf(tmpfilename, sizeof(tmpfilename), "%s/restoreCXXXXXX", tmpdir);
1187 tmpfile = mktemp(&tmpfilename[0]);
1188 }
1189 if ((stat(tmpfile, &stemp) == 0) && (unlink(tmpfile) != 0)) {
1190 panic("cannot delete tmp file %s: %s\n",
1191 tmpfile, strerror(errno));
1192 }
1193 if ((ofile = creat(tmpfile, 0600)) < 0) {
1194 panic("cannot create file temp file %s: %s\n",
1195 name, strerror(errno));
1196 }
1197 getfile(xtrfile, xtrskip);
1198 (void) close(ofile);
1199 #ifdef COMPARE_FAIL_KEEP_FILE
1200 if (cmpfiles(tmpfile, name, &sb))
1201 unlink(tmpfile);
1202 #else
1203 cmpfiles(tmpfile, name, &sb);
1204 unlink(tmpfile);
1205 #endif
1206 #endif /* COMPARE_ONTHEFLY */
1207 return;
1208 }
1209 /* NOTREACHED */
1210 }
1211
1212 /*
1213 * Read TP_BSIZE blocks from the input.
1214 * Handle read errors, and end of media.
1215 */
1216 static void
1217 readtape(char *buf)
1218 {
1219 ssize_t rd, newvol, i;
1220 int cnt, seek_failed;
1221
1222 if (blkcnt < numtrec) {
1223 memmove(buf, &tapebuf[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1224 blksread++;
1225 tpblksread++;
1226 return;
1227 }
1228 for (i = 0; i < ntrec; i++)
1229 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1230 if (numtrec == 0)
1231 numtrec = ntrec;
1232 cnt = ntrec * TP_BSIZE;
1233 rd = 0;
1234 getmore:
1235 #ifdef RRESTORE
1236 if (host)
1237 i = rmtread(&tapebuf[rd], cnt);
1238 else
1239 #endif
1240 i = read(mt, &tapebuf[rd], cnt);
1241 /*
1242 * Check for mid-tape short read error.
1243 * If found, skip rest of buffer and start with the next.
1244 */
1245 if (!pipein && numtrec < ntrec && i > 0) {
1246 Dprintf(stdout, "mid-media short read error.\n");
1247 numtrec = ntrec;
1248 }
1249 /*
1250 * Handle partial block read.
1251 */
1252 if (pipein && i == 0 && rd > 0)
1253 i = rd;
1254 else if (i > 0 && i != ntrec * TP_BSIZE) {
1255 if (pipein) {
1256 rd += i;
1257 cnt -= i;
1258 if (cnt > 0)
1259 goto getmore;
1260 i = rd;
1261 } else {
1262 /*
1263 * Short read. Process the blocks read.
1264 */
1265 if (i % TP_BSIZE != 0)
1266 Vprintf(stdout,
1267 "partial block read: %ld should be %ld\n",
1268 (long)i, ntrec * TP_BSIZE);
1269 numtrec = i / TP_BSIZE;
1270 }
1271 }
1272 /*
1273 * Handle read error.
1274 */
1275 if (i < 0) {
1276 fprintf(stderr, "Tape read error while ");
1277 switch (curfile.action) {
1278 default:
1279 fprintf(stderr, "trying to set up tape\n");
1280 break;
1281 case UNKNOWN:
1282 fprintf(stderr, "trying to resynchronize\n");
1283 break;
1284 case USING:
1285 fprintf(stderr, "restoring %s\n", curfile.name);
1286 break;
1287 case SKIP:
1288 fprintf(stderr, "skipping over inode %lu\n",
1289 (unsigned long)curfile.ino);
1290 break;
1291 }
1292 if (!yflag && !reply("continue"))
1293 exit(1);
1294 i = ntrec * TP_BSIZE;
1295 memset(tapebuf, 0, (size_t)i);
1296 #ifdef RRESTORE
1297 if (host)
1298 seek_failed = (rmtseek(i, 1) < 0);
1299 else
1300 #endif
1301 seek_failed = (lseek(mt, i, SEEK_CUR) == (off_t)-1);
1302
1303 if (seek_failed)
1304 err(1, "continuation failed");
1305 }
1306 /*
1307 * Handle end of tape.
1308 */
1309 if (i == 0) {
1310 Vprintf(stdout, "End-of-tape encountered\n");
1311 if (!pipein) {
1312 newvol = volno + 1;
1313 volno = 0;
1314 numtrec = 0;
1315 getvol(newvol);
1316 readtape(buf);
1317 return;
1318 }
1319 if (rd % TP_BSIZE != 0)
1320 panic("partial block read: %d should be %d\n",
1321 rd, ntrec * TP_BSIZE);
1322 terminateinput();
1323 memmove(&tapebuf[rd], &endoftapemark, TP_BSIZE);
1324 }
1325 blkcnt = 0;
1326 memmove(buf, &tapebuf[(blkcnt++ * TP_BSIZE)], TP_BSIZE);
1327 blksread++;
1328 tpblksread++;
1329 }
1330
1331 static void
1332 findtapeblksize(void)
1333 {
1334 register long i;
1335
1336 for (i = 0; i < ntrec; i++)
1337 ((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
1338 blkcnt = 0;
1339 #ifdef RRESTORE
1340 if (host)
1341 i = rmtread(tapebuf, (size_t)(ntrec * TP_BSIZE));
1342 else
1343 #endif
1344 i = read(mt, tapebuf, (size_t)(ntrec * TP_BSIZE));
1345
1346 if (i <= 0)
1347 err(1, "tape read error");
1348 if (i % TP_BSIZE != 0)
1349 errx(1, "Tape block size (%ld) is not a multiple of dump block size (%d)",
1350 (long)i, TP_BSIZE);
1351 ntrec = i / TP_BSIZE;
1352 numtrec = ntrec;
1353 Vprintf(stdout, "Tape block size is %ld\n", ntrec);
1354 }
1355
1356 void
1357 closemt(void)
1358 {
1359
1360 if (mt < 0)
1361 return;
1362 #ifdef RRESTORE
1363 if (host)
1364 rmtclose();
1365 else
1366 #endif
1367 (void) close(mt);
1368 }
1369
1370 /*
1371 * Read the next block from the tape.
1372 * Check to see if it is one of several vintage headers.
1373 * If it is an old style header, convert it to a new style header.
1374 * If it is not any valid header, return an error.
1375 */
1376 static int
1377 gethead(struct s_spcl *buf)
1378 {
1379 int32_t i;
1380 union {
1381 quad_t qval;
1382 int32_t val[2];
1383 } qcvt;
1384 union u_ospcl {
1385 char dummy[TP_BSIZE];
1386 struct s_ospcl {
1387 int32_t c_type;
1388 int32_t c_date;
1389 int32_t c_ddate;
1390 int32_t c_volume;
1391 int32_t c_tapea;
1392 u_int16_t c_inumber;
1393 int32_t c_magic;
1394 int32_t c_checksum;
1395 struct odinode {
1396 u_int16_t odi_mode;
1397 u_int16_t odi_nlink;
1398 u_int16_t odi_uid;
1399 u_int16_t odi_gid;
1400 int32_t odi_size;
1401 int32_t odi_rdev;
1402 char odi_addr[36];
1403 int32_t odi_atime;
1404 int32_t odi_mtime;
1405 int32_t odi_ctime;
1406 } c_dinode;
1407 int32_t c_count;
1408 char c_addr[256];
1409 } s_ospcl;
1410 } u_ospcl;
1411
1412 if (!cvtflag) {
1413 readtape((char *)buf);
1414 if (buf->c_magic != NFS_MAGIC) {
1415 if (swabi(buf->c_magic) != NFS_MAGIC)
1416 return (FAIL);
1417 if (!Bcvt) {
1418 Vprintf(stdout, "Note: Doing Byte swapping\n");
1419 Bcvt = 1;
1420 }
1421 }
1422 if (checksum((int *)buf) == FAIL)
1423 return (FAIL);
1424 if (Bcvt)
1425 swabst((u_char *)"8i4s31i528bi192b2i", (u_char *)buf);
1426 goto good;
1427 }
1428 readtape((char *)(&u_ospcl.s_ospcl));
1429 memset((char *)buf, 0, (long)TP_BSIZE);
1430 buf->c_type = u_ospcl.s_ospcl.c_type;
1431 buf->c_date = u_ospcl.s_ospcl.c_date;
1432 buf->c_ddate = u_ospcl.s_ospcl.c_ddate;
1433 buf->c_volume = u_ospcl.s_ospcl.c_volume;
1434 buf->c_tapea = u_ospcl.s_ospcl.c_tapea;
1435 buf->c_inumber = u_ospcl.s_ospcl.c_inumber;
1436 buf->c_checksum = u_ospcl.s_ospcl.c_checksum;
1437 buf->c_magic = u_ospcl.s_ospcl.c_magic;
1438 buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode;
1439 buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink;
1440 buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid;
1441 buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid;
1442 buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size;
1443 buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev;
1444 #ifdef __linux__
1445 buf->c_dinode.di_atime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_atime;
1446 buf->c_dinode.di_mtime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_mtime;
1447 buf->c_dinode.di_ctime.tv_sec = u_ospcl.s_ospcl.c_dinode.odi_ctime;
1448 #else /* __linux__ */
1449 buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime;
1450 buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime;
1451 buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime;
1452 #endif /* __linux__ */
1453 buf->c_count = u_ospcl.s_ospcl.c_count;
1454 memmove(buf->c_addr, u_ospcl.s_ospcl.c_addr, (long)256);
1455 if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC ||
1456 checksum((int *)(&u_ospcl.s_ospcl)) == FAIL)
1457 return(FAIL);
1458 buf->c_magic = NFS_MAGIC;
1459
1460 good:
1461 if ((buf->c_dinode.di_size == 0 || buf->c_dinode.di_size > 0xfffffff) &&
1462 (buf->c_dinode.di_mode & IFMT) == IFDIR && Qcvt == 0) {
1463 qcvt.qval = buf->c_dinode.di_size;
1464 if (qcvt.val[0] || qcvt.val[1]) {
1465 printf("Note: Doing Quad swapping\n");
1466 Qcvt = 1;
1467 }
1468 }
1469 if (Qcvt) {
1470 qcvt.qval = buf->c_dinode.di_size;
1471 i = qcvt.val[1];
1472 qcvt.val[1] = qcvt.val[0];
1473 qcvt.val[0] = i;
1474 buf->c_dinode.di_size = qcvt.qval;
1475 }
1476 readmapflag = 0;
1477
1478 switch (buf->c_type) {
1479
1480 case TS_CLRI:
1481 case TS_BITS:
1482 /*
1483 * Have to patch up missing information in bit map headers
1484 */
1485 buf->c_inumber = 0;
1486 buf->c_dinode.di_size = buf->c_count * TP_BSIZE;
1487 if (buf->c_count > TP_NINDIR)
1488 readmapflag = 1;
1489 else
1490 for (i = 0; i < buf->c_count; i++)
1491 buf->c_addr[i]++;
1492 break;
1493
1494 case TS_TAPE:
1495 if ((buf->c_flags & DR_NEWINODEFMT) == 0)
1496 oldinofmt = 1;
1497 /* fall through */
1498 case TS_END:
1499 buf->c_inumber = 0;
1500 break;
1501
1502 case TS_INODE:
1503 case TS_ADDR:
1504 break;
1505
1506 default:
1507 panic("gethead: unknown inode type %d\n", buf->c_type);
1508 break;
1509 }
1510 /*
1511 * If we are restoring a filesystem with old format inodes,
1512 * copy the uid/gid to the new location.
1513 */
1514 if (oldinofmt) {
1515 buf->c_dinode.di_uid = buf->c_dinode.di_ouid;
1516 buf->c_dinode.di_gid = buf->c_dinode.di_ogid;
1517 }
1518 if (dflag)
1519 accthdr(buf);
1520 return(GOOD);
1521 }
1522
1523 /*
1524 * Check that a header is where it belongs and predict the next header
1525 */
1526 static void
1527 accthdr(struct s_spcl *header)
1528 {
1529 static ino_t previno = 0x7fffffff;
1530 static int prevtype;
1531 static long predict;
1532 long blks, i;
1533
1534 if (header->c_type == TS_TAPE) {
1535 fprintf(stderr, "Volume header (%s inode format) ",
1536 oldinofmt ? "old" : "new");
1537 if (header->c_firstrec)
1538 fprintf(stderr, "begins with record %d",
1539 header->c_firstrec);
1540 fprintf(stderr, "\n");
1541 previno = 0x7fffffff;
1542 return;
1543 }
1544 if (previno == 0x7fffffff)
1545 goto newcalc;
1546 switch (prevtype) {
1547 case TS_BITS:
1548 fprintf(stderr, "Dumped inodes map header");
1549 break;
1550 case TS_CLRI:
1551 fprintf(stderr, "Used inodes map header");
1552 break;
1553 case TS_INODE:
1554 fprintf(stderr, "File header, ino %lu", (unsigned long)previno);
1555 break;
1556 case TS_ADDR:
1557 fprintf(stderr, "File continuation header, ino %ld", (long)previno);
1558 break;
1559 case TS_END:
1560 fprintf(stderr, "End of tape header");
1561 break;
1562 }
1563 if (predict != blksread - 1)
1564 fprintf(stderr, "; predicted %ld blocks, got %ld blocks",
1565 predict, blksread - 1);
1566 fprintf(stderr, "\n");
1567 newcalc:
1568 blks = 0;
1569 if (header->c_type != TS_END)
1570 for (i = 0; i < header->c_count; i++)
1571 if (readmapflag || header->c_addr[i] != 0)
1572 blks++;
1573 predict = blks;
1574 blksread = 0;
1575 prevtype = header->c_type;
1576 previno = header->c_inumber;
1577 }
1578
1579 /*
1580 * Find an inode header.
1581 * Complain if had to skip, and complain is set.
1582 */
1583 static void
1584 findinode(struct s_spcl *header)
1585 {
1586 static long skipcnt = 0;
1587 long i;
1588 char buf[TP_BSIZE];
1589
1590 curfile.name = "<name unknown>";
1591 curfile.action = UNKNOWN;
1592 curfile.dip = NULL;
1593 curfile.ino = 0;
1594 do {
1595 if (header->c_magic != NFS_MAGIC) {
1596 skipcnt++;
1597 while (gethead(header) == FAIL ||
1598 header->c_date != dumpdate)
1599 skipcnt++;
1600 }
1601 switch (header->c_type) {
1602
1603 case TS_ADDR:
1604 /*
1605 * Skip up to the beginning of the next record
1606 */
1607 for (i = 0; i < header->c_count; i++)
1608 if (header->c_addr[i])
1609 readtape(buf);
1610 while (gethead(header) == FAIL ||
1611 header->c_date != dumpdate)
1612 skipcnt++;
1613 break;
1614
1615 case TS_INODE:
1616 curfile.dip = &header->c_dinode;
1617 curfile.ino = header->c_inumber;
1618 break;
1619
1620 case TS_END:
1621 curfile.ino = maxino;
1622 break;
1623
1624 case TS_CLRI:
1625 curfile.name = "<file removal list>";
1626 break;
1627
1628 case TS_BITS:
1629 curfile.name = "<file dump list>";
1630 break;
1631
1632 case TS_TAPE:
1633 panic("unexpected tape header\n");
1634 /* NOTREACHED */
1635
1636 default:
1637 panic("unknown tape header type %d\n", spcl.c_type);
1638 /* NOTREACHED */
1639
1640 }
1641 } while (header->c_type == TS_ADDR);
1642 if (skipcnt > 0)
1643 fprintf(stderr, "resync restore, skipped %ld blocks\n",
1644 skipcnt);
1645 skipcnt = 0;
1646 }
1647
1648 static int
1649 checksum(int *buf)
1650 {
1651 register int i, j;
1652
1653 j = sizeof(union u_spcl) / sizeof(int);
1654 i = 0;
1655 if(!Bcvt) {
1656 do
1657 i += *buf++;
1658 while (--j);
1659 } else {
1660 /* What happens if we want to read restore tapes
1661 for a 16bit int machine??? */
1662 do
1663 i += swabi(*buf++);
1664 while (--j);
1665 }
1666
1667 if (i != CHECKSUM) {
1668 fprintf(stderr, "Checksum error %o, inode %lu file %s\n", i,
1669 (unsigned long)curfile.ino, curfile.name);
1670 return(FAIL);
1671 }
1672 return(GOOD);
1673 }
1674
1675 #ifdef RRESTORE
1676 #ifdef __STDC__
1677 #include <stdarg.h>
1678 #else
1679 #include <varargs.h>
1680 #endif
1681
1682 void
1683 #ifdef __STDC__
1684 msg(const char *fmt, ...)
1685 #else
1686 msg(fmt, va_alist)
1687 char *fmt;
1688 va_dcl
1689 #endif
1690 {
1691 va_list ap;
1692 #ifdef __STDC__
1693 va_start(ap, fmt);
1694 #else
1695 va_start(ap);
1696 #endif
1697 (void)vfprintf(stderr, fmt, ap);
1698 va_end(ap);
1699 }
1700 #endif /* RRESTORE */
1701
1702 static u_char *
1703 swab16(u_char *sp, int n)
1704 {
1705 char c;
1706
1707 while (--n >= 0) {
1708 c = sp[0]; sp[0] = sp[1]; sp[1] = c;
1709 sp += 2;
1710 }
1711 return (sp);
1712 }
1713
1714 static u_char *
1715 swab32(u_char *sp, int n)
1716 {
1717 char c;
1718
1719 while (--n >= 0) {
1720 c = sp[0]; sp[0] = sp[3]; sp[3] = c;
1721 c = sp[1]; sp[1] = sp[2]; sp[2] = c;
1722 sp += 4;
1723 }
1724 return (sp);
1725 }
1726
1727 static u_char *
1728 swab64(u_char *sp, int n)
1729 {
1730 char c;
1731
1732 while (--n >= 0) {
1733 c = sp[0]; sp[0] = sp[7]; sp[7] = c;
1734 c = sp[1]; sp[1] = sp[6]; sp[6] = c;
1735 c = sp[2]; sp[2] = sp[5]; sp[5] = c;
1736 c = sp[3]; sp[3] = sp[4]; sp[4] = c;
1737 sp += 8;
1738 }
1739 return (sp);
1740 }
1741
1742 void
1743 swabst(u_char *cp, u_char *sp)
1744 {
1745 int n = 0;
1746
1747 while (*cp) {
1748 switch (*cp) {
1749 case '0': case '1': case '2': case '3': case '4':
1750 case '5': case '6': case '7': case '8': case '9':
1751 n = (n * 10) + (*cp++ - '0');
1752 continue;
1753
1754 case 's': case 'w': case 'h':
1755 if (n == 0)
1756 n = 1;
1757 sp = swab16(sp, n);
1758 break;
1759
1760 case 'i':
1761 if (n == 0)
1762 n = 1;
1763 sp = swab32(sp, n);
1764 break;
1765
1766 case 'l':
1767 if (n == 0)
1768 n = 1;
1769 sp = swab64(sp, n);
1770 break;
1771
1772 default: /* Any other character, like 'b' counts as byte. */
1773 if (n == 0)
1774 n = 1;
1775 sp += n;
1776 break;
1777 }
1778 cp++;
1779 n = 0;
1780 }
1781 }
1782
1783 static u_int
1784 swabi(u_int x)
1785 {
1786 swabst((u_char *)"i", (u_char *)&x);
1787 return (x);
1788 }
1789
1790 static u_long
1791 swabl(u_long x)
1792 {
1793 swabst((u_char *)"l", (u_char *)&x);
1794 return (x);
1795 }
Unnamed repository; edit this file 'description' to name the repository.