dirs.c revision 92806
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 92806 2002-03-20 17:55:10Z obrien $"; 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 timep[2]; 86 mode_t mode; 87 uid_t uid; 88 gid_t gid; 89 int flags; 90}; 91 92/* 93 * Definitions for library routines operating on directories. 94 */ 95#undef DIRBLKSIZ 96#define DIRBLKSIZ 1024 97struct rstdirdesc { 98 int dd_fd; 99 int32_t dd_loc; 100 int32_t dd_size; 101 char dd_buf[DIRBLKSIZ]; 102}; 103 104/* 105 * Global variables for this file. 106 */ 107static long seekpt; 108static FILE *df, *mf; 109static RST_DIR *dirp; 110static char dirfile[MAXPATHLEN] = "#"; /* No file */ 111static char modefile[MAXPATHLEN] = "#"; /* No file */ 112static char dot[2] = "."; /* So it can be modified */ 113 114/* 115 * Format of old style directories. 116 */ 117#define ODIRSIZ 14 118struct odirect { 119 u_short d_ino; 120 char d_name[ODIRSIZ]; 121}; 122 123static struct inotab *allocinotab __P((ino_t, struct dinode *, long)); 124static void dcvt __P((struct odirect *, struct direct *)); 125static void flushent __P((void)); 126static struct inotab *inotablookup __P((ino_t)); 127static RST_DIR *opendirfile __P((const char *)); 128static void putdir __P((char *, long)); 129static void putent __P((struct direct *)); 130static void rst_seekdir __P((RST_DIR *, long, long)); 131static long rst_telldir __P((RST_DIR *)); 132static struct direct *searchdir __P((ino_t, char *)); 133 134/* 135 * Extract directory contents, building up a directory structure 136 * on disk for extraction by name. 137 * If genmode is requested, save mode, owner, and times for all 138 * directories on the tape. 139 */ 140void 141extractdirs(genmode) 142 int genmode; 143{ 144 int i; 145 struct dinode *ip; 146 struct inotab *itp; 147 struct direct nulldir; 148 int fd; 149 const char *tmpdir; 150 151 vprintf(stdout, "Extract directories from tape\n"); 152 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0') 153 tmpdir = _PATH_TMP; 154 (void) sprintf(dirfile, "%s/rstdir%d", tmpdir, dumpdate); 155 if (command != 'r' && command != 'R') { 156 (void *) strcat(dirfile, "-XXXXXX"); 157 fd = mkstemp(dirfile); 158 } else 159 fd = open(dirfile, O_RDWR|O_CREAT|O_EXCL, 0666); 160 if (fd == -1 || (df = fdopen(fd, "w")) == NULL) { 161 if (fd != -1) 162 close(fd); 163 warn("%s - cannot create directory temporary\nfopen", dirfile); 164 done(1); 165 } 166 if (genmode != 0) { 167 (void) sprintf(modefile, "%s/rstmode%d", tmpdir, dumpdate); 168 if (command != 'r' && command != 'R') { 169 (void *) strcat(modefile, "-XXXXXX"); 170 fd = mkstemp(modefile); 171 } else 172 fd = open(modefile, O_RDWR|O_CREAT|O_EXCL, 0666); 173 if (fd == -1 || (mf = fdopen(fd, "w")) == NULL) { 174 if (fd != -1) 175 close(fd); 176 warn("%s - cannot create modefile\nfopen", modefile); 177 done(1); 178 } 179 } 180 nulldir.d_ino = 0; 181 nulldir.d_type = DT_DIR; 182 nulldir.d_namlen = 1; 183 (void) strcpy(nulldir.d_name, "/"); 184 nulldir.d_reclen = DIRSIZ(0, &nulldir); 185 for (;;) { 186 curfile.name = "<directory file - name unknown>"; 187 curfile.action = USING; 188 ip = curfile.dip; 189 if (ip == NULL || (ip->di_mode & IFMT) != IFDIR) { 190 (void) fclose(df); 191 dirp = opendirfile(dirfile); 192 if (dirp == NULL) 193 fprintf(stderr, "opendirfile: %s\n", 194 strerror(errno)); 195 if (mf != NULL) 196 (void) fclose(mf); 197 i = dirlookup(dot); 198 if (i == 0) 199 panic("Root directory is not on tape\n"); 200 return; 201 } 202 itp = allocinotab(curfile.ino, ip, seekpt); 203 getfile(putdir, xtrnull); 204 putent(&nulldir); 205 flushent(); 206 itp->t_size = seekpt - itp->t_seekpt; 207 } 208} 209 210/* 211 * skip over all the directories on the tape 212 */ 213void 214skipdirs() 215{ 216 217 while (curfile.dip && (curfile.dip->di_mode & IFMT) == IFDIR) { 218 skipfile(); 219 } 220} 221 222/* 223 * Recursively find names and inumbers of all files in subtree 224 * pname and pass them off to be processed. 225 */ 226void 227treescan(pname, ino, todo) 228 char *pname; 229 ino_t ino; 230 long (*todo) __P((char *, ino_t, int)); 231{ 232 struct inotab *itp; 233 struct direct *dp; 234 int namelen; 235 long bpt; 236 char locname[MAXPATHLEN + 1]; 237 238 itp = inotablookup(ino); 239 if (itp == NULL) { 240 /* 241 * Pname is name of a simple file or an unchanged directory. 242 */ 243 (void) (*todo)(pname, ino, LEAF); 244 return; 245 } 246 /* 247 * Pname is a dumped directory name. 248 */ 249 if ((*todo)(pname, ino, NODE) == FAIL) 250 return; 251 /* 252 * begin search through the directory 253 * skipping over "." and ".." 254 */ 255 (void) strncpy(locname, pname, sizeof(locname) - 1); 256 locname[sizeof(locname) - 1] = '\0'; 257 (void) strncat(locname, "/", sizeof(locname) - strlen(locname)); 258 namelen = strlen(locname); 259 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 260 dp = rst_readdir(dirp); /* "." */ 261 if (dp != NULL && strcmp(dp->d_name, ".") == 0) 262 dp = rst_readdir(dirp); /* ".." */ 263 else 264 fprintf(stderr, "Warning: `.' missing from directory %s\n", 265 pname); 266 if (dp != NULL && strcmp(dp->d_name, "..") == 0) 267 dp = rst_readdir(dirp); /* first real entry */ 268 else 269 fprintf(stderr, "Warning: `..' missing from directory %s\n", 270 pname); 271 bpt = rst_telldir(dirp); 272 /* 273 * a zero inode signals end of directory 274 */ 275 while (dp != NULL) { 276 locname[namelen] = '\0'; 277 if (namelen + dp->d_namlen >= sizeof(locname)) { 278 fprintf(stderr, "%s%s: name exceeds %d char\n", 279 locname, dp->d_name, sizeof(locname) - 1); 280 } else { 281 (void) strncat(locname, dp->d_name, (int)dp->d_namlen); 282 treescan(locname, dp->d_ino, todo); 283 rst_seekdir(dirp, bpt, itp->t_seekpt); 284 } 285 dp = rst_readdir(dirp); 286 bpt = rst_telldir(dirp); 287 } 288} 289 290/* 291 * Lookup a pathname which is always assumed to start from the ROOTINO. 292 */ 293struct direct * 294pathsearch(pathname) 295 const char *pathname; 296{ 297 ino_t ino; 298 struct direct *dp; 299 char *path, *name, buffer[MAXPATHLEN]; 300 301 strcpy(buffer, pathname); 302 path = buffer; 303 ino = ROOTINO; 304 while (*path == '/') 305 path++; 306 dp = NULL; 307 while ((name = strsep(&path, "/")) != NULL && *name != '\0') { 308 if ((dp = searchdir(ino, name)) == NULL) 309 return (NULL); 310 ino = dp->d_ino; 311 } 312 return (dp); 313} 314 315/* 316 * Lookup the requested name in directory inum. 317 * Return its inode number if found, zero if it does not exist. 318 */ 319static struct direct * 320searchdir(inum, name) 321 ino_t inum; 322 char *name; 323{ 324 struct direct *dp; 325 struct inotab *itp; 326 int len; 327 328 itp = inotablookup(inum); 329 if (itp == NULL) 330 return (NULL); 331 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 332 len = strlen(name); 333 do { 334 dp = rst_readdir(dirp); 335 if (dp == NULL) 336 return (NULL); 337 } while (dp->d_namlen != len || strncmp(dp->d_name, name, len) != 0); 338 return (dp); 339} 340 341/* 342 * Put the directory entries in the directory file 343 */ 344static void 345putdir(buf, size) 346 char *buf; 347 long size; 348{ 349 struct direct cvtbuf; 350 struct odirect *odp; 351 struct odirect *eodp; 352 struct direct *dp; 353 long loc, i; 354 355 if (cvtflag) { 356 eodp = (struct odirect *)&buf[size]; 357 for (odp = (struct odirect *)buf; odp < eodp; odp++) 358 if (odp->d_ino != 0) { 359 dcvt(odp, &cvtbuf); 360 putent(&cvtbuf); 361 } 362 } else { 363 for (loc = 0; loc < size; ) { 364 dp = (struct direct *)(buf + loc); 365 if (Bcvt) 366 swabst((u_char *)"ls", (u_char *) dp); 367 if (oldinofmt && dp->d_ino != 0) { 368# if BYTE_ORDER == BIG_ENDIAN 369 if (Bcvt) 370 dp->d_namlen = dp->d_type; 371# else 372 if (!Bcvt) 373 dp->d_namlen = dp->d_type; 374# endif 375 dp->d_type = DT_UNKNOWN; 376 } 377 i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1)); 378 if ((dp->d_reclen & 0x3) != 0 || 379 dp->d_reclen > i || 380 dp->d_reclen < DIRSIZ(0, dp) || 381 dp->d_namlen > NAME_MAX) { 382 vprintf(stdout, "Mangled directory: "); 383 if ((dp->d_reclen & 0x3) != 0) 384 vprintf(stdout, 385 "reclen not multiple of 4 "); 386 if (dp->d_reclen < DIRSIZ(0, dp)) 387 vprintf(stdout, 388 "reclen less than DIRSIZ (%d < %d) ", 389 dp->d_reclen, DIRSIZ(0, dp)); 390 if (dp->d_namlen > NAME_MAX) 391 vprintf(stdout, 392 "reclen name too big (%d > %d) ", 393 dp->d_namlen, NAME_MAX); 394 vprintf(stdout, "\n"); 395 loc += i; 396 continue; 397 } 398 loc += dp->d_reclen; 399 if (dp->d_ino != 0) { 400 putent(dp); 401 } 402 } 403 } 404} 405 406/* 407 * These variables are "local" to the following two functions. 408 */ 409char dirbuf[DIRBLKSIZ]; 410long dirloc = 0; 411long prev = 0; 412 413/* 414 * add a new directory entry to a file. 415 */ 416static void 417putent(dp) 418 struct direct *dp; 419{ 420 dp->d_reclen = DIRSIZ(0, dp); 421 if (dirloc + dp->d_reclen > DIRBLKSIZ) { 422 ((struct direct *)(dirbuf + prev))->d_reclen = 423 DIRBLKSIZ - prev; 424 (void) fwrite(dirbuf, 1, DIRBLKSIZ, df); 425 dirloc = 0; 426 } 427 memmove(dirbuf + dirloc, dp, (long)dp->d_reclen); 428 prev = dirloc; 429 dirloc += dp->d_reclen; 430} 431 432/* 433 * flush out a directory that is finished. 434 */ 435static void 436flushent() 437{ 438 ((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ - prev; 439 (void) fwrite(dirbuf, (int)dirloc, 1, df); 440 seekpt = ftell(df); 441 dirloc = 0; 442} 443 444static void 445dcvt(odp, ndp) 446 struct odirect *odp; 447 struct direct *ndp; 448{ 449 450 memset(ndp, 0, (long)(sizeof *ndp)); 451 ndp->d_ino = odp->d_ino; 452 ndp->d_type = DT_UNKNOWN; 453 (void) strncpy(ndp->d_name, odp->d_name, ODIRSIZ); 454 ndp->d_namlen = strlen(ndp->d_name); 455 ndp->d_reclen = DIRSIZ(0, ndp); 456} 457 458/* 459 * Seek to an entry in a directory. 460 * Only values returned by rst_telldir should be passed to rst_seekdir. 461 * This routine handles many directories in a single file. 462 * It takes the base of the directory in the file, plus 463 * the desired seek offset into it. 464 */ 465static void 466rst_seekdir(dirp, loc, base) 467 RST_DIR *dirp; 468 long loc, base; 469{ 470 471 if (loc == rst_telldir(dirp)) 472 return; 473 loc -= base; 474 if (loc < 0) 475 fprintf(stderr, "bad seek pointer to rst_seekdir %ld\n", loc); 476 (void) lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), SEEK_SET); 477 dirp->dd_loc = loc & (DIRBLKSIZ - 1); 478 if (dirp->dd_loc != 0) 479 dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ); 480} 481 482/* 483 * get next entry in a directory. 484 */ 485struct direct * 486rst_readdir(dirp) 487 RST_DIR *dirp; 488{ 489 struct direct *dp; 490 491 for (;;) { 492 if (dirp->dd_loc == 0) { 493 dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, 494 DIRBLKSIZ); 495 if (dirp->dd_size <= 0) { 496 dprintf(stderr, "error reading directory\n"); 497 return (NULL); 498 } 499 } 500 if (dirp->dd_loc >= dirp->dd_size) { 501 dirp->dd_loc = 0; 502 continue; 503 } 504 dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc); 505 if (dp->d_reclen == 0 || 506 dp->d_reclen > DIRBLKSIZ + 1 - dirp->dd_loc) { 507 dprintf(stderr, "corrupted directory: bad reclen %d\n", 508 dp->d_reclen); 509 return (NULL); 510 } 511 dirp->dd_loc += dp->d_reclen; 512 if (dp->d_ino == 0 && strcmp(dp->d_name, "/") == 0) 513 return (NULL); 514 if (dp->d_ino >= maxino) { 515 dprintf(stderr, "corrupted directory: bad inum %d\n", 516 dp->d_ino); 517 continue; 518 } 519 return (dp); 520 } 521} 522 523/* 524 * Simulate the opening of a directory 525 */ 526RST_DIR * 527rst_opendir(name) 528 const char *name; 529{ 530 struct inotab *itp; 531 RST_DIR *dirp; 532 ino_t ino; 533 534 if ((ino = dirlookup(name)) > 0 && 535 (itp = inotablookup(ino)) != NULL) { 536 dirp = opendirfile(dirfile); 537 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 538 return (dirp); 539 } 540 return (NULL); 541} 542 543/* 544 * In our case, there is nothing to do when closing a directory. 545 */ 546void 547rst_closedir(dirp) 548 RST_DIR *dirp; 549{ 550 551 (void)close(dirp->dd_fd); 552 free(dirp); 553 return; 554} 555 556/* 557 * Simulate finding the current offset in the directory. 558 */ 559static long 560rst_telldir(dirp) 561 RST_DIR *dirp; 562{ 563 return ((long)lseek(dirp->dd_fd, 564 (off_t)0, SEEK_CUR) - dirp->dd_size + dirp->dd_loc); 565} 566 567/* 568 * Open a directory file. 569 */ 570static RST_DIR * 571opendirfile(name) 572 const char *name; 573{ 574 RST_DIR *dirp; 575 int fd; 576 577 if ((fd = open(name, O_RDONLY)) == -1) 578 return (NULL); 579 if ((dirp = malloc(sizeof(RST_DIR))) == NULL) { 580 (void)close(fd); 581 return (NULL); 582 } 583 dirp->dd_fd = fd; 584 dirp->dd_loc = 0; 585 return (dirp); 586} 587 588/* 589 * Set the mode, owner, and times for all new or changed directories 590 */ 591void 592setdirmodes(flags) 593 int flags; 594{ 595 FILE *mf; 596 struct modeinfo node; 597 struct entry *ep; 598 char *cp; 599 const char *tmpdir; 600 601 vprintf(stdout, "Set directory mode, owner, and times.\n"); 602 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0') 603 tmpdir = _PATH_TMP; 604 if (command == 'r' || command == 'R') 605 (void) sprintf(modefile, "%s/rstmode%d", tmpdir, dumpdate); 606 if (modefile[0] == '#') { 607 panic("modefile not defined\n"); 608 fprintf(stderr, "directory mode, owner, and times not set\n"); 609 return; 610 } 611 mf = fopen(modefile, "r"); 612 if (mf == NULL) { 613 fprintf(stderr, "fopen: %s\n", strerror(errno)); 614 fprintf(stderr, "cannot open mode file %s\n", modefile); 615 fprintf(stderr, "directory mode, owner, and times not set\n"); 616 return; 617 } 618 clearerr(mf); 619 for (;;) { 620 (void) fread((char *)&node, 1, sizeof(struct modeinfo), mf); 621 if (feof(mf)) 622 break; 623 ep = lookupino(node.ino); 624 if (command == 'i' || command == 'x') { 625 if (ep == NULL) 626 continue; 627 if ((flags & FORCE) == 0 && ep->e_flags & EXISTED) { 628 ep->e_flags &= ~NEW; 629 continue; 630 } 631 if (node.ino == ROOTINO && 632 reply("set owner/mode for '.'") == FAIL) 633 continue; 634 } 635 if (ep == NULL) { 636 panic("cannot find directory inode %d\n", node.ino); 637 } else { 638 cp = myname(ep); 639 if (!Nflag) { 640 (void) chown(cp, node.uid, node.gid); 641 (void) chmod(cp, node.mode); 642 utimes(cp, node.timep); 643 (void) chflags(cp, node.flags); 644 } 645 ep->e_flags &= ~NEW; 646 } 647 } 648 if (ferror(mf)) 649 panic("error setting directory modes\n"); 650 (void) fclose(mf); 651} 652 653/* 654 * Generate a literal copy of a directory. 655 */ 656int 657genliteraldir(name, ino) 658 char *name; 659 ino_t ino; 660{ 661 struct inotab *itp; 662 int ofile, dp, i, size; 663 char buf[BUFSIZ]; 664 665 itp = inotablookup(ino); 666 if (itp == NULL) 667 panic("Cannot find directory inode %d named %s\n", ino, name); 668 if ((ofile = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) { 669 fprintf(stderr, "%s: ", name); 670 (void) fflush(stderr); 671 fprintf(stderr, "cannot create file: %s\n", strerror(errno)); 672 return (FAIL); 673 } 674 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt); 675 dp = dup(dirp->dd_fd); 676 for (i = itp->t_size; i > 0; i -= BUFSIZ) { 677 size = i < BUFSIZ ? i : BUFSIZ; 678 if (read(dp, buf, (int) size) == -1) { 679 fprintf(stderr, 680 "write error extracting inode %d, name %s\n", 681 curfile.ino, curfile.name); 682 fprintf(stderr, "read: %s\n", strerror(errno)); 683 done(1); 684 } 685 if (!Nflag && write(ofile, buf, (int) size) == -1) { 686 fprintf(stderr, 687 "write error extracting inode %d, name %s\n", 688 curfile.ino, curfile.name); 689 fprintf(stderr, "write: %s\n", strerror(errno)); 690 done(1); 691 } 692 } 693 (void) close(dp); 694 (void) close(ofile); 695 return (GOOD); 696} 697 698/* 699 * Determine the type of an inode 700 */ 701int 702inodetype(ino) 703 ino_t ino; 704{ 705 struct inotab *itp; 706 707 itp = inotablookup(ino); 708 if (itp == NULL) 709 return (LEAF); 710 return (NODE); 711} 712 713/* 714 * Allocate and initialize a directory inode entry. 715 * If requested, save its pertinent mode, owner, and time info. 716 */ 717static struct inotab * 718allocinotab(ino, dip, seekpt) 719 ino_t ino; 720 struct dinode *dip; 721 long seekpt; 722{ 723 struct inotab *itp; 724 struct modeinfo node; 725 726 itp = calloc(1, sizeof(struct inotab)); 727 if (itp == NULL) 728 panic("no memory directory table\n"); 729 itp->t_next = inotab[INOHASH(ino)]; 730 inotab[INOHASH(ino)] = itp; 731 itp->t_ino = ino; 732 itp->t_seekpt = seekpt; 733 if (mf == NULL) 734 return (itp); 735 node.ino = ino; 736 node.timep[0].tv_sec = dip->di_atime; 737 node.timep[0].tv_usec = dip->di_atimensec / 1000; 738 node.timep[1].tv_sec = dip->di_mtime; 739 node.timep[1].tv_usec = dip->di_mtimensec / 1000; 740 node.mode = dip->di_mode; 741 node.flags = dip->di_flags; 742 node.uid = dip->di_uid; 743 node.gid = dip->di_gid; 744 (void) fwrite((char *)&node, 1, sizeof(struct modeinfo), mf); 745 return (itp); 746} 747 748/* 749 * Look up an inode in the table of directories 750 */ 751static struct inotab * 752inotablookup(ino) 753 ino_t ino; 754{ 755 struct inotab *itp; 756 757 for (itp = inotab[INOHASH(ino)]; itp != NULL; itp = itp->t_next) 758 if (itp->t_ino == ino) 759 return (itp); 760 return (NULL); 761} 762 763/* 764 * Clean up and exit 765 */ 766void 767done(exitcode) 768 int exitcode; 769{ 770 771 closemt(); 772 if (modefile[0] != '#') 773 (void) unlink(modefile); 774 if (dirfile[0] != '#') 775 (void) unlink(dirfile); 776 exit(exitcode); 777} 778