xref: /illumos-gate/usr/src/cmd/backup/restore/symtab.c (revision 2c5ec7a875dcd76853e6618614e990f1e8cdd56d)
1 /*
2  * Copyright (c) 1983 Regents of the University of California.
3  * All rights reserved.  The Berkeley software License Agreement
4  * specifies the terms and conditions for redistribution.
5  */
6 
7 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
8 /*	  All Rights Reserved	*/
9 
10 /*
11  * Copyright (c) 1996,1998,2001 by Sun Microsystems, Inc.
12  * All rights reserved.
13  */
14 
15 /*
16  * These routines maintain the symbol table which tracks the state
17  * of the file system being restored. They provide lookup by either
18  * name or inode number. They also provide for creation, deletion,
19  * and renaming of entries. Because of the dynamic nature of pathnames,
20  * names should not be saved, but always constructed just before they
21  * are needed, by calling "myname".
22  */
23 
24 #include "restore.h"
25 #include <limits.h>
26 
27 /*
28  * The following variables define the inode symbol table.
29  * The primary hash table is dynamically allocated based on
30  * the number of inodes in the file system (maxino), scaled by
31  * HASHFACTOR. The variable "entry" points to the hash table;
32  * the variable "entrytblsize" indicates its size (in entries).
33  */
34 #define	HASHFACTOR 5
35 static struct entry **entry;
36 static uint_t entrytblsize;
37 
38 #ifdef __STDC__
39 static void addino(ino_t, struct entry *);
40 static struct entry *lookupparent(char *);
41 static void removeentry(struct entry *);
42 #else
43 static void addino();
44 static struct entry *lookupparent();
45 static void removeentry();
46 #endif
47 
48 /*
49  * Look up an entry by inode number
50  */
51 struct entry *
52 lookupino(inum)
53 	ino_t inum;
54 {
55 	struct entry *ep;
56 
57 	if (inum < ROOTINO || inum >= maxino)
58 		return (NIL);
59 	for (ep = entry[inum % entrytblsize]; ep != NIL; ep = ep->e_next)
60 		if (ep->e_ino == inum)
61 			return (ep);
62 	return (NIL);
63 }
64 
65 /*
66  * We now ignore inodes that are out of range.  This
67  * allows us to attempt to proceed in the face of
68  * a corrupted archive, albeit with future complaints
69  * about failed inode lookups.  We only complain once
70  * about range problems, to avoid irritating the user
71  * without providing any useful information.  Failed
72  * lookups have the bogus name, which is useful, so
73  * they always happen.
74  */
75 static int complained_about_range = 0;
76 
77 /*
78  * Add an entry into the entry table
79  */
80 static void
81 addino(inum, np)
82 	ino_t inum;
83 	struct entry *np;
84 {
85 	struct entry **epp;
86 
87 	if (inum < ROOTINO || inum >= maxino) {
88 		if (!complained_about_range) {
89 			panic(gettext("%s: out of range %d\n"),
90 			    "addino", inum);
91 			complained_about_range = 1;
92 		}
93 		return;
94 	}
95 	epp = &entry[inum % entrytblsize];
96 	np->e_ino = inum;
97 	np->e_next = *epp;
98 	*epp = np;
99 	if (dflag)
100 		for (np = np->e_next; np != NIL; np = np->e_next)
101 			if (np->e_ino == inum)
102 				badentry(np, gettext("duplicate inum"));
103 }
104 
105 /*
106  * Delete an entry from the entry table.  We assume our caller
107  * arranges for the necessary memory reclamation, if needed.
108  */
109 void
110 deleteino(inum)
111 	ino_t inum;
112 {
113 	struct entry *next;
114 	struct entry **prev;
115 
116 	if (inum < ROOTINO || inum >= maxino) {
117 		if (!complained_about_range) {
118 			panic(gettext("%s: out of range %d\n"),
119 			    "deleteino", inum);
120 			complained_about_range = 1;
121 		}
122 		return;
123 	}
124 
125 	prev = &entry[inum % entrytblsize];
126 	for (next = *prev; next != NIL; next = next->e_next) {
127 		if (next->e_ino == inum) {
128 			next->e_ino = 0;
129 			*prev = next->e_next;
130 			return;
131 		}
132 		prev = &next->e_next;
133 	}
134 }
135 
136 /*
137  * Look up an entry by name.
138  *	NOTE: this function handles "complex" pathnames (as returned
139  *	by myname()) for extended file attributes.  The name string
140  *	provided to this function should be terminated with *two*
141  *	NULL characters.
142  */
143 struct entry *
144 lookupname(name)
145 	char *name;
146 {
147 	struct entry *ep;
148 	char *np, *cp;
149 	char buf[MAXPATHLEN];
150 
151 	if (strlen(name) > (sizeof (buf) - 1)) {
152 		(void) fprintf(stderr, gettext("%s: ignoring too-long name\n"),
153 		    "lookupname");
154 		return (NIL);
155 	}
156 
157 	cp = name;
158 	for (ep = lookupino(ROOTINO); ep != NIL; ep = ep->e_entries) {
159 		np = buf;
160 		while (*cp != '/' && *cp != '\0')
161 			*np++ = *cp++;
162 		*np = '\0';
163 		for (; ep != NIL; ep = ep->e_sibling)
164 			if (strcmp(ep->e_name, buf) == 0)
165 				break;
166 		if (*cp++ == '\0') {
167 			if (*cp != '\0') {
168 				ep = ep->e_xattrs;
169 				/*
170 				 * skip over the "./" prefix on all
171 				 * extended attribute paths
172 				 */
173 				cp += 2;
174 			}
175 			if (*cp == '\0')
176 				return (ep);
177 		}
178 		if (ep == NIL)
179 			break;
180 	}
181 	return (NIL);
182 }
183 
184 /*
185  * Look up the parent of a pathname.  This routine accepts complex
186  * names so the provided name argument must terminate with two NULLs.
187  */
188 static struct entry *
189 lookupparent(name)
190 	char *name;
191 {
192 	struct entry *ep;
193 	char *tailindex, savechar, *lastpart;
194 	int xattrparent = 0;
195 
196 	/* find the last component of the complex name */
197 	lastpart = name;
198 	LASTPART(lastpart);
199 	tailindex = strrchr(lastpart, '/');
200 	if (tailindex == 0) {
201 		if (lastpart == name)
202 			return (NIL);
203 		/*
204 		 * tailindex normaly points to the '/' character
205 		 * dividing the path, but in the case of an extended
206 		 * attribute transition it will point to the NULL
207 		 * separator in front of the attribute path.
208 		 */
209 		tailindex = lastpart - 1;
210 		xattrparent = 1;
211 	} else {
212 		*tailindex = '\0';
213 	}
214 	savechar = *(tailindex+1);
215 	*(tailindex+1) = '\0';
216 	ep = lookupname(name);
217 	if (ep != NIL && !xattrparent && ep->e_type != NODE)
218 		panic(gettext("%s is not a directory\n"), name);
219 	if (!xattrparent) *tailindex = '/';
220 	*(tailindex+1) = savechar;
221 	return (ep);
222 }
223 
224 /*
225  * Determine the current pathname of a node or leaf.
226  * The returned pathname will be multiple strings with NULL separators:
227  *
228  *	./<path>/entry\0<path>/attrentry\0<path>/...\0\0
229  *	^	        ^		  ^	    ^
230  *   return pntr    entry attr	    recursive attr  terminator
231  *
232  * Guaranteed to return a name that fits within MAXCOMPLEXLEN and is
233  * terminated with two NULLs.
234  */
235 char *
236 myname(ep)
237 	struct entry *ep;
238 {
239 	char *cp;
240 	struct entry *root = lookupino(ROOTINO);
241 	static char namebuf[MAXCOMPLEXLEN];
242 
243 	cp = &namebuf[MAXCOMPLEXLEN - 3];
244 	*(cp + 1) = '\0';
245 	*(cp + 2) = '\0';
246 	while (cp > &namebuf[ep->e_namlen]) {
247 		cp -= ep->e_namlen;
248 		bcopy(ep->e_name, cp, (size_t)ep->e_namlen);
249 		if (ep == root)
250 			return (cp);
251 		if (ep->e_flags & XATTRROOT)
252 			*(--cp) = '\0';
253 		else
254 			*(--cp) = '/';
255 		ep = ep->e_parent;
256 	}
257 	panic(gettext("%s%s: pathname too long\n"), "...", cp);
258 	return (cp);
259 }
260 
261 /*
262  * Unused symbol table entries are linked together on a freelist
263  * headed by the following pointer.
264  */
265 static struct entry *freelist = NIL;
266 
267 /*
268  * add an entry to the symbol table
269  */
270 struct entry *
271 addentry(name, inum, type)
272 	char *name;
273 	ino_t inum;
274 	int type;
275 {
276 	struct entry *np, *ep;
277 	char *cp;
278 
279 	if (freelist != NIL) {
280 		np = freelist;
281 		freelist = np->e_next;
282 		(void) bzero((char *)np, (size_t)sizeof (*np));
283 	} else {
284 		np = (struct entry *)calloc(1, sizeof (*np));
285 		if (np == NIL) {
286 			(void) fprintf(stderr,
287 			    gettext("no memory to extend symbol table\n"));
288 			done(1);
289 		}
290 	}
291 	np->e_type = type & ~(LINK|ROOT);
292 	if (inattrspace)
293 		np->e_flags |= XATTR;
294 	ep = lookupparent(name);
295 	if (ep == NIL) {
296 		if (inum != ROOTINO || lookupino(ROOTINO) != NIL) {
297 			(void) fprintf(stderr, gettext(
298 			    "%s: bad name %s\n"), "addentry", name);
299 			assert(0);
300 			done(1);
301 		}
302 		np->e_name = savename(name);
303 		/* LINTED: savename guarantees that strlen fits in e_namlen */
304 		np->e_namlen = strlen(name);
305 		np->e_parent = np;
306 		addino(ROOTINO, np);
307 		return (np);
308 	}
309 
310 	if (np->e_flags & XATTR) {
311 		/*
312 		 * skip to the last part of the complex string: it
313 		 * containes the extended attribute file name.
314 		 */
315 		LASTPART(name);
316 	}
317 	cp = strrchr(name, '/');
318 	if (cp == NULL)
319 		cp = name;
320 	else
321 		cp++;
322 
323 	np->e_name = savename(cp);
324 	/* LINTED: savename guarantees that strlen will fit */
325 	np->e_namlen = strlen(np->e_name);
326 	np->e_parent = ep;
327 	/*
328 	 * Extended attribute root directories must be linked to their
329 	 * "parents" via the e_xattrs field.  Other entries are simply
330 	 * added to their parent directories e_entries list.
331 	 */
332 	if ((type & ROOT) && (np->e_flags & XATTR)) {
333 		/* link this extended attribute root dir to its "parent" */
334 		ep->e_xattrs = np;
335 	} else {
336 		/* add this entry to the entry list of the parent dir */
337 		np->e_sibling = ep->e_entries;
338 		ep->e_entries = np;
339 	}
340 	if (type & LINK) {
341 		ep = lookupino(inum);
342 		if (ep == NIL) {
343 			/* XXX just bail on this one and continue? */
344 			(void) fprintf(stderr,
345 			    gettext("link to non-existent name\n"));
346 			done(1);
347 		}
348 		np->e_ino = inum;
349 		np->e_links = ep->e_links;
350 		ep->e_links = np;
351 	} else if (inum != 0) {
352 		ep = lookupino(inum);
353 		if (ep != NIL)
354 			panic(gettext("duplicate entry\n"));
355 		else
356 			addino(inum, np);
357 	}
358 	return (np);
359 }
360 
361 /*
362  * delete an entry from the symbol table
363  */
364 void
365 freeentry(ep)
366 	struct entry *ep;
367 {
368 	struct entry *np;
369 	ino_t inum;
370 
371 	if ((ep->e_flags & REMOVED) == 0)
372 		badentry(ep, gettext("not marked REMOVED"));
373 	if (ep->e_type == NODE) {
374 		if (ep->e_links != NIL)
375 			badentry(ep, gettext("freeing referenced directory"));
376 		if (ep->e_entries != NIL)
377 			badentry(ep, gettext("freeing non-empty directory"));
378 	}
379 	if (ep->e_ino != 0) {
380 		np = lookupino(ep->e_ino);
381 		if (np == NIL)
382 			badentry(ep, gettext("lookupino failed"));
383 		if (np == ep) {
384 			inum = ep->e_ino;
385 			deleteino(inum);
386 			if (ep->e_links != NIL)
387 				addino(inum, ep->e_links);
388 		} else {
389 			for (; np != NIL; np = np->e_links) {
390 				if (np->e_links == ep) {
391 					np->e_links = ep->e_links;
392 					break;
393 				}
394 			}
395 			if (np == NIL)
396 				badentry(ep, gettext("link not found"));
397 		}
398 	}
399 	removeentry(ep);
400 	freename(ep->e_name);
401 	ep->e_next = freelist;
402 	freelist = ep;
403 }
404 
405 /*
406  * Relocate an entry in the tree structure
407  */
408 void
409 moveentry(ep, newname)
410 	struct entry *ep;
411 	char *newname;
412 {
413 	struct entry *np;
414 	char *cp;
415 
416 	np = lookupparent(newname);
417 	if (np == NIL)
418 		badentry(ep, gettext("cannot move ROOT"));
419 	if (np != ep->e_parent) {
420 		removeentry(ep);
421 		ep->e_parent = np;
422 		ep->e_sibling = np->e_entries;
423 		np->e_entries = ep;
424 	}
425 	/* find the last component of the complex name */
426 	LASTPART(newname);
427 	cp = strrchr(newname, '/') + 1;
428 	if (cp == (char *)1)
429 		cp = newname;
430 	freename(ep->e_name);
431 	ep->e_name = savename(cp);
432 	/* LINTED: savename guarantees that strlen will fit */
433 	ep->e_namlen = strlen(cp);
434 	if (strcmp(gentempname(ep), ep->e_name) == 0) {
435 		/* LINTED: result fits in a short */
436 		ep->e_flags |= TMPNAME;
437 	} else {
438 		/* LINTED: result fits in a short */
439 		ep->e_flags &= ~TMPNAME;
440 	}
441 }
442 
443 /*
444  * Remove an entry in the tree structure
445  */
446 static void
447 removeentry(ep)
448 	struct entry *ep;
449 {
450 	struct entry *np;
451 
452 	np = ep->e_parent;
453 	if (ep->e_flags & XATTRROOT) {
454 		if (np->e_xattrs == ep)
455 			np->e_xattrs = NIL;
456 		else
457 			badentry(ep, gettext(
458 				"parent does not reference this xattr tree"));
459 	} else if (np->e_entries == ep) {
460 		np->e_entries = ep->e_sibling;
461 	} else {
462 		for (np = np->e_entries; np != NIL; np = np->e_sibling) {
463 			if (np->e_sibling == ep) {
464 				np->e_sibling = ep->e_sibling;
465 				break;
466 			}
467 		}
468 		if (np == NIL)
469 			badentry(ep, gettext(
470 				"cannot find entry in parent list"));
471 	}
472 }
473 
474 /*
475  * Table of unused string entries, sorted by length.
476  *
477  * Entries are allocated in STRTBLINCR sized pieces so that names
478  * of similar lengths can use the same entry. The value of STRTBLINCR
479  * is chosen so that every entry has at least enough space to hold
480  * a "struct strtbl" header. Thus every entry can be linked onto an
481  * apprpriate free list.
482  *
483  * NB. The macro "allocsize" below assumes that "struct strhdr"
484  *	has a size that is a power of two. Also, an extra byte is
485  *	allocated for the string to provide space for the two NULL
486  *	string terminator required for extended attribute paths.
487  */
488 struct strhdr {
489 	struct strhdr *next;
490 };
491 
492 #define	STRTBLINCR	((size_t)sizeof (struct strhdr))
493 #define	allocsize(size)	(((size) + 2 + STRTBLINCR - 1) & ~(STRTBLINCR - 1))
494 
495 static struct strhdr strtblhdr[allocsize(MAXCOMPLEXLEN) / STRTBLINCR];
496 
497 /*
498  * Allocate space for a name. It first looks to see if it already
499  * has an appropriate sized entry, and if not allocates a new one.
500  */
501 char *
502 savename(name)
503 	char *name;
504 {
505 	struct strhdr *np;
506 	size_t len, as;
507 	char *cp;
508 
509 	if (name == NULL) {
510 		(void) fprintf(stderr, gettext("bad name\n"));
511 		done(1);
512 	}
513 	len = strlen(name);
514 	if (len > MAXPATHLEN) {
515 		(void) fprintf(stderr, gettext("name too long\n"));
516 		done(1);
517 	}
518 	as = allocsize(len);
519 	np = strtblhdr[as / STRTBLINCR].next;
520 	if (np != NULL) {
521 		strtblhdr[as / STRTBLINCR].next = np->next;
522 		cp = (char *)np;
523 	} else {
524 		/* Note that allocsize() adds 2 for the trailing \0s */
525 		cp = malloc(as);
526 		if (cp == NULL) {
527 			(void) fprintf(stderr,
528 			    gettext("no space for string table\n"));
529 			done(1);
530 		}
531 	}
532 	(void) strcpy(cp, name);
533 	/* add an extra null for complex (attribute) name support */
534 	cp[len+1] = '\0';
535 	return (cp);
536 }
537 
538 /*
539  * Free space for a name. The resulting entry is linked onto the
540  * appropriate free list.
541  */
542 void
543 freename(name)
544 	char *name;
545 {
546 	struct strhdr *tp, *np;
547 
548 	/* NULL case should never happen, but might as well be careful */
549 	if (name != NULL) {
550 		tp = &strtblhdr[allocsize(strlen(name)) / STRTBLINCR];
551 		/*LINTED [name points to at least sizeof (struct strhdr)]*/
552 		np = (struct strhdr *)name;
553 		np->next = tp->next;
554 		tp->next = np;
555 	}
556 }
557 
558 /*
559  * Useful quantities placed at the end of a dumped symbol table.
560  */
561 struct symtableheader {
562 	int	volno;
563 	uint_t	stringsize;
564 	uint_t	entrytblsize;
565 	time_t	dumptime;
566 	time_t	dumpdate;
567 	ino_t	maxino;
568 	uint_t	ntrec;
569 };
570 
571 /*
572  * dump a snapshot of the symbol table
573  */
574 void
575 dumpsymtable(filename, checkpt)
576 	char *filename;
577 	int checkpt;
578 {
579 	struct entry *ep, *tep;
580 	ino_t i;
581 	struct entry temp, *tentry;
582 	int mynum = 1;
583 	uint_t stroff;
584 	FILE *fp;
585 	struct symtableheader hdr;
586 
587 	vprintf(stdout, gettext("Check pointing the restore\n"));
588 	if ((fp = safe_fopen(filename, "w", 0600)) == (FILE *)NULL) {
589 		perror("fopen");
590 		(void) fprintf(stderr,
591 		    gettext("cannot create save file %s for symbol table\n"),
592 		    filename);
593 		done(1);
594 	}
595 	clearerr(fp);
596 	/*
597 	 * Assign an index to each entry
598 	 * Write out the string entries
599 	 */
600 	for (i = ROOTINO; i < maxino; i++) {
601 		for (ep = lookupino(i); ep != NIL; ep = ep->e_links) {
602 			ep->e_index = mynum++;
603 			(void) fwrite(ep->e_name, sizeof (ep->e_name[0]),
604 			    (size_t)allocsize(ep->e_namlen), fp);
605 		}
606 	}
607 	/*
608 	 * Convert e_name pointers to offsets, other pointers
609 	 * to indices, and output
610 	 */
611 	tep = &temp;
612 	stroff = 0;
613 	for (i = ROOTINO; !ferror(fp) && i < maxino; i++) {
614 		for (ep = lookupino(i);
615 		    !ferror(fp) && ep != NIL;
616 		    ep = ep->e_links) {
617 			bcopy((char *)ep, (char *)tep, sizeof (*tep));
618 			/* LINTED: type pun ok */
619 			tep->e_name = (char *)stroff;
620 			stroff += allocsize(ep->e_namlen);
621 			tep->e_parent = (struct entry *)ep->e_parent->e_index;
622 			if (ep->e_links != NIL)
623 				tep->e_links =
624 					(struct entry *)ep->e_links->e_index;
625 			if (ep->e_sibling != NIL)
626 				tep->e_sibling =
627 					(struct entry *)ep->e_sibling->e_index;
628 			if (ep->e_entries != NIL)
629 				tep->e_entries =
630 					(struct entry *)ep->e_entries->e_index;
631 			if (ep->e_xattrs != NIL)
632 				tep->e_xattrs =
633 					(struct entry *)ep->e_xattrs->e_index;
634 			if (ep->e_next != NIL)
635 				tep->e_next =
636 					(struct entry *)ep->e_next->e_index;
637 			(void) fwrite((char *)tep, sizeof (*tep), 1, fp);
638 		}
639 	}
640 	/*
641 	 * Convert entry pointers to indices, and output
642 	 */
643 	for (i = 0; !ferror(fp) && i < (ino_t)entrytblsize; i++) {
644 		if (entry[i] == NIL)
645 			tentry = NIL;
646 		else
647 			tentry = (struct entry *)entry[i]->e_index;
648 		(void) fwrite((char *)&tentry, sizeof (tentry), 1, fp);
649 	}
650 
651 	if (!ferror(fp)) {
652 		/* Ought to have a checksum or magic number */
653 		hdr.volno = checkpt;
654 		hdr.maxino = maxino;
655 		hdr.entrytblsize = entrytblsize;
656 		hdr.stringsize = stroff;
657 		hdr.dumptime = dumptime;
658 		hdr.dumpdate = dumpdate;
659 		hdr.ntrec = ntrec;
660 		(void) fwrite((char *)&hdr, sizeof (hdr), 1, fp);
661 	}
662 
663 	if (ferror(fp)) {
664 		perror("fwrite");
665 		panic(gettext("output error to file %s writing symbol table\n"),
666 		    filename);
667 	}
668 	(void) fclose(fp);
669 }
670 
671 /*
672  * Initialize a symbol table from a file
673  */
674 void
675 initsymtable(filename)
676 	char *filename;
677 {
678 	char *base;
679 	off64_t tblsize;
680 	struct entry *ep;
681 	struct entry *baseep, *lep;
682 	struct symtableheader hdr;
683 	struct stat64 stbuf;
684 	uint_t i;
685 	int fd;
686 
687 	vprintf(stdout, gettext("Initialize symbol table.\n"));
688 	if (filename == NULL) {
689 		if ((maxino / HASHFACTOR) > UINT_MAX) {
690 			(void) fprintf(stderr,
691 			    gettext("file system too large\n"));
692 			done(1);
693 		}
694 		/* LINTED: result fits in entrytblsize */
695 		entrytblsize = maxino / HASHFACTOR;
696 		entry = (struct entry **)
697 			/* LINTED entrytblsize fits in a size_t */
698 			calloc((size_t)entrytblsize, sizeof (*entry));
699 		if (entry == (struct entry **)NULL) {
700 			(void) fprintf(stderr,
701 			    gettext("no memory for entry table\n"));
702 			done(1);
703 		}
704 		ep = addentry(".", ROOTINO, NODE);
705 		/* LINTED: result fits in a short */
706 		ep->e_flags |= NEW;
707 		return;
708 	}
709 	if ((fd = open(filename, O_RDONLY|O_LARGEFILE)) < 0) {
710 		perror("open");
711 		(void) fprintf(stderr,
712 		    gettext("cannot open symbol table file %s\n"), filename);
713 		done(1);
714 	}
715 	if (fstat64(fd, &stbuf) < 0) {
716 		perror("stat");
717 		(void) fprintf(stderr,
718 		    gettext("cannot stat symbol table file %s\n"), filename);
719 		(void) close(fd);
720 		done(1);
721 	}
722 	/*
723 	 * The symbol table file is too small so say we can't read it.
724 	 */
725 	if (stbuf.st_size < sizeof (hdr)) {
726 		(void) fprintf(stderr,
727 		    gettext("cannot read symbol table file %s\n"), filename);
728 		(void) close(fd);
729 		done(1);
730 	}
731 	tblsize = stbuf.st_size - sizeof (hdr);
732 	if (tblsize > ULONG_MAX) {
733 		(void) fprintf(stderr,
734 		    gettext("symbol table file too large\n"));
735 		(void) close(fd);
736 		done(1);
737 	}
738 	/* LINTED tblsize fits in a size_t */
739 	base = calloc((size_t)sizeof (char), (size_t)tblsize);
740 	if (base == NULL) {
741 		(void) fprintf(stderr,
742 		    gettext("cannot allocate space for symbol table\n"));
743 		(void) close(fd);
744 		done(1);
745 	}
746 	/* LINTED tblsize fits in a size_t */
747 	if (read(fd, base, (size_t)tblsize) < 0 ||
748 	    read(fd, (char *)&hdr, sizeof (hdr)) < 0) {
749 		perror("read");
750 		(void) fprintf(stderr,
751 		    gettext("cannot read symbol table file %s\n"), filename);
752 		(void) close(fd);
753 		done(1);
754 	}
755 	(void) close(fd);
756 	switch (command) {
757 	case 'r':
758 	case 'M':
759 		/*
760 		 * For normal continuation, insure that we are using
761 		 * the next incremental tape
762 		 */
763 		if (hdr.dumpdate != dumptime) {
764 			if (hdr.dumpdate < dumptime)
765 				(void) fprintf(stderr, gettext(
766 					"Incremental volume too low\n"));
767 			else
768 				(void) fprintf(stderr, gettext(
769 					"Incremental volume too high\n"));
770 			done(1);
771 		}
772 		break;
773 	case 'R':
774 		/*
775 		 * For restart, insure that we are using the same tape
776 		 */
777 		curfile.action = SKIP;
778 		dumptime = hdr.dumptime;
779 		dumpdate = hdr.dumpdate;
780 		if (!bflag)
781 			newtapebuf(hdr.ntrec);
782 		getvol(hdr.volno);
783 		break;
784 	default:
785 		(void) fprintf(stderr,
786 		    gettext("initsymtable called from command %c\n"),
787 		    (uchar_t)command);
788 		done(1);
789 		/*NOTREACHED*/
790 	}
791 	maxino = hdr.maxino;
792 	entrytblsize = hdr.entrytblsize;
793 	/*LINTED [pointer cast alignment]*/
794 	entry = (struct entry **)
795 	    (base + tblsize - (entrytblsize * sizeof (*entry)));
796 	if (((ulong_t)entry % 4) != 0) {
797 		(void) fprintf(stderr,
798 		    gettext("Symbol table file corrupted\n"));
799 		done(1);
800 	}
801 	/*LINTED [rvalue % 4 == 0] */
802 	baseep = (struct entry *)
803 	    (base + hdr.stringsize - sizeof (*baseep));
804 	if (((ulong_t)baseep % 4) != 0) {
805 		(void) fprintf(stderr,
806 		    gettext("Symbol table file corrupted\n"));
807 		done(1);
808 	}
809 	lep = (struct entry *)entry;
810 	for (i = 0; i < entrytblsize; i++) {
811 		if (entry[i] == NIL)
812 			continue;
813 		entry[i] = &baseep[(long)entry[i]];
814 	}
815 	for (ep = &baseep[1]; ep < lep; ep++) {
816 		ep->e_name = base + (long)ep->e_name;
817 		ep->e_parent = &baseep[(long)ep->e_parent];
818 		if (ep->e_sibling != NIL)
819 			ep->e_sibling = &baseep[(long)ep->e_sibling];
820 		if (ep->e_links != NIL)
821 			ep->e_links = &baseep[(long)ep->e_links];
822 		if (ep->e_entries != NIL)
823 			ep->e_entries = &baseep[(long)ep->e_entries];
824 		if (ep->e_xattrs != NIL)
825 			ep->e_xattrs = &baseep[(long)ep->e_xattrs];
826 		if (ep->e_next != NIL)
827 			ep->e_next = &baseep[(long)ep->e_next];
828 	}
829 }
830