BSD 4_3_Net_2 release

[unix-history] / usr / src / bin / mv / mv.c

diff --git a/usr/src/bin/mv/mv.c b/usr/src/bin/mv/mv.c
index 274abdd..ca387b7 100644 (file)
--- a/usr/src/bin/mv/mv.c
+++ b/usr/src/bin/mv/mv.c
@@ -1,339 +1,259 @@
-static char *sccsid = "@(#)mv.c        4.5 (Berkeley) 82/02/11";

 /*
 /*

- * mv file1 file2
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Ken Smith of The State University of New York at Buffalo.
+ *
+ * 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.

  */
 
  */
 

-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <signal.h>
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */

 
 

-#define        DOT     "."
-#define        DOTDOT  ".."
-#define        DELIM   '/'
-#define SDELIM "/"
-#define        MAXN    100
-#define MODEBITS 07777
-#define ROOTINO 2
+#ifndef lint
+static char sccsid[] = "@(#)mv.c       5.11 (Berkeley) 4/3/91";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "pathnames.h"

 
 

-char   *pname();
-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 fflg, iflg;

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

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

 {
 {

-       register i, r;
-       register char *arg;
+       extern char *optarg;
+       extern int optind;
+       register int baselen, exitval, len;
+       register char *p, *endp;
+       struct stat sb;
+       int ch;
+       char path[MAXPATHLEN + 1];

 
 

-       /* get the flag(s) */
+       while (((ch = getopt(argc, argv, "-if")) != EOF))
+               switch((char)ch) {
+               case 'i':
+                       iflg = 1;
+                       break;
+               case 'f':
+                       fflg = 1;
+                       break;
+               case '-':               /* undocumented; for compatibility */
+                       goto endarg;
+               case '?':
+               default:
+                       usage();
+               }
+endarg:        argc -= optind;
+       argv += optind;

 
        if (argc < 2)
 
        if (argc < 2)

-               goto usage;
-       while (argc>1 && *argv[1] == '-') {
-               argc--;
-               arg = *++argv;
-
-               /*
-                *  all files following a null option are considered file names
-                */
-               if (*(arg+1) == '\0') break;
-
-               while (*++arg != '\0')
-                       switch (*arg) {
+               usage();

 
 

-                       /* interactive mode */
-                       case 'i':
-                               iflag++;
-                               break;
-
-                       /* force moves */
-                       case 'f':
-                               fflag++;
-                               break;
-
-                       /* don't live with bad options */
-                       default:
-                               goto usage;
-                       }
-       }
-       if (argc < 3)
-               goto usage;
-       if (stat(argv[1], &s1) < 0) {
-               fprintf(stderr, "mv: cannot access %s\n", argv[1]);
-               return(1);
+       /*
+        * If the stat on the target fails or the target isn't a directory,
+        * try the move.  More than 2 arguments is an error in this case.
+        */
+       if (stat(argv[argc - 1], &sb) || !S_ISDIR(sb.st_mode)) {
+               if (argc > 2)
+                       usage();
+               exit(do_move(argv[0], argv[1]));

        }
        }

-       if ((s1.st_mode & S_IFMT) == S_IFDIR) {
-               if (argc != 3)
-                       goto usage;
-               return mvdir(argv[1], argv[2]);
-       }
-       setuid(getuid());
-       if (argc > 3)
-               if (stat(argv[argc-1], &s2) < 0 || (s2.st_mode & S_IFMT) != S_IFDIR)
-                       goto usage;
-       r = 0;
-       for (i=1; i<argc-1; i++)
-               r |= move(argv[i], argv[argc-1]);
-       return(r);
-usage:
-       fprintf(stderr, "usage: mv [-if] f1 f2; or mv [-if] d1 d2; or mv [-if] f1 ... fn d1\n");
-       return(1);
-}
-
-move(source, target)
-char *source, *target;
-{
-       register c, i;
-       int     status;
-       char    buf[MAXN];

 
 

-       if (stat(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);
-       }
-       if (stat(target, &s2) >= 0) {
-               if ((s2.st_mode & S_IFMT) == S_IFDIR) {
-                       sprintf(buf, "%s/%s", target, dname(source));
-                       target = buf;
-               }
-               if (stat(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);
-                       }
+       /* It's a directory, move each file into it. */
+       (void)strcpy(path, argv[argc - 1]);
+       baselen = strlen(path);
+       endp = &path[baselen];
+       *endp++ = '/';
+       ++baselen;
+       for (exitval = 0; --argc; ++argv) {
+               if ((p = rindex(*argv, '/')) == NULL)
+                       p = *argv;
+               else
+                       ++p;
+               if ((baselen + (len = strlen(p))) >= MAXPATHLEN)
+                       (void)fprintf(stderr,
+                           "mv: %s: destination pathname too long\n", *argv);
+               else {
+                       bcopy(p, endp, len + 1);
+                       exitval |= do_move(*argv, path);

                }
        }
                }
        }

-       if (link(source, target) < 0) {
-               i = fork();
-               if (i == -1) {
-                       fprintf(stderr, "mv: try again\n");
-                       return(1);
-               }
-               if (i == 0) {
-                       execl("/bin/cp", "cp", source, target, 0);
-                       fprintf(stderr, "mv: cannot exec cp\n");
-                       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);
+       exit(exitval);

 }
 
 }
 

-mvdir(source, target)
-char *source, *target;
+do_move(from, to)
+       char *from, *to;

 {
 {

-       register char *p;
-       register i;
-       char buf[MAXN];
-       char c,cc;
+       struct stat sb;
+       int ask, ch;

 
 

-       if (stat(target, &s2) >= 0) {
-               if ((s2.st_mode&S_IFMT) != S_IFDIR) {
-                       fprintf(stderr, "mv: %s exists\n", target);
-                       return(1);
+       /*
+        * Check access.  If interactive and file exists, ask user if it
+        * should be replaced.  Otherwise if file exists but isn't writable
+        * make sure the user wants to clobber it.
+        */
+       if (!fflg && !access(to, F_OK)) {
+               ask = 0;
+               if (iflg) {
+                       (void)fprintf(stderr, "overwrite %s? ", to);
+                       ask = 1;

                }
                }

-               p = dname(source);
-               if (strlen(target) > MAXN-strlen(p)-2) {
-                       fprintf(stderr, "mv :target name too long\n");
-                       return(1);
+               else if (access(to, W_OK) && !stat(to, &sb)) {
+                       (void)fprintf(stderr, "override mode %o on %s? ",
+                           sb.st_mode & 07777, to);
+                       ask = 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 (ask) {
+                       if ((ch = getchar()) != EOF && ch != '\n')
+                               while (getchar() != '\n');
+                       if (ch != 'y')
+                               return(0);

                }
        }
                }
        }

-       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);
+       if (!rename(from, to))
+               return(0);
+
+       if (errno != EXDEV) {
+               (void)fprintf(stderr,
+                   "mv: rename %s to %s: %s\n", from, to, strerror(errno));

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

-       if (stat(pname(source), &s1) < 0 || stat(pname(target), &s2) < 0) {
-               fprintf(stderr, "mv: cannot locate parent\n");
+
+       /*
+        * If rename fails, and it's a regular file, do the copy internally;
+        * otherwise, use cp and rm.
+        */
+       if (stat(from, &sb)) {
+               (void)fprintf(stderr, "mv: %s: %s\n", from, strerror(errno));

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

-       if (access(pname(target), 2) < 0) {
-               fprintf(stderr, "mv: no write access to %s\n", pname(target));
+       return(S_ISREG(sb.st_mode) ?
+           fastcopy(from, to, &sb) : copy(from, to));
+}
+
+fastcopy(from, to, sbp)
+       char *from, *to;
+       struct stat *sbp;
+{
+       struct timeval tval[2];
+       static u_int blen;
+       static char *bp;
+       register int nread, from_fd, to_fd;
+
+       if ((from_fd = open(from, O_RDONLY, 0)) < 0) {
+               error(from);

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

-       if (access(pname(source), 2) < 0) {
-               fprintf(stderr, "mv: no write access to %s\n", pname(source));
+       if ((to_fd = open(to, O_CREAT|O_TRUNC|O_WRONLY, sbp->st_mode)) < 0) {
+               error(to);
+               (void)close(from_fd);

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

-       if (s1.st_dev != s2.st_dev) {
-               fprintf(stderr, "mv: cannot move directories across devices\n");
+       if (!blen && !(bp = malloc(blen = sbp->st_blksize))) {
+               error(NULL);

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

-       if (s1.st_ino != s2.st_ino) {
-               char dst[MAXN+5];
-
-               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);
+       while ((nread = read(from_fd, bp, blen)) > 0)
+               if (write(to_fd, bp, nread) != nread) {
+                       error(to);
+                       goto err;

                }
                }

-               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);
-       }
-       if (unlink(source) < 0) {
-               fprintf(stderr, "mv: ?? cannot unlink %s\n", source);
+       if (nread < 0) {
+               error(from);
+err:           (void)unlink(to);
+               (void)close(from_fd);
+               (void)close(to_fd);

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

-       return(0);
-}
+       (void)fchown(to_fd, sbp->st_uid, sbp->st_gid);
+       (void)fchmod(to_fd, sbp->st_mode);

 
 

-char *
-pname(name)
-register char *name;
-{
-       register c;
-       register char *p, *q;
-       static  char buf[MAXN];
+       (void)close(from_fd);
+       (void)close(to_fd);

 
 

-       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;
+       tval[0].tv_sec = sbp->st_atime;
+       tval[1].tv_sec = sbp->st_mtime;
+       tval[0].tv_usec = tval[1].tv_usec = 0;
+       (void)utimes(to, tval);
+       (void)unlink(from);
+       return(0);

 }
 
 }
 

-char *
-dname(name)
-register char *name;
+copy(from, to)
+       char *from, *to;

 {
 {

-       register char *p;
+       int pid, status;

 
 

-       p = name;
-       while (*p)
-               if (*p++ == DELIM && *p)
-                       name = p;
-       return name;
+       if (!(pid = vfork())) {
+               execl(_PATH_CP, "mv", "-pr", from, to, NULL);
+               error(_PATH_CP);
+               _exit(1);
+       }
+       (void)waitpid(pid, &status, 0);
+       if (!WIFEXITED(status) || WEXITSTATUS(status))
+               return(1);
+       if (!(pid = vfork())) {
+               execl(_PATH_RM, "mv", "-rf", from, NULL);
+               error(_PATH_RM);
+               _exit(1);
+       }
+       (void)waitpid(pid, &status, 0);
+       return(!WIFEXITED(status) || WEXITSTATUS(status));

 }
 
 }
 

-check(spth, dinode)
-char *spth;
-ino_t dinode;
+error(s)
+       char *s;

 {
 {

-       char nspth[MAXN];
-       struct stat sbuf;
-
-       sbuf.st_ino = 0;
-
-       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);
+       if (s)
+               (void)fprintf(stderr, "mv: %s: %s\n", s, strerror(errno));
+       else
+               (void)fprintf(stderr, "mv: %s\n", strerror(errno));

 }
 
 }
 

-chkdot(s)
-register char *s;
+usage()

 {
 {

-       do {
-               if (strcmp(dname(s), DOTDOT) == 0)
-                       return(1);
-               s = pname(s);
-       } while (strcmp(s, DOT) != 0 && strcmp(s, SDELIM) != 0);
-       return(0);
+       (void)fprintf(stderr,
+"usage: mv [-if] src target;\n   or: mv [-if] src1 ... srcN directory\n");
+       exit(1);

 }
 }