cp/utils.c

   1 /*      $NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $       */
   2
   3 /*-
   4  * Copyright (c) 1991, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 #if 0
  39 static char sccsid[] = "@(#)utils.c     8.3 (Berkeley) 4/1/94";
  40 #else
  41 __RCSID("$NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $");
  42 #endif
  43 #endif /* not lint */
  44
  45 #include <sys/param.h>
  46 #include <sys/stat.h>
  47 #include <sys/mman.h>
  48 #include <sys/time.h>
  49
  50 #include <err.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <fts.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <unistd.h>
  58
  59 #include "extern.h"
  60
  61 int
  62 set_utimes(file, fs)
  63         const char * file;
  64         struct stat * fs;
  65 {
  66     static struct timeval tv[2];
  67
  68     TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);
  69     TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);
  70
  71     if (utimes(file, tv)) {
  72         warn("utimes: %s", file);
  73         return (1);
  74     }
  75     return (0);
  76 }
  77
  78 int
  79 copy_file(entp, dne)
  80         FTSENT *entp;
  81         int dne;
  82 {
  83         static char buf[MAXBSIZE];
  84         struct stat to_stat, *fs;
  85         int ch, checkch, from_fd, rcount, rval, to_fd, wcount;
  86 #ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
  87         char *p;
  88 #endif
  89
  90         if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
  91                 warn("%s", entp->fts_path);
  92                 return (1);
  93         }
  94
  95         fs = entp->fts_statp;
  96
  97         /*
  98          * If the file exists and we're interactive, verify with the user.
  99          * If the file DNE, set the mode to be the from file, minus setuid
 100          * bits, modified by the umask; arguably wrong, but it makes copying
 101          * executables work right and it's been that way forever.  (The
 102          * other choice is 666 or'ed with the execute bits on the from file
 103          * modified by the umask.)
 104          */
 105         if (!dne) {
 106                 if (iflag) {
 107                         (void)fprintf(stderr, "overwrite %s? ", to.p_path);
 108                         checkch = ch = getchar();
 109                         while (ch != '\n' && ch != EOF)
 110                                 ch = getchar();
 111                         if (checkch != 'y' && checkch != 'Y') {
 112                                 (void)close(from_fd);
 113                                 return (0);
 114                         }
 115                 }
 116                 /* overwrite existing destination file name */
 117                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
 118         } else
 119                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 120                     fs->st_mode & ~(S_ISUID | S_ISGID));
 121
 122         if (to_fd == -1 && fflag) {
 123                 /*
 124                  * attempt to remove existing destination file name and
 125                  * create a new file
 126                  */
 127                 (void)unlink(to.p_path);
 128                 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
 129                              fs->st_mode & ~(S_ISUID | S_ISGID));
 130         }
 131
 132         if (to_fd == -1) {
 133                 warn("%s", to.p_path);
 134                 (void)close(from_fd);
 135                 return (1);;
 136         }
 137
 138         rval = 0;
 139
 140         /*
 141          * There's no reason to do anything other than close the file
 142          * now if it's empty, so let's not bother.
 143          */
 144         if (fs->st_size > 0) {
 145                 /*
 146                  * Mmap and write if less than 8M (the limit is so we don't totally
 147                  * trash memory on big files).  This is really a minor hack, but it
 148                  * wins some CPU back.
 149                  */
 150 #ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
 151                 if (fs->st_size <= 8 * 1048576) {
 152                         if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
 153                             MAP_FILE|MAP_SHARED, from_fd, (off_t)0)) == (char *)-1) {
 154                                 warn("%s", entp->fts_path);
 155                                 rval = 1;
 156                         } else {
 157                                 if (write(to_fd, p, fs->st_size) != fs->st_size) {
 158                                         warn("%s", to.p_path);
 159                                         rval = 1;
 160                                 }
 161                                 /* Some systems don't unmap on close(2). */
 162                                 if (munmap(p, fs->st_size) < 0) {
 163                                         warn("%s", entp->fts_path);
 164                                         rval = 1;
 165                                 }
 166                         }
 167                 } else
 168 #endif
 169                 {
 170                         while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
 171                                 wcount = write(to_fd, buf, rcount);
 172                                 if (rcount != wcount || wcount == -1) {
 173                                         warn("%s", to.p_path);
 174                                         rval = 1;
 175                                         break;
 176                                 }
 177                         }
 178                         if (rcount < 0) {
 179                                 warn("%s", entp->fts_path);
 180                                 rval = 1;
 181                         }
 182                 }
 183         }
 184
 185         if (rval == 1) {
 186                 (void)close(from_fd);
 187                 (void)close(to_fd);
 188                 return (1);
 189         }
 190
 191         if (pflag && setfile(fs, to_fd))
 192                 rval = 1;
 193         /*
 194          * If the source was setuid or setgid, lose the bits unless the
 195          * copy is owned by the same user and group.
 196          */
 197 #define RETAINBITS \
 198         (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
 199         else if (fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {
 200                 if (fstat(to_fd, &to_stat)) {
 201                         warn("%s", to.p_path);
 202                         rval = 1;
 203                 } else if (fs->st_gid == to_stat.st_gid &&
 204                     fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {
 205                         warn("%s", to.p_path);
 206                         rval = 1;
 207                 }
 208         }
 209         (void)close(from_fd);
 210         if (close(to_fd)) {
 211                 warn("%s", to.p_path);
 212                 rval = 1;
 213         }
 214         /* set the mod/access times now after close of the fd */
 215         if (pflag && set_utimes(to.p_path, fs)) {
 216             rval = 1;
 217         }
 218         return (rval);
 219 }
 220
 221 int
 222 copy_link(p, exists)
 223         FTSENT *p;
 224         int exists;
 225 {
 226         int len;
 227         char target[MAXPATHLEN];
 228
 229         if ((len = readlink(p->fts_path, target, sizeof(target))) == -1) {
 230                 warn("readlink: %s", p->fts_path);
 231                 return (1);
 232         }
 233         target[len] = '\0';
 234         if (exists && unlink(to.p_path)) {
 235                 warn("unlink: %s", to.p_path);
 236                 return (1);
 237         }
 238         if (symlink(target, to.p_path)) {
 239                 warn("symlink: %s", target);
 240                 return (1);
 241         }
 242         return (pflag ? setfile(p->fts_statp, 0) : 0);
 243 }
 244
 245 int
 246 copy_fifo(from_stat, exists)
 247         struct stat *from_stat;
 248         int exists;
 249 {
 250         if (exists && unlink(to.p_path)) {
 251                 warn("unlink: %s", to.p_path);
 252                 return (1);
 253         }
 254         if (mkfifo(to.p_path, from_stat->st_mode)) {
 255                 warn("mkfifo: %s", to.p_path);
 256                 return (1);
 257         }
 258         return (pflag ? setfile(from_stat, 0) : 0);
 259 }
 260
 261 int
 262 copy_special(from_stat, exists)
 263         struct stat *from_stat;
 264         int exists;
 265 {
 266         if (exists && unlink(to.p_path)) {
 267                 warn("unlink: %s", to.p_path);
 268                 return (1);
 269         }
 270         if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
 271                 warn("mknod: %s", to.p_path);
 272                 return (1);
 273         }
 274         return (pflag ? setfile(from_stat, 0) : 0);
 275 }
 276
 277
 278 /*
 279  * Function: setfile
 280  *
 281  * Purpose:
 282  *   Set the owner/group/permissions for the "to" file to the information
 283  *   in the stat structure.  If fd is zero, also call set_utimes() to set
 284  *   the mod/access times.  If fd is non-zero, the caller must do a utimes
 285  *   itself after close(fd).
 286  */
 287 int
 288 setfile(fs, fd)
 289         struct stat *fs;
 290         int fd;
 291 {
 292         int rval, islink;
 293
 294         rval = 0;
 295         islink = S_ISLNK(fs->st_mode);
 296         fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
 297
 298         /*
 299          * Changing the ownership probably won't succeed, unless we're root
 300          * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
 301          * the mode; current BSD behavior is to remove all setuid bits on
 302          * chown.  If chown fails, lose setuid/setgid bits.
 303          */
 304         if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
 305 #ifdef __APPLE__
 306             chown(to.p_path, fs->st_uid, fs->st_gid)) {
 307 #else
 308             lchown(to.p_path, fs->st_uid, fs->st_gid)) {
 309 #endif
 310                 if (errno != EPERM) {
 311                         warn("chown: %s", to.p_path);
 312                         rval = 1;
 313                 }
 314                 fs->st_mode &= ~(S_ISUID | S_ISGID);
 315         }
 316 #ifdef __APPLE__
 317         if (fd ? fchmod(fd, fs->st_mode) : chmod(to.p_path, fs->st_mode)) {
 318 #else
 319         if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {
 320 #endif
 321                 warn("chmod: %s", to.p_path);
 322                 rval = 1;
 323         }
 324
 325         if (!islink) {
 326                 /*
 327                  * XXX
 328                  * NFS doesn't support chflags; ignore errors unless
 329                  * there's reason to believe we're losing bits.
 330                  * (Note, this still won't be right if the server
 331                  * supports flags and we were trying to *remove* flags
 332                  * on a file that we copied, i.e., that we didn't create.)
 333                  */
 334                 errno = 0;
 335                 if (fd ? fchflags(fd, fs->st_flags) :
 336                     chflags(to.p_path, fs->st_flags))
 337                         if (errno != EOPNOTSUPP || fs->st_flags != 0) {
 338                                 warn("chflags: %s", to.p_path);
 339                                 rval = 1;
 340                         }
 341         }
 342         /* if fd is non-zero, caller must call set_utimes() after close() */
 343         if (fd == 0 && set_utimes(to.p_path, fs))
 344             rval = 1;
 345         return (rval);
 346 }
 347
 348 void
 349 usage()
 350 {
 351         (void)fprintf(stderr, "%s\n%s\n",
 352             "usage: cp [-R [-H | -L | -P]] [-f | -i] [-p] src target",
 353             "       cp [-R [-H | -L | -P]] [-f | -i] [-p] src1 ... srcN directory");
 354         exit(1);
 355         /* NOTREACHED */
 356 }