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