dirs.c revision 100207
1/* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 */ 38 39#ifndef lint 40#if 0 41static char sccsid[] = "@(#)dirs.c 8.7 (Berkeley) 5/1/95"; 42#endif 43static const char rcsid[] = 44 "$FreeBSD: head/sbin/restore/dirs.c 100207 2002-07-17 02:03:19Z mckusick $"; 45#endif /* not lint */ 46 47#include <sys/param.h> 48#include <sys/file.h> 49#include <sys/stat.h> 50#include <sys/time.h> 51 52#include <ufs/ufs/dinode.h> 53#include <ufs/ufs/dir.h> 54#include <protocols/dumprestore.h> 55 56#include <err.h> 57#include <errno.h> 58#include <paths.h> 59#include <stdio.h> 60#include <stdlib.h> 61#include <string.h> 62#include <unistd.h> 63 64#include "restore.h" 65#include "extern.h" 66 67/* 68 * Symbol table of directories read from tape. 69 */ 70#define HASHSIZE 1000 71#define INOHASH(val) (val % HASHSIZE) 72struct inotab { 73 struct inotab *t_next; 74 ino_t t_ino; 75 int32_t t_seekpt; 76 int32_t t_size; 77}; 78static struct inotab *inotab[HASHSIZE]; 79 80/* 81 * Information retained about directories. 82 */ 83struct modeinfo { 84 ino_t ino; 85 struct timeval ctimep[2]; 86 struct timeval mtimep[2]; 87 mode_t mode; 88 uid_t uid; 89 gid_t gid; 90 int flags; 91}; 92 93/* 94 * Definitions for library routines operating on directories. 95 */ 96#undef DIRBLKSIZ 97#define DIRBLKSIZ 1024 98struct rstdirdesc { 99 int dd_fd; 100 int32_t dd_loc; 101 int32_t dd_size; 102 char dd_buf[DIRBLKSIZ]; 103}; 104 105/* 106 * Global variables for this file. 107 */ 108static long seekpt; 109static FILE *df, *mf; 110static RST_DIR *dirp; 111static char dirfile[MAXPATHLEN] = "#"; /* No file */ 112static char modefile[MAXPATHLEN] = "#"; /* No file */ 113static char dot[2] = "."; /* So it can be modified */ 114 115/* 116 * Format of old style directories. 117 */ 118#define ODIRSIZ 14 119struct odirect { 120 u_short d_ino; 121 char d_name[ODIRSIZ]; 122}; 123 124static struct inotab *allocinotab(struct context *, long); 125static void dcvt(struct odirect *, struct direct *); 126static void flushent(void); 127static struct inotab *inotablookup(ino_t); 128static RST_DIR *opendirfile(const char *); 129static void putdir(char *, long); 130static void putent(struct direct *); 131static void rst_seekdir(RST_DIR *, long, long); 132static long rst_telldir(RST_DIR *); 133static struct direct *searchdir(ino_t, char *); 134 135/* 136 * Extract directory contents, building up a directory structure 137 * on disk for extraction by name. 138 * If genmode is requested, save mode, owner, and times for all 139 * directories on the tape. 140 */ 141void 142extractdirs(int genmode) 143{ 144 struct inotab *itp; 145 struct direct nulldir; 146 int i, fd; 147 const char *tmpdir; 148 149 vprintf(stdout, "Extract directories from tape\n"); 150 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0') 151 tmpdir = _PATH_TMP; 152 (void) sprintf(dirfile, "%s/rstdir%d", tmpdir, dumpdate); 153 if (command != 'r' && command != 'R') { 154 (void *) strcat(dirfile, "-XXXXXX"); 155 fd = mkstemp(dirfile); 156 } else 157 fd = open(dirfile, O_RDWR|O_CREAT|O_EXCL, 0666); 158 if (fd == -1 || (df = fdopen(fd, "w")) == NULL) { 159 if (fd != -1) 160 close(fd); 161 warn("%s - cannot create directory temporary\nfopen", dirfile); 162 done(1); 163 } 164 if (genmode != 0) { 165 (void) sprintf(modefile, "%s/rstmode%d", tmpdir, dumpdate); 166 if (command != 'r' && command != 'R') { 167 (void *) strcat(modefile, "-XXXXXX"); 168 fd = mkstemp(modefile); 169 } else 170 fd = open(modefile, O_RDWR|O_CREAT|O_EXCL, 0666); 171 if (fd == -1 || (mf = fdopen(fd, "w")) == NULL) { 172 if (fd != -1) 173 close(fd); 174 warn("%s - cannot create modefile\nfopen", modefile); 175 done(1); 176 } 177 } 178 nulldir.d_ino = 0; 179 nulldir.d_type = DT_DIR; 180 nulldir.d_namlen = 1; 181 (void) strcpy(nulldir.d_name, "/"); 182 nulldir.d_reclen = DIRSIZ(0, &nulldir); 183 for (;;) { 184 curfile.name = "<directory file - name unknown>"; 185 curfile.action = USING; 186 if (curfile.mode == 0 || (curfile.mode & IFMT) != IFDIR) { 187 (void) fclose(df); 188 dirp = opendirfile(dirfile); 189 if (dirp == NULL) 190 fprintf(stderr, "opendirfile: %s\n", 191 strerror(errno)); 192 if (mf != NULL) 193 (void) fclose(mf); 194 i = dirlookup(dot); 195 if (i == 0) 196 panic("Root directory is not on tape\n"); 197 return; 198 } 199 itp = allocinotab(&curfile, seekpt); 200 getfile(putdir, xtrnull); 201 putent(&nulldir); 202 flushent(); 203 itp->t_size = seekpt - itp->t_seekpt; 204 } 205} 206 207/* 208 * skip over all the directories on the tape 209 */ 210void 211skipdirs(void) 212{ 213 214 while (curfile.ino && (curfile.mode & IFMT) == IFDIR) { 215 skipfile(); 216 } 217} 218 219/* 220 * Recursively find names and inumbers of all files in subtree 221 * pname and pass them off to be processed. 222 */ 223void 224treescan(char *pname, ino_t ino, long (*todo)(char *, ino_t, int)) 225{ 226 struct inotab *itp; 227 struct direct *dp; 228 int namelen; 229 long bpt; 230 char locname[MAXPATHLEN + 1]; 231 232 itp = inotablookup(ino); 233 if (itp == NULL) { 234 /* 235 * Pname is name of a simple file or an unchanged directory. 236 */ 237 (void) (*todo)(pname, ino, LEAF); 238 return; 239 } 240 /* 241 * Pname is a dumped directory name. 242 */ 243 if ((*todo)(pname, ino, NODE) == FAIL) 244 return; 245 /* 246 * begin search through the directory 247 * skipping over "." and ".." 248 */ 249 (void) strncpy(locname, pname, sizeof(locname) - 1); 250 locname[sizeof(locname) - 1] = '\0'; 251 (void) strncat(locname, "/", sizeof(locname) - strlen(locname)); 252 namelen = strlen(locname); 253 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 254 dp = rst_readdir(dirp); /* "." */ 255 if (dp != NULL && strcmp(dp->d_name, ".") == 0) 256 dp = rst_readdir(dirp); /* ".." */ 257 else 258 fprintf(stderr, "Warning: `.' missing from directory %s\n", 259 pname); 260 if (dp != NULL && strcmp(dp->d_name, "..") == 0) 261 dp = rst_readdir(dirp); /* first real entry */ 262 else 263 fprintf(stderr, "Warning: `..' missing from directory %s\n", 264 pname); 265 bpt = rst_telldir(dirp); 266 /* 267 * a zero inode signals end of directory 268 */ 269 while (dp != NULL) { 270 locname[namelen] = '\0'; 271 if (namelen + dp->d_namlen >= sizeof(locname)) { 272 fprintf(stderr, "%s%s: name exceeds %d char\n", 273 locname, dp->d_name, sizeof(locname) - 1); 274 } else { 275 (void) strncat(locname, dp->d_name, (int)dp->d_namlen); 276 treescan(locname, dp->d_ino, todo); 277 rst_seekdir(dirp, bpt, itp->t_seekpt); 278 } 279 dp = rst_readdir(dirp); 280 bpt = rst_telldir(dirp); 281 } 282} 283 284/* 285 * Lookup a pathname which is always assumed to start from the ROOTINO. 286 */ 287struct direct * 288pathsearch(const char *pathname) 289{ 290 ino_t ino; 291 struct direct *dp; 292 char *path, *name, buffer[MAXPATHLEN]; 293 294 strcpy(buffer, pathname); 295 path = buffer; 296 ino = ROOTINO; 297 while (*path == '/') 298 path++; 299 dp = NULL; 300 while ((name = strsep(&path, "/")) != NULL && *name != '\0') { 301 if ((dp = searchdir(ino, name)) == NULL) 302 return (NULL); 303 ino = dp->d_ino; 304 } 305 return (dp); 306} 307 308/* 309 * Lookup the requested name in directory inum. 310 * Return its inode number if found, zero if it does not exist. 311 */ 312static struct direct * 313searchdir(ino_t inum, char *name) 314{ 315 struct direct *dp; 316 struct inotab *itp; 317 int len; 318 319 itp = inotablookup(inum); 320 if (itp == NULL) 321 return (NULL); 322 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 323 len = strlen(name); 324 do { 325 dp = rst_readdir(dirp); 326 if (dp == NULL) 327 return (NULL); 328 } while (dp->d_namlen != len || strncmp(dp->d_name, name, len) != 0); 329 return (dp); 330} 331 332/* 333 * Put the directory entries in the directory file 334 */ 335static void 336putdir(char *buf, long size) 337{ 338 struct direct cvtbuf; 339 struct odirect *odp; 340 struct odirect *eodp; 341 struct direct *dp; 342 long loc, i; 343 344 for (loc = 0; loc < size; ) { 345 dp = (struct direct *)(buf + loc); 346 if (Bcvt) 347 swabst((u_char *)"ls", (u_char *) dp); 348 i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1)); 349 if ((dp->d_reclen & 0x3) != 0 || 350 dp->d_reclen > i || 351 dp->d_reclen < DIRSIZ(0, dp) || 352 dp->d_namlen > NAME_MAX) { 353 vprintf(stdout, "Mangled directory: "); 354 if ((dp->d_reclen & 0x3) != 0) 355 vprintf(stdout, 356 "reclen not multiple of 4 "); 357 if (dp->d_reclen < DIRSIZ(0, dp)) 358 vprintf(stdout, 359 "reclen less than DIRSIZ (%d < %d) ", 360 dp->d_reclen, DIRSIZ(0, dp)); 361 if (dp->d_namlen > NAME_MAX) 362 vprintf(stdout, 363 "reclen name too big (%d > %d) ", 364 dp->d_namlen, NAME_MAX); 365 vprintf(stdout, "\n"); 366 loc += i; 367 continue; 368 } 369 loc += dp->d_reclen; 370 if (dp->d_ino != 0) { 371 putent(dp); 372 } 373 } 374} 375 376/* 377 * These variables are "local" to the following two functions. 378 */ 379char dirbuf[DIRBLKSIZ]; 380long dirloc = 0; 381long prev = 0; 382 383/* 384 * add a new directory entry to a file. 385 */ 386static void 387putent(struct direct *dp) 388{ 389 dp->d_reclen = DIRSIZ(0, dp); 390 if (dirloc + dp->d_reclen > DIRBLKSIZ) { 391 ((struct direct *)(dirbuf + prev))->d_reclen = 392 DIRBLKSIZ - prev; 393 (void) fwrite(dirbuf, 1, DIRBLKSIZ, df); 394 dirloc = 0; 395 } 396 memmove(dirbuf + dirloc, dp, (long)dp->d_reclen); 397 prev = dirloc; 398 dirloc += dp->d_reclen; 399} 400 401/* 402 * flush out a directory that is finished. 403 */ 404static void 405flushent(void) 406{ 407 ((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ - prev; 408 (void) fwrite(dirbuf, (int)dirloc, 1, df); 409 seekpt = ftell(df); 410 dirloc = 0; 411} 412 413static void 414dcvt(struct odirect *odp, struct direct *ndp) 415{ 416 417 memset(ndp, 0, (long)(sizeof *ndp)); 418 ndp->d_ino = odp->d_ino; 419 ndp->d_type = DT_UNKNOWN; 420 (void) strncpy(ndp->d_name, odp->d_name, ODIRSIZ); 421 ndp->d_namlen = strlen(ndp->d_name); 422 ndp->d_reclen = DIRSIZ(0, ndp); 423} 424 425/* 426 * Seek to an entry in a directory. 427 * Only values returned by rst_telldir should be passed to rst_seekdir. 428 * This routine handles many directories in a single file. 429 * It takes the base of the directory in the file, plus 430 * the desired seek offset into it. 431 */ 432static void 433rst_seekdir(RST_DIR *dirp, long loc, long base) 434{ 435 436 if (loc == rst_telldir(dirp)) 437 return; 438 loc -= base; 439 if (loc < 0) 440 fprintf(stderr, "bad seek pointer to rst_seekdir %ld\n", loc); 441 (void) lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), SEEK_SET); 442 dirp->dd_loc = loc & (DIRBLKSIZ - 1); 443 if (dirp->dd_loc != 0) 444 dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ); 445} 446 447/* 448 * get next entry in a directory. 449 */ 450struct direct * 451rst_readdir(RST_DIR *dirp) 452{ 453 struct direct *dp; 454 455 for (;;) { 456 if (dirp->dd_loc == 0) { 457 dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, 458 DIRBLKSIZ); 459 if (dirp->dd_size <= 0) { 460 dprintf(stderr, "error reading directory\n"); 461 return (NULL); 462 } 463 } 464 if (dirp->dd_loc >= dirp->dd_size) { 465 dirp->dd_loc = 0; 466 continue; 467 } 468 dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc); 469 if (dp->d_reclen == 0 || 470 dp->d_reclen > DIRBLKSIZ + 1 - dirp->dd_loc) { 471 dprintf(stderr, "corrupted directory: bad reclen %d\n", 472 dp->d_reclen); 473 return (NULL); 474 } 475 dirp->dd_loc += dp->d_reclen; 476 if (dp->d_ino == 0 && strcmp(dp->d_name, "/") == 0) 477 return (NULL); 478 if (dp->d_ino >= maxino) { 479 dprintf(stderr, "corrupted directory: bad inum %d\n", 480 dp->d_ino); 481 continue; 482 } 483 return (dp); 484 } 485} 486 487/* 488 * Simulate the opening of a directory 489 */ 490RST_DIR * 491rst_opendir(const char *name) 492{ 493 struct inotab *itp; 494 RST_DIR *dirp; 495 ino_t ino; 496 497 if ((ino = dirlookup(name)) > 0 && 498 (itp = inotablookup(ino)) != NULL) { 499 dirp = opendirfile(dirfile); 500 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 501 return (dirp); 502 } 503 return (NULL); 504} 505 506/* 507 * In our case, there is nothing to do when closing a directory. 508 */ 509void 510rst_closedir(RST_DIR *dirp) 511{ 512 513 (void)close(dirp->dd_fd); 514 free(dirp); 515 return; 516} 517 518/* 519 * Simulate finding the current offset in the directory. 520 */ 521static long 522rst_telldir(RST_DIR *dirp) 523{ 524 return ((long)lseek(dirp->dd_fd, 525 (off_t)0, SEEK_CUR) - dirp->dd_size + dirp->dd_loc); 526} 527 528/* 529 * Open a directory file. 530 */ 531static RST_DIR * 532opendirfile(const char *name) 533{ 534 RST_DIR *dirp; 535 int fd; 536 537 if ((fd = open(name, O_RDONLY)) == -1) 538 return (NULL); 539 if ((dirp = malloc(sizeof(RST_DIR))) == NULL) { 540 (void)close(fd); 541 return (NULL); 542 } 543 dirp->dd_fd = fd; 544 dirp->dd_loc = 0; 545 return (dirp); 546} 547 548/* 549 * Set the mode, owner, and times for all new or changed directories 550 */ 551void 552setdirmodes(int flags) 553{ 554 FILE *mf; 555 struct modeinfo node; 556 struct entry *ep; 557 char *cp; 558 const char *tmpdir; 559 560 vprintf(stdout, "Set directory mode, owner, and times.\n"); 561 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0') 562 tmpdir = _PATH_TMP; 563 if (command == 'r' || command == 'R') 564 (void) sprintf(modefile, "%s/rstmode%d", tmpdir, dumpdate); 565 if (modefile[0] == '#') { 566 panic("modefile not defined\n"); 567 fprintf(stderr, "directory mode, owner, and times not set\n"); 568 return; 569 } 570 mf = fopen(modefile, "r"); 571 if (mf == NULL) { 572 fprintf(stderr, "fopen: %s\n", strerror(errno)); 573 fprintf(stderr, "cannot open mode file %s\n", modefile); 574 fprintf(stderr, "directory mode, owner, and times not set\n"); 575 return; 576 } 577 clearerr(mf); 578 for (;;) { 579 (void) fread((char *)&node, 1, sizeof(struct modeinfo), mf); 580 if (feof(mf)) 581 break; 582 ep = lookupino(node.ino); 583 if (command == 'i' || command == 'x') { 584 if (ep == NULL) 585 continue; 586 if ((flags & FORCE) == 0 && ep->e_flags & EXISTED) { 587 ep->e_flags &= ~NEW; 588 continue; 589 } 590 if (node.ino == ROOTINO && 591 reply("set owner/mode for '.'") == FAIL) 592 continue; 593 } 594 if (ep == NULL) { 595 panic("cannot find directory inode %d\n", node.ino); 596 } else { 597 cp = myname(ep); 598 if (!Nflag) { 599 (void) chown(cp, node.uid, node.gid); 600 (void) chmod(cp, node.mode); 601 utimes(cp, node.ctimep); 602 utimes(cp, node.mtimep); 603 (void) chflags(cp, node.flags); 604 } 605 ep->e_flags &= ~NEW; 606 } 607 } 608 if (ferror(mf)) 609 panic("error setting directory modes\n"); 610 (void) fclose(mf); 611} 612 613/* 614 * Generate a literal copy of a directory. 615 */ 616int 617genliteraldir(char *name, ino_t ino) 618{ 619 struct inotab *itp; 620 int ofile, dp, i, size; 621 char buf[BUFSIZ]; 622 623 itp = inotablookup(ino); 624 if (itp == NULL) 625 panic("Cannot find directory inode %d named %s\n", ino, name); 626 if ((ofile = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) { 627 fprintf(stderr, "%s: ", name); 628 (void) fflush(stderr); 629 fprintf(stderr, "cannot create file: %s\n", strerror(errno)); 630 return (FAIL); 631 } 632 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 633 dp = dup(dirp->dd_fd); 634 for (i = itp->t_size; i > 0; i -= BUFSIZ) { 635 size = i < BUFSIZ ? i : BUFSIZ; 636 if (read(dp, buf, (int) size) == -1) { 637 fprintf(stderr, 638 "write error extracting inode %d, name %s\n", 639 curfile.ino, curfile.name); 640 fprintf(stderr, "read: %s\n", strerror(errno)); 641 done(1); 642 } 643 if (!Nflag && write(ofile, buf, (int) size) == -1) { 644 fprintf(stderr, 645 "write error extracting inode %d, name %s\n", 646 curfile.ino, curfile.name); 647 fprintf(stderr, "write: %s\n", strerror(errno)); 648 done(1); 649 } 650 } 651 (void) close(dp); 652 (void) close(ofile); 653 return (GOOD); 654} 655 656/* 657 * Determine the type of an inode 658 */ 659int 660inodetype(ino_t ino) 661{ 662 struct inotab *itp; 663 664 itp = inotablookup(ino); 665 if (itp == NULL) 666 return (LEAF); 667 return (NODE); 668} 669 670/* 671 * Allocate and initialize a directory inode entry. 672 * If requested, save its pertinent mode, owner, and time info. 673 */ 674static struct inotab * 675allocinotab(struct context *ctxp, long seekpt) 676{ 677 struct inotab *itp; 678 struct modeinfo node; 679 680 itp = calloc(1, sizeof(struct inotab)); 681 if (itp == NULL) 682 panic("no memory directory table\n"); 683 itp->t_next = inotab[INOHASH(ctxp->ino)]; 684 inotab[INOHASH(ctxp->ino)] = itp; 685 itp->t_ino = ctxp->ino; 686 itp->t_seekpt = seekpt; 687 if (mf == NULL) 688 return (itp); 689 node.ino = ctxp->ino; 690 node.mtimep[0].tv_sec = ctxp->atime_sec; 691 node.mtimep[0].tv_usec = ctxp->atime_nsec / 1000; 692 node.mtimep[1].tv_sec = ctxp->mtime_sec; 693 node.mtimep[1].tv_usec = ctxp->mtime_nsec / 1000; 694 node.ctimep[0].tv_sec = ctxp->atime_sec; 695 node.ctimep[0].tv_usec = ctxp->atime_nsec / 1000; 696 node.ctimep[1].tv_sec = ctxp->birthtime_sec; 697 node.ctimep[1].tv_usec = ctxp->birthtime_nsec / 1000; 698 node.mode = ctxp->mode; 699 node.flags = ctxp->file_flags; 700 node.uid = ctxp->uid; 701 node.gid = ctxp->gid; 702 (void) fwrite((char *)&node, 1, sizeof(struct modeinfo), mf); 703 return (itp); 704} 705 706/* 707 * Look up an inode in the table of directories 708 */ 709static struct inotab * 710inotablookup(ino_t ino) 711{ 712 struct inotab *itp; 713 714 for (itp = inotab[INOHASH(ino)]; itp != NULL; itp = itp->t_next) 715 if (itp->t_ino == ino) 716 return (itp); 717 return (NULL); 718} 719 720/* 721 * Clean up and exit 722 */ 723void 724done(int exitcode) 725{ 726 727 closemt(); 728 if (modefile[0] != '#') 729 (void) unlink(modefile); 730 if (dirfile[0] != '#') 731 (void) unlink(dirfile); 732 exit(exitcode); 733} 734