Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/3/3184

Internet Message Format | 1991-04-12 | 46.0 KB

From: [e-mail] (Bob Ankeney)
Newsgroups: alt.sources
Subject: fssal - BSD filesystem salvage program, Part 01/01
Message-ID: <[e-mail]>
Date: 9 Apr 91 20:44:15 GMT


#!/bin/sh
# shar:    Shell Archiver  (v1.22)
#
#    Run the following text with /bin/sh to create:
#      README
#      FILES
#      NOTES
#      Makefile
#      defs.h
#      fs.h
#      idir.c
#      iname.c
#      io.c
#      ls.c
#      main.c
#      namei.c
#      restore.c
#      stat.c
#
sed 's/^X//' << 'SHAR_EOF' > README &&
X     Fssal is a utility to salvage files from damaged BSD filesystems.
XSuch damage might include a lost super-block, trashed cylinder group,
Xdrive with bad blocks, or perhaps a filesystem with files that may get
Xconsumed by a fsck.  It requires the presence of a relatively intact
Xfilesystem (an intact original or alternate super-block, some semblence
Xof an inode-structure, and some intact cylinder-groups).  Thus such
Xthings as deleted files cannot be restored.
X
X     The impetus for writing this program was to recover files from a
Xfilesystem with the original super-block and first (of six) cylinder
Xgroups walked on.  What happened was a mkfs of a small system was
Xaccidentally done, which wiped the initial data.  Data from all other
Xcylinder groups was still intact and recoverable.  An alternate (spare)
Xsuper-block is found within each cylinder group.
X
X     All restored files are placed relative to the working directory,
Xand all permissions, creation/modification times, and ownerships are
Xrestored.  Both real and symbolic links are handled, as well as
Xcharacter and block special devices and sockets.
X
X     At no time is the specified file-system written on, thus data is
Xsafe.  The specified file-system need not be mounted (and probably
Xshouldn't be lest others modify it as a restore is in progress).
X
X     The general usage is:
X
X        fssal [-f device] [-s super-block] [-r root-inode] [-a] [-R] [-v]
X
X     where:
X    -f device: is the file-system to use (do not use the raw device!!)
X    -s super-block: is an alternate super-block
X    -r root-inode: is an alternate directory inode to start at
X
X    -a: stats all inodes in file-system and restores those that are
X        directories.  The -R flag can be used to recursively walk each
X        sub-directory.  Each directory found that has not yet been
X        restored will be created with the directory name '#inum', where
X        inum is the inode number of that directory.
X
X    -R: recursively walk each sub-directory found.
X
X    -v: verbose mode.  Spews out lots of information as to what's been
X        restored.
X
X     A link to fssal called fsls exists which does a directory listing on
Xthe specified file system.  The general usage is:
X
X        fsls [-f device] [-s super-block] [-r root-inode] [-a] [-R] [-l]
X
X     where:
X    -f device: is the file-system to use (do not use the raw device!!)
X    -s super-block: is an alternate super-block
X    -r root-inode: is an alternate directory inode to start at
X
X    -a: stats all inodes in file-system and lists those that are
X        directories.  The -R flag can be used to recursively walk each
X        sub-directory.
X
X    -R: recursively walk each sub-directory found.
X
X    -l: do a long directory list (like 'ls -liga')
X
X
X     Hopefully someone will take this under their wing and make improvements
Xto it.  Some suggestions are:
X     a) Make it interactive (ala restore -i).
X     b) Port it to other platforms; it has been used successfully on:
X        DEC VAX with Mt. Xinu
X        DEC VAX with Ultrix V2.3
X        Sun-4 with SunOs V4.1
X        Tektronix Utek V2.2
X     c) A manual page.
X
X
X     Feel free to mail me any suggestions, bug fixes and enhancements.  I'll
Xtry to integrate them (it's been a while since I wrote this) and make occasional
Xreleases.  If it looks solid enough, I'll post to comp.sources.unix.
X
X     Bob Ankeney
X     ...!tektronix![e-mail]
X
SHAR_EOF
chmod 0644 README || echo "restore of README fails"
sed 's/^X//' << 'SHAR_EOF' > FILES &&
XREADME
XFILES
XNOTES
XMakefile
Xdefs.h
Xfs.h
Xidir.c
Xiname.c
Xio.c
Xls.c
Xmain.c
Xnamei.c
Xrestore.c
Xstat.c
SHAR_EOF
chmod 0644 FILES || echo "restore of FILES fails"
sed 's/^X//' << 'SHAR_EOF' > NOTES &&
XThings to check for:
X
X     Error handling (failed reads especially).
X
X     Freeing of malloced space.
X
XTo do:
X
X     Read inode into buffer and get inode structures from it (fixes reads on
X     raw device).
X
X     Cache ureads?  (uread reads entire block and bcopies desired info).
X     Keep track of last block read to avoid duplicate reads.
X
SHAR_EOF
chmod 0644 NOTES || echo "restore of NOTES fails"
sed 's/^X//' << 'SHAR_EOF' > Makefile &&
X#CFLAGS = -g -DDEBUG
XCFLAGS = -g -DBSD4_3
X
XSRCS = io.c namei.c iname.c ls.c restore.c main.c stat.c idir.c
XOBJS = io.o namei.o iname.o ls.o restore.o main.o stat.o idir.o
X
Xall:    fssal fsls
X
Xfssal:    $(OBJS)
X    rm -f fsls
X    cc $(CFLAGS) $(OBJS) -o fssal
X
Xfsls:    fssal
X    ln fssal fsls
X
Xio.o: defs.h fs.h
X
Xnamei.o: defs.h fs.h
X
Xiname.o: defs.h fs.h
X
Xls.o: defs.h fs.h
X
Xrestore.o: defs.h fs.h
X
Xmain.o: defs.h fs.h
X
Xstat.o: defs.h fs.h
X
Xidir.o: defs.h fs.h
X
Xclean:
X    rm -f $(OBJS)
X
Xlint:
X    lint $(SRCS)
X
SHAR_EOF
chmod 0644 Makefile || echo "restore of Makefile fails"
sed 's/^X//' << 'SHAR_EOF' > defs.h &&
X
X#define FS_TO_READ    "/dev/dh60h"
X
X    /* Maximum size for path name */
X#define MAX_PATH_LEN    128
X
X    /* Number of inode numbers per sturct idir segment */
X#define MAX_ICNT    32
X
X#ifndef TRUE
X#define    TRUE    (1)
X#define FALSE    (0)
X#endif
X
SHAR_EOF
chmod 0644 defs.h || echo "restore of defs.h fails"
sed 's/^X//' << 'SHAR_EOF' > fs.h &&
X
X#include <stdio.h>
X#include <sys/types.h>
X#include <sys/file.h>
X#include <sys/param.h>
X#ifdef BSD4_2
X#include <sys/fs.h>
X#include <sys/inode.h>
X#endif
X#ifdef BSD4_3
X#include <sys/time.h>
X#include <sys/vnode.h>
X#include <ufs/fs.h>
X#include <ufs/inode.h>
X#endif
X#include <sys/dir.h>
X#include <sys/errno.h>
X
X#include "defs.h"
X
X/*
X *    itobo -    Convert inode number to file system byte offset (for lseek).
X *
X *        Converts inode to file system block (itod), then to device
X *        block (fsbtodb), multiplies by size of device block (DEV_BSIZE
X *        = 512), and adds offset into block of inode (itoo).
X */
X#define itobo(x) (fsbtodb(&sb, itod(&sb, x)) * DEV_BSIZE +    \
X          itoo(&sb,x) * sizeof(struct icommon))
X
X/*
X *    btobo - Convert file system block number to byte offset (for lseek).
X */
X#define btobo(x) (fsbtodb(&sb, x) * DEV_BSIZE)
X
X#define ISIZE    sizeof(struct icommon)
X
X
X/*
X *    struct file_ptr is the structure returned from a uopen() call.
X */
Xstruct file_ptr {
X    struct icommon    *ip;        /* Pointer to inode for file */
X    long        file_ptr;    /* # bytes into file */
X    long        file_size;    /* # bytes in file */
X};
X
X/*
X *    struct iname_list is a linked list of paths returned by iname() call.
X */
Xstruct iname_list {
X    char    name[MAX_PATH_LEN];
X    struct    iname_list *next_iname;
X};
X
X/*
X *    struct idir is a linked list of arrays of directory inode numbers.
X *    inums[] is the array containing icnt inode numbers.  next_idir
X *    points to the next list of numbers
X */
Xstruct idir {
X    ino_t    inums[MAX_ICNT];
X    int    icnt;
X    struct    idir *next_idir;
X};
X
SHAR_EOF
chmod 0644 fs.h || echo "restore of fs.h fails"
sed 's/^X//' << 'SHAR_EOF' > idir.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X#include <sys/stat.h>
X
X    /* File descriptor filesystem is open on */
Xextern int        fs_fd;
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* size of file system block (= 4096) */
X#define BLKSIZE sb.fs_bsize
X
X/*
X *    get_dir_inodes - stats inodes from from_inode to to_inode and, if
X *             a directory, adds to return_list.
X */
Xget_dir_inodes(return_list, from_inode, to_inode)
Xstruct    idir **return_list;
Xino_t    from_inode, to_inode;
X{
X    struct stat    statb;
X    struct idir    *idir_list, *cur_ilist;
X
X    ino_t    i;
X
X    new_idir(&idir_list);
X    cur_ilist = idir_list;
X
X    for (i = from_inode; i < to_inode; i++) {
X        if (fs_stat (i, &statb)) {
X            printf ("error reading inode %d\n");
X            break;
X        }
X        if ((statb.st_mode & S_IFMT) == S_IFDIR) {
X                /* Add inode number to list */
X            add_dir_inode(&cur_ilist, i);
X            printf ("found directory at %d\n", i);
X        }
X    }
X    *return_list = idir_list;
X}
X
X/*
X *    new_idir - makes new idir segment and returns pointer new_ptr
X */
Xnew_idir(new_ptr)
Xstruct    idir **new_ptr;
X{
X    char *malloc();
X
X    *new_ptr = (struct idir *) malloc(sizeof(struct idir));
X    (*new_ptr)->icnt = 0;
X    (*new_ptr)->next_idir = NULL;
X}
X
X/*
X *    add_dir_inode - adds inode number to struct idir, mallocing a new
X *            one if needed.
X */
Xadd_dir_inode(idir_ptr, inum)
Xstruct    idir **idir_ptr;
Xino_t    inum;
X{
X    if ((*idir_ptr)->icnt == MAX_ICNT) {
X            /* Current list full, add new segment */
X        new_idir(&((*idir_ptr)->next_idir));
X        *idir_ptr = (*idir_ptr)->next_idir;
X    }
X    (*idir_ptr)->inums[(*idir_ptr)->icnt++] = inum;
X}
X
X/*
X *    in_idir - returns TRUE if inum is found in idir_ptr
X */
Xin_idir(idir_ptr, inum)
Xstruct    idir *idir_ptr;
Xino_t    inum;
X{
X    struct    idir *itmp_ptr;
X
X    ino_t    itmp;
X
X    itmp_ptr = idir_ptr;
X    while (itmp_ptr) {
X        for (itmp = 0; itmp < itmp_ptr->icnt; itmp++)
X            if (itmp_ptr->inums[itmp] == inum)
X                return TRUE;
X        itmp_ptr = itmp_ptr->next_idir;
X    }
X    return FALSE;
X}
X
SHAR_EOF
chmod 0644 idir.c || echo "restore of idir.c fails"
sed 's/^X//' << 'SHAR_EOF' > iname.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X#include <sys/time.h>
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* File system block size */
X#define BLKSIZE sb.fs_bsize
X
X/*
X *    iname - generate list of file names based on given inode number.
X *        Given inode inum and maximum count icnt, returns linked list
X *        inames of path names and actual number found found_cnt.
X *        ipath is path name to inode istart, which is prepended to each
X *        iname.
X *
X *        Used for determining links to regular files.
X */
Xiname(ipath, istart, inum, icnt, inames, found_cnt)
Xchar    ipath[MAX_PATH_LEN];
Xino_t    istart, inum;
Xint    icnt, *found_cnt;
Xstruct    iname_list **inames;
X{
X    *inames = NULL;
X    *found_cnt = 0;
X    if (ilist(ipath, istart, inum, icnt, inames, found_cnt))
X        fprintf(stderr, "Inode %d is not a directory\n", inum);
X}
X
Xilist(ipath, istart, inum, icnt, inames, found_cnt)
Xchar    ipath[MAX_PATH_LEN];
Xino_t    istart, inum;
Xint    icnt, *found_cnt;
Xstruct    iname_list **inames;
X{
X    struct icommon    fs_inode;        /* Inode for directory */
X    struct direct    *fs_dir;        /* Directory structure */
X    struct file_ptr    dir_ptr;        /* Directory pointer */
X
X    char        dir_buf[MAXBSIZE];    /* Directory buffer */
X    int        buf_cnt;        /* # chars in buffer */
X    int        next_ent;        /* Buf offset of next dir */
X
X    char        cur_name[MAX_PATH_LEN];    /* Current directory pathname */
X
X    struct icommon    file_inode;        /* Inode for ls file */
X
X    static struct iname_list *cur_iname, *tmp_iname;
X
X    char        *strcpy(), *sprintf(), *strcat();
X    char        *malloc();
X
X    extern int    errno;
X
X
X        /* Fetch inode */
X    get_inode(istart, &fs_inode);
X
X        /* Make sure it's a directory! */
X    if ((fs_inode.ic_mode & IFMT) != IFDIR) {
X        errno = ENOTDIR;
X        return -1;
X    }
X        /* Open directory */
X    uopen(&fs_inode, &dir_ptr);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each file in directory, check inode # */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if (fs_dir->d_ino != 0) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X                /* Desired inode #? */
X            if (fs_dir->d_ino == inum) {
X                    /* Yep - Malloc new iname_list */
X                tmp_iname = cur_iname;
X                cur_iname = (struct iname_list *)
X                    malloc(sizeof(struct iname_list));
X                cur_iname->next_iname = NULL;
X                if (tmp_iname)
X                    tmp_iname->next_iname = cur_iname;
X                if (*inames == NULL)
X                    *inames = cur_iname;
X
X                    /* Copy starting path */
X                (void) strcpy(cur_iname->name, ipath);
X                (void) strcat(cur_iname->name, "/");
X                    /* Append actual file name */
X                (void) strcat(cur_iname->name, fs_dir->d_name);
X                ++*found_cnt;
X            }
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X
X        /* Open directory again */
X    uopen(&fs_inode, &dir_ptr);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each subdirectory in directory, check it */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if (fs_dir->d_ino != 0) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X                /* Make sure is dir and not . or .. */
X            if ((file_inode.ic_mode & IFMT) == IFDIR)
X                if (strcmp(fs_dir->d_name, ".") &&
X                strcmp(fs_dir->d_name, "..")) {
X                    if (*ipath)
X                    (void) sprintf(cur_name, "%s/%s",
X                        ipath, fs_dir->d_name);
X                    else
X                    (void) strcpy(cur_name, fs_dir->d_name);
X
X                    /* Check this directory! */
X                if (ilist(cur_name, fs_dir->d_ino, inum,
X                    icnt - *found_cnt, inames, found_cnt)) {
X                    fprintf(stderr,
X                    "Inode %d is not a directory\n", inum);
X                    return -1;
X                }
X                }
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X    return 0;
X}
SHAR_EOF
chmod 0644 iname.c || echo "restore of iname.c fails"
sed 's/^X//' << 'SHAR_EOF' > io.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X
X
X    /* File descriptor filesystem is open on */
Xextern int    fs_fd;
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* size of file system block */
X#define BLKSIZE sb.fs_bsize
X
X/*
X *    getsb - read super block into struct sb
X */
Xgetsb(fs_to_read, sb_block)
Xchar    *fs_to_read;
Xint    sb_block;
X{
X    long    lseek();
X
X        /* Open file system */
X    if ((fs_fd = open(fs_to_read, O_RDONLY)) == -1) {
X        perror("Cannot open filesystem");
X        exit(1);
X    }
X
X        /* Seek to super block */
X/*
X    (void) lseek(fs_fd, (long) BBSIZE, L_SET);
X*/
X    (void) lseek(fs_fd, (long) 512 * sb_block, L_SET);
X
X        /* Read super block */
X    if (read(fs_fd, (char *) &sb, sizeof(sb)) == -1) {
X        perror("Cannot read filesystem");
X        exit(1);
X    }
X
X        /* Check magic number */
X    if (sb.fs_magic != FS_MAGIC) {
X        fprintf(stderr, "Bad magic number for super block\n");
X        exit(1);
X    }
X
X}
X
X/*
X *    uopen - open file on unmounted file system.
X *
X *        Input is a pointer to the icommon for the file to open,
X *        and a pointer (struct file_ptr) to the info to be
X *        returned.  (Includes pointer to inode, index into file,
X *        and size of file).
X */
Xuopen(ip, fp)
Xstruct icommon    *ip;
Xstruct file_ptr    *fp;
X{
X    fp->ip = ip;
X    fp->file_ptr = 0;
X    fp->file_size = fp->ip->ic_size.val[0];
X}
X
X/*
X *    uread - read data from uopened file.
X *
X *        Input is pointer to struct file_ptr returned from uopen,
X *        pointer to buffer to place data in, and count of number
X *        of bytes to read.
X *
X *        Note - Doesn't handle double-indirect blocks!
X *            (Gawd, I'm lazy!)
X *
X *        Returns:
X *            -1 if no data was read,
X *            count if all data was transferred,
X *            else actual number of bytes transferred.
X */
Xuread(fp, bp, count)
Xstruct file_ptr    *fp;
Xchar        *bp;
Xlong        count;
X{
X    /* # indirect pointers in an indirect block */
X#define    NUM_IND_PTRS    (BLKSIZE / sizeof(long))
X    /* # bytes pointed to by an indirect block */
X#define    IND_CNT        (NUM_IND_PTRS * BLKSIZE)
X
X    long    direct_blk;        /* Index into direct block numbers */
X    long    ind_ptr;        /* Which byte in indirect block */
X    int    ind_blk;        /* Which indirect pointer of NIADDR */
X    int    ind_off;        /* Which indirect pointer in block */
Xstatic    char    ind_buf[MAXBSIZE];    /* Indirect block */
Xstatic    int    last_ind_blk;        /* Last indirect block read */
X
X    int    num_to_read;        /* # bytes of block to read */
X    int    offset;            /* Offset into block to start read */
X    int    nr;            /* # bytes actually read */
X    long    file_cnt;        /* # bytes left in file */
X    long    num_read;        /* # bytes read so far */
X    long    block_to_read;        /* Block # for read */
X
X    char    *bufptr;        /* Next byte in buffer to read into */
X
X    long    lseek();
X
X    bufptr = bp;
X    num_read = 0;
X
X        /* # bytes left in file */
X    file_cnt = fp->file_size - fp->file_ptr;
X
X        /* Limit count to size of file */
X    if (count > file_cnt)
X        count = file_cnt;
X
X    while (count != 0) {
X
X            /* Get direct block # */
X        direct_blk = fp->file_ptr / BLKSIZE;
X
X            /* Into indirect blocks? */
X        if (direct_blk >= NDADDR) {
X            ind_ptr = fp->file_ptr - NDADDR * BLKSIZE;
X
X                /* Into double-indirect blocks? */
X            if ((ind_blk = ind_ptr / IND_CNT) >= NIADDR) {
X                fprintf(stderr, "File too large\n");
X                exit(1);
X            }
X
X            ind_off = ind_ptr / BLKSIZE;
X
X            if (last_ind_blk != fp->ip->ic_ib[ind_blk]) {
X                    /* Read indirect block */
X#ifdef DEBUG
X                printf("Reading indirect block %d\n",
X                            last_ind_blk);
X#endif
X                last_ind_blk = fp->ip->ic_ib[ind_blk];
X                (void) lseek(fs_fd, btobo(last_ind_blk), L_SET);
X                if (read(fs_fd, ind_buf, (int) BLKSIZE) == -1) {
X                    perror("Cannot read indirect block");
X                    exit(1);
X                }
X            }
X
X            block_to_read = * ((long *) &ind_buf[ind_off *
X                                sizeof(long)]);
X        } else
X            block_to_read = fp->ip->ic_db[direct_blk];
X
X            /* Offset into block to start read */
X        offset = fp->file_ptr % BLKSIZE;
X
X            /* # bytes in block to read */
X        num_to_read = ((BLKSIZE - offset) < count) ?
X                (BLKSIZE - offset) : count;
X
X            /* Check for pointer to empty block */
X        if (block_to_read == 0) {
X            for (nr = 0; nr < num_to_read; nr++)
X                bufptr[nr] = '\0';
X        } else {
X
X#ifdef DEBUG
X            printf("Reading block %d\n", block_to_read);
X#endif
X                /* Seek to block */
X            (void) lseek(fs_fd, btobo(block_to_read), L_SET);
X
X                /* Read them */
X            if ((nr = read(fs_fd, bufptr, num_to_read)) == -1)
X                    /* Return error if nothing read,
X                     * else # bytes actually read    */
X                return (num_read == 0) ? -1 : num_read;
X        }
X
X        count -= nr;
X        file_cnt -= nr;
X        fp->file_ptr += nr;
X        num_read += nr;
X        bufptr += nr;        /* Point to next part of buffer */
X
X            /* Read short */
X        if (nr < num_to_read)
X            return num_read;
X    }
X    return num_read;
X}
X
SHAR_EOF
chmod 0644 io.c || echo "restore of io.c fails"
sed 's/^X//' << 'SHAR_EOF' > ls.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X#include <sys/time.h>
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* File system block size */
X#define BLKSIZE sb.fs_bsize
X
X/*
X *    ls -    Do a directory listing of given inode.  Do a 'ls -l'
X *        if Lflag is set;  do a 'ls -R' if Rflag is set.
X *        dir_name is name of passed directory.  idir_list is
X *        updated with inode number of each listed directory.
X */
Xls(ls_inode, dir_name, idir_list, Lflag, Rflag)
Xino_t    ls_inode;
Xchar    *dir_name;
Xstruct    idir **idir_list;
Xchar    Lflag, Rflag;
X{
X    struct icommon    fs_inode;    /* Inode for directory */
X    struct direct    *fs_dir;    /* Directory structure */
X    struct file_ptr    dir_ptr;    /* Directory pointer */
X
X    struct icommon    sym_inode;    /* Inode for symbolic link */
X    struct file_ptr    sym_ptr;    /* Symbolic link pointer */
X    long        sym_size;    /* Length of symbolic name */
X    char        sym_buf[MAX_PATH_LEN];    /* Buffer for symbolic name */
X
X    char        dir_buf[MAXBSIZE];    /* Directory buffer */
X    int        buf_cnt;    /* # chars in buffer */
X    int        next_ent;    /* Offset into buf of next direct */
X
X    int        mode;        /* File mode */
X    char        modes[11];    /* File mode string */
X    struct icommon    file_inode;    /* Inode for ls file */
X    int        i;
X    char        *create_time;    /* Creation date string */
X    char        cur_name[1024];    /* Current directory pathname */
X
X    char        *ctime();
X    char        *strcpy();
X    char        *sprintf();
X
X    extern int    errno;
X
X        /* Fetch inode */
X    get_inode(ls_inode, &fs_inode);
X
X        /* Make sure it's a directory! */
X    if ((fs_inode.ic_mode & IFMT) != IFDIR) {
X        errno = ENOTDIR;
X        return -1;
X    }
X
X        /* Add directory inode number to list */
X    add_dir_inode(idir_list, ls_inode);
X
X        /* Open directory */
X    uopen(&fs_inode, &dir_ptr);
X
X    if (Rflag && *dir_name)
X        printf("%s:\n", dir_name);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each file in directory, list it */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if (fs_dir->d_ino != 0) {
X            if (Lflag) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X            printf("%5d ", fs_dir->d_ino);        /* Inode # */
X            (void) strcpy(modes, "-rwxrwxrwx");
X            mode = file_inode.ic_mode;
X            for (i = 8; i >= 0; i--)
X                if ((mode & (1 << i)) == 0)
X                    modes[9 - i] = '-';    /* rwx bits */
X            if ((mode & IFMT) == IFDIR)
X                      modes[0] = 'd';    /* directory */
X            if ((mode & IFMT) == IFLNK)
X                      modes[0] = 'l';    /* sym link */
X
X            if (mode & ISUID) modes[3] = 's';    /* setuid */
X            if (mode & ISGID) modes[6] = 's';    /* setgid */
X            if (mode & ISVTX) modes[9] = 't';    /* sticky */
X            printf("%s %3d %3d/%-3d %8ld",
X                modes,                /* modes */
X                file_inode.ic_nlink,        /* link cnt */
X                file_inode.ic_uid,        /* uid */
X                file_inode.ic_gid,        /* gid */
X                file_inode.ic_size.val[0]);    /* size */
X            create_time = ctime((long *) &file_inode.ic_ctime);
X            printf(" %-12.12s %-4.4s ", create_time + 4,
X                            create_time + 20);
X                printf("%s", fs_dir->d_name);        /* file name */
X
X                /* Symbolic link? */
X            if ((mode & IFMT) == IFLNK) {
X                    /* Yup - print name of link */
X                get_inode(fs_dir->d_ino, &sym_inode);
X                sym_size = sym_inode.ic_size.val[0];
X                if (sym_size >= sizeof(sym_buf))
X                    printf(" -> ?name too big");
X                else {
X                    uopen(&sym_inode, &sym_ptr);
X                    if (uread(&sym_ptr, sym_buf, sym_size)
X                            != sym_size) {
X                        perror("Cannot read symlink");
X                        exit(1);
X                    }
X                    sym_buf[sym_size] = '\0';
X                    printf(" -> %s", sym_buf);
X                }
X            }
X            printf("\n");
X
X            } else
X                printf("%s\n", fs_dir->d_name);        /* file name */
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X
X    printf("\n");
X
X    /* Recursive (ls -R)? */
X    if (Rflag) {
X        /* Open directory again */
X    uopen(&fs_inode, &dir_ptr);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each directory in directory, list it */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if (fs_dir->d_ino != 0) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X                /* Make sure is dir and not . or .. */
X            if ((file_inode.ic_mode & IFMT) == IFDIR)
X                if (strcmp(fs_dir->d_name, ".") &&
X                strcmp(fs_dir->d_name, ".."))
X
X                /* Make sure not already listed */
X                if (in_idir(*idir_list, fs_dir->d_ino))
X                fprintf(stderr, "Already ls'd inum %d, directory: %s !\n", fs_dir->d_ino, cur_name);
X                else {
X                    if (*dir_name)
X                    (void) sprintf(cur_name, "%s/%s",
X                        dir_name, fs_dir->d_name);
X                    else
X                    (void) strcpy(cur_name, fs_dir->d_name);
X
X                    /* List this directory! */
X                    if (ls(fs_dir->d_ino, cur_name, idir_list,
X                    Lflag, Rflag))
X                        return -1;
X                }
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X    }
X    return 0;
X}
X
X
Xls_all(Rflag, verbose)
Xchar    Rflag, verbose;
X{
X    struct    idir *idir_list, *ls_list, *idir_ptr, *ls_ptr;
X
X    ino_t    inum;
X    int    icnt = 0;
X    char    iname[MAX_PATH_LEN];
X
X        /* Get list of directory inodes for filesystem */
X    get_dir_inodes(&idir_list, (ino_t) 2, (ino_t) sb.fs_ncg * sb.fs_ipg);
X
X        /* Make list of ls'd directory inodes */
X    new_idir(&ls_list);
X    idir_ptr = idir_list;
X    while (idir_ptr) {
X        inum = idir_ptr->inums[icnt];
X            /* Inode been ls'd? */
X        if (!in_idir(ls_list, inum)) {
X
X                /* Point to end of ls'd inode list */
X            ls_ptr = ls_list;
X            while(ls_ptr->next_idir)
X                ls_ptr = ls_ptr->next_idir;
X
X                /* Append to end of ls'd inode list */
X            if (ls(inum, iname, &ls_ptr, Rflag, verbose))
X                return -1;
X        }
X        if (++icnt == idir_ptr->icnt) {
X            icnt = 0;
X            idir_ptr = idir_ptr->next_idir;
X        }
X    }
X    return 0;
X}
SHAR_EOF
chmod 0644 ls.c || echo "restore of ls.c fails"
sed 's/^X//' << 'SHAR_EOF' > main.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X#include <sys/stat.h>
X
X    /* File descriptor filesystem is open on */
Xint        fs_fd;
X
X    /* struct holding super block */
Xstruct fs    sb;
X
X    /* Current root inode */
Xino_t    root_inode = ROOTINO;
X
Xchar    *fs_to_read = FS_TO_READ;
Xint    sb_block = BBSIZE / 512;
X
Xusage(fs_name)
Xchar    *fs_name;
X{
X    fprintf (stderr,
X"usage: %s [-f device] [-s super-block] [-r root-inode] [-a] [-l] [-R] [-v]\n",
X    fs_name);
X    exit(1);
X}
X
Xmain(argc, argv)
Xint    argc;
Xchar    *argv[];
X{
X    char    do_all, verbose, recurse, long_ls = FALSE;
X    char    *fs_name = argv[0];
X    struct    stat statb;
X    struct    idir *idir_list;
X
X    for (fs_name = argv[0] + strlen(argv[0]);
X        (fs_name != argv[0]) && (*(fs_name - 1) != '/'); fs_name--) ;
X
X    while (*++argv) {
X        if (**argv == '-') {
X            switch (*++*argv) {
X            case 'f':
X                fs_to_read = *++argv;
X                break;
X            case 's':
X                sb_block = atoi (*++argv);
X                break;
X            case 'r':
X                root_inode = atoi (*++argv);
X                break;
X            case 'a':
X                do_all = TRUE;
X                break;
X            case 'v':
X                verbose = TRUE;
X                break;
X            case 'R':
X                recurse = TRUE;
X                break;
X            case 'l':
X                long_ls = TRUE;
X                break;
X
X            default:
X                usage(fs_name);
X            }
X        }
X    }
X
X        /* Stat file and see if it's a block special device */
X    if (stat(fs_to_read, &statb)) {
X        perror("Cannot stat file");
X        exit(1);
X    } else
X        if ((statb.st_mode & S_IFMT) != S_IFBLK) {
X            fprintf(stderr, "%s not a block special device\n",
X                fs_to_read);
X        exit(1);
X    }
X
X        /* Read in superblock */
X    getsb(fs_to_read, sb_block);
X
X    new_idir(&idir_list);
X
X    if (!strcmp(fs_name, "fssal"))
X        if (do_all)
X            exit( restore_all(recurse, verbose) );
X        else
X            exit( restore(".", root_inode, ".",
X                    &idir_list, recurse, verbose) );
X
X    if (!strcmp(fs_name, "fsls"))
X        if (do_all)
X            exit( ls_all(long_ls, recurse) );
X        else
X            exit( ls(root_inode, "", &idir_list, long_ls, recurse));
X
X    usage(fs_name);
X
X    (void) close(fs_fd);
X    exit(0);
X}
SHAR_EOF
chmod 0644 main.c || echo "restore of main.c fails"
sed 's/^X//' << 'SHAR_EOF' > namei.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X
X
X    /* File descriptor filesystem is open on */
Xextern int    fs_fd;
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* File system block size */
X#define BLKSIZE sb.fs_bsize
X
X/*
X *    get_inode - read inode inum into struct rd_inode
X */
Xget_inode(inum, rd_inode)
Xino_t        inum;
Xstruct icommon    *rd_inode;
X{
X    long    lseek();
X
X        /* Seek to desired inode */
X    (void) lseek(fs_fd, (long) itobo(inum), L_SET);
X
X        /* Read that inode */
X    if (read(fs_fd, (char *) rd_inode, ISIZE) == -1) {
X        perror("Cannot read file system");
X        exit(1);
X    }
X}
X
X/*
X *    namei -    Convert filename to inode number.
X *
X *        First get root inode for file system.
X *        From there, search each directory in path for next
X *        component of path name, till final filename found.
X *
X *        Returns:
X *            0 if file not found (ENOENT),
X *            0 if file in path was not a directory (ENOTDIR),
X *            else inode of file filename.
X */
Xnamei(filename)
Xchar    *filename;
X{
X    char    tmp_name[1024];        /* Copy of filename */
X    ino_t    cur_ino;        /* Current inode in path */
X    char     *curnam;        /* Points to next char in filename */
X    char    *next_name;        /* Next name to scan */
X    int    next_slash;
X
X    struct icommon    fs_inode;    /* Inode for file/directory */
X    struct direct    *fs_dir;    /* Directory structure */
X    struct file_ptr    dir_ptr;    /* Directory pointer */
X
X    char    dir_buf[MAXBSIZE];    /* Directory buffer */
X    int        buf_cnt;    /* # chars in buffer */
X
X    int        next_ent;    /* Offset into buf of next direct */
X
X    char        *strcpy();
X
X    extern int    errno;
X
X        /* Save copy of path name */
X    (void) strcpy(tmp_name, filename);
X    curnam = tmp_name;
X
X        /* Start at root inode */
X    cur_ino = ROOTINO;
X
X        /* Search till nothing left of path name */
X    while ((*curnam != '\0') && (cur_ino != 0)) {
X
X#ifdef DEBUG
X        printf("Reading inode %d\n", cur_ino);
X#endif
X            /* Get current inode */
X        get_inode(cur_ino, &fs_inode);
X
X            /* Make sure it's a directory! */
X        if ((fs_inode.ic_mode & IFMT) != IFDIR) {
X            errno = ENOTDIR;
X            return 0;
X        }
X
X            /* Skip /'s in next component of name */
X        while (*curnam == '/') curnam++;
X
X            /* Get next component of path in next_name */
X        for (next_slash = 0;
X            (curnam[next_slash] != '\0') && (curnam[next_slash] != '/');
X             next_slash ++) ;
X
X        next_name = curnam;
X        curnam += next_slash;
X        if (*curnam == '/') curnam++;
X        next_name[next_slash] = '\0';
X
X#ifdef DEBUG
X        printf("Scanning directory for file '%s'.\n", next_name);
X#endif
X
X            /* Open directory */
X        uopen(&fs_inode, &dir_ptr);
X
X            /*
X             * Search each directory block for name.
X             * Return inode number in cur_ino when found.
X             */
X        cur_ino = 0;
X        do {
X
X                /* Read next block of directory */
X            if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE))
X                                == -1) {
X                perror("Cannot read directory");
X                exit(1);
X            }
X
X            if (buf_cnt == 0)
X                break;
X
X                /* Scan directory block for desired name */
X            next_ent = 0;
X            do {
X                    /* Point to next directory entry */
X                fs_dir = (struct direct *)
X                         &dir_buf[next_ent];
X
X                    /* Directory entry here? */
X                if (fs_dir->d_ino != 0) {
X#ifdef DEBUG
X                    printf("Inode: %6d file: %s\n",
X                        fs_dir->d_ino, fs_dir->d_name);
X#endif
X
X                        /* Names match? */
X                    if (!strcmp(next_name, fs_dir->d_name))
X                            /* Yes- save inode */
X                        cur_ino = fs_dir->d_ino;
X                }
X                next_ent += fs_dir->d_reclen;
X            } while ((cur_ino == 0) &&
X                 (next_ent < buf_cnt));
X
X        } while ((cur_ino == 0) && (buf_cnt > 0));
X    }
X
X    if (cur_ino == 0) {
X        errno = ENOENT;
X        return 0;        /* File not found - return 0 */
X    } else
X        return cur_ino;        /* Found - return inode number */
X}
X
SHAR_EOF
chmod 0644 namei.c || echo "restore of namei.c fails"
sed 's/^X//' << 'SHAR_EOF' > restore.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X#include "fs.h"
X#include <sys/stat.h>
X#include <sys/time.h>
X
X    /* struct holding super block */
Xextern struct fs    sb;
X
X    /* Current root inode */
Xextern ino_t    root_inode;
X
X    /* File system block size */
X#define BLKSIZE sb.fs_bsize
X
Xchar *base_path;    /* Initial restore path */
Xino_t   base_inode;    /* Initial restore inode # */
X
X/*
X *    restore - Restore files from given directory.
X *          from_path is path name to from_inode, which is
X *          directory to be restored.  Files are restored to
X *          to_path.  If Rflag is set, restore is recursive
X *          ( cp -R ).  idir_list is updated with inode number of
X *          each directory restored.
X */
Xrestore(from_path, from_inode, to_path, idir_list, Rflag, verbose)
Xino_t    from_inode;
Xchar    *from_path, *to_path;
Xstruct    idir **idir_list;
Xchar    Rflag, verbose;
X{
X        /* Save initial restore path and inode # */
X    base_path = to_path;
X    base_inode = from_inode;
X    return
X        rrestore(from_path, from_inode, to_path, idir_list, Rflag, verbose);
X}
X
Xrrestore(from_path, from_inode, to_path, idir_list, Rflag, verbose)
Xino_t    from_inode;
Xchar    *from_path, *to_path;
Xstruct    idir **idir_list;
Xchar    Rflag, verbose;
X{
X    struct icommon    fs_inode;    /* Inode for directory */
X    struct direct    *fs_dir;    /* Directory structure */
X    struct file_ptr    dir_ptr;    /* Directory pointer */
X
X    struct icommon    sym_inode;    /* Inode for symbolic link */
X    struct file_ptr    sym_ptr;    /* Symbolic link pointer */
X    long        sym_size;    /* Length of symbolic name */
X    char        sym_buf[MAX_PATH_LEN];    /* Buffer for symbolic name */
X
X    char        dir_buf[MAXBSIZE];    /* Directory buffer */
X    int        buf_cnt;    /* # chars in buffer */
X    int        next_ent;    /* Offset into buf of next direct */
X
X    int        mode;        /* File mode */
X    struct icommon    file_inode;    /* Inode for ls file */
X    char        in_path[MAX_PATH_LEN];    /* Current input file name */
X    char        out_path[MAX_PATH_LEN];    /* Current output file name */
X
X    char        set_times;    /* TRUE to set creation time */
X    struct timeval    file_times[2];
X
X    struct iname_list *link_list;    /* List of files with common inode */
X    struct iname_list *temp_link;
X    int        links_found;
X    struct stat    file_stat;    /* File status (for inode # to link) */
X    int        out_file;    /* Output file descriptor */
X
X    char        copy_file;    /* TRUE to copy (not link) file */
X    struct file_ptr    in_ptr;        /* File pointer for input file */
X    int        nr;
X    char        buf[8192];
X
X    char        *ctime();
X    char        *strcpy(), *strcat();
X
X    extern int    errno;
X
X    (void) umask(0);        /* Create any mode file */
X
X        /* Fetch inode */
X    get_inode(from_inode, &fs_inode);
X
X        /* Make sure it's a directory! */
X    if ((fs_inode.ic_mode & IFMT) != IFDIR) {
X        errno = ENOTDIR;
X        return -1;
X    }
X
X        /* Add directory inode number to list */
X    add_dir_inode(idir_list, from_inode);
X
X        /* Open directory */
X    uopen(&fs_inode, &dir_ptr);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each file in directory, restore it */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if ((fs_dir->d_ino != 0) && strcmp(fs_dir->d_name, ".")
X                     && strcmp(fs_dir->d_name, "..")) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X            (void) strcpy(in_path, from_path);
X            (void) strcat(in_path, "/");
X            (void) strcat(in_path, fs_dir->d_name);
X            (void) strcpy(out_path, to_path);
X            (void) strcat(out_path, "/");
X            (void) strcat(out_path, fs_dir->d_name);
X
X                /* Set up access and mod times */
X            set_times = TRUE;
X            file_times[0].tv_sec = file_inode.ic_atime;
X            file_times[0].tv_usec = file_times[1].tv_usec = 0;
X            file_times[1].tv_sec = file_inode.ic_mtime;
X
X            mode = file_inode.ic_mode;
X
X            switch (mode & IFMT) {
X
X            case 0020000:        /* character special */
X            case 0060000:        /* block special */
X            case 0140000:        /* socket - will it work? */
X                if (verbose)
X                    printf("Creating special file: %s\n",
X                        out_path);
X                if (mknod(out_path, mode,
X                    (int) file_inode.ic_db[0]))
X                {
X                    fprintf(stderr,
X                        "Cannot create special file: %s; ",
X                        out_path);
X                    perror("");
X                    set_times = FALSE;
X                }
X                break;
X
X            case 0040000:        /* directory */
X                if (verbose)
X                    printf("Creating directory: %s\n",
X                        out_path);
X                if (mkdir(out_path, mode)) {
X                    fprintf(stderr,
X                        "Cannot create directory: %s; ",
X                        out_path);
X                    perror("");
X                    set_times = FALSE;
X                }
X                break;
X
X            case 0100000:        /* regular file */
X                copy_file = (file_inode.ic_nlink == 1);
X                if (!copy_file) {
X                        /* Oh shit; it's a link */
X                        /* Get filenames with inode # */
X                    iname(base_path, base_inode,
X                        fs_dir->d_ino, file_inode.ic_nlink,
X                        &link_list, &links_found);
X
X                        /* Search for existing file */
X                        /* to link to */
X                    for (temp_link = link_list;
X                         temp_link;
X                         temp_link = temp_link->next_iname)
X                    {
X                        if (stat(temp_link->name,
X                            &file_stat)) {
X                            if (errno != ENOENT) {
X                            fprintf(stderr,
X                                "Cannot stat %s: ",
X                                temp_link->name);
X                            perror("");
X                            }
X                        } else
X                        if (mode != file_stat.st_mode) {
X                        fprintf(stderr,
X                            "Mode mismatch on %s\n",
X                            temp_link->name);
X                        } else
X                        break;
X                    }
X
X                    if (temp_link) {
X                        /* Found file to link to */
X                        if (verbose)
X                        printf("Linking %s to %s\n",
X                            temp_link->name, out_path);
X                        if (link(temp_link->name, out_path))
X                        {
X                        fprintf(stderr,
X                            "Cannot link %s to %s: ",
X                            temp_link->name, out_path);
X                        perror("");
X                        copy_file = TRUE;
X                        } else
X                        set_times = FALSE;
X                    } else
X                        copy_file = TRUE;
X                }
X
X                if (copy_file) {
X                        /* Copy file */
X                    if (verbose)
X                        printf("Copying %s to %s\n",
X                            in_path, out_path);
X                    uopen(&file_inode, &in_ptr);
X                    if ((out_file = open(out_path,
X                                O_CREAT | O_WRONLY,
X                                mode)) == -1) {
X                        fprintf(stderr,
X                            "Cannot create %s: ",
X                            out_path);
X                        perror("");
X                        break;
X                    }
X
X                        /* Copy file */
X                    do {
X                        if ((nr = uread(&in_ptr, buf,
X                                BLKSIZE)) == -1) {
X                            fprintf(stderr,
X                                "Cannot read %s: ",
X                                in_path);
X                            perror("");
X                        }
X
X                        if (nr > 0)
X                            if (write(out_file, buf, nr)
X                                == -1) {
X                            fprintf(stderr,
X                                "Cannot write %s: ",
X                                out_path);
X                            perror("");
X                        }
X                    } while (nr > 0);
X
X                    (void) close(out_file);
X                }
X                break;
X
X            case 0120000:            /* symbolic link */
X                    /* Can't utime symlink */
X                set_times = FALSE;
X                    /* Get name of link */
X                get_inode(fs_dir->d_ino, &sym_inode);
X                sym_size = sym_inode.ic_size.val[0];
X                if (sym_size >= sizeof(sym_buf)) {
X                    fprintf(stderr,
X                        "Symbolic link to %s too long\n",
X                        out_path);
X                    set_times = FALSE;
X                } else {
X                    uopen(&sym_inode, &sym_ptr);
X                    if (uread(&sym_ptr, sym_buf, sym_size)
X                            != sym_size) {
X                        perror("Cannot read symlink");
X                        set_times = FALSE;
X                    }
X                    sym_buf[sym_size] = '\0';
X
X                    if (verbose)
X                        printf("Creating symbolic link %s -> %s\n",
X                            sym_buf, out_path);
X                    if (symlink(sym_buf, out_path)) {
X                        fprintf(stderr,
X                            "Cannot create symbolic link %s -> %s: ",
X                            out_path, sym_buf);
X                        perror("");
X#ifdef UTEK
X                        if (errno != EDFSNOSUCHHOST)
X                            set_times = FALSE;
X#endif
X                    }
X                }
X                break;
X
X            default:
X                fprintf(stderr, "Unknown mode %o on file %s\n",
X                    mode, in_path);
X                set_times = FALSE;
X            }
X
X            if (set_times) {
X                    /* Set creation times on file */
X                if (utimes(out_path, file_times)) {
X                    fprintf(stderr,
X                        "Cannot set creation times on %s: ",
X                        out_path);
X                    perror("");
X                }
X                    /* Set owner and group */
X                if (chown(out_path, file_inode.ic_uid,
X                            file_inode.ic_gid)) {
X                    fprintf(stderr,
X                        "Cannot set owner on %s: ",
X                        out_path);
X                    perror("");
X                }
X            }
X
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X
X    /* Recursive (cp -R)? */
X    if (Rflag) {
X        /* Open directory again */
X    uopen(&fs_inode, &dir_ptr);
X
X        /* Read each directory block */
X    do {
X            /* Read next block of directory */
X        if ((buf_cnt = uread(&dir_ptr, dir_buf, BLKSIZE)) == -1) {
X            perror("Cannot read directory");
X            exit(1);
X        }
X
X        if (buf_cnt == 0)
X        break;
X
X            /* For each sub-directory in directory, restore it */
X        next_ent = 0;
X        do {
X            /* Point to next directory entry */
X        fs_dir = (struct direct *) &dir_buf[next_ent];
X
X            /* Directory entry here? */
X        if (fs_dir->d_ino != 0) {
X                /* Get inode */
X            get_inode(fs_dir->d_ino, &file_inode);
X
X
X                /* Make sure is dir and not . or .. */
X            if ((file_inode.ic_mode & IFMT) == IFDIR)
X                    if (strcmp(fs_dir->d_name, ".") &&
X                    strcmp(fs_dir->d_name, "..")) {
X
X                /* Make sure not restored yet */
X                if (in_idir(*idir_list, fs_dir->d_ino)) {
X                fprintf(stderr,
X                  "Already restored inum %d, directory: %s !\n",
X                    fs_dir->d_ino, from_path);
X                } else {
X                (void) strcpy(in_path, from_path);
X                (void) strcat(in_path, "/");
X                (void) strcat(in_path, fs_dir->d_name);
X                (void) strcpy(out_path, to_path);
X                (void) strcat(out_path, "/");
X                (void) strcat(out_path, fs_dir->d_name);
X
X                file_times[0].tv_sec = file_inode.ic_atime;
X                file_times[0].tv_usec = file_times[1].tv_usec
X                                    = 0;
X                file_times[1].tv_sec = file_inode.ic_mtime;
X
X                    /* Restore this directory! */
X                if (rrestore(in_path, fs_dir->d_ino, out_path,
X                        idir_list, Rflag, verbose))
X                    return -1;
X
X                    /* Set creation times on directory */
X                if (utimes(out_path, file_times)) {
X                    fprintf(stderr,
X                        "Cannot set creation times on %s: ",
X                        out_path);
X                    perror("");
X                }
X                }
X            }
X        }
X        next_ent += fs_dir->d_reclen;
X        } while (next_ent < buf_cnt);
X
X    } while (buf_cnt > 0);
X    }
X    return 0;
X}
X
Xrestore_all(Rflag, verbose)
Xchar    Rflag, verbose;
X{
X    struct    idir *idir_list, *restore_list, *idir_ptr, *restore_ptr;
X
X    ino_t    inum;
X    int    icnt = 0;
X    char    iname[MAX_PATH_LEN];
X
X    char     *sprintf();
X
X        /* Get list of directory inodes for filesystem */
X    get_dir_inodes(&idir_list, (ino_t) 2, (ino_t) sb.fs_ncg * sb.fs_ipg);
X
X        /* Make list of restored directory inodes */
X    new_idir(&restore_list);
X    idir_ptr = idir_list;
X    while (idir_ptr) {
X        inum = idir_ptr->inums[icnt];
X            /* Inode been restored? */
X        if (!in_idir(restore_list, inum)) {
X
X                /* Nope - create directory and restore */
X            (void) sprintf(iname, "i%d", inum);
X
X            if (verbose)
X                printf("Creating new base directory: %s\n",
X                    iname);
X            if (mkdir(iname, 0775)) {
X                fprintf(stderr,
X                    "Cannot create directory: %s; ",
X                    iname);
X                perror("");
X            }
X
X                /* Point to end of restored inode list */
X            restore_ptr = restore_list;
X            while(restore_ptr->next_idir)
X                restore_ptr = restore_ptr->next_idir;
X
X                /* Append to end of restored inode list */
X            if (restore(iname, inum, iname, &restore_ptr,
X                        Rflag, verbose))
X                return -1;
X        }
X        if (++icnt == idir_ptr->icnt) {
X            icnt = 0;
X            idir_ptr = idir_ptr->next_idir;
X        }
X    }
X    return 0;
X}
SHAR_EOF
chmod 0644 restore.c || echo "restore of restore.c fails"
sed 's/^X//' << 'SHAR_EOF' > stat.c &&
X
X/*
X *     fssal - BSD file system salvage program
X *
X *     Copyright 1989, Robert Ankeney
X *                     Generic Computer Products
X *                     5315 S.W. 53rd Court
X *                     Portland, Oregon  97221
X *                     [phone]
X *     All Rights Reserved
X *
X *     Distribution of any portion of this software as part of any product
X *     for sale is prohibited.
X *
X *     Version 1.00 (Preliminary)
X */
X
X/*
X * stat.c
X *
X * load an inode into memory
X */
X
X# include    "fs.h"
X# include    <sys/stat.h>
X
Xextern struct fs    sb;
Xextern int        fs_fd;
X
Xfs_stat (inum, statb)
Xino_t        inum;
Xstruct stat    *statb;
X{
X    long    off;
X    struct    dinode di;
X
X    long    lseek();
X
X    off = itobo (inum);
X    (void) lseek (fs_fd, off, L_SET);
X    if (read (fs_fd, (char *) &di, sizeof (di)) != sizeof (di))
X        return -1;
X    statb->st_dev = 0;
X    statb->st_ino = inum;
X    statb->st_mode = di.di_mode;
X    statb->st_nlink = di.di_nlink;
X    statb->st_uid = di.di_uid;
X    statb->st_gid = di.di_gid;
X    statb->st_atime = di.di_atime;
X    statb->st_mtime = di.di_mtime;
X    statb->st_ctime = di.di_ctime;
X    statb->st_blocks = di.di_blocks;
X    return 0;
X}
SHAR_EOF
chmod 0644 stat.c || echo "restore of stat.c fails"
exit 0