global: convert indentation-TABs to spaces
[coreutils.git] / src / mv.c
blob814e55dfefbbf7e67365877c154377f8654e98e9
1 /* mv -- move or rename files
2 Copyright (C) 86, 89, 90, 91, 1995-2009 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Mike Parker, David MacKenzie, and Jim Meyering */
19 #include <config.h>
20 #include <stdio.h>
21 #include <getopt.h>
22 #include <sys/types.h>
23 #include <assert.h>
24 #include <selinux/selinux.h>
26 #include "system.h"
27 #include "backupfile.h"
28 #include "copy.h"
29 #include "cp-hash.h"
30 #include "error.h"
31 #include "filenamecat.h"
32 #include "quote.h"
33 #include "remove.h"
34 #include "root-dev-ino.h"
35 #include "priv-set.h"
37 /* The official name of this program (e.g., no `g' prefix). */
38 #define PROGRAM_NAME "mv"
40 #define AUTHORS \
41 proper_name ("Mike Parker"), \
42 proper_name ("David MacKenzie"), \
43 proper_name ("Jim Meyering")
45 /* For long options that have no equivalent short option, use a
46 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
47 enum
49 STRIP_TRAILING_SLASHES_OPTION = CHAR_MAX + 1
52 /* Remove any trailing slashes from each SOURCE argument. */
53 static bool remove_trailing_slashes;
55 static struct option const long_options[] =
57 {"backup", optional_argument, NULL, 'b'},
58 {"force", no_argument, NULL, 'f'},
59 {"interactive", no_argument, NULL, 'i'},
60 {"no-clobber", no_argument, NULL, 'n'},
61 {"no-target-directory", no_argument, NULL, 'T'},
62 {"strip-trailing-slashes", no_argument, NULL, STRIP_TRAILING_SLASHES_OPTION},
63 {"suffix", required_argument, NULL, 'S'},
64 {"target-directory", required_argument, NULL, 't'},
65 {"update", no_argument, NULL, 'u'},
66 {"verbose", no_argument, NULL, 'v'},
67 {GETOPT_HELP_OPTION_DECL},
68 {GETOPT_VERSION_OPTION_DECL},
69 {NULL, 0, NULL, 0}
72 static void
73 rm_option_init (struct rm_options *x)
75 x->ignore_missing_files = false;
76 x->recursive = true;
77 x->one_file_system = false;
79 /* Should we prompt for removal, too? No. Prompting for the `move'
80 part is enough. It implies removal. */
81 x->interactive = RMI_NEVER;
82 x->stdin_tty = false;
84 x->verbose = false;
86 /* Since this program may well have to process additional command
87 line arguments after any call to `rm', that function must preserve
88 the initial working directory, in case one of those is a
89 `.'-relative name. */
90 x->require_restore_cwd = true;
93 static struct dev_ino dev_ino_buf;
94 x->root_dev_ino = get_root_dev_ino (&dev_ino_buf);
95 if (x->root_dev_ino == NULL)
96 error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
97 quote ("/"));
101 static void
102 cp_option_init (struct cp_options *x)
104 bool selinux_enabled = (0 < is_selinux_enabled ());
106 cp_options_default (x);
107 x->copy_as_regular = false; /* FIXME: maybe make this an option */
108 x->reflink = false;
109 x->dereference = DEREF_NEVER;
110 x->unlink_dest_before_opening = false;
111 x->unlink_dest_after_failed_open = false;
112 x->hard_link = false;
113 x->interactive = I_UNSPECIFIED;
114 x->move_mode = true;
115 x->one_file_system = false;
116 x->preserve_ownership = true;
117 x->preserve_links = true;
118 x->preserve_mode = true;
119 x->preserve_timestamps = true;
120 x->preserve_security_context = selinux_enabled;
121 x->reduce_diagnostics = false;
122 x->require_preserve = false; /* FIXME: maybe make this an option */
123 x->require_preserve_context = false;
124 x->preserve_xattr = true;
125 x->require_preserve_xattr = false;
126 x->recursive = true;
127 x->sparse_mode = SPARSE_AUTO; /* FIXME: maybe make this an option */
128 x->symbolic_link = false;
129 x->set_mode = false;
130 x->mode = 0;
131 x->stdin_tty = isatty (STDIN_FILENO);
133 x->open_dangling_dest_symlink = false;
134 x->update = false;
135 x->verbose = false;
136 x->dest_info = NULL;
137 x->src_info = NULL;
140 /* FILE is the last operand of this command. Return true if FILE is a
141 directory. But report an error if there is a problem accessing FILE, other
142 than nonexistence (errno == ENOENT). */
144 static bool
145 target_directory_operand (char const *file)
147 struct stat st;
148 int err = (stat (file, &st) == 0 ? 0 : errno);
149 bool is_a_dir = !err && S_ISDIR (st.st_mode);
150 if (err && err != ENOENT)
151 error (EXIT_FAILURE, err, _("accessing %s"), quote (file));
152 return is_a_dir;
155 /* Move SOURCE onto DEST. Handles cross-file-system moves.
156 If SOURCE is a directory, DEST must not exist.
157 Return true if successful. */
159 static bool
160 do_move (const char *source, const char *dest, const struct cp_options *x)
162 bool copy_into_self;
163 bool rename_succeeded;
164 bool ok = copy (source, dest, false, x, &copy_into_self, &rename_succeeded);
166 if (ok)
168 char const *dir_to_remove;
169 if (copy_into_self)
171 /* In general, when copy returns with copy_into_self set, SOURCE is
172 the same as, or a parent of DEST. In this case we know it's a
173 parent. It doesn't make sense to move a directory into itself, and
174 besides in some situations doing so would give highly nonintuitive
175 results. Run this `mkdir b; touch a c; mv * b' in an empty
176 directory. Here's the result of running echo `find b -print`:
177 b b/a b/b b/b/a b/c. Notice that only file `a' was copied
178 into b/b. Handle this by giving a diagnostic, removing the
179 copied-into-self directory, DEST (`b/b' in the example),
180 and failing. */
182 dir_to_remove = NULL;
183 ok = false;
185 else if (rename_succeeded)
187 /* No need to remove anything. SOURCE was successfully
188 renamed to DEST. Or the user declined to rename a file. */
189 dir_to_remove = NULL;
191 else
193 /* This may mean SOURCE and DEST referred to different devices.
194 It may also conceivably mean that even though they referred
195 to the same device, rename wasn't implemented for that device.
197 E.g., (from Joel N. Weber),
198 [...] there might someday be cases where you can't rename
199 but you can copy where the device name is the same, especially
200 on Hurd. Consider an ftpfs with a primitive ftp server that
201 supports uploading, downloading and deleting, but not renaming.
203 Also, note that comparing device numbers is not a reliable
204 check for `can-rename'. Some systems can be set up so that
205 files from many different physical devices all have the same
206 st_dev field. This is a feature of some NFS mounting
207 configurations.
209 We reach this point if SOURCE has been successfully copied
210 to DEST. Now we have to remove SOURCE.
212 This function used to resort to copying only when rename
213 failed and set errno to EXDEV. */
215 dir_to_remove = source;
218 if (dir_to_remove != NULL)
220 struct rm_options rm_options;
221 enum RM_status status;
223 rm_option_init (&rm_options);
224 rm_options.verbose = x->verbose;
226 status = rm (1, &dir_to_remove, &rm_options);
227 assert (VALID_STATUS (status));
228 if (status == RM_ERROR)
229 ok = false;
233 return ok;
236 /* Move file SOURCE onto DEST. Handles the case when DEST is a directory.
237 Treat DEST as a directory if DEST_IS_DIR.
238 Return true if successful. */
240 static bool
241 movefile (char *source, char *dest, bool dest_is_dir,
242 const struct cp_options *x)
244 bool ok;
246 /* This code was introduced to handle the ambiguity in the semantics
247 of mv that is induced by the varying semantics of the rename function.
248 Some systems (e.g., GNU/Linux) have a rename function that honors a
249 trailing slash, while others (like Solaris 5,6,7) have a rename
250 function that ignores a trailing slash. I believe the GNU/Linux
251 rename semantics are POSIX and susv2 compliant. */
253 if (remove_trailing_slashes)
254 strip_trailing_slashes (source);
256 if (dest_is_dir)
258 /* Treat DEST as a directory; build the full filename. */
259 char const *src_basename = last_component (source);
260 char *new_dest = file_name_concat (dest, src_basename, NULL);
261 strip_trailing_slashes (new_dest);
262 ok = do_move (source, new_dest, x);
263 free (new_dest);
265 else
267 ok = do_move (source, dest, x);
270 return ok;
273 void
274 usage (int status)
276 if (status != EXIT_SUCCESS)
277 fprintf (stderr, _("Try `%s --help' for more information.\n"),
278 program_name);
279 else
281 printf (_("\
282 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
283 or: %s [OPTION]... SOURCE... DIRECTORY\n\
284 or: %s [OPTION]... -t DIRECTORY SOURCE...\n\
286 program_name, program_name, program_name);
287 fputs (_("\
288 Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n\
290 "), stdout);
291 fputs (_("\
292 Mandatory arguments to long options are mandatory for short options too.\n\
293 "), stdout);
294 fputs (_("\
295 --backup[=CONTROL] make a backup of each existing destination file\n\
296 -b like --backup but does not accept an argument\n\
297 -f, --force do not prompt before overwriting\n\
298 -i, --interactive prompt before overwrite\n\
299 -n, --no-clobber do not overwrite an existing file\n\
300 If you specify more than one of -i, -f, -n, only the final one takes effect.\n\
301 "), stdout);
302 fputs (_("\
303 --strip-trailing-slashes remove any trailing slashes from each SOURCE\n\
304 argument\n\
305 -S, --suffix=SUFFIX override the usual backup suffix\n\
306 "), stdout);
307 fputs (_("\
308 -t, --target-directory=DIRECTORY move all SOURCE arguments into DIRECTORY\n\
309 -T, --no-target-directory treat DEST as a normal file\n\
310 -u, --update move only when the SOURCE file is newer\n\
311 than the destination file or when the\n\
312 destination file is missing\n\
313 -v, --verbose explain what is being done\n\
314 "), stdout);
315 fputs (HELP_OPTION_DESCRIPTION, stdout);
316 fputs (VERSION_OPTION_DESCRIPTION, stdout);
317 fputs (_("\
319 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
320 The version control method may be selected via the --backup option or through\n\
321 the VERSION_CONTROL environment variable. Here are the values:\n\
323 "), stdout);
324 fputs (_("\
325 none, off never make backups (even if --backup is given)\n\
326 numbered, t make numbered backups\n\
327 existing, nil numbered if numbered backups exist, simple otherwise\n\
328 simple, never always make simple backups\n\
329 "), stdout);
330 emit_bug_reporting_address ();
332 exit (status);
336 main (int argc, char **argv)
338 int c;
339 bool ok;
340 bool make_backups = false;
341 char *backup_suffix_string;
342 char *version_control_string = NULL;
343 struct cp_options x;
344 char *target_directory = NULL;
345 bool no_target_directory = false;
346 int n_files;
347 char **file;
349 initialize_main (&argc, &argv);
350 set_program_name (argv[0]);
351 setlocale (LC_ALL, "");
352 bindtextdomain (PACKAGE, LOCALEDIR);
353 textdomain (PACKAGE);
355 atexit (close_stdin);
357 cp_option_init (&x);
359 /* Try to disable the ability to unlink a directory. */
360 priv_set_remove_linkdir ();
362 /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
363 we'll actually use backup_suffix_string. */
364 backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
366 while ((c = getopt_long (argc, argv, "bfint:uvS:T", long_options, NULL))
367 != -1)
369 switch (c)
371 case 'b':
372 make_backups = true;
373 if (optarg)
374 version_control_string = optarg;
375 break;
376 case 'f':
377 x.interactive = I_ALWAYS_YES;
378 break;
379 case 'i':
380 x.interactive = I_ASK_USER;
381 break;
382 case 'n':
383 x.interactive = I_ALWAYS_NO;
384 break;
385 case STRIP_TRAILING_SLASHES_OPTION:
386 remove_trailing_slashes = true;
387 break;
388 case 't':
389 if (target_directory)
390 error (EXIT_FAILURE, 0, _("multiple target directories specified"));
391 else
393 struct stat st;
394 if (stat (optarg, &st) != 0)
395 error (EXIT_FAILURE, errno, _("accessing %s"), quote (optarg));
396 if (! S_ISDIR (st.st_mode))
397 error (EXIT_FAILURE, 0, _("target %s is not a directory"),
398 quote (optarg));
400 target_directory = optarg;
401 break;
402 case 'T':
403 no_target_directory = true;
404 break;
405 case 'u':
406 x.update = true;
407 break;
408 case 'v':
409 x.verbose = true;
410 break;
411 case 'S':
412 make_backups = true;
413 backup_suffix_string = optarg;
414 break;
415 case_GETOPT_HELP_CHAR;
416 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
417 default:
418 usage (EXIT_FAILURE);
422 n_files = argc - optind;
423 file = argv + optind;
425 if (n_files <= !target_directory)
427 if (n_files <= 0)
428 error (0, 0, _("missing file operand"));
429 else
430 error (0, 0, _("missing destination file operand after %s"),
431 quote (file[0]));
432 usage (EXIT_FAILURE);
435 if (no_target_directory)
437 if (target_directory)
438 error (EXIT_FAILURE, 0,
439 _("cannot combine --target-directory (-t) "
440 "and --no-target-directory (-T)"));
441 if (2 < n_files)
443 error (0, 0, _("extra operand %s"), quote (file[2]));
444 usage (EXIT_FAILURE);
447 else if (!target_directory)
449 assert (2 <= n_files);
450 if (target_directory_operand (file[n_files - 1]))
451 target_directory = file[--n_files];
452 else if (2 < n_files)
453 error (EXIT_FAILURE, 0, _("target %s is not a directory"),
454 quote (file[n_files - 1]));
457 if (make_backups && x.interactive == I_ALWAYS_NO)
459 error (0, 0,
460 _("options --backup and --no-clobber are mutually exclusive"));
461 usage (EXIT_FAILURE);
464 if (backup_suffix_string)
465 simple_backup_suffix = xstrdup (backup_suffix_string);
467 x.backup_type = (make_backups
468 ? xget_version (_("backup type"),
469 version_control_string)
470 : no_backups);
472 hash_init ();
474 if (target_directory)
476 int i;
478 /* Initialize the hash table only if we'll need it.
479 The problem it is used to detect can arise only if there are
480 two or more files to move. */
481 if (2 <= n_files)
482 dest_info_init (&x);
484 ok = true;
485 for (i = 0; i < n_files; ++i)
486 ok &= movefile (file[i], target_directory, true, &x);
488 else
489 ok = movefile (file[0], file[1], false, &x);
491 exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);