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