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