![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to allrestor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / local|
Return to allrestor.c CVS log | Up to [Research Unix] / researchv10no / local |
1.1 root 1: static char *sccsid = "@(#)restor.c 4.1 (Berkeley) 10/1/80";
2:
3: #define MAXINO 3000
4: #define BITS 8
5: #define MAXXTR 600
6: #define NCACHE 3
7:
8: #ifndef STANDALONE
9: #include <stdio.h>
10: #include <signal.h>
11: #endif
12: #include <sys/param.h>
13: #include <sys/inode.h>
14: #include <sys/ino.h>
15: #include <sys/fblk.h>
16: #include <sys/filsys.h>
17: #include <sys/dir.h>
18: #include <dumprestor.h>
19:
20: #define MWORD(m,i) (m[(unsigned)(i-1)/MLEN])
21: #define MBIT(i) (1<<((unsigned)(i-1)%MLEN))
22: #define BIS(i,w) (MWORD(w,i) |= MBIT(i))
23: #define BIC(i,w) (MWORD(w,i) &= ~MBIT(i))
24: #define BIT(i,w) (MWORD(w,i) & MBIT(i))
25:
26: struct filsys sblock;
27:
28: int fi;
29: ino_t ino, maxi, curino;
30:
31: int mt;
32: char tapename[] = "/dev/rmt8";
33: char *magtape = tapename;
34: #ifdef STANDALONE
35: char mbuf[50];
36: #endif
37:
38: #ifndef STANDALONE
39: daddr_t seekpt;
40: int df, ofile;
41: char dirfile[] = "rstXXXXXX";
42:
43: struct {
44: ino_t t_ino;
45: daddr_t t_seekpt;
46: } inotab[MAXINO];
47: int ipos;
48:
49: #define ONTAPE 1
50: #define XTRACTD 2
51: #define XINUSE 4
52: struct xtrlist {
53: ino_t x_ino;
54: char x_flags;
55: } xtrlist[MAXXTR];
56:
57: char name[12];
58:
59: char drblock[BSIZE];
60: int bpt;
61: #endif
62:
63: int eflag;
64:
65: int volno = 1;
66:
67: struct dinode tino, dino;
68: daddr_t taddr[NADDR];
69:
70: daddr_t curbno;
71:
72: short dumpmap[MSIZ];
73: short clrimap[MSIZ];
74:
75:
76: int bct = NTREC+1;
77: char tbf[NTREC*BSIZE];
78:
79: struct cache {
80: daddr_t c_bno;
81: int c_time;
82: char c_block[BSIZE];
83: } cache[NCACHE];
84: int curcache;
85:
86: main(argc, argv)
87: char *argv[];
88: {
89: register char *cp;
90: char command;
91: int done();
92:
93: #ifndef STANDALONE
94: mktemp(dirfile);
95: if (argc < 2) {
96: usage:
97: printf("Usage: restor x file file..., restor r filesys, or restor t\n");
98: exit(1);
99: }
100: argv++;
101: argc -= 2;
102: for (cp = *argv++; *cp; cp++) {
103: switch (*cp) {
104: case '-':
105: break;
106: case 'f':
107: magtape = *argv++;
108: argc--;
109: break;
110: case 'r':
111: case 'R':
112: case 't':
113: case 'x':
114: command = *cp;
115: break;
116: default:
117: printf("Bad key character %c\n", *cp);
118: goto usage;
119: }
120: }
121: if (command == 'x') {
122: if (signal(SIGINT, done) == SIG_IGN)
123: signal(SIGINT, SIG_IGN);
124: if (signal(SIGTERM, done) == SIG_IGN)
125: signal(SIGTERM, SIG_IGN);
126:
127: df = creat(dirfile, 0666);
128: if (df < 0) {
129: printf("restor: %s - cannot create directory temporary\n", dirfile);
130: exit(1);
131: }
132: close(df);
133: df = open(dirfile, 2);
134: }
135: doit(command, argc, argv);
136: if (command == 'x')
137: unlink(dirfile);
138: exit(0);
139: #else
140: magtape = "tape";
141: doit('r', 1, 0);
142: #endif
143: }
144:
145: doit(command, argc, argv)
146: char command;
147: int argc;
148: char *argv[];
149: {
150: extern char *ctime();
151: register i, k;
152: ino_t d;
153: #ifndef STANDALONE
154: int xtrfile(), skip();
155: #endif
156: int rstrfile(), rstrskip();
157: struct dinode *ip, *ip1;
158:
159: #ifndef STANDALONE
160: if ((mt = open(magtape, 0)) < 0) {
161: printf("%s: cannot open tape\n", magtape);
162: exit(1);
163: }
164: #else
165: do {
166: printf("Tape? ");
167: gets(mbuf);
168: mt = open(mbuf, 0);
169: } while (mt == -1);
170: magtape = mbuf;
171: #endif
172: switch(command) {
173: #ifndef STANDALONE
174: case 't':
175: if (readhdr(&spcl) == 0) {
176: printf("Tape is not a dump tape\n");
177: exit(1);
178: }
179: printf("Dump date: %s", ctime(&spcl.c_date));
180: printf("Dumped from: %s", ctime(&spcl.c_ddate));
181: return;
182: case 'x':
183: if (readhdr(&spcl) == 0) {
184: printf("Tape is not a dump tape\n");
185: exit(1);
186: }
187: if (checkvol(&spcl, 1) == 0) {
188: printf("Tape is not volume 1 of the dump\n");
189: exit(1);
190: }
191: pass1(); /* This sets the various maps on the way by */
192: i = 0;
193: while (i < MAXXTR-1 && argc--) {
194: if ((d = psearch(*argv)) == 0 || BIT(d, dumpmap) == 0) {
195: printf("%s: not on the tape\n", *argv++);
196: continue;
197: }
198: xtrlist[i].x_ino = d;
199: xtrlist[i].x_flags |= XINUSE;
200: printf("%s: inode %u\n", *argv, d);
201: argv++;
202: i++;
203: }
204: newvol:
205: flsht();
206: close(mt);
207: getvol:
208: printf("Mount desired tape volume: Specify volume #: ");
209: if (gets(tbf) == NULL)
210: return;
211: volno = atoi(tbf);
212: if (volno <= 0) {
213: printf("Volume numbers are positive numerics\n");
214: goto getvol;
215: }
216: mt = open(magtape, 0);
217: if (readhdr(&spcl) == 0) {
218: printf("tape is not dump tape\n");
219: goto newvol;
220: }
221: if (checkvol(&spcl, volno) == 0) {
222: printf("Wrong volume (%d)\n", spcl.c_volume);
223: goto newvol;
224: }
225: rbits:
226: while (gethead(&spcl) == 0)
227: ;
228: if (checktype(&spcl, TS_INODE) == 1) {
229: printf("Can't find inode mask!\n");
230: goto newvol;
231: }
232: if (checktype(&spcl, TS_BITS) == 0)
233: goto rbits;
234: readbits(dumpmap);
235: for (;;) {
236: again:
237: if (ishead(&spcl) == 0)
238: while(gethead(&spcl) == 0)
239: ;
240: if (checktype(&spcl, TS_END) == 1) {
241: printf("end of tape\n");
242: checkdone:
243: return;
244: }
245: if (checktype(&spcl, TS_INODE) == 0) {
246: gethead(&spcl);
247: goto again;
248: }
249: d = spcl.c_inumber;
250: printf("extract file %u\n", d);
251: sprintf(name, "%u", d);
252: if ((ofile = creat(name, 0666)) < 0) {
253: printf("%s: cannot create file\n", name);
254: continue;
255: }
256: chown(name, spcl.c_dinode.di_uid, spcl.c_dinode.di_gid);
257: getfile(ino, xtrfile, skip, spcl.c_dinode.di_size);
258: close(ofile);
259: ;
260: }
261: goto checkdone;
262: #endif
263: case 'r':
264: case 'R':
265: #ifndef STANDALONE
266: if ((fi = open(*argv, 2)) < 0) {
267: printf("%s: cannot open\n", *argv);
268: exit(1);
269: }
270: #else
271: do {
272: char charbuf[50];
273:
274: printf("Disk? ");
275: gets(charbuf);
276: fi = open(charbuf, 2);
277: } while (fi == -1);
278: #endif
279: #ifndef STANDALONE
280: if (command == 'R') {
281: printf("Enter starting volume number: ");
282: if (gets(tbf) == EOF) {
283: volno = 1;
284: printf("\n");
285: }
286: else
287: volno = atoi(tbf);
288: }
289: else
290: #endif
291: volno = 1;
292: printf("Last chance before scribbling on %s. ",
293: #ifdef STANDALONE
294: "disk");
295: #else
296: *argv);
297: #endif
298: while (getchar() != '\n');
299: dread((daddr_t)1, (char *)&sblock, sizeof(sblock));
300: maxi = (sblock.s_isize-2)*INOPB;
301: if (readhdr(&spcl) == 0) {
302: printf("Missing volume record\n");
303: exit(1);
304: }
305: if (checkvol(&spcl, volno) == 0) {
306: printf("Tape is not volume %d\n", volno);
307: exit(1);
308: }
309: gethead(&spcl);
310: for (;;) {
311: ragain:
312: if (ishead(&spcl) == 0) {
313: printf("Missing header block\n");
314: while (gethead(&spcl) == 0)
315: ;
316: eflag++;
317: }
318: if (checktype(&spcl, TS_END) == 1) {
319: printf("End of tape\n");
320: close(mt);
321: dwrite( (daddr_t) 1, (char *) &sblock);
322: return;
323: }
324: if (checktype(&spcl, TS_CLRI) == 1) {
325: readbits(clrimap);
326: for (ino = 1; ino <= maxi; ino++)
327: if (BIT(ino, clrimap) == 0) {
328: getdino(ino, &tino);
329: if (tino.di_mode == 0)
330: continue;
331: itrunc(&tino);
332: clri(&tino);
333: putdino(ino, &tino);
334: }
335: dwrite( (daddr_t) 1, (char *) &sblock);
336: goto ragain;
337: }
338: if (checktype(&spcl, TS_BITS) == 1) {
339: readbits(dumpmap);
340: goto ragain;
341: }
342: if (checktype(&spcl, TS_INODE) == 0) {
343: printf("Unknown header type\n");
344: eflag++;
345: gethead(&spcl);
346: goto ragain;
347: }
348: ino = spcl.c_inumber;
349: if (eflag)
350: printf("Resynced at inode %u\n", ino);
351: eflag = 0;
352: if (ino > maxi) {
353: printf("%u: ilist too small\n", ino);
354: gethead(&spcl);
355: goto ragain;
356: }
357: dino = spcl.c_dinode;
358: getdino(ino, &tino);
359: curbno = 0;
360: itrunc(&tino);
361: clri(&tino);
362: for (i = 0; i < NADDR; i++)
363: taddr[i] = 0;
364: l3tol(taddr, dino.di_addr, 1);
365: getfile(d, rstrfile, rstrskip, dino.di_size);
366: ip = &tino;
367: ltol3(ip->di_addr, taddr, NADDR);
368: ip1 = &dino;
369: ip->di_mode = ip1->di_mode;
370: ip->di_nlink = ip1->di_nlink;
371: ip->di_uid = ip1->di_uid;
372: ip->di_gid = ip1->di_gid;
373: ip->di_size = ip1->di_size;
374: ip->di_atime = ip1->di_atime;
375: ip->di_mtime = ip1->di_mtime;
376: ip->di_ctime = ip1->di_ctime;
377: putdino(ino, &tino);
378: }
379: }
380: }
381:
382: /*
383: * Read the tape, bulding up a directory structure for extraction
384: * by name
385: */
386: #ifndef STANDALONE
387: pass1()
388: {
389: register i;
390: struct dinode *ip;
391: int putdir(), null();
392:
393: while (gethead(&spcl) == 0) {
394: printf("Can't find directory header!\n");
395: }
396: for (;;) {
397: if (checktype(&spcl, TS_BITS) == 1) {
398: readbits(dumpmap);
399: continue;
400: }
401: if (checktype(&spcl, TS_CLRI) == 1) {
402: readbits(clrimap);
403: continue;
404: }
405: if (checktype(&spcl, TS_INODE) == 0) {
406: finish:
407: flsh();
408: close(mt);
409: return;
410: }
411: ip = &spcl.c_dinode;
412: i = ip->di_mode & IFMT;
413: if (i != IFDIR) {
414: goto finish;
415: }
416: inotab[ipos].t_ino = spcl.c_inumber;
417: inotab[ipos++].t_seekpt = seekpt;
418: getfile(spcl.c_inumber, putdir, null, spcl.c_dinode.di_size);
419: putent("\000\000/");
420: }
421: }
422: #endif
423:
424: /*
425: * Do the file extraction, calling the supplied functions
426: * with the blocks
427: */
428: getfile(n, f1, f2, size)
429: ino_t n;
430: int (*f2)(), (*f1)();
431: long size;
432: {
433: register i;
434: struct spcl addrblock;
435: char buf[BSIZE];
436:
437: addrblock = spcl;
438: curino = n;
439: goto start;
440: for (;;) {
441: if (gethead(&addrblock) == 0) {
442: printf("Missing address (header) block\n");
443: goto eloop;
444: }
445: if (checktype(&addrblock, TS_ADDR) == 0) {
446: spcl = addrblock;
447: curino = 0;
448: curino = 0;
449: return;
450: }
451: start:
452: for (i = 0; i < addrblock.c_count; i++) {
453: if (addrblock.c_addr[i]) {
454: readtape(buf);
455: (*f1)(buf, size > BSIZE ? (long) BSIZE : size);
456: }
457: else {
458: clearbuf(buf);
459: (*f2)(buf, size > BSIZE ? (long) BSIZE : size);
460: }
461: if ((size -= BSIZE) <= 0) {
462: eloop:
463: while (gethead(&spcl) == 0)
464: ;
465: if (checktype(&spcl, TS_ADDR) == 1)
466: goto eloop;
467: curino = 0;
468: return;
469: }
470: }
471: }
472: }
473:
474: /*
475: * Do the tape i\/o, dealling with volume changes
476: * etc..
477: */
478: readtape(b)
479: char *b;
480: {
481: register i;
482: struct spcl tmpbuf;
483:
484: if (bct >= NTREC) {
485: for (i = 0; i < NTREC; i++)
486: ((struct spcl *)&tbf[i*BSIZE])->c_magic = 0;
487: bct = 0;
488: if ((i = read(mt, tbf, NTREC*BSIZE)) < 0) {
489: printf("Tape read error: inode %u\n", curino);
490: eflag++;
491: exit(1);
492: }
493: if (i == 0) {
494: bct = NTREC + 1;
495: volno++;
496: loop:
497: flsht();
498: close(mt);
499: printf("Mount volume %d\n", volno);
500: while (getchar() != '\n')
501: ;
502: if ((mt = open(magtape, 0)) == -1) {
503: printf("Cannot open tape!\n");
504: goto loop;
505: }
506: if (readhdr(&tmpbuf) == 0) {
507: printf("Not a dump tape.Try again\n");
508: goto loop;
509: }
510: if (checkvol(&tmpbuf, volno) == 0) {
511: printf("Wrong tape. Try again\n");
512: goto loop;
513: }
514: readtape(b);
515: return;
516: }
517: }
518: copy(&tbf[(bct++*BSIZE)], b, BSIZE);
519: }
520:
521: flsht()
522: {
523: bct = NTREC+1;
524: }
525:
526: copy(f, t, s)
527: register char *f, *t;
528: {
529: register i;
530:
531: i = s;
532: do
533: *t++ = *f++;
534: while (--i);
535: }
536:
537: clearbuf(cp)
538: register char *cp;
539: {
540: register i;
541:
542: i = BSIZE;
543: do
544: *cp++ = 0;
545: while (--i);
546: }
547:
548: /*
549: * Put and get the directory entries from the compressed
550: * directory file
551: */
552: #ifndef STANDALONE
553: putent(cp)
554: char *cp;
555: {
556: register i;
557:
558: for (i = 0; i < sizeof(ino_t); i++)
559: writec(*cp++);
560: for (i = 0; i < DIRSIZ; i++) {
561: writec(*cp);
562: if (*cp++ == 0)
563: return;
564: }
565: return;
566: }
567:
568: getent(bf)
569: register char *bf;
570: {
571: register i;
572:
573: for (i = 0; i < sizeof(ino_t); i++)
574: *bf++ = readc();
575: for (i = 0; i < DIRSIZ; i++)
576: if ((*bf++ = readc()) == 0)
577: return;
578: return;
579: }
580:
581: /*
582: * read/write te directory file
583: */
584: writec(c)
585: char c;
586: {
587: drblock[bpt++] = c;
588: seekpt++;
589: if (bpt >= BSIZE) {
590: bpt = 0;
591: write(df, drblock, BSIZE);
592: }
593: }
594:
595: readc()
596: {
597: if (bpt >= BSIZE) {
598: read(df, drblock, BSIZE);
599: bpt = 0;
600: }
601: return(drblock[bpt++]);
602: }
603:
604: mseek(pt)
605: daddr_t pt;
606: {
607: bpt = BSIZE;
608: lseek(df, pt, 0);
609: }
610:
611: flsh()
612: {
613: write(df, drblock, bpt+1);
614: }
615:
616: /*
617: * search the directory inode ino
618: * looking for entry cp
619: */
620: ino_t
621: search(inum, cp)
622: ino_t inum;
623: char *cp;
624: {
625: register i;
626: struct direct dir;
627:
628: for (i = 0; i < MAXINO; i++)
629: if (inotab[i].t_ino == inum) {
630: goto found;
631: }
632: return(0);
633: found:
634: mseek(inotab[i].t_seekpt);
635: do {
636: getent((char *)&dir);
637: if (direq(dir.d_name, "/"))
638: return(0);
639: } while (direq(dir.d_name, cp) == 0);
640: return(dir.d_ino);
641: }
642:
643: /*
644: * Search the directory tree rooted at inode 2
645: * for the path pointed at by n
646: */
647: psearch(n)
648: char *n;
649: {
650: register char *cp, *cp1;
651: char c;
652:
653: ino = 2;
654: if (*(cp = n) == '/')
655: cp++;
656: next:
657: cp1 = cp + 1;
658: while (*cp1 != '/' && *cp1)
659: cp1++;
660: c = *cp1;
661: *cp1 = 0;
662: ino = search(ino, cp);
663: if (ino == 0) {
664: *cp1 = c;
665: return(0);
666: }
667: *cp1 = c;
668: if (c == '/') {
669: cp = cp1+1;
670: goto next;
671: }
672: return(ino);
673: }
674:
675: direq(s1, s2)
676: register char *s1, *s2;
677: {
678: register i;
679:
680: for (i = 0; i < DIRSIZ; i++)
681: if (*s1++ == *s2) {
682: if (*s2++ == 0)
683: return(1);
684: } else
685: return(0);
686: return(1);
687: }
688: #endif
689:
690: /*
691: * read/write a disk block, be sure to update the buffer
692: * cache if needed.
693: */
694: dwrite(bno, b)
695: daddr_t bno;
696: char *b;
697: {
698: register i;
699:
700: for (i = 0; i < NCACHE; i++) {
701: if (cache[i].c_bno == bno) {
702: copy(b, cache[i].c_block, BSIZE);
703: cache[i].c_time = 0;
704: break;
705: }
706: else
707: cache[i].c_time++;
708: }
709: lseek(fi, bno*BSIZE, 0);
710: if(write(fi, b, BSIZE) != BSIZE) {
711: #ifdef STANDALONE
712: printf("disk write error %D\n", bno);
713: #else
714: fprintf(stderr, "disk write error %ld\n", bno);
715: #endif
716: exit(1);
717: }
718: }
719:
720: dread(bno, buf, cnt)
721: daddr_t bno;
722: char *buf;
723: {
724: register i, j;
725:
726: j = 0;
727: for (i = 0; i < NCACHE; i++) {
728: if (++curcache >= NCACHE)
729: curcache = 0;
730: if (cache[curcache].c_bno == bno) {
731: copy(cache[curcache].c_block, buf, cnt);
732: cache[curcache].c_time = 0;
733: return;
734: }
735: else {
736: cache[curcache].c_time++;
737: if (cache[j].c_time < cache[curcache].c_time)
738: j = curcache;
739: }
740: }
741:
742: lseek(fi, bno*BSIZE, 0);
743: if (read(fi, cache[j].c_block, BSIZE) != BSIZE) {
744: #ifdef STANDALONE
745: printf("read error %D\n", bno);
746: #else
747: printf("read error %ld\n", bno);
748: #endif
749: exit(1);
750: }
751: copy(cache[j].c_block, buf, cnt);
752: cache[j].c_time = 0;
753: cache[j].c_bno = bno;
754: }
755:
756: /*
757: * the inode manpulation routines. Like the system.
758: *
759: * clri zeros the inode
760: */
761: clri(ip)
762: struct dinode *ip;
763: {
764: int i, *p;
765: if (ip->di_mode&IFMT)
766: sblock.s_tinode++;
767: i = sizeof(struct dinode)/sizeof(int);
768: p = (int *)ip;
769: do
770: *p++ = 0;
771: while(--i);
772: }
773:
774: /*
775: * itrunc/tloop/bfree free all of the blocks pointed at by the inode
776: */
777: itrunc(ip)
778: register struct dinode *ip;
779: {
780: register i;
781: daddr_t bn, iaddr[NADDR];
782:
783: if (ip->di_mode == 0)
784: return;
785: i = ip->di_mode & IFMT;
786: if (i != IFDIR && i != IFREG)
787: return;
788: l3tol(iaddr, ip->di_addr, NADDR);
789: for(i=NADDR-1;i>=0;i--) {
790: bn = iaddr[i];
791: if(bn == 0) continue;
792: switch(i) {
793:
794: default:
795: bfree(bn);
796: break;
797:
798: case NADDR-3:
799: tloop(bn, 0, 0);
800: break;
801:
802: case NADDR-2:
803: tloop(bn, 1, 0);
804: break;
805:
806: case NADDR-1:
807: tloop(bn, 1, 1);
808: }
809: }
810: ip->di_size = 0;
811: }
812:
813: tloop(bn, f1, f2)
814: daddr_t bn;
815: int f1, f2;
816: {
817: register i;
818: daddr_t nb;
819: union {
820: char data[BSIZE];
821: daddr_t indir[NINDIR];
822: } ibuf;
823:
824: dread(bn, ibuf.data, BSIZE);
825: for(i=NINDIR-1;i>=0;i--) {
826: nb = ibuf.indir[i];
827: if(nb) {
828: if(f1)
829: tloop(nb, f2, 0);
830: else
831: bfree(nb);
832: }
833: }
834: bfree(bn);
835: }
836:
837: bfree(bn)
838: daddr_t bn;
839: {
840: register i;
841: union {
842: char data[BSIZE];
843: struct fblk frees;
844: } fbun;
845: #define fbuf fbun.frees
846:
847: if(sblock.s_nfree >= NICFREE) {
848: fbuf.df_nfree = sblock.s_nfree;
849: for(i=0;i<NICFREE;i++)
850: fbuf.df_free[i] = sblock.s_free[i];
851: sblock.s_nfree = 0;
852: dwrite(bn, fbun.data);
853: }
854: sblock.s_free[sblock.s_nfree++] = bn;
855: sblock.s_tfree++;
856: }
857:
858: /*
859: * allocate a block off the free list.
860: */
861: daddr_t
862: balloc()
863: {
864: daddr_t bno;
865: register i;
866: static char zeroes[BSIZE];
867: union {
868: char data[BSIZE];
869: struct fblk frees;
870: } fbun;
871: #undef fbuf
872: #define fbuf fbun.frees
873:
874: if(sblock.s_nfree == 0 || (bno=sblock.s_free[--sblock.s_nfree]) == 0) {
875: #ifdef STANDALONE
876: printf("Out of space\n");
877: #else
878: fprintf(stderr, "Out of space.\n");
879: #endif
880: exit(1);
881: }
882: if(sblock.s_nfree == 0) {
883: dread(bno, (char *)&fbuf, BSIZE);
884: sblock.s_nfree = fbuf.df_nfree;
885: for(i=0;i<NICFREE;i++)
886: sblock.s_free[i] = fbuf.df_free[i];
887: }
888: dwrite(bno, zeroes);
889: sblock.s_tfree--;
890: return(bno);
891: }
892:
893: /*
894: * map a block number into a block address, ensuring
895: * all of the correct indirect blocks are around. Allocate
896: * the block requested.
897: */
898: daddr_t
899: bmap(iaddr, bn)
900: daddr_t iaddr[NADDR];
901: daddr_t bn;
902: {
903: register i;
904: int j, sh;
905: daddr_t nb, nnb;
906: daddr_t indir[NINDIR];
907:
908: /*
909: * blocks 0..NADDR-4 are direct blocks
910: */
911: if(bn < NADDR-3) {
912: iaddr[bn] = nb = balloc();
913: return(nb);
914: }
915:
916: /*
917: * addresses NADDR-3, NADDR-2, and NADDR-1
918: * have single, double, triple indirect blocks.
919: * the first step is to determine
920: * how many levels of indirection.
921: */
922: sh = 0;
923: nb = 1;
924: bn -= NADDR-3;
925: for(j=3; j>0; j--) {
926: sh += NSHIFT;
927: nb <<= NSHIFT;
928: if(bn < nb)
929: break;
930: bn -= nb;
931: }
932: if(j == 0) {
933: return((daddr_t)0);
934: }
935:
936: /*
937: * fetch the address from the inode
938: */
939: if((nb = iaddr[NADDR-j]) == 0) {
940: iaddr[NADDR-j] = nb = balloc();
941: }
942:
943: /*
944: * fetch through the indirect blocks
945: */
946: for(; j<=3; j++) {
947: dread(nb, (char *)indir, BSIZE);
948: sh -= NSHIFT;
949: i = (bn>>sh) & NMASK;
950: nnb = indir[i];
951: if(nnb == 0) {
952: nnb = balloc();
953: indir[i] = nnb;
954: dwrite(nb, (char *)indir);
955: }
956: nb = nnb;
957: }
958: return(nb);
959: }
960:
961: /*
962: * read the tape into buf, then return whether or
963: * or not it is a header block.
964: */
965: gethead(buf)
966: struct spcl *buf;
967: {
968: readtape((char *)buf);
969: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0)
970: return(0);
971: return(1);
972: }
973:
974: /*
975: * return whether or not the buffer contains a header block
976: */
977: ishead(buf)
978: struct spcl *buf;
979: {
980: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0)
981: return(0);
982: return(1);
983: }
984:
985: checktype(b, t)
986: struct spcl *b;
987: int t;
988: {
989: return(b->c_type == t);
990: }
991:
992:
993: checksum(b)
994: int *b;
995: {
996: register i, j;
997:
998: j = BSIZE/sizeof(int);
999: i = 0;
1000: do
1001: i += *b++;
1002: while (--j);
1003: if (i != CHECKSUM) {
1004: printf("Checksum error %o\n", i);
1005: return(0);
1006: }
1007: return(1);
1008: }
1009:
1010: checkvol(b, t)
1011: struct spcl *b;
1012: int t;
1013: {
1014: if (b->c_volume == t)
1015: return(1);
1016: return(0);
1017: }
1018:
1019: readhdr(b)
1020: struct spcl *b;
1021: {
1022: if (gethead(b) == 0)
1023: return(0);
1024: if (checktype(b, TS_TAPE) == 0)
1025: return(0);
1026: return(1);
1027: }
1028:
1029: /*
1030: * The next routines are called during file extraction to
1031: * put the data into the right form and place.
1032: */
1033: #ifndef STANDALONE
1034: xtrfile(b, size)
1035: char *b;
1036: long size;
1037: {
1038: write(ofile, b, (int) size);
1039: }
1040:
1041: null() {;}
1042:
1043: skip()
1044: {
1045: lseek(ofile, (long) BSIZE, 1);
1046: }
1047: #endif
1048:
1049:
1050: rstrfile(b, s)
1051: char *b;
1052: long s;
1053: {
1054: daddr_t d;
1055:
1056: d = bmap(taddr, curbno);
1057: dwrite(d, b);
1058: curbno += 1;
1059: }
1060:
1061: rstrskip(b, s)
1062: char *b;
1063: long s;
1064: {
1065: curbno += 1;
1066: }
1067:
1068: #ifndef STANDALONE
1069: putdir(b)
1070: char *b;
1071: {
1072: register struct direct *dp;
1073: register i;
1074:
1075: for (dp = (struct direct *) b, i = 0; i < BSIZE; dp++, i += sizeof(*dp)) {
1076: if (dp->d_ino == 0)
1077: continue;
1078: putent((char *) dp);
1079: }
1080: }
1081: #endif
1082:
1083: /*
1084: * read/write an inode from the disk
1085: */
1086: getdino(inum, b)
1087: ino_t inum;
1088: struct dinode *b;
1089: {
1090: daddr_t bno;
1091: char buf[BSIZE];
1092:
1093: bno = (ino - 1)/INOPB;
1094: bno += 2;
1095: dread(bno, buf, BSIZE);
1096: copy(&buf[((inum-1)%INOPB)*sizeof(struct dinode)], (char *) b, sizeof(struct dinode));
1097: }
1098:
1099: putdino(inum, b)
1100: ino_t inum;
1101: struct dinode *b;
1102: {
1103: daddr_t bno;
1104: char buf[BSIZE];
1105:
1106: if (b->di_mode&IFMT)
1107: sblock.s_tinode--;
1108: bno = ((ino - 1)/INOPB) + 2;
1109: dread(bno, buf, BSIZE);
1110: copy((char *) b, &buf[((inum-1)%INOPB)*sizeof(struct dinode)], sizeof(struct dinode));
1111: dwrite(bno, buf);
1112: }
1113:
1114: /*
1115: * read a bit mask from the tape into m.
1116: */
1117: readbits(m)
1118: short *m;
1119: {
1120: register i;
1121:
1122: i = spcl.c_count;
1123:
1124: while (i--) {
1125: readtape((char *) m);
1126: m += (BSIZE/(MLEN/BITS));
1127: }
1128: while (gethead(&spcl) == 0)
1129: ;
1130: }
1131:
1132: done()
1133: {
1134: #ifndef STANDALONE
1135: unlink(dirfile);
1136: #endif
1137: exit(0);
1138: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.