[apple/file_cmds.git] / cp / utils.c

/*-
 * Copyright (c) 1991, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 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.
 */

#ifndef lint
#if 0
static char sccsid[] = "@(#)utils.c	8.3 (Berkeley) 4/1/94";
#endif
#endif /* not lint */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/bin/cp/utils.c,v 1.46 2005/09/05 04:36:08 csjp Exp $");

#include <sys/types.h>
#include <sys/acl.h>
#include <sys/param.h>
#include <sys/stat.h>
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
#include <sys/mman.h>
#endif

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <fts.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <unistd.h>

#ifdef __APPLE__
#include <sys/time.h>
#include <copyfile.h>
#include <string.h>
#include <sys/mount.h>
#include <get_compat.h> 
#else 
#define COMPAT_MODE(a,b) (1)
#endif /* __APPLE__ */

#include "extern.h"
#define	cp_pct(x,y)	(int)(100.0 * (double)(x) / (double)(y))

int
copy_file(const FTSENT *entp, int dne)
{
	static char buf[MAXBSIZE];
	struct stat *fs;
	int ch, checkch, from_fd, rval, to_fd;
	ssize_t rcount;
	ssize_t wcount;
	size_t wresid;
	off_t wtotal;
	char *bufp;
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
	char *p;
#endif
	mode_t mode = 0;
	struct stat to_stat;

	if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
		warn("%s", entp->fts_path);
		return (1);
	}

	fs = entp->fts_statp;

	/*
	 * If the file exists and we're interactive, verify with the user.
	 * If the file DNE, set the mode to be the from file, minus setuid
	 * bits, modified by the umask; arguably wrong, but it makes copying
	 * executables work right and it's been that way forever.  (The
	 * other choice is 666 or'ed with the execute bits on the from file
	 * modified by the umask.)
	 */
	if (!dne) {
#define YESNO "(y/n [n]) "
		if (nflag) {
			if (vflag)
				printf("%s not overwritten\n", to.p_path);
			(void)close(from_fd);
			return (1);
		} else if (iflag) {
			(void)fprintf(stderr, "overwrite %s? %s", 
					to.p_path, YESNO);
			checkch = ch = getchar();
			while (ch != '\n' && ch != EOF)
				ch = getchar();
			if (checkch != 'y' && checkch != 'Y') {
				(void)close(from_fd);
				(void)fprintf(stderr, "not overwritten\n");
				return (1);
			}
		}
		
		if (COMPAT_MODE("bin/cp", "unix2003")) {
		    /* first try to overwrite existing destination file name */
		    to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
		    if (to_fd == -1) {
			if (fflag) {
			    /* Only if it fails remove file and create a new one */
			    (void)unlink(to.p_path);
			    to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
					 fs->st_mode & ~(S_ISUID | S_ISGID));
			}
		    }
		} else {
			if (fflag) {
			    /* remove existing destination file name, 
			     * create a new file  */
			    (void)unlink(to.p_path);
			    to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
					 fs->st_mode & ~(S_ISUID | S_ISGID));
			} else 
			    /* overwrite existing destination file name */
			    to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
		}
	} else
		to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
		    fs->st_mode & ~(S_ISUID | S_ISGID));

	if (to_fd == -1) {
		warn("%s", to.p_path);
		(void)close(from_fd);
		return (1);
	}

	rval = 0;

#ifdef __APPLE__
       if (S_ISREG(fs->st_mode)) {
               struct statfs sfs;

               /*
                * Pre-allocate blocks for the destination file if it
                * resides on Xsan.
                */
               if (fstatfs(to_fd, &sfs) == 0 &&
                   strcmp(sfs.f_fstypename, "acfs") == 0) {
                       fstore_t fst;

                       fst.fst_flags = 0;
                       fst.fst_posmode = F_PEOFPOSMODE;
                       fst.fst_offset = 0;
                       fst.fst_length = fs->st_size;

                       (void) fcntl(to_fd, F_PREALLOCATE, &fst);
               }
       }
#endif /* __APPLE__ */

       if (fstat(to_fd, &to_stat) != -1) {
	       mode = to_stat.st_mode;
	       if ((mode & (S_IRWXG|S_IRWXO))
		   && fchmod(to_fd, mode & ~(S_IRWXG|S_IRWXO))) {
		       if (errno != EPERM) /* we have write access but do not own the file */
			       warn("%s: fchmod failed", to.p_path);
		       mode = 0;
	       }
       } else {
	       warn("%s", to.p_path);
       }
	/*
	 * Mmap and write if less than 8M (the limit is so we don't totally
	 * trash memory on big files.  This is really a minor hack, but it
	 * wins some CPU back.
	 */
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
	if (S_ISREG(fs->st_mode) && fs->st_size > 0 &&
	    fs->st_size <= 8 * 1048576) {
		if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
		    MAP_SHARED, from_fd, (off_t)0)) == MAP_FAILED) {
			warn("%s", entp->fts_path);
			rval = 1;
		} else {
			wtotal = 0;
			for (bufp = p, wresid = fs->st_size; ;
			    bufp += wcount, wresid -= (size_t)wcount) {
				wcount = write(to_fd, bufp, wresid);
				wtotal += wcount;
				if (info) {
					info = 0;
					(void)fprintf(stderr,
						"%s -> %s %3d%%\n",
						entp->fts_path, to.p_path,
						cp_pct(wtotal, fs->st_size));
						
				}
				if (wcount >= (ssize_t)wresid || wcount <= 0)
					break;
			}
			if (wcount != (ssize_t)wresid) {
				warn("%s", to.p_path);
				rval = 1;
			}
			/* Some systems don't unmap on close(2). */
			if (munmap(p, fs->st_size) < 0) {
				warn("%s", entp->fts_path);
				rval = 1;
			}
		}
	} else
#endif
	{
		wtotal = 0;
		while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
			for (bufp = buf, wresid = rcount; ;
			    bufp += wcount, wresid -= wcount) {
				wcount = write(to_fd, bufp, wresid);
				wtotal += wcount;
				if (info) {
					info = 0;
					(void)fprintf(stderr,
						"%s -> %s %3d%%\n",
						entp->fts_path, to.p_path,
						cp_pct(wtotal, fs->st_size));
						
				}
				if (wcount >= (ssize_t)wresid || wcount <= 0)
					break;
			}
			if (wcount != (ssize_t)wresid) {
				warn("%s", to.p_path);
				rval = 1;
				break;
			}
		}
		if (rcount < 0) {
			warn("%s", entp->fts_path);
			rval = 1;
		}
	}

	/*
	 * Don't remove the target even after an error.  The target might
	 * not be a regular file, or its attributes might be important,
	 * or its contents might be irreplaceable.  It would only be safe
	 * to remove it if we created it and its length is 0.
	 */
	if (mode != 0)
		if (fchmod(to_fd, mode))
			warn("%s: fchmod failed", to.p_path);
#ifdef __APPLE__
	/* do these before setfile in case copyfile changes mtime */
	if (!Xflag && S_ISREG(fs->st_mode)) { /* skip devices, etc */
		if (fcopyfile(from_fd, to_fd, NULL, COPYFILE_XATTR) < 0)
			warn("%s: could not copy extended attributes to %s", entp->fts_path, to.p_path);
	}
	if (pflag && setfile(fs, to_fd))
		rval = 1;
	if (pflag) {
		/* If this ACL denies writeattr then setfile will fail... */
		if (fcopyfile(from_fd, to_fd, NULL, COPYFILE_ACL) < 0)
			warn("%s: could not copy ACL to %s", entp->fts_path, to.p_path);
	}
#else  /* !__APPLE__ */
	if (pflag && setfile(fs, to_fd))
		rval = 1;
	if (pflag && preserve_fd_acls(from_fd, to_fd) != 0)
		rval = 1;
#endif /* __APPLE__ */
	(void)close(from_fd);
	if (close(to_fd)) {
		warn("%s", to.p_path);
		rval = 1;
	}
	return (rval);
}

int
copy_link(const FTSENT *p, int exists)
{
	ssize_t len;
	char llink[PATH_MAX];

	if ((len = readlink(p->fts_path, llink, sizeof(llink) - 1)) == -1) {
		warn("readlink: %s", p->fts_path);
		return (1);
	}
	llink[len] = '\0';
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (symlink(llink, to.p_path)) {
		warn("symlink: %s", llink);
		return (1);
	}
#ifdef __APPLE__
	if (!Xflag)
		if (copyfile(p->fts_path, to.p_path, NULL, COPYFILE_XATTR | COPYFILE_NOFOLLOW_SRC) <0)
			warn("%s: could not copy extended attributes to %s",
			     p->fts_path, to.p_path);
#endif
	return (pflag ? setfile(p->fts_statp, -1) : 0);
}

int
copy_fifo(struct stat *from_stat, int exists)
{
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (mkfifo(to.p_path, from_stat->st_mode)) {
		warn("mkfifo: %s", to.p_path);
		return (1);
	}
	return (pflag ? setfile(from_stat, -1) : 0);
}

int
copy_special(struct stat *from_stat, int exists)
{
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
		warn("mknod: %s", to.p_path);
		return (1);
	}
	return (pflag ? setfile(from_stat, -1) : 0);
}

int
setfile(struct stat *fs, int fd)
{
	static struct timeval tv[2];
	struct stat ts;
	int rval, gotstat, islink, fdval;

	rval = 0;
	fdval = fd != -1;
	islink = !fdval && S_ISLNK(fs->st_mode);
	fs->st_mode &= S_ISUID | S_ISGID | S_ISVTX |
		       S_IRWXU | S_IRWXG | S_IRWXO;

	TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);
	TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);
#ifdef __APPLE__
	if (islink ? 0 : utimes(to.p_path, tv)) {
#else
	if (islink ? lutimes(to.p_path, tv) : utimes(to.p_path, tv)) {
#endif /* __APPLE__ */
		warn("%sutimes: %s", islink ? "l" : "", to.p_path);
		rval = 1;
	}
	if (fdval ? fstat(fd, &ts) :
	    (islink ? lstat(to.p_path, &ts) : stat(to.p_path, &ts)))
		gotstat = 0;
	else {
		gotstat = 1;
		ts.st_mode &= S_ISUID | S_ISGID | S_ISVTX |
			      S_IRWXU | S_IRWXG | S_IRWXO;
	}
	/*
	 * Changing the ownership probably won't succeed, unless we're root
	 * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
	 * the mode; current BSD behavior is to remove all setuid bits on
	 * chown.  If chown fails, lose setuid/setgid bits.
	 */
	if (!gotstat || fs->st_uid != ts.st_uid || fs->st_gid != ts.st_gid)
		if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) :
		    (islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) :
		    chown(to.p_path, fs->st_uid, fs->st_gid))) {
			if (errno != EPERM) {
				warn("%schown: %s", islink ? "l" : "", to.p_path);
				rval = 1;
			}
			fs->st_mode &= ~(S_ISUID | S_ISGID);
		}

	if (!gotstat || fs->st_mode != ts.st_mode)
		if (fdval ? fchmod(fd, fs->st_mode) :
		    (islink ? lchmod(to.p_path, fs->st_mode) :
		    chmod(to.p_path, fs->st_mode))) {
			warn("%schmod: %s", islink ? "l" : "", to.p_path);
			rval = 1;
		}

	if (!gotstat || fs->st_flags != ts.st_flags)
		if (fdval ?
		    fchflags(fd, fs->st_flags) :
		    (islink ? lchflags(to.p_path, fs->st_flags) :
		    chflags(to.p_path, fs->st_flags))) {
			warn("%schflags: %s", islink ? "l" : "", to.p_path);
			rval = 1;
		}

	return (rval);
}

#ifndef __APPLE__
int
preserve_fd_acls(int source_fd, int dest_fd)
{
	struct acl *aclp;
	acl_t acl;

	if (fpathconf(source_fd, _PC_ACL_EXTENDED) != 1 ||
	    fpathconf(dest_fd, _PC_ACL_EXTENDED) != 1)
		return (0);
	acl = acl_get_fd(source_fd);
	if (acl == NULL) {
		warn("failed to get acl entries while setting %s", to.p_path);
		return (1);
	}
	aclp = &acl->ats_acl;
	if (aclp->acl_cnt == 3)
		return (0);
	if (acl_set_fd(dest_fd, acl) < 0) {
		warn("failed to set acl entries for %s", to.p_path);
		return (1);
	}
	return (0);
}

int
preserve_dir_acls(struct stat *fs, char *source_dir, char *dest_dir)
{
	acl_t (*aclgetf)(const char *, acl_type_t);
	int (*aclsetf)(const char *, acl_type_t, acl_t);
	struct acl *aclp;
	acl_t acl;

	if (pathconf(source_dir, _PC_ACL_EXTENDED) != 1 ||
	    pathconf(dest_dir, _PC_ACL_EXTENDED) != 1)
		return (0);
	/*
	 * If the file is a link we will not follow it
	 */
	if (S_ISLNK(fs->st_mode)) {
		aclgetf = acl_get_link_np;
		aclsetf = acl_set_link_np;
	} else {
		aclgetf = acl_get_file;
		aclsetf = acl_set_file;
	}
	/*
	 * Even if there is no ACL_TYPE_DEFAULT entry here, a zero
	 * size ACL will be returned. So it is not safe to simply
	 * check the pointer to see if the default ACL is present.
	 */
	acl = aclgetf(source_dir, ACL_TYPE_DEFAULT);
	if (acl == NULL) {
		warn("failed to get default acl entries on %s",
		    source_dir);
		return (1);
	}
	aclp = &acl->ats_acl;
	if (aclp->acl_cnt != 0 && aclsetf(dest_dir,
	    ACL_TYPE_DEFAULT, acl) < 0) {
		warn("failed to set default acl entries on %s",
		    dest_dir);
		return (1);
	}
	acl = aclgetf(source_dir, ACL_TYPE_ACCESS);
	if (acl == NULL) {
		warn("failed to get acl entries on %s", source_dir);
		return (1);
	}
	aclp = &acl->ats_acl;
	if (aclsetf(dest_dir, ACL_TYPE_ACCESS, acl) < 0) {
		warn("failed to set acl entries on %s", dest_dir);
		return (1);
	}
	return (0);
}
#endif /* !__APPLE__ */

void
usage(void)
{

	if (COMPAT_MODE("bin/cp", "unix2003")) {
	(void)fprintf(stderr, "%s\n%s\n",
"usage: cp [-R [-H | -L | -P]] [-fi | -n] [-apvX] source_file target_file",
"       cp [-R [-H | -L | -P]] [-fi | -n] [-apvX] source_file ... "
"target_directory");
	} else {
	(void)fprintf(stderr, "%s\n%s\n",
"usage: cp [-R [-H | -L | -P]] [-f | -i | -n] [-apvX] source_file target_file",
"       cp [-R [-H | -L | -P]] [-f | -i | -n] [-apvX] source_file ... "
"target_directory");
	}
	exit(EX_USAGE);
}
Commit	Line	Data
44a7a5ab A	1	/*-
	2	* Copyright (c) 1991, 1993, 1994
	3	* The Regents of the University of California. All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
44a7a5ab A	13	* 4. Neither the name of the University nor the names of its contributors
	14	* may be used to endorse or promote products derived from this software
	15	* without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	27	* SUCH DAMAGE.
	28	*/
	29
44a7a5ab A	30	#ifndef lint
	31	#if 0
	32	static char sccsid[] = "@(#)utils.c 8.3 (Berkeley) 4/1/94";
44a7a5ab A	33	#endif
44a7a5ab A	34	#endif /* not lint */
6c780a1f	35	#include <sys/cdefs.h>
864a4b6e	36	__FBSDID("$FreeBSD: src/bin/cp/utils.c,v 1.46 2005/09/05 04:36:08 csjp Exp $");
44a7a5ab	37
864a4b6e A	38	#include <sys/types.h>
864a4b6e A	39	#include <sys/acl.h>
44a7a5ab A	40	#include <sys/param.h>
44a7a5ab A	41	#include <sys/stat.h>
6c780a1f	42	#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
44a7a5ab	43	#include <sys/mman.h>
6c780a1f	44	#endif
44a7a5ab A	45
	46	#include <err.h>
	47	#include <errno.h>
	48	#include <fcntl.h>
	49	#include <fts.h>
6c780a1f	50	#include <limits.h>
44a7a5ab A	51	#include <stdio.h>
44a7a5ab A	52	#include <stdlib.h>
6c780a1f	53	#include <sysexits.h>
44a7a5ab A	54	#include <unistd.h>
44a7a5ab A	55
c59d3020	56	#ifdef __APPLE__
864a4b6e	57	#include <sys/time.h>
c59d3020	58	#include <copyfile.h>
52f52064 A	59	#include <string.h>
52f52064 A	60	#include <sys/mount.h>
864a4b6e A	61	#include <get_compat.h>
	62	#else
	63	#define COMPAT_MODE(a,b) (1)
	64	#endif /* __APPLE__ */
c59d3020	65
44a7a5ab	66	#include "extern.h"
864a4b6e	67	#define cp_pct(x,y) (int)(100.0 * (double)(x) / (double)(y))
44a7a5ab A	68
44a7a5ab A	69	int
864a4b6e	70	copy_file(const FTSENT *entp, int dne)
44a7a5ab A	71	{
44a7a5ab A	72	static char buf[MAXBSIZE];
6c780a1f	73	struct stat *fs;
4d0bb651 A	74	int ch, checkch, from_fd, rval, to_fd;
4d0bb651 A	75	ssize_t rcount;
6c780a1f A	76	ssize_t wcount;
6c780a1f A	77	size_t wresid;
864a4b6e	78	off_t wtotal;
6c780a1f	79	char *bufp;
44a7a5ab A	80	#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
	81	char *p;
	82	#endif
64d2f73f A	83	mode_t mode = 0;
64d2f73f A	84	struct stat to_stat;
6c780a1f	85
44a7a5ab A	86	if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
	87	warn("%s", entp->fts_path);
	88	return (1);
	89	}
	90
	91	fs = entp->fts_statp;
	92
	93	/*
	94	* If the file exists and we're interactive, verify with the user.
	95	* If the file DNE, set the mode to be the from file, minus setuid
	96	* bits, modified by the umask; arguably wrong, but it makes copying
	97	* executables work right and it's been that way forever. (The
	98	* other choice is 666 or'ed with the execute bits on the from file
	99	* modified by the umask.)
	100	*/
	101	if (!dne) {
6c780a1f A	102	#define YESNO "(y/n [n]) "
	103	if (nflag) {
	104	if (vflag)
	105	printf("%s not overwritten\n", to.p_path);
864a4b6e A	106	(void)close(from_fd);
864a4b6e A	107	return (1);
6c780a1f A	108	} else if (iflag) {
	109	(void)fprintf(stderr, "overwrite %s? %s",
	110	to.p_path, YESNO);
44a7a5ab A	111	checkch = ch = getchar();
	112	while (ch != '\n' && ch != EOF)
	113	ch = getchar();
	114	if (checkch != 'y' && checkch != 'Y') {
	115	(void)close(from_fd);
6c780a1f A	116	(void)fprintf(stderr, "not overwritten\n");
6c780a1f A	117	return (1);
44a7a5ab A	118	}
44a7a5ab A	119	}
6c780a1f	120
864a4b6e A	121	if (COMPAT_MODE("bin/cp", "unix2003")) {
864a4b6e A	122	/* first try to overwrite existing destination file name */
6c780a1f	123	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC, 0);
864a4b6e A	124	if (to_fd == -1) {
	125	if (fflag) {
	126	/* Only if it fails remove file and create a new one */
	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	} else {
	133	if (fflag) {
	134	/* remove existing destination file name,
	135	* create a new file */
	136	(void)unlink(to.p_path);
	137	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC \| O_CREAT,
	138	fs->st_mode & ~(S_ISUID \| S_ISGID));
	139	} else
	140	/* overwrite existing destination file name */
	141	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC, 0);
	142	}
44a7a5ab A	143	} else
	144	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC \| O_CREAT,
	145	fs->st_mode & ~(S_ISUID \| S_ISGID));
	146
44a7a5ab A	147	if (to_fd == -1) {
	148	warn("%s", to.p_path);
	149	(void)close(from_fd);
6c780a1f	150	return (1);
44a7a5ab A	151	}
	152
	153	rval = 0;
	154
52f52064	155	#ifdef __APPLE__
864a4b6e A	156	if (S_ISREG(fs->st_mode)) {
	157	struct statfs sfs;
	158
	159	/*
	160	* Pre-allocate blocks for the destination file if it
	161	* resides on Xsan.
	162	*/
	163	if (fstatfs(to_fd, &sfs) == 0 &&
	164	strcmp(sfs.f_fstypename, "acfs") == 0) {
	165	fstore_t fst;
	166
	167	fst.fst_flags = 0;
	168	fst.fst_posmode = F_PEOFPOSMODE;
	169	fst.fst_offset = 0;
	170	fst.fst_length = fs->st_size;
	171
	172	(void) fcntl(to_fd, F_PREALLOCATE, &fst);
	173	}
	174	}
52f52064 A	175	#endif /* __APPLE__ */
52f52064 A	176
64d2f73f A	177	if (fstat(to_fd, &to_stat) != -1) {
	178	mode = to_stat.st_mode;
	179	if ((mode & (S_IRWXG\|S_IRWXO))
	180	&& fchmod(to_fd, mode & ~(S_IRWXG\|S_IRWXO))) {
40bf83fe A	181	if (errno != EPERM) /* we have write access but do not own the file */
40bf83fe A	182	warn("%s: fchmod failed", to.p_path);
64d2f73f A	183	mode = 0;
	184	}
	185	} else {
	186	warn("%s", to.p_path);
	187	}
44a7a5ab	188	/*
6c780a1f A	189	* Mmap and write if less than 8M (the limit is so we don't totally
	190	* trash memory on big files. This is really a minor hack, but it
	191	* wins some CPU back.
44a7a5ab	192	*/
44a7a5ab	193	#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
864a4b6e A	194	if (S_ISREG(fs->st_mode) && fs->st_size > 0 &&
864a4b6e A	195	fs->st_size <= 8 * 1048576) {
6c780a1f A	196	if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
	197	MAP_SHARED, from_fd, (off_t)0)) == MAP_FAILED) {
	198	warn("%s", entp->fts_path);
	199	rval = 1;
	200	} else {
864a4b6e	201	wtotal = 0;
6c780a1f A	202	for (bufp = p, wresid = fs->st_size; ;
	203	bufp += wcount, wresid -= (size_t)wcount) {
	204	wcount = write(to_fd, bufp, wresid);
864a4b6e A	205	wtotal += wcount;
	206	if (info) {
	207	info = 0;
	208	(void)fprintf(stderr,
	209	"%s -> %s %3d%%\n",
	210	entp->fts_path, to.p_path,
	211	cp_pct(wtotal, fs->st_size));
	212
	213	}
6c780a1f A	214	if (wcount >= (ssize_t)wresid \|\| wcount <= 0)
	215	break;
	216	}
	217	if (wcount != (ssize_t)wresid) {
	218	warn("%s", to.p_path);
	219	rval = 1;
	220	}
	221	/* Some systems don't unmap on close(2). */
	222	if (munmap(p, fs->st_size) < 0) {
44a7a5ab A	223	warn("%s", entp->fts_path);
44a7a5ab A	224	rval = 1;
44a7a5ab	225	}
6c780a1f A	226	}
6c780a1f A	227	} else
44a7a5ab	228	#endif
6c780a1f	229	{
864a4b6e	230	wtotal = 0;
6c780a1f A	231	while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
	232	for (bufp = buf, wresid = rcount; ;
	233	bufp += wcount, wresid -= wcount) {
	234	wcount = write(to_fd, bufp, wresid);
864a4b6e A	235	wtotal += wcount;
	236	if (info) {
	237	info = 0;
	238	(void)fprintf(stderr,
	239	"%s -> %s %3d%%\n",
	240	entp->fts_path, to.p_path,
	241	cp_pct(wtotal, fs->st_size));
	242
	243	}
6c780a1f	244	if (wcount >= (ssize_t)wresid \|\| wcount <= 0)
44a7a5ab	245	break;
44a7a5ab	246	}
6c780a1f A	247	if (wcount != (ssize_t)wresid) {
6c780a1f A	248	warn("%s", to.p_path);
44a7a5ab	249	rval = 1;
6c780a1f	250	break;
44a7a5ab A	251	}
44a7a5ab A	252	}
6c780a1f A	253	if (rcount < 0) {
	254	warn("%s", entp->fts_path);
	255	rval = 1;
	256	}
44a7a5ab A	257	}
44a7a5ab A	258
6c780a1f A	259	/*
	260	* Don't remove the target even after an error. The target might
	261	* not be a regular file, or its attributes might be important,
	262	* or its contents might be irreplaceable. It would only be safe
	263	* to remove it if we created it and its length is 0.
	264	*/
64d2f73f A	265	if (mode != 0)
	266	if (fchmod(to_fd, mode))
	267	warn("%s: fchmod failed", to.p_path);
864a4b6e A	268	#ifdef __APPLE__
	269	/* do these before setfile in case copyfile changes mtime */
	270	if (!Xflag && S_ISREG(fs->st_mode)) { /* skip devices, etc */
	271	if (fcopyfile(from_fd, to_fd, NULL, COPYFILE_XATTR) < 0)
	272	warn("%s: could not copy extended attributes to %s", entp->fts_path, to.p_path);
	273	}
44a7a5ab A	274	if (pflag && setfile(fs, to_fd))
44a7a5ab A	275	rval = 1;
864a4b6e A	276	if (pflag) {
	277	/* If this ACL denies writeattr then setfile will fail... */
	278	if (fcopyfile(from_fd, to_fd, NULL, COPYFILE_ACL) < 0)
	279	warn("%s: could not copy ACL to %s", entp->fts_path, to.p_path);
	280	}
	281	#else /* !__APPLE__ */
	282	if (pflag && setfile(fs, to_fd))
	283	rval = 1;
	284	if (pflag && preserve_fd_acls(from_fd, to_fd) != 0)
	285	rval = 1;
	286	#endif /* __APPLE__ */
44a7a5ab A	287	(void)close(from_fd);
	288	if (close(to_fd)) {
	289	warn("%s", to.p_path);
	290	rval = 1;
	291	}
44a7a5ab A	292	return (rval);
	293	}
	294
	295	int
864a4b6e	296	copy_link(const FTSENT *p, int exists)
44a7a5ab	297	{
4d0bb651	298	ssize_t len;
6c780a1f	299	char llink[PATH_MAX];
44a7a5ab	300
6c780a1f	301	if ((len = readlink(p->fts_path, llink, sizeof(llink) - 1)) == -1) {
44a7a5ab A	302	warn("readlink: %s", p->fts_path);
	303	return (1);
	304	}
6c780a1f	305	llink[len] = '\0';
44a7a5ab A	306	if (exists && unlink(to.p_path)) {
	307	warn("unlink: %s", to.p_path);
	308	return (1);
	309	}
6c780a1f A	310	if (symlink(llink, to.p_path)) {
6c780a1f A	311	warn("symlink: %s", llink);
44a7a5ab A	312	return (1);
44a7a5ab A	313	}
c59d3020	314	#ifdef __APPLE__
864a4b6e A	315	if (!Xflag)
	316	if (copyfile(p->fts_path, to.p_path, NULL, COPYFILE_XATTR \| COPYFILE_NOFOLLOW_SRC) <0)
	317	warn("%s: could not copy extended attributes to %s",
	318	p->fts_path, to.p_path);
c59d3020	319	#endif
864a4b6e	320	return (pflag ? setfile(p->fts_statp, -1) : 0);
44a7a5ab A	321	}
	322
	323	int
6c780a1f	324	copy_fifo(struct stat *from_stat, int exists)
44a7a5ab A	325	{
	326	if (exists && unlink(to.p_path)) {
	327	warn("unlink: %s", to.p_path);
	328	return (1);
	329	}
	330	if (mkfifo(to.p_path, from_stat->st_mode)) {
	331	warn("mkfifo: %s", to.p_path);
	332	return (1);
	333	}
864a4b6e	334	return (pflag ? setfile(from_stat, -1) : 0);
44a7a5ab A	335	}
	336
	337	int
6c780a1f	338	copy_special(struct stat *from_stat, int exists)
44a7a5ab A	339	{
	340	if (exists && unlink(to.p_path)) {
	341	warn("unlink: %s", to.p_path);
	342	return (1);
	343	}
	344	if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
	345	warn("mknod: %s", to.p_path);
	346	return (1);
	347	}
864a4b6e	348	return (pflag ? setfile(from_stat, -1) : 0);
44a7a5ab A	349	}
44a7a5ab A	350
44a7a5ab	351	int
6c780a1f	352	setfile(struct stat *fs, int fd)
44a7a5ab	353	{
6c780a1f A	354	static struct timeval tv[2];
6c780a1f A	355	struct stat ts;
864a4b6e	356	int rval, gotstat, islink, fdval;
44a7a5ab A	357
44a7a5ab A	358	rval = 0;
864a4b6e A	359	fdval = fd != -1;
864a4b6e A	360	islink = !fdval && S_ISLNK(fs->st_mode);
6c780a1f A	361	fs->st_mode &= S_ISUID \| S_ISGID \| S_ISVTX \|
6c780a1f A	362	S_IRWXU \| S_IRWXG \| S_IRWXO;
44a7a5ab	363
6c780a1f A	364	TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);
6c780a1f A	365	TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);
864a4b6e A	366	#ifdef __APPLE__
	367	if (islink ? 0 : utimes(to.p_path, tv)) {
	368	#else
	369	if (islink ? lutimes(to.p_path, tv) : utimes(to.p_path, tv)) {
	370	#endif /* __APPLE__ */
	371	warn("%sutimes: %s", islink ? "l" : "", to.p_path);
6c780a1f A	372	rval = 1;
6c780a1f A	373	}
864a4b6e A	374	if (fdval ? fstat(fd, &ts) :
864a4b6e A	375	(islink ? lstat(to.p_path, &ts) : stat(to.p_path, &ts)))
6c780a1f A	376	gotstat = 0;
	377	else {
	378	gotstat = 1;
	379	ts.st_mode &= S_ISUID \| S_ISGID \| S_ISVTX \|
	380	S_IRWXU \| S_IRWXG \| S_IRWXO;
	381	}
44a7a5ab A	382	/*
	383	* Changing the ownership probably won't succeed, unless we're root
	384	* or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
	385	* the mode; current BSD behavior is to remove all setuid bits on
	386	* chown. If chown fails, lose setuid/setgid bits.
	387	*/
6c780a1f	388	if (!gotstat \|\| fs->st_uid != ts.st_uid \|\| fs->st_gid != ts.st_gid)
864a4b6e A	389	if (fdval ? fchown(fd, fs->st_uid, fs->st_gid) :
	390	(islink ? lchown(to.p_path, fs->st_uid, fs->st_gid) :
	391	chown(to.p_path, fs->st_uid, fs->st_gid))) {
6c780a1f	392	if (errno != EPERM) {
864a4b6e	393	warn("%schown: %s", islink ? "l" : "", to.p_path);
6c780a1f A	394	rval = 1;
	395	}
	396	fs->st_mode &= ~(S_ISUID \| S_ISGID);
	397	}
	398
	399	if (!gotstat \|\| fs->st_mode != ts.st_mode)
864a4b6e A	400	if (fdval ? fchmod(fd, fs->st_mode) :
	401	(islink ? lchmod(to.p_path, fs->st_mode) :
	402	chmod(to.p_path, fs->st_mode))) {
	403	warn("%schmod: %s", islink ? "l" : "", to.p_path);
6c780a1f A	404	rval = 1;
	405	}
	406
	407	if (!gotstat \|\| fs->st_flags != ts.st_flags)
864a4b6e A	408	if (fdval ?
	409	fchflags(fd, fs->st_flags) :
	410	(islink ? lchflags(to.p_path, fs->st_flags) :
	411	chflags(to.p_path, fs->st_flags))) {
	412	warn("%schflags: %s", islink ? "l" : "", to.p_path);
44a7a5ab A	413	rval = 1;
44a7a5ab A	414	}
44a7a5ab	415
44a7a5ab A	416	return (rval);
	417	}
	418
864a4b6e A	419	#ifndef __APPLE__
	420	int
	421	preserve_fd_acls(int source_fd, int dest_fd)
	422	{
	423	struct acl *aclp;
	424	acl_t acl;
	425
	426	if (fpathconf(source_fd, _PC_ACL_EXTENDED) != 1 \|\|
	427	fpathconf(dest_fd, _PC_ACL_EXTENDED) != 1)
	428	return (0);
	429	acl = acl_get_fd(source_fd);
	430	if (acl == NULL) {
	431	warn("failed to get acl entries while setting %s", to.p_path);
	432	return (1);
	433	}
	434	aclp = &acl->ats_acl;
	435	if (aclp->acl_cnt == 3)
	436	return (0);
	437	if (acl_set_fd(dest_fd, acl) < 0) {
	438	warn("failed to set acl entries for %s", to.p_path);
	439	return (1);
	440	}
	441	return (0);
	442	}
	443
	444	int
	445	preserve_dir_acls(struct stat fs, char source_dir, char *dest_dir)
	446	{
	447	acl_t (aclgetf)(const char , acl_type_t);
	448	int (aclsetf)(const char , acl_type_t, acl_t);
	449	struct acl *aclp;
	450	acl_t acl;
	451
	452	if (pathconf(source_dir, _PC_ACL_EXTENDED) != 1 \|\|
	453	pathconf(dest_dir, _PC_ACL_EXTENDED) != 1)
	454	return (0);
	455	/*
	456	* If the file is a link we will not follow it
	457	*/
	458	if (S_ISLNK(fs->st_mode)) {
	459	aclgetf = acl_get_link_np;
	460	aclsetf = acl_set_link_np;
	461	} else {
	462	aclgetf = acl_get_file;
	463	aclsetf = acl_set_file;
	464	}
	465	/*
	466	* Even if there is no ACL_TYPE_DEFAULT entry here, a zero
	467	* size ACL will be returned. So it is not safe to simply
	468	* check the pointer to see if the default ACL is present.
	469	*/
	470	acl = aclgetf(source_dir, ACL_TYPE_DEFAULT);
	471	if (acl == NULL) {
	472	warn("failed to get default acl entries on %s",
	473	source_dir);
	474	return (1);
	475	}
	476	aclp = &acl->ats_acl;
	477	if (aclp->acl_cnt != 0 && aclsetf(dest_dir,
	478	ACL_TYPE_DEFAULT, acl) < 0) {
	479	warn("failed to set default acl entries on %s",
	480	dest_dir);
	481	return (1);
	482	}
483	acl = aclgetf(source_dir, ACL_TYPE_ACCESS);
484	if (acl == NULL) {
485	warn("failed to get acl entries on %s", source_dir);
486	return (1);
487	}
488	aclp = &acl->ats_acl;
489	if (aclsetf(dest_dir, ACL_TYPE_ACCESS, acl) < 0) {
490	warn("failed to set acl entries on %s", dest_dir);
491	return (1);
492	}
493	return (0);
494	}
495	#endif /* !__APPLE__ */
496
44a7a5ab	497	void
6c780a1f	498	usage(void)
44a7a5ab	499	{
6c780a1f	500
864a4b6e A	501	if (COMPAT_MODE("bin/cp", "unix2003")) {
864a4b6e A	502	(void)fprintf(stderr, "%s\n%s\n",
40bf83fe A	503	"usage: cp [-R [-H \| -L \| -P]] [-fi \| -n] [-apvX] source_file target_file",
40bf83fe A	504	" cp [-R [-H \| -L \| -P]] [-fi \| -n] [-apvX] source_file ... "
864a4b6e A	505	"target_directory");
864a4b6e A	506	} else {
44a7a5ab	507	(void)fprintf(stderr, "%s\n%s\n",
40bf83fe A	508	"usage: cp [-R [-H \| -L \| -P]] [-f \| -i \| -n] [-apvX] source_file target_file",
40bf83fe A	509	" cp [-R [-H \| -L \| -P]] [-f \| -i \| -n] [-apvX] source_file ... "
864a4b6e A	510	"target_directory");
864a4b6e A	511	}
6c780a1f	512	exit(EX_USAGE);
44a7a5ab	513	}