sbin/restore/dirs.c

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