src/mv.c

   1 /* mv -- move or rename files
   2    Copyright (C) 86, 89, 90, 91, 1995-2001 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Written by Mike Parker, David MacKenzie, and Jim Meyering */
  19
  20 #ifdef _AIX
  21  #pragma alloca
  22 #endif
  23
  24 #include <config.h>
  25 #include <stdio.h>
  26 #include <getopt.h>
  27 #include <sys/types.h>
  28 #include <assert.h>
  29
  30 #include "system.h"
  31 #include "argmatch.h"
  32 #include "backupfile.h"
  33 #include "copy.h"
  34 #include "cp-hash.h"
  35 #include "dirname.h"
  36 #include "error.h"
  37 #include "path-concat.h"
  38 #include "quote.h"
  39 #include "remove.h"
  40
  41 /* The official name of this program (e.g., no `g' prefix).  */
  42 #define PROGRAM_NAME "mv"
  43
  44 #define AUTHORS N_ ("Mike Parker, David MacKenzie, and Jim Meyering")
  45
  46 /* Initial number of entries in each hash table entry's table of inodes.  */
  47 #define INITIAL_HASH_MODULE 100
  48
  49 /* Initial number of entries in the inode hash table.  */
  50 #define INITIAL_ENTRY_TAB_SIZE 70
  51
  52 /* For long options that have no equivalent short option, use a
  53    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  54 enum
  55 {
  56   TARGET_DIRECTORY_OPTION = CHAR_MAX + 1,
  57   STRIP_TRAILING_SLASHES_OPTION,
  58   REPLY_OPTION
  59 };
  60
  61 int euidaccess ();
  62 int isdir ();
  63 int lstat ();
  64 int yesno ();
  65
  66 /* The name this program was run with. */
  67 char *program_name;
  68
  69 /* Remove any trailing slashes from each SOURCE argument.  */
  70 static int remove_trailing_slashes;
  71
  72 /* Valid arguments to the `--reply' option. */
  73 static char const* const reply_args[] =
  74 {
  75   "yes", "no", "query", 0
  76 };
  77
  78 /* The values that correspond to the above strings. */
  79 static int const reply_vals[] =
  80 {
  81   I_ALWAYS_YES, I_ALWAYS_NO, I_ASK_USER
  82 };
  83
  84 static struct option const long_options[] =
  85 {
  86   {"backup", optional_argument, NULL, 'b'},
  87   {"force", no_argument, NULL, 'f'},
  88   {"interactive", no_argument, NULL, 'i'},
  89   {"reply", required_argument, NULL, REPLY_OPTION},
  90   {"strip-trailing-slashes", no_argument, NULL, STRIP_TRAILING_SLASHES_OPTION},
  91   {"suffix", required_argument, NULL, 'S'},
  92   {"target-directory", required_argument, NULL, TARGET_DIRECTORY_OPTION},
  93   {"update", no_argument, NULL, 'u'},
  94   {"verbose", no_argument, NULL, 'v'},
  95   {"version-control", required_argument, NULL, 'V'},
  96   {GETOPT_HELP_OPTION_DECL},
  97   {GETOPT_VERSION_OPTION_DECL},
  98   {NULL, 0, NULL, 0}
  99 };
 100
 101 static void
 102 rm_option_init (struct rm_options *x)
 103 {
 104   x->unlink_dirs = 0;
 105
 106   x->ignore_missing_files = 0;
 107
 108   x->recursive = 1;
 109
 110   /* Should we prompt for removal, too?  No.  Prompting for the `move'
 111      part is enough.  It implies removal.  */
 112   x->interactive = 0;
 113   x->stdin_tty = 0;
 114
 115   x->verbose = 0;
 116 }
 117
 118 static void
 119 cp_option_init (struct cp_options *x)
 120 {
 121   x->copy_as_regular = 0;  /* FIXME: maybe make this an option */
 122   x->dereference = DEREF_NEVER;
 123   x->unlink_dest_before_opening = 0;
 124   x->unlink_dest_after_failed_open = 0;
 125   x->hard_link = 0;
 126   x->interactive = I_UNSPECIFIED;
 127   x->move_mode = 1;
 128   x->myeuid = geteuid ();
 129   x->one_file_system = 0;
 130   x->preserve_ownership = 1;
 131   x->preserve_links = 1;
 132   x->preserve_mode = 1;
 133   x->preserve_timestamps = 1;
 134   x->require_preserve = 0;  /* FIXME: maybe make this an option */
 135   x->recursive = 1;
 136   x->sparse_mode = SPARSE_AUTO;  /* FIXME: maybe make this an option */
 137   x->symbolic_link = 0;
 138   x->set_mode = 0;
 139   x->mode = 0;
 140   x->stdin_tty = isatty (STDIN_FILENO);
 141
 142   /* Find out the current file creation mask, to knock the right bits
 143      when using chmod.  The creation mask is set to be liberal, so
 144      that created directories can be written, even if it would not
 145      have been allowed with the mask this process was started with.  */
 146   x->umask_kill = ~ umask (0);
 147
 148   x->update = 0;
 149   x->verbose = 0;
 150   x->xstat = lstat;
 151   x->dest_info = NULL;
 152   x->src_info = NULL;
 153 }
 154
 155 /* If PATH is an existing directory, return nonzero, else 0.  */
 156
 157 static int
 158 is_real_dir (const char *path)
 159 {
 160   struct stat stats;
 161
 162   return lstat (path, &stats) == 0 && S_ISDIR (stats.st_mode);
 163 }
 164
 165 /* Move SOURCE onto DEST.  Handles cross-filesystem moves.
 166    If SOURCE is a directory, DEST must not exist.
 167    Return 0 if successful, non-zero if an error occurred.  */
 168
 169 static int
 170 do_move (const char *source, const char *dest, const struct cp_options *x)
 171 {
 172   static int first = 1;
 173   int copy_into_self;
 174   int rename_succeeded;
 175   int fail;
 176
 177   if (first)
 178     {
 179       first = 0;
 180
 181       /* Allocate space for remembering copied and created files.  */
 182       hash_init ();
 183     }
 184
 185   fail = copy (source, dest, 0, x, &copy_into_self, &rename_succeeded);
 186
 187   if (!fail)
 188     {
 189       const char *dir_to_remove;
 190       if (copy_into_self)
 191         {
 192           /* In general, when copy returns with copy_into_self set, SOURCE is
 193              the same as, or a parent of DEST.  In this case we know it's a
 194              parent.  It doesn't make sense to move a directory into itself, and
 195              besides in some situations doing so would give highly nonintuitive
 196              results.  Run this `mkdir b; touch a c; mv * b' in an empty
 197              directory.  Here's the result of running echo `find b -print`:
 198              b b/a b/b b/b/a b/c.  Notice that only file `a' was copied
 199              into b/b.  Handle this by giving a diagnostic, removing the
 200              copied-into-self directory, DEST (`b/b' in the example),
 201              and failing.  */
 202
 203           dir_to_remove = NULL;
 204           fail = 1;
 205         }
 206       else if (rename_succeeded)
 207         {
 208           /* No need to remove anything.  SOURCE was successfully
 209              renamed to DEST.  */
 210           dir_to_remove = NULL;
 211         }
 212       else
 213         {
 214           /* This may mean SOURCE and DEST referred to different devices.
 215              It may also conceivably mean that even though they referred
 216              to the same device, rename wasn't implemented for that device.
 217
 218              E.g., (from Joel N. Weber),
 219              [...] there might someday be cases where you can't rename
 220              but you can copy where the device name is the same, especially
 221              on Hurd.  Consider an ftpfs with a primitive ftp server that
 222              supports uploading, downloading and deleting, but not renaming.
 223
 224              Also, note that comparing device numbers is not a reliable
 225              check for `can-rename'.  Some systems can be set up so that
 226              files from many different physical devices all have the same
 227              st_dev field.  This is a feature of some NFS mounting
 228              configurations.
 229
 230              We reach this point if SOURCE has been successfully copied
 231              to DEST.  Now we have to remove SOURCE.
 232
 233              This function used to resort to copying only when rename
 234              failed and set errno to EXDEV.  */
 235
 236           dir_to_remove = source;
 237         }
 238
 239       if (dir_to_remove != NULL)
 240         {
 241           struct rm_options rm_options;
 242           struct File_spec fs;
 243           enum RM_status status;
 244
 245           rm_option_init (&rm_options);
 246           rm_options.verbose = x->verbose;
 247
 248           remove_init ();
 249
 250           fspec_init_file (&fs, dir_to_remove);
 251
 252           /* Remove any trailing slashes.  This is necessary if we
 253              took the else branch of movefile.  */
 254           strip_trailing_slashes (fs.filename);
 255
 256           status = rm (&fs, 1, &rm_options);
 257           assert (VALID_STATUS (status));
 258           if (status == RM_ERROR)
 259             fail = 1;
 260
 261           remove_fini ();
 262
 263           if (fail)
 264             error (0, errno, _("cannot remove %s"), quote (dir_to_remove));
 265         }
 266     }
 267
 268   return fail;
 269 }
 270
 271 /* Move file SOURCE onto DEST.  Handles the case when DEST is a directory.
 272    DEST_IS_DIR must be nonzero when DEST is a directory or a symlink to a
 273    directory and zero otherwise.
 274    Return 0 if successful, non-zero if an error occurred.  */
 275
 276 static int
 277 movefile (char *source, char *dest, int dest_is_dir,
 278           const struct cp_options *x)
 279 {
 280   int dest_had_trailing_slash = strip_trailing_slashes (dest);
 281   int fail;
 282
 283   /* This code was introduced to handle the ambiguity in the semantics
 284      of mv that is induced by the varying semantics of the rename function.
 285      Some systems (e.g., Linux) have a rename function that honors a
 286      trailing slash, while others (like Solaris 5,6,7) have a rename
 287      function that ignores a trailing slash.  I believe the Linux
 288      rename semantics are POSIX and susv2 compliant.  */
 289
 290   if (remove_trailing_slashes)
 291     strip_trailing_slashes (source);
 292
 293   /* In addition to when DEST is a directory, if DEST has a trailing
 294      slash and neither SOURCE nor DEST is a directory, presume the target
 295      is DEST/`basename source`.  This converts `mv x y/' to `mv x y/x'.
 296      This change means that the command `mv any file/' will now fail
 297      rather than performing the move.  The case when SOURCE is a
 298      directory and DEST is not is properly diagnosed by do_move.  */
 299
 300   if (dest_is_dir || (dest_had_trailing_slash && !is_real_dir (source)))
 301     {
 302       /* DEST is a directory; build full target filename. */
 303       char *src_basename;
 304       char *new_dest;
 305
 306       strip_trailing_slashes (source);
 307       src_basename = base_name (source);
 308       new_dest = path_concat (dest, src_basename, NULL);
 309       if (new_dest == NULL)
 310         xalloc_die ();
 311       fail = do_move (source, new_dest, x);
 312       free (new_dest);
 313     }
 314   else
 315     {
 316       fail = do_move (source, dest, x);
 317     }
 318
 319   return fail;
 320 }
 321
 322 void
 323 usage (int status)
 324 {
 325   if (status != 0)
 326     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 327              program_name);
 328   else
 329     {
 330       printf (_("\
 331 Usage: %s [OPTION]... SOURCE DEST\n\
 332   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 333   or:  %s [OPTION]... --target-directory=DIRECTORY SOURCE...\n\
 334 "),
 335               program_name, program_name, program_name);
 336       fputs (_("\
 337 Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n\
 338 \n\
 339       --backup[=CONTROL]       make a backup of each existing destination file\n\
 340   -b                           like --backup but does not accept an argument\n\
 341   -f, --force                  do not prompt before overwriting\n\
 342                                  equivalent to --reply=yes\n\
 343   -i, --interactive            prompt before overwrite\n\
 344                                  equivalent to --reply=query\n\
 345 "), stdout);
 346       fputs (_("\
 347       --reply={yes,no,query}   specify how to handle the prompt about an\n\
 348                                  existing destination file\n\
 349       --strip-trailing-slashes remove any trailing slashes from each SOURCE\n\
 350                                  argument\n\
 351   -S, --suffix=SUFFIX          override the usual backup suffix\n\
 352 "), stdout);
 353       fputs (_("\
 354       --target-directory=DIRECTORY  move all SOURCE arguments into DIRECTORY\n\
 355   -u, --update                 move only when the SOURCE file is newer\n\
 356                                  than the destination file or when the\n\
 357                                  destination file is missing\n\
 358   -v, --verbose                explain what is being done\n\
 359 "), stdout);
 360       fputs (_("\
 361       --help                   display this help and exit\n\
 362       --version                output version information and exit\n\
 363 \n\
 364 "), stdout);
 365       fputs (_("\
 366 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 367 The version control method may be selected via the --backup option or through\n\
 368 the VERSION_CONTROL environment variable.  Here are the values:\n\
 369 \n\
 370 "), stdout);
 371       fputs (_("\
 372   none, off       never make backups (even if --backup is given)\n\
 373   numbered, t     make numbered backups\n\
 374   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 375   simple, never   always make simple backups\n\
 376 "), stdout);
 377       puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
 378     }
 379   exit (status);
 380 }
 381
 382 int
 383 main (int argc, char **argv)
 384 {
 385   int c;
 386   int errors;
 387   int make_backups = 0;
 388   int dest_is_dir;
 389   char *backup_suffix_string;
 390   char *version_control_string = NULL;
 391   struct cp_options x;
 392   char *target_directory = NULL;
 393   int target_directory_specified;
 394   unsigned int n_files;
 395   char **file;
 396
 397   program_name = argv[0];
 398   setlocale (LC_ALL, "");
 399   bindtextdomain (PACKAGE, LOCALEDIR);
 400   textdomain (PACKAGE);
 401
 402   atexit (close_stdout);
 403
 404   cp_option_init (&x);
 405
 406   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 407      we'll actually use backup_suffix_string.  */
 408   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 409
 410   errors = 0;
 411
 412   while ((c = getopt_long (argc, argv, "bfiuvS:V:", long_options, NULL)) != -1)
 413     {
 414       switch (c)
 415         {
 416         case 0:
 417           break;
 418
 419         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 420           error (0, 0,
 421                  _("warning: --version-control (-V) is obsolete;  support for\
 422  it\nwill be removed in some future release.  Use --backup=%s instead."
 423                    ), optarg);
 424           /* Fall through.  */
 425
 426         case 'b':
 427           make_backups = 1;
 428           if (optarg)
 429             version_control_string = optarg;
 430           break;
 431         case 'f':
 432           x.interactive = I_ALWAYS_YES;
 433           break;
 434         case 'i':
 435           x.interactive = I_ASK_USER;
 436           break;
 437         case REPLY_OPTION:
 438           x.interactive = XARGMATCH ("--reply", optarg,
 439                                      reply_args, reply_vals);
 440           break;
 441         case STRIP_TRAILING_SLASHES_OPTION:
 442           remove_trailing_slashes = 1;
 443           break;
 444         case TARGET_DIRECTORY_OPTION:
 445           target_directory = optarg;
 446           break;
 447         case 'u':
 448           x.update = 1;
 449           break;
 450         case 'v':
 451           x.verbose = 1;
 452           break;
 453         case 'S':
 454           make_backups = 1;
 455           backup_suffix_string = optarg;
 456           break;
 457         case_GETOPT_HELP_CHAR;
 458         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 459         default:
 460           usage (1);
 461         }
 462     }
 463
 464   n_files = argc - optind;
 465   file = argv + optind;
 466
 467   target_directory_specified = (target_directory != NULL);
 468   if (target_directory == NULL && n_files != 0)
 469     target_directory = file[n_files - 1];
 470
 471   dest_is_dir = (n_files > 0 && isdir (target_directory));
 472
 473   if (n_files == 0 || (n_files == 1 && !target_directory_specified))
 474     {
 475       error (0, 0, _("missing file argument"));
 476       usage (1);
 477     }
 478
 479   if (target_directory_specified)
 480     {
 481       if (!dest_is_dir)
 482         {
 483           error (0, 0, _("specified target, %s is not a directory"),
 484                  quote (target_directory));
 485           usage (1);
 486         }
 487     }
 488   else if (n_files > 2 && !dest_is_dir)
 489     {
 490       error (0, 0,
 491             _("when moving multiple files, last argument must be a directory"));
 492       usage (1);
 493     }
 494
 495   if (backup_suffix_string)
 496     simple_backup_suffix = xstrdup (backup_suffix_string);
 497
 498   x.backup_type = (make_backups
 499                    ? xget_version (_("backup type"),
 500                                    version_control_string)
 501                    : none);
 502
 503   /* Move each arg but the last into the target_directory.  */
 504   {
 505     unsigned int last_file_idx = (target_directory_specified
 506                                   ? n_files - 1
 507                                   : n_files - 2);
 508     unsigned int i;
 509
 510     /* Initialize the hash table only if we'll need it.
 511        The problem it is used to detect can arise only if there are
 512        two or more files to move.  */
 513     if (last_file_idx)
 514       dest_info_init (&x);
 515
 516     for (i = 0; i <= last_file_idx; ++i)
 517       errors |= movefile (file[i], target_directory, dest_is_dir, &x);
 518   }
 519
 520   exit (errors);
 521 }