projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_4_Lite2 release
[unix-history] / usr / src / sbin / restore / utilities.c
diff --git a/usr/src/sbin/restore/utilities.c b/usr/src/sbin/restore/utilities.c
index 2f95e81..29ac8bd 100644 (file)
--- a/usr/src/sbin/restore/utilities.c
+++ b/usr/src/sbin/restore/utilities.c
@@ -1,95 +1,134 @@
-/* Copyright (c) 1983 Regents of the University of California */
+/*
+ * Copyright (c) 1983, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
 #ifndef lint
 
 #ifndef lint
-static char sccsid[] = "@(#)utilities.c        3.2     (Berkeley)      83/02/27";
-#endif
+static char sccsid[] = "@(#)utilities.c        8.5 (Berkeley) 4/28/95";
+#endif /* not lint */
 
 
-#include "restore.h"
+#include <sys/param.h>
+#include <sys/stat.h>
 
 
-/*
- * Move the contents of a directory to a new directory.
- */
-movecontents(from, to)
-       struct entry *from, *to;
-{
-       register struct entry *ep;
-       struct entry *np;
-       register char *targetp;
-       char target[BUFSIZ];
-
-       strcpy(target, myname(to));
-       targetp = &target[strlen(target)];
-       *targetp++ = '/';
-       for (ep = from->e_entries; ep != NIL; ) {
-               strcpy(targetp, ep->e_name);
-               if (ep->e_flags & TMPNAME)
-                       badentry(ep, "movecontents: found TMPNAME");
-               np = lookupname(target);
-               if (np != NIL)
-                       mktempname(np);
-               renameit(myname(ep), target);
-               np = ep->e_sibling;
-               moveentry(ep, target);
-               ep = np;
-       }
-}
+#include <ufs/ufs/dinode.h>
+#include <ufs/ufs/dir.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "restore.h"
+#include "extern.h"
 
 /*
  * Insure that all the components of a pathname exist.
  */
 
 /*
  * Insure that all the components of a pathname exist.
  */
-struct entry *
-pathcheck(name, type)
+void
+pathcheck(name)
        char *name;
        char *name;
-       char type;
 {
        register char *cp;
        struct entry *ep;
        char *start;
 
 {
        register char *cp;
        struct entry *ep;
        char *start;
 
-       start = index(name, '/');
+       start = strchr(name, '/');
        if (start == 0)
        if (start == 0)
-               return (lookupino(ROOTINO));
+               return;
        for (cp = start; *cp != '\0'; cp++) {
                if (*cp != '/')
                        continue;
                *cp = '\0';
                ep = lookupname(name);
        for (cp = start; *cp != '\0'; cp++) {
                if (*cp != '/')
                        continue;
                *cp = '\0';
                ep = lookupname(name);
-               if (ep == NIL) {
-                       ep = addentry(name, (ino_t)0, NODE);
-                       ep->e_flags |= type;
+               if (ep == NULL) {
+                       /* Safe; we know the pathname exists in the dump. */
+                       ep = addentry(name, pathsearch(name)->d_ino, NODE);
                        newnode(ep);
                }
                        newnode(ep);
                }
+               ep->e_flags |= NEW|KEEP;
                *cp = '/';
        }
                *cp = '/';
        }
-       return (ep);
 }
 
 /*
  * Change a name to a unique temporary name.
  */
 }
 
 /*
  * Change a name to a unique temporary name.
  */
+void
 mktempname(ep)
        register struct entry *ep;
 {
 mktempname(ep)
        register struct entry *ep;
 {
-       char oldname[BUFSIZ];
+       char oldname[MAXPATHLEN];
 
        if (ep->e_flags & TMPNAME)
                badentry(ep, "mktempname: called with TMPNAME");
        ep->e_flags |= TMPNAME;
 
        if (ep->e_flags & TMPNAME)
                badentry(ep, "mktempname: called with TMPNAME");
        ep->e_flags |= TMPNAME;
-       strcpy(oldname, myname(ep));
-       ep->e_name[ep->e_namlen++] = TMPCHAR;
-       ep->e_name[ep->e_namlen] = '\0';
+       (void) strcpy(oldname, myname(ep));
+       freename(ep->e_name);
+       ep->e_name = savename(gentempname(ep));
+       ep->e_namlen = strlen(ep->e_name);
        renameit(oldname, myname(ep));
 }
 
        renameit(oldname, myname(ep));
 }
 
+/*
+ * Generate a temporary name for an entry.
+ */
+char *
+gentempname(ep)
+       struct entry *ep;
+{
+       static char name[MAXPATHLEN];
+       struct entry *np;
+       long i = 0;
+
+       for (np = lookupino(ep->e_ino);
+           np != NULL && np != ep; np = np->e_links)
+               i++;
+       if (np == NULL)
+               badentry(ep, "not on ino list");
+       (void) sprintf(name, "%s%d%d", TMPHDR, i, ep->e_ino);
+       return (name);
+}
+
 /*
  * Rename a file or directory.
  */
 /*
  * Rename a file or directory.
  */
+void
 renameit(from, to)
        char *from, *to;
 {
 renameit(from, to)
        char *from, *to;
 {
-       if (rename(from, to) < 0) {
-               perror("renameit");
-               panic("Cannot rename %s to %s\n", from, to);
+       if (!Nflag && rename(from, to) < 0) {
+               fprintf(stderr, "warning: cannot rename %s to %s: %s\n",
+                   from, to, strerror(errno));
+               return;
        }
        vprintf(stdout, "rename %s to %s\n", from, to);
 }
        }
        vprintf(stdout, "rename %s to %s\n", from, to);
 }
@@ -97,6 +136,7 @@ renameit(from, to)
 /*
  * Create a new node (directory).
  */
 /*
  * Create a new node (directory).
  */
+void
 newnode(np)
        struct entry *np;
 {
 newnode(np)
        struct entry *np;
 {
@@ -105,9 +145,10 @@ newnode(np)
        if (np->e_type != NODE)
                badentry(np, "newnode: not a node");
        cp = myname(np);
        if (np->e_type != NODE)
                badentry(np, "newnode: not a node");
        cp = myname(np);
-       if (mkdir(cp, 0777) < 0) {
-               perror("newnode");
-               panic("Cannot make node %s\n", cp);
+       if (!Nflag && mkdir(cp, 0777) < 0) {
+               np->e_flags |= EXISTED;
+               fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
+               return;
        }
        vprintf(stdout, "Make node %s\n", cp);
 }
        }
        vprintf(stdout, "Make node %s\n", cp);
 }
@@ -115,6 +156,7 @@ newnode(np)
 /*
  * Remove an old node (directory).
  */
 /*
  * Remove an old node (directory).
  */
+void
 removenode(ep)
        register struct entry *ep;
 {
 removenode(ep)
        register struct entry *ep;
 {
@@ -122,21 +164,22 @@ removenode(ep)
 
        if (ep->e_type != NODE)
                badentry(ep, "removenode: not a node");
 
        if (ep->e_type != NODE)
                badentry(ep, "removenode: not a node");
-       if (ep->e_entries != NIL)
+       if (ep->e_entries != NULL)
                badentry(ep, "removenode: non-empty directory");
                badentry(ep, "removenode: non-empty directory");
+       ep->e_flags |= REMOVED;
+       ep->e_flags &= ~TMPNAME;
        cp = myname(ep);
        cp = myname(ep);
-       if (rmdir(cp) < 0) {
-               perror("removenode");
-               panic("Cannot remove node %s\n", cp);
+       if (!Nflag && rmdir(cp) < 0) {
+               fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
+               return;
        }
        }
-       ep->e_flags |= REMOVED;
-       ep->e_flags &= ~(TMPNAME|TMPNODE);
        vprintf(stdout, "Remove node %s\n", cp);
 }
 
 /*
  * Remove a leaf.
  */
        vprintf(stdout, "Remove node %s\n", cp);
 }
 
 /*
  * Remove a leaf.
  */
+void
 removeleaf(ep)
        register struct entry *ep;
 {
 removeleaf(ep)
        register struct entry *ep;
 {
@@ -144,41 +187,85 @@ removeleaf(ep)
 
        if (ep->e_type != LEAF)
                badentry(ep, "removeleaf: not a leaf");
 
        if (ep->e_type != LEAF)
                badentry(ep, "removeleaf: not a leaf");
-       cp = myname(ep);
-       if (unlink(cp) < 0) {
-               perror("removeleaf");
-               panic("Cannot remove leaf %s\n", cp);
-       }
        ep->e_flags |= REMOVED;
        ep->e_flags &= ~TMPNAME;
        ep->e_flags |= REMOVED;
        ep->e_flags &= ~TMPNAME;
+       cp = myname(ep);
+       if (!Nflag && unlink(cp) < 0) {
+               fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
+               return;
+       }
        vprintf(stdout, "Remove leaf %s\n", cp);
 }
 
 /*
  * Create a link.
  */
        vprintf(stdout, "Remove leaf %s\n", cp);
 }
 
 /*
  * Create a link.
  */
+int
 linkit(existing, new, type)
        char *existing, *new;
        int type;
 {
 
        if (type == SYMLINK) {
 linkit(existing, new, type)
        char *existing, *new;
        int type;
 {
 
        if (type == SYMLINK) {
-               if (symlink(existing, new) < 0) {
-                       perror("linkit");
-                       panic("Cannot create symbolic link %s->%s\n",
-                               new, existing);
+               if (!Nflag && symlink(existing, new) < 0) {
+                       fprintf(stderr,
+                           "warning: cannot create symbolic link %s->%s: %s\n",
+                           new, existing, strerror(errno));
+                       return (FAIL);
                }
        } else if (type == HARDLINK) {
                }
        } else if (type == HARDLINK) {
-               if (link(existing, new) < 0) {
-                       perror("linkit");
-                       panic("Cannot create hard link %s->%s\n",
-                               new, existing);
+               if (!Nflag && link(existing, new) < 0) {
+                       fprintf(stderr,
+                           "warning: cannot create hard link %s->%s: %s\n",
+                           new, existing, strerror(errno));
+                       return (FAIL);
                }
        } else {
                panic("linkit: unknown type %d\n", type);
                }
        } else {
                panic("linkit: unknown type %d\n", type);
+               return (FAIL);
        }
        vprintf(stdout, "Create %s link %s->%s\n",
                type == SYMLINK ? "symbolic" : "hard", new, existing);
        }
        vprintf(stdout, "Create %s link %s->%s\n",
                type == SYMLINK ? "symbolic" : "hard", new, existing);
+       return (GOOD);
+}
+
+/*
+ * Create a whiteout.
+ */
+int
+addwhiteout(name)
+       char *name;
+{
+
+       if (!Nflag && mknod(name, S_IFWHT, 0) < 0) {
+               fprintf(stderr, "warning: cannot create whiteout %s: %s\n",
+                   name, strerror(errno));
+               return (FAIL);
+       }
+       vprintf(stdout, "Create whiteout %s\n", name);
+       return (GOOD);
+}
+
+/*
+ * Delete a whiteout.
+ */
+void
+delwhiteout(ep)
+       register struct entry *ep;
+{
+       char *name;
+
+       if (ep->e_type != LEAF)
+               badentry(ep, "delwhiteout: not a leaf");
+       ep->e_flags |= REMOVED;
+       ep->e_flags &= ~TMPNAME;
+       name = myname(ep);
+       if (!Nflag && undelete(name) < 0) {
+               fprintf(stderr, "warning: cannot delete whiteout %s: %s\n",
+                   name, strerror(errno));
+               return;
+       }
+       vprintf(stdout, "Delete whiteout %s\n", name);
 }
 
 /*
 }
 
 /*
@@ -192,9 +279,9 @@ lowerbnd(start)
 
        for ( ; start < maxino; start++) {
                ep = lookupino(start);
 
        for ( ; start < maxino; start++) {
                ep = lookupino(start);
-               if (ep == NIL)
+               if (ep == NULL || ep->e_type == NODE)
                        continue;
                        continue;
-               if (ep->e_flags & (NEW|EXTRACT|CHANGE))
+               if (ep->e_flags & (NEW|EXTRACT))
                        return (start);
        }
        return (start);
                        return (start);
        }
        return (start);
@@ -211,9 +298,9 @@ upperbnd(start)
 
        for ( ; start > ROOTINO; start--) {
                ep = lookupino(start);
 
        for ( ; start > ROOTINO; start--) {
                ep = lookupino(start);
-               if (ep == NIL)
+               if (ep == NULL || ep->e_type == NODE)
                        continue;
                        continue;
-               if (ep->e_flags & (NEW|EXTRACT|CHANGE))
+               if (ep->e_flags & (NEW|EXTRACT))
                        return (start);
        }
        return (start);
                        return (start);
        }
        return (start);
@@ -222,91 +309,126 @@ upperbnd(start)
 /*
  * report on a badly formed entry
  */
 /*
  * report on a badly formed entry
  */
+void
 badentry(ep, msg)
        register struct entry *ep;
        char *msg;
 {
 badentry(ep, msg)
        register struct entry *ep;
        char *msg;
 {
-       char flagbuf[BUFSIZ];
 
        fprintf(stderr, "bad entry: %s\n", msg);
        fprintf(stderr, "name: %s\n", myname(ep));
 
        fprintf(stderr, "bad entry: %s\n", msg);
        fprintf(stderr, "name: %s\n", myname(ep));
-       if (ep->e_newname != NULL)
-               fprintf(stderr, "new name: %s\n", ep->e_newname);
        fprintf(stderr, "parent name %s\n", myname(ep->e_parent));
        fprintf(stderr, "parent name %s\n", myname(ep->e_parent));
-       if (ep->e_sibling != NIL)
+       if (ep->e_sibling != NULL)
                fprintf(stderr, "sibling name: %s\n", myname(ep->e_sibling));
                fprintf(stderr, "sibling name: %s\n", myname(ep->e_sibling));
-       if (ep->e_entries != NIL)
+       if (ep->e_entries != NULL)
                fprintf(stderr, "next entry name: %s\n", myname(ep->e_entries));
                fprintf(stderr, "next entry name: %s\n", myname(ep->e_entries));
-       if (ep->e_links != NIL)
+       if (ep->e_links != NULL)
                fprintf(stderr, "next link name: %s\n", myname(ep->e_links));
                fprintf(stderr, "next link name: %s\n", myname(ep->e_links));
+       if (ep->e_next != NULL)
+               fprintf(stderr,
+                   "next hashchain name: %s\n", myname(ep->e_next));
        fprintf(stderr, "entry type: %s\n",
                ep->e_type == NODE ? "NODE" : "LEAF");
        fprintf(stderr, "inode number: %ld\n", ep->e_ino);
        fprintf(stderr, "entry type: %s\n",
                ep->e_type == NODE ? "NODE" : "LEAF");
        fprintf(stderr, "inode number: %ld\n", ep->e_ino);
-       strcpy(flagbuf, "|NIL");
+       panic("flags: %s\n", flagvalues(ep));
+}
+
+/*
+ * Construct a string indicating the active flag bits of an entry.
+ */
+char *
+flagvalues(ep)
+       register struct entry *ep;
+{
+       static char flagbuf[BUFSIZ];
+
+       (void) strcpy(flagbuf, "|NIL");
        flagbuf[0] = '\0';
        flagbuf[0] = '\0';
-       if (ep->e_flags & REMOVE)
-               strcat(flagbuf, "|REMOVE");
        if (ep->e_flags & REMOVED)
        if (ep->e_flags & REMOVED)
-               strcat(flagbuf, "|REMOVED");
-       if (ep->e_flags & RENAME)
-               strcat(flagbuf, "|RENAME");
+               (void) strcat(flagbuf, "|REMOVED");
        if (ep->e_flags & TMPNAME)
        if (ep->e_flags & TMPNAME)
-               strcat(flagbuf, "|TMPNAME");
-       if (ep->e_flags & TMPNODE)
-               strcat(flagbuf, "|TMPNODE");
+               (void) strcat(flagbuf, "|TMPNAME");
        if (ep->e_flags & EXTRACT)
        if (ep->e_flags & EXTRACT)
-               strcat(flagbuf, "|EXTRACT");
-       if (ep->e_flags & RENUMBER)
-               strcat(flagbuf, "|RENUMBER");
-       if (ep->e_flags & CHANGE)
-               strcat(flagbuf, "|CHANGE");
+               (void) strcat(flagbuf, "|EXTRACT");
        if (ep->e_flags & NEW)
        if (ep->e_flags & NEW)
-               strcat(flagbuf, "|NEW");
+               (void) strcat(flagbuf, "|NEW");
        if (ep->e_flags & KEEP)
        if (ep->e_flags & KEEP)
-               strcat(flagbuf, "|KEEP");
-       panic("flags: %s\n", &flagbuf[1]);
-}
-
-/*
- * respond to interrupts
- */
-onintr()
-{
-       if (reply("restore interrupted, continue"))
-               return;
-       done(1);
+               (void) strcat(flagbuf, "|KEEP");
+       if (ep->e_flags & EXISTED)
+               (void) strcat(flagbuf, "|EXISTED");
+       return (&flagbuf[1]);
 }
 
 /*
 }
 
 /*
- * handle unexpected inconsistencies
+ * Check to see if a name is on a dump tape.
  */
  */
-/* VARARGS1 */
-panic(msg, d1, d2)
-       char *msg;
-       long d1, d2;
+ino_t
+dirlookup(name)
+       const char *name;
 {
 {
+       struct direct *dp;
+       ino_t ino;
+ 
+       ino = ((dp = pathsearch(name)) == NULL) ? 0 : dp->d_ino;
 
 
-       fprintf(stderr, msg, d1, d2);
-       if (reply("abort"))
-               abort();
+       if (ino == 0 || TSTINO(ino, dumpmap) == 0)
+               fprintf(stderr, "%s is not on the tape\n", name);
+       return (ino);
 }
 
 /*
 }
 
 /*
- * elicit a reply
+ * Elicit a reply.
  */
  */
+int
 reply(question)
        char *question;
 {
        char c;
 
 reply(question)
        char *question;
 {
        char c;
 
-       fprintf(stderr, "%s? ", question);
        do      {
        do      {
-               fprintf(stderr, "[yn] ");
-               c = getchar();
-               while (c != '\n' && getchar() != '\n')
-                       /* void */;
+               fprintf(stderr, "%s? [yn] ", question);
+               (void) fflush(stderr);
+               c = getc(terminal);
+               while (c != '\n' && getc(terminal) != '\n')
+                       if (feof(terminal))
+                               return (FAIL);
        } while (c != 'y' && c != 'n');
        if (c == 'y')
                return (GOOD);
        return (FAIL);
 }
        } while (c != 'y' && c != 'n');
        if (c == 'y')
                return (GOOD);
        return (FAIL);
 }
+
+/*
+ * handle unexpected inconsistencies
+ */
+#if __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+void
+#if __STDC__
+panic(const char *fmt, ...)
+#else
+panic(fmt, va_alist)
+       char *fmt;
+       va_dcl
+#endif
+{
+       va_list ap;
+#if __STDC__
+       va_start(ap, fmt);
+#else
+       va_start(ap);
+#endif
+
+       vfprintf(stderr, fmt, ap);
+       if (yflag)
+               return;
+       if (reply("abort") == GOOD) {
+               if (reply("dump core") == GOOD)
+                       abort();
+               done(1);
+       }
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.