xref: /illumos-gate/usr/src/cmd/mv/mv.c (revision 6fcd7f75f4dad6a238f1623ce452827399e3a79b)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
594d2b9abSmarks  * Common Development and Distribution License (the "License").
694d2b9abSmarks  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22beab0215Sbasabi  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
277c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate  * University Copyright- Copyright (c) 1982, 1986, 1988
317c478bd9Sstevel@tonic-gate  * The Regents of the University of California
327c478bd9Sstevel@tonic-gate  * All Rights Reserved
337c478bd9Sstevel@tonic-gate  *
347c478bd9Sstevel@tonic-gate  * University Acknowledgment- Portions of this document are derived from
357c478bd9Sstevel@tonic-gate  * software developed by the University of California, Berkeley, and its
367c478bd9Sstevel@tonic-gate  * contributors.
377c478bd9Sstevel@tonic-gate  */
387c478bd9Sstevel@tonic-gate 
397c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
407c478bd9Sstevel@tonic-gate 
417c478bd9Sstevel@tonic-gate /*
427c478bd9Sstevel@tonic-gate  * Combined mv/cp/ln command:
437c478bd9Sstevel@tonic-gate  *	mv file1 file2
447c478bd9Sstevel@tonic-gate  *	mv dir1 dir2
457c478bd9Sstevel@tonic-gate  *	mv file1 ... filen dir1
467c478bd9Sstevel@tonic-gate  */
477c478bd9Sstevel@tonic-gate #include <sys/time.h>
487c478bd9Sstevel@tonic-gate #include <signal.h>
497c478bd9Sstevel@tonic-gate #include <locale.h>
507c478bd9Sstevel@tonic-gate #include <stdarg.h>
517c478bd9Sstevel@tonic-gate #include <sys/acl.h>
527c478bd9Sstevel@tonic-gate #include <libcmdutils.h>
53fa9e4066Sahrens #include <aclutils.h>
543d63ea05Sas #include "getresponse.h"
557c478bd9Sstevel@tonic-gate 
567c478bd9Sstevel@tonic-gate #define	FTYPE(A)	(A.st_mode)
577c478bd9Sstevel@tonic-gate #define	FMODE(A)	(A.st_mode)
587c478bd9Sstevel@tonic-gate #define	UID(A)		(A.st_uid)
597c478bd9Sstevel@tonic-gate #define	GID(A)		(A.st_gid)
607c478bd9Sstevel@tonic-gate #define	IDENTICAL(A, B)	(A.st_dev == B.st_dev && A.st_ino == B.st_ino)
617c478bd9Sstevel@tonic-gate #define	ISBLK(A)	((A.st_mode & S_IFMT) == S_IFBLK)
627c478bd9Sstevel@tonic-gate #define	ISCHR(A)	((A.st_mode & S_IFMT) == S_IFCHR)
637c478bd9Sstevel@tonic-gate #define	ISDIR(A)	((A.st_mode & S_IFMT) == S_IFDIR)
647c478bd9Sstevel@tonic-gate #define	ISDOOR(A)	((A.st_mode & S_IFMT) == S_IFDOOR)
657c478bd9Sstevel@tonic-gate #define	ISFIFO(A)	((A.st_mode & S_IFMT) == S_IFIFO)
667c478bd9Sstevel@tonic-gate #define	ISLNK(A)	((A.st_mode & S_IFMT) == S_IFLNK)
677c478bd9Sstevel@tonic-gate #define	ISREG(A)	(((A).st_mode & S_IFMT) == S_IFREG)
687c478bd9Sstevel@tonic-gate #define	ISDEV(A)	((A.st_mode & S_IFMT) == S_IFCHR || \
697c478bd9Sstevel@tonic-gate 			(A.st_mode & S_IFMT) == S_IFBLK || \
707c478bd9Sstevel@tonic-gate 			(A.st_mode & S_IFMT) == S_IFIFO)
717c478bd9Sstevel@tonic-gate 
727c478bd9Sstevel@tonic-gate #define	BLKSIZE	4096
737c478bd9Sstevel@tonic-gate #define	PATHSIZE 1024
747c478bd9Sstevel@tonic-gate #define	DOT	"."
757c478bd9Sstevel@tonic-gate #define	DOTDOT	".."
767c478bd9Sstevel@tonic-gate #define	DELIM	'/'
777c478bd9Sstevel@tonic-gate #define	EQ(x, y)	(strcmp(x, y) == 0)
787c478bd9Sstevel@tonic-gate #define	FALSE	0
797c478bd9Sstevel@tonic-gate #define	MODEBITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
807c478bd9Sstevel@tonic-gate #define	TRUE 1
817c478bd9Sstevel@tonic-gate #define	MAXMAPSIZE	(1024*1024*8)	/* map at most 8MB */
827c478bd9Sstevel@tonic-gate #define	SMALLFILESIZE	(32*1024)	/* don't use mmap on little files */
837c478bd9Sstevel@tonic-gate 
847c478bd9Sstevel@tonic-gate static char		*dname(char *);
857c478bd9Sstevel@tonic-gate static int		lnkfil(char *, char *);
867c478bd9Sstevel@tonic-gate static int		cpymve(char *, char *);
877c478bd9Sstevel@tonic-gate static int		chkfiles(char *, char **);
887c478bd9Sstevel@tonic-gate static int		rcopy(char *, char *);
897c478bd9Sstevel@tonic-gate static int		chk_different(char *, char *);
907c478bd9Sstevel@tonic-gate static int		chg_time(char *, struct stat);
917c478bd9Sstevel@tonic-gate static int		chg_mode(char *, uid_t, gid_t, mode_t);
927c478bd9Sstevel@tonic-gate static int		copydir(char *, char *);
937c478bd9Sstevel@tonic-gate static int		copyspecial(char *);
947c478bd9Sstevel@tonic-gate static int		getrealpath(char *, char *);
957c478bd9Sstevel@tonic-gate static void		usage(void);
967c478bd9Sstevel@tonic-gate static void		Perror(char *);
977c478bd9Sstevel@tonic-gate static void		Perror2(char *, char *);
987c478bd9Sstevel@tonic-gate static int		use_stdin(void);
997c478bd9Sstevel@tonic-gate static int		copyattributes(char *, char *);
100da6c28aaSamw static int		copy_sysattr(char *, char *);
1017c478bd9Sstevel@tonic-gate static void		timestruc_to_timeval(timestruc_t *, struct timeval *);
1027c478bd9Sstevel@tonic-gate static tree_node_t	*create_tnode(dev_t, ino_t);
1037c478bd9Sstevel@tonic-gate 
104da6c28aaSamw static struct stat 	s1, s2, s3, s4;
1057c478bd9Sstevel@tonic-gate static int 		cpy = FALSE;
1067c478bd9Sstevel@tonic-gate static int 		mve = FALSE;
1077c478bd9Sstevel@tonic-gate static int 		lnk = FALSE;
1087c478bd9Sstevel@tonic-gate static char		*cmd;
1097c478bd9Sstevel@tonic-gate static int		silent = 0;
1107c478bd9Sstevel@tonic-gate static int		fflg = 0;
1117c478bd9Sstevel@tonic-gate static int		iflg = 0;
1127c478bd9Sstevel@tonic-gate static int		pflg = 0;
1137c478bd9Sstevel@tonic-gate static int		Rflg = 0;	/* recursive copy */
1147c478bd9Sstevel@tonic-gate static int		rflg = 0;	/* recursive copy */
1157c478bd9Sstevel@tonic-gate static int		sflg = 0;
1167c478bd9Sstevel@tonic-gate static int		Hflg = 0;	/* follow cmd line arg symlink to dir */
1177c478bd9Sstevel@tonic-gate static int		Lflg = 0;	/* follow symlinks */
1187c478bd9Sstevel@tonic-gate static int		Pflg = 0;	/* do not follow symlinks */
1197c478bd9Sstevel@tonic-gate static int		atflg = 0;
1207c478bd9Sstevel@tonic-gate static int		attrsilent = 0;
1217c478bd9Sstevel@tonic-gate static int		targetexists = 0;
1227c478bd9Sstevel@tonic-gate static int		cmdarg;		/* command line argument */
1237c478bd9Sstevel@tonic-gate static avl_tree_t	*stree = NULL;	/* source file inode search tree */
124fa9e4066Sahrens static acl_t		*s1acl;
125da6c28aaSamw static int		saflg = 0;	/* 'cp' extended system attr. */
126beab0215Sbasabi static int		srcfd = -1;
127beab0215Sbasabi static int		targfd = -1;
128beab0215Sbasabi static int		sourcedirfd = -1;
129beab0215Sbasabi static int		targetdirfd = -1;
130beab0215Sbasabi static DIR 		*srcdirp = NULL;
131beab0215Sbasabi static int		srcattrfd = -1;
132beab0215Sbasabi static int		targattrfd = -1;
133da6c28aaSamw static struct stat 	attrdir;
134da6c28aaSamw 
135da6c28aaSamw /* Extended system attributes support */
136da6c28aaSamw 
137da6c28aaSamw static int open_source(char  *);
138da6c28aaSamw static int open_target_srctarg_attrdirs(char  *, char *);
139da6c28aaSamw static int open_attrdirp(char *);
140da6c28aaSamw static int traverse_attrfile(struct dirent *, char *, char *, int);
141da6c28aaSamw static void rewind_attrdir(DIR *);
142da6c28aaSamw static void close_all();
143da6c28aaSamw 
1447c478bd9Sstevel@tonic-gate 
145a77d64afScf int
1467c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
1477c478bd9Sstevel@tonic-gate {
1487c478bd9Sstevel@tonic-gate 	int c, i, r, errflg = 0;
1497c478bd9Sstevel@tonic-gate 	char target[PATH_MAX];
1507c478bd9Sstevel@tonic-gate 	int (*move)(char *, char *);
1517c478bd9Sstevel@tonic-gate 
1527c478bd9Sstevel@tonic-gate 	/*
1537c478bd9Sstevel@tonic-gate 	 * Determine command invoked (mv, cp, or ln)
1547c478bd9Sstevel@tonic-gate 	 */
1557c478bd9Sstevel@tonic-gate 
1567c478bd9Sstevel@tonic-gate 	if (cmd = strrchr(argv[0], '/'))
1577c478bd9Sstevel@tonic-gate 		++cmd;
1587c478bd9Sstevel@tonic-gate 	else
1597c478bd9Sstevel@tonic-gate 		cmd = argv[0];
1607c478bd9Sstevel@tonic-gate 
1617c478bd9Sstevel@tonic-gate 	/*
1627c478bd9Sstevel@tonic-gate 	 * Set flags based on command.
1637c478bd9Sstevel@tonic-gate 	 */
1647c478bd9Sstevel@tonic-gate 
1657c478bd9Sstevel@tonic-gate 	(void) setlocale(LC_ALL, "");
1667c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
1677c478bd9Sstevel@tonic-gate #define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
1687c478bd9Sstevel@tonic-gate #endif
1697c478bd9Sstevel@tonic-gate 	(void) textdomain(TEXT_DOMAIN);
1703d63ea05Sas 	if (init_yes() < 0) {
1713d63ea05Sas 		(void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
1723d63ea05Sas 		    strerror(errno));
1733d63ea05Sas 		exit(3);
1743d63ea05Sas 	}
1757c478bd9Sstevel@tonic-gate 
1767c478bd9Sstevel@tonic-gate 	if (EQ(cmd, "mv"))
1777c478bd9Sstevel@tonic-gate 		mve = TRUE;
1787c478bd9Sstevel@tonic-gate 	else if (EQ(cmd, "ln"))
1797c478bd9Sstevel@tonic-gate 		lnk = TRUE;
1807c478bd9Sstevel@tonic-gate 	else if (EQ(cmd, "cp"))
1817c478bd9Sstevel@tonic-gate 		cpy = TRUE;
1827c478bd9Sstevel@tonic-gate 	else {
1837c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
1847c478bd9Sstevel@tonic-gate 		    gettext("Invalid command name (%s); expecting "
1857c478bd9Sstevel@tonic-gate 		    "mv, cp, or ln.\n"), cmd);
1867c478bd9Sstevel@tonic-gate 		exit(1);
1877c478bd9Sstevel@tonic-gate 	}
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate 	/*
1907c478bd9Sstevel@tonic-gate 	 * Check for options:
191da6c28aaSamw 	 * 	cp  -r|-R [-H|-L|-P] [-fip@/] file1 [file2 ...] target
192da6c28aaSamw 	 * 	cp [-fiprR@/] file1 [file2 ...] target
1937c478bd9Sstevel@tonic-gate 	 *	ln [-f] [-n] [-s] file1 [file2 ...] target
1947c478bd9Sstevel@tonic-gate 	 *	ln [-f] [-n] [-s] file1 [file2 ...]
1957c478bd9Sstevel@tonic-gate 	 *	mv [-f|i] file1 [file2 ...] target
1967c478bd9Sstevel@tonic-gate 	 *	mv [-f|i] dir1 target
1977c478bd9Sstevel@tonic-gate 	 */
1987c478bd9Sstevel@tonic-gate 
1997c478bd9Sstevel@tonic-gate 	if (cpy) {
200da6c28aaSamw 		while ((c = getopt(argc, argv, "fHiLpPrR@/")) != EOF)
2017c478bd9Sstevel@tonic-gate 			switch (c) {
2027c478bd9Sstevel@tonic-gate 			case 'f':
2037c478bd9Sstevel@tonic-gate 				fflg++;
2047c478bd9Sstevel@tonic-gate 				break;
2057c478bd9Sstevel@tonic-gate 			case 'i':
2067c478bd9Sstevel@tonic-gate 				iflg++;
2077c478bd9Sstevel@tonic-gate 				break;
2087c478bd9Sstevel@tonic-gate 			case 'p':
2097c478bd9Sstevel@tonic-gate 				pflg++;
2107c478bd9Sstevel@tonic-gate #ifdef XPG4
2117c478bd9Sstevel@tonic-gate 				attrsilent = 1;
2127c478bd9Sstevel@tonic-gate 				atflg = 0;
213da6c28aaSamw 				saflg = 0;
2147c478bd9Sstevel@tonic-gate #else
215cee1ddadSbasabi 				if (atflg == 0)
2167c478bd9Sstevel@tonic-gate 					attrsilent = 1;
2177c478bd9Sstevel@tonic-gate #endif
2187c478bd9Sstevel@tonic-gate 				break;
2197c478bd9Sstevel@tonic-gate 			case 'H':
2207c478bd9Sstevel@tonic-gate 				/*
2217c478bd9Sstevel@tonic-gate 				 * If more than one of -H, -L, or -P are
2227c478bd9Sstevel@tonic-gate 				 * specified, only the last option specified
2237c478bd9Sstevel@tonic-gate 				 * determines the behavior.
2247c478bd9Sstevel@tonic-gate 				 */
2257c478bd9Sstevel@tonic-gate 				Lflg = Pflg = 0;
2267c478bd9Sstevel@tonic-gate 				Hflg++;
2277c478bd9Sstevel@tonic-gate 				break;
2287c478bd9Sstevel@tonic-gate 			case 'L':
2297c478bd9Sstevel@tonic-gate 				Hflg = Pflg = 0;
2307c478bd9Sstevel@tonic-gate 				Lflg++;
2317c478bd9Sstevel@tonic-gate 				break;
2327c478bd9Sstevel@tonic-gate 			case 'P':
2337c478bd9Sstevel@tonic-gate 				Lflg = Hflg = 0;
2347c478bd9Sstevel@tonic-gate 				Pflg++;
2357c478bd9Sstevel@tonic-gate 				break;
2367c478bd9Sstevel@tonic-gate 			case 'R':
2377c478bd9Sstevel@tonic-gate 				/*
2387c478bd9Sstevel@tonic-gate 				 * The default behavior of cp -R|-r
2397c478bd9Sstevel@tonic-gate 				 * when specified without -H|-L|-P
2407c478bd9Sstevel@tonic-gate 				 * is -L.
2417c478bd9Sstevel@tonic-gate 				 */
2427c478bd9Sstevel@tonic-gate 				Rflg++;
2437c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
2447c478bd9Sstevel@tonic-gate 			case 'r':
2457c478bd9Sstevel@tonic-gate 				rflg++;
2467c478bd9Sstevel@tonic-gate 				break;
2477c478bd9Sstevel@tonic-gate 			case '@':
2487c478bd9Sstevel@tonic-gate 				atflg++;
2497c478bd9Sstevel@tonic-gate 				attrsilent = 0;
2507c478bd9Sstevel@tonic-gate #ifdef XPG4
2517c478bd9Sstevel@tonic-gate 				pflg = 0;
252da6c28aaSamw #endif
253da6c28aaSamw 				break;
254da6c28aaSamw 			case '/':
255da6c28aaSamw 				saflg++;
256da6c28aaSamw 				attrsilent = 0;
257da6c28aaSamw #ifdef XPG4
258da6c28aaSamw 				pflg = 0;
2597c478bd9Sstevel@tonic-gate #endif
2607c478bd9Sstevel@tonic-gate 				break;
2617c478bd9Sstevel@tonic-gate 			default:
2627c478bd9Sstevel@tonic-gate 				errflg++;
2637c478bd9Sstevel@tonic-gate 			}
2647c478bd9Sstevel@tonic-gate 
2657c478bd9Sstevel@tonic-gate 		/* -R or -r must be specified with -H, -L, or -P */
2667c478bd9Sstevel@tonic-gate 		if ((Hflg || Lflg || Pflg) && !(Rflg || rflg)) {
2677c478bd9Sstevel@tonic-gate 			errflg++;
2687c478bd9Sstevel@tonic-gate 		}
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate 	} else if (mve) {
2717c478bd9Sstevel@tonic-gate 		while ((c = getopt(argc, argv, "fis")) != EOF)
2727c478bd9Sstevel@tonic-gate 			switch (c) {
2737c478bd9Sstevel@tonic-gate 			case 'f':
2747c478bd9Sstevel@tonic-gate 				silent++;
2757c478bd9Sstevel@tonic-gate #ifdef XPG4
2767c478bd9Sstevel@tonic-gate 				iflg = 0;
2777c478bd9Sstevel@tonic-gate #endif
2787c478bd9Sstevel@tonic-gate 				break;
2797c478bd9Sstevel@tonic-gate 			case 'i':
2807c478bd9Sstevel@tonic-gate 				iflg++;
2817c478bd9Sstevel@tonic-gate #ifdef XPG4
2827c478bd9Sstevel@tonic-gate 				silent = 0;
2837c478bd9Sstevel@tonic-gate #endif
2847c478bd9Sstevel@tonic-gate 				break;
2857c478bd9Sstevel@tonic-gate 			default:
2867c478bd9Sstevel@tonic-gate 				errflg++;
2877c478bd9Sstevel@tonic-gate 			}
2887c478bd9Sstevel@tonic-gate 	} else { /* ln */
2897c478bd9Sstevel@tonic-gate 		while ((c = getopt(argc, argv, "fns")) != EOF)
2907c478bd9Sstevel@tonic-gate 			switch (c) {
2917c478bd9Sstevel@tonic-gate 			case 'f':
2927c478bd9Sstevel@tonic-gate 				silent++;
2937c478bd9Sstevel@tonic-gate 				break;
2947c478bd9Sstevel@tonic-gate 			case 'n':
2957c478bd9Sstevel@tonic-gate 				/* silently ignored; this is the default */
2967c478bd9Sstevel@tonic-gate 				break;
2977c478bd9Sstevel@tonic-gate 			case 's':
2987c478bd9Sstevel@tonic-gate 				sflg++;
2997c478bd9Sstevel@tonic-gate 				break;
3007c478bd9Sstevel@tonic-gate 			default:
3017c478bd9Sstevel@tonic-gate 				errflg++;
3027c478bd9Sstevel@tonic-gate 			}
3037c478bd9Sstevel@tonic-gate 	}
3047c478bd9Sstevel@tonic-gate 
3057c478bd9Sstevel@tonic-gate 	/*
3067c478bd9Sstevel@tonic-gate 	 * For BSD compatibility allow - to delimit the end of
3077c478bd9Sstevel@tonic-gate 	 * options for mv.
3087c478bd9Sstevel@tonic-gate 	 */
3097c478bd9Sstevel@tonic-gate 	if (mve && optind < argc && (strcmp(argv[optind], "-") == 0))
3107c478bd9Sstevel@tonic-gate 		optind++;
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate 	/*
3137c478bd9Sstevel@tonic-gate 	 * Check for sufficient arguments
3147c478bd9Sstevel@tonic-gate 	 * or a usage error.
3157c478bd9Sstevel@tonic-gate 	 */
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 	argc -= optind;
3187c478bd9Sstevel@tonic-gate 	argv  = &argv[optind];
3197c478bd9Sstevel@tonic-gate 
3207c478bd9Sstevel@tonic-gate 	if ((argc < 2 && lnk != TRUE) || (argc < 1 && lnk == TRUE)) {
3217c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
3227c478bd9Sstevel@tonic-gate 		    gettext("%s: Insufficient arguments (%d)\n"),
3237c478bd9Sstevel@tonic-gate 		    cmd, argc);
3247c478bd9Sstevel@tonic-gate 		usage();
3257c478bd9Sstevel@tonic-gate 	}
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate 	if (errflg != 0)
3287c478bd9Sstevel@tonic-gate 		usage();
3297c478bd9Sstevel@tonic-gate 
3307c478bd9Sstevel@tonic-gate 	/*
3317c478bd9Sstevel@tonic-gate 	 * If there is more than a source and target,
3327c478bd9Sstevel@tonic-gate 	 * the last argument (the target) must be a directory
3337c478bd9Sstevel@tonic-gate 	 * which really exists.
3347c478bd9Sstevel@tonic-gate 	 */
3357c478bd9Sstevel@tonic-gate 
3367c478bd9Sstevel@tonic-gate 	if (argc > 2) {
3377c478bd9Sstevel@tonic-gate 		if (stat(argv[argc-1], &s2) < 0) {
3387c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
3397c478bd9Sstevel@tonic-gate 			    gettext("%s: %s not found\n"),
3407c478bd9Sstevel@tonic-gate 			    cmd, argv[argc-1]);
3417c478bd9Sstevel@tonic-gate 			exit(2);
3427c478bd9Sstevel@tonic-gate 		}
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 		if (!ISDIR(s2)) {
3457c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
3467c478bd9Sstevel@tonic-gate 			    gettext("%s: Target %s must be a directory\n"),
3477c478bd9Sstevel@tonic-gate 			    cmd, argv[argc-1]);
3487c478bd9Sstevel@tonic-gate 			usage();
3497c478bd9Sstevel@tonic-gate 		}
3507c478bd9Sstevel@tonic-gate 	}
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate 	if (strlen(argv[argc-1]) >= PATH_MAX) {
3537c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
3547c478bd9Sstevel@tonic-gate 		    gettext("%s: Target %s file name length exceeds PATH_MAX"
3557c478bd9Sstevel@tonic-gate 		    " %d\n"), cmd, argv[argc-1], PATH_MAX);
3567c478bd9Sstevel@tonic-gate 		exit(78);
3577c478bd9Sstevel@tonic-gate 	}
3587c478bd9Sstevel@tonic-gate 
3597c478bd9Sstevel@tonic-gate 	if (argc == 1) {
3607c478bd9Sstevel@tonic-gate 		if (!lnk)
3617c478bd9Sstevel@tonic-gate 			usage();
3627c478bd9Sstevel@tonic-gate 		(void) strcpy(target, ".");
3637c478bd9Sstevel@tonic-gate 	} else {
3647c478bd9Sstevel@tonic-gate 		(void) strcpy(target, argv[--argc]);
3657c478bd9Sstevel@tonic-gate 	}
3667c478bd9Sstevel@tonic-gate 
3677c478bd9Sstevel@tonic-gate 	/*
3687c478bd9Sstevel@tonic-gate 	 * Perform a multiple argument mv|cp|ln by
3697c478bd9Sstevel@tonic-gate 	 * multiple invocations of cpymve() or lnkfil().
3707c478bd9Sstevel@tonic-gate 	 */
3717c478bd9Sstevel@tonic-gate 	if (lnk)
3727c478bd9Sstevel@tonic-gate 		move = lnkfil;
3737c478bd9Sstevel@tonic-gate 	else
3747c478bd9Sstevel@tonic-gate 		move = cpymve;
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 	r = 0;
3777c478bd9Sstevel@tonic-gate 	for (i = 0; i < argc; i++) {
3787c478bd9Sstevel@tonic-gate 		stree = NULL;
3797c478bd9Sstevel@tonic-gate 		cmdarg = 1;
3807c478bd9Sstevel@tonic-gate 		r += move(argv[i], target);
3817c478bd9Sstevel@tonic-gate 	}
3827c478bd9Sstevel@tonic-gate 
3837c478bd9Sstevel@tonic-gate 	/*
3847c478bd9Sstevel@tonic-gate 	 * Show errors by nonzero exit code.
3857c478bd9Sstevel@tonic-gate 	 */
3867c478bd9Sstevel@tonic-gate 
387a77d64afScf 	return (r?2:0);
3887c478bd9Sstevel@tonic-gate }
3897c478bd9Sstevel@tonic-gate 
3907c478bd9Sstevel@tonic-gate static int
3917c478bd9Sstevel@tonic-gate lnkfil(char *source, char *target)
3927c478bd9Sstevel@tonic-gate {
3937c478bd9Sstevel@tonic-gate 	char	*buf = NULL;
3947c478bd9Sstevel@tonic-gate 
3957c478bd9Sstevel@tonic-gate 	if (sflg) {
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 		/*
3987c478bd9Sstevel@tonic-gate 		 * If target is a directory make complete
3997c478bd9Sstevel@tonic-gate 		 * name of the new symbolic link within that
4007c478bd9Sstevel@tonic-gate 		 * directory.
4017c478bd9Sstevel@tonic-gate 		 */
4027c478bd9Sstevel@tonic-gate 
4037c478bd9Sstevel@tonic-gate 		if ((stat(target, &s2) >= 0) && ISDIR(s2)) {
4047c478bd9Sstevel@tonic-gate 			size_t len;
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate 			len = strlen(target) + strlen(dname(source)) + 4;
4077c478bd9Sstevel@tonic-gate 			if ((buf = (char *)malloc(len)) == NULL) {
4087c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
4097c478bd9Sstevel@tonic-gate 				    gettext("%s: Insufficient memory "
4107c478bd9Sstevel@tonic-gate 				    "to %s %s\n"), cmd, cmd, source);
4117c478bd9Sstevel@tonic-gate 				exit(3);
4127c478bd9Sstevel@tonic-gate 			}
4137c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, len, "%s/%s",
4147c478bd9Sstevel@tonic-gate 			    target, dname(source));
4157c478bd9Sstevel@tonic-gate 			target = buf;
4167c478bd9Sstevel@tonic-gate 		}
4177c478bd9Sstevel@tonic-gate 
4187c478bd9Sstevel@tonic-gate 		/*
419*6fcd7f75Schin 		 * Check to see if the file exists already.
420*6fcd7f75Schin 		 * In this case we use lstat() instead of stat():
421*6fcd7f75Schin 		 * unlink(2) and symlink(2) will operate on the file
422*6fcd7f75Schin 		 * itself, not its reference, if the file is a symlink.
4237c478bd9Sstevel@tonic-gate 		 */
4247c478bd9Sstevel@tonic-gate 
425*6fcd7f75Schin 		if ((lstat(target, &s2) == 0)) {
4267c478bd9Sstevel@tonic-gate 			/*
4277c478bd9Sstevel@tonic-gate 			 * Check if the silent flag is set ie. the -f option
4287c478bd9Sstevel@tonic-gate 			 * is used.  If so, use unlink to remove the current
4297c478bd9Sstevel@tonic-gate 			 * target to replace with the new target, specified
4307c478bd9Sstevel@tonic-gate 			 * on the command line.  Proceed with symlink.
4317c478bd9Sstevel@tonic-gate 			 */
4327c478bd9Sstevel@tonic-gate 			if (silent) {
433*6fcd7f75Schin 			/*
434*6fcd7f75Schin 			 * Don't allow silent (-f) removal of an existing
435*6fcd7f75Schin 			 * directory; could leave unreferenced directory
436*6fcd7f75Schin 			 * entries.
437*6fcd7f75Schin 			 */
438*6fcd7f75Schin 				if (ISDIR(s2)) {
439*6fcd7f75Schin 					(void) fprintf(stderr,
440*6fcd7f75Schin 					    gettext("%s: cannot create link "
441*6fcd7f75Schin 					    "over directory %s\n"), cmd,
442*6fcd7f75Schin 					    target);
443*6fcd7f75Schin 					return (1);
444*6fcd7f75Schin 				}
4457c478bd9Sstevel@tonic-gate 				if (unlink(target) < 0) {
4467c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
4477c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot unlink %s: "),
4487c478bd9Sstevel@tonic-gate 					    cmd, target);
4497c478bd9Sstevel@tonic-gate 					perror("");
4507c478bd9Sstevel@tonic-gate 					return (1);
4517c478bd9Sstevel@tonic-gate 				}
4527c478bd9Sstevel@tonic-gate 			}
4537c478bd9Sstevel@tonic-gate 		}
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate 
4567c478bd9Sstevel@tonic-gate 		/*
4577c478bd9Sstevel@tonic-gate 		 * Create a symbolic link to the source.
4587c478bd9Sstevel@tonic-gate 		 */
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 		if (symlink(source, target) < 0) {
4617c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
4627c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot create %s: "),
4637c478bd9Sstevel@tonic-gate 			    cmd, target);
4647c478bd9Sstevel@tonic-gate 			perror("");
4657c478bd9Sstevel@tonic-gate 			if (buf != NULL)
4667c478bd9Sstevel@tonic-gate 				free(buf);
4677c478bd9Sstevel@tonic-gate 			return (1);
4687c478bd9Sstevel@tonic-gate 		}
4697c478bd9Sstevel@tonic-gate 		if (buf != NULL)
4707c478bd9Sstevel@tonic-gate 			free(buf);
4717c478bd9Sstevel@tonic-gate 		return (0);
4727c478bd9Sstevel@tonic-gate 	}
4737c478bd9Sstevel@tonic-gate 
4747c478bd9Sstevel@tonic-gate 	switch (chkfiles(source, &target)) {
4757c478bd9Sstevel@tonic-gate 		case 1: return (1);
4767c478bd9Sstevel@tonic-gate 		case 2: return (0);
4777c478bd9Sstevel@tonic-gate 			/* default - fall through */
4787c478bd9Sstevel@tonic-gate 	}
4797c478bd9Sstevel@tonic-gate 
4807c478bd9Sstevel@tonic-gate 	/*
4817c478bd9Sstevel@tonic-gate 	 * Make sure source file is not a directory,
4827c478bd9Sstevel@tonic-gate 	 * we can't link directories...
4837c478bd9Sstevel@tonic-gate 	 */
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate 	if (ISDIR(s1)) {
4867c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
4877c478bd9Sstevel@tonic-gate 		    gettext("%s: %s is a directory\n"), cmd, source);
4887c478bd9Sstevel@tonic-gate 		return (1);
4897c478bd9Sstevel@tonic-gate 	}
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate 	/*
4927c478bd9Sstevel@tonic-gate 	 * hard link, call link() and return.
4937c478bd9Sstevel@tonic-gate 	 */
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate 	if (link(source, target) < 0) {
4967c478bd9Sstevel@tonic-gate 		if (errno == EXDEV)
4977c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
4987c478bd9Sstevel@tonic-gate 			    gettext("%s: %s is on a different file system\n"),
4997c478bd9Sstevel@tonic-gate 			    cmd, target);
5007c478bd9Sstevel@tonic-gate 		else {
5017c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
5027c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot create link %s: "),
5037c478bd9Sstevel@tonic-gate 			    cmd, target);
5047c478bd9Sstevel@tonic-gate 			perror("");
5057c478bd9Sstevel@tonic-gate 		}
5067c478bd9Sstevel@tonic-gate 		if (buf != NULL)
5077c478bd9Sstevel@tonic-gate 			free(buf);
5087c478bd9Sstevel@tonic-gate 		return (1);
5097c478bd9Sstevel@tonic-gate 	} else {
5107c478bd9Sstevel@tonic-gate 		if (buf != NULL)
5117c478bd9Sstevel@tonic-gate 			free(buf);
5127c478bd9Sstevel@tonic-gate 		return (0);
5137c478bd9Sstevel@tonic-gate 	}
5147c478bd9Sstevel@tonic-gate }
5157c478bd9Sstevel@tonic-gate 
5167c478bd9Sstevel@tonic-gate static int
5177c478bd9Sstevel@tonic-gate cpymve(char *source, char *target)
5187c478bd9Sstevel@tonic-gate {
5197c478bd9Sstevel@tonic-gate 	int	n;
5207c478bd9Sstevel@tonic-gate 	int fi, fo;
5217c478bd9Sstevel@tonic-gate 	int ret = 0;
5227c478bd9Sstevel@tonic-gate 	int attret = 0;
523da6c28aaSamw 	int sattret = 0;
5247c478bd9Sstevel@tonic-gate 	int errno_save;
525cee1ddadSbasabi 	int error = 0;
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate 	switch (chkfiles(source, &target)) {
5287c478bd9Sstevel@tonic-gate 		case 1: return (1);
5297c478bd9Sstevel@tonic-gate 		case 2: return (0);
5307c478bd9Sstevel@tonic-gate 			/* default - fall through */
5317c478bd9Sstevel@tonic-gate 	}
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate 	/*
5347c478bd9Sstevel@tonic-gate 	 * If it's a recursive copy and source
5357c478bd9Sstevel@tonic-gate 	 * is a directory, then call rcopy (from copydir).
5367c478bd9Sstevel@tonic-gate 	 */
5377c478bd9Sstevel@tonic-gate 	if (cpy) {
5387c478bd9Sstevel@tonic-gate 		if (ISDIR(s1)) {
5397c478bd9Sstevel@tonic-gate 			int		rc;
5407c478bd9Sstevel@tonic-gate 			avl_index_t	where = 0;
5417c478bd9Sstevel@tonic-gate 			tree_node_t	*tnode;
5427c478bd9Sstevel@tonic-gate 			tree_node_t	*tptr;
5437c478bd9Sstevel@tonic-gate 			dev_t		save_dev = s1.st_dev;
5447c478bd9Sstevel@tonic-gate 			ino_t		save_ino = s1.st_ino;
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate 			/*
5477c478bd9Sstevel@tonic-gate 			 * We will be recursing into the directory so
5487c478bd9Sstevel@tonic-gate 			 * save the inode information to a search tree
5497c478bd9Sstevel@tonic-gate 			 * to avoid getting into an endless loop.
5507c478bd9Sstevel@tonic-gate 			 */
5517c478bd9Sstevel@tonic-gate 			if ((rc = add_tnode(&stree, save_dev, save_ino)) != 1) {
5527c478bd9Sstevel@tonic-gate 				if (rc == 0) {
5537c478bd9Sstevel@tonic-gate 					/*
5547c478bd9Sstevel@tonic-gate 					 * We've already visited this directory.
5557c478bd9Sstevel@tonic-gate 					 * Don't remove the search tree entry
5567c478bd9Sstevel@tonic-gate 					 * to make sure we don't get into an
5577c478bd9Sstevel@tonic-gate 					 * endless loop if revisited from a
5587c478bd9Sstevel@tonic-gate 					 * different part of the hierarchy.
5597c478bd9Sstevel@tonic-gate 					 */
5607c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
5617c478bd9Sstevel@tonic-gate 					    "%s: cycle detected: %s\n"),
5627c478bd9Sstevel@tonic-gate 					    cmd, source);
5637c478bd9Sstevel@tonic-gate 				} else {
5647c478bd9Sstevel@tonic-gate 					Perror(source);
5657c478bd9Sstevel@tonic-gate 				}
5667c478bd9Sstevel@tonic-gate 				return (1);
5677c478bd9Sstevel@tonic-gate 			}
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate 			cmdarg = 0;
5707c478bd9Sstevel@tonic-gate 			rc = copydir(source, target);
5717c478bd9Sstevel@tonic-gate 
5727c478bd9Sstevel@tonic-gate 			/*
5737c478bd9Sstevel@tonic-gate 			 * Create a tnode to get an index to the matching
5747c478bd9Sstevel@tonic-gate 			 * node (same dev and inode) in the search tree,
5757c478bd9Sstevel@tonic-gate 			 * then use the index to remove the matching node
5767c478bd9Sstevel@tonic-gate 			 * so it we do not wrongly detect a cycle when
5777c478bd9Sstevel@tonic-gate 			 * revisiting this directory from another part of
5787c478bd9Sstevel@tonic-gate 			 * the hierarchy.
5797c478bd9Sstevel@tonic-gate 			 */
5807c478bd9Sstevel@tonic-gate 			if ((tnode = create_tnode(save_dev,
5817c478bd9Sstevel@tonic-gate 			    save_ino)) == NULL) {
5827c478bd9Sstevel@tonic-gate 				Perror(source);
5837c478bd9Sstevel@tonic-gate 				return (1);
5847c478bd9Sstevel@tonic-gate 			}
5857c478bd9Sstevel@tonic-gate 			if ((tptr = avl_find(stree, tnode, &where)) != NULL) {
5867c478bd9Sstevel@tonic-gate 				avl_remove(stree, tptr);
5877c478bd9Sstevel@tonic-gate 			}
5887c478bd9Sstevel@tonic-gate 			free(tptr);
5897c478bd9Sstevel@tonic-gate 			free(tnode);
5907c478bd9Sstevel@tonic-gate 			return (rc);
5917c478bd9Sstevel@tonic-gate 
5927c478bd9Sstevel@tonic-gate 		} else if (ISDEV(s1) && Rflg) {
5937c478bd9Sstevel@tonic-gate 			return (copyspecial(target));
5947c478bd9Sstevel@tonic-gate 		} else {
5957c478bd9Sstevel@tonic-gate 			goto copy;
5967c478bd9Sstevel@tonic-gate 		}
5977c478bd9Sstevel@tonic-gate 	}
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate 	if (mve) {
6007c478bd9Sstevel@tonic-gate 		if (rename(source, target) >= 0)
6017c478bd9Sstevel@tonic-gate 			return (0);
6027c478bd9Sstevel@tonic-gate 		if (errno != EXDEV) {
6037c478bd9Sstevel@tonic-gate 			if (errno == ENOTDIR && ISDIR(s1)) {
6047c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
6057c478bd9Sstevel@tonic-gate 				    gettext("%s: %s is a directory\n"),
6067c478bd9Sstevel@tonic-gate 				    cmd, source);
6077c478bd9Sstevel@tonic-gate 				return (1);
6087c478bd9Sstevel@tonic-gate 			}
6097c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
6107c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot rename %s to %s: "),
6117c478bd9Sstevel@tonic-gate 			    cmd, source, target);
6127c478bd9Sstevel@tonic-gate 			perror("");
6137c478bd9Sstevel@tonic-gate 			return (1);
6147c478bd9Sstevel@tonic-gate 		}
6157c478bd9Sstevel@tonic-gate 
6167c478bd9Sstevel@tonic-gate 		/*
6177c478bd9Sstevel@tonic-gate 		 * cannot move a non-directory (source) onto an existing
6187c478bd9Sstevel@tonic-gate 		 * directory (target)
6197c478bd9Sstevel@tonic-gate 		 *
6207c478bd9Sstevel@tonic-gate 		 */
6217c478bd9Sstevel@tonic-gate 		if (targetexists && ISDIR(s2) && (!ISDIR(s1))) {
6227c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
6237c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot mv a non directory %s "
6247c478bd9Sstevel@tonic-gate 			    "over existing directory"
6257c478bd9Sstevel@tonic-gate 			    " %s \n"), cmd, source, target);
6267c478bd9Sstevel@tonic-gate 			return (1);
6277c478bd9Sstevel@tonic-gate 		}
6287c478bd9Sstevel@tonic-gate 		if (ISDIR(s1)) {
6297c478bd9Sstevel@tonic-gate #ifdef XPG4
6307c478bd9Sstevel@tonic-gate 			if (targetexists && ISDIR(s2)) {
6317c478bd9Sstevel@tonic-gate 				/* existing target dir must be empty */
6327c478bd9Sstevel@tonic-gate 				if (rmdir(target) < 0) {
6337c478bd9Sstevel@tonic-gate 					errno_save = errno;
6347c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
6357c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot rmdir %s: "),
6367c478bd9Sstevel@tonic-gate 					    cmd, target);
6377c478bd9Sstevel@tonic-gate 					errno = errno_save;
6387c478bd9Sstevel@tonic-gate 					perror("");
6397c478bd9Sstevel@tonic-gate 					return (1);
6407c478bd9Sstevel@tonic-gate 				}
6417c478bd9Sstevel@tonic-gate 			}
6427c478bd9Sstevel@tonic-gate #endif
6437c478bd9Sstevel@tonic-gate 			if ((n =  copydir(source, target)) == 0)
6447c478bd9Sstevel@tonic-gate 				(void) rmdir(source);
6457c478bd9Sstevel@tonic-gate 			return (n);
6467c478bd9Sstevel@tonic-gate 		}
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate 		/* doors can't be moved across filesystems */
6497c478bd9Sstevel@tonic-gate 		if (ISDOOR(s1)) {
6507c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
6517c478bd9Sstevel@tonic-gate 			    gettext("%s: %s: can't move door "
6527c478bd9Sstevel@tonic-gate 			    "across file systems\n"), cmd, source);
6537c478bd9Sstevel@tonic-gate 			return (1);
6547c478bd9Sstevel@tonic-gate 		}
6557c478bd9Sstevel@tonic-gate 		/*
6567c478bd9Sstevel@tonic-gate 		 * File can't be renamed, try to recreate the symbolic
6577c478bd9Sstevel@tonic-gate 		 * link or special device, or copy the file wholesale
6587c478bd9Sstevel@tonic-gate 		 * between file systems.
6597c478bd9Sstevel@tonic-gate 		 */
6607c478bd9Sstevel@tonic-gate 		if (ISLNK(s1)) {
6617c478bd9Sstevel@tonic-gate 			register int	m;
6627c478bd9Sstevel@tonic-gate 			register mode_t md;
6637c478bd9Sstevel@tonic-gate 			char symln[PATH_MAX + 1];
6647c478bd9Sstevel@tonic-gate 
6657c478bd9Sstevel@tonic-gate 			if (targetexists && unlink(target) < 0) {
6667c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
6677c478bd9Sstevel@tonic-gate 				    gettext("%s: cannot unlink %s: "),
6687c478bd9Sstevel@tonic-gate 				    cmd, target);
6697c478bd9Sstevel@tonic-gate 				perror("");
6707c478bd9Sstevel@tonic-gate 				return (1);
6717c478bd9Sstevel@tonic-gate 			}
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 			if ((m = readlink(source, symln,
6747c478bd9Sstevel@tonic-gate 			    sizeof (symln) - 1)) < 0) {
6757c478bd9Sstevel@tonic-gate 				Perror(source);
6767c478bd9Sstevel@tonic-gate 				return (1);
6777c478bd9Sstevel@tonic-gate 			}
6787c478bd9Sstevel@tonic-gate 			symln[m] = '\0';
6797c478bd9Sstevel@tonic-gate 
6807c478bd9Sstevel@tonic-gate 			md = umask(~(s1.st_mode & MODEBITS));
6817c478bd9Sstevel@tonic-gate 			if (symlink(symln, target) < 0) {
6827c478bd9Sstevel@tonic-gate 				Perror(target);
6837c478bd9Sstevel@tonic-gate 				return (1);
6847c478bd9Sstevel@tonic-gate 			}
6857c478bd9Sstevel@tonic-gate 			(void) umask(md);
6867c478bd9Sstevel@tonic-gate 			m = lchown(target, UID(s1), GID(s1));
6877c478bd9Sstevel@tonic-gate #ifdef XPG4
6887c478bd9Sstevel@tonic-gate 			if (m < 0) {
6897c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, gettext("%s: cannot"
6907c478bd9Sstevel@tonic-gate 				    " change owner and group of"
6917c478bd9Sstevel@tonic-gate 				    " %s: "), cmd, target);
6927c478bd9Sstevel@tonic-gate 				perror("");
6937c478bd9Sstevel@tonic-gate 			}
6947c478bd9Sstevel@tonic-gate #endif
6957c478bd9Sstevel@tonic-gate 			goto cleanup;
6967c478bd9Sstevel@tonic-gate 		}
6977c478bd9Sstevel@tonic-gate 		if (ISDEV(s1)) {
6987c478bd9Sstevel@tonic-gate 
6997c478bd9Sstevel@tonic-gate 			if (targetexists && unlink(target) < 0) {
7007c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
7017c478bd9Sstevel@tonic-gate 				    gettext("%s: cannot unlink %s: "),
7027c478bd9Sstevel@tonic-gate 				    cmd, target);
7037c478bd9Sstevel@tonic-gate 				perror("");
7047c478bd9Sstevel@tonic-gate 				return (1);
7057c478bd9Sstevel@tonic-gate 			}
7067c478bd9Sstevel@tonic-gate 
7077c478bd9Sstevel@tonic-gate 			if (mknod(target, s1.st_mode, s1.st_rdev) < 0) {
7087c478bd9Sstevel@tonic-gate 				Perror(target);
7097c478bd9Sstevel@tonic-gate 				return (1);
7107c478bd9Sstevel@tonic-gate 			}
7117c478bd9Sstevel@tonic-gate 
7127c478bd9Sstevel@tonic-gate 			(void) chg_mode(target, UID(s1), GID(s1), FMODE(s1));
7137c478bd9Sstevel@tonic-gate 			(void) chg_time(target, s1);
7147c478bd9Sstevel@tonic-gate 			goto cleanup;
7157c478bd9Sstevel@tonic-gate 		}
7167c478bd9Sstevel@tonic-gate 
7177c478bd9Sstevel@tonic-gate 		if (ISREG(s1)) {
7187c478bd9Sstevel@tonic-gate 			if (ISDIR(s2)) {
7197c478bd9Sstevel@tonic-gate 				if (targetexists && rmdir(target) < 0) {
7207c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
7217c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot rmdir %s: "),
7227c478bd9Sstevel@tonic-gate 					    cmd, target);
7237c478bd9Sstevel@tonic-gate 					perror("");
7247c478bd9Sstevel@tonic-gate 					return (1);
7257c478bd9Sstevel@tonic-gate 				}
7267c478bd9Sstevel@tonic-gate 			} else {
7277c478bd9Sstevel@tonic-gate 				if (targetexists && unlink(target) < 0) {
7287c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
7297c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot unlink %s: "),
7307c478bd9Sstevel@tonic-gate 					    cmd, target);
7317c478bd9Sstevel@tonic-gate 					perror("");
7327c478bd9Sstevel@tonic-gate 					return (1);
7337c478bd9Sstevel@tonic-gate 				}
7347c478bd9Sstevel@tonic-gate 			}
7357c478bd9Sstevel@tonic-gate 
7367c478bd9Sstevel@tonic-gate 
7377c478bd9Sstevel@tonic-gate copy:
7387c478bd9Sstevel@tonic-gate 			/*
7397c478bd9Sstevel@tonic-gate 			 * If the source file is a symlink, and either
7407c478bd9Sstevel@tonic-gate 			 * -P or -H flag (only if -H is specified and the
7417c478bd9Sstevel@tonic-gate 			 * source file is not a command line argument)
7427c478bd9Sstevel@tonic-gate 			 * were specified, then action is taken on the symlink
7437c478bd9Sstevel@tonic-gate 			 * itself, not the file referenced by the symlink.
7447c478bd9Sstevel@tonic-gate 			 * Note: this is executed for 'cp' only.
7457c478bd9Sstevel@tonic-gate 			 */
7467c478bd9Sstevel@tonic-gate 			if (cpy && (Pflg || (Hflg && !cmdarg)) && (ISLNK(s1))) {
7477c478bd9Sstevel@tonic-gate 				int	m;
7487c478bd9Sstevel@tonic-gate 				mode_t	md;
7497c478bd9Sstevel@tonic-gate 				char symln[PATH_MAX + 1];
7507c478bd9Sstevel@tonic-gate 
7517c478bd9Sstevel@tonic-gate 				m = readlink(source, symln, sizeof (symln) - 1);
7527c478bd9Sstevel@tonic-gate 
7537c478bd9Sstevel@tonic-gate 				if (m < 0) {
7547c478bd9Sstevel@tonic-gate 					Perror(source);
7557c478bd9Sstevel@tonic-gate 					return (1);
7567c478bd9Sstevel@tonic-gate 				}
7577c478bd9Sstevel@tonic-gate 				symln[m] = '\0';
7587c478bd9Sstevel@tonic-gate 
7597c478bd9Sstevel@tonic-gate 				/*
7607c478bd9Sstevel@tonic-gate 				 * Copy the sym link to the target.
7617c478bd9Sstevel@tonic-gate 				 * Note: If the target exists, write a
7627c478bd9Sstevel@tonic-gate 				 * diagnostic message, do nothing more
7637c478bd9Sstevel@tonic-gate 				 * with the source file, and return to
7647c478bd9Sstevel@tonic-gate 				 * process any remaining files.
7657c478bd9Sstevel@tonic-gate 				 */
7667c478bd9Sstevel@tonic-gate 				md = umask(~(s1.st_mode & MODEBITS));
7677c478bd9Sstevel@tonic-gate 				if (symlink(symln, target) < 0) {
7687c478bd9Sstevel@tonic-gate 					Perror(target);
7697c478bd9Sstevel@tonic-gate 					return (1);
7707c478bd9Sstevel@tonic-gate 				}
7717c478bd9Sstevel@tonic-gate 				(void) umask(md);
7727c478bd9Sstevel@tonic-gate 				m = lchown(target, UID(s1), GID(s1));
7737c478bd9Sstevel@tonic-gate 
7747c478bd9Sstevel@tonic-gate 				if (m < 0) {
7757c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
7767c478bd9Sstevel@tonic-gate 					    "cp: cannot change owner and "
7777c478bd9Sstevel@tonic-gate 					    "group of %s:"), target);
7787c478bd9Sstevel@tonic-gate 					perror("");
7797c478bd9Sstevel@tonic-gate 				}
7807c478bd9Sstevel@tonic-gate 			} else {
7817c478bd9Sstevel@tonic-gate 				/*
7827c478bd9Sstevel@tonic-gate 				 * Copy the file.  If it happens to be a
7837c478bd9Sstevel@tonic-gate 				 * symlink, copy the file referenced
7847c478bd9Sstevel@tonic-gate 				 * by the symlink.
7857c478bd9Sstevel@tonic-gate 				 */
7867c478bd9Sstevel@tonic-gate 				fi = open(source, O_RDONLY);
7877c478bd9Sstevel@tonic-gate 				if (fi < 0) {
7887c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
7897c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot open %s: "),
7907c478bd9Sstevel@tonic-gate 					    cmd, source);
7917c478bd9Sstevel@tonic-gate 					perror("");
7927c478bd9Sstevel@tonic-gate 					return (1);
7937c478bd9Sstevel@tonic-gate 				}
7947c478bd9Sstevel@tonic-gate 
7957c478bd9Sstevel@tonic-gate 				fo = creat(target, s1.st_mode & MODEBITS);
7967c478bd9Sstevel@tonic-gate 				if (fo < 0) {
7977c478bd9Sstevel@tonic-gate 					/*
7987c478bd9Sstevel@tonic-gate 					 * If -f and creat() failed, unlink
7997c478bd9Sstevel@tonic-gate 					 * and try again.
8007c478bd9Sstevel@tonic-gate 					 */
8017c478bd9Sstevel@tonic-gate 					if (fflg) {
8027c478bd9Sstevel@tonic-gate 						(void) unlink(target);
8037c478bd9Sstevel@tonic-gate 						fo = creat(target,
8047c478bd9Sstevel@tonic-gate 						    s1.st_mode & MODEBITS);
8057c478bd9Sstevel@tonic-gate 					}
8067c478bd9Sstevel@tonic-gate 				}
8077c478bd9Sstevel@tonic-gate 				if (fo < 0) {
8087c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
8097c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot create %s: "),
8107c478bd9Sstevel@tonic-gate 					    cmd, target);
8117c478bd9Sstevel@tonic-gate 					perror("");
8127c478bd9Sstevel@tonic-gate 					(void) close(fi);
8137c478bd9Sstevel@tonic-gate 					return (1);
8147c478bd9Sstevel@tonic-gate 				} else {
8157c478bd9Sstevel@tonic-gate 					/* stat the new file, its used below */
8167c478bd9Sstevel@tonic-gate 					(void) stat(target, &s2);
8177c478bd9Sstevel@tonic-gate 				}
8187c478bd9Sstevel@tonic-gate 
8197c478bd9Sstevel@tonic-gate 				/*
8207c478bd9Sstevel@tonic-gate 				 * Set target's permissions to the source
8217c478bd9Sstevel@tonic-gate 				 * before any copying so that any partially
8227c478bd9Sstevel@tonic-gate 				 * copied file will have the source's
8237c478bd9Sstevel@tonic-gate 				 * permissions (at most) or umask permissions
8247c478bd9Sstevel@tonic-gate 				 * whichever is the most restrictive.
8257c478bd9Sstevel@tonic-gate 				 *
8267c478bd9Sstevel@tonic-gate 				 * ACL for regular files
8277c478bd9Sstevel@tonic-gate 				 */
8287c478bd9Sstevel@tonic-gate 
8297c478bd9Sstevel@tonic-gate 				if (pflg || mve) {
8307c478bd9Sstevel@tonic-gate 					(void) chmod(target, FMODE(s1));
831fa9e4066Sahrens 					if (s1acl != NULL) {
832fa9e4066Sahrens 						if ((acl_set(target,
833fa9e4066Sahrens 						    s1acl)) < 0) {
834cee1ddadSbasabi 							error++;
835cee1ddadSbasabi 							(void) fprintf(stderr,
836cee1ddadSbasabi 							    gettext("%s: "
837cee1ddadSbasabi 							    "Failed to set "
838cee1ddadSbasabi 							    "acl entries "
839cee1ddadSbasabi 							    "on %s\n"), cmd,
840cee1ddadSbasabi 							    target);
84194d2b9abSmarks 							acl_free(s1acl);
84294d2b9abSmarks 							s1acl = NULL;
8437c478bd9Sstevel@tonic-gate 							/*
8447c478bd9Sstevel@tonic-gate 							 * else: silent and
8457c478bd9Sstevel@tonic-gate 							 * continue
8467c478bd9Sstevel@tonic-gate 							 */
8477c478bd9Sstevel@tonic-gate 						}
8487c478bd9Sstevel@tonic-gate 					}
8497c478bd9Sstevel@tonic-gate 				}
8507c478bd9Sstevel@tonic-gate 
8517c478bd9Sstevel@tonic-gate 				if (fstat(fi, &s1) < 0) {
8527c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
8537c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot access %s\n"),
8547c478bd9Sstevel@tonic-gate 					    cmd, source);
8557c478bd9Sstevel@tonic-gate 					return (1);
8567c478bd9Sstevel@tonic-gate 				}
8577c478bd9Sstevel@tonic-gate 				if (IDENTICAL(s1, s2)) {
8587c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
8597c478bd9Sstevel@tonic-gate 					    gettext(
8607c478bd9Sstevel@tonic-gate 					    "%s: %s and %s are identical\n"),
8617c478bd9Sstevel@tonic-gate 					    cmd, source, target);
8627c478bd9Sstevel@tonic-gate 					return (1);
8637c478bd9Sstevel@tonic-gate 				}
8647c478bd9Sstevel@tonic-gate 
865da6c28aaSamw 				if (writefile(fi, fo, source, target, NULL,
866da6c28aaSamw 				    NULL, &s1, &s2) != 0) {
8677c478bd9Sstevel@tonic-gate 					return (1);
8687c478bd9Sstevel@tonic-gate 				}
8697c478bd9Sstevel@tonic-gate 
8707c478bd9Sstevel@tonic-gate 				(void) close(fi);
8717c478bd9Sstevel@tonic-gate 				if (close(fo) < 0) {
8727c478bd9Sstevel@tonic-gate 					Perror2(target, "write");
8737c478bd9Sstevel@tonic-gate 					return (1);
8747c478bd9Sstevel@tonic-gate 				}
8757c478bd9Sstevel@tonic-gate 			}
876da6c28aaSamw 			/* Copy regular extended attributes */
877da6c28aaSamw 			if (pflg || atflg || mve || saflg) {
8787c478bd9Sstevel@tonic-gate 				attret = copyattributes(source, target);
8797c478bd9Sstevel@tonic-gate 				if (attret != 0 && !attrsilent) {
8807c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
8813d63ea05Sas 					    "%s: Failed to preserve"
8823d63ea05Sas 					    " extended attributes of file"
8833d63ea05Sas 					    " %s\n"), cmd, source);
8847c478bd9Sstevel@tonic-gate 				}
885da6c28aaSamw 				/* Copy extended system attributes */
886cee1ddadSbasabi 				if (pflg || mve || saflg)
887da6c28aaSamw 					sattret = copy_sysattr(source, target);
8887c478bd9Sstevel@tonic-gate 				if (mve && attret != 0) {
8897c478bd9Sstevel@tonic-gate 					(void) unlink(target);
8907c478bd9Sstevel@tonic-gate 					return (1);
8917c478bd9Sstevel@tonic-gate 				}
892da6c28aaSamw 				if (attrsilent) {
8937c478bd9Sstevel@tonic-gate 					attret = 0;
894da6c28aaSamw 				}
8957c478bd9Sstevel@tonic-gate 			}
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 			/*
8987c478bd9Sstevel@tonic-gate 			 * XPG4: the write system call will clear setgid
8997c478bd9Sstevel@tonic-gate 			 * and setuid bits, so set them again.
9007c478bd9Sstevel@tonic-gate 			 */
9017c478bd9Sstevel@tonic-gate 			if (pflg || mve) {
9027c478bd9Sstevel@tonic-gate 				if ((ret = chg_mode(target, UID(s1), GID(s1),
9037c478bd9Sstevel@tonic-gate 				    FMODE(s1))) > 0)
9047c478bd9Sstevel@tonic-gate 					return (1);
905d2443e76Smarks 				/*
906d2443e76Smarks 				 * Reapply ACL, since chmod may have
907d2443e76Smarks 				 * altered ACL
908d2443e76Smarks 				 */
909d2443e76Smarks 				if (s1acl != NULL) {
910d2443e76Smarks 					if ((acl_set(target, s1acl)) < 0) {
911cee1ddadSbasabi 						error++;
912cee1ddadSbasabi 						(void) fprintf(stderr,
913cee1ddadSbasabi 						    gettext("%s: Failed to "
914cee1ddadSbasabi 						    "set acl entries "
915cee1ddadSbasabi 						    "on %s\n"), cmd, target);
916d2443e76Smarks 						/*
917d2443e76Smarks 						 * else: silent and
918d2443e76Smarks 						 * continue
919d2443e76Smarks 						 */
920d2443e76Smarks 					}
921d2443e76Smarks 				}
9227c478bd9Sstevel@tonic-gate 				if ((ret = chg_time(target, s1)) > 0)
9237c478bd9Sstevel@tonic-gate 					return (1);
9247c478bd9Sstevel@tonic-gate 			}
9257c478bd9Sstevel@tonic-gate 			if (cpy) {
926cee1ddadSbasabi 				if (error != 0 || attret != 0 || sattret != 0)
9277c478bd9Sstevel@tonic-gate 					return (1);
9287c478bd9Sstevel@tonic-gate 				return (0);
9297c478bd9Sstevel@tonic-gate 			}
9307c478bd9Sstevel@tonic-gate 			goto cleanup;
9317c478bd9Sstevel@tonic-gate 		}
9327c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
9337c478bd9Sstevel@tonic-gate 		    gettext("%s: %s: unknown file type 0x%x\n"), cmd,
9343d63ea05Sas 		    source, (s1.st_mode & S_IFMT));
9357c478bd9Sstevel@tonic-gate 		return (1);
9367c478bd9Sstevel@tonic-gate 
9377c478bd9Sstevel@tonic-gate cleanup:
9387c478bd9Sstevel@tonic-gate 		if (unlink(source) < 0) {
9397c478bd9Sstevel@tonic-gate 			(void) unlink(target);
9407c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
9417c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot unlink %s: "),
9427c478bd9Sstevel@tonic-gate 			    cmd, source);
9437c478bd9Sstevel@tonic-gate 			perror("");
9447c478bd9Sstevel@tonic-gate 			return (1);
9457c478bd9Sstevel@tonic-gate 		}
946cee1ddadSbasabi 		if (error != 0 || attret != 0 || sattret != 0)
947cee1ddadSbasabi 			return (1);
9487c478bd9Sstevel@tonic-gate 		return (ret);
9497c478bd9Sstevel@tonic-gate 	}
9507c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
951a77d64afScf 	return (ret);
9527c478bd9Sstevel@tonic-gate }
9537c478bd9Sstevel@tonic-gate 
9547c478bd9Sstevel@tonic-gate /*
9557c478bd9Sstevel@tonic-gate  * create_tnode()
9567c478bd9Sstevel@tonic-gate  *
9577c478bd9Sstevel@tonic-gate  * Create a node for use with the search tree which contains the
9587c478bd9Sstevel@tonic-gate  * inode information (device id and inode number).
9597c478bd9Sstevel@tonic-gate  *
9607c478bd9Sstevel@tonic-gate  * Input
9617c478bd9Sstevel@tonic-gate  *	dev	- device id
9627c478bd9Sstevel@tonic-gate  *	ino	- inode number
9637c478bd9Sstevel@tonic-gate  *
9647c478bd9Sstevel@tonic-gate  * Output
9657c478bd9Sstevel@tonic-gate  *	tnode	- NULL on error, otherwise returns a tnode structure
9667c478bd9Sstevel@tonic-gate  *		  which contains the input device id and inode number.
9677c478bd9Sstevel@tonic-gate  */
9687c478bd9Sstevel@tonic-gate static tree_node_t *
9697c478bd9Sstevel@tonic-gate create_tnode(dev_t dev, ino_t ino)
9707c478bd9Sstevel@tonic-gate {
9717c478bd9Sstevel@tonic-gate 	tree_node_t	*tnode;
9727c478bd9Sstevel@tonic-gate 
9737c478bd9Sstevel@tonic-gate 	if ((tnode = (tree_node_t *)malloc(sizeof (tree_node_t))) != NULL) {
9747c478bd9Sstevel@tonic-gate 		tnode->node_dev = dev;
9757c478bd9Sstevel@tonic-gate 		tnode->node_ino = ino;
9767c478bd9Sstevel@tonic-gate 	}
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate 	return (tnode);
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate 
9817c478bd9Sstevel@tonic-gate static int
9827c478bd9Sstevel@tonic-gate chkfiles(char *source, char **to)
9837c478bd9Sstevel@tonic-gate {
9847c478bd9Sstevel@tonic-gate 	char	*buf = (char *)NULL;
9857c478bd9Sstevel@tonic-gate 	int	(*statf)() = (cpy &&
9863d63ea05Sas 	    !(Pflg || (Hflg && !cmdarg))) ? stat : lstat;
9877c478bd9Sstevel@tonic-gate 	char    *target = *to;
988fa9e4066Sahrens 	int	error;
9897c478bd9Sstevel@tonic-gate 
9907c478bd9Sstevel@tonic-gate 	/*
9917c478bd9Sstevel@tonic-gate 	 * Make sure source file exists.
9927c478bd9Sstevel@tonic-gate 	 */
9937c478bd9Sstevel@tonic-gate 	if ((*statf)(source, &s1) < 0) {
9947c478bd9Sstevel@tonic-gate 		/*
9957c478bd9Sstevel@tonic-gate 		 * Keep the old error message except when someone tries to
9967c478bd9Sstevel@tonic-gate 		 * mv/cp/ln a symbolic link that has a trailing slash and
9977c478bd9Sstevel@tonic-gate 		 * points to a file.
9987c478bd9Sstevel@tonic-gate 		 */
9997c478bd9Sstevel@tonic-gate 		if (errno == ENOTDIR)
10007c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, "%s: %s: %s\n", cmd, source,
10017c478bd9Sstevel@tonic-gate 			    strerror(errno));
10027c478bd9Sstevel@tonic-gate 		else
10037c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
10047c478bd9Sstevel@tonic-gate 			    gettext("%s: cannot access %s\n"), cmd, source);
10057c478bd9Sstevel@tonic-gate 		return (1);
10067c478bd9Sstevel@tonic-gate 	}
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 	/*
10097c478bd9Sstevel@tonic-gate 	 * Get ACL info: don't bother with ln or mv'ing symlinks
10107c478bd9Sstevel@tonic-gate 	 */
10117c478bd9Sstevel@tonic-gate 	if ((!lnk) && !(mve && ISLNK(s1))) {
1012fa9e4066Sahrens 		if (s1acl != NULL) {
1013fa9e4066Sahrens 			acl_free(s1acl);
1014fa9e4066Sahrens 			s1acl = NULL;
10157c478bd9Sstevel@tonic-gate 		}
1016fa9e4066Sahrens 		if ((error = acl_get(source, ACL_NO_TRIVIAL, &s1acl)) != 0) {
10177c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
1018fa9e4066Sahrens 			    "%s: failed to get acl entries: %s\n", source,
1019fa9e4066Sahrens 			    acl_strerror(error));
10207c478bd9Sstevel@tonic-gate 			return (1);
10217c478bd9Sstevel@tonic-gate 		}
10227c478bd9Sstevel@tonic-gate 		/* else: just permission bits */
10237c478bd9Sstevel@tonic-gate 	}
10247c478bd9Sstevel@tonic-gate 
10257c478bd9Sstevel@tonic-gate 	/*
10267c478bd9Sstevel@tonic-gate 	 * If stat fails, then the target doesn't exist,
10277c478bd9Sstevel@tonic-gate 	 * we will create a new target with default file type of regular.
10287c478bd9Sstevel@tonic-gate 	 */
10297c478bd9Sstevel@tonic-gate 
10307c478bd9Sstevel@tonic-gate 	FTYPE(s2) = S_IFREG;
10317c478bd9Sstevel@tonic-gate 	targetexists = 0;
10327c478bd9Sstevel@tonic-gate 	if ((*statf)(target, &s2) >= 0) {
10337c478bd9Sstevel@tonic-gate 		if (ISLNK(s2))
10347c478bd9Sstevel@tonic-gate 			(void) stat(target, &s2);
10357c478bd9Sstevel@tonic-gate 		/*
10367c478bd9Sstevel@tonic-gate 		 * If target is a directory,
10377c478bd9Sstevel@tonic-gate 		 * make complete name of new file
10387c478bd9Sstevel@tonic-gate 		 * within that directory.
10397c478bd9Sstevel@tonic-gate 		 */
10407c478bd9Sstevel@tonic-gate 		if (ISDIR(s2)) {
10417c478bd9Sstevel@tonic-gate 			size_t len;
10427c478bd9Sstevel@tonic-gate 
10437c478bd9Sstevel@tonic-gate 			len = strlen(target) + strlen(dname(source)) + 4;
10447c478bd9Sstevel@tonic-gate 			if ((buf = (char *)malloc(len)) == NULL) {
10457c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
10467c478bd9Sstevel@tonic-gate 				    gettext("%s: Insufficient memory to "
10473d63ea05Sas 				    "%s %s\n "), cmd, cmd, source);
10487c478bd9Sstevel@tonic-gate 				exit(3);
10497c478bd9Sstevel@tonic-gate 			}
10507c478bd9Sstevel@tonic-gate 			(void) snprintf(buf, len, "%s/%s",
10517c478bd9Sstevel@tonic-gate 			    target, dname(source));
10527c478bd9Sstevel@tonic-gate 			*to = target = buf;
10537c478bd9Sstevel@tonic-gate 		}
10547c478bd9Sstevel@tonic-gate 
10557c478bd9Sstevel@tonic-gate 		if ((*statf)(target, &s2) >= 0) {
10567c478bd9Sstevel@tonic-gate 			int overwrite	= FALSE;
10577c478bd9Sstevel@tonic-gate 			int override	= FALSE;
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate 			targetexists++;
10607c478bd9Sstevel@tonic-gate 			if (cpy || mve) {
10617c478bd9Sstevel@tonic-gate 				/*
10627c478bd9Sstevel@tonic-gate 				 * For cp and mv, it is an error if the
10637c478bd9Sstevel@tonic-gate 				 * source and target are the same file.
10647c478bd9Sstevel@tonic-gate 				 * Check for the same inode and file
10657c478bd9Sstevel@tonic-gate 				 * system, but don't check for the same
10667c478bd9Sstevel@tonic-gate 				 * absolute pathname because it is an
10677c478bd9Sstevel@tonic-gate 				 * error when the source and target are
10687c478bd9Sstevel@tonic-gate 				 * hard links to the same file.
10697c478bd9Sstevel@tonic-gate 				 */
10707c478bd9Sstevel@tonic-gate 				if (IDENTICAL(s1, s2)) {
10717c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
10727c478bd9Sstevel@tonic-gate 					    gettext(
10737c478bd9Sstevel@tonic-gate 					    "%s: %s and %s are identical\n"),
10747c478bd9Sstevel@tonic-gate 					    cmd, source, target);
10757c478bd9Sstevel@tonic-gate 					if (buf != NULL)
10767c478bd9Sstevel@tonic-gate 						free(buf);
10777c478bd9Sstevel@tonic-gate 					return (1);
10787c478bd9Sstevel@tonic-gate 				}
10797c478bd9Sstevel@tonic-gate 			}
10807c478bd9Sstevel@tonic-gate 			if (lnk) {
10817c478bd9Sstevel@tonic-gate 				/*
10827c478bd9Sstevel@tonic-gate 				 * For ln, it is an error if the source and
10837c478bd9Sstevel@tonic-gate 				 * target are identical files (same inode,
10847c478bd9Sstevel@tonic-gate 				 * same file system, and filenames resolve
10857c478bd9Sstevel@tonic-gate 				 * to same absolute pathname).
10867c478bd9Sstevel@tonic-gate 				 */
10877c478bd9Sstevel@tonic-gate 				if (!chk_different(source, target)) {
10887c478bd9Sstevel@tonic-gate 					if (buf != NULL)
10897c478bd9Sstevel@tonic-gate 						free(buf);
10907c478bd9Sstevel@tonic-gate 					return (1);
10917c478bd9Sstevel@tonic-gate 				}
10927c478bd9Sstevel@tonic-gate 			}
10937c478bd9Sstevel@tonic-gate 			if (lnk && !silent) {
10947c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
10957c478bd9Sstevel@tonic-gate 				    gettext("%s: %s: File exists\n"),
10967c478bd9Sstevel@tonic-gate 				    cmd, target);
10977c478bd9Sstevel@tonic-gate 				if (buf != NULL)
10987c478bd9Sstevel@tonic-gate 					free(buf);
10997c478bd9Sstevel@tonic-gate 				return (1);
11007c478bd9Sstevel@tonic-gate 			}
11017c478bd9Sstevel@tonic-gate 
11027c478bd9Sstevel@tonic-gate 			/*
11037c478bd9Sstevel@tonic-gate 			 * overwrite:
11047c478bd9Sstevel@tonic-gate 			 * If the user does not have access to
11057c478bd9Sstevel@tonic-gate 			 * the target, ask ----if it is not
11067c478bd9Sstevel@tonic-gate 			 * silent and user invoked command
11077c478bd9Sstevel@tonic-gate 			 * interactively.
11087c478bd9Sstevel@tonic-gate 			 *
11097c478bd9Sstevel@tonic-gate 			 * override:
11107c478bd9Sstevel@tonic-gate 			 * If not silent, and stdin is a terminal, and
11117c478bd9Sstevel@tonic-gate 			 * there's no write access, and the file isn't a
11127c478bd9Sstevel@tonic-gate 			 * symbolic link, ask for permission.
11137c478bd9Sstevel@tonic-gate 			 *
11147c478bd9Sstevel@tonic-gate 			 * XPG4: both overwrite and override:
11157c478bd9Sstevel@tonic-gate 			 * ask only one question.
11167c478bd9Sstevel@tonic-gate 			 *
11177c478bd9Sstevel@tonic-gate 			 * TRANSLATION_NOTE - The following messages will
11187c478bd9Sstevel@tonic-gate 			 * contain the first character of the strings for
11197c478bd9Sstevel@tonic-gate 			 * "yes" and "no" defined in the file
11207c478bd9Sstevel@tonic-gate 			 * "nl_langinfo.po".  After substitution, the
11217c478bd9Sstevel@tonic-gate 			 * message will appear as follows:
11227c478bd9Sstevel@tonic-gate 			 *	<cmd>: overwrite <filename> (y/n)?
11237c478bd9Sstevel@tonic-gate 			 * where <cmd> is the name of the command
11247c478bd9Sstevel@tonic-gate 			 * (cp, mv) and <filename> is the destination file
11257c478bd9Sstevel@tonic-gate 			 */
11267c478bd9Sstevel@tonic-gate 
11277c478bd9Sstevel@tonic-gate 
11287c478bd9Sstevel@tonic-gate 			overwrite = iflg && !silent && use_stdin();
11297c478bd9Sstevel@tonic-gate 			override = !cpy && (access(target, 2) < 0) &&
11307c478bd9Sstevel@tonic-gate 			    !silent && use_stdin() && !ISLNK(s2);
11317c478bd9Sstevel@tonic-gate 
11320f6e7ba6Sas 			if (overwrite && override) {
11337c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
11347c478bd9Sstevel@tonic-gate 				    gettext("%s: overwrite %s and override "
11357c478bd9Sstevel@tonic-gate 				    "protection %o (%s/%s)? "), cmd, target,
11363d63ea05Sas 				    FMODE(s2) & MODEBITS, yesstr, nostr);
11373d63ea05Sas 				if (yes() == 0) {
11380f6e7ba6Sas 					if (buf != NULL)
11390f6e7ba6Sas 						free(buf);
11400f6e7ba6Sas 					return (2);
11410f6e7ba6Sas 				}
11420f6e7ba6Sas 			} else if (overwrite && ISREG(s2)) {
11437c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
11447c478bd9Sstevel@tonic-gate 				    gettext("%s: overwrite %s (%s/%s)? "),
11453d63ea05Sas 				    cmd, target, yesstr, nostr);
11463d63ea05Sas 				if (yes() == 0) {
11470f6e7ba6Sas 					if (buf != NULL)
11480f6e7ba6Sas 						free(buf);
11490f6e7ba6Sas 					return (2);
11500f6e7ba6Sas 				}
11510f6e7ba6Sas 			} else if (override) {
11527c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
11537c478bd9Sstevel@tonic-gate 				    gettext("%s: %s: override protection "
11547c478bd9Sstevel@tonic-gate 				    /*CSTYLED*/
11557c478bd9Sstevel@tonic-gate 				    "%o (%s/%s)? "),
11567c478bd9Sstevel@tonic-gate 				    /*CSTYLED*/
11577c478bd9Sstevel@tonic-gate 				    cmd, target, FMODE(s2) & MODEBITS,
11583d63ea05Sas 				    yesstr, nostr);
11593d63ea05Sas 				if (yes() == 0) {
11600f6e7ba6Sas 					if (buf != NULL)
11610f6e7ba6Sas 						free(buf);
11620f6e7ba6Sas 					return (2);
11637c478bd9Sstevel@tonic-gate 				}
11647c478bd9Sstevel@tonic-gate 			}
11650f6e7ba6Sas 
11667c478bd9Sstevel@tonic-gate 			if (lnk && unlink(target) < 0) {
11677c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
11687c478bd9Sstevel@tonic-gate 				    gettext("%s: cannot unlink %s: "),
11697c478bd9Sstevel@tonic-gate 				    cmd, target);
11707c478bd9Sstevel@tonic-gate 				perror("");
11717c478bd9Sstevel@tonic-gate 				return (1);
11727c478bd9Sstevel@tonic-gate 			}
11737c478bd9Sstevel@tonic-gate 		}
11747c478bd9Sstevel@tonic-gate 	}
11757c478bd9Sstevel@tonic-gate 	return (0);
11767c478bd9Sstevel@tonic-gate }
11777c478bd9Sstevel@tonic-gate 
11787c478bd9Sstevel@tonic-gate /*
11797c478bd9Sstevel@tonic-gate  * check whether source and target are different
11807c478bd9Sstevel@tonic-gate  * return 1 when they are different
11817c478bd9Sstevel@tonic-gate  * return 0 when they are identical, or when unable to resolve a pathname
11827c478bd9Sstevel@tonic-gate  */
11837c478bd9Sstevel@tonic-gate static int
11847c478bd9Sstevel@tonic-gate chk_different(char *source, char *target)
11857c478bd9Sstevel@tonic-gate {
11867c478bd9Sstevel@tonic-gate 	char	rtarget[PATH_MAX], rsource[PATH_MAX];
11877c478bd9Sstevel@tonic-gate 
11887c478bd9Sstevel@tonic-gate 	if (IDENTICAL(s1, s2)) {
11897c478bd9Sstevel@tonic-gate 		/*
11907c478bd9Sstevel@tonic-gate 		 * IDENTICAL will be true for hard links, therefore
11917c478bd9Sstevel@tonic-gate 		 * check whether the filenames are different
11927c478bd9Sstevel@tonic-gate 		 */
11937c478bd9Sstevel@tonic-gate 		if ((getrealpath(source, rsource) == 0) ||
11947c478bd9Sstevel@tonic-gate 		    (getrealpath(target, rtarget) == 0)) {
11957c478bd9Sstevel@tonic-gate 			return (0);
11967c478bd9Sstevel@tonic-gate 		}
11977c478bd9Sstevel@tonic-gate 		if (strncmp(rsource, rtarget, PATH_MAX) == 0) {
11987c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, gettext(
11997c478bd9Sstevel@tonic-gate 			    "%s: %s and %s are identical\n"),
12007c478bd9Sstevel@tonic-gate 			    cmd, source, target);
12017c478bd9Sstevel@tonic-gate 			return (0);
12027c478bd9Sstevel@tonic-gate 		}
12037c478bd9Sstevel@tonic-gate 	}
12047c478bd9Sstevel@tonic-gate 	return (1);
12057c478bd9Sstevel@tonic-gate }
12067c478bd9Sstevel@tonic-gate 
12077c478bd9Sstevel@tonic-gate /*
12087c478bd9Sstevel@tonic-gate  * get real path (resolved absolute pathname)
12097c478bd9Sstevel@tonic-gate  * return 1 on success, 0 on failure
12107c478bd9Sstevel@tonic-gate  */
12117c478bd9Sstevel@tonic-gate static int
12127c478bd9Sstevel@tonic-gate getrealpath(char *path, char *rpath)
12137c478bd9Sstevel@tonic-gate {
12147c478bd9Sstevel@tonic-gate 	if (realpath(path, rpath) == NULL) {
12157c478bd9Sstevel@tonic-gate 		int	errno_save = errno;
12167c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, gettext(
12177c478bd9Sstevel@tonic-gate 		    "%s: can't resolve path %s: "), cmd, path);
12187c478bd9Sstevel@tonic-gate 		errno = errno_save;
12197c478bd9Sstevel@tonic-gate 		perror("");
12207c478bd9Sstevel@tonic-gate 		return (0);
12217c478bd9Sstevel@tonic-gate 	}
12227c478bd9Sstevel@tonic-gate 	return (1);
12237c478bd9Sstevel@tonic-gate }
12247c478bd9Sstevel@tonic-gate 
12257c478bd9Sstevel@tonic-gate static int
12267c478bd9Sstevel@tonic-gate rcopy(char *from, char *to)
12277c478bd9Sstevel@tonic-gate {
12287c478bd9Sstevel@tonic-gate 	DIR *fold = opendir(from);
12297c478bd9Sstevel@tonic-gate 	struct dirent *dp;
12307c478bd9Sstevel@tonic-gate 	struct stat statb, s1save;
12317c478bd9Sstevel@tonic-gate 	int errs = 0;
12327c478bd9Sstevel@tonic-gate 	char fromname[PATH_MAX];
12337c478bd9Sstevel@tonic-gate 
12347c478bd9Sstevel@tonic-gate 	if (fold == 0 || ((pflg || mve) && fstat(fold->dd_fd, &statb) < 0)) {
12357c478bd9Sstevel@tonic-gate 		Perror(from);
12367c478bd9Sstevel@tonic-gate 		return (1);
12377c478bd9Sstevel@tonic-gate 	}
12387c478bd9Sstevel@tonic-gate 	if (pflg || mve) {
12397c478bd9Sstevel@tonic-gate 		/*
12407c478bd9Sstevel@tonic-gate 		 * Save s1 (stat information for source dir) so that
12417c478bd9Sstevel@tonic-gate 		 * mod and access times can be reserved during "cp -p"
12427c478bd9Sstevel@tonic-gate 		 * or mv, since s1 gets overwritten.
12437c478bd9Sstevel@tonic-gate 		 */
12447c478bd9Sstevel@tonic-gate 		s1save = s1;
12457c478bd9Sstevel@tonic-gate 	}
12467c478bd9Sstevel@tonic-gate 	for (;;) {
12477c478bd9Sstevel@tonic-gate 		dp = readdir(fold);
12487c478bd9Sstevel@tonic-gate 		if (dp == 0) {
12497c478bd9Sstevel@tonic-gate 			(void) closedir(fold);
12507c478bd9Sstevel@tonic-gate 			if (pflg || mve)
12517c478bd9Sstevel@tonic-gate 				return (chg_time(to, s1save) + errs);
12527c478bd9Sstevel@tonic-gate 			return (errs);
12537c478bd9Sstevel@tonic-gate 		}
12547c478bd9Sstevel@tonic-gate 		if (dp->d_ino == 0)
12557c478bd9Sstevel@tonic-gate 			continue;
12567c478bd9Sstevel@tonic-gate 		if ((strcmp(dp->d_name, ".") == 0) ||
12577c478bd9Sstevel@tonic-gate 		    (strcmp(dp->d_name, "..") == 0))
12587c478bd9Sstevel@tonic-gate 			continue;
12597c478bd9Sstevel@tonic-gate 		if (strlen(from)+1+strlen(dp->d_name) >=
12607c478bd9Sstevel@tonic-gate 		    sizeof (fromname) - 1) {
12617c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
12627c478bd9Sstevel@tonic-gate 			    gettext("%s : %s/%s: Name too long\n"),
12637c478bd9Sstevel@tonic-gate 			    cmd, from, dp->d_name);
12647c478bd9Sstevel@tonic-gate 			errs++;
12657c478bd9Sstevel@tonic-gate 			continue;
12667c478bd9Sstevel@tonic-gate 		}
12677c478bd9Sstevel@tonic-gate 		(void) snprintf(fromname, sizeof (fromname),
12687c478bd9Sstevel@tonic-gate 		    "%s/%s", from, dp->d_name);
12697c478bd9Sstevel@tonic-gate 		errs += cpymve(fromname, to);
12707c478bd9Sstevel@tonic-gate 	}
12717c478bd9Sstevel@tonic-gate }
12727c478bd9Sstevel@tonic-gate 
12737c478bd9Sstevel@tonic-gate static char *
12747c478bd9Sstevel@tonic-gate dname(char *name)
12757c478bd9Sstevel@tonic-gate {
12767c478bd9Sstevel@tonic-gate 	register char *p;
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate 	/*
12797c478bd9Sstevel@tonic-gate 	 * Return just the file name given the complete path.
12807c478bd9Sstevel@tonic-gate 	 * Like basename(1).
12817c478bd9Sstevel@tonic-gate 	 */
12827c478bd9Sstevel@tonic-gate 
12837c478bd9Sstevel@tonic-gate 	p = name;
12847c478bd9Sstevel@tonic-gate 
12857c478bd9Sstevel@tonic-gate 	/*
12867c478bd9Sstevel@tonic-gate 	 * While there are characters left,
12877c478bd9Sstevel@tonic-gate 	 * set name to start after last
12887c478bd9Sstevel@tonic-gate 	 * delimiter.
12897c478bd9Sstevel@tonic-gate 	 */
12907c478bd9Sstevel@tonic-gate 
12917c478bd9Sstevel@tonic-gate 	while (*p)
12927c478bd9Sstevel@tonic-gate 		if (*p++ == DELIM && *p)
12937c478bd9Sstevel@tonic-gate 			name = p;
12947c478bd9Sstevel@tonic-gate 	return (name);
12957c478bd9Sstevel@tonic-gate }
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate static void
12987c478bd9Sstevel@tonic-gate usage(void)
12997c478bd9Sstevel@tonic-gate {
13007c478bd9Sstevel@tonic-gate 	/*
13017c478bd9Sstevel@tonic-gate 	 * Display usage message.
13027c478bd9Sstevel@tonic-gate 	 */
13037c478bd9Sstevel@tonic-gate 
13047c478bd9Sstevel@tonic-gate 	if (mve) {
13057c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, gettext(
13067c478bd9Sstevel@tonic-gate 		    "Usage: mv [-f] [-i] f1 f2\n"
13077c478bd9Sstevel@tonic-gate 		    "       mv [-f] [-i] f1 ... fn d1\n"
13087c478bd9Sstevel@tonic-gate 		    "       mv [-f] [-i] d1 d2\n"));
13097c478bd9Sstevel@tonic-gate 	} else if (lnk) {
13107c478bd9Sstevel@tonic-gate #ifdef XPG4
13113d63ea05Sas 		(void) fprintf(stderr, gettext(
13127c478bd9Sstevel@tonic-gate 		    "Usage: ln [-f] [-s] f1 [f2]\n"
13137c478bd9Sstevel@tonic-gate 		    "       ln [-f] [-s] f1 ... fn d1\n"
13147c478bd9Sstevel@tonic-gate 		    "       ln [-f] -s d1 d2\n"));
13157c478bd9Sstevel@tonic-gate #else
13163d63ea05Sas 		(void) fprintf(stderr, gettext(
13177c478bd9Sstevel@tonic-gate 		    "Usage: ln [-f] [-n] [-s] f1 [f2]\n"
13187c478bd9Sstevel@tonic-gate 		    "       ln [-f] [-n] [-s] f1 ... fn d1\n"
13197c478bd9Sstevel@tonic-gate 		    "       ln [-f] [-n] -s d1 d2\n"));
13207c478bd9Sstevel@tonic-gate #endif
13217c478bd9Sstevel@tonic-gate 	} else if (cpy) {
13227c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, gettext(
1323da6c28aaSamw 		    "Usage: cp [-f] [-i] [-p] [-@] [-/] f1 f2\n"
1324da6c28aaSamw 		    "       cp [-f] [-i] [-p] [-@] [-/] f1 ... fn d1\n"
1325da6c28aaSamw 		    "       cp -r|-R [-H|-L|-P] [-f] [-i] [-p] [-@] [-/] "
13267c478bd9Sstevel@tonic-gate 		    "d1 ... dn-1 dn\n"));
13277c478bd9Sstevel@tonic-gate 	}
13287c478bd9Sstevel@tonic-gate 	exit(2);
13297c478bd9Sstevel@tonic-gate }
13307c478bd9Sstevel@tonic-gate 
13317c478bd9Sstevel@tonic-gate /*
13327c478bd9Sstevel@tonic-gate  * chg_time()
13337c478bd9Sstevel@tonic-gate  *
13347c478bd9Sstevel@tonic-gate  * Try to preserve modification and access time.
13357c478bd9Sstevel@tonic-gate  * If 1) pflg is not set, or 2) pflg is set and this is the Solaris version,
13367c478bd9Sstevel@tonic-gate  * don't report a utime() failure.
13377c478bd9Sstevel@tonic-gate  * If this is the XPG4 version and utime fails, if 1) pflg is set (cp -p)
13387c478bd9Sstevel@tonic-gate  * or 2) we are doing a mv, print a diagnostic message; arrange for a non-zero
13397c478bd9Sstevel@tonic-gate  * exit status only if pflg is set.
13407c478bd9Sstevel@tonic-gate  * utimes(2) is being used to achieve granularity in
13417c478bd9Sstevel@tonic-gate  * microseconds while setting file times.
13427c478bd9Sstevel@tonic-gate  */
13437c478bd9Sstevel@tonic-gate static int
13447c478bd9Sstevel@tonic-gate chg_time(char *to, struct stat ss)
13457c478bd9Sstevel@tonic-gate {
13467c478bd9Sstevel@tonic-gate 	struct timeval times[2];
13477c478bd9Sstevel@tonic-gate 	int rc;
13487c478bd9Sstevel@tonic-gate 
13497c478bd9Sstevel@tonic-gate 	timestruc_to_timeval(&ss.st_atim, times);
13507c478bd9Sstevel@tonic-gate 	timestruc_to_timeval(&ss.st_mtim, times + 1);
13517c478bd9Sstevel@tonic-gate 
13527c478bd9Sstevel@tonic-gate 	rc = utimes(to, times);
13537c478bd9Sstevel@tonic-gate #ifdef XPG4
13547c478bd9Sstevel@tonic-gate 	if ((pflg || mve) && rc != 0) {
13557c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
13567c478bd9Sstevel@tonic-gate 		    gettext("%s: cannot set times for %s: "), cmd, to);
13577c478bd9Sstevel@tonic-gate 		perror("");
13587c478bd9Sstevel@tonic-gate 		if (pflg)
13597c478bd9Sstevel@tonic-gate 			return (1);
13607c478bd9Sstevel@tonic-gate 	}
13617c478bd9Sstevel@tonic-gate #endif
13627c478bd9Sstevel@tonic-gate 
13637c478bd9Sstevel@tonic-gate 	return (0);
13647c478bd9Sstevel@tonic-gate 
13657c478bd9Sstevel@tonic-gate }
13667c478bd9Sstevel@tonic-gate 
13677c478bd9Sstevel@tonic-gate /*
13687c478bd9Sstevel@tonic-gate  * chg_mode()
13697c478bd9Sstevel@tonic-gate  *
13707c478bd9Sstevel@tonic-gate  * This function is called upon "cp -p" or mv across filesystems.
13717c478bd9Sstevel@tonic-gate  *
13727c478bd9Sstevel@tonic-gate  * Try to preserve the owner and group id.  If chown() fails,
13737c478bd9Sstevel@tonic-gate  * only print a diagnostic message if doing a mv in the XPG4 version;
13747c478bd9Sstevel@tonic-gate  * try to clear S_ISUID and S_ISGID bits in the target.  If unable to clear
13757c478bd9Sstevel@tonic-gate  * S_ISUID and S_ISGID bits, print a diagnostic message and arrange for a
13767c478bd9Sstevel@tonic-gate  * non-zero exit status because this is a security violation.
13777c478bd9Sstevel@tonic-gate  * Try to preserve permissions.
13787c478bd9Sstevel@tonic-gate  * If this is the XPG4 version and chmod() fails, print a diagnostic message
13797c478bd9Sstevel@tonic-gate  * and arrange for a non-zero exit status.
13807c478bd9Sstevel@tonic-gate  * If this is the Solaris version and chmod() fails, do not print a
13817c478bd9Sstevel@tonic-gate  * diagnostic message or exit with a non-zero value.
13827c478bd9Sstevel@tonic-gate  */
13837c478bd9Sstevel@tonic-gate static int
13847c478bd9Sstevel@tonic-gate chg_mode(char *target, uid_t uid, gid_t gid, mode_t mode)
13857c478bd9Sstevel@tonic-gate {
13867c478bd9Sstevel@tonic-gate 	int clearflg = 0; /* controls message printed upon chown() error */
13877c478bd9Sstevel@tonic-gate 
13887c478bd9Sstevel@tonic-gate 	if (chown(target, uid, gid) != 0) {
13897c478bd9Sstevel@tonic-gate #ifdef XPG4
13907c478bd9Sstevel@tonic-gate 		if (mve) {
13917c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, gettext("%s: cannot change"
13927c478bd9Sstevel@tonic-gate 			    " owner and group of %s: "), cmd, target);
13937c478bd9Sstevel@tonic-gate 			perror("");
13947c478bd9Sstevel@tonic-gate 		}
13957c478bd9Sstevel@tonic-gate #endif
13967c478bd9Sstevel@tonic-gate 		if (mode & (S_ISUID | S_ISGID)) {
13977c478bd9Sstevel@tonic-gate 			/* try to clear S_ISUID and S_ISGID */
13987c478bd9Sstevel@tonic-gate 			mode &= ~S_ISUID & ~S_ISGID;
13997c478bd9Sstevel@tonic-gate 			++clearflg;
14007c478bd9Sstevel@tonic-gate 		}
14017c478bd9Sstevel@tonic-gate 	}
14027c478bd9Sstevel@tonic-gate 	if (chmod(target, mode) != 0) {
14037c478bd9Sstevel@tonic-gate 		if (clearflg) {
14047c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, gettext(
14057c478bd9Sstevel@tonic-gate 			    "%s: cannot clear S_ISUID and S_ISGID bits in"
14067c478bd9Sstevel@tonic-gate 			    " %s: "), cmd, target);
14077c478bd9Sstevel@tonic-gate 			perror("");
14087c478bd9Sstevel@tonic-gate 			/* cp -p should get non-zero exit; mv should not */
14097c478bd9Sstevel@tonic-gate 			if (pflg)
14107c478bd9Sstevel@tonic-gate 				return (1);
14117c478bd9Sstevel@tonic-gate 		}
14127c478bd9Sstevel@tonic-gate #ifdef XPG4
14137c478bd9Sstevel@tonic-gate 		else {
14147c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, gettext(
14157c478bd9Sstevel@tonic-gate 			"%s: cannot set permissions for %s: "), cmd, target);
14167c478bd9Sstevel@tonic-gate 			perror("");
14177c478bd9Sstevel@tonic-gate 			/* cp -p should get non-zero exit; mv should not */
14187c478bd9Sstevel@tonic-gate 			if (pflg)
14197c478bd9Sstevel@tonic-gate 				return (1);
14207c478bd9Sstevel@tonic-gate 		}
14217c478bd9Sstevel@tonic-gate #endif
14227c478bd9Sstevel@tonic-gate 	}
14237c478bd9Sstevel@tonic-gate 	return (0);
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate }
14267c478bd9Sstevel@tonic-gate 
14277c478bd9Sstevel@tonic-gate static void
14287c478bd9Sstevel@tonic-gate Perror(char *s)
14297c478bd9Sstevel@tonic-gate {
14307c478bd9Sstevel@tonic-gate 	char buf[PATH_MAX + 10];
14317c478bd9Sstevel@tonic-gate 
14327c478bd9Sstevel@tonic-gate 	(void) snprintf(buf, sizeof (buf), "%s: %s", cmd, s);
14337c478bd9Sstevel@tonic-gate 	perror(buf);
14347c478bd9Sstevel@tonic-gate }
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate static void
14377c478bd9Sstevel@tonic-gate Perror2(char *s1, char *s2)
14387c478bd9Sstevel@tonic-gate {
14397c478bd9Sstevel@tonic-gate 	char buf[PATH_MAX + 20];
14407c478bd9Sstevel@tonic-gate 
14417c478bd9Sstevel@tonic-gate 	(void) snprintf(buf, sizeof (buf), "%s: %s: %s",
14427c478bd9Sstevel@tonic-gate 	    cmd, gettext(s1), gettext(s2));
14437c478bd9Sstevel@tonic-gate 	perror(buf);
14447c478bd9Sstevel@tonic-gate }
14457c478bd9Sstevel@tonic-gate 
14467c478bd9Sstevel@tonic-gate /*
14477c478bd9Sstevel@tonic-gate  * used for cp -R and for mv across file systems
14487c478bd9Sstevel@tonic-gate  */
14497c478bd9Sstevel@tonic-gate static int
14507c478bd9Sstevel@tonic-gate copydir(char *source, char *target)
14517c478bd9Sstevel@tonic-gate {
14527c478bd9Sstevel@tonic-gate 	int ret, attret = 0;
1453cee1ddadSbasabi 	int sattret = 0;
14547c478bd9Sstevel@tonic-gate 	int pret = 0;		/* need separate flag if -p is specified */
14557c478bd9Sstevel@tonic-gate 	mode_t	fixmode = (mode_t)0;	/* cleanup mode after copy */
14567c478bd9Sstevel@tonic-gate 	struct stat s1save;
1457fa9e4066Sahrens 	acl_t  *s1acl_save;
1458cee1ddadSbasabi 	int error = 0;
1459fa9e4066Sahrens 
1460fa9e4066Sahrens 	s1acl_save = NULL;
14617c478bd9Sstevel@tonic-gate 
14627c478bd9Sstevel@tonic-gate 	if (cpy && !rflg) {
14637c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
14647c478bd9Sstevel@tonic-gate 		    gettext("%s: %s: is a directory\n"), cmd, source);
14657c478bd9Sstevel@tonic-gate 		return (1);
14667c478bd9Sstevel@tonic-gate 	}
14677c478bd9Sstevel@tonic-gate 
14687c478bd9Sstevel@tonic-gate 	if (stat(target, &s2) < 0) {
14697c478bd9Sstevel@tonic-gate 		if (mkdir(target, (s1.st_mode & MODEBITS)) < 0) {
14707c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, "%s: ", cmd);
14717c478bd9Sstevel@tonic-gate 			perror(target);
14727c478bd9Sstevel@tonic-gate 			return (1);
14737c478bd9Sstevel@tonic-gate 		}
14747c478bd9Sstevel@tonic-gate 		if (stat(target, &s2) == 0) {
14757c478bd9Sstevel@tonic-gate 			fixmode = s2.st_mode;
14767c478bd9Sstevel@tonic-gate 		} else {
14777c478bd9Sstevel@tonic-gate 			fixmode = s1.st_mode;
14787c478bd9Sstevel@tonic-gate 		}
14797c478bd9Sstevel@tonic-gate 		(void) chmod(target, ((fixmode & MODEBITS) | S_IRWXU));
14807c478bd9Sstevel@tonic-gate 	} else if (!(ISDIR(s2))) {
14817c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
14827c478bd9Sstevel@tonic-gate 		    gettext("%s: %s: not a directory.\n"), cmd, target);
14837c478bd9Sstevel@tonic-gate 		return (1);
14847c478bd9Sstevel@tonic-gate 	}
14857c478bd9Sstevel@tonic-gate 	if (pflg || mve) {
14867c478bd9Sstevel@tonic-gate 		/*
14877c478bd9Sstevel@tonic-gate 		 * Save s1 (stat information for source dir) and acl info,
14887c478bd9Sstevel@tonic-gate 		 * if any, so that ownership, modes, times, and acl's can
14897c478bd9Sstevel@tonic-gate 		 * be reserved during "cp -p" or mv.
14907c478bd9Sstevel@tonic-gate 		 * s1 gets overwritten when doing the recursive copy.
14917c478bd9Sstevel@tonic-gate 		 */
14927c478bd9Sstevel@tonic-gate 		s1save = s1;
1493fa9e4066Sahrens 		if (s1acl != NULL) {
1494fa9e4066Sahrens 			s1acl_save = acl_dup(s1acl);
1495fa9e4066Sahrens 			if (s1acl_save == NULL) {
1496fa9e4066Sahrens 				(void) fprintf(stderr, gettext("%s: "
1497fa9e4066Sahrens 				    "Insufficient memory to save acl"
1498fa9e4066Sahrens 				    " entry\n"), cmd);
1499fa9e4066Sahrens 				if (pflg)
1500fa9e4066Sahrens 					return (1);
1501fa9e4066Sahrens 
15027c478bd9Sstevel@tonic-gate 			}
15033d63ea05Sas #ifdef XPG4
15043d63ea05Sas 			else {
15053d63ea05Sas 				(void) fprintf(stderr, gettext("%s: "
15063d63ea05Sas 				    "Insufficient memory to save acl"
15073d63ea05Sas 				    " entry\n"), cmd);
15083d63ea05Sas 				if (pflg)
15093d63ea05Sas 					return (1);
15103d63ea05Sas 			}
15117c478bd9Sstevel@tonic-gate #endif
15127c478bd9Sstevel@tonic-gate 		}
15137c478bd9Sstevel@tonic-gate 	}
15147c478bd9Sstevel@tonic-gate 
15157c478bd9Sstevel@tonic-gate 	ret = rcopy(source, target);
15167c478bd9Sstevel@tonic-gate 
15177c478bd9Sstevel@tonic-gate 	/*
15187c478bd9Sstevel@tonic-gate 	 * Once we created a directory, go ahead and set
15197c478bd9Sstevel@tonic-gate 	 * its attributes, e.g. acls and time. The info
15207c478bd9Sstevel@tonic-gate 	 * may get overwritten if we continue traversing
15217c478bd9Sstevel@tonic-gate 	 * down the tree.
15227c478bd9Sstevel@tonic-gate 	 *
15237c478bd9Sstevel@tonic-gate 	 * ACL for directory
15247c478bd9Sstevel@tonic-gate 	 */
15257c478bd9Sstevel@tonic-gate 	if (pflg || mve) {
1526d2443e76Smarks 		if ((pret = chg_mode(target, UID(s1save), GID(s1save),
1527d2443e76Smarks 		    FMODE(s1save))) == 0)
1528d2443e76Smarks 			pret = chg_time(target, s1save);
1529d2443e76Smarks 		ret += pret;
1530fa9e4066Sahrens 		if (s1acl_save != NULL) {
1531fa9e4066Sahrens 			if (acl_set(target, s1acl_save) < 0) {
1532cee1ddadSbasabi 				error++;
15337c478bd9Sstevel@tonic-gate #ifdef XPG4
15347c478bd9Sstevel@tonic-gate 				if (pflg || mve) {
15357c478bd9Sstevel@tonic-gate #else
15367c478bd9Sstevel@tonic-gate 				if (pflg) {
15377c478bd9Sstevel@tonic-gate #endif
15387c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
15397c478bd9Sstevel@tonic-gate 					    "%s: failed to set acl entries "
15407c478bd9Sstevel@tonic-gate 					    "on %s\n"), cmd, target);
15417c478bd9Sstevel@tonic-gate 					if (pflg) {
1542fa9e4066Sahrens 						acl_free(s1acl_save);
1543fa9e4066Sahrens 						s1acl_save = NULL;
15447c478bd9Sstevel@tonic-gate 						ret++;
15457c478bd9Sstevel@tonic-gate 					}
15467c478bd9Sstevel@tonic-gate 				}
15477c478bd9Sstevel@tonic-gate 				/* else: silent and continue */
15487c478bd9Sstevel@tonic-gate 			}
1549fa9e4066Sahrens 			acl_free(s1acl_save);
1550fa9e4066Sahrens 			s1acl_save = NULL;
15517c478bd9Sstevel@tonic-gate 		}
15527c478bd9Sstevel@tonic-gate 	} else if (fixmode != (mode_t)0)
15537c478bd9Sstevel@tonic-gate 		(void) chmod(target, fixmode & MODEBITS);
15547c478bd9Sstevel@tonic-gate 
1555da6c28aaSamw 	if (pflg || atflg || mve || saflg) {
15567c478bd9Sstevel@tonic-gate 		attret = copyattributes(source, target);
15577c478bd9Sstevel@tonic-gate 		if (!attrsilent && attret != 0) {
15587c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, gettext("%s: Failed to preserve"
15597c478bd9Sstevel@tonic-gate 			    " extended attributes of directory"
15607c478bd9Sstevel@tonic-gate 			    " %s\n"), cmd, source);
15617c478bd9Sstevel@tonic-gate 		} else {
15627c478bd9Sstevel@tonic-gate 			/*
15637c478bd9Sstevel@tonic-gate 			 * Otherwise ignore failure.
15647c478bd9Sstevel@tonic-gate 			 */
15657c478bd9Sstevel@tonic-gate 			attret = 0;
15667c478bd9Sstevel@tonic-gate 		}
1567da6c28aaSamw 		/* Copy extended system attributes */
1568da6c28aaSamw 		if (pflg || mve || saflg) {
1569cee1ddadSbasabi 			sattret = copy_sysattr(source, target);
1570cee1ddadSbasabi 			if (sattret != 0) {
1571da6c28aaSamw 				(void) fprintf(stderr, gettext(
1572da6c28aaSamw 				    "%s: Failed to preserve "
1573da6c28aaSamw 				    "extended system attributes "
1574da6c28aaSamw 				    "of directory %s\n"), cmd, source);
1575da6c28aaSamw 			}
1576da6c28aaSamw 		}
15777c478bd9Sstevel@tonic-gate 	}
1578cee1ddadSbasabi 	if (attret != 0 || sattret != 0 || error != 0)
1579cee1ddadSbasabi 		return (1);
15807c478bd9Sstevel@tonic-gate 	return (ret);
15817c478bd9Sstevel@tonic-gate }
15827c478bd9Sstevel@tonic-gate 
15837c478bd9Sstevel@tonic-gate static int
15847c478bd9Sstevel@tonic-gate copyspecial(char *target)
15857c478bd9Sstevel@tonic-gate {
15867c478bd9Sstevel@tonic-gate 	int ret = 0;
15877c478bd9Sstevel@tonic-gate 
15887c478bd9Sstevel@tonic-gate 	if (mknod(target, s1.st_mode, s1.st_rdev) != 0) {
15897c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, gettext(
15907c478bd9Sstevel@tonic-gate 		    "cp: cannot create special file %s: "), target);
15917c478bd9Sstevel@tonic-gate 		perror("");
15927c478bd9Sstevel@tonic-gate 		return (1);
15937c478bd9Sstevel@tonic-gate 	}
15947c478bd9Sstevel@tonic-gate 
15957c478bd9Sstevel@tonic-gate 	if (pflg) {
15967c478bd9Sstevel@tonic-gate 		if ((ret = chg_mode(target, UID(s1), GID(s1), FMODE(s1))) == 0)
15977c478bd9Sstevel@tonic-gate 			ret = chg_time(target, s1);
15987c478bd9Sstevel@tonic-gate 	}
15997c478bd9Sstevel@tonic-gate 
16007c478bd9Sstevel@tonic-gate 	return (ret);
16017c478bd9Sstevel@tonic-gate }
16027c478bd9Sstevel@tonic-gate 
16037c478bd9Sstevel@tonic-gate static int
16047c478bd9Sstevel@tonic-gate use_stdin(void)
16057c478bd9Sstevel@tonic-gate {
16067c478bd9Sstevel@tonic-gate #ifdef XPG4
16077c478bd9Sstevel@tonic-gate 	return (1);
16087c478bd9Sstevel@tonic-gate #else
16097c478bd9Sstevel@tonic-gate 	return (isatty(fileno(stdin)));
16107c478bd9Sstevel@tonic-gate #endif
16117c478bd9Sstevel@tonic-gate }
16127c478bd9Sstevel@tonic-gate 
1613da6c28aaSamw /* Copy non-system extended attributes */
1614da6c28aaSamw 
16157c478bd9Sstevel@tonic-gate static int
16167c478bd9Sstevel@tonic-gate copyattributes(char *source, char *target)
16177c478bd9Sstevel@tonic-gate {
16187c478bd9Sstevel@tonic-gate 	struct dirent *dp;
16197c478bd9Sstevel@tonic-gate 	int error = 0;
1620fa9e4066Sahrens 	int aclerror;
16217c478bd9Sstevel@tonic-gate 	mode_t mode;
16227c478bd9Sstevel@tonic-gate 	int clearflg = 0;
1623fa9e4066Sahrens 	acl_t *xacl = NULL;
1624fa9e4066Sahrens 	acl_t *attrdiracl = NULL;
16257c478bd9Sstevel@tonic-gate 	struct timeval times[2];
16267c478bd9Sstevel@tonic-gate 
1627da6c28aaSamw 
1628da6c28aaSamw 	if (pathconf(source,  _PC_XATTR_EXISTS) != 1)
16297c478bd9Sstevel@tonic-gate 		return (0);
16307c478bd9Sstevel@tonic-gate 
16317c478bd9Sstevel@tonic-gate 	if (pathconf(target, _PC_XATTR_ENABLED) != 1) {
16327c478bd9Sstevel@tonic-gate 		if (!attrsilent) {
16337c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
16347c478bd9Sstevel@tonic-gate 			    gettext(
16357c478bd9Sstevel@tonic-gate 			    "%s: cannot preserve extended attributes, "
16367c478bd9Sstevel@tonic-gate 			    "operation not supported on file"
16377c478bd9Sstevel@tonic-gate 			    " %s\n"), cmd, target);
16387c478bd9Sstevel@tonic-gate 		}
16397c478bd9Sstevel@tonic-gate 		return (1);
16407c478bd9Sstevel@tonic-gate 	}
1641da6c28aaSamw 	if (open_source(source) != 0)
1642da6c28aaSamw 		return (1);
1643da6c28aaSamw 	if (open_target_srctarg_attrdirs(source, target) !=  0)
1644da6c28aaSamw 		return (1);
1645da6c28aaSamw 	if (open_attrdirp(source) != 0)
1646da6c28aaSamw 		return (1);
16477c478bd9Sstevel@tonic-gate 
16487c478bd9Sstevel@tonic-gate 	if (pflg || mve) {
16497c478bd9Sstevel@tonic-gate 		if (fchmod(targetdirfd, attrdir.st_mode) == -1) {
16507c478bd9Sstevel@tonic-gate 			if (!attrsilent) {
16517c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
16523d63ea05Sas 				    gettext("%s: failed to set file mode"
16533d63ea05Sas 				    " correctly on attribute directory of"
16543d63ea05Sas 				    " file %s: "), cmd, target);
16557c478bd9Sstevel@tonic-gate 				perror("");
16567c478bd9Sstevel@tonic-gate 				++error;
16577c478bd9Sstevel@tonic-gate 			}
16587c478bd9Sstevel@tonic-gate 		}
16597c478bd9Sstevel@tonic-gate 
16607c478bd9Sstevel@tonic-gate 		if (fchown(targetdirfd, attrdir.st_uid, attrdir.st_gid) == -1) {
16617c478bd9Sstevel@tonic-gate 			if (!attrsilent) {
16627c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
16637c478bd9Sstevel@tonic-gate 				    gettext("%s: failed to set file"
16647c478bd9Sstevel@tonic-gate 				    " ownership correctly on attribute"
16657c478bd9Sstevel@tonic-gate 				    " directory of file %s: "), cmd, target);
16667c478bd9Sstevel@tonic-gate 				perror("");
16677c478bd9Sstevel@tonic-gate 				++error;
16687c478bd9Sstevel@tonic-gate 			}
16697c478bd9Sstevel@tonic-gate 		}
16707c478bd9Sstevel@tonic-gate 		/*
16717c478bd9Sstevel@tonic-gate 		 * Now that we are the owner we can update st_ctime by calling
16727c478bd9Sstevel@tonic-gate 		 * futimesat.
16737c478bd9Sstevel@tonic-gate 		 */
16747c478bd9Sstevel@tonic-gate 		times[0].tv_sec = attrdir.st_atime;
16757c478bd9Sstevel@tonic-gate 		times[0].tv_usec = 0;
16767c478bd9Sstevel@tonic-gate 		times[1].tv_sec = attrdir.st_mtime;
16777c478bd9Sstevel@tonic-gate 		times[1].tv_usec = 0;
16787c478bd9Sstevel@tonic-gate 		if (futimesat(targetdirfd, ".", times) < 0) {
16797c478bd9Sstevel@tonic-gate 			if (!attrsilent) {
16807c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
16813d63ea05Sas 				    gettext("%s: cannot set attribute times"
16823d63ea05Sas 				    " for %s: "), cmd, target);
16837c478bd9Sstevel@tonic-gate 				perror("");
16847c478bd9Sstevel@tonic-gate 				++error;
16857c478bd9Sstevel@tonic-gate 			}
16867c478bd9Sstevel@tonic-gate 		}
16877c478bd9Sstevel@tonic-gate 
16887c478bd9Sstevel@tonic-gate 		/*
16897c478bd9Sstevel@tonic-gate 		 * Now set owner and group of attribute directory, implies
16907c478bd9Sstevel@tonic-gate 		 * changing the ACL of the hidden attribute directory first.
16917c478bd9Sstevel@tonic-gate 		 */
1692fa9e4066Sahrens 		if ((aclerror = facl_get(sourcedirfd,
1693fa9e4066Sahrens 		    ACL_NO_TRIVIAL, &attrdiracl)) != 0) {
16947c478bd9Sstevel@tonic-gate 			if (!attrsilent) {
16957c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr, gettext(
16967c478bd9Sstevel@tonic-gate 				    "%s: failed to get acl entries of"
16977c478bd9Sstevel@tonic-gate 				    " attribute directory for"
1698fa9e4066Sahrens 				    " %s : %s\n"), cmd,
1699fa9e4066Sahrens 				    source, acl_strerror(aclerror));
17007c478bd9Sstevel@tonic-gate 				++error;
17017c478bd9Sstevel@tonic-gate 			}
17027c478bd9Sstevel@tonic-gate 		}
1703fa9e4066Sahrens 
1704fa9e4066Sahrens 		if (attrdiracl) {
1705fa9e4066Sahrens 			if (facl_set(targetdirfd, attrdiracl) != 0) {
17067c478bd9Sstevel@tonic-gate 				if (!attrsilent) {
17077c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
1708fa9e4066Sahrens 					"%s: failed to set acl entries"
1709fa9e4066Sahrens 					" on attribute directory "
1710fa9e4066Sahrens 					"for %s\n"), cmd, target);
17117c478bd9Sstevel@tonic-gate 					++error;
17127c478bd9Sstevel@tonic-gate 				}
1713fa9e4066Sahrens 				acl_free(attrdiracl);
1714fa9e4066Sahrens 				attrdiracl = NULL;
17157c478bd9Sstevel@tonic-gate 			}
17167c478bd9Sstevel@tonic-gate 		}
17177c478bd9Sstevel@tonic-gate 	}
17187c478bd9Sstevel@tonic-gate 
1719da6c28aaSamw 	while ((dp = readdir(srcdirp)) != NULL) {
1720da6c28aaSamw 		int ret;
17217c478bd9Sstevel@tonic-gate 
1722da6c28aaSamw 		if ((ret = traverse_attrfile(dp, source, target, 1)) == -1)
1723da6c28aaSamw 			continue;
1724da6c28aaSamw 		else if (ret > 0) {
17257c478bd9Sstevel@tonic-gate 			++error;
17267c478bd9Sstevel@tonic-gate 			goto out;
17277c478bd9Sstevel@tonic-gate 		}
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 		if (pflg || mve) {
1730fa9e4066Sahrens 			if ((aclerror = facl_get(srcattrfd,
1731fa9e4066Sahrens 			    ACL_NO_TRIVIAL, &xacl)) != 0) {
17327c478bd9Sstevel@tonic-gate 				if (!attrsilent) {
17337c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
17347c478bd9Sstevel@tonic-gate 					    "%s: failed to get acl entries of"
17357c478bd9Sstevel@tonic-gate 					    " attribute %s for"
1736fa9e4066Sahrens 					    " %s: %s"), cmd, dp->d_name,
1737fa9e4066Sahrens 					    source, acl_strerror(aclerror));
17387c478bd9Sstevel@tonic-gate 					++error;
17397c478bd9Sstevel@tonic-gate 				}
17407c478bd9Sstevel@tonic-gate 			}
17417c478bd9Sstevel@tonic-gate 		}
17427c478bd9Sstevel@tonic-gate 
17437c478bd9Sstevel@tonic-gate 		/*
17447c478bd9Sstevel@tonic-gate 		 * preserve ACL
17457c478bd9Sstevel@tonic-gate 		 */
1746fa9e4066Sahrens 		if ((pflg || mve) && xacl != NULL) {
1747fa9e4066Sahrens 			if ((facl_set(targattrfd, xacl)) < 0) {
17487c478bd9Sstevel@tonic-gate 				if (!attrsilent) {
17497c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
17507c478bd9Sstevel@tonic-gate 					    "%s: failed to set acl entries on"
17517c478bd9Sstevel@tonic-gate 					    " attribute %s for"
17527c478bd9Sstevel@tonic-gate 					    "%s\n"), cmd, dp->d_name, target);
17537c478bd9Sstevel@tonic-gate 					++error;
17547c478bd9Sstevel@tonic-gate 				}
1755fa9e4066Sahrens 				acl_free(xacl);
1756fa9e4066Sahrens 				xacl = NULL;
17577c478bd9Sstevel@tonic-gate 			}
17587c478bd9Sstevel@tonic-gate 		}
17597c478bd9Sstevel@tonic-gate 
1760da6c28aaSamw 		if (writefile(srcattrfd, targattrfd, source, target,
1761da6c28aaSamw 		    dp->d_name, dp->d_name, &s3, &s4) != 0) {
17627c478bd9Sstevel@tonic-gate 			if (!attrsilent) {
17637c478bd9Sstevel@tonic-gate 				++error;
17647c478bd9Sstevel@tonic-gate 			}
17657c478bd9Sstevel@tonic-gate 			goto next;
17667c478bd9Sstevel@tonic-gate 		}
17677c478bd9Sstevel@tonic-gate 
17687c478bd9Sstevel@tonic-gate 		if (pflg || mve) {
17697c478bd9Sstevel@tonic-gate 			mode = FMODE(s3);
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 			if (fchown(targattrfd, UID(s3), GID(s3)) != 0) {
17727c478bd9Sstevel@tonic-gate 				if (!attrsilent) {
17737c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
17747c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot change"
17757c478bd9Sstevel@tonic-gate 					    " owner and group of"
17767c478bd9Sstevel@tonic-gate 					    " attribute %s for" " file"
17777c478bd9Sstevel@tonic-gate 					    " %s: "), cmd, dp->d_name, target);
17787c478bd9Sstevel@tonic-gate 					perror("");
17797c478bd9Sstevel@tonic-gate 					++error;
17807c478bd9Sstevel@tonic-gate 				}
17817c478bd9Sstevel@tonic-gate 				if (mode & (S_ISUID | S_ISGID)) {
17827c478bd9Sstevel@tonic-gate 					/* try to clear S_ISUID and S_ISGID */
17837c478bd9Sstevel@tonic-gate 					mode &= ~S_ISUID & ~S_ISGID;
17847c478bd9Sstevel@tonic-gate 					++clearflg;
17857c478bd9Sstevel@tonic-gate 				}
17867c478bd9Sstevel@tonic-gate 			}
17877c478bd9Sstevel@tonic-gate 			/* tv_usec were cleared above */
17887c478bd9Sstevel@tonic-gate 			times[0].tv_sec = s3.st_atime;
17897c478bd9Sstevel@tonic-gate 			times[1].tv_sec = s3.st_mtime;
17907c478bd9Sstevel@tonic-gate 			if (futimesat(targetdirfd, dp->d_name, times) < 0) {
17917c478bd9Sstevel@tonic-gate 				if (!attrsilent) {
17927c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr,
17937c478bd9Sstevel@tonic-gate 					    gettext("%s: cannot set attribute"
17947c478bd9Sstevel@tonic-gate 					    " times for %s: "), cmd, target);
17957c478bd9Sstevel@tonic-gate 					perror("");
17967c478bd9Sstevel@tonic-gate 					++error;
17977c478bd9Sstevel@tonic-gate 				}
17987c478bd9Sstevel@tonic-gate 			}
17997c478bd9Sstevel@tonic-gate 			if (fchmod(targattrfd, mode) != 0) {
18007c478bd9Sstevel@tonic-gate 				if (clearflg) {
18017c478bd9Sstevel@tonic-gate 					(void) fprintf(stderr, gettext(
18027c478bd9Sstevel@tonic-gate 					    "%s: cannot clear S_ISUID and "
18037c478bd9Sstevel@tonic-gate 					    "S_ISGID bits in attribute %s"
18047c478bd9Sstevel@tonic-gate 					    " for file"
18057c478bd9Sstevel@tonic-gate 					    " %s: "), cmd, dp->d_name, target);
18067c478bd9Sstevel@tonic-gate 				} else {
18077c478bd9Sstevel@tonic-gate 					if (!attrsilent) {
18087c478bd9Sstevel@tonic-gate 						(void) fprintf(stderr,
18093d63ea05Sas 						    gettext(
18107c478bd9Sstevel@tonic-gate 				"%s: cannot set permissions of attribute"
18117c478bd9Sstevel@tonic-gate 				" %s for %s: "), cmd, dp->d_name, target);
18127c478bd9Sstevel@tonic-gate 						perror("");
18137c478bd9Sstevel@tonic-gate 						++error;
18147c478bd9Sstevel@tonic-gate 					}
18157c478bd9Sstevel@tonic-gate 				}
18167c478bd9Sstevel@tonic-gate 			}
1817d2443e76Smarks 			if (xacl && ((facl_set(targattrfd, xacl)) < 0)) {
1818d2443e76Smarks 				if (!attrsilent) {
1819d2443e76Smarks 					(void) fprintf(stderr, gettext(
1820d2443e76Smarks 					    "%s: failed to set acl entries on"
1821d2443e76Smarks 					    " attribute %s for"
1822d2443e76Smarks 					    "%s\n"), cmd, dp->d_name, target);
1823d2443e76Smarks 					++error;
1824d2443e76Smarks 				}
1825d2443e76Smarks 				acl_free(xacl);
1826d2443e76Smarks 				xacl = NULL;
1827d2443e76Smarks 			}
18287c478bd9Sstevel@tonic-gate 		}
18297c478bd9Sstevel@tonic-gate next:
1830fa9e4066Sahrens 		if (xacl != NULL) {
1831fa9e4066Sahrens 			acl_free(xacl);
1832fa9e4066Sahrens 			xacl = NULL;
18337c478bd9Sstevel@tonic-gate 		}
18347c478bd9Sstevel@tonic-gate 		if (srcattrfd != -1)
18357c478bd9Sstevel@tonic-gate 			(void) close(srcattrfd);
18367c478bd9Sstevel@tonic-gate 		if (targattrfd != -1)
18377c478bd9Sstevel@tonic-gate 			(void) close(targattrfd);
18387c478bd9Sstevel@tonic-gate 		srcattrfd = targattrfd = -1;
18397c478bd9Sstevel@tonic-gate 	}
18407c478bd9Sstevel@tonic-gate out:
1841fa9e4066Sahrens 	if (xacl != NULL) {
1842fa9e4066Sahrens 		acl_free(xacl);
1843fa9e4066Sahrens 		xacl = NULL;
1844fa9e4066Sahrens 	}
1845fa9e4066Sahrens 	if (attrdiracl != NULL) {
1846fa9e4066Sahrens 		acl_free(attrdiracl);
1847fa9e4066Sahrens 		attrdiracl = NULL;
1848fa9e4066Sahrens 	}
1849da6c28aaSamw 
1850da6c28aaSamw 	if (!saflg && !pflg && !mve)
1851da6c28aaSamw 		close_all();
1852da6c28aaSamw 	return (error == 0 ? 0 : 1);
1853da6c28aaSamw }
1854da6c28aaSamw 
1855da6c28aaSamw /* Copy extended system attributes from source to target */
1856da6c28aaSamw 
1857da6c28aaSamw static int
1858da6c28aaSamw copy_sysattr(char *source, char *target)
1859da6c28aaSamw {
1860da6c28aaSamw 	struct dirent	*dp;
1861da6c28aaSamw 	nvlist_t	*response;
1862da6c28aaSamw 	int		error = 0;
18632b9240ecSbasabi 	int		target_sa_support = 0;
1864da6c28aaSamw 
1865da6c28aaSamw 	if (sysattr_support(source, _PC_SATTR_EXISTS) != 1)
1866da6c28aaSamw 		return (0);
1867da6c28aaSamw 
1868da6c28aaSamw 	if (open_source(source) != 0)
1869da6c28aaSamw 		return (1);
1870da6c28aaSamw 
1871da6c28aaSamw 	/*
1872da6c28aaSamw 	 * Gets non default extended system attributes from the
1873da6c28aaSamw 	 * source file to copy to the target. The target has
1874da6c28aaSamw 	 * the defaults set when its created and thus  no need
1875da6c28aaSamw 	 * to copy the defaults.
1876da6c28aaSamw 	 */
1877da6c28aaSamw 	response = sysattr_list(cmd, srcfd, source);
1878da6c28aaSamw 
18792b9240ecSbasabi 	if (sysattr_support(target, _PC_SATTR_ENABLED) != 1) {
18802b9240ecSbasabi 		if (response != NULL) {
18812b9240ecSbasabi 			(void) fprintf(stderr,
18822b9240ecSbasabi 			    gettext(
18832b9240ecSbasabi 			    "%s: cannot preserve extended system "
18842b9240ecSbasabi 			    "attribute, operation not supported on file"
18852b9240ecSbasabi 			    " %s\n"), cmd, target);
1886da6c28aaSamw 			error++;
1887da6c28aaSamw 			goto out;
1888da6c28aaSamw 		}
1889da6c28aaSamw 	} else {
18902b9240ecSbasabi 		target_sa_support = 1;
1891da6c28aaSamw 	}
1892da6c28aaSamw 
18932b9240ecSbasabi 	if (target_sa_support) {
18942b9240ecSbasabi 		if (srcdirp == NULL) {
18952b9240ecSbasabi 			if (open_target_srctarg_attrdirs(source,
18962b9240ecSbasabi 			    target) !=  0) {
1897da6c28aaSamw 				error++;
18982b9240ecSbasabi 				goto out;
1899da6c28aaSamw 			}
19002b9240ecSbasabi 			if (open_attrdirp(source) != 0) {
19012b9240ecSbasabi 				error++;
19022b9240ecSbasabi 				goto out;
19032b9240ecSbasabi 			}
19042b9240ecSbasabi 		} else {
19052b9240ecSbasabi 			rewind_attrdir(srcdirp);
19062b9240ecSbasabi 		}
19072b9240ecSbasabi 		while ((dp = readdir(srcdirp)) != NULL) {
19082b9240ecSbasabi 			nvlist_t	*res;
19092b9240ecSbasabi 			int		ret;
19102b9240ecSbasabi 
19112b9240ecSbasabi 			if ((ret = traverse_attrfile(dp, source, target,
19122b9240ecSbasabi 			    0)) == -1)
19132b9240ecSbasabi 				continue;
19142b9240ecSbasabi 			else if (ret > 0) {
19152b9240ecSbasabi 				++error;
19162b9240ecSbasabi 				goto out;
19172b9240ecSbasabi 			}
19182b9240ecSbasabi 			/*
19192b9240ecSbasabi 			 * Gets non default extended system attributes from the
19202b9240ecSbasabi 			 * attribute file to copy to the target. The target has
19212b9240ecSbasabi 			 * the defaults set when its created and thus  no need
19222b9240ecSbasabi 			 * to copy the defaults.
19232b9240ecSbasabi 			 */
19242b9240ecSbasabi 			if (dp->d_name != NULL) {
19252b9240ecSbasabi 				res = sysattr_list(cmd, srcattrfd, dp->d_name);
19262b9240ecSbasabi 				if (res == NULL)
19272b9240ecSbasabi 					goto next;
1928da6c28aaSamw 
1929da6c28aaSamw 			/*
1930da6c28aaSamw 			 * Copy non default extended system attributes of named
1931da6c28aaSamw 			 * attribute file.
1932da6c28aaSamw 			 */
19332b9240ecSbasabi 				if (fsetattr(targattrfd,
19342b9240ecSbasabi 				    XATTR_VIEW_READWRITE, res) != 0) {
19352b9240ecSbasabi 					++error;
19362b9240ecSbasabi 					(void) fprintf(stderr, gettext("%s: "
19372b9240ecSbasabi 					    "Failed to copy extended system "
19382b9240ecSbasabi 					    "attributes from attribute file "
19392b9240ecSbasabi 					    "%s of %s to %s\n"), cmd,
19402b9240ecSbasabi 					    dp->d_name, source, target);
19412b9240ecSbasabi 				}
1942da6c28aaSamw 			}
1943da6c28aaSamw next:
19442b9240ecSbasabi 			if (srcattrfd != -1)
19452b9240ecSbasabi 				(void) close(srcattrfd);
19462b9240ecSbasabi 			if (targattrfd != -1)
19472b9240ecSbasabi 				(void) close(targattrfd);
19482b9240ecSbasabi 			srcattrfd = targattrfd = -1;
19492b9240ecSbasabi 			if (res != NULL)
19502b9240ecSbasabi 				nvlist_free(res);
19512b9240ecSbasabi 		}
1952da6c28aaSamw 	}
1953da6c28aaSamw 	/* Copy source file non default extended system attributes to target */
19542b9240ecSbasabi 	if (target_sa_support && (response != NULL) &&
1955da6c28aaSamw 	    (fsetattr(targfd, XATTR_VIEW_READWRITE, response)) != 0) {
1956da6c28aaSamw 		++error;
1957cee1ddadSbasabi 		(void) fprintf(stderr, gettext("%s: Failed to "
1958cee1ddadSbasabi 		    "copy extended system attributes from "
1959cee1ddadSbasabi 		    "%s to %s\n"), cmd, source, target);
1960da6c28aaSamw 	}
1961da6c28aaSamw out:
1962da6c28aaSamw 	if (response != NULL)
1963da6c28aaSamw 		nvlist_free(response);
1964da6c28aaSamw 	close_all();
19657c478bd9Sstevel@tonic-gate 	return (error == 0 ? 0 : 1);
19667c478bd9Sstevel@tonic-gate }
19677c478bd9Sstevel@tonic-gate 
19687c478bd9Sstevel@tonic-gate /*
19697c478bd9Sstevel@tonic-gate  * nanoseconds are rounded off to microseconds by flooring.
19707c478bd9Sstevel@tonic-gate  */
19717c478bd9Sstevel@tonic-gate static void
19727c478bd9Sstevel@tonic-gate timestruc_to_timeval(timestruc_t *ts, struct timeval *tv)
19737c478bd9Sstevel@tonic-gate {
19747c478bd9Sstevel@tonic-gate 	tv->tv_sec = ts->tv_sec;
19757c478bd9Sstevel@tonic-gate 	tv->tv_usec = ts->tv_nsec / 1000;
19767c478bd9Sstevel@tonic-gate }
1977da6c28aaSamw 
1978da6c28aaSamw /* Open the source file */
1979da6c28aaSamw 
1980da6c28aaSamw int
1981da6c28aaSamw open_source(char  *src)
1982da6c28aaSamw {
1983da6c28aaSamw 	int	error = 0;
1984da6c28aaSamw 
1985da6c28aaSamw 	srcfd = -1;
1986da6c28aaSamw 	if ((srcfd = open(src, O_RDONLY)) == -1) {
1987da6c28aaSamw 		if (pflg && attrsilent) {
1988da6c28aaSamw 			error++;
1989da6c28aaSamw 			goto out;
1990da6c28aaSamw 		}
1991da6c28aaSamw 		if (!attrsilent) {
1992da6c28aaSamw 			(void) fprintf(stderr,
1993da6c28aaSamw 			    gettext("%s: cannot open file"
1994da6c28aaSamw 			    " %s: "), cmd, src);
1995da6c28aaSamw 			perror("");
1996da6c28aaSamw 		}
1997da6c28aaSamw 		++error;
1998da6c28aaSamw 	}
1999da6c28aaSamw out:
2000da6c28aaSamw 	if (error)
2001da6c28aaSamw 		close_all();
2002da6c28aaSamw 	return (error == 0 ? 0 : 1);
2003da6c28aaSamw }
2004da6c28aaSamw 
2005da6c28aaSamw /* Open source attribute dir, target and target attribute dir. */
2006da6c28aaSamw 
2007da6c28aaSamw int
2008da6c28aaSamw open_target_srctarg_attrdirs(char  *src, char *targ)
2009da6c28aaSamw {
2010da6c28aaSamw 	int		error = 0;
2011da6c28aaSamw 
2012da6c28aaSamw 	targfd = sourcedirfd = targetdirfd = -1;
2013da6c28aaSamw 
2014da6c28aaSamw 	if ((targfd = open(targ, O_RDONLY)) == -1) {
2015da6c28aaSamw 		if (pflg && attrsilent) {
2016da6c28aaSamw 			error++;
2017da6c28aaSamw 			goto out;
2018da6c28aaSamw 		}
2019da6c28aaSamw 		if (!attrsilent) {
2020da6c28aaSamw 			(void) fprintf(stderr,
2021da6c28aaSamw 			    gettext("%s: cannot open file"
2022da6c28aaSamw 			    " %s: "), cmd, targ);
2023da6c28aaSamw 			perror("");
2024da6c28aaSamw 		}
2025da6c28aaSamw 		++error;
2026da6c28aaSamw 		goto out;
2027da6c28aaSamw 	}
2028da6c28aaSamw 
2029da6c28aaSamw 	if ((sourcedirfd = openat(srcfd, ".", O_RDONLY|O_XATTR)) == -1) {
2030da6c28aaSamw 		if (pflg && attrsilent) {
2031da6c28aaSamw 			error++;
2032da6c28aaSamw 			goto out;
2033da6c28aaSamw 		}
2034da6c28aaSamw 		if (!attrsilent) {
2035da6c28aaSamw 			(void) fprintf(stderr,
2036da6c28aaSamw 			    gettext("%s: cannot open attribute"
2037da6c28aaSamw 			    " directory for %s: "), cmd, src);
2038da6c28aaSamw 			perror("");
2039da6c28aaSamw 		}
2040da6c28aaSamw 		++error;
2041da6c28aaSamw 		goto out;
2042da6c28aaSamw 	}
2043da6c28aaSamw 
2044da6c28aaSamw 	if (fstat(sourcedirfd, &attrdir) == -1) {
2045da6c28aaSamw 		if (pflg && attrsilent) {
2046da6c28aaSamw 			error++;
2047da6c28aaSamw 			goto out;
2048da6c28aaSamw 		}
2049da6c28aaSamw 
2050da6c28aaSamw 		if (!attrsilent) {
2051da6c28aaSamw 			(void) fprintf(stderr,
2052da6c28aaSamw 			    gettext("%s: could not retrieve stat"
2053da6c28aaSamw 			    " information for attribute directory"
2054da6c28aaSamw 			    "of file %s: "), cmd, src);
2055da6c28aaSamw 			perror("");
2056da6c28aaSamw 		}
2057da6c28aaSamw 		++error;
2058da6c28aaSamw 		goto out;
2059da6c28aaSamw 	}
2060da6c28aaSamw 	if ((targetdirfd = openat(targfd, ".", O_RDONLY|O_XATTR)) == -1) {
2061da6c28aaSamw 		if (pflg && attrsilent) {
2062da6c28aaSamw 			error++;
2063da6c28aaSamw 			goto out;
2064da6c28aaSamw 		}
2065da6c28aaSamw 		if (!attrsilent) {
2066da6c28aaSamw 			(void) fprintf(stderr,
2067da6c28aaSamw 			    gettext("%s: cannot open attribute"
2068da6c28aaSamw 			    " directory for %s: "), cmd, targ);
2069da6c28aaSamw 			perror("");
2070da6c28aaSamw 		}
2071da6c28aaSamw 		++error;
2072da6c28aaSamw 	}
2073da6c28aaSamw out:
2074da6c28aaSamw 	if (error)
2075da6c28aaSamw 		close_all();
2076da6c28aaSamw 	return (error == 0 ? 0 : 1);
2077da6c28aaSamw }
2078da6c28aaSamw 
2079da6c28aaSamw int
2080da6c28aaSamw open_attrdirp(char *source)
2081da6c28aaSamw {
2082da6c28aaSamw 	int tmpfd = -1;
2083da6c28aaSamw 	int error = 0;
2084da6c28aaSamw 
2085da6c28aaSamw 	/*
2086da6c28aaSamw 	 * dup sourcedirfd for use by fdopendir().
2087da6c28aaSamw 	 * fdopendir will take ownership of given fd and will close
2088da6c28aaSamw 	 * it when closedir() is called.
2089da6c28aaSamw 	 */
2090da6c28aaSamw 
2091da6c28aaSamw 	if ((tmpfd = dup(sourcedirfd)) == -1) {
2092da6c28aaSamw 		if (pflg && attrsilent) {
2093da6c28aaSamw 			error++;
2094da6c28aaSamw 			goto out;
2095da6c28aaSamw 		}
2096da6c28aaSamw 		if (!attrsilent) {
2097da6c28aaSamw 			(void) fprintf(stderr,
2098da6c28aaSamw 			    gettext(
2099da6c28aaSamw 			    "%s: unable to dup attribute directory"
2100da6c28aaSamw 			    " file descriptor for %s: "), cmd, source);
2101da6c28aaSamw 			perror("");
2102da6c28aaSamw 			++error;
2103da6c28aaSamw 		}
2104da6c28aaSamw 		goto out;
2105da6c28aaSamw 	}
2106da6c28aaSamw 	if ((srcdirp = fdopendir(tmpfd)) == NULL) {
2107da6c28aaSamw 		if (pflg && attrsilent) {
2108da6c28aaSamw 			error++;
2109da6c28aaSamw 			goto out;
2110da6c28aaSamw 		}
2111da6c28aaSamw 		if (!attrsilent) {
2112da6c28aaSamw 			(void) fprintf(stderr,
2113da6c28aaSamw 			    gettext("%s: failed to open attribute"
2114da6c28aaSamw 			    " directory for %s: "), cmd, source);
2115da6c28aaSamw 			perror("");
2116da6c28aaSamw 			++error;
2117da6c28aaSamw 		}
2118da6c28aaSamw 	}
2119da6c28aaSamw out:
2120da6c28aaSamw 	if (error)
2121da6c28aaSamw 		close_all();
2122da6c28aaSamw 	return (error == 0 ? 0 : 1);
2123da6c28aaSamw }
2124da6c28aaSamw 
2125da6c28aaSamw /* Skips through ., .., and system attribute 'view' files */
2126da6c28aaSamw int
2127da6c28aaSamw traverse_attrfile(struct dirent *dp, char *source, char *target, int  first)
2128da6c28aaSamw {
2129da6c28aaSamw 	int		error = 0;
2130da6c28aaSamw 
2131beab0215Sbasabi 	srcattrfd = targattrfd = -1;
2132beab0215Sbasabi 
2133da6c28aaSamw 	if ((dp->d_name[0] == '.' && dp->d_name[1] == '\0') ||
2134da6c28aaSamw 	    (dp->d_name[0] == '.' && dp->d_name[1] == '.' &&
2135da6c28aaSamw 	    dp->d_name[2] == '\0') ||
2136da6c28aaSamw 	    (sysattr_type(dp->d_name) == _RO_SATTR) ||
2137da6c28aaSamw 	    (sysattr_type(dp->d_name) == _RW_SATTR))
2138da6c28aaSamw 		return (-1);
2139da6c28aaSamw 
2140da6c28aaSamw 	if ((srcattrfd = openat(sourcedirfd, dp->d_name,
2141da6c28aaSamw 	    O_RDONLY)) == -1) {
2142da6c28aaSamw 		if (!attrsilent) {
2143da6c28aaSamw 			(void) fprintf(stderr,
2144da6c28aaSamw 			    gettext("%s: cannot open attribute %s on"
2145da6c28aaSamw 			    " file %s: "), cmd, dp->d_name, source);
2146da6c28aaSamw 			perror("");
2147da6c28aaSamw 			++error;
2148da6c28aaSamw 			goto out;
2149da6c28aaSamw 		}
2150da6c28aaSamw 	}
2151da6c28aaSamw 
2152da6c28aaSamw 	if (fstat(srcattrfd, &s3) < 0) {
2153da6c28aaSamw 		if (!attrsilent) {
2154da6c28aaSamw 			(void) fprintf(stderr,
2155da6c28aaSamw 			    gettext("%s: could not stat attribute"
2156da6c28aaSamw 			    " %s on file"
2157da6c28aaSamw 			    " %s: "), cmd, dp->d_name, source);
2158da6c28aaSamw 			perror("");
2159da6c28aaSamw 			++error;
2160da6c28aaSamw 		}
2161da6c28aaSamw 		goto out;
2162da6c28aaSamw 	}
2163da6c28aaSamw 
2164da6c28aaSamw 	if (first) {
2165da6c28aaSamw 		(void) unlinkat(targetdirfd, dp->d_name, 0);
21663a1874bcSbasabi 		if ((targattrfd = openat(targetdirfd, dp->d_name,
21673a1874bcSbasabi 		    O_RDWR|O_CREAT|O_TRUNC, s3.st_mode & MODEBITS)) == -1) {
21683a1874bcSbasabi 			if (!attrsilent) {
21693a1874bcSbasabi 				(void) fprintf(stderr,
21703a1874bcSbasabi 				    gettext("%s: could not create attribute"
21713a1874bcSbasabi 				    " %s on file %s: "), cmd, dp->d_name,
21723a1874bcSbasabi 				    target);
21733a1874bcSbasabi 				perror("");
21743a1874bcSbasabi 				++error;
21753a1874bcSbasabi 			}
21763a1874bcSbasabi 			goto out;
21773a1874bcSbasabi 		}
2178da6c28aaSamw 	} else {
21793a1874bcSbasabi 		if ((targattrfd = openat(targetdirfd, dp->d_name,
21803a1874bcSbasabi 		    O_RDONLY)) == -1) {
21813a1874bcSbasabi 			if (!attrsilent) {
21823a1874bcSbasabi 				(void) fprintf(stderr,
21833a1874bcSbasabi 				    gettext("%s: could not open attribute"
21843a1874bcSbasabi 				    " %s on file %s: "), cmd, dp->d_name,
21853a1874bcSbasabi 				    target);
21863a1874bcSbasabi 				perror("");
21873a1874bcSbasabi 				++error;
21883a1874bcSbasabi 			}
21893a1874bcSbasabi 			goto out;
2190da6c28aaSamw 		}
2191da6c28aaSamw 	}
2192da6c28aaSamw 
21933a1874bcSbasabi 
2194da6c28aaSamw 	if (fstat(targattrfd, &s4) < 0) {
2195da6c28aaSamw 		if (!attrsilent) {
2196da6c28aaSamw 			(void) fprintf(stderr,
2197da6c28aaSamw 			    gettext("%s: could not stat attribute"
2198da6c28aaSamw 			    " %s on file"
2199da6c28aaSamw 			    " %s: "), cmd, dp->d_name, target);
2200da6c28aaSamw 			perror("");
2201da6c28aaSamw 			++error;
2202da6c28aaSamw 		}
2203da6c28aaSamw 	}
2204da6c28aaSamw 
2205da6c28aaSamw out:
2206da6c28aaSamw 	if (error) {
2207da6c28aaSamw 		if (srcattrfd != -1)
2208da6c28aaSamw 			(void) close(srcattrfd);
2209da6c28aaSamw 		if (targattrfd != -1)
2210beab0215Sbasabi 			(void) close(targattrfd);
2211beab0215Sbasabi 		srcattrfd = targattrfd = -1;
2212da6c28aaSamw 	}
2213da6c28aaSamw 	return (error == 0 ? 0 :1);
2214da6c28aaSamw }
2215da6c28aaSamw 
2216da6c28aaSamw void
2217da6c28aaSamw rewind_attrdir(DIR * sdp)
2218da6c28aaSamw {
2219da6c28aaSamw 	int pwdfd;
2220da6c28aaSamw 
2221da6c28aaSamw 	pwdfd = open(".", O_RDONLY);
2222da6c28aaSamw 	if ((pwdfd != -1) && (fchdir(sourcedirfd) == 0)) {
2223da6c28aaSamw 		rewinddir(sdp);
2224da6c28aaSamw 		(void) fchdir(pwdfd);
2225da6c28aaSamw 		(void) close(pwdfd);
2226da6c28aaSamw 	} else {
2227da6c28aaSamw 		if (!attrsilent) {
2228da6c28aaSamw 			(void) fprintf(stderr, gettext("%s: "
2229da6c28aaSamw 			    "failed to rewind attribute dir\n"),
2230da6c28aaSamw 			    cmd);
2231da6c28aaSamw 		}
2232da6c28aaSamw 	}
2233da6c28aaSamw }
2234da6c28aaSamw 
2235da6c28aaSamw void
2236da6c28aaSamw close_all()
2237da6c28aaSamw {
2238da6c28aaSamw 	if (srcattrfd != -1)
2239da6c28aaSamw 		(void) close(srcattrfd);
2240da6c28aaSamw 	if (targattrfd != -1)
2241da6c28aaSamw 		(void) close(targattrfd);
2242da6c28aaSamw 	if (sourcedirfd != -1)
2243da6c28aaSamw 		(void) close(sourcedirfd);
2244da6c28aaSamw 	if (targetdirfd != -1)
2245da6c28aaSamw 		(void) close(targetdirfd);
2246da6c28aaSamw 	if (srcdirp != NULL) {
2247da6c28aaSamw 		(void) closedir(srcdirp);
2248da6c28aaSamw 		srcdirp = NULL;
2249da6c28aaSamw 	}
2250da6c28aaSamw 	if (srcfd != -1)
2251da6c28aaSamw 		(void) close(srcfd);
2252da6c28aaSamw 	if (targfd != -1)
2253da6c28aaSamw 		(void) close(targfd);
2254da6c28aaSamw }
2255