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 db19cdb..29ac8bd 100644 (file)
--- a/usr/src/sbin/restore/utilities.c
+++ b/usr/src/sbin/restore/utilities.c
@@ -1,14 +1,59 @@
-/* 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.9     (Berkeley)      83/04/11";
-#endif
+static char sccsid[] = "@(#)utilities.c        8.5 (Berkeley) 4/28/95";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#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 "restore.h"

+#include "extern.h"

 
 /*
  * Insure that all the components of a pathname exist.
  */
 
 /*
  * Insure that all the components of a pathname exist.
  */

+void

 pathcheck(name)
        char *name;
 {
 pathcheck(name)
        char *name;
 {


@@ -16,7 +61,7 @@ pathcheck(name)
        struct entry *ep;
        char *start;
 
        struct entry *ep;
        char *start;
 

-       start = index(name, '/');
+       start = strchr(name, '/');

        if (start == 0)
                return;
        for (cp = start; *cp != '\0'; cp++) {
        if (start == 0)
                return;
        for (cp = start; *cp != '\0'; cp++) {


@@ -24,11 +69,12 @@ pathcheck(name)
                        continue;
                *cp = '\0';
                ep = lookupname(name);
                        continue;
                *cp = '\0';
                ep = lookupname(name);

-               if (ep == NIL) {
-                       ep = addentry(name, ep->e_ino, NODE);
-                       ep->e_flags |= KEEP;
+               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 = '/';
        }
 }


@@ -36,6 +82,7 @@ pathcheck(name)
 /*
  * 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;
 {


@@ -44,7 +91,7 @@ mktempname(ep)
        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));
+       (void) strcpy(oldname, myname(ep));

        freename(ep->e_name);
        ep->e_name = savename(gentempname(ep));
        ep->e_namlen = strlen(ep->e_name);
        freename(ep->e_name);
        ep->e_name = savename(gentempname(ep));
        ep->e_namlen = strlen(ep->e_name);


@@ -62,9 +109,10 @@ gentempname(ep)
        struct entry *np;
        long i = 0;
 
        struct entry *np;
        long i = 0;
 

-       for (np = lookupino(ep->e_ino); np != NIL && np != ep; np = np->e_links)
+       for (np = lookupino(ep->e_ino);
+           np != NULL && np != ep; np = np->e_links)

                i++;
                i++;

-       if (np == NIL)
+       if (np == NULL)

                badentry(ep, "not on ino list");
        (void) sprintf(name, "%s%d%d", TMPHDR, i, ep->e_ino);
        return (name);
                badentry(ep, "not on ino list");
        (void) sprintf(name, "%s%d%d", TMPHDR, i, ep->e_ino);
        return (name);


@@ -73,12 +121,14 @@ gentempname(ep)
 /*
  * 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);
 }


@@ -86,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;
 {


@@ -94,10 +145,9 @@ 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) {
-               fprintf(stderr, "Warning: ");
-               fflush(stderr);
-               perror(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);
                return;
        }
        vprintf(stdout, "Make node %s\n", cp);


@@ -106,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;
 {


@@ -113,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");

-       cp = myname(ep);
-       if (rmdir(cp) < 0) {
-               perror("removenode");
-               panic("Cannot remove node %s\n", cp);
-       }

        ep->e_flags |= REMOVED;
        ep->e_flags &= ~TMPNAME;
        ep->e_flags |= REMOVED;
        ep->e_flags &= ~TMPNAME;

+       cp = myname(ep);
+       if (!Nflag && rmdir(cp) < 0) {
+               fprintf(stderr, "warning: %s: %s\n", cp, strerror(errno));
+               return;
+       }

        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;
 {


@@ -135,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);

 }
 
 /*
 }
 
 /*


@@ -183,7 +279,7 @@ 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;
                if (ep->e_flags & (NEW|EXTRACT))
                        return (start);
                        continue;
                if (ep->e_flags & (NEW|EXTRACT))
                        return (start);


@@ -202,7 +298,7 @@ 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;
                if (ep->e_flags & (NEW|EXTRACT))
                        return (start);
                        continue;
                if (ep->e_flags & (NEW|EXTRACT))
                        return (start);


@@ -213,6 +309,7 @@ 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;


@@ -221,14 +318,15 @@ badentry(ep, msg)
        fprintf(stderr, "bad entry: %s\n", msg);
        fprintf(stderr, "name: %s\n", myname(ep));
        fprintf(stderr, "parent name %s\n", myname(ep->e_parent));
        fprintf(stderr, "bad entry: %s\n", msg);
        fprintf(stderr, "name: %s\n", myname(ep));
        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 != NIL)
-               fprintf(stderr, "next hashchain name: %s\n", myname(ep->e_next));
+       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);


@@ -256,45 +354,81 @@ flagvalues(ep)
                (void) strcat(flagbuf, "|NEW");
        if (ep->e_flags & KEEP)
                (void) strcat(flagbuf, "|KEEP");
                (void) strcat(flagbuf, "|NEW");
        if (ep->e_flags & KEEP)
                (void) strcat(flagbuf, "|KEEP");

+       if (ep->e_flags & EXISTED)
+               (void) strcat(flagbuf, "|EXISTED");

        return (&flagbuf[1]);
 }
 
 /*
        return (&flagbuf[1]);
 }
 
 /*

- * canonicalize file names to always start with ``./''
+ * Check to see if a name is on a dump tape.

  */
  */

-canon(rawname, canonname)
-       char *rawname, *canonname;
+ino_t
+dirlookup(name)
+       const char *name;

 {
 {

-       int len;
-
-       if (strcmp(rawname, ".") == 0 || strncmp(rawname, "./", 2) == 0)
-               (void) strcpy(canonname, "");
-       else if (rawname[0] == '/')
-               (void) strcpy(canonname, ".");
-       else
-               (void) strcpy(canonname, "./");
-       (void) strcat(canonname, rawname);
-       len = strlen(canonname) - 1;
-       if (canonname[len] == '/')
-               canonname[len] = '\0';
+       struct direct *dp;
+       ino_t ino;
+ 
+       ino = ((dp = pathsearch(name)) == NULL) ? 0 : dp->d_ino;
+
+       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);
+       }
+}