2 * Copyright (c) 1991, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 static char sccsid
[] = "@(#)utils.c 8.3 (Berkeley) 4/1/94";
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD: src/bin/cp/utils.c,v 1.46 2005/09/05 04:36:08 csjp Exp $");
38 #include <sys/types.h>
40 #include <sys/param.h>
42 #ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
60 #include <sys/mount.h>
61 #include <get_compat.h>
63 #include <sys/clonefile.h>
65 #define COMPAT_MODE(a,b) (1)
66 #endif /* __APPLE__ */
69 #define cp_pct(x,y) (int)(100.0 * (double)(x) / (double)(y))
72 copy_file(const FTSENT
*entp
, int dne
)
74 static char buf
[MAXBSIZE
];
76 int ch
, checkch
, from_fd
, rval
, to_fd
;
82 #ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
88 if ((from_fd
= open(entp
->fts_path
, O_RDONLY
, 0)) == -1) {
89 warn("%s", entp
->fts_path
);
96 * If the file exists and we're interactive, verify with the user.
97 * If the file DNE, set the mode to be the from file, minus setuid
98 * bits, modified by the umask; arguably wrong, but it makes copying
99 * executables work right and it's been that way forever. (The
100 * other choice is 666 or'ed with the execute bits on the from file
101 * modified by the umask.)
104 #define YESNO "(y/n [n]) "
107 printf("%s not overwritten\n", to
.p_path
);
108 (void)close(from_fd
);
111 (void)fprintf(stderr
, "overwrite %s? %s",
113 checkch
= ch
= getchar();
114 while (ch
!= '\n' && ch
!= EOF
)
116 if (checkch
!= 'y' && checkch
!= 'Y') {
117 (void)close(from_fd
);
118 (void)fprintf(stderr
, "not overwritten\n");
124 (void)unlink(to
.p_path
);
125 int error
= clonefile(entp
->fts_path
, to
.p_path
, 0);
127 warn("%s: clonefile failed", to
.p_path
);
128 (void)close(from_fd
);
129 return error
== 0 ?
0 : 1;
132 if (COMPAT_MODE("bin/cp", "unix2003")) {
133 /* first try to overwrite existing destination file name */
134 to_fd
= open(to
.p_path
, O_WRONLY
| O_TRUNC
, 0);
137 /* Only if it fails remove file and create a new one */
138 (void)unlink(to
.p_path
);
139 to_fd
= open(to
.p_path
, O_WRONLY
| O_TRUNC
| O_CREAT
,
140 fs
->st_mode
& ~(S_ISUID
| S_ISGID
));
145 /* remove existing destination file name,
146 * create a new file */
147 (void)unlink(to
.p_path
);
148 to_fd
= open(to
.p_path
, O_WRONLY
| O_TRUNC
| O_CREAT
,
149 fs
->st_mode
& ~(S_ISUID
| S_ISGID
));
151 /* overwrite existing destination file name */
152 to_fd
= open(to
.p_path
, O_WRONLY
| O_TRUNC
, 0);
157 int error
= clonefile(entp
->fts_path
, to
.p_path
, 0);
159 warn("%s: clonefile failed", to
.p_path
);
160 (void)close(from_fd
);
161 return error
== 0 ?
0 : 1;
164 to_fd
= open(to
.p_path
, O_WRONLY
| O_TRUNC
| O_CREAT
,
165 fs
->st_mode
& ~(S_ISUID
| S_ISGID
));
169 warn("%s", to
.p_path
);
170 (void)close(from_fd
);
177 if (S_ISREG(fs
->st_mode
)) {
181 * Pre-allocate blocks for the destination file if it
184 if (fstatfs(to_fd
, &sfs
) == 0 &&
185 strcmp(sfs
.f_fstypename
, "acfs") == 0) {
189 fst
.fst_posmode
= F_PEOFPOSMODE
;
191 fst
.fst_length
= fs
->st_size
;
193 (void) fcntl(to_fd
, F_PREALLOCATE
, &fst
);
196 #endif /* __APPLE__ */
198 if (fstat(to_fd
, &to_stat
) != -1) {
199 mode
= to_stat
.st_mode
;
200 if ((mode
& (S_IRWXG
|S_IRWXO
))
201 && fchmod(to_fd
, mode
& ~(S_IRWXG
|S_IRWXO
))) {
202 if (errno
!= EPERM
) /* we have write access but do not own the file */
203 warn("%s: fchmod failed", to
.p_path
);
207 warn("%s", to
.p_path
);
210 * Mmap and write if less than 8M (the limit is so we don't totally
211 * trash memory on big files. This is really a minor hack, but it
212 * wins some CPU back.
214 #ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
215 if (S_ISREG(fs
->st_mode
) && fs
->st_size
> 0 &&
216 fs
->st_size
<= 8 * 1048576) {
217 if ((p
= mmap(NULL
, (size_t)fs
->st_size
, PROT_READ
,
218 MAP_SHARED
, from_fd
, (off_t
)0)) == MAP_FAILED
) {
219 warn("%s", entp
->fts_path
);
223 for (bufp
= p
, wresid
= fs
->st_size
; ;
224 bufp
+= wcount
, wresid
-= (size_t)wcount
) {
225 wcount
= write(to_fd
, bufp
, wresid
);
229 (void)fprintf(stderr
,
231 entp
->fts_path
, to
.p_path
,
232 cp_pct(wtotal
, fs
->st_size
));
235 if (wcount
>= (ssize_t
)wresid
|| wcount
<= 0)
238 if (wcount
!= (ssize_t
)wresid
) {
239 warn("%s", to
.p_path
);
242 /* Some systems don't unmap on close(2). */
243 if (munmap(p
, fs
->st_size
) < 0) {
244 warn("%s", entp
->fts_path
);
252 while ((rcount
= read(from_fd
, buf
, MAXBSIZE
)) > 0) {
253 for (bufp
= buf
, wresid
= rcount
; ;
254 bufp
+= wcount
, wresid
-= wcount
) {
255 wcount
= write(to_fd
, bufp
, wresid
);
259 (void)fprintf(stderr
,
261 entp
->fts_path
, to
.p_path
,
262 cp_pct(wtotal
, fs
->st_size
));
265 if (wcount
>= (ssize_t
)wresid
|| wcount
<= 0)
268 if (wcount
!= (ssize_t
)wresid
) {
269 warn("%s", to
.p_path
);
275 warn("%s", entp
->fts_path
);
281 * Don't remove the target even after an error. The target might
282 * not be a regular file, or its attributes might be important,
283 * or its contents might be irreplaceable. It would only be safe
284 * to remove it if we created it and its length is 0.
287 if (fchmod(to_fd
, mode
))
288 warn("%s: fchmod failed", to
.p_path
);
290 /* do these before setfile in case copyfile changes mtime */
291 if (!Xflag
&& S_ISREG(fs
->st_mode
)) { /* skip devices, etc */
292 if (fcopyfile(from_fd
, to_fd
, NULL
, COPYFILE_XATTR
) < 0)
293 warn("%s: could not copy extended attributes to %s", entp
->fts_path
, to
.p_path
);
295 if (pflag
&& setfile(fs
, to_fd
))
298 /* If this ACL denies writeattr then setfile will fail... */
299 if (fcopyfile(from_fd
, to_fd
, NULL
, COPYFILE_ACL
) < 0)
300 warn("%s: could not copy ACL to %s", entp
->fts_path
, to
.p_path
);
302 #else /* !__APPLE__ */
303 if (pflag
&& setfile(fs
, to_fd
))
305 if (pflag
&& preserve_fd_acls(from_fd
, to_fd
) != 0)
307 #endif /* __APPLE__ */
308 (void)close(from_fd
);
310 warn("%s", to
.p_path
);
317 copy_link(const FTSENT
*p
, int exists
)
320 char llink
[PATH_MAX
];
322 if ((len
= readlink(p
->fts_path
, llink
, sizeof(llink
) - 1)) == -1) {
323 warn("readlink: %s", p
->fts_path
);
327 if (exists
&& unlink(to
.p_path
)) {
328 warn("unlink: %s", to
.p_path
);
331 if (symlink(llink
, to
.p_path
)) {
332 warn("symlink: %s", llink
);
337 if (copyfile(p
->fts_path
, to
.p_path
, NULL
, COPYFILE_XATTR
| COPYFILE_NOFOLLOW_SRC
) <0)
338 warn("%s: could not copy extended attributes to %s",
339 p
->fts_path
, to
.p_path
);
341 return (pflag ?
setfile(p
->fts_statp
, -1) : 0);
345 copy_fifo(struct stat
*from_stat
, int exists
)
347 if (exists
&& unlink(to
.p_path
)) {
348 warn("unlink: %s", to
.p_path
);
351 if (mkfifo(to
.p_path
, from_stat
->st_mode
)) {
352 warn("mkfifo: %s", to
.p_path
);
355 return (pflag ?
setfile(from_stat
, -1) : 0);
359 copy_special(struct stat
*from_stat
, int exists
)
361 if (exists
&& unlink(to
.p_path
)) {
362 warn("unlink: %s", to
.p_path
);
365 if (mknod(to
.p_path
, from_stat
->st_mode
, from_stat
->st_rdev
)) {
366 warn("mknod: %s", to
.p_path
);
369 return (pflag ?
setfile(from_stat
, -1) : 0);
373 setfile(struct stat
*fs
, int fd
)
375 static struct timeval tv
[2];
377 int rval
, gotstat
, islink
, fdval
;
381 islink
= !fdval
&& S_ISLNK(fs
->st_mode
);
382 fs
->st_mode
&= S_ISUID
| S_ISGID
| S_ISVTX
| S_IRWXU
| S_IRWXG
| S_IRWXO
;
384 TIMESPEC_TO_TIMEVAL(&tv
[0], &fs
->st_atimespec
);
385 TIMESPEC_TO_TIMEVAL(&tv
[1], &fs
->st_mtimespec
);
386 if (fdval ?
futimes(fd
, tv
) : (islink ?
lutimes(to
.p_path
, tv
) : utimes(to
.p_path
, tv
))) {
387 warn("%sutimes: %s", fdval ?
"f" : (islink ?
"l" : ""), to
.p_path
);
390 if (fdval ?
fstat(fd
, &ts
) : (islink ?
lstat(to
.p_path
, &ts
) :
391 stat(to
.p_path
, &ts
))) {
395 ts
.st_mode
&= S_ISUID
| S_ISGID
| S_ISVTX
| S_IRWXU
| S_IRWXG
| S_IRWXO
;
398 * Changing the ownership probably won't succeed, unless we're root
399 * or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
400 * the mode; current BSD behavior is to remove all setuid bits on
401 * chown. If chown fails, lose setuid/setgid bits.
403 if (!gotstat
|| fs
->st_uid
!= ts
.st_uid
|| fs
->st_gid
!= ts
.st_gid
) {
404 if (fdval ?
fchown(fd
, fs
->st_uid
, fs
->st_gid
) : (islink ?
405 lchown(to
.p_path
, fs
->st_uid
, fs
->st_gid
) :
406 chown(to
.p_path
, fs
->st_uid
, fs
->st_gid
))) {
407 if (errno
!= EPERM
) {
408 warn("%schown: %s", fdval ?
"f" : (islink ?
"l" : ""), to
.p_path
);
411 fs
->st_mode
&= ~(S_ISUID
| S_ISGID
);
415 if (!gotstat
|| fs
->st_mode
!= ts
.st_mode
) {
416 if (fdval ?
fchmod(fd
, fs
->st_mode
) : (islink ?
417 lchmod(to
.p_path
, fs
->st_mode
) :
418 chmod(to
.p_path
, fs
->st_mode
))) {
419 warn("%schmod: %s", fdval ?
"f" : (islink ?
"l" : ""), to
.p_path
);
424 if (!gotstat
|| fs
->st_flags
!= ts
.st_flags
) {
425 if (fdval ?
fchflags(fd
, fs
->st_flags
) : (islink ?
426 lchflags(to
.p_path
, fs
->st_flags
) :
427 chflags(to
.p_path
, fs
->st_flags
))) {
428 if (errno
!= EPERM
) {
429 warn("%schflags: %s", fdval ?
"f" : (islink ?
"l" : ""), to
.p_path
);
439 preserve_fd_acls(int source_fd
, int dest_fd
)
444 if (fpathconf(source_fd
, _PC_ACL_EXTENDED
) != 1 ||
445 fpathconf(dest_fd
, _PC_ACL_EXTENDED
) != 1)
447 acl
= acl_get_fd(source_fd
);
449 warn("failed to get acl entries while setting %s", to
.p_path
);
452 aclp
= &acl
->ats_acl
;
453 if (aclp
->acl_cnt
== 3)
455 if (acl_set_fd(dest_fd
, acl
) < 0) {
456 warn("failed to set acl entries for %s", to
.p_path
);
463 preserve_dir_acls(struct stat
*fs
, char *source_dir
, char *dest_dir
)
465 acl_t (*aclgetf
)(const char *, acl_type_t
);
466 int (*aclsetf
)(const char *, acl_type_t
, acl_t
);
470 if (pathconf(source_dir
, _PC_ACL_EXTENDED
) != 1 ||
471 pathconf(dest_dir
, _PC_ACL_EXTENDED
) != 1)
474 * If the file is a link we will not follow it
476 if (S_ISLNK(fs
->st_mode
)) {
477 aclgetf
= acl_get_link_np
;
478 aclsetf
= acl_set_link_np
;
480 aclgetf
= acl_get_file
;
481 aclsetf
= acl_set_file
;
484 * Even if there is no ACL_TYPE_DEFAULT entry here, a zero
485 * size ACL will be returned. So it is not safe to simply
486 * check the pointer to see if the default ACL is present.
488 acl
= aclgetf(source_dir
, ACL_TYPE_DEFAULT
);
490 warn("failed to get default acl entries on %s",
494 aclp
= &acl
->ats_acl
;
495 if (aclp
->acl_cnt
!= 0 && aclsetf(dest_dir
,
496 ACL_TYPE_DEFAULT
, acl
) < 0) {
497 warn("failed to set default acl entries on %s",
501 acl
= aclgetf(source_dir
, ACL_TYPE_ACCESS
);
503 warn("failed to get acl entries on %s", source_dir
);
506 aclp
= &acl
->ats_acl
;
507 if (aclsetf(dest_dir
, ACL_TYPE_ACCESS
, acl
) < 0) {
508 warn("failed to set acl entries on %s", dest_dir
);
513 #endif /* !__APPLE__ */
519 if (COMPAT_MODE("bin/cp", "unix2003")) {
520 (void)fprintf(stderr
, "%s\n%s\n",
521 "usage: cp [-R [-H | -L | -P]] [-fi | -n] [-apvXc] source_file target_file",
522 " cp [-R [-H | -L | -P]] [-fi | -n] [-apvXc] source_file ... "
525 (void)fprintf(stderr
, "%s\n%s\n",
526 "usage: cp [-R [-H | -L | -P]] [-f | -i | -n] [-apvXc] source_file target_file",
527 " cp [-R [-H | -L | -P]] [-f | -i | -n] [-apvXc] source_file ... "