1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
33 * All Rights Reserved
34 *
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
37 * contributors.
38 */
39
40 /*
41 * Combined mv/cp/ln command:
42 * mv file1 file2
43 * mv dir1 dir2
44 * mv file1 ... filen dir1
45 */
46 #include <sys/time.h>
47 #include <signal.h>
48 #include <locale.h>
49 #include <stdarg.h>
50 #include <sys/acl.h>
51 #include <libcmdutils.h>
52 #include <aclutils.h>
53 #include "getresponse.h"
54
55 #define FTYPE(A) (A.st_mode)
56 #define FMODE(A) (A.st_mode)
57 #define UID(A) (A.st_uid)
58 #define GID(A) (A.st_gid)
59 #define IDENTICAL(A, B) (A.st_dev == B.st_dev && A.st_ino == B.st_ino)
60 #define ISDIR(A) ((A.st_mode & S_IFMT) == S_IFDIR)
61 #define ISDOOR(A) ((A.st_mode & S_IFMT) == S_IFDOOR)
62 #define ISLNK(A) ((A.st_mode & S_IFMT) == S_IFLNK)
63 #define ISREG(A) (((A).st_mode & S_IFMT) == S_IFREG)
64 #define ISDEV(A) ((A.st_mode & S_IFMT) == S_IFCHR || \
65 (A.st_mode & S_IFMT) == S_IFBLK || \
66 (A.st_mode & S_IFMT) == S_IFIFO)
67 #define ISSOCK(A) ((A.st_mode & S_IFMT) == S_IFSOCK)
68
69 #define DELIM '/'
70 #define EQ(x, y) (strcmp(x, y) == 0)
71 #define FALSE 0
72 #define MODEBITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
73 #define TRUE 1
74
75 static char *dname(char *);
76 static int lnkfil(char *, char *);
77 static int cpymve(char *, char *);
78 static int chkfiles(char *, char **);
79 static int rcopy(char *, char *);
80 static int chk_different(char *, char *);
81 static int chg_time(char *, struct stat);
82 static int chg_mode(char *, uid_t, gid_t, mode_t);
83 static int copydir(char *, char *);
84 static int copyspecial(char *);
85 static int getrealpath(char *, char *);
86 static void usage(void);
87 static void Perror(char *);
88 static void Perror2(char *, char *);
89 static int use_stdin(void);
90 static int copyattributes(char *, char *);
91 static int copy_sysattr(char *, char *);
92 static tree_node_t *create_tnode(dev_t, ino_t);
93
94 static struct stat s1, s2, s3, s4;
95 static int cpy = FALSE;
96 static int mve = FALSE;
97 static int lnk = FALSE;
98 static char *cmd;
99 static int silent = 0;
100 static int fflg = 0;
101 static int iflg = 0;
102 static int pflg = 0;
103 static int Rflg = 0; /* recursive copy */
104 static int rflg = 0; /* recursive copy */
105 static int sflg = 0;
106 static int Hflg = 0; /* follow cmd line arg symlink to dir */
107 static int Lflg = 0; /* follow symlinks */
108 static int Pflg = 0; /* do not follow symlinks */
109 static int atflg = 0;
110 static int attrsilent = 0;
111 static int targetexists = 0;
112 static int cmdarg; /* command line argument */
113 static avl_tree_t *stree = NULL; /* source file inode search tree */
114 static acl_t *s1acl;
115 static int saflg = 0; /* 'cp' extended system attr. */
116 static int srcfd = -1;
117 static int targfd = -1;
118 static int sourcedirfd = -1;
119 static int targetdirfd = -1;
120 static DIR *srcdirp = NULL;
121 static int srcattrfd = -1;
122 static int targattrfd = -1;
123 static struct stat attrdir;
124
125 /* Extended system attributes support */
126
127 static int open_source(char *);
128 static int open_target_srctarg_attrdirs(char *, char *);
129 static int open_attrdirp(char *);
130 static int traverse_attrfile(struct dirent *, char *, char *, int);
131 static void rewind_attrdir(DIR *);
132 static void close_all();
133
134
135 int
136 main(int argc, char *argv[])
137 {
138 int c, i, r, errflg = 0;
139 char target[PATH_MAX];
140 int (*move)(char *, char *);
141
142 /*
143 * Determine command invoked (mv, cp, or ln)
144 */
145
146 if (cmd = strrchr(argv[0], '/'))
147 ++cmd;
148 else
149 cmd = argv[0];
150
151 /*
152 * Set flags based on command.
153 */
154
155 (void) setlocale(LC_ALL, "");
156 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
157 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
158 #endif
159 (void) textdomain(TEXT_DOMAIN);
160 if (init_yes() < 0) {
161 (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
162 strerror(errno));
163 exit(3);
164 }
165
166 if (EQ(cmd, "mv"))
167 mve = TRUE;
168 else if (EQ(cmd, "ln"))
169 lnk = TRUE;
170 else if (EQ(cmd, "cp"))
171 cpy = TRUE;
172 else {
173 (void) fprintf(stderr,
174 gettext("Invalid command name (%s); expecting "
175 "mv, cp, or ln.\n"), cmd);
176 exit(1);
177 }
178
179 /*
180 * Check for options:
181 * cp -r|-R [-H|-L|-P] [-fip@/] file1 [file2 ...] target
182 * cp [-fiprR@/] file1 [file2 ...] target
183 * ln [-f] [-n] [-s] file1 [file2 ...] target
184 * ln [-f] [-n] [-s] file1 [file2 ...]
185 * mv [-f|i] file1 [file2 ...] target
186 * mv [-f|i] dir1 target
187 */
188
189 if (cpy) {
190 while ((c = getopt(argc, argv, "fHiLpPrR@/")) != EOF)
191 switch (c) {
192 case 'f':
193 fflg++;
194 break;
195 case 'i':
196 iflg++;
197 break;
198 case 'p':
199 pflg++;
200 #ifdef XPG4
201 attrsilent = 1;
202 atflg = 0;
203 saflg = 0;
204 #else
205 if (atflg == 0)
206 attrsilent = 1;
207 #endif
208 break;
209 case 'H':
210 /*
211 * If more than one of -H, -L, or -P are
212 * specified, only the last option specified
213 * determines the behavior.
214 */
215 Lflg = Pflg = 0;
216 Hflg++;
217 break;
218 case 'L':
219 Hflg = Pflg = 0;
220 Lflg++;
221 break;
222 case 'P':
223 Lflg = Hflg = 0;
224 Pflg++;
225 break;
226 case 'R':
227 /*
228 * The default behavior of cp -R|-r
229 * when specified without -H|-L|-P
230 * is -L.
231 */
232 Rflg++;
233 /*FALLTHROUGH*/
234 case 'r':
235 rflg++;
236 break;
237 case '@':
238 atflg++;
239 attrsilent = 0;
240 #ifdef XPG4
241 pflg = 0;
242 #endif
243 break;
244 case '/':
245 saflg++;
246 attrsilent = 0;
247 #ifdef XPG4
248 pflg = 0;
249 #endif
250 break;
251 default:
252 errflg++;
253 }
254
255 /* -R or -r must be specified with -H, -L, or -P */
256 if ((Hflg || Lflg || Pflg) && !(Rflg || rflg)) {
257 errflg++;
258 }
259
260 } else if (mve) {
261 while ((c = getopt(argc, argv, "fis")) != EOF)
262 switch (c) {
263 case 'f':
264 silent++;
265 #ifdef XPG4
266 iflg = 0;
267 #endif
268 break;
269 case 'i':
270 iflg++;
271 #ifdef XPG4
272 silent = 0;
273 #endif
274 break;
275 default:
276 errflg++;
277 }
278 } else { /* ln */
279 while ((c = getopt(argc, argv, "fns")) != EOF)
280 switch (c) {
281 case 'f':
282 silent++;
283 break;
284 case 'n':
285 /* silently ignored; this is the default */
286 break;
287 case 's':
288 sflg++;
289 break;
290 default:
291 errflg++;
292 }
293 }
294
295 /*
296 * For BSD compatibility allow - to delimit the end of
297 * options for mv.
298 */
299 if (mve && optind < argc && (strcmp(argv[optind], "-") == 0))
300 optind++;
301
302 /*
303 * Check for sufficient arguments
304 * or a usage error.
305 */
306
307 argc -= optind;
308 argv = &argv[optind];
309
310 if ((argc < 2 && lnk != TRUE) || (argc < 1 && lnk == TRUE)) {
311 (void) fprintf(stderr,
312 gettext("%s: Insufficient arguments (%d)\n"),
313 cmd, argc);
314 usage();
315 }
316
317 if (errflg != 0)
318 usage();
319
320 /*
321 * If there is more than a source and target,
322 * the last argument (the target) must be a directory
323 * which really exists.
324 */
325
326 if (argc > 2) {
327 if (stat(argv[argc-1], &s2) < 0) {
328 (void) fprintf(stderr,
329 gettext("%s: %s not found\n"),
330 cmd, argv[argc-1]);
331 exit(2);
332 }
333
334 if (!ISDIR(s2)) {
335 (void) fprintf(stderr,
336 gettext("%s: Target %s must be a directory\n"),
337 cmd, argv[argc-1]);
338 usage();
339 }
340 }
341
342 if (strlen(argv[argc-1]) >= PATH_MAX) {
343 (void) fprintf(stderr,
344 gettext("%s: Target %s file name length exceeds PATH_MAX"
345 " %d\n"), cmd, argv[argc-1], PATH_MAX);
346 exit(78);
347 }
348
349 if (argc == 1) {
350 if (!lnk)
351 usage();
352 (void) strcpy(target, ".");
353 } else {
354 (void) strcpy(target, argv[--argc]);
355 }
356
357 /*
358 * Perform a multiple argument mv|cp|ln by
359 * multiple invocations of cpymve() or lnkfil().
360 */
361 if (lnk)
362 move = lnkfil;
363 else
364 move = cpymve;
365
366 r = 0;
367 for (i = 0; i < argc; i++) {
368 stree = NULL;
369 cmdarg = 1;
370 r += move(argv[i], target);
371 }
372
373 /*
374 * Show errors by nonzero exit code.
375 */
376
377 return (r?2:0);
378 }
379
380 static int
381 lnkfil(char *source, char *target)
382 {
383 char *buf = NULL;
384
385 if (sflg) {
386
387 /*
388 * If target is a directory make complete
389 * name of the new symbolic link within that
390 * directory.
391 */
392
393 if ((stat(target, &s2) >= 0) && ISDIR(s2)) {
394 size_t len;
395
396 len = strlen(target) + strlen(dname(source)) + 4;
397 if ((buf = (char *)malloc(len)) == NULL) {
398 (void) fprintf(stderr,
399 gettext("%s: Insufficient memory "
400 "to %s %s\n"), cmd, cmd, source);
401 exit(3);
402 }
403 (void) snprintf(buf, len, "%s/%s",
404 target, dname(source));
405 target = buf;
406 }
407
408 /*
409 * Check to see if the file exists already.
410 * In this case we use lstat() instead of stat():
411 * unlink(2) and symlink(2) will operate on the file
412 * itself, not its reference, if the file is a symlink.
413 */
414
415 if ((lstat(target, &s2) == 0)) {
416 /*
417 * Check if the silent flag is set ie. the -f option
418 * is used. If so, use unlink to remove the current
419 * target to replace with the new target, specified
420 * on the command line. Proceed with symlink.
421 */
422 if (silent) {
423 /*
424 * Don't allow silent (-f) removal of an existing
425 * directory; could leave unreferenced directory
426 * entries.
427 */
428 if (ISDIR(s2)) {
429 (void) fprintf(stderr,
430 gettext("%s: cannot create link "
431 "over directory %s\n"), cmd,
432 target);
433 return (1);
434 }
435 if (unlink(target) < 0) {
436 (void) fprintf(stderr,
437 gettext("%s: cannot unlink %s: "),
438 cmd, target);
439 perror("");
440 return (1);
441 }
442 }
443 }
444
445
446 /*
447 * Create a symbolic link to the source.
448 */
449
450 if (symlink(source, target) < 0) {
451 (void) fprintf(stderr,
452 gettext("%s: cannot create %s: "),
453 cmd, target);
454 perror("");
455 if (buf != NULL)
456 free(buf);
457 return (1);
458 }
459 if (buf != NULL)
460 free(buf);
461 return (0);
462 }
463
464 switch (chkfiles(source, &target)) {
465 case 1: return (1);
466 case 2: return (0);
467 /* default - fall through */
468 }
469
470 /*
471 * Make sure source file is not a directory,
472 * we cannot link directories...
473 */
474
475 if (ISDIR(s1)) {
476 (void) fprintf(stderr,
477 gettext("%s: %s is a directory\n"), cmd, source);
478 return (1);
479 }
480
481 /*
482 * hard link, call link() and return.
483 */
484
485 if (link(source, target) < 0) {
486 if (errno == EXDEV)
487 (void) fprintf(stderr,
488 gettext("%s: %s is on a different file system\n"),
489 cmd, target);
490 else {
491 (void) fprintf(stderr,
492 gettext("%s: cannot create link %s: "),
493 cmd, target);
494 perror("");
495 }
496 if (buf != NULL)
497 free(buf);
498 return (1);
499 } else {
500 if (buf != NULL)
501 free(buf);
502 return (0);
503 }
504 }
505
506 static int
507 cpymve(char *source, char *target)
508 {
509 int n;
510 int fi, fo;
511 int ret = 0;
512 int attret = 0;
513 int sattret = 0;
514 int errno_save;
515 int error = 0;
516
517 switch (chkfiles(source, &target)) {
518 case 1: return (1);
519 case 2: return (0);
520 /* default - fall through */
521 }
522
523 /*
524 * If it's a recursive copy and source
525 * is a directory, then call rcopy (from copydir).
526 */
527 if (cpy) {
528 if (ISDIR(s1)) {
529 int rc;
530 avl_index_t where = 0;
531 tree_node_t *tnode;
532 tree_node_t *tptr;
533 dev_t save_dev = s1.st_dev;
534 ino_t save_ino = s1.st_ino;
535
536 /*
537 * We will be recursing into the directory so
538 * save the inode information to a search tree
539 * to avoid getting into an endless loop.
540 */
541 if ((rc = add_tnode(&stree, save_dev, save_ino)) != 1) {
542 if (rc == 0) {
543 /*
544 * We've already visited this directory.
545 * Don't remove the search tree entry
546 * to make sure we don't get into an
547 * endless loop if revisited from a
548 * different part of the hierarchy.
549 */
550 (void) fprintf(stderr, gettext(
551 "%s: cycle detected: %s\n"),
552 cmd, source);
553 } else {
554 Perror(source);
555 }
556 return (1);
557 }
558
559 cmdarg = 0;
560 rc = copydir(source, target);
561
562 /*
563 * Create a tnode to get an index to the matching
564 * node (same dev and inode) in the search tree,
565 * then use the index to remove the matching node
566 * so it we do not wrongly detect a cycle when
567 * revisiting this directory from another part of
568 * the hierarchy.
569 */
570 if ((tnode = create_tnode(save_dev,
571 save_ino)) == NULL) {
572 Perror(source);
573 return (1);
574 }
575 if ((tptr = avl_find(stree, tnode, &where)) != NULL) {
576 avl_remove(stree, tptr);
577 }
578 free(tptr);
579 free(tnode);
580 return (rc);
581
582 } else if (ISDEV(s1) && Rflg) {
583 return (copyspecial(target));
584 } else {
585 goto copy;
586 }
587 }
588
589 if (mve) {
590 if (rename(source, target) >= 0)
591 return (0);
592 if (errno != EXDEV) {
593 if (errno == ENOTDIR && ISDIR(s1)) {
594 (void) fprintf(stderr,
595 gettext("%s: %s is a directory\n"),
596 cmd, source);
597 return (1);
598 }
599 (void) fprintf(stderr,
600 gettext("%s: cannot rename %s to %s: "),
601 cmd, source, target);
602 perror("");
603 return (1);
604 }
605
606 /*
607 * cannot move a non-directory (source) onto an existing
608 * directory (target)
609 *
610 */
611 if (targetexists && ISDIR(s2) && (!ISDIR(s1))) {
612 (void) fprintf(stderr,
613 gettext("%s: cannot mv a non directory %s "
614 "over existing directory"
615 " %s \n"), cmd, source, target);
616 return (1);
617 }
618 if (ISDIR(s1)) {
619 #ifdef XPG4
620 if (targetexists && ISDIR(s2)) {
621 /* existing target dir must be empty */
622 if (rmdir(target) < 0) {
623 errno_save = errno;
624 (void) fprintf(stderr,
625 gettext("%s: cannot rmdir %s: "),
626 cmd, target);
627 errno = errno_save;
628 perror("");
629 return (1);
630 }
631 }
632 #endif
633 if ((n = copydir(source, target)) == 0)
634 (void) rmdir(source);
635 return (n);
636 }
637
638 /* doors cannot be moved across filesystems */
639 if (ISDOOR(s1)) {
640 (void) fprintf(stderr,
641 gettext("%s: %s: cannot move door "
642 "across file systems\n"), cmd, source);
643 return (1);
644 }
645
646 /* sockets cannot be moved across filesystems */
647 if (ISSOCK(s1)) {
648 (void) fprintf(stderr,
649 gettext("%s: %s: cannot move socket "
650 "across file systems\n"), cmd, source);
651 return (1);
652 }
653
654 /*
655 * File cannot be renamed, try to recreate the symbolic
656 * link or special device, or copy the file wholesale
657 * between file systems.
658 */
659 if (ISLNK(s1)) {
660 register int m;
661 register mode_t md;
662 char symln[PATH_MAX + 1];
663
664 if (targetexists && unlink(target) < 0) {
665 (void) fprintf(stderr,
666 gettext("%s: cannot unlink %s: "),
667 cmd, target);
668 perror("");
669 return (1);
670 }
671
672 if ((m = readlink(source, symln,
673 sizeof (symln) - 1)) < 0) {
674 Perror(source);
675 return (1);
676 }
677 symln[m] = '\0';
678
679 md = umask(~(s1.st_mode & MODEBITS));
680 if (symlink(symln, target) < 0) {
681 Perror(target);
682 return (1);
683 }
684 (void) umask(md);
685 m = lchown(target, UID(s1), GID(s1));
686 #ifdef XPG4
687 if (m < 0) {
688 (void) fprintf(stderr, gettext("%s: cannot"
689 " change owner and group of"
690 " %s: "), cmd, target);
691 perror("");
692 }
693 #endif
694 goto cleanup;
695 }
696 if (ISDEV(s1)) {
697
698 if (targetexists && unlink(target) < 0) {
699 (void) fprintf(stderr,
700 gettext("%s: cannot unlink %s: "),
701 cmd, target);
702 perror("");
703 return (1);
704 }
705
706 if (mknod(target, s1.st_mode, s1.st_rdev) < 0) {
707 Perror(target);
708 return (1);
709 }
710
711 (void) chg_mode(target, UID(s1), GID(s1), FMODE(s1));
712 (void) chg_time(target, s1);
713 goto cleanup;
714 }
715
716 if (ISREG(s1)) {
717 if (ISDIR(s2)) {
718 if (targetexists && rmdir(target) < 0) {
719 (void) fprintf(stderr,
720 gettext("%s: cannot rmdir %s: "),
721 cmd, target);
722 perror("");
723 return (1);
724 }
725 } else {
726 if (targetexists && unlink(target) < 0) {
727 (void) fprintf(stderr,
728 gettext("%s: cannot unlink %s: "),
729 cmd, target);
730 perror("");
731 return (1);
732 }
733 }
734
735
736 copy:
737 /*
738 * If the source file is a symlink, and either
739 * -P or -H flag (only if -H is specified and the
740 * source file is not a command line argument)
741 * were specified, then action is taken on the symlink
742 * itself, not the file referenced by the symlink.
743 * Note: this is executed for 'cp' only.
744 */
745 if (cpy && (Pflg || (Hflg && !cmdarg)) && (ISLNK(s1))) {
746 int m;
747 mode_t md;
748 char symln[PATH_MAX + 1];
749
750 m = readlink(source, symln, sizeof (symln) - 1);
751
752 if (m < 0) {
753 Perror(source);
754 return (1);
755 }
756 symln[m] = '\0';
757
758 /*
759 * Copy the sym link to the target.
760 * Note: If the target exists, write a
761 * diagnostic message, do nothing more
762 * with the source file, and return to
763 * process any remaining files.
764 */
765 md = umask(~(s1.st_mode & MODEBITS));
766 if (symlink(symln, target) < 0) {
767 Perror(target);
768 return (1);
769 }
770 (void) umask(md);
771 m = lchown(target, UID(s1), GID(s1));
772
773 if (m < 0) {
774 (void) fprintf(stderr, gettext(
775 "cp: cannot change owner and "
776 "group of %s:"), target);
777 perror("");
778 }
779 } else {
780 /*
781 * Copy the file. If it happens to be a
782 * symlink, copy the file referenced
783 * by the symlink.
784 */
785 fi = open(source, O_RDONLY);
786 if (fi < 0) {
787 (void) fprintf(stderr,
788 gettext("%s: cannot open %s: "),
789 cmd, source);
790 perror("");
791 return (1);
792 }
793
794 fo = creat(target, s1.st_mode & MODEBITS);
795 if (fo < 0) {
796 /*
797 * If -f and creat() failed, unlink
798 * and try again.
799 */
800 if (fflg) {
801 (void) unlink(target);
802 fo = creat(target,
803 s1.st_mode & MODEBITS);
804 }
805 }
806 if (fo < 0) {
807 (void) fprintf(stderr,
808 gettext("%s: cannot create %s: "),
809 cmd, target);
810 perror("");
811 (void) close(fi);
812 return (1);
813 } else {
814 /* stat the new file, its used below */
815 (void) stat(target, &s2);
816 }
817
818 /*
819 * Set target's permissions to the source
820 * before any copying so that any partially
821 * copied file will have the source's
822 * permissions (at most) or umask permissions
823 * whichever is the most restrictive.
824 *
825 * ACL for regular files
826 */
827
828 if (pflg || mve) {
829 (void) chmod(target, FMODE(s1));
830 if (s1acl != NULL) {
831 if ((acl_set(target,
832 s1acl)) < 0) {
833 error++;
834 (void) fprintf(stderr,
835 gettext("%s: "
836 "Failed to set "
837 "acl entries "
838 "on %s\n"), cmd,
839 target);
840 acl_free(s1acl);
841 s1acl = NULL;
842 /*
843 * else: silent and
844 * continue
845 */
846 }
847 }
848 }
849
850 if (fstat(fi, &s1) < 0) {
851 (void) fprintf(stderr,
852 gettext("%s: cannot access %s\n"),
853 cmd, source);
854 return (1);
855 }
856 if (IDENTICAL(s1, s2)) {
857 (void) fprintf(stderr,
858 gettext(
859 "%s: %s and %s are identical\n"),
860 cmd, source, target);
861 return (1);
862 }
863
864 if (writefile(fi, fo, source, target, NULL,
865 NULL, &s1, &s2) != 0) {
866 return (1);
867 }
868
869 (void) close(fi);
870 if (close(fo) < 0) {
871 Perror2(target, "write");
872 return (1);
873 }
874 }
875 /* Copy regular extended attributes */
876 if (pflg || atflg || mve || saflg) {
877 attret = copyattributes(source, target);
878 if (attret != 0 && !attrsilent) {
879 (void) fprintf(stderr, gettext(
880 "%s: Failed to preserve"
881 " extended attributes of file"
882 " %s\n"), cmd, source);
883 }
884 /* Copy extended system attributes */
885 if (pflg || mve || saflg)
886 sattret = copy_sysattr(source, target);
887 if (mve && attret != 0) {
888 (void) unlink(target);
889 return (1);
890 }
891 if (attrsilent) {
892 attret = 0;
893 }
894 }
895
896 /*
897 * XPG4: the write system call will clear setgid
898 * and setuid bits, so set them again.
899 */
900 if (pflg || mve) {
901 if ((ret = chg_mode(target, UID(s1), GID(s1),
902 FMODE(s1))) > 0)
903 return (1);
904 /*
905 * Reapply ACL, since chmod may have
906 * altered ACL
907 */
908 if (s1acl != NULL) {
909 if ((acl_set(target, s1acl)) < 0) {
910 error++;
911 (void) fprintf(stderr,
912 gettext("%s: Failed to "
913 "set acl entries "
914 "on %s\n"), cmd, target);
915 /*
916 * else: silent and
917 * continue
918 */
919 }
920 }
921 if ((ret = chg_time(target, s1)) > 0)
922 return (1);
923 }
924 if (cpy) {
925 if (error != 0 || attret != 0 || sattret != 0)
926 return (1);
927 return (0);
928 }
929 goto cleanup;
930 }
931 (void) fprintf(stderr,
932 gettext("%s: %s: unknown file type 0x%x\n"), cmd,
933 source, (s1.st_mode & S_IFMT));
934 return (1);
935
936 cleanup:
937 if (unlink(source) < 0) {
938 (void) unlink(target);
939 (void) fprintf(stderr,
940 gettext("%s: cannot unlink %s: "),
941 cmd, source);
942 perror("");
943 return (1);
944 }
945 if (error != 0 || attret != 0 || sattret != 0)
946 return (1);
947 return (ret);
948 }
949 /*NOTREACHED*/
950 return (ret);
951 }
952
953 /*
954 * create_tnode()
955 *
956 * Create a node for use with the search tree which contains the
957 * inode information (device id and inode number).
958 *
959 * Input
960 * dev - device id
961 * ino - inode number
962 *
963 * Output
964 * tnode - NULL on error, otherwise returns a tnode structure
965 * which contains the input device id and inode number.
966 */
967 static tree_node_t *
968 create_tnode(dev_t dev, ino_t ino)
969 {
970 tree_node_t *tnode;
971
972 if ((tnode = (tree_node_t *)malloc(sizeof (tree_node_t))) != NULL) {
973 tnode->node_dev = dev;
974 tnode->node_ino = ino;
975 }
976
977 return (tnode);
978 }
979
980 static int
981 chkfiles(char *source, char **to)
982 {
983 char *buf = (char *)NULL;
984 int (*statf)() = (cpy &&
985 !(Pflg || (Hflg && !cmdarg))) ? stat : lstat;
986 char *target = *to;
987 int error;
988
989 /*
990 * Make sure source file exists.
991 */
992 if ((*statf)(source, &s1) < 0) {
993 /*
994 * Keep the old error message except when someone tries to
995 * mv/cp/ln a symbolic link that has a trailing slash and
996 * points to a file.
997 */
998 if (errno == ENOTDIR)
999 (void) fprintf(stderr, "%s: %s: %s\n", cmd, source,
1000 strerror(errno));
1001 else
1002 (void) fprintf(stderr,
1003 gettext("%s: cannot access %s\n"), cmd, source);
1004 return (1);
1005 }
1006
1007 /*
1008 * Get ACL info: don't bother with ln or cp/mv'ing symlinks
1009 */
1010 if (!lnk && !ISLNK(s1)) {
1011 if (s1acl != NULL) {
1012 acl_free(s1acl);
1013 s1acl = NULL;
1014 }
1015 if ((error = acl_get(source, ACL_NO_TRIVIAL, &s1acl)) != 0) {
1016 (void) fprintf(stderr,
1017 "%s: failed to get acl entries: %s\n", source,
1018 acl_strerror(error));
1019 return (1);
1020 }
1021 /* else: just permission bits */
1022 }
1023
1024 /*
1025 * If stat fails, then the target doesn't exist,
1026 * we will create a new target with default file type of regular.
1027 */
1028
1029 FTYPE(s2) = S_IFREG;
1030 targetexists = 0;
1031 if ((*statf)(target, &s2) >= 0) {
1032 if (ISLNK(s2))
1033 (void) stat(target, &s2);
1034 /*
1035 * If target is a directory,
1036 * make complete name of new file
1037 * within that directory.
1038 */
1039 if (ISDIR(s2)) {
1040 size_t len;
1041
1042 len = strlen(target) + strlen(dname(source)) + 4;
1043 if ((buf = (char *)malloc(len)) == NULL) {
1044 (void) fprintf(stderr,
1045 gettext("%s: Insufficient memory to "
1046 "%s %s\n "), cmd, cmd, source);
1047 exit(3);
1048 }
1049 (void) snprintf(buf, len, "%s/%s",
1050 target, dname(source));
1051 *to = target = buf;
1052 }
1053
1054 if ((*statf)(target, &s2) >= 0) {
1055 int overwrite = FALSE;
1056 int override = FALSE;
1057
1058 targetexists++;
1059 if (cpy || mve) {
1060 /*
1061 * For cp and mv, it is an error if the
1062 * source and target are the same file.
1063 * Check for the same inode and file
1064 * system, but don't check for the same
1065 * absolute pathname because it is an
1066 * error when the source and target are
1067 * hard links to the same file.
1068 */
1069 if (IDENTICAL(s1, s2)) {
1070 (void) fprintf(stderr,
1071 gettext(
1072 "%s: %s and %s are identical\n"),
1073 cmd, source, target);
1074 if (buf != NULL)
1075 free(buf);
1076 return (1);
1077 }
1078 }
1079 if (lnk) {
1080 /*
1081 * For ln, it is an error if the source and
1082 * target are identical files (same inode,
1083 * same file system, and filenames resolve
1084 * to same absolute pathname).
1085 */
1086 if (!chk_different(source, target)) {
1087 if (buf != NULL)
1088 free(buf);
1089 return (1);
1090 }
1091 }
1092 if (lnk && !silent) {
1093 (void) fprintf(stderr,
1094 gettext("%s: %s: File exists\n"),
1095 cmd, target);
1096 if (buf != NULL)
1097 free(buf);
1098 return (1);
1099 }
1100
1101 /*
1102 * overwrite:
1103 * If the user does not have access to
1104 * the target, ask ----if it is not
1105 * silent and user invoked command
1106 * interactively.
1107 *
1108 * override:
1109 * If not silent, and stdin is a terminal, and
1110 * there's no write access, and the file isn't a
1111 * symbolic link, ask for permission.
1112 *
1113 * XPG4: both overwrite and override:
1114 * ask only one question.
1115 *
1116 * TRANSLATION_NOTE - The following messages will
1117 * contain the first character of the strings for
1118 * "yes" and "no" defined in the file
1119 * "nl_langinfo.po". After substitution, the
1120 * message will appear as follows:
1121 * <cmd>: overwrite <filename> (y/n)?
1122 * where <cmd> is the name of the command
1123 * (cp, mv) and <filename> is the destination file
1124 */
1125
1126
1127 overwrite = iflg && !silent && use_stdin();
1128 override = !cpy && (access(target, 2) < 0) &&
1129 !silent && use_stdin() && !ISLNK(s2);
1130
1131 if (overwrite && override) {
1132 (void) fprintf(stderr,
1133 gettext("%s: overwrite %s and override "
1134 "protection %o (%s/%s)? "), cmd, target,
1135 FMODE(s2) & MODEBITS, yesstr, nostr);
1136 if (yes() == 0) {
1137 if (buf != NULL)
1138 free(buf);
1139 return (2);
1140 }
1141 } else if (overwrite && ISREG(s2)) {
1142 (void) fprintf(stderr,
1143 gettext("%s: overwrite %s (%s/%s)? "),
1144 cmd, target, yesstr, nostr);
1145 if (yes() == 0) {
1146 if (buf != NULL)
1147 free(buf);
1148 return (2);
1149 }
1150 } else if (override) {
1151 (void) fprintf(stderr,
1152 gettext("%s: %s: override protection "
1153 /*CSTYLED*/
1154 "%o (%s/%s)? "),
1155 /*CSTYLED*/
1156 cmd, target, FMODE(s2) & MODEBITS,
1157 yesstr, nostr);
1158 if (yes() == 0) {
1159 if (buf != NULL)
1160 free(buf);
1161 return (2);
1162 }
1163 }
1164
1165 if (lnk && unlink(target) < 0) {
1166 (void) fprintf(stderr,
1167 gettext("%s: cannot unlink %s: "),
1168 cmd, target);
1169 perror("");
1170 return (1);
1171 }
1172 }
1173 }
1174 return (0);
1175 }
1176
1177 /*
1178 * check whether source and target are different
1179 * return 1 when they are different
1180 * return 0 when they are identical, or when unable to resolve a pathname
1181 */
1182 static int
1183 chk_different(char *source, char *target)
1184 {
1185 char rtarget[PATH_MAX], rsource[PATH_MAX];
1186
1187 if (IDENTICAL(s1, s2)) {
1188 /*
1189 * IDENTICAL will be true for hard links, therefore
1190 * check whether the filenames are different
1191 */
1192 if ((getrealpath(source, rsource) == 0) ||
1193 (getrealpath(target, rtarget) == 0)) {
1194 return (0);
1195 }
1196 if (strncmp(rsource, rtarget, PATH_MAX) == 0) {
1197 (void) fprintf(stderr, gettext(
1198 "%s: %s and %s are identical\n"),
1199 cmd, source, target);
1200 return (0);
1201 }
1202 }
1203 return (1);
1204 }
1205
1206 /*
1207 * get real path (resolved absolute pathname)
1208 * return 1 on success, 0 on failure
1209 */
1210 static int
1211 getrealpath(char *path, char *rpath)
1212 {
1213 if (realpath(path, rpath) == NULL) {
1214 int errno_save = errno;
1215 (void) fprintf(stderr, gettext(
1216 "%s: cannot resolve path %s: "), cmd, path);
1217 errno = errno_save;
1218 perror("");
1219 return (0);
1220 }
1221 return (1);
1222 }
1223
1224 static int
1225 rcopy(char *from, char *to)
1226 {
1227 DIR *fold = opendir(from);
1228 struct dirent *dp;
1229 struct stat statb, s1save;
1230 int errs = 0;
1231 char fromname[PATH_MAX];
1232
1233 if (fold == 0 || ((pflg || mve) && fstat(fold->dd_fd, &statb) < 0)) {
1234 Perror(from);
1235 return (1);
1236 }
1237 if (pflg || mve) {
1238 /*
1239 * Save s1 (stat information for source dir) so that
1240 * mod and access times can be reserved during "cp -p"
1241 * or mv, since s1 gets overwritten.
1242 */
1243 s1save = s1;
1244 }
1245 for (;;) {
1246 dp = readdir(fold);
1247 if (dp == 0) {
1248 (void) closedir(fold);
1249 if (pflg || mve)
1250 return (chg_time(to, s1save) + errs);
1251 return (errs);
1252 }
1253 if (dp->d_ino == 0)
1254 continue;
1255 if ((strcmp(dp->d_name, ".") == 0) ||
1256 (strcmp(dp->d_name, "..") == 0))
1257 continue;
1258 if (strlen(from)+1+strlen(dp->d_name) >=
1259 sizeof (fromname) - 1) {
1260 (void) fprintf(stderr,
1261 gettext("%s : %s/%s: Name too long\n"),
1262 cmd, from, dp->d_name);
1263 errs++;
1264 continue;
1265 }
1266 (void) snprintf(fromname, sizeof (fromname),
1267 "%s/%s", from, dp->d_name);
1268 errs += cpymve(fromname, to);
1269 }
1270 }
1271
1272 static char *
1273 dname(char *name)
1274 {
1275 register char *p;
1276
1277 /*
1278 * Return just the file name given the complete path.
1279 * Like basename(1).
1280 */
1281
1282 p = name;
1283
1284 /*
1285 * While there are characters left,
1286 * set name to start after last
1287 * delimiter.
1288 */
1289
1290 while (*p)
1291 if (*p++ == DELIM && *p)
1292 name = p;
1293 return (name);
1294 }
1295
1296 static void
1297 usage(void)
1298 {
1299 /*
1300 * Display usage message.
1301 */
1302
1303 if (mve) {
1304 (void) fprintf(stderr, gettext(
1305 "Usage: mv [-f] [-i] f1 f2\n"
1306 " mv [-f] [-i] f1 ... fn d1\n"
1307 " mv [-f] [-i] d1 d2\n"));
1308 } else if (lnk) {
1309 #ifdef XPG4
1310 (void) fprintf(stderr, gettext(
1311 "Usage: ln [-f] [-s] f1 [f2]\n"
1312 " ln [-f] [-s] f1 ... fn d1\n"
1313 " ln [-f] -s d1 d2\n"));
1314 #else
1315 (void) fprintf(stderr, gettext(
1316 "Usage: ln [-f] [-n] [-s] f1 [f2]\n"
1317 " ln [-f] [-n] [-s] f1 ... fn d1\n"
1318 " ln [-f] [-n] -s d1 d2\n"));
1319 #endif
1320 } else if (cpy) {
1321 (void) fprintf(stderr, gettext(
1322 "Usage: cp [-f] [-i] [-p] [-@] [-/] f1 f2\n"
1323 " cp [-f] [-i] [-p] [-@] [-/] f1 ... fn d1\n"
1324 " cp -r|-R [-H|-L|-P] [-f] [-i] [-p] [-@] [-/] "
1325 "d1 ... dn-1 dn\n"));
1326 }
1327 exit(2);
1328 }
1329
1330 /*
1331 * chg_time()
1332 *
1333 * Try to preserve modification and access time.
1334 * If 1) pflg is not set, or 2) pflg is set and this is the Solaris version,
1335 * don't report a utimensat() failure.
1336 * If this is the XPG4 version and utimensat fails, if 1) pflg is set (cp -p)
1337 * or 2) we are doing a mv, print a diagnostic message; arrange for a non-zero
1338 * exit status only if pflg is set.
1339 * utimensat(2) is being used to achieve granularity in nanoseconds
1340 * (if supported by the underlying file system) while setting file times.
1341 */
1342 static int
1343 chg_time(char *to, struct stat ss)
1344 {
1345 struct timespec times[2];
1346 int rc;
1347
1348 times[0] = ss.st_atim;
1349 times[1] = ss.st_mtim;
1350
1351 rc = utimensat(AT_FDCWD, to, times, 0);
1352 #ifdef XPG4
1353 if ((pflg || mve) && rc != 0) {
1354 (void) fprintf(stderr,
1355 gettext("%s: cannot set times for %s: "), cmd, to);
1356 perror("");
1357 if (pflg)
1358 return (1);
1359 }
1360 #endif
1361
1362 return (0);
1363
1364 }
1365
1366 /*
1367 * chg_mode()
1368 *
1369 * This function is called upon "cp -p" or mv across filesystems.
1370 *
1371 * Try to preserve the owner and group id. If chown() fails,
1372 * only print a diagnostic message if doing a mv in the XPG4 version;
1373 * try to clear S_ISUID and S_ISGID bits in the target. If unable to clear
1374 * S_ISUID and S_ISGID bits, print a diagnostic message and arrange for a
1375 * non-zero exit status because this is a security violation.
1376 * Try to preserve permissions.
1377 * If this is the XPG4 version and chmod() fails, print a diagnostic message
1378 * and arrange for a non-zero exit status.
1379 * If this is the Solaris version and chmod() fails, do not print a
1380 * diagnostic message or exit with a non-zero value.
1381 */
1382 static int
1383 chg_mode(char *target, uid_t uid, gid_t gid, mode_t mode)
1384 {
1385 int clearflg = 0; /* controls message printed upon chown() error */
1386
1387 if (chown(target, uid, gid) != 0) {
1388 #ifdef XPG4
1389 if (mve) {
1390 (void) fprintf(stderr, gettext("%s: cannot change"
1391 " owner and group of %s: "), cmd, target);
1392 perror("");
1393 }
1394 #endif
1395 if (mode & (S_ISUID | S_ISGID)) {
1396 /* try to clear S_ISUID and S_ISGID */
1397 mode &= ~S_ISUID & ~S_ISGID;
1398 ++clearflg;
1399 }
1400 }
1401 if (chmod(target, mode) != 0) {
1402 if (clearflg) {
1403 (void) fprintf(stderr, gettext(
1404 "%s: cannot clear S_ISUID and S_ISGID bits in"
1405 " %s: "), cmd, target);
1406 perror("");
1407 /* cp -p should get non-zero exit; mv should not */
1408 if (pflg)
1409 return (1);
1410 }
1411 #ifdef XPG4
1412 else {
1413 (void) fprintf(stderr, gettext(
1414 "%s: cannot set permissions for %s: "), cmd, target);
1415 perror("");
1416 /* cp -p should get non-zero exit; mv should not */
1417 if (pflg)
1418 return (1);
1419 }
1420 #endif
1421 }
1422 return (0);
1423
1424 }
1425
1426 static void
1427 Perror(char *s)
1428 {
1429 char buf[PATH_MAX + 10];
1430
1431 (void) snprintf(buf, sizeof (buf), "%s: %s", cmd, s);
1432 perror(buf);
1433 }
1434
1435 static void
1436 Perror2(char *s1, char *s2)
1437 {
1438 char buf[PATH_MAX + 20];
1439
1440 (void) snprintf(buf, sizeof (buf), "%s: %s: %s",
1441 cmd, gettext(s1), gettext(s2));
1442 perror(buf);
1443 }
1444
1445 /*
1446 * used for cp -R and for mv across file systems
1447 */
1448 static int
1449 copydir(char *source, char *target)
1450 {
1451 int ret, attret = 0;
1452 int sattret = 0;
1453 int pret = 0; /* need separate flag if -p is specified */
1454 mode_t fixmode = (mode_t)0; /* cleanup mode after copy */
1455 struct stat s1save;
1456 acl_t *s1acl_save;
1457 int error = 0;
1458
1459 s1acl_save = NULL;
1460
1461 if (cpy && !rflg) {
1462 (void) fprintf(stderr,
1463 gettext("%s: %s: is a directory\n"), cmd, source);
1464 return (1);
1465 }
1466
1467 if (stat(target, &s2) < 0) {
1468 if (mkdir(target, (s1.st_mode & MODEBITS)) < 0) {
1469 (void) fprintf(stderr, "%s: ", cmd);
1470 perror(target);
1471 return (1);
1472 }
1473 if (stat(target, &s2) == 0) {
1474 fixmode = s2.st_mode;
1475 } else {
1476 fixmode = s1.st_mode;
1477 }
1478 (void) chmod(target, ((fixmode & MODEBITS) | S_IRWXU));
1479 } else if (!(ISDIR(s2))) {
1480 (void) fprintf(stderr,
1481 gettext("%s: %s: not a directory.\n"), cmd, target);
1482 return (1);
1483 }
1484 if (pflg || mve) {
1485 /*
1486 * Save s1 (stat information for source dir) and acl info,
1487 * if any, so that ownership, modes, times, and acl's can
1488 * be reserved during "cp -p" or mv.
1489 * s1 gets overwritten when doing the recursive copy.
1490 */
1491 s1save = s1;
1492 if (s1acl != NULL) {
1493 s1acl_save = acl_dup(s1acl);
1494 if (s1acl_save == NULL) {
1495 (void) fprintf(stderr, gettext("%s: "
1496 "Insufficient memory to save acl"
1497 " entry\n"), cmd);
1498 if (pflg)
1499 return (1);
1500
1501 }
1502 #ifdef XPG4
1503 else {
1504 (void) fprintf(stderr, gettext("%s: "
1505 "Insufficient memory to save acl"
1506 " entry\n"), cmd);
1507 if (pflg)
1508 return (1);
1509 }
1510 #endif
1511 }
1512 }
1513
1514 ret = rcopy(source, target);
1515
1516 /*
1517 * Once we created a directory, go ahead and set
1518 * its attributes, e.g. acls and time. The info
1519 * may get overwritten if we continue traversing
1520 * down the tree.
1521 *
1522 * ACL for directory
1523 */
1524 if (pflg || mve) {
1525 if ((pret = chg_mode(target, UID(s1save), GID(s1save),
1526 FMODE(s1save))) == 0)
1527 pret = chg_time(target, s1save);
1528 ret += pret;
1529 if (s1acl_save != NULL) {
1530 if (acl_set(target, s1acl_save) < 0) {
1531 error++;
1532 #ifdef XPG4
1533 if (pflg || mve) {
1534 #else
1535 if (pflg) {
1536 #endif
1537 (void) fprintf(stderr, gettext(
1538 "%s: failed to set acl entries "
1539 "on %s\n"), cmd, target);
1540 if (pflg) {
1541 acl_free(s1acl_save);
1542 s1acl_save = NULL;
1543 ret++;
1544 }
1545 }
1546 /* else: silent and continue */
1547 }
1548 acl_free(s1acl_save);
1549 s1acl_save = NULL;
1550 }
1551 } else if (fixmode != (mode_t)0)
1552 (void) chmod(target, fixmode & MODEBITS);
1553
1554 if (pflg || atflg || mve || saflg) {
1555 attret = copyattributes(source, target);
1556 if (!attrsilent && attret != 0) {
1557 (void) fprintf(stderr, gettext("%s: Failed to preserve"
1558 " extended attributes of directory"
1559 " %s\n"), cmd, source);
1560 } else {
1561 /*
1562 * Otherwise ignore failure.
1563 */
1564 attret = 0;
1565 }
1566 /* Copy extended system attributes */
1567 if (pflg || mve || saflg) {
1568 sattret = copy_sysattr(source, target);
1569 if (sattret != 0) {
1570 (void) fprintf(stderr, gettext(
1571 "%s: Failed to preserve "
1572 "extended system attributes "
1573 "of directory %s\n"), cmd, source);
1574 }
1575 }
1576 }
1577 if (attret != 0 || sattret != 0 || error != 0)
1578 return (1);
1579 return (ret);
1580 }
1581
1582 static int
1583 copyspecial(char *target)
1584 {
1585 int ret = 0;
1586
1587 if (mknod(target, s1.st_mode, s1.st_rdev) != 0) {
1588 (void) fprintf(stderr, gettext(
1589 "cp: cannot create special file %s: "), target);
1590 perror("");
1591 return (1);
1592 }
1593
1594 if (pflg) {
1595 if ((ret = chg_mode(target, UID(s1), GID(s1), FMODE(s1))) == 0)
1596 ret = chg_time(target, s1);
1597 }
1598
1599 return (ret);
1600 }
1601
1602 static int
1603 use_stdin(void)
1604 {
1605 #ifdef XPG4
1606 return (1);
1607 #else
1608 return (isatty(fileno(stdin)));
1609 #endif
1610 }
1611
1612 /* Copy non-system extended attributes */
1613
1614 static int
1615 copyattributes(char *source, char *target)
1616 {
1617 struct dirent *dp;
1618 int error = 0;
1619 int aclerror;
1620 mode_t mode;
1621 int clearflg = 0;
1622 acl_t *xacl = NULL;
1623 acl_t *attrdiracl = NULL;
1624 struct timespec times[2];
1625
1626
1627 if (pathconf(source, _PC_XATTR_EXISTS) != 1)
1628 return (0);
1629
1630 if (pathconf(target, _PC_XATTR_ENABLED) != 1) {
1631 if (!attrsilent) {
1632 (void) fprintf(stderr,
1633 gettext(
1634 "%s: cannot preserve extended attributes, "
1635 "operation not supported on file"
1636 " %s\n"), cmd, target);
1637 }
1638 return (1);
1639 }
1640 if (open_source(source) != 0)
1641 return (1);
1642 if (open_target_srctarg_attrdirs(source, target) != 0)
1643 return (1);
1644 if (open_attrdirp(source) != 0)
1645 return (1);
1646
1647 if (pflg || mve) {
1648 if (fchmod(targetdirfd, attrdir.st_mode) == -1) {
1649 if (!attrsilent) {
1650 (void) fprintf(stderr,
1651 gettext("%s: failed to set file mode"
1652 " correctly on attribute directory of"
1653 " file %s: "), cmd, target);
1654 perror("");
1655 ++error;
1656 }
1657 }
1658
1659 if (fchown(targetdirfd, attrdir.st_uid, attrdir.st_gid) == -1) {
1660 if (!attrsilent) {
1661 (void) fprintf(stderr,
1662 gettext("%s: failed to set file"
1663 " ownership correctly on attribute"
1664 " directory of file %s: "), cmd, target);
1665 perror("");
1666 ++error;
1667 }
1668 }
1669 /*
1670 * Now that we are the owner we can update st_ctime by calling
1671 * utimensat.
1672 */
1673 times[0] = attrdir.st_atim;
1674 times[1] = attrdir.st_mtim;
1675 if (utimensat(targetdirfd, ".", times, 0) < 0) {
1676 if (!attrsilent) {
1677 (void) fprintf(stderr,
1678 gettext("%s: cannot set attribute times"
1679 " for %s: "), cmd, target);
1680 perror("");
1681 ++error;
1682 }
1683 }
1684
1685 /*
1686 * Now set owner and group of attribute directory, implies
1687 * changing the ACL of the hidden attribute directory first.
1688 */
1689 if ((aclerror = facl_get(sourcedirfd,
1690 ACL_NO_TRIVIAL, &attrdiracl)) != 0) {
1691 if (!attrsilent) {
1692 (void) fprintf(stderr, gettext(
1693 "%s: failed to get acl entries of"
1694 " attribute directory for"
1695 " %s : %s\n"), cmd,
1696 source, acl_strerror(aclerror));
1697 ++error;
1698 }
1699 }
1700
1701 if (attrdiracl) {
1702 if (facl_set(targetdirfd, attrdiracl) != 0) {
1703 if (!attrsilent) {
1704 (void) fprintf(stderr, gettext(
1705 "%s: failed to set acl entries"
1706 " on attribute directory "
1707 "for %s\n"), cmd, target);
1708 ++error;
1709 }
1710 acl_free(attrdiracl);
1711 attrdiracl = NULL;
1712 }
1713 }
1714 }
1715
1716 while ((dp = readdir(srcdirp)) != NULL) {
1717 int ret;
1718
1719 if ((ret = traverse_attrfile(dp, source, target, 1)) == -1)
1720 continue;
1721 else if (ret > 0) {
1722 ++error;
1723 goto out;
1724 }
1725
1726 if (pflg || mve) {
1727 if ((aclerror = facl_get(srcattrfd,
1728 ACL_NO_TRIVIAL, &xacl)) != 0) {
1729 if (!attrsilent) {
1730 (void) fprintf(stderr, gettext(
1731 "%s: failed to get acl entries of"
1732 " attribute %s for"
1733 " %s: %s"), cmd, dp->d_name,
1734 source, acl_strerror(aclerror));
1735 ++error;
1736 }
1737 }
1738 }
1739
1740 /*
1741 * preserve ACL
1742 */
1743 if ((pflg || mve) && xacl != NULL) {
1744 if ((facl_set(targattrfd, xacl)) < 0) {
1745 if (!attrsilent) {
1746 (void) fprintf(stderr, gettext(
1747 "%s: failed to set acl entries on"
1748 " attribute %s for"
1749 "%s\n"), cmd, dp->d_name, target);
1750 ++error;
1751 }
1752 acl_free(xacl);
1753 xacl = NULL;
1754 }
1755 }
1756
1757 if (writefile(srcattrfd, targattrfd, source, target,
1758 dp->d_name, dp->d_name, &s3, &s4) != 0) {
1759 if (!attrsilent) {
1760 ++error;
1761 }
1762 goto next;
1763 }
1764
1765 if (pflg || mve) {
1766 mode = FMODE(s3);
1767
1768 if (fchown(targattrfd, UID(s3), GID(s3)) != 0) {
1769 if (!attrsilent) {
1770 (void) fprintf(stderr,
1771 gettext("%s: cannot change"
1772 " owner and group of"
1773 " attribute %s for" " file"
1774 " %s: "), cmd, dp->d_name, target);
1775 perror("");
1776 ++error;
1777 }
1778 if (mode & (S_ISUID | S_ISGID)) {
1779 /* try to clear S_ISUID and S_ISGID */
1780 mode &= ~S_ISUID & ~S_ISGID;
1781 ++clearflg;
1782 }
1783 }
1784 times[0] = s3.st_atim;
1785 times[1] = s3.st_mtim;
1786 if (utimensat(targetdirfd, dp->d_name, times, 0) < 0) {
1787 if (!attrsilent) {
1788 (void) fprintf(stderr,
1789 gettext("%s: cannot set attribute"
1790 " times for %s: "), cmd, target);
1791 perror("");
1792 ++error;
1793 }
1794 }
1795 if (fchmod(targattrfd, mode) != 0) {
1796 if (clearflg) {
1797 (void) fprintf(stderr, gettext(
1798 "%s: cannot clear S_ISUID and "
1799 "S_ISGID bits in attribute %s"
1800 " for file"
1801 " %s: "), cmd, dp->d_name, target);
1802 } else {
1803 if (!attrsilent) {
1804 (void) fprintf(stderr,
1805 gettext(
1806 "%s: cannot set permissions of attribute"
1807 " %s for %s: "), cmd, dp->d_name, target);
1808 perror("");
1809 ++error;
1810 }
1811 }
1812 }
1813 if (xacl && ((facl_set(targattrfd, xacl)) < 0)) {
1814 if (!attrsilent) {
1815 (void) fprintf(stderr, gettext(
1816 "%s: failed to set acl entries on"
1817 " attribute %s for"
1818 "%s\n"), cmd, dp->d_name, target);
1819 ++error;
1820 }
1821 acl_free(xacl);
1822 xacl = NULL;
1823 }
1824 }
1825 next:
1826 if (xacl != NULL) {
1827 acl_free(xacl);
1828 xacl = NULL;
1829 }
1830 if (srcattrfd != -1)
1831 (void) close(srcattrfd);
1832 if (targattrfd != -1)
1833 (void) close(targattrfd);
1834 srcattrfd = targattrfd = -1;
1835 }
1836 out:
1837 if (xacl != NULL) {
1838 acl_free(xacl);
1839 xacl = NULL;
1840 }
1841 if (attrdiracl != NULL) {
1842 acl_free(attrdiracl);
1843 attrdiracl = NULL;
1844 }
1845
1846 if (!saflg && !pflg && !mve)
1847 close_all();
1848 return (error == 0 ? 0 : 1);
1849 }
1850
1851 /* Copy extended system attributes from source to target */
1852
1853 static int
1854 copy_sysattr(char *source, char *target)
1855 {
1856 struct dirent *dp;
1857 nvlist_t *response;
1858 int error = 0;
1859 int target_sa_support = 0;
1860
1861 if (sysattr_support(source, _PC_SATTR_EXISTS) != 1)
1862 return (0);
1863
1864 if (open_source(source) != 0)
1865 return (1);
1866
1867 /*
1868 * Gets non default extended system attributes from the
1869 * source file to copy to the target. The target has
1870 * the defaults set when its created and thus no need
1871 * to copy the defaults.
1872 */
1873 response = sysattr_list(cmd, srcfd, source);
1874
1875 if (sysattr_support(target, _PC_SATTR_ENABLED) != 1) {
1876 if (response != NULL) {
1877 (void) fprintf(stderr,
1878 gettext(
1879 "%s: cannot preserve extended system "
1880 "attribute, operation not supported on file"
1881 " %s\n"), cmd, target);
1882 error++;
1883 goto out;
1884 }
1885 } else {
1886 target_sa_support = 1;
1887 }
1888
1889 if (target_sa_support) {
1890 if (srcdirp == NULL) {
1891 if (open_target_srctarg_attrdirs(source,
1892 target) != 0) {
1893 error++;
1894 goto out;
1895 }
1896 if (open_attrdirp(source) != 0) {
1897 error++;
1898 goto out;
1899 }
1900 } else {
1901 rewind_attrdir(srcdirp);
1902 }
1903 while ((dp = readdir(srcdirp)) != NULL) {
1904 nvlist_t *res;
1905 int ret;
1906
1907 if ((ret = traverse_attrfile(dp, source, target,
1908 0)) == -1)
1909 continue;
1910 else if (ret > 0) {
1911 ++error;
1912 goto out;
1913 }
1914 /*
1915 * Gets non default extended system attributes from the
1916 * attribute file to copy to the target. The target has
1917 * the defaults set when its created and thus no need
1918 * to copy the defaults.
1919 */
1920 if (dp->d_name != NULL) {
1921 res = sysattr_list(cmd, srcattrfd, dp->d_name);
1922 if (res == NULL)
1923 goto next;
1924
1925 /*
1926 * Copy non default extended system attributes of named
1927 * attribute file.
1928 */
1929 if (fsetattr(targattrfd,
1930 XATTR_VIEW_READWRITE, res) != 0) {
1931 ++error;
1932 (void) fprintf(stderr, gettext("%s: "
1933 "Failed to copy extended system "
1934 "attributes from attribute file "
1935 "%s of %s to %s\n"), cmd,
1936 dp->d_name, source, target);
1937 }
1938 }
1939 next:
1940 if (srcattrfd != -1)
1941 (void) close(srcattrfd);
1942 if (targattrfd != -1)
1943 (void) close(targattrfd);
1944 srcattrfd = targattrfd = -1;
1945 if (res != NULL)
1946 nvlist_free(res);
1947 }
1948 }
1949 /* Copy source file non default extended system attributes to target */
1950 if (target_sa_support && (response != NULL) &&
1951 (fsetattr(targfd, XATTR_VIEW_READWRITE, response)) != 0) {
1952 ++error;
1953 (void) fprintf(stderr, gettext("%s: Failed to "
1954 "copy extended system attributes from "
1955 "%s to %s\n"), cmd, source, target);
1956 }
1957 out:
1958 if (response != NULL)
1959 nvlist_free(response);
1960 close_all();
1961 return (error == 0 ? 0 : 1);
1962 }
1963
1964 /* Open the source file */
1965
1966 int
1967 open_source(char *src)
1968 {
1969 int error = 0;
1970
1971 srcfd = -1;
1972 if ((srcfd = open(src, O_RDONLY)) == -1) {
1973 if (pflg && attrsilent) {
1974 error++;
1975 goto out;
1976 }
1977 if (!attrsilent) {
1978 (void) fprintf(stderr,
1979 gettext("%s: cannot open file"
1980 " %s: "), cmd, src);
1981 perror("");
1982 }
1983 ++error;
1984 }
1985 out:
1986 if (error)
1987 close_all();
1988 return (error == 0 ? 0 : 1);
1989 }
1990
1991 /* Open source attribute dir, target and target attribute dir. */
1992
1993 int
1994 open_target_srctarg_attrdirs(char *src, char *targ)
1995 {
1996 int error = 0;
1997
1998 targfd = sourcedirfd = targetdirfd = -1;
1999
2000 if ((targfd = open(targ, O_RDONLY)) == -1) {
2001 if (pflg && attrsilent) {
2002 error++;
2003 goto out;
2004 }
2005 if (!attrsilent) {
2006 (void) fprintf(stderr,
2007 gettext("%s: cannot open file"
2008 " %s: "), cmd, targ);
2009 perror("");
2010 }
2011 ++error;
2012 goto out;
2013 }
2014
2015 if ((sourcedirfd = openat(srcfd, ".", O_RDONLY|O_XATTR)) == -1) {
2016 if (pflg && attrsilent) {
2017 error++;
2018 goto out;
2019 }
2020 if (!attrsilent) {
2021 (void) fprintf(stderr,
2022 gettext("%s: cannot open attribute"
2023 " directory for %s: "), cmd, src);
2024 perror("");
2025 }
2026 ++error;
2027 goto out;
2028 }
2029
2030 if (fstat(sourcedirfd, &attrdir) == -1) {
2031 if (pflg && attrsilent) {
2032 error++;
2033 goto out;
2034 }
2035
2036 if (!attrsilent) {
2037 (void) fprintf(stderr,
2038 gettext("%s: could not retrieve stat"
2039 " information for attribute directory"
2040 "of file %s: "), cmd, src);
2041 perror("");
2042 }
2043 ++error;
2044 goto out;
2045 }
2046 if ((targetdirfd = openat(targfd, ".", O_RDONLY|O_XATTR)) == -1) {
2047 if (pflg && attrsilent) {
2048 error++;
2049 goto out;
2050 }
2051 if (!attrsilent) {
2052 (void) fprintf(stderr,
2053 gettext("%s: cannot open attribute"
2054 " directory for %s: "), cmd, targ);
2055 perror("");
2056 }
2057 ++error;
2058 }
2059 out:
2060 if (error)
2061 close_all();
2062 return (error == 0 ? 0 : 1);
2063 }
2064
2065 int
2066 open_attrdirp(char *source)
2067 {
2068 int tmpfd = -1;
2069 int error = 0;
2070
2071 /*
2072 * dup sourcedirfd for use by fdopendir().
2073 * fdopendir will take ownership of given fd and will close
2074 * it when closedir() is called.
2075 */
2076
2077 if ((tmpfd = dup(sourcedirfd)) == -1) {
2078 if (pflg && attrsilent) {
2079 error++;
2080 goto out;
2081 }
2082 if (!attrsilent) {
2083 (void) fprintf(stderr,
2084 gettext(
2085 "%s: unable to dup attribute directory"
2086 " file descriptor for %s: "), cmd, source);
2087 perror("");
2088 ++error;
2089 }
2090 goto out;
2091 }
2092 if ((srcdirp = fdopendir(tmpfd)) == NULL) {
2093 if (pflg && attrsilent) {
2094 error++;
2095 goto out;
2096 }
2097 if (!attrsilent) {
2098 (void) fprintf(stderr,
2099 gettext("%s: failed to open attribute"
2100 " directory for %s: "), cmd, source);
2101 perror("");
2102 ++error;
2103 }
2104 }
2105 out:
2106 if (error)
2107 close_all();
2108 return (error == 0 ? 0 : 1);
2109 }
2110
2111 /* Skips through ., .., and system attribute 'view' files */
2112 int
2113 traverse_attrfile(struct dirent *dp, char *source, char *target, int first)
2114 {
2115 int error = 0;
2116
2117 srcattrfd = targattrfd = -1;
2118
2119 if ((dp->d_name[0] == '.' && dp->d_name[1] == '\0') ||
2120 (dp->d_name[0] == '.' && dp->d_name[1] == '.' &&
2121 dp->d_name[2] == '\0') ||
2122 (sysattr_type(dp->d_name) == _RO_SATTR) ||
2123 (sysattr_type(dp->d_name) == _RW_SATTR))
2124 return (-1);
2125
2126 if ((srcattrfd = openat(sourcedirfd, dp->d_name,
2127 O_RDONLY)) == -1) {
2128 if (!attrsilent) {
2129 (void) fprintf(stderr,
2130 gettext("%s: cannot open attribute %s on"
2131 " file %s: "), cmd, dp->d_name, source);
2132 perror("");
2133 ++error;
2134 goto out;
2135 }
2136 }
2137
2138 if (fstat(srcattrfd, &s3) < 0) {
2139 if (!attrsilent) {
2140 (void) fprintf(stderr,
2141 gettext("%s: could not stat attribute"
2142 " %s on file"
2143 " %s: "), cmd, dp->d_name, source);
2144 perror("");
2145 ++error;
2146 }
2147 goto out;
2148 }
2149
2150 if (first) {
2151 (void) unlinkat(targetdirfd, dp->d_name, 0);
2152 if ((targattrfd = openat(targetdirfd, dp->d_name,
2153 O_RDWR|O_CREAT|O_TRUNC, s3.st_mode & MODEBITS)) == -1) {
2154 if (!attrsilent) {
2155 (void) fprintf(stderr,
2156 gettext("%s: could not create attribute"
2157 " %s on file %s: "), cmd, dp->d_name,
2158 target);
2159 perror("");
2160 ++error;
2161 }
2162 goto out;
2163 }
2164 } else {
2165 if ((targattrfd = openat(targetdirfd, dp->d_name,
2166 O_RDONLY)) == -1) {
2167 if (!attrsilent) {
2168 (void) fprintf(stderr,
2169 gettext("%s: could not open attribute"
2170 " %s on file %s: "), cmd, dp->d_name,
2171 target);
2172 perror("");
2173 ++error;
2174 }
2175 goto out;
2176 }
2177 }
2178
2179
2180 if (fstat(targattrfd, &s4) < 0) {
2181 if (!attrsilent) {
2182 (void) fprintf(stderr,
2183 gettext("%s: could not stat attribute"
2184 " %s on file"
2185 " %s: "), cmd, dp->d_name, target);
2186 perror("");
2187 ++error;
2188 }
2189 }
2190
2191 out:
2192 if (error) {
2193 if (srcattrfd != -1)
2194 (void) close(srcattrfd);
2195 if (targattrfd != -1)
2196 (void) close(targattrfd);
2197 srcattrfd = targattrfd = -1;
2198 }
2199 return (error == 0 ? 0 :1);
2200 }
2201
2202 void
2203 rewind_attrdir(DIR * sdp)
2204 {
2205 int pwdfd;
2206
2207 pwdfd = open(".", O_RDONLY);
2208 if ((pwdfd != -1) && (fchdir(sourcedirfd) == 0)) {
2209 rewinddir(sdp);
2210 (void) fchdir(pwdfd);
2211 (void) close(pwdfd);
2212 } else {
2213 if (!attrsilent) {
2214 (void) fprintf(stderr, gettext("%s: "
2215 "failed to rewind attribute dir\n"),
2216 cmd);
2217 }
2218 }
2219 }
2220
2221 void
2222 close_all()
2223 {
2224 if (srcattrfd != -1)
2225 (void) close(srcattrfd);
2226 if (targattrfd != -1)
2227 (void) close(targattrfd);
2228 if (sourcedirfd != -1)
2229 (void) close(sourcedirfd);
2230 if (targetdirfd != -1)
2231 (void) close(targetdirfd);
2232 if (srcdirp != NULL) {
2233 (void) closedir(srcdirp);
2234 srcdirp = NULL;
2235 }
2236 if (srcfd != -1)
2237 (void) close(srcfd);
2238 if (targfd != -1)
2239 (void) close(targfd);
2240 }