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