kernel - Fix auto port assignment collision in network code
[dragonfly.git] / bin / mv / mv.c
blobdded66527d12eee43d695141829407d238de22c4
1 /*-
2 * Copyright (c) 1989, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Ken Smith of The State University of New York at Buffalo.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
33 #include <sys/param.h>
34 #include <sys/time.h>
35 #include <sys/wait.h>
36 #include <sys/stat.h>
37 #include <sys/mount.h>
39 #include <err.h>
40 #include <errno.h>
41 #include <fcntl.h>
42 #include <grp.h>
43 #include <limits.h>
44 #include <paths.h>
45 #include <pwd.h>
46 #include <signal.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <sysexits.h>
51 #include <unistd.h>
53 /* Exit code for a failed exec. */
54 #define EXEC_FAILED 127
56 #ifndef _PATH_RM
57 #define _PATH_RM "/bin/rm"
58 #endif
60 static int fflg, hflg, iflg, nflg, vflg;
61 static volatile sig_atomic_t info;
63 static int copy(const char *, const char *);
64 static int do_move(const char *, const char *);
65 static int fastcopy(const char *, const char *, struct stat *);
66 static void usage(void);
67 #ifdef SIGINFO
68 static void siginfo(int);
69 #endif
71 int
72 main(int argc, char *argv[])
74 size_t baselen, len;
75 int rval;
76 char *p, *endp;
77 struct stat sb;
78 int ch;
79 char path[PATH_MAX];
81 while ((ch = getopt(argc, argv, "fhinv")) != -1)
82 switch (ch) {
83 case 'h':
84 hflg = 1;
85 break;
86 case 'i':
87 iflg = 1;
88 fflg = nflg = 0;
89 break;
90 case 'f':
91 fflg = 1;
92 iflg = nflg = 0;
93 break;
94 case 'n':
95 nflg = 1;
96 fflg = iflg = 0;
97 break;
98 case 'v':
99 vflg = 1;
100 break;
101 default:
102 usage();
104 argc -= optind;
105 argv += optind;
107 #ifdef SIGINFO
108 signal(SIGINFO, siginfo);
109 #endif
111 if (argc < 2)
112 usage();
115 * If the stat on the target fails or the target isn't a directory,
116 * try the move. More than 2 arguments is an error in this case.
118 if (stat(argv[argc - 1], &sb) || !S_ISDIR(sb.st_mode)) {
119 if (argc > 2)
120 usage();
121 exit(do_move(argv[0], argv[1]));
125 * If -h was specified, treat the target as a symlink instead of
126 * directory.
128 if (hflg) {
129 if (argc > 2)
130 usage();
131 if (lstat(argv[1], &sb) == 0 && S_ISLNK(sb.st_mode))
132 exit(do_move(argv[0], argv[1]));
135 /* It's a directory, move each file into it. */
136 if (strlen(argv[argc - 1]) > sizeof(path) - 1)
137 errx(1, "%s: destination pathname too long", *argv);
138 strcpy(path, argv[argc - 1]);
139 baselen = strlen(path);
140 endp = &path[baselen];
141 if (!baselen || *(endp - 1) != '/') {
142 *endp++ = '/';
143 ++baselen;
145 for (rval = 0; --argc; ++argv) {
147 * Find the last component of the source pathname. It
148 * may have trailing slashes.
150 p = *argv + strlen(*argv);
151 while (p != *argv && p[-1] == '/')
152 --p;
153 while (p != *argv && p[-1] != '/')
154 --p;
156 if ((baselen + (len = strlen(p))) >= PATH_MAX) {
157 warnx("%s: destination pathname too long", *argv);
158 rval = 1;
159 } else {
160 memmove(endp, p, (size_t)len + 1);
161 if (do_move(*argv, path))
162 rval = 1;
165 exit(rval);
168 static int
169 do_move(const char *from, const char *to)
171 struct stat sb;
172 int ask, ch, first;
173 char modep[15];
176 * Check access. If interactive and file exists, ask user if it
177 * should be replaced. Otherwise if file exists but isn't writable
178 * make sure the user wants to clobber it.
180 if (!fflg && !access(to, F_OK)) {
182 /* prompt only if source exist */
183 if (lstat(from, &sb) == -1) {
184 warn("%s", from);
185 return (1);
188 #define YESNO "(y/n [n]) "
189 ask = 0;
190 if (nflg) {
191 if (vflg)
192 printf("%s not overwritten\n", to);
193 return (0);
194 } else if (iflg) {
195 fprintf(stderr, "overwrite %s? %s", to, YESNO);
196 ask = 1;
197 } else if (access(to, W_OK) && !stat(to, &sb) && isatty(STDIN_FILENO)) {
198 strmode(sb.st_mode, modep);
199 fprintf(stderr, "override %s%s%s/%s for %s? %s",
200 modep + 1, modep[9] == ' ' ? "" : " ",
201 user_from_uid((unsigned long)sb.st_uid, 0),
202 group_from_gid((unsigned long)sb.st_gid, 0), to, YESNO);
203 ask = 1;
205 if (ask) {
206 first = ch = getchar();
207 while (ch != '\n' && ch != EOF)
208 ch = getchar();
209 if (first != 'y' && first != 'Y') {
210 fprintf(stderr, "not overwritten\n");
211 return (0);
216 * Rename on FreeBSD will fail with EISDIR and ENOTDIR, before failing
217 * with EXDEV. Therefore, copy() doesn't have to perform the checks
218 * specified in the Step 3 of the POSIX mv specification.
220 if (!rename(from, to)) {
221 if (vflg)
222 printf("%s -> %s\n", from, to);
223 return (0);
226 if (errno == EXDEV) {
227 char path[PATH_MAX];
228 int target_is_file = 0;
230 if (!lstat(to, &sb) && S_ISREG(sb.st_mode))
231 target_is_file = 1;
233 * If the source is a symbolic link and is on another
234 * filesystem, it can be recreated at the destination.
236 if (lstat(from, &sb) == -1) {
237 warn("%s", from);
238 return (1);
240 /* Can't mv(1) directory into a file ever. */
241 if (target_is_file && S_ISDIR(sb.st_mode)) {
242 warn("cannot overwrite %s with directory", to);
243 return (1);
245 if (!S_ISLNK(sb.st_mode)) {
246 /* Can't mv(1) a mount point. */
247 if (realpath(from, path) == NULL) {
248 warn("cannot resolve %s: %s", from, path);
249 return (1);
251 #ifdef MNAMELEN
252 struct statfs sfs;
253 if (!statfs(path, &sfs) &&
254 !strcmp(path, sfs.f_mntonname)) {
255 warnx("cannot rename a mount point");
256 return (1);
258 #endif
260 } else {
261 warn("rename %s to %s", from, to);
262 return (1);
266 * If rename fails because we're trying to cross devices, and
267 * it's a regular file, do the copy internally; otherwise, use
268 * cp and rm.
270 if (lstat(from, &sb)) {
271 warn("%s", from);
272 return (1);
274 return (S_ISREG(sb.st_mode) ?
275 fastcopy(from, to, &sb) : copy(from, to));
278 static int
279 fastcopy(const char *from, const char *to, struct stat *sbp)
281 struct timeval tval[2];
282 static u_int blen = MAXPHYS;
283 static char *bp = NULL;
284 mode_t oldmode;
285 int from_fd, to_fd;
286 ssize_t nread;
288 if ((from_fd = open(from, O_RDONLY, 0)) < 0) {
289 warn("fastcopy: open() failed (from): %s", from);
290 return (1);
292 if (bp == NULL && (bp = malloc((size_t)blen)) == NULL) {
293 warnx("malloc(%u) failed", blen);
294 return (1);
296 while ((to_fd =
297 open(to, O_CREAT | O_EXCL | O_TRUNC | O_WRONLY, 0)) < 0) {
298 if (errno == EEXIST && unlink(to) == 0)
299 continue;
300 warn("fastcopy: open() failed (to): %s", to);
301 close(from_fd);
302 return (1);
304 while ((nread = read(from_fd, bp, (size_t)blen)) > 0)
305 if (write(to_fd, bp, (size_t)nread) != nread) {
306 warn("fastcopy: write() failed: %s", to);
307 goto err;
309 if (nread < 0) {
310 warn("fastcopy: read() failed: %s", from);
311 err: if (unlink(to))
312 warn("%s: remove", to);
313 close(from_fd);
314 close(to_fd);
315 return (1);
318 oldmode = sbp->st_mode & ALLPERMS;
319 if (fchown(to_fd, sbp->st_uid, sbp->st_gid)) {
320 warn("%s: set owner/group (was: %lu/%lu)", to,
321 (u_long)sbp->st_uid, (u_long)sbp->st_gid);
322 if (oldmode & (S_ISUID | S_ISGID)) {
323 warnx(
324 "%s: owner/group changed; clearing suid/sgid (mode was 0%03o)",
325 to, oldmode);
326 sbp->st_mode &= ~(S_ISUID | S_ISGID);
329 if (fchmod(to_fd, sbp->st_mode))
330 warn("%s: set mode (was: 0%03o)", to, oldmode);
332 close(from_fd);
334 * XXX
335 * NFS doesn't support chflags; ignore errors unless there's reason
336 * to believe we're losing bits. (Note, this still won't be right
337 * if the server supports flags and we were trying to *remove* flags
338 * on a file that we copied, i.e., that we didn't create.)
340 errno = 0;
341 #ifdef _ST_FLAGS_PRESENT_
342 if (fchflags(to_fd, sbp->st_flags))
343 if (errno != EOPNOTSUPP || sbp->st_flags != 0)
344 warn("%s: set flags (was: 0%07o)", to, sbp->st_flags);
345 #endif
347 tval[0].tv_sec = sbp->st_atime;
348 tval[1].tv_sec = sbp->st_mtime;
349 tval[0].tv_usec = tval[1].tv_usec = 0;
350 if (utimes(to, tval))
351 warn("%s: set times", to);
353 if (close(to_fd)) {
354 warn("%s", to);
355 return (1);
358 if (unlink(from)) {
359 warn("%s: remove", from);
360 return (1);
362 if (vflg)
363 printf("%s -> %s\n", from, to);
364 return (0);
367 static int
368 copy(const char *from, const char *to)
370 struct stat sb;
371 int status;
372 pid_t pid;
374 if (lstat(to, &sb) == 0) {
375 /* Destination path exists. */
376 if (S_ISDIR(sb.st_mode)) {
377 if (rmdir(to) != 0) {
378 warn("rmdir %s", to);
379 return (1);
381 } else {
382 if (unlink(to) != 0) {
383 warn("unlink %s", to);
384 return (1);
387 } else if (errno != ENOENT) {
388 warn("%s", to);
389 return (1);
392 /* Copy source to destination. */
393 if (!(pid = vfork())) {
394 execl(_PATH_CP, "mv", vflg ? "-PRpv" : "-PRp", "--", from, to,
395 NULL);
396 _exit(EXEC_FAILED);
398 if (waitpid(pid, &status, 0) == -1) {
399 warn("%s %s %s: waitpid", _PATH_CP, from, to);
400 return (1);
402 if (!WIFEXITED(status)) {
403 warnx("%s %s %s: did not terminate normally",
404 _PATH_CP, from, to);
405 return (1);
407 switch (WEXITSTATUS(status)) {
408 case 0:
409 break;
410 case EXEC_FAILED:
411 warnx("%s %s %s: exec failed", _PATH_CP, from, to);
412 return (1);
413 default:
414 warnx("%s %s %s: terminated with %d (non-zero) status",
415 _PATH_CP, from, to, WEXITSTATUS(status));
416 return (1);
419 /* Delete the source. */
420 if (!(pid = vfork())) {
421 execl(_PATH_RM, "mv", "-rf", "--", from, NULL);
422 _exit(EXEC_FAILED);
424 if (waitpid(pid, &status, 0) == -1) {
425 warn("%s %s: waitpid", _PATH_RM, from);
426 return (1);
428 if (!WIFEXITED(status)) {
429 warnx("%s %s: did not terminate normally", _PATH_RM, from);
430 return (1);
432 switch (WEXITSTATUS(status)) {
433 case 0:
434 break;
435 case EXEC_FAILED:
436 warnx("%s %s: exec failed", _PATH_RM, from);
437 return (1);
438 default:
439 warnx("%s %s: terminated with %d (non-zero) status",
440 _PATH_RM, from, WEXITSTATUS(status));
441 return (1);
443 return (0);
446 static void
447 usage(void)
450 fprintf(stderr, "%s\n%s\n",
451 "usage: mv [-f | -i | -n] [-hv] source target",
452 " mv [-f | -i | -n] [-v] source ... directory");
453 exit(EX_USAGE);
456 #ifdef SIGINFO
457 static void
458 siginfo(int notused __unused)
460 info = 1;
462 #endif