src/mv.c

   1 /* mv -- move or rename files
   2    Copyright (C) 86, 89, 90, 91, 1995-2009 Free Software Foundation, Inc.
   3
   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.
   8
   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.
  13
  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/>.  */
  16
  17 /* Written by Mike Parker, David MacKenzie, and Jim Meyering */
  18
  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>
  25
  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"
  36
  37 /* The official name of this program (e.g., no `g' prefix).  */
  38 #define PROGRAM_NAME "mv"
  39
  40 #define AUTHORS \
  41   proper_name ("Mike Parker"), \
  42   proper_name ("David MacKenzie"), \
  43   proper_name ("Jim Meyering")
  44
  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
  48 {
  49   STRIP_TRAILING_SLASHES_OPTION = CHAR_MAX + 1
  50 };
  51
  52 /* Remove any trailing slashes from each SOURCE argument.  */
  53 static bool remove_trailing_slashes;
  54
  55 static struct option const long_options[] =
  56 {
  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}
  70 };
  71
  72 static void
  73 rm_option_init (struct rm_options *x)
  74 {
  75   x->ignore_missing_files = false;
  76   x->recursive = true;
  77   x->one_file_system = false;
  78
  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;
  83
  84   x->verbose = false;
  85
  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;
  91
  92   {
  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 ("/"));
  98   }
  99 }
 100
 101 static void
 102 cp_option_init (struct cp_options *x)
 103 {
 104   bool selinux_enabled = (0 < is_selinux_enabled ());
 105
 106   cp_options_default (x);
 107   x->copy_as_regular = false;  /* FIXME: maybe make this an option */
 108   x->reflink_mode = REFLINK_NEVER;
 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);
 132
 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;
 138 }
 139
 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).  */
 143
 144 static bool
 145 target_directory_operand (char const *file)
 146 {
 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;
 153 }
 154
 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.  */
 158
 159 static bool
 160 do_move (const char *source, const char *dest, const struct cp_options *x)
 161 {
 162   bool copy_into_self;
 163   bool rename_succeeded;
 164   bool ok = copy (source, dest, false, x, &copy_into_self, &rename_succeeded);
 165
 166   if (ok)
 167     {
 168       char const *dir_to_remove;
 169       if (copy_into_self)
 170         {
 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.  */
 181
 182           dir_to_remove = NULL;
 183           ok = false;
 184         }
 185       else if (rename_succeeded)
 186         {
 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;
 190         }
 191       else
 192         {
 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.
 196
 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.
 202
 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.
 208
 209              We reach this point if SOURCE has been successfully copied
 210              to DEST.  Now we have to remove SOURCE.
 211
 212              This function used to resort to copying only when rename
 213              failed and set errno to EXDEV.  */
 214
 215           dir_to_remove = source;
 216         }
 217
 218       if (dir_to_remove != NULL)
 219         {
 220           struct rm_options rm_options;
 221           enum RM_status status;
 222
 223           rm_option_init (&rm_options);
 224           rm_options.verbose = x->verbose;
 225
 226           status = rm (1, &dir_to_remove, &rm_options);
 227           assert (VALID_STATUS (status));
 228           if (status == RM_ERROR)
 229             ok = false;
 230         }
 231     }
 232
 233   return ok;
 234 }
 235
 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.  */
 239
 240 static bool
 241 movefile (char *source, char *dest, bool dest_is_dir,
 242           const struct cp_options *x)
 243 {
 244   bool ok;
 245
 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.  */
 252
 253   if (remove_trailing_slashes)
 254     strip_trailing_slashes (source);
 255
 256   if (dest_is_dir)
 257     {
 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);
 264     }
 265   else
 266     {
 267       ok = do_move (source, dest, x);
 268     }
 269
 270   return ok;
 271 }
 272
 273 void
 274 usage (int status)
 275 {
 276   if (status != EXIT_SUCCESS)
 277     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 278              program_name);
 279   else
 280     {
 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\
 285 "),
 286               program_name, program_name, program_name);
 287       fputs (_("\
 288 Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n\
 289 \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 (_("\
 318 \n\
 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\
 322 \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 ();
 331     }
 332   exit (status);
 333 }
 334
 335 int
 336 main (int argc, char **argv)
 337 {
 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;
 348
 349   initialize_main (&argc, &argv);
 350   set_program_name (argv[0]);
 351   setlocale (LC_ALL, "");
 352   bindtextdomain (PACKAGE, LOCALEDIR);
 353   textdomain (PACKAGE);
 354
 355   atexit (close_stdin);
 356
 357   cp_option_init (&x);
 358
 359   /* Try to disable the ability to unlink a directory.  */
 360   priv_set_remove_linkdir ();
 361
 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");
 365
 366   while ((c = getopt_long (argc, argv, "bfint:uvS:T", long_options, NULL))
 367          != -1)
 368     {
 369       switch (c)
 370         {
 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
 392             {
 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));
 399             }
 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);
 419         }
 420     }
 421
 422   n_files = argc - optind;
 423   file = argv + optind;
 424
 425   if (n_files <= !target_directory)
 426     {
 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);
 433     }
 434
 435   if (no_target_directory)
 436     {
 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)
 442         {
 443           error (0, 0, _("extra operand %s"), quote (file[2]));
 444           usage (EXIT_FAILURE);
 445         }
 446     }
 447   else if (!target_directory)
 448     {
 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]));
 455     }
 456
 457   if (make_backups && x.interactive == I_ALWAYS_NO)
 458     {
 459       error (0, 0,
 460              _("options --backup and --no-clobber are mutually exclusive"));
 461       usage (EXIT_FAILURE);
 462     }
 463
 464   if (backup_suffix_string)
 465     simple_backup_suffix = xstrdup (backup_suffix_string);
 466
 467   x.backup_type = (make_backups
 468                    ? xget_version (_("backup type"),
 469                                    version_control_string)
 470                    : no_backups);
 471
 472   hash_init ();
 473
 474   if (target_directory)
 475     {
 476       int i;
 477
 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);
 483
 484       ok = true;
 485       for (i = 0; i < n_files; ++i)
 486         ok &= movefile (file[i], target_directory, true, &x);
 487     }
 488   else
 489     ok = movefile (file[0], file[1], false, &x);
 490
 491   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 492 }