![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dirs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / restore|
Return to dirs.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / restore |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)dirs.c 3.16 (Berkeley) 83/08/11";
3: #endif
4:
5: /* Copyright (c) 1983 Regents of the University of California */
6:
7: #include "restore.h"
8: #include <dumprestor.h>
9: #include <sys/file.h>
10: #include <sys/dir.h>
11:
12: /*
13: * Symbol table of directories read from tape.
14: */
15: #define HASHSIZE 1000
16: #define INOHASH(val) (val % HASHSIZE)
17: struct inotab {
18: struct inotab *t_next;
19: ino_t t_ino;
20: daddr_t t_seekpt;
21: long t_size;
22: };
23: static struct inotab *inotab[HASHSIZE];
24: extern struct inotab *inotablookup();
25: extern struct inotab *allocinotab();
26:
27: /*
28: * Information retained about directories.
29: */
30: struct modeinfo {
31: ino_t ino;
32: time_t timep[2];
33: short mode;
34: short uid;
35: short gid;
36: };
37:
38: /*
39: * Global variables for this file.
40: */
41: static daddr_t seekpt;
42: static FILE *df, *mf;
43: static DIR *dirp;
44: static char dirfile[32] = "#"; /* No file */
45: static char modefile[32] = "#"; /* No file */
46: extern ino_t search();
47: struct direct *rst_readdir();
48: extern void rst_seekdir();
49:
50: /*
51: * Format of old style directories.
52: */
53: #define ODIRSIZ 14
54: struct odirect {
55: u_short d_ino;
56: char d_name[ODIRSIZ];
57: };
58:
59: /*
60: * Structure and routines associated with listing directories.
61: */
62: struct afile {
63: ino_t fnum; /* inode number of file */
64: char *fname; /* file name */
65: short fflags; /* extraction flags, if any */
66: char ftype; /* file type, e.g. LEAF or NODE */
67: };
68: extern int fcmp();
69: extern char *fmtentry();
70:
71: /*
72: * Extract directory contents, building up a directory structure
73: * on disk for extraction by name.
74: * If genmode is requested, save mode, owner, and times for all
75: * directories on the tape.
76: */
77: extractdirs(genmode)
78: int genmode;
79: {
80: register int i;
81: register struct dinode *ip;
82: struct inotab *itp;
83: struct direct nulldir;
84: int putdir(), null();
85:
86: vprintf(stdout, "Extract directories from tape\n");
87: (void) sprintf(dirfile, "/tmp/rstdir%d", dumpdate);
88: df = fopen(dirfile, "w");
89: if (df == 0) {
90: fprintf(stderr,
91: "restor: %s - cannot create directory temporary\n",
92: dirfile);
93: perror("fopen");
94: done(1);
95: }
96: if (genmode != 0) {
97: (void) sprintf(modefile, "/tmp/rstmode%d", dumpdate);
98: mf = fopen(modefile, "w");
99: if (mf == 0) {
100: fprintf(stderr,
101: "restor: %s - cannot create modefile \n",
102: modefile);
103: perror("fopen");
104: done(1);
105: }
106: }
107: nulldir.d_ino = 0;
108: nulldir.d_namlen = 1;
109: (void) strcpy(nulldir.d_name, "/");
110: nulldir.d_reclen = DIRSIZ(&nulldir);
111: for (;;) {
112: curfile.name = "<directory file - name unknown>";
113: curfile.action = USING;
114: ip = curfile.dip;
115: i = ip->di_mode & IFMT;
116: if (i != IFDIR) {
117: (void) fclose(df);
118: dirp = opendir(dirfile);
119: if (dirp == NULL)
120: perror("opendir");
121: if (mf != NULL)
122: (void) fclose(mf);
123: i = dirlookup(".");
124: if (i == 0)
125: panic("Root directory is not on tape\n");
126: return;
127: }
128: itp = allocinotab(curfile.ino, ip, seekpt);
129: getfile(putdir, null);
130: putent(&nulldir);
131: flushent();
132: itp->t_size = seekpt - itp->t_seekpt;
133: }
134: }
135:
136: /*
137: * skip over all the directories on the tape
138: */
139: skipdirs()
140: {
141:
142: while ((curfile.dip->di_mode & IFMT) == IFDIR) {
143: skipfile();
144: }
145: }
146:
147: /*
148: * Recursively find names and inumbers of all files in subtree
149: * pname and pass them off to be processed.
150: */
151: treescan(pname, ino, todo)
152: char *pname;
153: ino_t ino;
154: long (*todo)();
155: {
156: register struct inotab *itp;
157: register struct direct *dp;
158: register struct entry *np;
159: int namelen;
160: daddr_t bpt;
161: char locname[MAXPATHLEN + 1];
162:
163: itp = inotablookup(ino);
164: if (itp == NULL) {
165: /*
166: * Pname is name of a simple file or an unchanged directory.
167: */
168: (void) (*todo)(pname, ino, LEAF);
169: return;
170: }
171: /*
172: * Pname is a dumped directory name.
173: */
174: if ((*todo)(pname, ino, NODE) == FAIL)
175: return;
176: /*
177: * begin search through the directory
178: * skipping over "." and ".."
179: */
180: (void) strncpy(locname, pname, MAXPATHLEN);
181: (void) strncat(locname, "/", MAXPATHLEN);
182: namelen = strlen(locname);
183: rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
184: dp = rst_readdir(dirp); /* "." or ".." */
185: if (dp != NULL &&
186: (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)) {
187: dp = rst_readdir(dirp); /* "." or ".." */
188: } else {
189: np = lookupino(ino);
190: if (np == NULL)
191: panic("corrupted symbol table\n");
192: fprintf(stderr, ". and .. are not the first two entries in directory %s\n", myname(np));
193: dp = (struct direct *)NULL;
194: }
195: if (dp != NULL &&
196: (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)) {
197: dp = rst_readdir(dirp); /* first real entry */
198: } else {
199: np = lookupino(ino);
200: if (np == NULL)
201: panic("corrupted symbol table\n");
202: fprintf(stderr, ". and .. are not the first two entries in directory %s\n", myname(np));
203: dp = (struct direct *)NULL;
204: }
205: bpt = telldir(dirp);
206: /*
207: * a zero inode signals end of directory
208: */
209: while (dp != NULL && dp->d_ino != 0) {
210: locname[namelen] = '\0';
211: if (namelen + dp->d_namlen >= MAXPATHLEN) {
212: fprintf(stderr, "%s%s: name exceeds %d char\n",
213: locname, dp->d_name, MAXPATHLEN);
214: } else {
215: (void) strncat(locname, dp->d_name, (int)dp->d_namlen);
216: treescan(locname, dp->d_ino, todo);
217: rst_seekdir(dirp, bpt, itp->t_seekpt);
218: }
219: dp = rst_readdir(dirp);
220: bpt = telldir(dirp);
221: }
222: if (dp == NULL)
223: fprintf(stderr, "corrupted directory: %s.\n", locname);
224: }
225:
226: /*
227: * Search the directory tree rooted at inode ROOTINO
228: * for the path pointed at by n
229: */
230: ino_t
231: psearch(n)
232: char *n;
233: {
234: register char *cp, *cp1;
235: ino_t ino;
236: char c;
237:
238: ino = ROOTINO;
239: if (*(cp = n) == '/')
240: cp++;
241: next:
242: cp1 = cp + 1;
243: while (*cp1 != '/' && *cp1)
244: cp1++;
245: c = *cp1;
246: *cp1 = 0;
247: ino = search(ino, cp);
248: if (ino == 0) {
249: *cp1 = c;
250: return(0);
251: }
252: *cp1 = c;
253: if (c == '/') {
254: cp = cp1+1;
255: goto next;
256: }
257: return(ino);
258: }
259:
260: /*
261: * search the directory inode ino
262: * looking for entry cp
263: */
264: ino_t
265: search(inum, cp)
266: ino_t inum;
267: char *cp;
268: {
269: register struct direct *dp;
270: register struct inotab *itp;
271: int len;
272:
273: itp = inotablookup(inum);
274: if (itp == NULL)
275: return(0);
276: rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
277: len = strlen(cp);
278: do {
279: dp = rst_readdir(dirp);
280: if (dp == NULL || dp->d_ino == 0)
281: return (0);
282: } while (dp->d_namlen != len || strncmp(dp->d_name, cp, len) != 0);
283: return(dp->d_ino);
284: }
285:
286: /*
287: * Put the directory entries in the directory file
288: */
289: putdir(buf, size)
290: char *buf;
291: int size;
292: {
293: struct direct cvtbuf;
294: register struct odirect *odp;
295: struct odirect *eodp;
296: register struct direct *dp;
297: long loc, i;
298:
299: if (cvtflag) {
300: eodp = (struct odirect *)&buf[size];
301: for (odp = (struct odirect *)buf; odp < eodp; odp++)
302: if (odp->d_ino != 0) {
303: dcvt(odp, &cvtbuf);
304: putent(&cvtbuf);
305: }
306: } else {
307: for (loc = 0; loc < size; ) {
308: dp = (struct direct *)(buf + loc);
309: i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
310: if (dp->d_reclen == 0 || dp->d_reclen > i) {
311: loc += i;
312: continue;
313: }
314: loc += dp->d_reclen;
315: if (dp->d_ino != 0) {
316: putent(dp);
317: }
318: }
319: }
320: }
321:
322: /*
323: * These variables are "local" to the following two functions.
324: */
325: char dirbuf[DIRBLKSIZ];
326: long dirloc = 0;
327: long prev = 0;
328:
329: /*
330: * add a new directory entry to a file.
331: */
332: putent(dp)
333: struct direct *dp;
334: {
335: dp->d_reclen = DIRSIZ(dp);
336: if (dirloc + dp->d_reclen > DIRBLKSIZ) {
337: ((struct direct *)(dirbuf + prev))->d_reclen =
338: DIRBLKSIZ - prev;
339: (void) fwrite(dirbuf, 1, DIRBLKSIZ, df);
340: dirloc = 0;
341: }
342: bcopy((char *)dp, dirbuf + dirloc, (long)dp->d_reclen);
343: prev = dirloc;
344: dirloc += dp->d_reclen;
345: }
346:
347: /*
348: * flush out a directory that is finished.
349: */
350: flushent()
351: {
352:
353: ((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ - prev;
354: (void) fwrite(dirbuf, (int)dirloc, 1, df);
355: seekpt = ftell(df);
356: dirloc = 0;
357: }
358:
359: dcvt(odp, ndp)
360: register struct odirect *odp;
361: register struct direct *ndp;
362: {
363:
364: bzero((char *)ndp, (long)(sizeof *ndp));
365: ndp->d_ino = odp->d_ino;
366: (void) strncpy(ndp->d_name, odp->d_name, ODIRSIZ);
367: ndp->d_namlen = strlen(ndp->d_name);
368: ndp->d_reclen = DIRSIZ(ndp);
369: }
370:
371: /*
372: * Seek to an entry in a directory.
373: * Only values returned by ``telldir'' should be passed to rst_seekdir.
374: * This routine handles many directories in a single file.
375: * It takes the base of the directory in the file, plus
376: * the desired seek offset into it.
377: */
378: void
379: rst_seekdir(dirp, loc, base)
380: register DIR *dirp;
381: daddr_t loc, base;
382: {
383:
384: if (loc == telldir(dirp))
385: return;
386: loc -= base;
387: if (loc < 0)
388: fprintf(stderr, "bad seek pointer to rst_seekdir %d\n", loc);
389: (void) lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), 0);
390: dirp->dd_loc = loc & (DIRBLKSIZ - 1);
391: if (dirp->dd_loc != 0)
392: dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ);
393: }
394:
395: /*
396: * get next entry in a directory.
397: */
398: struct direct *
399: rst_readdir(dirp)
400: register DIR *dirp;
401: {
402: register struct direct *dp;
403:
404: for (;;) {
405: if (dirp->dd_loc == 0) {
406: dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
407: DIRBLKSIZ);
408: if (dirp->dd_size <= 0) {
409: dprintf(stderr, "error reading directory\n");
410: return NULL;
411: }
412: }
413: if (dirp->dd_loc >= dirp->dd_size) {
414: dirp->dd_loc = 0;
415: continue;
416: }
417: dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc);
418: if (dp->d_reclen == 0 ||
419: dp->d_reclen > DIRBLKSIZ + 1 - dirp->dd_loc) {
420: dprintf(stderr, "corrupted directory: bad reclen %d\n",
421: dp->d_reclen);
422: return NULL;
423: }
424: dirp->dd_loc += dp->d_reclen;
425: if (dp->d_ino == 0 && strcmp(dp->d_name, "/") != 0)
426: continue;
427: if (dp->d_ino >= maxino) {
428: dprintf(stderr, "corrupted directory: bad inum %d\n",
429: dp->d_ino);
430: continue;
431: }
432: return (dp);
433: }
434: }
435:
436: /*
437: * Set the mode, owner, and times for all new or changed directories
438: */
439: setdirmodes()
440: {
441: FILE *mf;
442: struct modeinfo node;
443: struct entry *ep;
444: char *cp;
445:
446: vprintf(stdout, "Set directory mode, owner, and times.\n");
447: mf = fopen(modefile, "r");
448: if (mf == NULL) {
449: perror("fopen");
450: panic("cannot open mode file %s\n", modefile);
451: }
452: clearerr(mf);
453: for (;;) {
454: (void) fread((char *)&node, 1, sizeof(struct modeinfo), mf);
455: if (feof(mf))
456: break;
457: ep = lookupino(node.ino);
458: if (command == 'i' || command == 'x' || command == 'X') {
459: if (ep == NIL)
460: continue;
461: if (node.ino == ROOTINO &&
462: reply("set owner/mode for '.'") == FAIL)
463: continue;
464: }
465: if (ep == NIL)
466: panic("cannot find directory inode %d\n", node.ino);
467: cp = myname(ep);
468: (void) chown(cp, node.uid, node.gid);
469: (void) chmod(cp, node.mode);
470: utime(cp, node.timep);
471: ep->e_flags &= ~NEW;
472: }
473: if (ferror(mf))
474: panic("error setting directory modes\n");
475: (void) fclose(mf);
476: }
477:
478: /*
479: * Generate a literal copy of a directory.
480: */
481: genliteraldir(name, ino)
482: char *name;
483: ino_t ino;
484: {
485: register struct inotab *itp;
486: int ofile, dp, i, size;
487: char buf[BUFSIZ];
488:
489: itp = inotablookup(ino);
490: if (itp == NULL)
491: panic("Cannot find directory inode %d named %s\n", ino, name);
492: if ((ofile = creat(name, 0666)) < 0) {
493: fprintf(stderr, "%s: ", name);
494: (void) fflush(stderr);
495: perror("cannot create file");
496: return (FAIL);
497: }
498: rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
499: dp = dup(dirp->dd_fd);
500: for (i = itp->t_size; i > 0; i -= BUFSIZ) {
501: size = i < BUFSIZ ? i : BUFSIZ;
502: if (read(dp, buf, (int) size) == -1) {
503: fprintf(stderr,
504: "write error extracting inode %d, name %s\n",
505: curfile.ino, curfile.name);
506: perror("read");
507: done(1);
508: }
509: if (write(ofile, buf, (int) size) == -1) {
510: fprintf(stderr,
511: "write error extracting inode %d, name %s\n",
512: curfile.ino, curfile.name);
513: perror("write");
514: done(1);
515: }
516: }
517: (void) close(dp);
518: (void) close(ofile);
519: return (GOOD);
520: }
521:
522: /*
523: * Do an "ls" style listing of a directory
524: */
525: printlist(name, ino)
526: char *name;
527: ino_t ino;
528: {
529: register struct afile *fp;
530: register struct inotab *itp;
531: struct afile *dfp0, *dfplast;
532: struct afile single;
533:
534: itp = inotablookup(ino);
535: if (itp == NULL) {
536: single.fnum = ino;
537: single.fname = savename(rindex(name, '/') + 1);
538: dfp0 = &single;
539: dfplast = dfp0 + 1;
540: } else {
541: rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
542: if (getdir(dirp, &dfp0, &dfplast) == FAIL)
543: return;
544: }
545: qsort((char *)dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
546: formatf(dfp0, dfplast);
547: for (fp = dfp0; fp < dfplast; fp++)
548: freename(fp->fname);
549: }
550:
551: /*
552: * Read the contents of a directory.
553: */
554: getdir(dirp, pfp0, pfplast)
555: DIR *dirp;
556: struct afile **pfp0, **pfplast;
557: {
558: register struct afile *fp;
559: register struct direct *dp;
560: static struct afile *basefp = NULL;
561: static long nent = 20;
562:
563: if (basefp == NULL) {
564: basefp = (struct afile *)calloc((unsigned)nent,
565: sizeof (struct afile));
566: if (basefp == NULL) {
567: fprintf(stderr, "ls: out of memory\n");
568: return (FAIL);
569: }
570: }
571: fp = *pfp0 = basefp;
572: *pfplast = *pfp0 + nent;
573: while (dp = rst_readdir(dirp)) {
574: if (dp == NULL || dp->d_ino == 0)
575: break;
576: if (!dflag && BIT(dp->d_ino, dumpmap) == 0)
577: continue;
578: if (vflag == 0 &&
579: (strcmp(dp->d_name, ".") == 0 ||
580: strcmp(dp->d_name, "..") == 0))
581: continue;
582: fp->fnum = dp->d_ino;
583: fp->fname = savename(dp->d_name);
584: fp++;
585: if (fp == *pfplast) {
586: basefp = (struct afile *)realloc((char *)basefp,
587: (unsigned)(2 * nent * sizeof (struct afile)));
588: if (basefp == 0) {
589: fprintf(stderr, "ls: out of memory\n");
590: return (FAIL);
591: }
592: *pfp0 = basefp;
593: fp = *pfp0 + nent;
594: *pfplast = fp + nent;
595: nent *= 2;
596: }
597: }
598: *pfplast = fp;
599: return (GOOD);
600: }
601:
602: /*
603: * Print out a pretty listing of a directory
604: */
605: formatf(fp0, fplast)
606: struct afile *fp0, *fplast;
607: {
608: register struct afile *fp;
609: struct entry *np;
610: int width = 0, w, nentry = fplast - fp0;
611: int i, j, len, columns, lines;
612: char *cp;
613:
614: if (fp0 == fplast)
615: return;
616: for (fp = fp0; fp < fplast; fp++) {
617: fp->ftype = inodetype(fp->fnum);
618: np = lookupino(fp->fnum);
619: if (np != NIL)
620: fp->fflags = np->e_flags;
621: else
622: fp->fflags = 0;
623: len = strlen(fmtentry(fp));
624: if (len > width)
625: width = len;
626: }
627: width += 2;
628: columns = 80 / width;
629: if (columns == 0)
630: columns = 1;
631: lines = (nentry + columns - 1) / columns;
632: for (i = 0; i < lines; i++) {
633: for (j = 0; j < columns; j++) {
634: fp = fp0 + j * lines + i;
635: cp = fmtentry(fp);
636: fprintf(stderr, "%s", cp);
637: if (fp + lines >= fplast) {
638: fprintf(stderr, "\n");
639: break;
640: }
641: w = strlen(cp);
642: while (w < width) {
643: w++;
644: fprintf(stderr, " ");
645: }
646: }
647: }
648: }
649:
650: /*
651: * Comparison routine for qsort.
652: */
653: fcmp(f1, f2)
654: register struct afile *f1, *f2;
655: {
656:
657: return (strcmp(f1->fname, f2->fname));
658: }
659:
660: /*
661: * Format a directory entry.
662: */
663: char *
664: fmtentry(fp)
665: register struct afile *fp;
666: {
667: static char fmtres[BUFSIZ];
668: register char *cp, *dp;
669:
670: if (vflag)
671: (void) sprintf(fmtres, "%5d ", fp->fnum);
672: else
673: fmtres[0] = '\0';
674: dp = &fmtres[strlen(fmtres)];
675: if (dflag && BIT(fp->fnum, dumpmap) == 0)
676: *dp++ = '^';
677: else if ((fp->fflags & NEW) != 0)
678: *dp++ = '*';
679: else
680: *dp++ = ' ';
681: for (cp = fp->fname; *cp; cp++)
682: if (!vflag && (*cp < ' ' || *cp >= 0177))
683: *dp++ = '?';
684: else
685: *dp++ = *cp;
686: if (fp->ftype == NODE)
687: *dp++ = '/';
688: *dp++ = 0;
689: return (fmtres);
690: }
691:
692: /*
693: * Determine the type of an inode
694: */
695: inodetype(ino)
696: ino_t ino;
697: {
698: struct inotab *itp;
699:
700: itp = inotablookup(ino);
701: if (itp == NULL)
702: return (LEAF);
703: return (NODE);
704: }
705:
706: /*
707: * Allocate and initialize a directory inode entry.
708: * If requested, save its pertinent mode, owner, and time info.
709: */
710: struct inotab *
711: allocinotab(ino, dip, seekpt)
712: ino_t ino;
713: struct dinode *dip;
714: daddr_t seekpt;
715: {
716: register struct inotab *itp;
717: struct modeinfo node;
718:
719: itp = (struct inotab *)calloc(1, sizeof(struct inotab));
720: if (itp == 0)
721: panic("no memory directory table\n");
722: itp->t_next = inotab[INOHASH(ino)];
723: inotab[INOHASH(ino)] = itp;
724: itp->t_ino = ino;
725: itp->t_seekpt = seekpt;
726: if (mf == NULL)
727: return(itp);
728: node.ino = ino;
729: node.timep[0] = dip->di_atime;
730: node.timep[1] = dip->di_mtime;
731: node.mode = dip->di_mode;
732: node.uid = dip->di_uid;
733: node.gid = dip->di_gid;
734: (void) fwrite((char *)&node, 1, sizeof(struct modeinfo), mf);
735: return(itp);
736: }
737:
738: /*
739: * Look up an inode in the table of directories
740: */
741: struct inotab *
742: inotablookup(ino)
743: ino_t ino;
744: {
745: register struct inotab *itp;
746:
747: for (itp = inotab[INOHASH(ino)]; itp != NULL; itp = itp->t_next)
748: if (itp->t_ino == ino)
749: return(itp);
750: return ((struct inotab *)0);
751: }
752:
753: /*
754: * Clean up and exit
755: */
756: done(exitcode)
757: int exitcode;
758: {
759:
760: closemt();
761: if (modefile[0] != '#')
762: (void) unlink(modefile);
763: if (dirfile[0] != '#')
764: (void) unlink(dirfile);
765: exit(exitcode);
766: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.