Home | History | Annotate | Line # | Download | only in cp
utils.c revision 1.27 
      1 /* $NetBSD: utils.c,v 1.27 2004/01/04 16:04:18 jschauma 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.27 2004/01/04 16:04:18 jschauma 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 			p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
    145 			    MAP_FILE|MAP_SHARED, from_fd, (off_t)0);
    146 			if (p == MAP_FAILED) {
    147 				goto mmap_failed;
    148 			} else {
    149 				(void) madvise(p, (size_t)fs->st_size,
    150 				     MADV_SEQUENTIAL);
    151 				if (write(to_fd, p, fs->st_size) !=
    152 				    fs->st_size) {
    153 					warn("%s", to.p_path);
    154 					rval = 1;
    155 				}
    156 				if (munmap(p, fs->st_size) < 0) {
    157 					warn("%s", entp->fts_path);
    158 					rval = 1;
    159 				}
    160 			}
    161 		} else {
    162 mmap_failed:
    163 			while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
    164 				wcount = write(to_fd, buf, rcount);
    165 				if (rcount != wcount || wcount == -1) {
    166 					warn("%s", to.p_path);
    167 					rval = 1;
    168 					break;
    169 				}
    170 			}
    171 			if (rcount < 0) {
    172 				warn("%s", entp->fts_path);
    173 				rval = 1;
    174 			}
    175 		}
    176 	}
    177 
    178 	if (rval == 1) {
    179 		(void)close(from_fd);
    180 		(void)close(to_fd);
    181 		return (1);
    182 	}
    183 
    184 	if (pflag && setfile(fs, to_fd))
    185 		rval = 1;
    186 	/*
    187 	 * If the source was setuid or setgid, lose the bits unless the
    188 	 * copy is owned by the same user and group.
    189 	 */
    190 #define	RETAINBITS \
    191 	(S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
    192 	else if (fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {
    193 		if (fstat(to_fd, &to_stat)) {
    194 			warn("%s", to.p_path);
    195 			rval = 1;
    196 		} else if (fs->st_gid == to_stat.st_gid &&
    197 		    fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {
    198 			warn("%s", to.p_path);
    199 			rval = 1;
    200 		}
    201 	}
    202 	(void)close(from_fd);
    203 	if (close(to_fd)) {
    204 		warn("%s", to.p_path);
    205 		rval = 1;
    206 	}
    207 	/* set the mod/access times now after close of the fd */
    208 	if (pflag && set_utimes(to.p_path, fs)) {
    209 	    rval = 1;
    210 	}
    211 	return (rval);
    212 }
    213 
    214 int
    215 copy_link(FTSENT *p, int exists)
    216 {
    217 	int len;
    218 	char target[MAXPATHLEN];
    219 
    220 	if ((len = readlink(p->fts_path, target, sizeof(target)-1)) == -1) {
    221 		warn("readlink: %s", p->fts_path);
    222 		return (1);
    223 	}
    224 	target[len] = '\0';
    225 	if (exists && unlink(to.p_path)) {
    226 		warn("unlink: %s", to.p_path);
    227 		return (1);
    228 	}
    229 	if (symlink(target, to.p_path)) {
    230 		warn("symlink: %s", target);
    231 		return (1);
    232 	}
    233 	return (pflag ? setfile(p->fts_statp, 0) : 0);
    234 }
    235 
    236 int
    237 copy_fifo(struct stat *from_stat, int exists)
    238 {
    239 	if (exists && unlink(to.p_path)) {
    240 		warn("unlink: %s", to.p_path);
    241 		return (1);
    242 	}
    243 	if (mkfifo(to.p_path, from_stat->st_mode)) {
    244 		warn("mkfifo: %s", to.p_path);
    245 		return (1);
    246 	}
    247 	return (pflag ? setfile(from_stat, 0) : 0);
    248 }
    249 
    250 int
    251 copy_special(struct stat *from_stat, int exists)
    252 {
    253 	if (exists && unlink(to.p_path)) {
    254 		warn("unlink: %s", to.p_path);
    255 		return (1);
    256 	}
    257 	if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
    258 		warn("mknod: %s", to.p_path);
    259 		return (1);
    260 	}
    261 	return (pflag ? setfile(from_stat, 0) : 0);
    262 }
    263 
    264 
    265 /*
    266  * Function: setfile
    267  *
    268  * Purpose:
    269  *   Set the owner/group/permissions for the "to" file to the information
    270  *   in the stat structure.  If fd is zero, also call set_utimes() to set
    271  *   the mod/access times.  If fd is non-zero, the caller must do a utimes
    272  *   itself after close(fd).
    273  */
    274 int
    275 setfile(struct stat *fs, int fd)
    276 {
    277 	int rval, islink;
    278 
    279 	rval = 0;
    280 	islink = S_ISLNK(fs->st_mode);
    281 	fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
    282 
    283 	/*
    284 	 * Changing the ownership probably won't succeed, unless we're root
    285 	 * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
    286 	 * the mode; current BSD behavior is to remove all setuid bits on
    287 	 * chown.  If chown fails, lose setuid/setgid bits.
    288 	 */
    289 	if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
    290 	    lchown(to.p_path, fs->st_uid, fs->st_gid)) {
    291 		if (errno != EPERM) {
    292 			warn("chown: %s", to.p_path);
    293 			rval = 1;
    294 		}
    295 		fs->st_mode &= ~(S_ISUID | S_ISGID);
    296 	}
    297 	if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {
    298 		warn("chmod: %s", to.p_path);
    299 		rval = 1;
    300 	}
    301 
    302 	if (!islink) {
    303 		/*
    304 		 * XXX
    305 		 * NFS doesn't support chflags; ignore errors unless
    306 		 * there's reason to believe we're losing bits.
    307 		 * (Note, this still won't be right if the server
    308 		 * supports flags and we were trying to *remove* flags
    309 		 * on a file that we copied, i.e., that we didn't create.)
    310 		 */
    311 		errno = 0;
    312 		if (fd ? fchflags(fd, fs->st_flags) :
    313 		    chflags(to.p_path, fs->st_flags))
    314 			if (errno != EOPNOTSUPP || fs->st_flags != 0) {
    315 				warn("chflags: %s", to.p_path);
    316 				rval = 1;
    317 			}
    318 	}
    319 	/* if fd is non-zero, caller must call set_utimes() after close() */
    320 	if (fd == 0 && set_utimes(to.p_path, fs))
    321 	    rval = 1;
    322 	return (rval);
    323 }
    324 
    325 void
    326 usage(void)
    327 {
    328 	(void)fprintf(stderr,
    329 	    "usage: %s [-R [-H | -L | -P]] [-f | -i] [-pv] src target\n"
    330 	    "       %s [-R [-H | -L | -P]] [-f | -i] [-pv] src1 ... srcN directory\n",
    331 	    getprogname(), getprogname());
    332 	exit(1);
    333 	/* NOTREACHED */
    334 }
    335