1/* $NetBSD: utils.c,v 1.46 2018/07/17 13:04:58 darcy Exp $ */
2
3/*-
4 * Copyright (c) 1991, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33#ifndef lint
34#if 0
35static char sccsid[] = "@(#)utils.c 8.3 (Berkeley) 4/1/94";
36#else
37__RCSID("$NetBSD: utils.c,v 1.46 2018/07/17 13:04:58 darcy Exp $");
38#endif
39#endif /* not lint */
40
41#include <sys/mman.h>
42#include <sys/param.h>
43#include <sys/stat.h>
44#include <sys/time.h>
45#include <sys/extattr.h>
46
47#include <err.h>
48#include <errno.h>
49#include <fcntl.h>
50#include <fts.h>
51#include <stdbool.h>
52#include <stdio.h>
53#include <stdlib.h>
54#include <string.h>
55#include <unistd.h>
56
57#include "extern.h"
58
59#define MMAP_MAX_SIZE (8 * 1048576)
60#define MMAP_MAX_WRITE (64 * 1024)
61
62int
63set_utimes(const char *file, struct stat *fs)
64{
65 struct timespec ts[2];
66
67 ts[0] = fs->st_atimespec;
68 ts[1] = fs->st_mtimespec;
69
70 if (lutimens(file, ts)) {
71 warn("lutimens: %s", file);
72 return (1);
73 }
74 return (0);
75}
76
77struct finfo {
78 const char *from;
79 const char *to;
80 off_t size;
81};
82
83static void
84progress(const struct finfo *fi, off_t written)
85{
86 int pcent = (int)((100.0 * written) / fi->size);
87
88 pinfo = 0;
89 (void)fprintf(stderr, "%s => %s %llu/%llu bytes %d%% written\n",
90 fi->from, fi->to, (unsigned long long)written,
91 (unsigned long long)fi->size, pcent);
92}
93
94int
95copy_file(FTSENT *entp, int dne)
96{
97 static char buf[MAXBSIZE];
98 struct stat to_stat, *fs;
99 int ch, checkch, from_fd, rcount, rval, to_fd, tolnk, wcount;
100 char *p;
101 off_t ptotal = 0;
102
103 /* if hard linking then simply link and return */
104 if (lflag) {
105 (void)unlink(to.p_path);
106 if (link(entp->fts_path, to.p_path)) {
107 warn("%s", to.p_path);
108 return (1);
109 }
110 return (0);
111 }
112
113 if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
114 warn("%s", entp->fts_path);
115 return (1);
116 }
117
118 to_fd = -1;
119 fs = entp->fts_statp;
120 tolnk = ((Rflag && !(Lflag || Hflag)) || Pflag);
121
122 /*
123 * If the file exists and we're interactive, verify with the user.
124 * If the file DNE, set the mode to be the from file, minus setuid
125 * bits, modified by the umask; arguably wrong, but it makes copying
126 * executables work right and it's been that way forever. (The
127 * other choice is 666 or'ed with the execute bits on the from file
128 * modified by the umask.)
129 */
130 if (!dne) {
131 struct stat sb;
132 int sval;
133
134 if (iflag) {
135 (void)fprintf(stderr, "overwrite %s? ", to.p_path);
136 checkch = ch = getchar();
137 while (ch != '\n' && ch != EOF)
138 ch = getchar();
139 if (checkch != 'y' && checkch != 'Y') {
140 (void)close(from_fd);
141 return (0);
142 }
143 }
144
145 sval = tolnk ?
146 lstat(to.p_path, &sb) : stat(to.p_path, &sb);
147 if (sval == -1) {
148 warn("stat: %s", to.p_path);
149 (void)close(from_fd);
150 return (1);
151 }
152
153 if (!(tolnk && S_ISLNK(sb.st_mode)))
154 to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
155 } else
156 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
157 fs->st_mode & ~(S_ISUID | S_ISGID));
158
159 if (to_fd == -1 && (fflag || tolnk)) {
160 /*
161 * attempt to remove existing destination file name and
162 * create a new file
163 */
164 (void)unlink(to.p_path);
165 to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
166 fs->st_mode & ~(S_ISUID | S_ISGID));
167 }
168
169 if (to_fd == -1) {
170 warn("%s", to.p_path);
171 (void)close(from_fd);
172 return (1);
173 }
174
175 rval = 0;
176
177 /*
178 * There's no reason to do anything other than close the file
179 * now if it's empty, so let's not bother.
180 */
181 if (fs->st_size > 0) {
182 struct finfo fi;
183
184 fi.from = entp->fts_path;
185 fi.to = to.p_path;
186 fi.size = fs->st_size;
187
188 /*
189 * Mmap and write if less than 8M (the limit is so
190 * we don't totally trash memory on big files).
191 * This is really a minor hack, but it wins some CPU back.
192 */
193 bool use_read;
194
195 use_read = true;
196 if (fs->st_size <= MMAP_MAX_SIZE) {
197 size_t fsize = (size_t)fs->st_size;
198 p = mmap(NULL, fsize, PROT_READ, MAP_FILE|MAP_SHARED,
199 from_fd, (off_t)0);
200 if (p != MAP_FAILED) {
201 size_t remainder;
202
203 use_read = false;
204
205 (void) madvise(p, (size_t)fs->st_size,
206 MADV_SEQUENTIAL);
207
208 /*
209 * Write out the data in small chunks to
210 * avoid locking the output file for a
211 * long time if the reading the data from
212 * the source is slow.
213 */
214 remainder = fsize;
215 do {
216 ssize_t chunk;
217
218 chunk = (remainder > MMAP_MAX_WRITE) ?
219 MMAP_MAX_WRITE : remainder;
220 if (write(to_fd, &p[fsize - remainder],
221 chunk) != chunk) {
222 warn("%s", to.p_path);
223 rval = 1;
224 break;
225 }
226 remainder -= chunk;
227 ptotal += chunk;
228 if (pinfo)
229 progress(&fi, ptotal);
230 } while (remainder > 0);
231
232 if (munmap(p, fsize) < 0) {
233 warn("%s", entp->fts_path);
234 rval = 1;
235 }
236 }
237 }
238
239 if (use_read) {
240 while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
241 wcount = write(to_fd, buf, (size_t)rcount);
242 if (rcount != wcount || wcount == -1) {
243 warn("%s", to.p_path);
244 rval = 1;
245 break;
246 }
247 ptotal += wcount;
248 if (pinfo)
249 progress(&fi, ptotal);
250 }
251 if (rcount < 0) {
252 warn("%s", entp->fts_path);
253 rval = 1;
254 }
255 }
256 }
257
258 if (pflag && (fcpxattr(from_fd, to_fd) != 0))
259 warn("%s: error copying extended attributes", to.p_path);
260
261 (void)close(from_fd);
262
263 if (rval == 1) {
264 (void)close(to_fd);
265 return (1);
266 }
267
268 if (pflag && setfile(fs, to_fd))
269 rval = 1;
270 /*
271 * If the source was setuid or setgid, lose the bits unless the
272 * copy is owned by the same user and group.
273 */
274#define RETAINBITS \
275 (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
276 if (!pflag && dne
277 && fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {
278 if (fstat(to_fd, &to_stat)) {
279 warn("%s", to.p_path);
280 rval = 1;
281 } else if (fs->st_gid == to_stat.st_gid &&
282 fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {
283 warn("%s", to.p_path);
284 rval = 1;
285 }
286 }
287 if (close(to_fd)) {
288 warn("%s", to.p_path);
289 rval = 1;
290 }
291 /* set the mod/access times now after close of the fd */
292 if (pflag && set_utimes(to.p_path, fs)) {
293 rval = 1;
294 }
295 return (rval);
296}
297
298int
299copy_link(FTSENT *p, int exists)
300{
301 int len;
302 char target[MAXPATHLEN];
303
304 if ((len = readlink(p->fts_path, target, sizeof(target)-1)) == -1) {
305 warn("readlink: %s", p->fts_path);
306 return (1);
307 }
308 target[len] = '\0';
309 if (exists && unlink(to.p_path)) {
310 warn("unlink: %s", to.p_path);
311 return (1);
312 }
313 if (symlink(target, to.p_path)) {
314 warn("symlink: %s", target);
315 return (1);
316 }
317 return (pflag ? setfile(p->fts_statp, 0) : 0);
318}
319
320int
321copy_fifo(struct stat *from_stat, int exists)
322{
323 if (exists && unlink(to.p_path)) {
324 warn("unlink: %s", to.p_path);
325 return (1);
326 }
327 if (mkfifo(to.p_path, from_stat->st_mode)) {
328 warn("mkfifo: %s", to.p_path);
329 return (1);
330 }
331 return (pflag ? setfile(from_stat, 0) : 0);
332}
333
334int
335copy_special(struct stat *from_stat, int exists)
336{
337 if (exists && unlink(to.p_path)) {
338 warn("unlink: %s", to.p_path);
339 return (1);
340 }
341 if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
342 warn("mknod: %s", to.p_path);
343 return (1);
344 }
345 return (pflag ? setfile(from_stat, 0) : 0);
346}
347
348
349/*
350 * Function: setfile
351 *
352 * Purpose:
353 * Set the owner/group/permissions for the "to" file to the information
354 * in the stat structure. If fd is zero, also call set_utimes() to set
355 * the mod/access times. If fd is non-zero, the caller must do a utimes
356 * itself after close(fd).
357 */
358int
359setfile(struct stat *fs, int fd)
360{
361 int rval, islink;
362
363 rval = 0;
364 islink = S_ISLNK(fs->st_mode);
365 fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
366
367 /*
368 * Changing the ownership probably won't succeed, unless we're root
369 * or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
370 * the mode; current BSD behavior is to remove all setuid bits on
371 * chown. If chown fails, lose setuid/setgid bits.
372 */
373 if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
374 lchown(to.p_path, fs->st_uid, fs->st_gid)) {
375 if (errno != EPERM) {
376 warn("chown: %s", to.p_path);
377 rval = 1;
378 }
379 fs->st_mode &= ~(S_ISUID | S_ISGID);
380 }
381 if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {
382 warn("chmod: %s", to.p_path);
383 rval = 1;
384 }
385
386 if (!islink && !Nflag) {
387 unsigned long fflags = fs->st_flags;
388 /*
389 * XXX
390 * NFS doesn't support chflags; ignore errors unless
391 * there's reason to believe we're losing bits.
392 * (Note, this still won't be right if the server
393 * supports flags and we were trying to *remove* flags
394 * on a file that we copied, i.e., that we didn't create.)
395 */
396 errno = 0;
397 if ((fd ? fchflags(fd, fflags) :
398 chflags(to.p_path, fflags)) == -1)
399 if (errno != EOPNOTSUPP || fs->st_flags != 0) {
400 warn("chflags: %s", to.p_path);
401 rval = 1;
402 }
403 }
404 /* if fd is non-zero, caller must call set_utimes() after close() */
405 if (fd == 0 && set_utimes(to.p_path, fs))
406 rval = 1;
407 return (rval);
408}
409
410void
411usage(void)
412{
413 (void)fprintf(stderr,
414 "usage: %s [-R [-H | -L | -P]] [-f | -i] [-alNpv] src target\n"
415 " %s [-R [-H | -L | -P]] [-f | -i] [-alNpv] src1 ... srcN directory\n",
416 getprogname(), getprogname());
417 exit(1);
418 /* NOTREACHED */
419}
420