rewrite to use rename

SCCS-vsn: bin/mv/mv.c 4.7

diff --git a/usr/src/bin/mv/mv.c b/usr/src/bin/mv/mv.c
index a5847ae..86a1655 100644 (file)
--- a/usr/src/bin/mv/mv.c
+++ b/usr/src/bin/mv/mv.c
@@ -1,308 +1,237 @@
-static char *sccsid = "@(#)mv.c        4.6 (Berkeley) 82/10/23";
+#ifndef lint
+static char *sccsid = "@(#)mv.c        4.7 (Berkeley) 83/01/01";
+#endif

 
 /*
  * mv file1 file2
  */
 
 /*
  * mv file1 file2
  */

+#include <sys/param.h>
+#include <sys/stat.h>

 
 #include <stdio.h>
 
 #include <stdio.h>

-#include <sys/types.h>
-#include <sys/stat.h>
+#include <dir.h>
+#include <errno.h>

 #include <signal.h>
 
 #include <signal.h>
 

-#define        DOT     "."
-#define        DOTDOT  ".."

 #define        DELIM   '/'
 #define        DELIM   '/'

-#define SDELIM "/"
-#define        MAXN    300

 #define MODEBITS 07777
 #define MODEBITS 07777

-#define ROOTINO 2

 
 

-char   *pname();
+#define        ISDIR(st)       (((st).st_mode&S_IFMT) == S_IFDIR)
+#define        ISLNK(st)       (((st).st_mode&S_IFMT) == S_IFLNK)
+#define        ISREG(st)       (((st).st_mode&S_IFMT) == S_IFREG)
+#define        ISDEV(st) \
+       (((st).st_mode&S_IFMT) == S_IFCHR || ((st).st_mode&S_IFMT) == S_IFBLK)
+

 char   *sprintf();
 char   *dname();
 struct stat s1, s2;
 char   *sprintf();
 char   *dname();
 struct stat s1, s2;

-int    iflag = 0;      /* interactive flag. If this flag is set,
-                        * the user is queried before files are
-                        * destroyed by cp.
-                        */
-int    fflag = 0;      /* force flag. supercedes all restrictions */
+int    iflag = 0;      /* interactive mode */
+int    fflag = 0;      /* force overwriting */
+extern unsigned errno;

 
 main(argc, argv)
 
 main(argc, argv)

-register char *argv[];
+       register char *argv[];

 {
        register i, r;
        register char *arg;
 
 {
        register i, r;
        register char *arg;
 

-       /* get the flag(s) */
-

        if (argc < 2)
                goto usage;
        if (argc < 2)
                goto usage;

-       while (argc>1 && *argv[1] == '-') {
+       while (argc > 1 && *argv[1] == '-') {

                argc--;
                arg = *++argv;
 
                /*
                argc--;
                arg = *++argv;
 
                /*

-                *  all files following a null option are considered file names
+                * all files following a null option
+                * are considered file names

                 */
                 */

-               if (*(arg+1) == '\0') break;
-
-               while (*++arg != '\0')
-                       switch (*arg) {
+               if (*(arg+1) == '\0')
+                       break;
+               while (*++arg != '\0') switch (*arg) {

 
 

-                       /* interactive mode */
-                       case 'i':
-                               iflag++;
-                               break;
+               case 'i':
+                       iflag++;
+                       break;

 
 

-                       /* force moves */
-                       case 'f':
-                               fflag++;
-                               break;
+               case 'f':
+                       fflag++;
+                       break;

 
 

-                       /* don't live with bad options */
-                       default:
-                               goto usage;
-                       }
+               default:
+                       goto usage;
+               }

        }
        if (argc < 3)
                goto usage;
        }
        if (argc < 3)
                goto usage;

-       if (lstat(argv[1], &s1) < 0) {
-               fprintf(stderr, "mv: cannot access %s\n", argv[1]);
-               return(1);
-       }
-       if ((s1.st_mode & S_IFMT) == S_IFDIR) {
-               if (argc != 3)
-                       goto usage;
-               return mvdir(argv[1], argv[2]);
-       }

        setuid(getuid());
        setuid(getuid());

-       if (argc > 3)
-               if (stat(argv[argc-1], &s2) < 0 || (s2.st_mode & S_IFMT) != S_IFDIR)
-                       goto usage;

        r = 0;
        r = 0;

-       for (i=1; i<argc-1; i++)
-               r |= move(argv[i], argv[argc-1]);
-       return(r);
+       if (argc > 3) {
+               register char *dest;
+
+               dest = argv[argc-1];
+               if (stat(dest, &s2) < 0 || !ISDIR(s2))
+                       goto usage;
+               for (i = 1; i < argc-1; i++)
+                       r |= movewithshortname(argv[i], dest);
+               exit(r);
+       }
+       if (stat(argv[2], &s2) >= 0 && ISDIR(s2)) {
+               struct stat s1;
+
+               if (stat(argv[1], &s1) >= 0 && ISDIR(s1))
+                       r = move(argv[1], argv[2]);
+               else
+                       r = movewithshortname(argv[1], argv[2]);
+       } else
+               r = move(argv[1], argv[2]);
+       exit(r);
+       /*NOTREACHED*/

 usage:
 usage:

-       fprintf(stderr, "usage: mv [-if] f1 f2; or mv [-if] d1 d2; or mv [-if] f1 ... fn d1\n");
-       return(1);
+       fprintf(stderr,
+"usage: mv [-if] f1 ... fn d1 (where `fn' is a file or directory)\n");
+       return (1);
+}
+
+movewithshortname(src, dest)
+       char *src, *dest;
+{
+       register char *shortname;
+       char target[MAXPATHLEN + 1];
+
+       shortname = dname(src);
+       if (strlen(dest) + strlen(shortname) > MAXPATHLEN - 1) {
+               error("%s/%s: pathname too long", dest,
+                       shortname);
+               return (1);
+       }
+       sprintf(target, "%s/%s", dest, shortname);
+       return (move(src, target));

 }
 
 move(source, target)
 }
 
 move(source, target)

-char *source, *target;
+       char *source, *target;

 {
 {

-       register c, i;
-       int     status;
-       char    buf[MAXN];

 
        if (lstat(source, &s1) < 0) {
 
        if (lstat(source, &s1) < 0) {

-               fprintf(stderr, "mv: cannot access %s\n", source);
-               return(1);
-       }
-       if ((s1.st_mode & S_IFMT) == S_IFDIR) {
-               fprintf(stderr, "mv: directory rename only\n");
-               return(1);
+               error("cannot access %s", source);
+               return (1);

        }
        }

-       if (stat(target, &s2) >= 0) {
-               if ((s2.st_mode & S_IFMT) == S_IFDIR) {
-                       sprintf(buf, "%s/%s", target, dname(source));
-                       target = buf;
+       /*
+        * First, try to rename source to destination.
+        * The only reason we continue on failure is if
+        * the move is on a nondirectory and not across
+        * file systems.
+        */
+       if (lstat(target, &s2) >= 0) {
+               if (iflag && !fflag && query("remove %s? ", target) == 0)
+                       return (1);
+               if (s1.st_dev == s2.st_dev && s1.st_ino == s2.st_ino) {
+                       error("%s and %s are identical", source, target);
+                       return (1);

                }
                }

-               if (lstat(target, &s2) >= 0) {
-                       if ((s2.st_mode & S_IFMT) == S_IFDIR) {
-                               fprintf(stderr, "mv: %s is a directory\n", target);
-                               return(1);
-                       } else if (iflag && !fflag) {
-                               fprintf(stderr, "remove %s? ", target);
-                               i = c = getchar();
-                               while (c != '\n' && c != EOF)
-                                       c = getchar();
-                               if (i != 'y')
-                                       return(1);
-                       }
-                       if (s1.st_dev==s2.st_dev && s1.st_ino==s2.st_ino) {
-                               fprintf(stderr, "mv: %s and %s are identical\n",
-                                               source, target);
-                               return(1);
-                       }
-                       if (access(target, 2) < 0 && !fflag && isatty(fileno(stdin))) {
-                               fprintf(stderr, "override protection %o for %s? ", 
-                                       s2.st_mode & MODEBITS, target);
-                               i = c = getchar();
-                               while (c != '\n' && c != EOF)
-                                       c = getchar();
-                               if (i != 'y')
-                                       return(1);
-                       }
-                       if (unlink(target) < 0) {
-                               fprintf(stderr, "mv: cannot unlink %s\n", target);
-                               return(1);
-                       }
+               if (access(target, 2) < 0 && !fflag && isatty(fileno(stdin))) {
+                       if (query("override protection %o for %s? ",
+                         s2.st_mode & MODEBITS, target) == 0)
+                               return (1);
+               }
+               if (rename(source, target) >= 0)
+                       return (0);
+               if (errno != EXDEV) {
+                       Perror2(source, "rename");
+                       return (1);
+               }
+               if (ISDIR(s1)) {
+                       error("can't mv directories across file systems");
+                       return (1);
+               }
+               if (unlink(target) < 0) {
+                       error("cannot unlink %s", target);
+                       return (1);
+               }
+       } else {
+               if (rename(source, target) >= 0)
+                       return (0);
+               if (ISDIR(s1)) {
+                       Perror2(source, "rename");
+                       return (1);

                }
        }
                }
        }

-       if ((s1.st_mode & S_IFMT) == S_IFLNK) {
+       /*
+        * File can't be renamed, try to recreate the symbolic
+        * link or special device, or copy the file wholesale
+        * between file systems.
+        */
+       if (ISLNK(s1)) {

                register m;
                register m;

-               char symln[MAXN];
+               char symln[MAXPATHLEN];

 
                if (readlink(source, symln, sizeof (symln)) < 0) {
 
                if (readlink(source, symln, sizeof (symln)) < 0) {

-                       perror(source);
+                       Perror(source);

                        return (1);
                }
                m = umask(~(s1.st_mode & MODEBITS));
                if (symlink(symln, target) < 0) {
                        return (1);
                }
                m = umask(~(s1.st_mode & MODEBITS));
                if (symlink(symln, target) < 0) {

-                       perror(target);
+                       Perror(target);

                        return (1);
                }
                        return (1);
                }

-               umask(m);
-       } else if (link(source, target) < 0) {
+               (void) umask(m);
+               goto cleanup;
+       }
+       if (ISDEV(s1)) {
+               if (mknod(target, s1.st_mode, s1.st_rdev) < 0) {
+                       Perror(target);
+                       return (1);
+               }
+               (void) utime(target, &s1.st_atime);
+               goto cleanup;
+       }
+       if (ISREG(s1)) {
+               int i, c, status;
+

                i = fork();
                if (i == -1) {
                i = fork();
                if (i == -1) {

-                       fprintf(stderr, "mv: try again\n");
-                       return(1);
+                       error("try again");
+                       return (1);

                }
                if (i == 0) {
                        execl("/bin/cp", "cp", source, target, 0);
                }
                if (i == 0) {
                        execl("/bin/cp", "cp", source, target, 0);

-                       fprintf(stderr, "mv: cannot exec cp\n");
+                       error("cannot exec /bin/cp");

                        exit(1);
                }
                while ((c = wait(&status)) != i && c != -1)
                        ;
                if (status != 0)
                        exit(1);
                }
                while ((c = wait(&status)) != i && c != -1)
                        ;
                if (status != 0)

-                       return(1);
-               utime(target, &s1.st_atime);
-       }
-       if (unlink(source) < 0) {
-               fprintf(stderr, "mv: cannot unlink %s\n", source);
-               return(1);
-       }
-       return(0);
-}
-
-mvdir(source, target)
-char *source, *target;
-{
-       register char *p;
-       register i;
-       char buf[MAXN];
-       char c,cc;
-
-       if (stat(target, &s2) >= 0) {
-               if ((s2.st_mode&S_IFMT) != S_IFDIR) {
-                       fprintf(stderr, "mv: %s exists\n", target);
-                       return(1);
-               }
-               p = dname(source);
-               if (strlen(target) > MAXN-strlen(p)-2) {
-                       fprintf(stderr, "mv :target name too long\n");
-                       return(1);
-               }
-               strcpy(buf, target);
-               target = buf;
-               strcat(buf, SDELIM);
-               strcat(buf, p);
-               if (stat(target, &s2) >= 0) {
-                       fprintf(stderr, "mv: %s exists\n", buf);
-                       return(1);
-               }
-       }
-       if (strcmp(source, target) == 0) {
-               fprintf(stderr, "mv: ?? source == target, source exists and target doesnt\n");
-               return(1);
-       }
-       p = dname(source);
-       if (!strcmp(p, DOT) || !strcmp(p, DOTDOT) || !strcmp(p, "") || p[strlen(p)-1]=='/') {
-               fprintf(stderr, "mv: cannot rename %s\n", p);
-               return(1);
-       }
-       if (stat(pname(source), &s1) < 0 || stat(pname(target), &s2) < 0) {
-               fprintf(stderr, "mv: cannot locate parent\n");
-               return(1);
-       }
-       if (access(pname(target), 2) < 0) {
-               fprintf(stderr, "mv: no write access to %s\n", pname(target));
-               return(1);
-       }
-       if (access(pname(source), 2) < 0) {
-               fprintf(stderr, "mv: no write access to %s\n", pname(source));
-               return(1);
-       }
-       if (s1.st_dev != s2.st_dev) {
-               fprintf(stderr, "mv: cannot move directories across devices\n");
-               return(1);
+                       return (1);
+               (void) utime(target, &s1.st_atime);
+               goto cleanup;

        }
        }

-       if (s1.st_ino != s2.st_ino) {
-               char dst[MAXN+5];
+       error("%s: unknown file type %o", source, s1.st_mode);
+       return (1);

 
 

-               if (chkdot(source) || chkdot(target)) {
-                       fprintf(stderr, "mv: Sorry, path names including %s aren't allowed\n", DOTDOT);
-                       return(1);
-               }
-               stat(source, &s1);
-               if (check(pname(target), s1.st_ino))
-                       return(1);
-               for (i = 1; i <= NSIG; i++)
-                       signal(i, SIG_IGN);
-               if (link(source, target) < 0) {
-                       fprintf(stderr, "mv: cannot link %s to %s\n", target, source);
-                       return(1);
-               }
-               if (unlink(source) < 0) {
-                       fprintf(stderr, "mv: %s: cannot unlink\n", source);
-                       unlink(target);
-                       return(1);
-               }
-               strcat(dst, target);
-               strcat(dst, "/");
-               strcat(dst, DOTDOT);
-               if (unlink(dst) < 0) {
-                       fprintf(stderr, "mv: %s: cannot unlink\n", dst);
-                       if (link(target, source) >= 0)
-                               unlink(target);
-                       return(1);
-               }
-               if (link(pname(target), dst) < 0) {
-                       fprintf(stderr, "mv: cannot link %s to %s\n",
-                               dst, pname(target));
-                       if (link(pname(source), dst) >= 0)
-                               if (link(target, source) >= 0)
-                                       unlink(target);
-                       return(1);
-               }
-               return(0);
-       }
-       if (link(source, target) < 0) {
-               fprintf(stderr, "mv: cannot link %s and %s\n",
-                       source, target);
-               return(1);
-       }
+cleanup:

        if (unlink(source) < 0) {
        if (unlink(source) < 0) {

-               fprintf(stderr, "mv: ?? cannot unlink %s\n", source);
-               return(1);
+               error("cannot unlink %s", source);
+               return (1);

        }
        }

-       return(0);
+       return (0);

 }
 
 }
 

-char *
-pname(name)
-register char *name;
+/*VARARGS*/
+query(prompt, a1, a2)
+       char *a1;

 {
 {

-       register c;
-       register char *p, *q;
-       static  char buf[MAXN];
+       register char i, c;

 
 

-       p = q = buf;
-       while (c = *p++ = *name++)
-               if (c == DELIM)
-                       q = p-1;
-       if (q == buf && *q == DELIM)
-               q++;
-       *q = 0;
-       return buf[0]? buf : DOT;
+       fprintf(stderr, prompt, a1, a2);
+       i = c = getchar();
+       while (c != '\n' && c != EOF)
+               c = getchar();
+       return (i == 'y');

 }
 
 char *
 dname(name)
 }
 
 char *
 dname(name)

-register char *name;
+       register char *name;

 {
        register char *p;
 
 {
        register char *p;
 


@@ -313,42 +242,30 @@ register char *name;
        return name;
 }
 
        return name;
 }
 

-check(spth, dinode)
-char *spth;
-ino_t dinode;
+/*VARARGS*/
+error(fmt, a1, a2)
+       char *fmt;

 {
 {

-       char nspth[MAXN];
-       struct stat sbuf;

 
 

-       sbuf.st_ino = 0;
+       fprintf(stderr, "mv: ");
+       fprintf(stderr, fmt, a1, a2);
+       fprintf(stderr, "\n");
+}

 
 

-       strcpy(nspth, spth);
-       while (sbuf.st_ino != ROOTINO) {
-               if (stat(nspth, &sbuf) < 0) {
-                       fprintf(stderr, "mv: cannot access %s\n", nspth);
-                       return(1);
-               }
-               if (sbuf.st_ino == dinode) {
-                       fprintf(stderr, "mv: cannot move a directory into itself\n");
-                       return(1);
-               }
-               if (strlen(nspth) > MAXN-2-sizeof(DOTDOT)) {
-                       fprintf(stderr, "mv: name too long\n");
-                       return(1);
-               }
-               strcat(nspth, SDELIM);
-               strcat(nspth, DOTDOT);
-       }
-       return(0);
+Perror(s)
+       char *s;
+{
+       char buf[MAXPATHLEN + 10];
+       
+       sprintf(buf, "mv: %s", s);
+       perror(buf);

 }
 
 }
 

-chkdot(s)
-register char *s;
+Perror2(s1, s2)
+       char *s1, *s2;

 {
 {

-       do {
-               if (strcmp(dname(s), DOTDOT) == 0)
-                       return(1);
-               s = pname(s);
-       } while (strcmp(s, DOT) != 0 && strcmp(s, SDELIM) != 0);
-       return(0);
+       char buf[MAXPATHLEN + 20];
+
+       sprintf(buf, "mv: %s: %s", s1, s2);
+       perror(buf);

 }
 }