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 */
2178cca7e2SRoger A. Faulkner
226cdb7222SAlexander Eremin /*
236cdb7222SAlexander Eremin * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
246cdb7222SAlexander Eremin */
256cdb7222SAlexander Eremin
267c478bd9Sstevel@tonic-gate /*
27ee9c203bSRenaud Manus * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
287c478bd9Sstevel@tonic-gate * Use is subject to license terms.
297c478bd9Sstevel@tonic-gate */
307c478bd9Sstevel@tonic-gate
317c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
327c478bd9Sstevel@tonic-gate /* All Rights Reserved */
337c478bd9Sstevel@tonic-gate
34*31b6814eSJohn Levon /*
35*31b6814eSJohn Levon * Copyright (c) 2018, Joyent, Inc.
36*31b6814eSJohn Levon */
37*31b6814eSJohn Levon
387c478bd9Sstevel@tonic-gate /*
397c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988
407c478bd9Sstevel@tonic-gate * The Regents of the University of California
417c478bd9Sstevel@tonic-gate * All Rights Reserved
427c478bd9Sstevel@tonic-gate *
437c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from
447c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its
457c478bd9Sstevel@tonic-gate * contributors.
467c478bd9Sstevel@tonic-gate */
477c478bd9Sstevel@tonic-gate
487c478bd9Sstevel@tonic-gate /*
497c478bd9Sstevel@tonic-gate * Combined mv/cp/ln command:
507c478bd9Sstevel@tonic-gate * mv file1 file2
517c478bd9Sstevel@tonic-gate * mv dir1 dir2
527c478bd9Sstevel@tonic-gate * mv file1 ... filen dir1
537c478bd9Sstevel@tonic-gate */
547c478bd9Sstevel@tonic-gate #include <sys/time.h>
557c478bd9Sstevel@tonic-gate #include <signal.h>
567c478bd9Sstevel@tonic-gate #include <locale.h>
577c478bd9Sstevel@tonic-gate #include <stdarg.h>
587c478bd9Sstevel@tonic-gate #include <sys/acl.h>
597c478bd9Sstevel@tonic-gate #include <libcmdutils.h>
60fa9e4066Sahrens #include <aclutils.h>
613d63ea05Sas #include "getresponse.h"
627c478bd9Sstevel@tonic-gate
637c478bd9Sstevel@tonic-gate #define FTYPE(A) (A.st_mode)
647c478bd9Sstevel@tonic-gate #define FMODE(A) (A.st_mode)
657c478bd9Sstevel@tonic-gate #define UID(A) (A.st_uid)
667c478bd9Sstevel@tonic-gate #define GID(A) (A.st_gid)
677c478bd9Sstevel@tonic-gate #define IDENTICAL(A, B) (A.st_dev == B.st_dev && A.st_ino == B.st_ino)
687c478bd9Sstevel@tonic-gate #define ISDIR(A) ((A.st_mode & S_IFMT) == S_IFDIR)
697c478bd9Sstevel@tonic-gate #define ISDOOR(A) ((A.st_mode & S_IFMT) == S_IFDOOR)
707c478bd9Sstevel@tonic-gate #define ISLNK(A) ((A.st_mode & S_IFMT) == S_IFLNK)
717c478bd9Sstevel@tonic-gate #define ISREG(A) (((A).st_mode & S_IFMT) == S_IFREG)
727c478bd9Sstevel@tonic-gate #define ISDEV(A) ((A.st_mode & S_IFMT) == S_IFCHR || \
737c478bd9Sstevel@tonic-gate (A.st_mode & S_IFMT) == S_IFBLK || \
747c478bd9Sstevel@tonic-gate (A.st_mode & S_IFMT) == S_IFIFO)
75e1636a06Sdanny webster #define ISSOCK(A) ((A.st_mode & S_IFMT) == S_IFSOCK)
767c478bd9Sstevel@tonic-gate
777c478bd9Sstevel@tonic-gate #define DELIM '/'
787c478bd9Sstevel@tonic-gate #define EQ(x, y) (strcmp(x, y) == 0)
797c478bd9Sstevel@tonic-gate #define FALSE 0
807c478bd9Sstevel@tonic-gate #define MODEBITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
817c478bd9Sstevel@tonic-gate #define TRUE 1
827c478bd9Sstevel@tonic-gate
837c478bd9Sstevel@tonic-gate static char *dname(char *);
847c478bd9Sstevel@tonic-gate static int lnkfil(char *, char *);
857c478bd9Sstevel@tonic-gate static int cpymve(char *, char *);
867c478bd9Sstevel@tonic-gate static int chkfiles(char *, char **);
877c478bd9Sstevel@tonic-gate static int rcopy(char *, char *);
887c478bd9Sstevel@tonic-gate static int chk_different(char *, char *);
897c478bd9Sstevel@tonic-gate static int chg_time(char *, struct stat);
907c478bd9Sstevel@tonic-gate static int chg_mode(char *, uid_t, gid_t, mode_t);
917c478bd9Sstevel@tonic-gate static int copydir(char *, char *);
927c478bd9Sstevel@tonic-gate static int copyspecial(char *);
937c478bd9Sstevel@tonic-gate static int getrealpath(char *, char *);
947c478bd9Sstevel@tonic-gate static void usage(void);
957c478bd9Sstevel@tonic-gate static void Perror(char *);
967c478bd9Sstevel@tonic-gate static void Perror2(char *, char *);
977c478bd9Sstevel@tonic-gate static int use_stdin(void);
987c478bd9Sstevel@tonic-gate static int copyattributes(char *, char *);
99da6c28aaSamw static int copy_sysattr(char *, char *);
1007c478bd9Sstevel@tonic-gate static tree_node_t *create_tnode(dev_t, ino_t);
1017c478bd9Sstevel@tonic-gate
102da6c28aaSamw static struct stat s1, s2, s3, s4;
1037c478bd9Sstevel@tonic-gate static int cpy = FALSE;
1047c478bd9Sstevel@tonic-gate static int mve = FALSE;
1057c478bd9Sstevel@tonic-gate static int lnk = FALSE;
1067c478bd9Sstevel@tonic-gate static char *cmd;
1077c478bd9Sstevel@tonic-gate static int silent = 0;
1087c478bd9Sstevel@tonic-gate static int fflg = 0;
1097c478bd9Sstevel@tonic-gate static int iflg = 0;
1107c478bd9Sstevel@tonic-gate static int pflg = 0;
1117c478bd9Sstevel@tonic-gate static int Rflg = 0; /* recursive copy */
1127c478bd9Sstevel@tonic-gate static int rflg = 0; /* recursive copy */
1137c478bd9Sstevel@tonic-gate static int sflg = 0;
1147c478bd9Sstevel@tonic-gate static int Hflg = 0; /* follow cmd line arg symlink to dir */
1157c478bd9Sstevel@tonic-gate static int Lflg = 0; /* follow symlinks */
1167c478bd9Sstevel@tonic-gate static int Pflg = 0; /* do not follow symlinks */
1177c478bd9Sstevel@tonic-gate static int atflg = 0;
1187c478bd9Sstevel@tonic-gate static int attrsilent = 0;
1197c478bd9Sstevel@tonic-gate static int targetexists = 0;
1207c478bd9Sstevel@tonic-gate static int cmdarg; /* command line argument */
1217c478bd9Sstevel@tonic-gate static avl_tree_t *stree = NULL; /* source file inode search tree */
122fa9e4066Sahrens static acl_t *s1acl;
123da6c28aaSamw static int saflg = 0; /* 'cp' extended system attr. */
124beab0215Sbasabi static int srcfd = -1;
125beab0215Sbasabi static int targfd = -1;
126beab0215Sbasabi static int sourcedirfd = -1;
127beab0215Sbasabi static int targetdirfd = -1;
128beab0215Sbasabi static DIR *srcdirp = NULL;
129beab0215Sbasabi static int srcattrfd = -1;
130beab0215Sbasabi static int targattrfd = -1;
131da6c28aaSamw static struct stat attrdir;
132da6c28aaSamw
133da6c28aaSamw /* Extended system attributes support */
134da6c28aaSamw
135da6c28aaSamw static int open_source(char *);
136da6c28aaSamw static int open_target_srctarg_attrdirs(char *, char *);
137da6c28aaSamw static int open_attrdirp(char *);
138da6c28aaSamw static int traverse_attrfile(struct dirent *, char *, char *, int);
139da6c28aaSamw static void rewind_attrdir(DIR *);
140da6c28aaSamw static void close_all();
141da6c28aaSamw
1427c478bd9Sstevel@tonic-gate
143a77d64afScf int
main(int argc,char * argv[])1447c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
1457c478bd9Sstevel@tonic-gate {
1467c478bd9Sstevel@tonic-gate int c, i, r, errflg = 0;
1477c478bd9Sstevel@tonic-gate char target[PATH_MAX];
1487c478bd9Sstevel@tonic-gate int (*move)(char *, char *);
1497c478bd9Sstevel@tonic-gate
1507c478bd9Sstevel@tonic-gate /*
1517c478bd9Sstevel@tonic-gate * Determine command invoked (mv, cp, or ln)
1527c478bd9Sstevel@tonic-gate */
1537c478bd9Sstevel@tonic-gate
1547c478bd9Sstevel@tonic-gate if (cmd = strrchr(argv[0], '/'))
1557c478bd9Sstevel@tonic-gate ++cmd;
1567c478bd9Sstevel@tonic-gate else
1577c478bd9Sstevel@tonic-gate cmd = argv[0];
1587c478bd9Sstevel@tonic-gate
1597c478bd9Sstevel@tonic-gate /*
1607c478bd9Sstevel@tonic-gate * Set flags based on command.
1617c478bd9Sstevel@tonic-gate */
1627c478bd9Sstevel@tonic-gate
1637c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, "");
1647c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
1657c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
1667c478bd9Sstevel@tonic-gate #endif
1677c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN);
1683d63ea05Sas if (init_yes() < 0) {
1693d63ea05Sas (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
1703d63ea05Sas strerror(errno));
1713d63ea05Sas exit(3);
1723d63ea05Sas }
1737c478bd9Sstevel@tonic-gate
1747c478bd9Sstevel@tonic-gate if (EQ(cmd, "mv"))
1757c478bd9Sstevel@tonic-gate mve = TRUE;
1767c478bd9Sstevel@tonic-gate else if (EQ(cmd, "ln"))
1777c478bd9Sstevel@tonic-gate lnk = TRUE;
1787c478bd9Sstevel@tonic-gate else if (EQ(cmd, "cp"))
1797c478bd9Sstevel@tonic-gate cpy = TRUE;
1807c478bd9Sstevel@tonic-gate else {
1817c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
1827c478bd9Sstevel@tonic-gate gettext("Invalid command name (%s); expecting "
1837c478bd9Sstevel@tonic-gate "mv, cp, or ln.\n"), cmd);
1847c478bd9Sstevel@tonic-gate exit(1);
1857c478bd9Sstevel@tonic-gate }
1867c478bd9Sstevel@tonic-gate
1877c478bd9Sstevel@tonic-gate /*
1887c478bd9Sstevel@tonic-gate * Check for options:
1899e647765SAlexander Eremin * cp [ -r|-R [-H|-L|-P]] [-afip@/] file1 [file2 ...] target
1909e647765SAlexander Eremin * cp [-afiprR@/] file1 [file2 ...] target
1917c478bd9Sstevel@tonic-gate * ln [-f] [-n] [-s] file1 [file2 ...] target
1927c478bd9Sstevel@tonic-gate * ln [-f] [-n] [-s] file1 [file2 ...]
1937c478bd9Sstevel@tonic-gate * mv [-f|i] file1 [file2 ...] target
1947c478bd9Sstevel@tonic-gate * mv [-f|i] dir1 target
1957c478bd9Sstevel@tonic-gate */
1967c478bd9Sstevel@tonic-gate
1977c478bd9Sstevel@tonic-gate if (cpy) {
1989e647765SAlexander Eremin while ((c = getopt(argc, argv, "afHiLpPrR@/")) != EOF)
1997c478bd9Sstevel@tonic-gate switch (c) {
2007c478bd9Sstevel@tonic-gate case 'f':
2017c478bd9Sstevel@tonic-gate fflg++;
2027c478bd9Sstevel@tonic-gate break;
2037c478bd9Sstevel@tonic-gate case 'i':
2047c478bd9Sstevel@tonic-gate iflg++;
2057c478bd9Sstevel@tonic-gate break;
2067c478bd9Sstevel@tonic-gate case 'p':
2077c478bd9Sstevel@tonic-gate pflg++;
2087c478bd9Sstevel@tonic-gate #ifdef XPG4
2097c478bd9Sstevel@tonic-gate attrsilent = 1;
2107c478bd9Sstevel@tonic-gate atflg = 0;
211da6c28aaSamw saflg = 0;
2127c478bd9Sstevel@tonic-gate #else
213cee1ddadSbasabi if (atflg == 0)
2147c478bd9Sstevel@tonic-gate attrsilent = 1;
2157c478bd9Sstevel@tonic-gate #endif
2167c478bd9Sstevel@tonic-gate break;
2177c478bd9Sstevel@tonic-gate case 'H':
2187c478bd9Sstevel@tonic-gate /*
2197c478bd9Sstevel@tonic-gate * If more than one of -H, -L, or -P are
2207c478bd9Sstevel@tonic-gate * specified, only the last option specified
2217c478bd9Sstevel@tonic-gate * determines the behavior.
2227c478bd9Sstevel@tonic-gate */
2237c478bd9Sstevel@tonic-gate Lflg = Pflg = 0;
2247c478bd9Sstevel@tonic-gate Hflg++;
2257c478bd9Sstevel@tonic-gate break;
2267c478bd9Sstevel@tonic-gate case 'L':
2277c478bd9Sstevel@tonic-gate Hflg = Pflg = 0;
2287c478bd9Sstevel@tonic-gate Lflg++;
2297c478bd9Sstevel@tonic-gate break;
2307c478bd9Sstevel@tonic-gate case 'P':
2317c478bd9Sstevel@tonic-gate Lflg = Hflg = 0;
2327c478bd9Sstevel@tonic-gate Pflg++;
2337c478bd9Sstevel@tonic-gate break;
2347c478bd9Sstevel@tonic-gate case 'R':
2357c478bd9Sstevel@tonic-gate /*
2367c478bd9Sstevel@tonic-gate * The default behavior of cp -R|-r
2377c478bd9Sstevel@tonic-gate * when specified without -H|-L|-P
2387c478bd9Sstevel@tonic-gate * is -L.
2397c478bd9Sstevel@tonic-gate */
2407c478bd9Sstevel@tonic-gate Rflg++;
2417c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
2427c478bd9Sstevel@tonic-gate case 'r':
2437c478bd9Sstevel@tonic-gate rflg++;
2447c478bd9Sstevel@tonic-gate break;
2459e647765SAlexander Eremin case 'a':
2469e647765SAlexander Eremin Lflg = Hflg = 0;
2479e647765SAlexander Eremin pflg++;
2489e647765SAlexander Eremin Pflg++;
2499e647765SAlexander Eremin Rflg++;
2509e647765SAlexander Eremin rflg++;
2519e647765SAlexander Eremin break;
2527c478bd9Sstevel@tonic-gate case '@':
2537c478bd9Sstevel@tonic-gate atflg++;
2547c478bd9Sstevel@tonic-gate attrsilent = 0;
2557c478bd9Sstevel@tonic-gate #ifdef XPG4
2567c478bd9Sstevel@tonic-gate pflg = 0;
257da6c28aaSamw #endif
258da6c28aaSamw break;
259da6c28aaSamw case '/':
260da6c28aaSamw saflg++;
261da6c28aaSamw attrsilent = 0;
262da6c28aaSamw #ifdef XPG4
263da6c28aaSamw pflg = 0;
2647c478bd9Sstevel@tonic-gate #endif
2657c478bd9Sstevel@tonic-gate break;
2667c478bd9Sstevel@tonic-gate default:
2677c478bd9Sstevel@tonic-gate errflg++;
2687c478bd9Sstevel@tonic-gate }
2697c478bd9Sstevel@tonic-gate
2707c478bd9Sstevel@tonic-gate /* -R or -r must be specified with -H, -L, or -P */
2717c478bd9Sstevel@tonic-gate if ((Hflg || Lflg || Pflg) && !(Rflg || rflg)) {
2727c478bd9Sstevel@tonic-gate errflg++;
2737c478bd9Sstevel@tonic-gate }
2747c478bd9Sstevel@tonic-gate
2757c478bd9Sstevel@tonic-gate } else if (mve) {
2767c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "fis")) != EOF)
2777c478bd9Sstevel@tonic-gate switch (c) {
2787c478bd9Sstevel@tonic-gate case 'f':
2797c478bd9Sstevel@tonic-gate silent++;
2807c478bd9Sstevel@tonic-gate #ifdef XPG4
2817c478bd9Sstevel@tonic-gate iflg = 0;
2827c478bd9Sstevel@tonic-gate #endif
2837c478bd9Sstevel@tonic-gate break;
2847c478bd9Sstevel@tonic-gate case 'i':
2857c478bd9Sstevel@tonic-gate iflg++;
2867c478bd9Sstevel@tonic-gate #ifdef XPG4
2877c478bd9Sstevel@tonic-gate silent = 0;
2887c478bd9Sstevel@tonic-gate #endif
2897c478bd9Sstevel@tonic-gate break;
2907c478bd9Sstevel@tonic-gate default:
2917c478bd9Sstevel@tonic-gate errflg++;
2927c478bd9Sstevel@tonic-gate }
2937c478bd9Sstevel@tonic-gate } else { /* ln */
2947c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "fns")) != EOF)
2957c478bd9Sstevel@tonic-gate switch (c) {
2967c478bd9Sstevel@tonic-gate case 'f':
2977c478bd9Sstevel@tonic-gate silent++;
2987c478bd9Sstevel@tonic-gate break;
2997c478bd9Sstevel@tonic-gate case 'n':
3007c478bd9Sstevel@tonic-gate /* silently ignored; this is the default */
3017c478bd9Sstevel@tonic-gate break;
3027c478bd9Sstevel@tonic-gate case 's':
3037c478bd9Sstevel@tonic-gate sflg++;
3047c478bd9Sstevel@tonic-gate break;
3057c478bd9Sstevel@tonic-gate default:
3067c478bd9Sstevel@tonic-gate errflg++;
3077c478bd9Sstevel@tonic-gate }
3087c478bd9Sstevel@tonic-gate }
3097c478bd9Sstevel@tonic-gate
3107c478bd9Sstevel@tonic-gate /*
3117c478bd9Sstevel@tonic-gate * For BSD compatibility allow - to delimit the end of
3127c478bd9Sstevel@tonic-gate * options for mv.
3137c478bd9Sstevel@tonic-gate */
3147c478bd9Sstevel@tonic-gate if (mve && optind < argc && (strcmp(argv[optind], "-") == 0))
3157c478bd9Sstevel@tonic-gate optind++;
3167c478bd9Sstevel@tonic-gate
3177c478bd9Sstevel@tonic-gate /*
3187c478bd9Sstevel@tonic-gate * Check for sufficient arguments
3197c478bd9Sstevel@tonic-gate * or a usage error.
3207c478bd9Sstevel@tonic-gate */
3217c478bd9Sstevel@tonic-gate
3227c478bd9Sstevel@tonic-gate argc -= optind;
3237c478bd9Sstevel@tonic-gate argv = &argv[optind];
3247c478bd9Sstevel@tonic-gate
3257c478bd9Sstevel@tonic-gate if ((argc < 2 && lnk != TRUE) || (argc < 1 && lnk == TRUE)) {
3267c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
3277c478bd9Sstevel@tonic-gate gettext("%s: Insufficient arguments (%d)\n"),
3287c478bd9Sstevel@tonic-gate cmd, argc);
3297c478bd9Sstevel@tonic-gate usage();
3307c478bd9Sstevel@tonic-gate }
3317c478bd9Sstevel@tonic-gate
3327c478bd9Sstevel@tonic-gate if (errflg != 0)
3337c478bd9Sstevel@tonic-gate usage();
3347c478bd9Sstevel@tonic-gate
3357c478bd9Sstevel@tonic-gate /*
3367c478bd9Sstevel@tonic-gate * If there is more than a source and target,
3377c478bd9Sstevel@tonic-gate * the last argument (the target) must be a directory
3387c478bd9Sstevel@tonic-gate * which really exists.
3397c478bd9Sstevel@tonic-gate */
3407c478bd9Sstevel@tonic-gate
3417c478bd9Sstevel@tonic-gate if (argc > 2) {
3427c478bd9Sstevel@tonic-gate if (stat(argv[argc-1], &s2) < 0) {
3437c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
3447c478bd9Sstevel@tonic-gate gettext("%s: %s not found\n"),
3457c478bd9Sstevel@tonic-gate cmd, argv[argc-1]);
3467c478bd9Sstevel@tonic-gate exit(2);
3477c478bd9Sstevel@tonic-gate }
3487c478bd9Sstevel@tonic-gate
3497c478bd9Sstevel@tonic-gate if (!ISDIR(s2)) {
3507c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
3517c478bd9Sstevel@tonic-gate gettext("%s: Target %s must be a directory\n"),
3527c478bd9Sstevel@tonic-gate cmd, argv[argc-1]);
3537c478bd9Sstevel@tonic-gate usage();
3547c478bd9Sstevel@tonic-gate }
3557c478bd9Sstevel@tonic-gate }
3567c478bd9Sstevel@tonic-gate
3577c478bd9Sstevel@tonic-gate if (strlen(argv[argc-1]) >= PATH_MAX) {
3587c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
3597c478bd9Sstevel@tonic-gate gettext("%s: Target %s file name length exceeds PATH_MAX"
3607c478bd9Sstevel@tonic-gate " %d\n"), cmd, argv[argc-1], PATH_MAX);
3617c478bd9Sstevel@tonic-gate exit(78);
3627c478bd9Sstevel@tonic-gate }
3637c478bd9Sstevel@tonic-gate
3647c478bd9Sstevel@tonic-gate if (argc == 1) {
3657c478bd9Sstevel@tonic-gate if (!lnk)
3667c478bd9Sstevel@tonic-gate usage();
3677c478bd9Sstevel@tonic-gate (void) strcpy(target, ".");
3687c478bd9Sstevel@tonic-gate } else {
3697c478bd9Sstevel@tonic-gate (void) strcpy(target, argv[--argc]);
3707c478bd9Sstevel@tonic-gate }
3717c478bd9Sstevel@tonic-gate
3727c478bd9Sstevel@tonic-gate /*
3737c478bd9Sstevel@tonic-gate * Perform a multiple argument mv|cp|ln by
3747c478bd9Sstevel@tonic-gate * multiple invocations of cpymve() or lnkfil().
3757c478bd9Sstevel@tonic-gate */
3767c478bd9Sstevel@tonic-gate if (lnk)
3777c478bd9Sstevel@tonic-gate move = lnkfil;
3787c478bd9Sstevel@tonic-gate else
3797c478bd9Sstevel@tonic-gate move = cpymve;
3807c478bd9Sstevel@tonic-gate
3817c478bd9Sstevel@tonic-gate r = 0;
3827c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) {
3837c478bd9Sstevel@tonic-gate stree = NULL;
3847c478bd9Sstevel@tonic-gate cmdarg = 1;
3857c478bd9Sstevel@tonic-gate r += move(argv[i], target);
3867c478bd9Sstevel@tonic-gate }
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate /*
3897c478bd9Sstevel@tonic-gate * Show errors by nonzero exit code.
3907c478bd9Sstevel@tonic-gate */
3917c478bd9Sstevel@tonic-gate
392a77d64afScf return (r?2:0);
3937c478bd9Sstevel@tonic-gate }
3947c478bd9Sstevel@tonic-gate
3957c478bd9Sstevel@tonic-gate static int
lnkfil(char * source,char * target)3967c478bd9Sstevel@tonic-gate lnkfil(char *source, char *target)
3977c478bd9Sstevel@tonic-gate {
3987c478bd9Sstevel@tonic-gate char *buf = NULL;
3997c478bd9Sstevel@tonic-gate
4007c478bd9Sstevel@tonic-gate if (sflg) {
4017c478bd9Sstevel@tonic-gate
4027c478bd9Sstevel@tonic-gate /*
4037c478bd9Sstevel@tonic-gate * If target is a directory make complete
4047c478bd9Sstevel@tonic-gate * name of the new symbolic link within that
4057c478bd9Sstevel@tonic-gate * directory.
4067c478bd9Sstevel@tonic-gate */
4077c478bd9Sstevel@tonic-gate
4087c478bd9Sstevel@tonic-gate if ((stat(target, &s2) >= 0) && ISDIR(s2)) {
4097c478bd9Sstevel@tonic-gate size_t len;
4107c478bd9Sstevel@tonic-gate
4117c478bd9Sstevel@tonic-gate len = strlen(target) + strlen(dname(source)) + 4;
4127c478bd9Sstevel@tonic-gate if ((buf = (char *)malloc(len)) == NULL) {
4137c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
4147c478bd9Sstevel@tonic-gate gettext("%s: Insufficient memory "
4157c478bd9Sstevel@tonic-gate "to %s %s\n"), cmd, cmd, source);
4167c478bd9Sstevel@tonic-gate exit(3);
4177c478bd9Sstevel@tonic-gate }
4187c478bd9Sstevel@tonic-gate (void) snprintf(buf, len, "%s/%s",
4197c478bd9Sstevel@tonic-gate target, dname(source));
4207c478bd9Sstevel@tonic-gate target = buf;
4217c478bd9Sstevel@tonic-gate }
4227c478bd9Sstevel@tonic-gate
4237c478bd9Sstevel@tonic-gate /*
4246fcd7f75Schin * Check to see if the file exists already.
4256fcd7f75Schin * In this case we use lstat() instead of stat():
4266fcd7f75Schin * unlink(2) and symlink(2) will operate on the file
4276fcd7f75Schin * itself, not its reference, if the file is a symlink.
4287c478bd9Sstevel@tonic-gate */
4297c478bd9Sstevel@tonic-gate
4306fcd7f75Schin if ((lstat(target, &s2) == 0)) {
4317c478bd9Sstevel@tonic-gate /*
4327c478bd9Sstevel@tonic-gate * Check if the silent flag is set ie. the -f option
4337c478bd9Sstevel@tonic-gate * is used. If so, use unlink to remove the current
4347c478bd9Sstevel@tonic-gate * target to replace with the new target, specified
4357c478bd9Sstevel@tonic-gate * on the command line. Proceed with symlink.
4367c478bd9Sstevel@tonic-gate */
4377c478bd9Sstevel@tonic-gate if (silent) {
4386fcd7f75Schin /*
4396fcd7f75Schin * Don't allow silent (-f) removal of an existing
4406fcd7f75Schin * directory; could leave unreferenced directory
4416fcd7f75Schin * entries.
4426fcd7f75Schin */
4436fcd7f75Schin if (ISDIR(s2)) {
4446fcd7f75Schin (void) fprintf(stderr,
4456fcd7f75Schin gettext("%s: cannot create link "
4466fcd7f75Schin "over directory %s\n"), cmd,
4476fcd7f75Schin target);
4486fcd7f75Schin return (1);
4496fcd7f75Schin }
4507c478bd9Sstevel@tonic-gate if (unlink(target) < 0) {
4517c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
4527c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
4537c478bd9Sstevel@tonic-gate cmd, target);
4547c478bd9Sstevel@tonic-gate perror("");
4557c478bd9Sstevel@tonic-gate return (1);
4567c478bd9Sstevel@tonic-gate }
4577c478bd9Sstevel@tonic-gate }
4587c478bd9Sstevel@tonic-gate }
4597c478bd9Sstevel@tonic-gate
4607c478bd9Sstevel@tonic-gate
4617c478bd9Sstevel@tonic-gate /*
4627c478bd9Sstevel@tonic-gate * Create a symbolic link to the source.
4637c478bd9Sstevel@tonic-gate */
4647c478bd9Sstevel@tonic-gate
4657c478bd9Sstevel@tonic-gate if (symlink(source, target) < 0) {
4667c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
4677c478bd9Sstevel@tonic-gate gettext("%s: cannot create %s: "),
4687c478bd9Sstevel@tonic-gate cmd, target);
4697c478bd9Sstevel@tonic-gate perror("");
4707c478bd9Sstevel@tonic-gate if (buf != NULL)
4717c478bd9Sstevel@tonic-gate free(buf);
4727c478bd9Sstevel@tonic-gate return (1);
4737c478bd9Sstevel@tonic-gate }
4747c478bd9Sstevel@tonic-gate if (buf != NULL)
4757c478bd9Sstevel@tonic-gate free(buf);
4767c478bd9Sstevel@tonic-gate return (0);
4777c478bd9Sstevel@tonic-gate }
4787c478bd9Sstevel@tonic-gate
4797c478bd9Sstevel@tonic-gate switch (chkfiles(source, &target)) {
4807c478bd9Sstevel@tonic-gate case 1: return (1);
4817c478bd9Sstevel@tonic-gate case 2: return (0);
4827c478bd9Sstevel@tonic-gate /* default - fall through */
4837c478bd9Sstevel@tonic-gate }
4847c478bd9Sstevel@tonic-gate
4857c478bd9Sstevel@tonic-gate /*
4867c478bd9Sstevel@tonic-gate * Make sure source file is not a directory,
487e1636a06Sdanny webster * we cannot link directories...
4887c478bd9Sstevel@tonic-gate */
4897c478bd9Sstevel@tonic-gate
4907c478bd9Sstevel@tonic-gate if (ISDIR(s1)) {
4917c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
4927c478bd9Sstevel@tonic-gate gettext("%s: %s is a directory\n"), cmd, source);
4937c478bd9Sstevel@tonic-gate return (1);
4947c478bd9Sstevel@tonic-gate }
4957c478bd9Sstevel@tonic-gate
4967c478bd9Sstevel@tonic-gate /*
4977c478bd9Sstevel@tonic-gate * hard link, call link() and return.
4987c478bd9Sstevel@tonic-gate */
4997c478bd9Sstevel@tonic-gate
5007c478bd9Sstevel@tonic-gate if (link(source, target) < 0) {
5017c478bd9Sstevel@tonic-gate if (errno == EXDEV)
5027c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
5037c478bd9Sstevel@tonic-gate gettext("%s: %s is on a different file system\n"),
5047c478bd9Sstevel@tonic-gate cmd, target);
5057c478bd9Sstevel@tonic-gate else {
5067c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
5077c478bd9Sstevel@tonic-gate gettext("%s: cannot create link %s: "),
5087c478bd9Sstevel@tonic-gate cmd, target);
5097c478bd9Sstevel@tonic-gate perror("");
5107c478bd9Sstevel@tonic-gate }
5117c478bd9Sstevel@tonic-gate if (buf != NULL)
5127c478bd9Sstevel@tonic-gate free(buf);
5137c478bd9Sstevel@tonic-gate return (1);
5147c478bd9Sstevel@tonic-gate } else {
5157c478bd9Sstevel@tonic-gate if (buf != NULL)
5167c478bd9Sstevel@tonic-gate free(buf);
5177c478bd9Sstevel@tonic-gate return (0);
5187c478bd9Sstevel@tonic-gate }
5197c478bd9Sstevel@tonic-gate }
5207c478bd9Sstevel@tonic-gate
5217c478bd9Sstevel@tonic-gate static int
cpymve(char * source,char * target)5227c478bd9Sstevel@tonic-gate cpymve(char *source, char *target)
5237c478bd9Sstevel@tonic-gate {
5247c478bd9Sstevel@tonic-gate int n;
5257c478bd9Sstevel@tonic-gate int fi, fo;
5267c478bd9Sstevel@tonic-gate int ret = 0;
5277c478bd9Sstevel@tonic-gate int attret = 0;
528da6c28aaSamw int sattret = 0;
5297c478bd9Sstevel@tonic-gate int errno_save;
530cee1ddadSbasabi int error = 0;
5317c478bd9Sstevel@tonic-gate
5327c478bd9Sstevel@tonic-gate switch (chkfiles(source, &target)) {
5337c478bd9Sstevel@tonic-gate case 1: return (1);
5347c478bd9Sstevel@tonic-gate case 2: return (0);
5357c478bd9Sstevel@tonic-gate /* default - fall through */
5367c478bd9Sstevel@tonic-gate }
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate /*
5397c478bd9Sstevel@tonic-gate * If it's a recursive copy and source
5407c478bd9Sstevel@tonic-gate * is a directory, then call rcopy (from copydir).
5417c478bd9Sstevel@tonic-gate */
5427c478bd9Sstevel@tonic-gate if (cpy) {
5437c478bd9Sstevel@tonic-gate if (ISDIR(s1)) {
5447c478bd9Sstevel@tonic-gate int rc;
5457c478bd9Sstevel@tonic-gate avl_index_t where = 0;
5467c478bd9Sstevel@tonic-gate tree_node_t *tnode;
5477c478bd9Sstevel@tonic-gate tree_node_t *tptr;
5487c478bd9Sstevel@tonic-gate dev_t save_dev = s1.st_dev;
5497c478bd9Sstevel@tonic-gate ino_t save_ino = s1.st_ino;
5507c478bd9Sstevel@tonic-gate
5517c478bd9Sstevel@tonic-gate /*
5527c478bd9Sstevel@tonic-gate * We will be recursing into the directory so
5537c478bd9Sstevel@tonic-gate * save the inode information to a search tree
5547c478bd9Sstevel@tonic-gate * to avoid getting into an endless loop.
5557c478bd9Sstevel@tonic-gate */
5567c478bd9Sstevel@tonic-gate if ((rc = add_tnode(&stree, save_dev, save_ino)) != 1) {
5577c478bd9Sstevel@tonic-gate if (rc == 0) {
5587c478bd9Sstevel@tonic-gate /*
5597c478bd9Sstevel@tonic-gate * We've already visited this directory.
5607c478bd9Sstevel@tonic-gate * Don't remove the search tree entry
5617c478bd9Sstevel@tonic-gate * to make sure we don't get into an
5627c478bd9Sstevel@tonic-gate * endless loop if revisited from a
5637c478bd9Sstevel@tonic-gate * different part of the hierarchy.
5647c478bd9Sstevel@tonic-gate */
5657c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
5667c478bd9Sstevel@tonic-gate "%s: cycle detected: %s\n"),
5677c478bd9Sstevel@tonic-gate cmd, source);
5687c478bd9Sstevel@tonic-gate } else {
5697c478bd9Sstevel@tonic-gate Perror(source);
5707c478bd9Sstevel@tonic-gate }
5717c478bd9Sstevel@tonic-gate return (1);
5727c478bd9Sstevel@tonic-gate }
5737c478bd9Sstevel@tonic-gate
5747c478bd9Sstevel@tonic-gate cmdarg = 0;
5757c478bd9Sstevel@tonic-gate rc = copydir(source, target);
5767c478bd9Sstevel@tonic-gate
5777c478bd9Sstevel@tonic-gate /*
5787c478bd9Sstevel@tonic-gate * Create a tnode to get an index to the matching
5797c478bd9Sstevel@tonic-gate * node (same dev and inode) in the search tree,
5807c478bd9Sstevel@tonic-gate * then use the index to remove the matching node
5817c478bd9Sstevel@tonic-gate * so it we do not wrongly detect a cycle when
5827c478bd9Sstevel@tonic-gate * revisiting this directory from another part of
5837c478bd9Sstevel@tonic-gate * the hierarchy.
5847c478bd9Sstevel@tonic-gate */
5857c478bd9Sstevel@tonic-gate if ((tnode = create_tnode(save_dev,
5867c478bd9Sstevel@tonic-gate save_ino)) == NULL) {
5877c478bd9Sstevel@tonic-gate Perror(source);
5887c478bd9Sstevel@tonic-gate return (1);
5897c478bd9Sstevel@tonic-gate }
5907c478bd9Sstevel@tonic-gate if ((tptr = avl_find(stree, tnode, &where)) != NULL) {
5917c478bd9Sstevel@tonic-gate avl_remove(stree, tptr);
5927c478bd9Sstevel@tonic-gate }
5937c478bd9Sstevel@tonic-gate free(tptr);
5947c478bd9Sstevel@tonic-gate free(tnode);
5957c478bd9Sstevel@tonic-gate return (rc);
5967c478bd9Sstevel@tonic-gate
5977c478bd9Sstevel@tonic-gate } else if (ISDEV(s1) && Rflg) {
5987c478bd9Sstevel@tonic-gate return (copyspecial(target));
5997c478bd9Sstevel@tonic-gate } else {
6007c478bd9Sstevel@tonic-gate goto copy;
6017c478bd9Sstevel@tonic-gate }
6027c478bd9Sstevel@tonic-gate }
6037c478bd9Sstevel@tonic-gate
6047c478bd9Sstevel@tonic-gate if (mve) {
6057c478bd9Sstevel@tonic-gate if (rename(source, target) >= 0)
6067c478bd9Sstevel@tonic-gate return (0);
6077c478bd9Sstevel@tonic-gate if (errno != EXDEV) {
6087c478bd9Sstevel@tonic-gate if (errno == ENOTDIR && ISDIR(s1)) {
6097c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
6107c478bd9Sstevel@tonic-gate gettext("%s: %s is a directory\n"),
6117c478bd9Sstevel@tonic-gate cmd, source);
6127c478bd9Sstevel@tonic-gate return (1);
6137c478bd9Sstevel@tonic-gate }
6147c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
6157c478bd9Sstevel@tonic-gate gettext("%s: cannot rename %s to %s: "),
6167c478bd9Sstevel@tonic-gate cmd, source, target);
6177c478bd9Sstevel@tonic-gate perror("");
6187c478bd9Sstevel@tonic-gate return (1);
6197c478bd9Sstevel@tonic-gate }
6207c478bd9Sstevel@tonic-gate
6217c478bd9Sstevel@tonic-gate /*
6227c478bd9Sstevel@tonic-gate * cannot move a non-directory (source) onto an existing
6237c478bd9Sstevel@tonic-gate * directory (target)
6247c478bd9Sstevel@tonic-gate *
6257c478bd9Sstevel@tonic-gate */
6267c478bd9Sstevel@tonic-gate if (targetexists && ISDIR(s2) && (!ISDIR(s1))) {
6277c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
6287c478bd9Sstevel@tonic-gate gettext("%s: cannot mv a non directory %s "
6297c478bd9Sstevel@tonic-gate "over existing directory"
6307c478bd9Sstevel@tonic-gate " %s \n"), cmd, source, target);
6317c478bd9Sstevel@tonic-gate return (1);
6327c478bd9Sstevel@tonic-gate }
6337c478bd9Sstevel@tonic-gate if (ISDIR(s1)) {
6347c478bd9Sstevel@tonic-gate #ifdef XPG4
6357c478bd9Sstevel@tonic-gate if (targetexists && ISDIR(s2)) {
6367c478bd9Sstevel@tonic-gate /* existing target dir must be empty */
6377c478bd9Sstevel@tonic-gate if (rmdir(target) < 0) {
6387c478bd9Sstevel@tonic-gate errno_save = errno;
6397c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
6407c478bd9Sstevel@tonic-gate gettext("%s: cannot rmdir %s: "),
6417c478bd9Sstevel@tonic-gate cmd, target);
6427c478bd9Sstevel@tonic-gate errno = errno_save;
6437c478bd9Sstevel@tonic-gate perror("");
6447c478bd9Sstevel@tonic-gate return (1);
6457c478bd9Sstevel@tonic-gate }
6467c478bd9Sstevel@tonic-gate }
6477c478bd9Sstevel@tonic-gate #endif
6487c478bd9Sstevel@tonic-gate if ((n = copydir(source, target)) == 0)
6497c478bd9Sstevel@tonic-gate (void) rmdir(source);
6507c478bd9Sstevel@tonic-gate return (n);
6517c478bd9Sstevel@tonic-gate }
6527c478bd9Sstevel@tonic-gate
653e1636a06Sdanny webster /* doors cannot be moved across filesystems */
6547c478bd9Sstevel@tonic-gate if (ISDOOR(s1)) {
6557c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
656e1636a06Sdanny webster gettext("%s: %s: cannot move door "
6577c478bd9Sstevel@tonic-gate "across file systems\n"), cmd, source);
6587c478bd9Sstevel@tonic-gate return (1);
6597c478bd9Sstevel@tonic-gate }
660e1636a06Sdanny webster
661e1636a06Sdanny webster /* sockets cannot be moved across filesystems */
662e1636a06Sdanny webster if (ISSOCK(s1)) {
663e1636a06Sdanny webster (void) fprintf(stderr,
664e1636a06Sdanny webster gettext("%s: %s: cannot move socket "
665e1636a06Sdanny webster "across file systems\n"), cmd, source);
666e1636a06Sdanny webster return (1);
667e1636a06Sdanny webster }
668e1636a06Sdanny webster
6697c478bd9Sstevel@tonic-gate /*
670e1636a06Sdanny webster * File cannot be renamed, try to recreate the symbolic
6717c478bd9Sstevel@tonic-gate * link or special device, or copy the file wholesale
6727c478bd9Sstevel@tonic-gate * between file systems.
6737c478bd9Sstevel@tonic-gate */
6747c478bd9Sstevel@tonic-gate if (ISLNK(s1)) {
6757c478bd9Sstevel@tonic-gate register int m;
6767c478bd9Sstevel@tonic-gate register mode_t md;
6777c478bd9Sstevel@tonic-gate char symln[PATH_MAX + 1];
6787c478bd9Sstevel@tonic-gate
6797c478bd9Sstevel@tonic-gate if (targetexists && unlink(target) < 0) {
6807c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
6817c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
6827c478bd9Sstevel@tonic-gate cmd, target);
6837c478bd9Sstevel@tonic-gate perror("");
6847c478bd9Sstevel@tonic-gate return (1);
6857c478bd9Sstevel@tonic-gate }
6867c478bd9Sstevel@tonic-gate
6877c478bd9Sstevel@tonic-gate if ((m = readlink(source, symln,
6887c478bd9Sstevel@tonic-gate sizeof (symln) - 1)) < 0) {
6897c478bd9Sstevel@tonic-gate Perror(source);
6907c478bd9Sstevel@tonic-gate return (1);
6917c478bd9Sstevel@tonic-gate }
6927c478bd9Sstevel@tonic-gate symln[m] = '\0';
6937c478bd9Sstevel@tonic-gate
6947c478bd9Sstevel@tonic-gate md = umask(~(s1.st_mode & MODEBITS));
6957c478bd9Sstevel@tonic-gate if (symlink(symln, target) < 0) {
6967c478bd9Sstevel@tonic-gate Perror(target);
6977c478bd9Sstevel@tonic-gate return (1);
6987c478bd9Sstevel@tonic-gate }
6997c478bd9Sstevel@tonic-gate (void) umask(md);
7007c478bd9Sstevel@tonic-gate m = lchown(target, UID(s1), GID(s1));
7017c478bd9Sstevel@tonic-gate #ifdef XPG4
7027c478bd9Sstevel@tonic-gate if (m < 0) {
7037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot"
7047c478bd9Sstevel@tonic-gate " change owner and group of"
7057c478bd9Sstevel@tonic-gate " %s: "), cmd, target);
7067c478bd9Sstevel@tonic-gate perror("");
7077c478bd9Sstevel@tonic-gate }
7087c478bd9Sstevel@tonic-gate #endif
7097c478bd9Sstevel@tonic-gate goto cleanup;
7107c478bd9Sstevel@tonic-gate }
7117c478bd9Sstevel@tonic-gate if (ISDEV(s1)) {
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate if (targetexists && unlink(target) < 0) {
7147c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
7157c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
7167c478bd9Sstevel@tonic-gate cmd, target);
7177c478bd9Sstevel@tonic-gate perror("");
7187c478bd9Sstevel@tonic-gate return (1);
7197c478bd9Sstevel@tonic-gate }
7207c478bd9Sstevel@tonic-gate
7217c478bd9Sstevel@tonic-gate if (mknod(target, s1.st_mode, s1.st_rdev) < 0) {
7227c478bd9Sstevel@tonic-gate Perror(target);
7237c478bd9Sstevel@tonic-gate return (1);
7247c478bd9Sstevel@tonic-gate }
7257c478bd9Sstevel@tonic-gate
7267c478bd9Sstevel@tonic-gate (void) chg_mode(target, UID(s1), GID(s1), FMODE(s1));
7277c478bd9Sstevel@tonic-gate (void) chg_time(target, s1);
7287c478bd9Sstevel@tonic-gate goto cleanup;
7297c478bd9Sstevel@tonic-gate }
7307c478bd9Sstevel@tonic-gate
7317c478bd9Sstevel@tonic-gate if (ISREG(s1)) {
7327c478bd9Sstevel@tonic-gate if (ISDIR(s2)) {
7337c478bd9Sstevel@tonic-gate if (targetexists && rmdir(target) < 0) {
7347c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
7357c478bd9Sstevel@tonic-gate gettext("%s: cannot rmdir %s: "),
7367c478bd9Sstevel@tonic-gate cmd, target);
7377c478bd9Sstevel@tonic-gate perror("");
7387c478bd9Sstevel@tonic-gate return (1);
7397c478bd9Sstevel@tonic-gate }
7407c478bd9Sstevel@tonic-gate } else {
7417c478bd9Sstevel@tonic-gate if (targetexists && unlink(target) < 0) {
7427c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
7437c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
7447c478bd9Sstevel@tonic-gate cmd, target);
7457c478bd9Sstevel@tonic-gate perror("");
7467c478bd9Sstevel@tonic-gate return (1);
7477c478bd9Sstevel@tonic-gate }
7487c478bd9Sstevel@tonic-gate }
7497c478bd9Sstevel@tonic-gate
7507c478bd9Sstevel@tonic-gate
7517c478bd9Sstevel@tonic-gate copy:
7527c478bd9Sstevel@tonic-gate /*
7537c478bd9Sstevel@tonic-gate * If the source file is a symlink, and either
7547c478bd9Sstevel@tonic-gate * -P or -H flag (only if -H is specified and the
7557c478bd9Sstevel@tonic-gate * source file is not a command line argument)
7567c478bd9Sstevel@tonic-gate * were specified, then action is taken on the symlink
7577c478bd9Sstevel@tonic-gate * itself, not the file referenced by the symlink.
7587c478bd9Sstevel@tonic-gate * Note: this is executed for 'cp' only.
7597c478bd9Sstevel@tonic-gate */
7607c478bd9Sstevel@tonic-gate if (cpy && (Pflg || (Hflg && !cmdarg)) && (ISLNK(s1))) {
7617c478bd9Sstevel@tonic-gate int m;
7627c478bd9Sstevel@tonic-gate mode_t md;
7637c478bd9Sstevel@tonic-gate char symln[PATH_MAX + 1];
7647c478bd9Sstevel@tonic-gate
7657c478bd9Sstevel@tonic-gate m = readlink(source, symln, sizeof (symln) - 1);
7667c478bd9Sstevel@tonic-gate
7677c478bd9Sstevel@tonic-gate if (m < 0) {
7687c478bd9Sstevel@tonic-gate Perror(source);
7697c478bd9Sstevel@tonic-gate return (1);
7707c478bd9Sstevel@tonic-gate }
7717c478bd9Sstevel@tonic-gate symln[m] = '\0';
7727c478bd9Sstevel@tonic-gate
7737c478bd9Sstevel@tonic-gate /*
7747c478bd9Sstevel@tonic-gate * Copy the sym link to the target.
7757c478bd9Sstevel@tonic-gate * Note: If the target exists, write a
7767c478bd9Sstevel@tonic-gate * diagnostic message, do nothing more
7777c478bd9Sstevel@tonic-gate * with the source file, and return to
7787c478bd9Sstevel@tonic-gate * process any remaining files.
7797c478bd9Sstevel@tonic-gate */
7807c478bd9Sstevel@tonic-gate md = umask(~(s1.st_mode & MODEBITS));
7817c478bd9Sstevel@tonic-gate if (symlink(symln, target) < 0) {
7827c478bd9Sstevel@tonic-gate Perror(target);
7837c478bd9Sstevel@tonic-gate return (1);
7847c478bd9Sstevel@tonic-gate }
7857c478bd9Sstevel@tonic-gate (void) umask(md);
7867c478bd9Sstevel@tonic-gate m = lchown(target, UID(s1), GID(s1));
7877c478bd9Sstevel@tonic-gate
7887c478bd9Sstevel@tonic-gate if (m < 0) {
7897c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
7907c478bd9Sstevel@tonic-gate "cp: cannot change owner and "
7917c478bd9Sstevel@tonic-gate "group of %s:"), target);
7927c478bd9Sstevel@tonic-gate perror("");
7937c478bd9Sstevel@tonic-gate }
7947c478bd9Sstevel@tonic-gate } else {
7957c478bd9Sstevel@tonic-gate /*
7967c478bd9Sstevel@tonic-gate * Copy the file. If it happens to be a
7977c478bd9Sstevel@tonic-gate * symlink, copy the file referenced
7987c478bd9Sstevel@tonic-gate * by the symlink.
7997c478bd9Sstevel@tonic-gate */
8007c478bd9Sstevel@tonic-gate fi = open(source, O_RDONLY);
8017c478bd9Sstevel@tonic-gate if (fi < 0) {
8027c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
8037c478bd9Sstevel@tonic-gate gettext("%s: cannot open %s: "),
8047c478bd9Sstevel@tonic-gate cmd, source);
8057c478bd9Sstevel@tonic-gate perror("");
8067c478bd9Sstevel@tonic-gate return (1);
8077c478bd9Sstevel@tonic-gate }
8087c478bd9Sstevel@tonic-gate
8097c478bd9Sstevel@tonic-gate fo = creat(target, s1.st_mode & MODEBITS);
8107c478bd9Sstevel@tonic-gate if (fo < 0) {
8117c478bd9Sstevel@tonic-gate /*
8127c478bd9Sstevel@tonic-gate * If -f and creat() failed, unlink
8137c478bd9Sstevel@tonic-gate * and try again.
8147c478bd9Sstevel@tonic-gate */
8157c478bd9Sstevel@tonic-gate if (fflg) {
8167c478bd9Sstevel@tonic-gate (void) unlink(target);
8177c478bd9Sstevel@tonic-gate fo = creat(target,
8187c478bd9Sstevel@tonic-gate s1.st_mode & MODEBITS);
8197c478bd9Sstevel@tonic-gate }
8207c478bd9Sstevel@tonic-gate }
8217c478bd9Sstevel@tonic-gate if (fo < 0) {
8227c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
8237c478bd9Sstevel@tonic-gate gettext("%s: cannot create %s: "),
8247c478bd9Sstevel@tonic-gate cmd, target);
8257c478bd9Sstevel@tonic-gate perror("");
8267c478bd9Sstevel@tonic-gate (void) close(fi);
8277c478bd9Sstevel@tonic-gate return (1);
8287c478bd9Sstevel@tonic-gate } else {
8297c478bd9Sstevel@tonic-gate /* stat the new file, its used below */
8307c478bd9Sstevel@tonic-gate (void) stat(target, &s2);
8317c478bd9Sstevel@tonic-gate }
8327c478bd9Sstevel@tonic-gate
8337c478bd9Sstevel@tonic-gate /*
8347c478bd9Sstevel@tonic-gate * Set target's permissions to the source
8357c478bd9Sstevel@tonic-gate * before any copying so that any partially
8367c478bd9Sstevel@tonic-gate * copied file will have the source's
8377c478bd9Sstevel@tonic-gate * permissions (at most) or umask permissions
8387c478bd9Sstevel@tonic-gate * whichever is the most restrictive.
8397c478bd9Sstevel@tonic-gate *
8407c478bd9Sstevel@tonic-gate * ACL for regular files
8417c478bd9Sstevel@tonic-gate */
8427c478bd9Sstevel@tonic-gate
8437c478bd9Sstevel@tonic-gate if (pflg || mve) {
8447c478bd9Sstevel@tonic-gate (void) chmod(target, FMODE(s1));
845fa9e4066Sahrens if (s1acl != NULL) {
846fa9e4066Sahrens if ((acl_set(target,
847fa9e4066Sahrens s1acl)) < 0) {
848cee1ddadSbasabi error++;
849cee1ddadSbasabi (void) fprintf(stderr,
850cee1ddadSbasabi gettext("%s: "
851cee1ddadSbasabi "Failed to set "
852cee1ddadSbasabi "acl entries "
853cee1ddadSbasabi "on %s\n"), cmd,
854cee1ddadSbasabi target);
85594d2b9abSmarks acl_free(s1acl);
85694d2b9abSmarks s1acl = NULL;
8577c478bd9Sstevel@tonic-gate /*
8587c478bd9Sstevel@tonic-gate * else: silent and
8597c478bd9Sstevel@tonic-gate * continue
8607c478bd9Sstevel@tonic-gate */
8617c478bd9Sstevel@tonic-gate }
8627c478bd9Sstevel@tonic-gate }
8637c478bd9Sstevel@tonic-gate }
8647c478bd9Sstevel@tonic-gate
8657c478bd9Sstevel@tonic-gate if (fstat(fi, &s1) < 0) {
8667c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
8677c478bd9Sstevel@tonic-gate gettext("%s: cannot access %s\n"),
8687c478bd9Sstevel@tonic-gate cmd, source);
8697c478bd9Sstevel@tonic-gate return (1);
8707c478bd9Sstevel@tonic-gate }
8717c478bd9Sstevel@tonic-gate if (IDENTICAL(s1, s2)) {
8727c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
8737c478bd9Sstevel@tonic-gate gettext(
8747c478bd9Sstevel@tonic-gate "%s: %s and %s are identical\n"),
8757c478bd9Sstevel@tonic-gate cmd, source, target);
8767c478bd9Sstevel@tonic-gate return (1);
8777c478bd9Sstevel@tonic-gate }
8787c478bd9Sstevel@tonic-gate
879da6c28aaSamw if (writefile(fi, fo, source, target, NULL,
880da6c28aaSamw NULL, &s1, &s2) != 0) {
8817c478bd9Sstevel@tonic-gate return (1);
8827c478bd9Sstevel@tonic-gate }
8837c478bd9Sstevel@tonic-gate
8847c478bd9Sstevel@tonic-gate (void) close(fi);
8857c478bd9Sstevel@tonic-gate if (close(fo) < 0) {
8867c478bd9Sstevel@tonic-gate Perror2(target, "write");
8877c478bd9Sstevel@tonic-gate return (1);
8887c478bd9Sstevel@tonic-gate }
8897c478bd9Sstevel@tonic-gate }
890da6c28aaSamw /* Copy regular extended attributes */
891da6c28aaSamw if (pflg || atflg || mve || saflg) {
8927c478bd9Sstevel@tonic-gate attret = copyattributes(source, target);
8937c478bd9Sstevel@tonic-gate if (attret != 0 && !attrsilent) {
8947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
8953d63ea05Sas "%s: Failed to preserve"
8963d63ea05Sas " extended attributes of file"
8973d63ea05Sas " %s\n"), cmd, source);
8987c478bd9Sstevel@tonic-gate }
899da6c28aaSamw /* Copy extended system attributes */
900cee1ddadSbasabi if (pflg || mve || saflg)
901da6c28aaSamw sattret = copy_sysattr(source, target);
9027c478bd9Sstevel@tonic-gate if (mve && attret != 0) {
9037c478bd9Sstevel@tonic-gate (void) unlink(target);
9047c478bd9Sstevel@tonic-gate return (1);
9057c478bd9Sstevel@tonic-gate }
906da6c28aaSamw if (attrsilent) {
9077c478bd9Sstevel@tonic-gate attret = 0;
908da6c28aaSamw }
9097c478bd9Sstevel@tonic-gate }
9107c478bd9Sstevel@tonic-gate
9117c478bd9Sstevel@tonic-gate /*
9127c478bd9Sstevel@tonic-gate * XPG4: the write system call will clear setgid
9137c478bd9Sstevel@tonic-gate * and setuid bits, so set them again.
9147c478bd9Sstevel@tonic-gate */
9157c478bd9Sstevel@tonic-gate if (pflg || mve) {
9167c478bd9Sstevel@tonic-gate if ((ret = chg_mode(target, UID(s1), GID(s1),
9177c478bd9Sstevel@tonic-gate FMODE(s1))) > 0)
9187c478bd9Sstevel@tonic-gate return (1);
919d2443e76Smarks /*
920d2443e76Smarks * Reapply ACL, since chmod may have
921d2443e76Smarks * altered ACL
922d2443e76Smarks */
923d2443e76Smarks if (s1acl != NULL) {
924d2443e76Smarks if ((acl_set(target, s1acl)) < 0) {
925cee1ddadSbasabi error++;
926cee1ddadSbasabi (void) fprintf(stderr,
927cee1ddadSbasabi gettext("%s: Failed to "
928cee1ddadSbasabi "set acl entries "
929cee1ddadSbasabi "on %s\n"), cmd, target);
930d2443e76Smarks /*
931d2443e76Smarks * else: silent and
932d2443e76Smarks * continue
933d2443e76Smarks */
934d2443e76Smarks }
935d2443e76Smarks }
9367c478bd9Sstevel@tonic-gate if ((ret = chg_time(target, s1)) > 0)
9377c478bd9Sstevel@tonic-gate return (1);
9387c478bd9Sstevel@tonic-gate }
9397c478bd9Sstevel@tonic-gate if (cpy) {
940cee1ddadSbasabi if (error != 0 || attret != 0 || sattret != 0)
9417c478bd9Sstevel@tonic-gate return (1);
9427c478bd9Sstevel@tonic-gate return (0);
9437c478bd9Sstevel@tonic-gate }
9447c478bd9Sstevel@tonic-gate goto cleanup;
9457c478bd9Sstevel@tonic-gate }
9467c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
9477c478bd9Sstevel@tonic-gate gettext("%s: %s: unknown file type 0x%x\n"), cmd,
9483d63ea05Sas source, (s1.st_mode & S_IFMT));
9497c478bd9Sstevel@tonic-gate return (1);
9507c478bd9Sstevel@tonic-gate
9517c478bd9Sstevel@tonic-gate cleanup:
9527c478bd9Sstevel@tonic-gate if (unlink(source) < 0) {
9537c478bd9Sstevel@tonic-gate (void) unlink(target);
9547c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
9557c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
9567c478bd9Sstevel@tonic-gate cmd, source);
9577c478bd9Sstevel@tonic-gate perror("");
9587c478bd9Sstevel@tonic-gate return (1);
9597c478bd9Sstevel@tonic-gate }
960cee1ddadSbasabi if (error != 0 || attret != 0 || sattret != 0)
961cee1ddadSbasabi return (1);
9627c478bd9Sstevel@tonic-gate return (ret);
9637c478bd9Sstevel@tonic-gate }
9647c478bd9Sstevel@tonic-gate /*NOTREACHED*/
965a77d64afScf return (ret);
9667c478bd9Sstevel@tonic-gate }
9677c478bd9Sstevel@tonic-gate
9687c478bd9Sstevel@tonic-gate /*
9697c478bd9Sstevel@tonic-gate * create_tnode()
9707c478bd9Sstevel@tonic-gate *
9717c478bd9Sstevel@tonic-gate * Create a node for use with the search tree which contains the
9727c478bd9Sstevel@tonic-gate * inode information (device id and inode number).
9737c478bd9Sstevel@tonic-gate *
9747c478bd9Sstevel@tonic-gate * Input
9757c478bd9Sstevel@tonic-gate * dev - device id
9767c478bd9Sstevel@tonic-gate * ino - inode number
9777c478bd9Sstevel@tonic-gate *
9787c478bd9Sstevel@tonic-gate * Output
9797c478bd9Sstevel@tonic-gate * tnode - NULL on error, otherwise returns a tnode structure
9807c478bd9Sstevel@tonic-gate * which contains the input device id and inode number.
9817c478bd9Sstevel@tonic-gate */
9827c478bd9Sstevel@tonic-gate static tree_node_t *
create_tnode(dev_t dev,ino_t ino)9837c478bd9Sstevel@tonic-gate create_tnode(dev_t dev, ino_t ino)
9847c478bd9Sstevel@tonic-gate {
9857c478bd9Sstevel@tonic-gate tree_node_t *tnode;
9867c478bd9Sstevel@tonic-gate
9877c478bd9Sstevel@tonic-gate if ((tnode = (tree_node_t *)malloc(sizeof (tree_node_t))) != NULL) {
9887c478bd9Sstevel@tonic-gate tnode->node_dev = dev;
9897c478bd9Sstevel@tonic-gate tnode->node_ino = ino;
9907c478bd9Sstevel@tonic-gate }
9917c478bd9Sstevel@tonic-gate
9927c478bd9Sstevel@tonic-gate return (tnode);
9937c478bd9Sstevel@tonic-gate }
9947c478bd9Sstevel@tonic-gate
9957c478bd9Sstevel@tonic-gate static int
chkfiles(char * source,char ** to)9967c478bd9Sstevel@tonic-gate chkfiles(char *source, char **to)
9977c478bd9Sstevel@tonic-gate {
9987c478bd9Sstevel@tonic-gate char *buf = (char *)NULL;
9997c478bd9Sstevel@tonic-gate int (*statf)() = (cpy &&
10003d63ea05Sas !(Pflg || (Hflg && !cmdarg))) ? stat : lstat;
10017c478bd9Sstevel@tonic-gate char *target = *to;
1002fa9e4066Sahrens int error;
10037c478bd9Sstevel@tonic-gate
10047c478bd9Sstevel@tonic-gate /*
10057c478bd9Sstevel@tonic-gate * Make sure source file exists.
10067c478bd9Sstevel@tonic-gate */
10077c478bd9Sstevel@tonic-gate if ((*statf)(source, &s1) < 0) {
10087c478bd9Sstevel@tonic-gate /*
10097c478bd9Sstevel@tonic-gate * Keep the old error message except when someone tries to
10107c478bd9Sstevel@tonic-gate * mv/cp/ln a symbolic link that has a trailing slash and
10117c478bd9Sstevel@tonic-gate * points to a file.
10127c478bd9Sstevel@tonic-gate */
10137c478bd9Sstevel@tonic-gate if (errno == ENOTDIR)
10147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s: %s\n", cmd, source,
10157c478bd9Sstevel@tonic-gate strerror(errno));
10167c478bd9Sstevel@tonic-gate else
10177c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
10187c478bd9Sstevel@tonic-gate gettext("%s: cannot access %s\n"), cmd, source);
10197c478bd9Sstevel@tonic-gate return (1);
10207c478bd9Sstevel@tonic-gate }
10217c478bd9Sstevel@tonic-gate
10227c478bd9Sstevel@tonic-gate /*
1023ee9c203bSRenaud Manus * Get ACL info: don't bother with ln or cp/mv'ing symlinks
10247c478bd9Sstevel@tonic-gate */
1025ee9c203bSRenaud Manus if (!lnk && !ISLNK(s1)) {
1026fa9e4066Sahrens if (s1acl != NULL) {
1027fa9e4066Sahrens acl_free(s1acl);
1028fa9e4066Sahrens s1acl = NULL;
10297c478bd9Sstevel@tonic-gate }
1030fa9e4066Sahrens if ((error = acl_get(source, ACL_NO_TRIVIAL, &s1acl)) != 0) {
10317c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
1032fa9e4066Sahrens "%s: failed to get acl entries: %s\n", source,
1033fa9e4066Sahrens acl_strerror(error));
10347c478bd9Sstevel@tonic-gate return (1);
10357c478bd9Sstevel@tonic-gate }
10367c478bd9Sstevel@tonic-gate /* else: just permission bits */
10377c478bd9Sstevel@tonic-gate }
10387c478bd9Sstevel@tonic-gate
10397c478bd9Sstevel@tonic-gate /*
10407c478bd9Sstevel@tonic-gate * If stat fails, then the target doesn't exist,
10417c478bd9Sstevel@tonic-gate * we will create a new target with default file type of regular.
10427c478bd9Sstevel@tonic-gate */
10437c478bd9Sstevel@tonic-gate
10447c478bd9Sstevel@tonic-gate FTYPE(s2) = S_IFREG;
10457c478bd9Sstevel@tonic-gate targetexists = 0;
10467c478bd9Sstevel@tonic-gate if ((*statf)(target, &s2) >= 0) {
10477c478bd9Sstevel@tonic-gate if (ISLNK(s2))
10487c478bd9Sstevel@tonic-gate (void) stat(target, &s2);
10497c478bd9Sstevel@tonic-gate /*
10507c478bd9Sstevel@tonic-gate * If target is a directory,
10517c478bd9Sstevel@tonic-gate * make complete name of new file
10527c478bd9Sstevel@tonic-gate * within that directory.
10537c478bd9Sstevel@tonic-gate */
10547c478bd9Sstevel@tonic-gate if (ISDIR(s2)) {
10557c478bd9Sstevel@tonic-gate size_t len;
10567c478bd9Sstevel@tonic-gate
10577c478bd9Sstevel@tonic-gate len = strlen(target) + strlen(dname(source)) + 4;
10587c478bd9Sstevel@tonic-gate if ((buf = (char *)malloc(len)) == NULL) {
10597c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
10607c478bd9Sstevel@tonic-gate gettext("%s: Insufficient memory to "
10613d63ea05Sas "%s %s\n "), cmd, cmd, source);
10627c478bd9Sstevel@tonic-gate exit(3);
10637c478bd9Sstevel@tonic-gate }
10647c478bd9Sstevel@tonic-gate (void) snprintf(buf, len, "%s/%s",
10657c478bd9Sstevel@tonic-gate target, dname(source));
10667c478bd9Sstevel@tonic-gate *to = target = buf;
10677c478bd9Sstevel@tonic-gate }
10687c478bd9Sstevel@tonic-gate
10697c478bd9Sstevel@tonic-gate if ((*statf)(target, &s2) >= 0) {
10707c478bd9Sstevel@tonic-gate int overwrite = FALSE;
10717c478bd9Sstevel@tonic-gate int override = FALSE;
10727c478bd9Sstevel@tonic-gate
10737c478bd9Sstevel@tonic-gate targetexists++;
10747c478bd9Sstevel@tonic-gate if (cpy || mve) {
10757c478bd9Sstevel@tonic-gate /*
10767c478bd9Sstevel@tonic-gate * For cp and mv, it is an error if the
10777c478bd9Sstevel@tonic-gate * source and target are the same file.
10787c478bd9Sstevel@tonic-gate * Check for the same inode and file
10797c478bd9Sstevel@tonic-gate * system, but don't check for the same
10807c478bd9Sstevel@tonic-gate * absolute pathname because it is an
10817c478bd9Sstevel@tonic-gate * error when the source and target are
10827c478bd9Sstevel@tonic-gate * hard links to the same file.
10837c478bd9Sstevel@tonic-gate */
10847c478bd9Sstevel@tonic-gate if (IDENTICAL(s1, s2)) {
10857c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
10867c478bd9Sstevel@tonic-gate gettext(
10877c478bd9Sstevel@tonic-gate "%s: %s and %s are identical\n"),
10887c478bd9Sstevel@tonic-gate cmd, source, target);
10897c478bd9Sstevel@tonic-gate if (buf != NULL)
10907c478bd9Sstevel@tonic-gate free(buf);
10917c478bd9Sstevel@tonic-gate return (1);
10927c478bd9Sstevel@tonic-gate }
10937c478bd9Sstevel@tonic-gate }
10947c478bd9Sstevel@tonic-gate if (lnk) {
10957c478bd9Sstevel@tonic-gate /*
10967c478bd9Sstevel@tonic-gate * For ln, it is an error if the source and
10977c478bd9Sstevel@tonic-gate * target are identical files (same inode,
10987c478bd9Sstevel@tonic-gate * same file system, and filenames resolve
10997c478bd9Sstevel@tonic-gate * to same absolute pathname).
11007c478bd9Sstevel@tonic-gate */
11017c478bd9Sstevel@tonic-gate if (!chk_different(source, target)) {
11027c478bd9Sstevel@tonic-gate if (buf != NULL)
11037c478bd9Sstevel@tonic-gate free(buf);
11047c478bd9Sstevel@tonic-gate return (1);
11057c478bd9Sstevel@tonic-gate }
11067c478bd9Sstevel@tonic-gate }
11077c478bd9Sstevel@tonic-gate if (lnk && !silent) {
11087c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
11097c478bd9Sstevel@tonic-gate gettext("%s: %s: File exists\n"),
11107c478bd9Sstevel@tonic-gate cmd, target);
11117c478bd9Sstevel@tonic-gate if (buf != NULL)
11127c478bd9Sstevel@tonic-gate free(buf);
11137c478bd9Sstevel@tonic-gate return (1);
11147c478bd9Sstevel@tonic-gate }
11157c478bd9Sstevel@tonic-gate
11167c478bd9Sstevel@tonic-gate /*
11177c478bd9Sstevel@tonic-gate * overwrite:
11187c478bd9Sstevel@tonic-gate * If the user does not have access to
11197c478bd9Sstevel@tonic-gate * the target, ask ----if it is not
11207c478bd9Sstevel@tonic-gate * silent and user invoked command
11217c478bd9Sstevel@tonic-gate * interactively.
11227c478bd9Sstevel@tonic-gate *
11237c478bd9Sstevel@tonic-gate * override:
11247c478bd9Sstevel@tonic-gate * If not silent, and stdin is a terminal, and
11257c478bd9Sstevel@tonic-gate * there's no write access, and the file isn't a
11267c478bd9Sstevel@tonic-gate * symbolic link, ask for permission.
11277c478bd9Sstevel@tonic-gate *
11287c478bd9Sstevel@tonic-gate * XPG4: both overwrite and override:
11297c478bd9Sstevel@tonic-gate * ask only one question.
11307c478bd9Sstevel@tonic-gate *
11317c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE - The following messages will
11327c478bd9Sstevel@tonic-gate * contain the first character of the strings for
11337c478bd9Sstevel@tonic-gate * "yes" and "no" defined in the file
11347c478bd9Sstevel@tonic-gate * "nl_langinfo.po". After substitution, the
11357c478bd9Sstevel@tonic-gate * message will appear as follows:
11367c478bd9Sstevel@tonic-gate * <cmd>: overwrite <filename> (y/n)?
11377c478bd9Sstevel@tonic-gate * where <cmd> is the name of the command
11387c478bd9Sstevel@tonic-gate * (cp, mv) and <filename> is the destination file
11397c478bd9Sstevel@tonic-gate */
11407c478bd9Sstevel@tonic-gate
11417c478bd9Sstevel@tonic-gate
11427c478bd9Sstevel@tonic-gate overwrite = iflg && !silent && use_stdin();
11437c478bd9Sstevel@tonic-gate override = !cpy && (access(target, 2) < 0) &&
11447c478bd9Sstevel@tonic-gate !silent && use_stdin() && !ISLNK(s2);
11457c478bd9Sstevel@tonic-gate
11460f6e7ba6Sas if (overwrite && override) {
11477c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
11487c478bd9Sstevel@tonic-gate gettext("%s: overwrite %s and override "
11497c478bd9Sstevel@tonic-gate "protection %o (%s/%s)? "), cmd, target,
11503d63ea05Sas FMODE(s2) & MODEBITS, yesstr, nostr);
11513d63ea05Sas if (yes() == 0) {
11520f6e7ba6Sas if (buf != NULL)
11530f6e7ba6Sas free(buf);
11540f6e7ba6Sas return (2);
11550f6e7ba6Sas }
11560f6e7ba6Sas } else if (overwrite && ISREG(s2)) {
11577c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
11587c478bd9Sstevel@tonic-gate gettext("%s: overwrite %s (%s/%s)? "),
11593d63ea05Sas cmd, target, yesstr, nostr);
11603d63ea05Sas if (yes() == 0) {
11610f6e7ba6Sas if (buf != NULL)
11620f6e7ba6Sas free(buf);
11630f6e7ba6Sas return (2);
11640f6e7ba6Sas }
11650f6e7ba6Sas } else if (override) {
11667c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
11677c478bd9Sstevel@tonic-gate gettext("%s: %s: override protection "
11687c478bd9Sstevel@tonic-gate /*CSTYLED*/
11697c478bd9Sstevel@tonic-gate "%o (%s/%s)? "),
11707c478bd9Sstevel@tonic-gate /*CSTYLED*/
11717c478bd9Sstevel@tonic-gate cmd, target, FMODE(s2) & MODEBITS,
11723d63ea05Sas yesstr, nostr);
11733d63ea05Sas if (yes() == 0) {
11740f6e7ba6Sas if (buf != NULL)
11750f6e7ba6Sas free(buf);
11760f6e7ba6Sas return (2);
11777c478bd9Sstevel@tonic-gate }
11787c478bd9Sstevel@tonic-gate }
11790f6e7ba6Sas
11807c478bd9Sstevel@tonic-gate if (lnk && unlink(target) < 0) {
11817c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
11827c478bd9Sstevel@tonic-gate gettext("%s: cannot unlink %s: "),
11837c478bd9Sstevel@tonic-gate cmd, target);
11847c478bd9Sstevel@tonic-gate perror("");
11857c478bd9Sstevel@tonic-gate return (1);
11867c478bd9Sstevel@tonic-gate }
11877c478bd9Sstevel@tonic-gate }
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate return (0);
11907c478bd9Sstevel@tonic-gate }
11917c478bd9Sstevel@tonic-gate
11927c478bd9Sstevel@tonic-gate /*
11937c478bd9Sstevel@tonic-gate * check whether source and target are different
11947c478bd9Sstevel@tonic-gate * return 1 when they are different
11957c478bd9Sstevel@tonic-gate * return 0 when they are identical, or when unable to resolve a pathname
11967c478bd9Sstevel@tonic-gate */
11977c478bd9Sstevel@tonic-gate static int
chk_different(char * source,char * target)11987c478bd9Sstevel@tonic-gate chk_different(char *source, char *target)
11997c478bd9Sstevel@tonic-gate {
12007c478bd9Sstevel@tonic-gate char rtarget[PATH_MAX], rsource[PATH_MAX];
12017c478bd9Sstevel@tonic-gate
12027c478bd9Sstevel@tonic-gate if (IDENTICAL(s1, s2)) {
12037c478bd9Sstevel@tonic-gate /*
12047c478bd9Sstevel@tonic-gate * IDENTICAL will be true for hard links, therefore
12057c478bd9Sstevel@tonic-gate * check whether the filenames are different
12067c478bd9Sstevel@tonic-gate */
12077c478bd9Sstevel@tonic-gate if ((getrealpath(source, rsource) == 0) ||
12087c478bd9Sstevel@tonic-gate (getrealpath(target, rtarget) == 0)) {
12097c478bd9Sstevel@tonic-gate return (0);
12107c478bd9Sstevel@tonic-gate }
12117c478bd9Sstevel@tonic-gate if (strncmp(rsource, rtarget, PATH_MAX) == 0) {
12127c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
12137c478bd9Sstevel@tonic-gate "%s: %s and %s are identical\n"),
12147c478bd9Sstevel@tonic-gate cmd, source, target);
12157c478bd9Sstevel@tonic-gate return (0);
12167c478bd9Sstevel@tonic-gate }
12177c478bd9Sstevel@tonic-gate }
12187c478bd9Sstevel@tonic-gate return (1);
12197c478bd9Sstevel@tonic-gate }
12207c478bd9Sstevel@tonic-gate
12217c478bd9Sstevel@tonic-gate /*
12227c478bd9Sstevel@tonic-gate * get real path (resolved absolute pathname)
12237c478bd9Sstevel@tonic-gate * return 1 on success, 0 on failure
12247c478bd9Sstevel@tonic-gate */
12257c478bd9Sstevel@tonic-gate static int
getrealpath(char * path,char * rpath)12267c478bd9Sstevel@tonic-gate getrealpath(char *path, char *rpath)
12277c478bd9Sstevel@tonic-gate {
12287c478bd9Sstevel@tonic-gate if (realpath(path, rpath) == NULL) {
12297c478bd9Sstevel@tonic-gate int errno_save = errno;
12307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
1231e1636a06Sdanny webster "%s: cannot resolve path %s: "), cmd, path);
12327c478bd9Sstevel@tonic-gate errno = errno_save;
12337c478bd9Sstevel@tonic-gate perror("");
12347c478bd9Sstevel@tonic-gate return (0);
12357c478bd9Sstevel@tonic-gate }
12367c478bd9Sstevel@tonic-gate return (1);
12377c478bd9Sstevel@tonic-gate }
12387c478bd9Sstevel@tonic-gate
12397c478bd9Sstevel@tonic-gate static int
rcopy(char * from,char * to)12407c478bd9Sstevel@tonic-gate rcopy(char *from, char *to)
12417c478bd9Sstevel@tonic-gate {
12427c478bd9Sstevel@tonic-gate DIR *fold = opendir(from);
12437c478bd9Sstevel@tonic-gate struct dirent *dp;
12447c478bd9Sstevel@tonic-gate struct stat statb, s1save;
12457c478bd9Sstevel@tonic-gate int errs = 0;
12467c478bd9Sstevel@tonic-gate char fromname[PATH_MAX];
12477c478bd9Sstevel@tonic-gate
12487c478bd9Sstevel@tonic-gate if (fold == 0 || ((pflg || mve) && fstat(fold->dd_fd, &statb) < 0)) {
12497c478bd9Sstevel@tonic-gate Perror(from);
12507c478bd9Sstevel@tonic-gate return (1);
12517c478bd9Sstevel@tonic-gate }
12527c478bd9Sstevel@tonic-gate if (pflg || mve) {
12537c478bd9Sstevel@tonic-gate /*
12547c478bd9Sstevel@tonic-gate * Save s1 (stat information for source dir) so that
12557c478bd9Sstevel@tonic-gate * mod and access times can be reserved during "cp -p"
12567c478bd9Sstevel@tonic-gate * or mv, since s1 gets overwritten.
12577c478bd9Sstevel@tonic-gate */
12587c478bd9Sstevel@tonic-gate s1save = s1;
12597c478bd9Sstevel@tonic-gate }
12607c478bd9Sstevel@tonic-gate for (;;) {
12617c478bd9Sstevel@tonic-gate dp = readdir(fold);
12627c478bd9Sstevel@tonic-gate if (dp == 0) {
12637c478bd9Sstevel@tonic-gate (void) closedir(fold);
12647c478bd9Sstevel@tonic-gate if (pflg || mve)
12657c478bd9Sstevel@tonic-gate return (chg_time(to, s1save) + errs);
12667c478bd9Sstevel@tonic-gate return (errs);
12677c478bd9Sstevel@tonic-gate }
12687c478bd9Sstevel@tonic-gate if (dp->d_ino == 0)
12697c478bd9Sstevel@tonic-gate continue;
12707c478bd9Sstevel@tonic-gate if ((strcmp(dp->d_name, ".") == 0) ||
12717c478bd9Sstevel@tonic-gate (strcmp(dp->d_name, "..") == 0))
12727c478bd9Sstevel@tonic-gate continue;
12737c478bd9Sstevel@tonic-gate if (strlen(from)+1+strlen(dp->d_name) >=
12747c478bd9Sstevel@tonic-gate sizeof (fromname) - 1) {
12757c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
12767c478bd9Sstevel@tonic-gate gettext("%s : %s/%s: Name too long\n"),
12777c478bd9Sstevel@tonic-gate cmd, from, dp->d_name);
12787c478bd9Sstevel@tonic-gate errs++;
12797c478bd9Sstevel@tonic-gate continue;
12807c478bd9Sstevel@tonic-gate }
12817c478bd9Sstevel@tonic-gate (void) snprintf(fromname, sizeof (fromname),
12827c478bd9Sstevel@tonic-gate "%s/%s", from, dp->d_name);
12837c478bd9Sstevel@tonic-gate errs += cpymve(fromname, to);
12847c478bd9Sstevel@tonic-gate }
12857c478bd9Sstevel@tonic-gate }
12867c478bd9Sstevel@tonic-gate
12877c478bd9Sstevel@tonic-gate static char *
dname(char * name)12887c478bd9Sstevel@tonic-gate dname(char *name)
12897c478bd9Sstevel@tonic-gate {
12907c478bd9Sstevel@tonic-gate register char *p;
12917c478bd9Sstevel@tonic-gate
12927c478bd9Sstevel@tonic-gate /*
12937c478bd9Sstevel@tonic-gate * Return just the file name given the complete path.
12947c478bd9Sstevel@tonic-gate * Like basename(1).
12957c478bd9Sstevel@tonic-gate */
12967c478bd9Sstevel@tonic-gate
12977c478bd9Sstevel@tonic-gate p = name;
12987c478bd9Sstevel@tonic-gate
12997c478bd9Sstevel@tonic-gate /*
13007c478bd9Sstevel@tonic-gate * While there are characters left,
13017c478bd9Sstevel@tonic-gate * set name to start after last
13027c478bd9Sstevel@tonic-gate * delimiter.
13037c478bd9Sstevel@tonic-gate */
13047c478bd9Sstevel@tonic-gate
13057c478bd9Sstevel@tonic-gate while (*p)
13067c478bd9Sstevel@tonic-gate if (*p++ == DELIM && *p)
13077c478bd9Sstevel@tonic-gate name = p;
13087c478bd9Sstevel@tonic-gate return (name);
13097c478bd9Sstevel@tonic-gate }
13107c478bd9Sstevel@tonic-gate
13117c478bd9Sstevel@tonic-gate static void
usage(void)13127c478bd9Sstevel@tonic-gate usage(void)
13137c478bd9Sstevel@tonic-gate {
13147c478bd9Sstevel@tonic-gate /*
13157c478bd9Sstevel@tonic-gate * Display usage message.
13167c478bd9Sstevel@tonic-gate */
13177c478bd9Sstevel@tonic-gate
13187c478bd9Sstevel@tonic-gate if (mve) {
13197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
13207c478bd9Sstevel@tonic-gate "Usage: mv [-f] [-i] f1 f2\n"
13217c478bd9Sstevel@tonic-gate " mv [-f] [-i] f1 ... fn d1\n"
13227c478bd9Sstevel@tonic-gate " mv [-f] [-i] d1 d2\n"));
13237c478bd9Sstevel@tonic-gate } else if (lnk) {
13247c478bd9Sstevel@tonic-gate #ifdef XPG4
13253d63ea05Sas (void) fprintf(stderr, gettext(
13267c478bd9Sstevel@tonic-gate "Usage: ln [-f] [-s] f1 [f2]\n"
13277c478bd9Sstevel@tonic-gate " ln [-f] [-s] f1 ... fn d1\n"
13287c478bd9Sstevel@tonic-gate " ln [-f] -s d1 d2\n"));
13297c478bd9Sstevel@tonic-gate #else
13303d63ea05Sas (void) fprintf(stderr, gettext(
13317c478bd9Sstevel@tonic-gate "Usage: ln [-f] [-n] [-s] f1 [f2]\n"
13327c478bd9Sstevel@tonic-gate " ln [-f] [-n] [-s] f1 ... fn d1\n"
13337c478bd9Sstevel@tonic-gate " ln [-f] [-n] -s d1 d2\n"));
13347c478bd9Sstevel@tonic-gate #endif
13357c478bd9Sstevel@tonic-gate } else if (cpy) {
13367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
13379e647765SAlexander Eremin "Usage: cp [-a] [-f] [-i] [-p] [-@] [-/] f1 f2\n"
13389e647765SAlexander Eremin " cp [-a] [-f] [-i] [-p] [-@] [-/] f1 ... fn d1\n"
13399e647765SAlexander Eremin " cp [-r|-R [-H|-L|-P]] [-a] [-f] [-i] [-p] [-@] "
13409e647765SAlexander Eremin "[-/] d1 ... dn-1 dn\n"));
13417c478bd9Sstevel@tonic-gate }
13427c478bd9Sstevel@tonic-gate exit(2);
13437c478bd9Sstevel@tonic-gate }
13447c478bd9Sstevel@tonic-gate
13457c478bd9Sstevel@tonic-gate /*
13467c478bd9Sstevel@tonic-gate * chg_time()
13477c478bd9Sstevel@tonic-gate *
13487c478bd9Sstevel@tonic-gate * Try to preserve modification and access time.
13497c478bd9Sstevel@tonic-gate * If 1) pflg is not set, or 2) pflg is set and this is the Solaris version,
135078cca7e2SRoger A. Faulkner * don't report a utimensat() failure.
135178cca7e2SRoger A. Faulkner * If this is the XPG4 version and utimensat fails, if 1) pflg is set (cp -p)
13527c478bd9Sstevel@tonic-gate * or 2) we are doing a mv, print a diagnostic message; arrange for a non-zero
13537c478bd9Sstevel@tonic-gate * exit status only if pflg is set.
135478cca7e2SRoger A. Faulkner * utimensat(2) is being used to achieve granularity in nanoseconds
135578cca7e2SRoger A. Faulkner * (if supported by the underlying file system) while setting file times.
13567c478bd9Sstevel@tonic-gate */
13577c478bd9Sstevel@tonic-gate static int
chg_time(char * to,struct stat ss)13587c478bd9Sstevel@tonic-gate chg_time(char *to, struct stat ss)
13597c478bd9Sstevel@tonic-gate {
136078cca7e2SRoger A. Faulkner struct timespec times[2];
1361dfe02591SToomas Soome #ifdef XPG4
13627c478bd9Sstevel@tonic-gate int rc;
1363dfe02591SToomas Soome #endif
13647c478bd9Sstevel@tonic-gate
136578cca7e2SRoger A. Faulkner times[0] = ss.st_atim;
136678cca7e2SRoger A. Faulkner times[1] = ss.st_mtim;
13677c478bd9Sstevel@tonic-gate
1368dfe02591SToomas Soome #ifdef XPG4
13696cdb7222SAlexander Eremin rc = utimensat(AT_FDCWD, to, times,
13706cdb7222SAlexander Eremin ISLNK(s1) ? AT_SYMLINK_NOFOLLOW : 0);
13717c478bd9Sstevel@tonic-gate if ((pflg || mve) && rc != 0) {
13727c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
13737c478bd9Sstevel@tonic-gate gettext("%s: cannot set times for %s: "), cmd, to);
13747c478bd9Sstevel@tonic-gate perror("");
13757c478bd9Sstevel@tonic-gate if (pflg)
13767c478bd9Sstevel@tonic-gate return (1);
13777c478bd9Sstevel@tonic-gate }
1378dfe02591SToomas Soome #else
1379dfe02591SToomas Soome (void) utimensat(AT_FDCWD, to, times,
1380dfe02591SToomas Soome ISLNK(s1) ? AT_SYMLINK_NOFOLLOW : 0);
13817c478bd9Sstevel@tonic-gate #endif
13827c478bd9Sstevel@tonic-gate
13837c478bd9Sstevel@tonic-gate return (0);
13847c478bd9Sstevel@tonic-gate
13857c478bd9Sstevel@tonic-gate }
13867c478bd9Sstevel@tonic-gate
13877c478bd9Sstevel@tonic-gate /*
13887c478bd9Sstevel@tonic-gate * chg_mode()
13897c478bd9Sstevel@tonic-gate *
13907c478bd9Sstevel@tonic-gate * This function is called upon "cp -p" or mv across filesystems.
13917c478bd9Sstevel@tonic-gate *
13927c478bd9Sstevel@tonic-gate * Try to preserve the owner and group id. If chown() fails,
13937c478bd9Sstevel@tonic-gate * only print a diagnostic message if doing a mv in the XPG4 version;
13947c478bd9Sstevel@tonic-gate * try to clear S_ISUID and S_ISGID bits in the target. If unable to clear
13957c478bd9Sstevel@tonic-gate * S_ISUID and S_ISGID bits, print a diagnostic message and arrange for a
13967c478bd9Sstevel@tonic-gate * non-zero exit status because this is a security violation.
13977c478bd9Sstevel@tonic-gate * Try to preserve permissions.
13987c478bd9Sstevel@tonic-gate * If this is the XPG4 version and chmod() fails, print a diagnostic message
13997c478bd9Sstevel@tonic-gate * and arrange for a non-zero exit status.
14007c478bd9Sstevel@tonic-gate * If this is the Solaris version and chmod() fails, do not print a
14017c478bd9Sstevel@tonic-gate * diagnostic message or exit with a non-zero value.
14027c478bd9Sstevel@tonic-gate */
14037c478bd9Sstevel@tonic-gate static int
chg_mode(char * target,uid_t uid,gid_t gid,mode_t mode)14047c478bd9Sstevel@tonic-gate chg_mode(char *target, uid_t uid, gid_t gid, mode_t mode)
14057c478bd9Sstevel@tonic-gate {
14067c478bd9Sstevel@tonic-gate int clearflg = 0; /* controls message printed upon chown() error */
14076cdb7222SAlexander Eremin struct stat st;
14086cdb7222SAlexander Eremin
14096cdb7222SAlexander Eremin /* Don't change mode if target is symlink */
14106cdb7222SAlexander Eremin if (lstat(target, &st) == 0 && ISLNK(st))
14116cdb7222SAlexander Eremin return (0);
14127c478bd9Sstevel@tonic-gate
14137c478bd9Sstevel@tonic-gate if (chown(target, uid, gid) != 0) {
14147c478bd9Sstevel@tonic-gate #ifdef XPG4
14157c478bd9Sstevel@tonic-gate if (mve) {
14167c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot change"
14177c478bd9Sstevel@tonic-gate " owner and group of %s: "), cmd, target);
14187c478bd9Sstevel@tonic-gate perror("");
14197c478bd9Sstevel@tonic-gate }
14207c478bd9Sstevel@tonic-gate #endif
14217c478bd9Sstevel@tonic-gate if (mode & (S_ISUID | S_ISGID)) {
14227c478bd9Sstevel@tonic-gate /* try to clear S_ISUID and S_ISGID */
14237c478bd9Sstevel@tonic-gate mode &= ~S_ISUID & ~S_ISGID;
14247c478bd9Sstevel@tonic-gate ++clearflg;
14257c478bd9Sstevel@tonic-gate }
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate if (chmod(target, mode) != 0) {
14287c478bd9Sstevel@tonic-gate if (clearflg) {
14297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
14307c478bd9Sstevel@tonic-gate "%s: cannot clear S_ISUID and S_ISGID bits in"
14317c478bd9Sstevel@tonic-gate " %s: "), cmd, target);
14327c478bd9Sstevel@tonic-gate perror("");
14337c478bd9Sstevel@tonic-gate /* cp -p should get non-zero exit; mv should not */
14347c478bd9Sstevel@tonic-gate if (pflg)
14357c478bd9Sstevel@tonic-gate return (1);
14367c478bd9Sstevel@tonic-gate }
14377c478bd9Sstevel@tonic-gate #ifdef XPG4
14387c478bd9Sstevel@tonic-gate else {
14397c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
14407c478bd9Sstevel@tonic-gate "%s: cannot set permissions for %s: "), cmd, target);
14417c478bd9Sstevel@tonic-gate perror("");
14427c478bd9Sstevel@tonic-gate /* cp -p should get non-zero exit; mv should not */
14437c478bd9Sstevel@tonic-gate if (pflg)
14447c478bd9Sstevel@tonic-gate return (1);
14457c478bd9Sstevel@tonic-gate }
14467c478bd9Sstevel@tonic-gate #endif
14477c478bd9Sstevel@tonic-gate }
14487c478bd9Sstevel@tonic-gate return (0);
14497c478bd9Sstevel@tonic-gate
14507c478bd9Sstevel@tonic-gate }
14517c478bd9Sstevel@tonic-gate
14527c478bd9Sstevel@tonic-gate static void
Perror(char * s)14537c478bd9Sstevel@tonic-gate Perror(char *s)
14547c478bd9Sstevel@tonic-gate {
14557c478bd9Sstevel@tonic-gate char buf[PATH_MAX + 10];
14567c478bd9Sstevel@tonic-gate
14577c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s: %s", cmd, s);
14587c478bd9Sstevel@tonic-gate perror(buf);
14597c478bd9Sstevel@tonic-gate }
14607c478bd9Sstevel@tonic-gate
14617c478bd9Sstevel@tonic-gate static void
Perror2(char * s1,char * s2)14627c478bd9Sstevel@tonic-gate Perror2(char *s1, char *s2)
14637c478bd9Sstevel@tonic-gate {
14647c478bd9Sstevel@tonic-gate char buf[PATH_MAX + 20];
14657c478bd9Sstevel@tonic-gate
14667c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s: %s: %s",
14677c478bd9Sstevel@tonic-gate cmd, gettext(s1), gettext(s2));
14687c478bd9Sstevel@tonic-gate perror(buf);
14697c478bd9Sstevel@tonic-gate }
14707c478bd9Sstevel@tonic-gate
14717c478bd9Sstevel@tonic-gate /*
14727c478bd9Sstevel@tonic-gate * used for cp -R and for mv across file systems
14737c478bd9Sstevel@tonic-gate */
14747c478bd9Sstevel@tonic-gate static int
copydir(char * source,char * target)14757c478bd9Sstevel@tonic-gate copydir(char *source, char *target)
14767c478bd9Sstevel@tonic-gate {
14777c478bd9Sstevel@tonic-gate int ret, attret = 0;
1478cee1ddadSbasabi int sattret = 0;
14797c478bd9Sstevel@tonic-gate int pret = 0; /* need separate flag if -p is specified */
14807c478bd9Sstevel@tonic-gate mode_t fixmode = (mode_t)0; /* cleanup mode after copy */
14817c478bd9Sstevel@tonic-gate struct stat s1save;
1482fa9e4066Sahrens acl_t *s1acl_save;
1483cee1ddadSbasabi int error = 0;
1484fa9e4066Sahrens
1485fa9e4066Sahrens s1acl_save = NULL;
14867c478bd9Sstevel@tonic-gate
14877c478bd9Sstevel@tonic-gate if (cpy && !rflg) {
14887c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
14897c478bd9Sstevel@tonic-gate gettext("%s: %s: is a directory\n"), cmd, source);
14907c478bd9Sstevel@tonic-gate return (1);
14917c478bd9Sstevel@tonic-gate }
14927c478bd9Sstevel@tonic-gate
14937c478bd9Sstevel@tonic-gate if (stat(target, &s2) < 0) {
14947c478bd9Sstevel@tonic-gate if (mkdir(target, (s1.st_mode & MODEBITS)) < 0) {
14957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", cmd);
14967c478bd9Sstevel@tonic-gate perror(target);
14977c478bd9Sstevel@tonic-gate return (1);
14987c478bd9Sstevel@tonic-gate }
14997c478bd9Sstevel@tonic-gate if (stat(target, &s2) == 0) {
15007c478bd9Sstevel@tonic-gate fixmode = s2.st_mode;
15017c478bd9Sstevel@tonic-gate } else {
15027c478bd9Sstevel@tonic-gate fixmode = s1.st_mode;
15037c478bd9Sstevel@tonic-gate }
15047c478bd9Sstevel@tonic-gate (void) chmod(target, ((fixmode & MODEBITS) | S_IRWXU));
15057c478bd9Sstevel@tonic-gate } else if (!(ISDIR(s2))) {
15067c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
15077c478bd9Sstevel@tonic-gate gettext("%s: %s: not a directory.\n"), cmd, target);
15087c478bd9Sstevel@tonic-gate return (1);
15097c478bd9Sstevel@tonic-gate }
15107c478bd9Sstevel@tonic-gate if (pflg || mve) {
15117c478bd9Sstevel@tonic-gate /*
15127c478bd9Sstevel@tonic-gate * Save s1 (stat information for source dir) and acl info,
15137c478bd9Sstevel@tonic-gate * if any, so that ownership, modes, times, and acl's can
15147c478bd9Sstevel@tonic-gate * be reserved during "cp -p" or mv.
15157c478bd9Sstevel@tonic-gate * s1 gets overwritten when doing the recursive copy.
15167c478bd9Sstevel@tonic-gate */
15177c478bd9Sstevel@tonic-gate s1save = s1;
1518fa9e4066Sahrens if (s1acl != NULL) {
1519fa9e4066Sahrens s1acl_save = acl_dup(s1acl);
1520fa9e4066Sahrens if (s1acl_save == NULL) {
1521fa9e4066Sahrens (void) fprintf(stderr, gettext("%s: "
1522fa9e4066Sahrens "Insufficient memory to save acl"
1523fa9e4066Sahrens " entry\n"), cmd);
1524fa9e4066Sahrens if (pflg)
1525fa9e4066Sahrens return (1);
1526fa9e4066Sahrens
15277c478bd9Sstevel@tonic-gate }
15283d63ea05Sas #ifdef XPG4
15293d63ea05Sas else {
15303d63ea05Sas (void) fprintf(stderr, gettext("%s: "
15313d63ea05Sas "Insufficient memory to save acl"
15323d63ea05Sas " entry\n"), cmd);
15333d63ea05Sas if (pflg)
15343d63ea05Sas return (1);
15353d63ea05Sas }
15367c478bd9Sstevel@tonic-gate #endif
15377c478bd9Sstevel@tonic-gate }
15387c478bd9Sstevel@tonic-gate }
15397c478bd9Sstevel@tonic-gate
15407c478bd9Sstevel@tonic-gate ret = rcopy(source, target);
15417c478bd9Sstevel@tonic-gate
15427c478bd9Sstevel@tonic-gate /*
15437c478bd9Sstevel@tonic-gate * Once we created a directory, go ahead and set
15447c478bd9Sstevel@tonic-gate * its attributes, e.g. acls and time. The info
15457c478bd9Sstevel@tonic-gate * may get overwritten if we continue traversing
15467c478bd9Sstevel@tonic-gate * down the tree.
15477c478bd9Sstevel@tonic-gate *
15487c478bd9Sstevel@tonic-gate * ACL for directory
15497c478bd9Sstevel@tonic-gate */
15507c478bd9Sstevel@tonic-gate if (pflg || mve) {
1551d2443e76Smarks if ((pret = chg_mode(target, UID(s1save), GID(s1save),
1552d2443e76Smarks FMODE(s1save))) == 0)
1553d2443e76Smarks pret = chg_time(target, s1save);
1554d2443e76Smarks ret += pret;
1555fa9e4066Sahrens if (s1acl_save != NULL) {
1556fa9e4066Sahrens if (acl_set(target, s1acl_save) < 0) {
1557cee1ddadSbasabi error++;
15587c478bd9Sstevel@tonic-gate #ifdef XPG4
15597c478bd9Sstevel@tonic-gate if (pflg || mve) {
15607c478bd9Sstevel@tonic-gate #else
15617c478bd9Sstevel@tonic-gate if (pflg) {
15627c478bd9Sstevel@tonic-gate #endif
15637c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
15647c478bd9Sstevel@tonic-gate "%s: failed to set acl entries "
15657c478bd9Sstevel@tonic-gate "on %s\n"), cmd, target);
15667c478bd9Sstevel@tonic-gate if (pflg) {
1567fa9e4066Sahrens acl_free(s1acl_save);
1568fa9e4066Sahrens s1acl_save = NULL;
15697c478bd9Sstevel@tonic-gate ret++;
15707c478bd9Sstevel@tonic-gate }
15717c478bd9Sstevel@tonic-gate }
15727c478bd9Sstevel@tonic-gate /* else: silent and continue */
15737c478bd9Sstevel@tonic-gate }
1574fa9e4066Sahrens acl_free(s1acl_save);
1575fa9e4066Sahrens s1acl_save = NULL;
15767c478bd9Sstevel@tonic-gate }
15777c478bd9Sstevel@tonic-gate } else if (fixmode != (mode_t)0)
15787c478bd9Sstevel@tonic-gate (void) chmod(target, fixmode & MODEBITS);
15797c478bd9Sstevel@tonic-gate
1580da6c28aaSamw if (pflg || atflg || mve || saflg) {
15817c478bd9Sstevel@tonic-gate attret = copyattributes(source, target);
15827c478bd9Sstevel@tonic-gate if (!attrsilent && attret != 0) {
15837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: Failed to preserve"
15847c478bd9Sstevel@tonic-gate " extended attributes of directory"
15857c478bd9Sstevel@tonic-gate " %s\n"), cmd, source);
15867c478bd9Sstevel@tonic-gate } else {
15877c478bd9Sstevel@tonic-gate /*
15887c478bd9Sstevel@tonic-gate * Otherwise ignore failure.
15897c478bd9Sstevel@tonic-gate */
15907c478bd9Sstevel@tonic-gate attret = 0;
15917c478bd9Sstevel@tonic-gate }
1592da6c28aaSamw /* Copy extended system attributes */
1593da6c28aaSamw if (pflg || mve || saflg) {
1594cee1ddadSbasabi sattret = copy_sysattr(source, target);
1595cee1ddadSbasabi if (sattret != 0) {
1596da6c28aaSamw (void) fprintf(stderr, gettext(
1597da6c28aaSamw "%s: Failed to preserve "
1598da6c28aaSamw "extended system attributes "
1599da6c28aaSamw "of directory %s\n"), cmd, source);
1600da6c28aaSamw }
1601da6c28aaSamw }
16027c478bd9Sstevel@tonic-gate }
1603cee1ddadSbasabi if (attret != 0 || sattret != 0 || error != 0)
1604cee1ddadSbasabi return (1);
16057c478bd9Sstevel@tonic-gate return (ret);
16067c478bd9Sstevel@tonic-gate }
16077c478bd9Sstevel@tonic-gate
16087c478bd9Sstevel@tonic-gate static int
16097c478bd9Sstevel@tonic-gate copyspecial(char *target)
16107c478bd9Sstevel@tonic-gate {
16117c478bd9Sstevel@tonic-gate int ret = 0;
16127c478bd9Sstevel@tonic-gate
16137c478bd9Sstevel@tonic-gate if (mknod(target, s1.st_mode, s1.st_rdev) != 0) {
16147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
16157c478bd9Sstevel@tonic-gate "cp: cannot create special file %s: "), target);
16167c478bd9Sstevel@tonic-gate perror("");
16177c478bd9Sstevel@tonic-gate return (1);
16187c478bd9Sstevel@tonic-gate }
16197c478bd9Sstevel@tonic-gate
16207c478bd9Sstevel@tonic-gate if (pflg) {
16217c478bd9Sstevel@tonic-gate if ((ret = chg_mode(target, UID(s1), GID(s1), FMODE(s1))) == 0)
16227c478bd9Sstevel@tonic-gate ret = chg_time(target, s1);
16237c478bd9Sstevel@tonic-gate }
16247c478bd9Sstevel@tonic-gate
16257c478bd9Sstevel@tonic-gate return (ret);
16267c478bd9Sstevel@tonic-gate }
16277c478bd9Sstevel@tonic-gate
16287c478bd9Sstevel@tonic-gate static int
16297c478bd9Sstevel@tonic-gate use_stdin(void)
16307c478bd9Sstevel@tonic-gate {
16317c478bd9Sstevel@tonic-gate #ifdef XPG4
16327c478bd9Sstevel@tonic-gate return (1);
16337c478bd9Sstevel@tonic-gate #else
16347c478bd9Sstevel@tonic-gate return (isatty(fileno(stdin)));
16357c478bd9Sstevel@tonic-gate #endif
16367c478bd9Sstevel@tonic-gate }
16377c478bd9Sstevel@tonic-gate
1638da6c28aaSamw /* Copy non-system extended attributes */
1639da6c28aaSamw
16407c478bd9Sstevel@tonic-gate static int
16417c478bd9Sstevel@tonic-gate copyattributes(char *source, char *target)
16427c478bd9Sstevel@tonic-gate {
16437c478bd9Sstevel@tonic-gate struct dirent *dp;
16447c478bd9Sstevel@tonic-gate int error = 0;
1645fa9e4066Sahrens int aclerror;
16467c478bd9Sstevel@tonic-gate mode_t mode;
16477c478bd9Sstevel@tonic-gate int clearflg = 0;
1648fa9e4066Sahrens acl_t *xacl = NULL;
1649fa9e4066Sahrens acl_t *attrdiracl = NULL;
165078cca7e2SRoger A. Faulkner struct timespec times[2];
16517c478bd9Sstevel@tonic-gate
1652da6c28aaSamw
1653da6c28aaSamw if (pathconf(source, _PC_XATTR_EXISTS) != 1)
16547c478bd9Sstevel@tonic-gate return (0);
16557c478bd9Sstevel@tonic-gate
16567c478bd9Sstevel@tonic-gate if (pathconf(target, _PC_XATTR_ENABLED) != 1) {
16577c478bd9Sstevel@tonic-gate if (!attrsilent) {
16587c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
16597c478bd9Sstevel@tonic-gate gettext(
16607c478bd9Sstevel@tonic-gate "%s: cannot preserve extended attributes, "
16617c478bd9Sstevel@tonic-gate "operation not supported on file"
16627c478bd9Sstevel@tonic-gate " %s\n"), cmd, target);
16637c478bd9Sstevel@tonic-gate }
16647c478bd9Sstevel@tonic-gate return (1);
16657c478bd9Sstevel@tonic-gate }
1666da6c28aaSamw if (open_source(source) != 0)
1667da6c28aaSamw return (1);
1668da6c28aaSamw if (open_target_srctarg_attrdirs(source, target) != 0)
1669da6c28aaSamw return (1);
1670da6c28aaSamw if (open_attrdirp(source) != 0)
1671da6c28aaSamw return (1);
16727c478bd9Sstevel@tonic-gate
16737c478bd9Sstevel@tonic-gate if (pflg || mve) {
16747c478bd9Sstevel@tonic-gate if (fchmod(targetdirfd, attrdir.st_mode) == -1) {
16757c478bd9Sstevel@tonic-gate if (!attrsilent) {
16767c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
16773d63ea05Sas gettext("%s: failed to set file mode"
16783d63ea05Sas " correctly on attribute directory of"
16793d63ea05Sas " file %s: "), cmd, target);
16807c478bd9Sstevel@tonic-gate perror("");
16817c478bd9Sstevel@tonic-gate ++error;
16827c478bd9Sstevel@tonic-gate }
16837c478bd9Sstevel@tonic-gate }
16847c478bd9Sstevel@tonic-gate
16857c478bd9Sstevel@tonic-gate if (fchown(targetdirfd, attrdir.st_uid, attrdir.st_gid) == -1) {
16867c478bd9Sstevel@tonic-gate if (!attrsilent) {
16877c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
16887c478bd9Sstevel@tonic-gate gettext("%s: failed to set file"
16897c478bd9Sstevel@tonic-gate " ownership correctly on attribute"
16907c478bd9Sstevel@tonic-gate " directory of file %s: "), cmd, target);
16917c478bd9Sstevel@tonic-gate perror("");
16927c478bd9Sstevel@tonic-gate ++error;
16937c478bd9Sstevel@tonic-gate }
16947c478bd9Sstevel@tonic-gate }
16957c478bd9Sstevel@tonic-gate /*
16967c478bd9Sstevel@tonic-gate * Now that we are the owner we can update st_ctime by calling
169778cca7e2SRoger A. Faulkner * utimensat.
16987c478bd9Sstevel@tonic-gate */
169978cca7e2SRoger A. Faulkner times[0] = attrdir.st_atim;
170078cca7e2SRoger A. Faulkner times[1] = attrdir.st_mtim;
170178cca7e2SRoger A. Faulkner if (utimensat(targetdirfd, ".", times, 0) < 0) {
17027c478bd9Sstevel@tonic-gate if (!attrsilent) {
17037c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
17043d63ea05Sas gettext("%s: cannot set attribute times"
17053d63ea05Sas " for %s: "), cmd, target);
17067c478bd9Sstevel@tonic-gate perror("");
17077c478bd9Sstevel@tonic-gate ++error;
17087c478bd9Sstevel@tonic-gate }
17097c478bd9Sstevel@tonic-gate }
17107c478bd9Sstevel@tonic-gate
17117c478bd9Sstevel@tonic-gate /*
17127c478bd9Sstevel@tonic-gate * Now set owner and group of attribute directory, implies
17137c478bd9Sstevel@tonic-gate * changing the ACL of the hidden attribute directory first.
17147c478bd9Sstevel@tonic-gate */
1715fa9e4066Sahrens if ((aclerror = facl_get(sourcedirfd,
1716fa9e4066Sahrens ACL_NO_TRIVIAL, &attrdiracl)) != 0) {
17177c478bd9Sstevel@tonic-gate if (!attrsilent) {
17187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
17197c478bd9Sstevel@tonic-gate "%s: failed to get acl entries of"
17207c478bd9Sstevel@tonic-gate " attribute directory for"
1721fa9e4066Sahrens " %s : %s\n"), cmd,
1722fa9e4066Sahrens source, acl_strerror(aclerror));
17237c478bd9Sstevel@tonic-gate ++error;
17247c478bd9Sstevel@tonic-gate }
17257c478bd9Sstevel@tonic-gate }
1726fa9e4066Sahrens
1727fa9e4066Sahrens if (attrdiracl) {
1728fa9e4066Sahrens if (facl_set(targetdirfd, attrdiracl) != 0) {
17297c478bd9Sstevel@tonic-gate if (!attrsilent) {
17307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
1731fa9e4066Sahrens "%s: failed to set acl entries"
1732fa9e4066Sahrens " on attribute directory "
1733fa9e4066Sahrens "for %s\n"), cmd, target);
17347c478bd9Sstevel@tonic-gate ++error;
17357c478bd9Sstevel@tonic-gate }
1736fa9e4066Sahrens acl_free(attrdiracl);
1737fa9e4066Sahrens attrdiracl = NULL;
17387c478bd9Sstevel@tonic-gate }
17397c478bd9Sstevel@tonic-gate }
17407c478bd9Sstevel@tonic-gate }
17417c478bd9Sstevel@tonic-gate
1742da6c28aaSamw while ((dp = readdir(srcdirp)) != NULL) {
1743da6c28aaSamw int ret;
17447c478bd9Sstevel@tonic-gate
1745da6c28aaSamw if ((ret = traverse_attrfile(dp, source, target, 1)) == -1)
1746da6c28aaSamw continue;
1747da6c28aaSamw else if (ret > 0) {
17487c478bd9Sstevel@tonic-gate ++error;
17497c478bd9Sstevel@tonic-gate goto out;
17507c478bd9Sstevel@tonic-gate }
17517c478bd9Sstevel@tonic-gate
17527c478bd9Sstevel@tonic-gate if (pflg || mve) {
1753fa9e4066Sahrens if ((aclerror = facl_get(srcattrfd,
1754fa9e4066Sahrens ACL_NO_TRIVIAL, &xacl)) != 0) {
17557c478bd9Sstevel@tonic-gate if (!attrsilent) {
17567c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
17577c478bd9Sstevel@tonic-gate "%s: failed to get acl entries of"
17587c478bd9Sstevel@tonic-gate " attribute %s for"
1759fa9e4066Sahrens " %s: %s"), cmd, dp->d_name,
1760fa9e4066Sahrens source, acl_strerror(aclerror));
17617c478bd9Sstevel@tonic-gate ++error;
17627c478bd9Sstevel@tonic-gate }
17637c478bd9Sstevel@tonic-gate }
17647c478bd9Sstevel@tonic-gate }
17657c478bd9Sstevel@tonic-gate
17667c478bd9Sstevel@tonic-gate /*
17677c478bd9Sstevel@tonic-gate * preserve ACL
17687c478bd9Sstevel@tonic-gate */
1769fa9e4066Sahrens if ((pflg || mve) && xacl != NULL) {
1770fa9e4066Sahrens if ((facl_set(targattrfd, xacl)) < 0) {
17717c478bd9Sstevel@tonic-gate if (!attrsilent) {
17727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
17737c478bd9Sstevel@tonic-gate "%s: failed to set acl entries on"
17747c478bd9Sstevel@tonic-gate " attribute %s for"
17757c478bd9Sstevel@tonic-gate "%s\n"), cmd, dp->d_name, target);
17767c478bd9Sstevel@tonic-gate ++error;
17777c478bd9Sstevel@tonic-gate }
1778fa9e4066Sahrens acl_free(xacl);
1779fa9e4066Sahrens xacl = NULL;
17807c478bd9Sstevel@tonic-gate }
17817c478bd9Sstevel@tonic-gate }
17827c478bd9Sstevel@tonic-gate
1783da6c28aaSamw if (writefile(srcattrfd, targattrfd, source, target,
1784da6c28aaSamw dp->d_name, dp->d_name, &s3, &s4) != 0) {
17857c478bd9Sstevel@tonic-gate if (!attrsilent) {
17867c478bd9Sstevel@tonic-gate ++error;
17877c478bd9Sstevel@tonic-gate }
17887c478bd9Sstevel@tonic-gate goto next;
17897c478bd9Sstevel@tonic-gate }
17907c478bd9Sstevel@tonic-gate
17917c478bd9Sstevel@tonic-gate if (pflg || mve) {
17927c478bd9Sstevel@tonic-gate mode = FMODE(s3);
17937c478bd9Sstevel@tonic-gate
17947c478bd9Sstevel@tonic-gate if (fchown(targattrfd, UID(s3), GID(s3)) != 0) {
17957c478bd9Sstevel@tonic-gate if (!attrsilent) {
17967c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
17977c478bd9Sstevel@tonic-gate gettext("%s: cannot change"
17987c478bd9Sstevel@tonic-gate " owner and group of"
17997c478bd9Sstevel@tonic-gate " attribute %s for" " file"
18007c478bd9Sstevel@tonic-gate " %s: "), cmd, dp->d_name, target);
18017c478bd9Sstevel@tonic-gate perror("");
18027c478bd9Sstevel@tonic-gate ++error;
18037c478bd9Sstevel@tonic-gate }
18047c478bd9Sstevel@tonic-gate if (mode & (S_ISUID | S_ISGID)) {
18057c478bd9Sstevel@tonic-gate /* try to clear S_ISUID and S_ISGID */
18067c478bd9Sstevel@tonic-gate mode &= ~S_ISUID & ~S_ISGID;
18077c478bd9Sstevel@tonic-gate ++clearflg;
18087c478bd9Sstevel@tonic-gate }
18097c478bd9Sstevel@tonic-gate }
181078cca7e2SRoger A. Faulkner times[0] = s3.st_atim;
181178cca7e2SRoger A. Faulkner times[1] = s3.st_mtim;
181278cca7e2SRoger A. Faulkner if (utimensat(targetdirfd, dp->d_name, times, 0) < 0) {
18137c478bd9Sstevel@tonic-gate if (!attrsilent) {
18147c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
18157c478bd9Sstevel@tonic-gate gettext("%s: cannot set attribute"
18167c478bd9Sstevel@tonic-gate " times for %s: "), cmd, target);
18177c478bd9Sstevel@tonic-gate perror("");
18187c478bd9Sstevel@tonic-gate ++error;
18197c478bd9Sstevel@tonic-gate }
18207c478bd9Sstevel@tonic-gate }
18217c478bd9Sstevel@tonic-gate if (fchmod(targattrfd, mode) != 0) {
18227c478bd9Sstevel@tonic-gate if (clearflg) {
18237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
18247c478bd9Sstevel@tonic-gate "%s: cannot clear S_ISUID and "
18257c478bd9Sstevel@tonic-gate "S_ISGID bits in attribute %s"
18267c478bd9Sstevel@tonic-gate " for file"
18277c478bd9Sstevel@tonic-gate " %s: "), cmd, dp->d_name, target);
18287c478bd9Sstevel@tonic-gate } else {
18297c478bd9Sstevel@tonic-gate if (!attrsilent) {
18307c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
18313d63ea05Sas gettext(
18327c478bd9Sstevel@tonic-gate "%s: cannot set permissions of attribute"
18337c478bd9Sstevel@tonic-gate " %s for %s: "), cmd, dp->d_name, target);
18347c478bd9Sstevel@tonic-gate perror("");
18357c478bd9Sstevel@tonic-gate ++error;
18367c478bd9Sstevel@tonic-gate }
18377c478bd9Sstevel@tonic-gate }
18387c478bd9Sstevel@tonic-gate }
1839d2443e76Smarks if (xacl && ((facl_set(targattrfd, xacl)) < 0)) {
1840d2443e76Smarks if (!attrsilent) {
1841d2443e76Smarks (void) fprintf(stderr, gettext(
1842d2443e76Smarks "%s: failed to set acl entries on"
1843d2443e76Smarks " attribute %s for"
1844d2443e76Smarks "%s\n"), cmd, dp->d_name, target);
1845d2443e76Smarks ++error;
1846d2443e76Smarks }
1847d2443e76Smarks acl_free(xacl);
1848d2443e76Smarks xacl = NULL;
1849d2443e76Smarks }
18507c478bd9Sstevel@tonic-gate }
18517c478bd9Sstevel@tonic-gate next:
1852fa9e4066Sahrens if (xacl != NULL) {
1853fa9e4066Sahrens acl_free(xacl);
1854fa9e4066Sahrens xacl = NULL;
18557c478bd9Sstevel@tonic-gate }
18567c478bd9Sstevel@tonic-gate if (srcattrfd != -1)
18577c478bd9Sstevel@tonic-gate (void) close(srcattrfd);
18587c478bd9Sstevel@tonic-gate if (targattrfd != -1)
18597c478bd9Sstevel@tonic-gate (void) close(targattrfd);
18607c478bd9Sstevel@tonic-gate srcattrfd = targattrfd = -1;
18617c478bd9Sstevel@tonic-gate }
18627c478bd9Sstevel@tonic-gate out:
1863fa9e4066Sahrens if (xacl != NULL) {
1864fa9e4066Sahrens acl_free(xacl);
1865fa9e4066Sahrens xacl = NULL;
1866fa9e4066Sahrens }
1867fa9e4066Sahrens if (attrdiracl != NULL) {
1868fa9e4066Sahrens acl_free(attrdiracl);
1869fa9e4066Sahrens attrdiracl = NULL;
1870fa9e4066Sahrens }
1871da6c28aaSamw
1872da6c28aaSamw if (!saflg && !pflg && !mve)
1873da6c28aaSamw close_all();
1874da6c28aaSamw return (error == 0 ? 0 : 1);
1875da6c28aaSamw }
1876da6c28aaSamw
1877da6c28aaSamw /* Copy extended system attributes from source to target */
1878da6c28aaSamw
1879da6c28aaSamw static int
1880da6c28aaSamw copy_sysattr(char *source, char *target)
1881da6c28aaSamw {
1882da6c28aaSamw struct dirent *dp;
1883da6c28aaSamw nvlist_t *response;
1884da6c28aaSamw int error = 0;
18852b9240ecSbasabi int target_sa_support = 0;
1886da6c28aaSamw
1887da6c28aaSamw if (sysattr_support(source, _PC_SATTR_EXISTS) != 1)
1888da6c28aaSamw return (0);
1889da6c28aaSamw
1890da6c28aaSamw if (open_source(source) != 0)
1891da6c28aaSamw return (1);
1892da6c28aaSamw
1893da6c28aaSamw /*
1894da6c28aaSamw * Gets non default extended system attributes from the
1895da6c28aaSamw * source file to copy to the target. The target has
1896da6c28aaSamw * the defaults set when its created and thus no need
1897da6c28aaSamw * to copy the defaults.
1898da6c28aaSamw */
1899da6c28aaSamw response = sysattr_list(cmd, srcfd, source);
1900da6c28aaSamw
19012b9240ecSbasabi if (sysattr_support(target, _PC_SATTR_ENABLED) != 1) {
19022b9240ecSbasabi if (response != NULL) {
19032b9240ecSbasabi (void) fprintf(stderr,
19042b9240ecSbasabi gettext(
19052b9240ecSbasabi "%s: cannot preserve extended system "
19062b9240ecSbasabi "attribute, operation not supported on file"
19072b9240ecSbasabi " %s\n"), cmd, target);
1908da6c28aaSamw error++;
1909da6c28aaSamw goto out;
1910da6c28aaSamw }
1911da6c28aaSamw } else {
19122b9240ecSbasabi target_sa_support = 1;
1913da6c28aaSamw }
1914da6c28aaSamw
19152b9240ecSbasabi if (target_sa_support) {
19162b9240ecSbasabi if (srcdirp == NULL) {
19172b9240ecSbasabi if (open_target_srctarg_attrdirs(source,
19182b9240ecSbasabi target) != 0) {
1919da6c28aaSamw error++;
19202b9240ecSbasabi goto out;
1921da6c28aaSamw }
19222b9240ecSbasabi if (open_attrdirp(source) != 0) {
19232b9240ecSbasabi error++;
19242b9240ecSbasabi goto out;
19252b9240ecSbasabi }
19262b9240ecSbasabi } else {
19272b9240ecSbasabi rewind_attrdir(srcdirp);
19282b9240ecSbasabi }
19292b9240ecSbasabi while ((dp = readdir(srcdirp)) != NULL) {
19302b9240ecSbasabi nvlist_t *res;
19312b9240ecSbasabi int ret;
19322b9240ecSbasabi
19332b9240ecSbasabi if ((ret = traverse_attrfile(dp, source, target,
19342b9240ecSbasabi 0)) == -1)
19352b9240ecSbasabi continue;
19362b9240ecSbasabi else if (ret > 0) {
19372b9240ecSbasabi ++error;
19382b9240ecSbasabi goto out;
19392b9240ecSbasabi }
19402b9240ecSbasabi /*
19412b9240ecSbasabi * Gets non default extended system attributes from the
19422b9240ecSbasabi * attribute file to copy to the target. The target has
19432b9240ecSbasabi * the defaults set when its created and thus no need
19442b9240ecSbasabi * to copy the defaults.
19452b9240ecSbasabi */
1946*31b6814eSJohn Levon res = sysattr_list(cmd, srcattrfd, dp->d_name);
1947*31b6814eSJohn Levon if (res == NULL)
1948*31b6814eSJohn Levon goto next;
1949da6c28aaSamw
1950da6c28aaSamw /*
1951da6c28aaSamw * Copy non default extended system attributes of named
1952da6c28aaSamw * attribute file.
1953da6c28aaSamw */
1954*31b6814eSJohn Levon if (fsetattr(targattrfd,
1955*31b6814eSJohn Levon XATTR_VIEW_READWRITE, res) != 0) {
1956*31b6814eSJohn Levon ++error;
1957*31b6814eSJohn Levon (void) fprintf(stderr, gettext("%s: "
1958*31b6814eSJohn Levon "Failed to copy extended system "
1959*31b6814eSJohn Levon "attributes from attribute file "
1960*31b6814eSJohn Levon "%s of %s to %s\n"), cmd,
1961*31b6814eSJohn Levon dp->d_name, source, target);
1962da6c28aaSamw }
1963*31b6814eSJohn Levon
1964da6c28aaSamw next:
19652b9240ecSbasabi if (srcattrfd != -1)
19662b9240ecSbasabi (void) close(srcattrfd);
19672b9240ecSbasabi if (targattrfd != -1)
19682b9240ecSbasabi (void) close(targattrfd);
19692b9240ecSbasabi srcattrfd = targattrfd = -1;
1970aab83bb8SJosef 'Jeff' Sipek nvlist_free(res);
19712b9240ecSbasabi }
1972da6c28aaSamw }
1973da6c28aaSamw /* Copy source file non default extended system attributes to target */
19742b9240ecSbasabi if (target_sa_support && (response != NULL) &&
1975da6c28aaSamw (fsetattr(targfd, XATTR_VIEW_READWRITE, response)) != 0) {
1976da6c28aaSamw ++error;
1977cee1ddadSbasabi (void) fprintf(stderr, gettext("%s: Failed to "
1978cee1ddadSbasabi "copy extended system attributes from "
1979cee1ddadSbasabi "%s to %s\n"), cmd, source, target);
1980da6c28aaSamw }
1981da6c28aaSamw out:
1982aab83bb8SJosef 'Jeff' Sipek nvlist_free(response);
1983da6c28aaSamw close_all();
19847c478bd9Sstevel@tonic-gate return (error == 0 ? 0 : 1);
19857c478bd9Sstevel@tonic-gate }
19867c478bd9Sstevel@tonic-gate
1987da6c28aaSamw /* Open the source file */
1988da6c28aaSamw
1989da6c28aaSamw int
1990da6c28aaSamw open_source(char *src)
1991da6c28aaSamw {
1992da6c28aaSamw int error = 0;
1993da6c28aaSamw
1994da6c28aaSamw srcfd = -1;
1995da6c28aaSamw if ((srcfd = open(src, O_RDONLY)) == -1) {
1996da6c28aaSamw if (pflg && attrsilent) {
1997da6c28aaSamw error++;
1998da6c28aaSamw goto out;
1999da6c28aaSamw }
2000da6c28aaSamw if (!attrsilent) {
2001da6c28aaSamw (void) fprintf(stderr,
2002da6c28aaSamw gettext("%s: cannot open file"
2003da6c28aaSamw " %s: "), cmd, src);
2004da6c28aaSamw perror("");
2005da6c28aaSamw }
2006da6c28aaSamw ++error;
2007da6c28aaSamw }
2008da6c28aaSamw out:
2009da6c28aaSamw if (error)
2010da6c28aaSamw close_all();
2011da6c28aaSamw return (error == 0 ? 0 : 1);
2012da6c28aaSamw }
2013da6c28aaSamw
2014da6c28aaSamw /* Open source attribute dir, target and target attribute dir. */
2015da6c28aaSamw
2016da6c28aaSamw int
2017da6c28aaSamw open_target_srctarg_attrdirs(char *src, char *targ)
2018da6c28aaSamw {
2019da6c28aaSamw int error = 0;
2020da6c28aaSamw
2021da6c28aaSamw targfd = sourcedirfd = targetdirfd = -1;
2022da6c28aaSamw
2023da6c28aaSamw if ((targfd = open(targ, O_RDONLY)) == -1) {
2024da6c28aaSamw if (pflg && attrsilent) {
2025da6c28aaSamw error++;
2026da6c28aaSamw goto out;
2027da6c28aaSamw }
2028da6c28aaSamw if (!attrsilent) {
2029da6c28aaSamw (void) fprintf(stderr,
2030da6c28aaSamw gettext("%s: cannot open file"
2031da6c28aaSamw " %s: "), cmd, targ);
2032da6c28aaSamw perror("");
2033da6c28aaSamw }
2034da6c28aaSamw ++error;
2035da6c28aaSamw goto out;
2036da6c28aaSamw }
2037da6c28aaSamw
2038da6c28aaSamw if ((sourcedirfd = openat(srcfd, ".", O_RDONLY|O_XATTR)) == -1) {
2039da6c28aaSamw if (pflg && attrsilent) {
2040da6c28aaSamw error++;
2041da6c28aaSamw goto out;
2042da6c28aaSamw }
2043da6c28aaSamw if (!attrsilent) {
2044da6c28aaSamw (void) fprintf(stderr,
2045da6c28aaSamw gettext("%s: cannot open attribute"
2046da6c28aaSamw " directory for %s: "), cmd, src);
2047da6c28aaSamw perror("");
2048da6c28aaSamw }
2049da6c28aaSamw ++error;
2050da6c28aaSamw goto out;
2051da6c28aaSamw }
2052da6c28aaSamw
2053da6c28aaSamw if (fstat(sourcedirfd, &attrdir) == -1) {
2054da6c28aaSamw if (pflg && attrsilent) {
2055da6c28aaSamw error++;
2056da6c28aaSamw goto out;
2057da6c28aaSamw }
2058da6c28aaSamw
2059da6c28aaSamw if (!attrsilent) {
2060da6c28aaSamw (void) fprintf(stderr,
2061da6c28aaSamw gettext("%s: could not retrieve stat"
2062da6c28aaSamw " information for attribute directory"
2063da6c28aaSamw "of file %s: "), cmd, src);
2064da6c28aaSamw perror("");
2065da6c28aaSamw }
2066da6c28aaSamw ++error;
2067da6c28aaSamw goto out;
2068da6c28aaSamw }
2069da6c28aaSamw if ((targetdirfd = openat(targfd, ".", O_RDONLY|O_XATTR)) == -1) {
2070da6c28aaSamw if (pflg && attrsilent) {
2071da6c28aaSamw error++;
2072da6c28aaSamw goto out;
2073da6c28aaSamw }
2074da6c28aaSamw if (!attrsilent) {
2075da6c28aaSamw (void) fprintf(stderr,
2076da6c28aaSamw gettext("%s: cannot open attribute"
2077da6c28aaSamw " directory for %s: "), cmd, targ);
2078da6c28aaSamw perror("");
2079da6c28aaSamw }
2080da6c28aaSamw ++error;
2081da6c28aaSamw }
2082da6c28aaSamw out:
2083da6c28aaSamw if (error)
2084da6c28aaSamw close_all();
2085da6c28aaSamw return (error == 0 ? 0 : 1);
2086da6c28aaSamw }
2087da6c28aaSamw
2088da6c28aaSamw int
2089da6c28aaSamw open_attrdirp(char *source)
2090da6c28aaSamw {
2091da6c28aaSamw int tmpfd = -1;
2092da6c28aaSamw int error = 0;
2093da6c28aaSamw
2094da6c28aaSamw /*
2095da6c28aaSamw * dup sourcedirfd for use by fdopendir().
2096da6c28aaSamw * fdopendir will take ownership of given fd and will close
2097da6c28aaSamw * it when closedir() is called.
2098da6c28aaSamw */
2099da6c28aaSamw
2100da6c28aaSamw if ((tmpfd = dup(sourcedirfd)) == -1) {
2101da6c28aaSamw if (pflg && attrsilent) {
2102da6c28aaSamw error++;
2103da6c28aaSamw goto out;
2104da6c28aaSamw }
2105da6c28aaSamw if (!attrsilent) {
2106da6c28aaSamw (void) fprintf(stderr,
2107da6c28aaSamw gettext(
2108da6c28aaSamw "%s: unable to dup attribute directory"
2109da6c28aaSamw " file descriptor for %s: "), cmd, source);
2110da6c28aaSamw perror("");
2111da6c28aaSamw ++error;
2112da6c28aaSamw }
2113da6c28aaSamw goto out;
2114da6c28aaSamw }
2115da6c28aaSamw if ((srcdirp = fdopendir(tmpfd)) == NULL) {
2116da6c28aaSamw if (pflg && attrsilent) {
2117da6c28aaSamw error++;
2118da6c28aaSamw goto out;
2119da6c28aaSamw }
2120da6c28aaSamw if (!attrsilent) {
2121da6c28aaSamw (void) fprintf(stderr,
2122da6c28aaSamw gettext("%s: failed to open attribute"
2123da6c28aaSamw " directory for %s: "), cmd, source);
2124da6c28aaSamw perror("");
2125da6c28aaSamw ++error;
2126da6c28aaSamw }
2127da6c28aaSamw }
2128da6c28aaSamw out:
2129da6c28aaSamw if (error)
2130da6c28aaSamw close_all();
2131da6c28aaSamw return (error == 0 ? 0 : 1);
2132da6c28aaSamw }
2133da6c28aaSamw
2134da6c28aaSamw /* Skips through ., .., and system attribute 'view' files */
2135da6c28aaSamw int
2136da6c28aaSamw traverse_attrfile(struct dirent *dp, char *source, char *target, int first)
2137da6c28aaSamw {
2138da6c28aaSamw int error = 0;
2139da6c28aaSamw
2140beab0215Sbasabi srcattrfd = targattrfd = -1;
2141beab0215Sbasabi
2142da6c28aaSamw if ((dp->d_name[0] == '.' && dp->d_name[1] == '\0') ||
2143da6c28aaSamw (dp->d_name[0] == '.' && dp->d_name[1] == '.' &&
2144da6c28aaSamw dp->d_name[2] == '\0') ||
2145da6c28aaSamw (sysattr_type(dp->d_name) == _RO_SATTR) ||
2146da6c28aaSamw (sysattr_type(dp->d_name) == _RW_SATTR))
2147da6c28aaSamw return (-1);
2148da6c28aaSamw
2149da6c28aaSamw if ((srcattrfd = openat(sourcedirfd, dp->d_name,
2150da6c28aaSamw O_RDONLY)) == -1) {
2151da6c28aaSamw if (!attrsilent) {
2152da6c28aaSamw (void) fprintf(stderr,
2153da6c28aaSamw gettext("%s: cannot open attribute %s on"
2154da6c28aaSamw " file %s: "), cmd, dp->d_name, source);
2155da6c28aaSamw perror("");
2156da6c28aaSamw ++error;
2157da6c28aaSamw goto out;
2158da6c28aaSamw }
2159da6c28aaSamw }
2160da6c28aaSamw
2161da6c28aaSamw if (fstat(srcattrfd, &s3) < 0) {
2162da6c28aaSamw if (!attrsilent) {
2163da6c28aaSamw (void) fprintf(stderr,
2164da6c28aaSamw gettext("%s: could not stat attribute"
2165da6c28aaSamw " %s on file"
2166da6c28aaSamw " %s: "), cmd, dp->d_name, source);
2167da6c28aaSamw perror("");
2168da6c28aaSamw ++error;
2169da6c28aaSamw }
2170da6c28aaSamw goto out;
2171da6c28aaSamw }
2172da6c28aaSamw
2173da6c28aaSamw if (first) {
2174da6c28aaSamw (void) unlinkat(targetdirfd, dp->d_name, 0);
21753a1874bcSbasabi if ((targattrfd = openat(targetdirfd, dp->d_name,
21763a1874bcSbasabi O_RDWR|O_CREAT|O_TRUNC, s3.st_mode & MODEBITS)) == -1) {
21773a1874bcSbasabi if (!attrsilent) {
21783a1874bcSbasabi (void) fprintf(stderr,
21793a1874bcSbasabi gettext("%s: could not create attribute"
21803a1874bcSbasabi " %s on file %s: "), cmd, dp->d_name,
21813a1874bcSbasabi target);
21823a1874bcSbasabi perror("");
21833a1874bcSbasabi ++error;
21843a1874bcSbasabi }
21853a1874bcSbasabi goto out;
21863a1874bcSbasabi }
2187da6c28aaSamw } else {
21883a1874bcSbasabi if ((targattrfd = openat(targetdirfd, dp->d_name,
21893a1874bcSbasabi O_RDONLY)) == -1) {
21903a1874bcSbasabi if (!attrsilent) {
21913a1874bcSbasabi (void) fprintf(stderr,
21923a1874bcSbasabi gettext("%s: could not open attribute"
21933a1874bcSbasabi " %s on file %s: "), cmd, dp->d_name,
21943a1874bcSbasabi target);
21953a1874bcSbasabi perror("");
21963a1874bcSbasabi ++error;
21973a1874bcSbasabi }
21983a1874bcSbasabi goto out;
2199da6c28aaSamw }
2200da6c28aaSamw }
2201da6c28aaSamw
22023a1874bcSbasabi
2203da6c28aaSamw if (fstat(targattrfd, &s4) < 0) {
2204da6c28aaSamw if (!attrsilent) {
2205da6c28aaSamw (void) fprintf(stderr,
2206da6c28aaSamw gettext("%s: could not stat attribute"
2207da6c28aaSamw " %s on file"
2208da6c28aaSamw " %s: "), cmd, dp->d_name, target);
2209da6c28aaSamw perror("");
2210da6c28aaSamw ++error;
2211da6c28aaSamw }
2212da6c28aaSamw }
2213da6c28aaSamw
2214da6c28aaSamw out:
2215da6c28aaSamw if (error) {
2216da6c28aaSamw if (srcattrfd != -1)
2217da6c28aaSamw (void) close(srcattrfd);
2218da6c28aaSamw if (targattrfd != -1)
2219beab0215Sbasabi (void) close(targattrfd);
2220beab0215Sbasabi srcattrfd = targattrfd = -1;
2221da6c28aaSamw }
2222da6c28aaSamw return (error == 0 ? 0 :1);
2223da6c28aaSamw }
2224da6c28aaSamw
2225da6c28aaSamw void
2226da6c28aaSamw rewind_attrdir(DIR * sdp)
2227da6c28aaSamw {
2228da6c28aaSamw int pwdfd;
2229da6c28aaSamw
2230da6c28aaSamw pwdfd = open(".", O_RDONLY);
2231da6c28aaSamw if ((pwdfd != -1) && (fchdir(sourcedirfd) == 0)) {
2232da6c28aaSamw rewinddir(sdp);
2233da6c28aaSamw (void) fchdir(pwdfd);
2234da6c28aaSamw (void) close(pwdfd);
2235da6c28aaSamw } else {
2236da6c28aaSamw if (!attrsilent) {
2237da6c28aaSamw (void) fprintf(stderr, gettext("%s: "
2238da6c28aaSamw "failed to rewind attribute dir\n"),
2239da6c28aaSamw cmd);
2240da6c28aaSamw }
2241da6c28aaSamw }
2242da6c28aaSamw }
2243da6c28aaSamw
2244da6c28aaSamw void
2245da6c28aaSamw close_all()
2246da6c28aaSamw {
2247da6c28aaSamw if (srcattrfd != -1)
2248da6c28aaSamw (void) close(srcattrfd);
2249da6c28aaSamw if (targattrfd != -1)
2250da6c28aaSamw (void) close(targattrfd);
2251da6c28aaSamw if (sourcedirfd != -1)
2252da6c28aaSamw (void) close(sourcedirfd);
2253da6c28aaSamw if (targetdirfd != -1)
2254da6c28aaSamw (void) close(targetdirfd);
2255da6c28aaSamw if (srcdirp != NULL) {
2256da6c28aaSamw (void) closedir(srcdirp);
2257da6c28aaSamw srcdirp = NULL;
2258da6c28aaSamw }
2259da6c28aaSamw if (srcfd != -1)
2260da6c28aaSamw (void) close(srcfd);
2261da6c28aaSamw if (targfd != -1)
2262da6c28aaSamw (void) close(targfd);
2263da6c28aaSamw }
2264