src/mv.c

   1 /* mv -- move or rename files
   2    Copyright (C) 1986-2023 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 <https://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 <selinux/label.h>
  24
  25 #include "system.h"
  26 #include "argmatch.h"
  27 #include "assure.h"
  28 #include "backupfile.h"
  29 #include "copy.h"
  30 #include "cp-hash.h"
  31 #include "filenamecat.h"
  32 #include "remove.h"
  33 #include "renameatu.h"
  34 #include "root-dev-ino.h"
  35 #include "targetdir.h"
  36 #include "priv-set.h"
  37
  38 /* The official name of this program (e.g., no 'g' prefix).  */
  39 #define PROGRAM_NAME "mv"
  40
  41 #define AUTHORS \
  42   proper_name ("Mike Parker"), \
  43   proper_name ("David MacKenzie"), \
  44   proper_name ("Jim Meyering")
  45
  46 /* For long options that have no equivalent short option, use a
  47    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  48 enum
  49 {
  50   DEBUG_OPTION = CHAR_MAX + 1,
  51   NO_COPY_OPTION,
  52   STRIP_TRAILING_SLASHES_OPTION
  53 };
  54
  55 static char const *const update_type_string[] =
  56 {
  57   "all", "none", "older", nullptr
  58 };
  59 static enum Update_type const update_type[] =
  60 {
  61   UPDATE_ALL, UPDATE_NONE, UPDATE_OLDER,
  62 };
  63 ARGMATCH_VERIFY (update_type_string, update_type);
  64
  65 static struct option const long_options[] =
  66 {
  67   {"backup", optional_argument, nullptr, 'b'},
  68   {"context", no_argument, nullptr, 'Z'},
  69   {"debug", no_argument, nullptr, DEBUG_OPTION},
  70   {"force", no_argument, nullptr, 'f'},
  71   {"interactive", no_argument, nullptr, 'i'},
  72   {"no-clobber", no_argument, nullptr, 'n'},
  73   {"no-copy", no_argument, nullptr, NO_COPY_OPTION},
  74   {"no-target-directory", no_argument, nullptr, 'T'},
  75   {"strip-trailing-slashes", no_argument, nullptr,
  76    STRIP_TRAILING_SLASHES_OPTION},
  77   {"suffix", required_argument, nullptr, 'S'},
  78   {"target-directory", required_argument, nullptr, 't'},
  79   {"update", optional_argument, nullptr, 'u'},
  80   {"verbose", no_argument, nullptr, 'v'},
  81   {GETOPT_HELP_OPTION_DECL},
  82   {GETOPT_VERSION_OPTION_DECL},
  83   {nullptr, 0, nullptr, 0}
  84 };
  85
  86 static void
  87 rm_option_init (struct rm_options *x)
  88 {
  89   x->ignore_missing_files = false;
  90   x->remove_empty_directories = true;
  91   x->recursive = true;
  92   x->one_file_system = false;
  93
  94   /* Should we prompt for removal, too?  No.  Prompting for the 'move'
  95      part is enough.  It implies removal.  */
  96   x->interactive = RMI_NEVER;
  97   x->stdin_tty = false;
  98
  99   x->verbose = false;
 100
 101   /* Since this program may well have to process additional command
 102      line arguments after any call to 'rm', that function must preserve
 103      the initial working directory, in case one of those is a
 104      '.'-relative name.  */
 105   x->require_restore_cwd = true;
 106
 107   {
 108     static struct dev_ino dev_ino_buf;
 109     x->root_dev_ino = get_root_dev_ino (&dev_ino_buf);
 110     if (x->root_dev_ino == nullptr)
 111       error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 112              quoteaf ("/"));
 113   }
 114
 115   x->preserve_all_root = false;
 116 }
 117
 118 static void
 119 cp_option_init (struct cp_options *x)
 120 {
 121   bool selinux_enabled = (0 < is_selinux_enabled ());
 122
 123   cp_options_default (x);
 124   x->copy_as_regular = false;  /* FIXME: maybe make this an option */
 125   x->reflink_mode = REFLINK_AUTO;
 126   x->dereference = DEREF_NEVER;
 127   x->unlink_dest_before_opening = false;
 128   x->unlink_dest_after_failed_open = false;
 129   x->hard_link = false;
 130   x->interactive = I_UNSPECIFIED;
 131   x->move_mode = true;
 132   x->install_mode = false;
 133   x->one_file_system = false;
 134   x->preserve_ownership = true;
 135   x->preserve_links = true;
 136   x->preserve_mode = true;
 137   x->preserve_timestamps = true;
 138   x->explicit_no_preserve_mode= false;
 139   x->preserve_security_context = selinux_enabled;
 140   x->set_security_context = nullptr;
 141   x->reduce_diagnostics = false;
 142   x->data_copy_required = true;
 143   x->require_preserve = false;  /* FIXME: maybe make this an option */
 144   x->require_preserve_context = false;
 145   x->preserve_xattr = true;
 146   x->require_preserve_xattr = false;
 147   x->recursive = true;
 148   x->sparse_mode = SPARSE_AUTO;  /* FIXME: maybe make this an option */
 149   x->symbolic_link = false;
 150   x->set_mode = false;
 151   x->mode = 0;
 152   x->stdin_tty = isatty (STDIN_FILENO);
 153
 154   x->open_dangling_dest_symlink = false;
 155   x->update = false;
 156   x->verbose = false;
 157   x->dest_info = nullptr;
 158   x->src_info = nullptr;
 159 }
 160
 161 /* Move SOURCE onto DEST aka DEST_DIRFD+DEST_RELNAME.
 162    Handle cross-file-system moves.
 163    If SOURCE is a directory, DEST must not exist.
 164    Return true if successful.  */
 165
 166 static bool
 167 do_move (char const *source, char const *dest,
 168          int dest_dirfd, char const *dest_relname, const struct cp_options *x)
 169 {
 170   bool copy_into_self;
 171   bool rename_succeeded;
 172   bool ok = copy (source, dest, dest_dirfd, dest_relname, 0, x,
 173                   &copy_into_self, &rename_succeeded);
 174
 175   if (ok)
 176     {
 177       char const *dir_to_remove;
 178       if (copy_into_self)
 179         {
 180           /* In general, when copy returns with copy_into_self set, SOURCE is
 181              the same as, or a parent of DEST.  In this case we know it's a
 182              parent.  It doesn't make sense to move a directory into itself, and
 183              besides in some situations doing so would give highly nonintuitive
 184              results.  Run this 'mkdir b; touch a c; mv * b' in an empty
 185              directory.  Here's the result of running echo $(find b -print):
 186              b b/a b/b b/b/a b/c.  Notice that only file 'a' was copied
 187              into b/b.  Handle this by giving a diagnostic, removing the
 188              copied-into-self directory, DEST ('b/b' in the example),
 189              and failing.  */
 190
 191           dir_to_remove = nullptr;
 192           ok = false;
 193         }
 194       else if (rename_succeeded)
 195         {
 196           /* No need to remove anything.  SOURCE was successfully
 197              renamed to DEST.  Or the user declined to rename a file.  */
 198           dir_to_remove = nullptr;
 199         }
 200       else
 201         {
 202           /* This may mean SOURCE and DEST referred to different devices.
 203              It may also conceivably mean that even though they referred
 204              to the same device, rename wasn't implemented for that device.
 205
 206              E.g., (from Joel N. Weber),
 207              [...] there might someday be cases where you can't rename
 208              but you can copy where the device name is the same, especially
 209              on Hurd.  Consider an ftpfs with a primitive ftp server that
 210              supports uploading, downloading and deleting, but not renaming.
 211
 212              Also, note that comparing device numbers is not a reliable
 213              check for 'can-rename'.  Some systems can be set up so that
 214              files from many different physical devices all have the same
 215              st_dev field.  This is a feature of some NFS mounting
 216              configurations.
 217
 218              We reach this point if SOURCE has been successfully copied
 219              to DEST.  Now we have to remove SOURCE.
 220
 221              This function used to resort to copying only when rename
 222              failed and set errno to EXDEV.  */
 223
 224           dir_to_remove = source;
 225         }
 226
 227       if (dir_to_remove != nullptr)
 228         {
 229           struct rm_options rm_options;
 230           enum RM_status status;
 231           char const *dir[2];
 232
 233           rm_option_init (&rm_options);
 234           rm_options.verbose = x->verbose;
 235           dir[0] = dir_to_remove;
 236           dir[1] = nullptr;
 237
 238           status = rm ((void *) dir, &rm_options);
 239           affirm (VALID_STATUS (status));
 240           if (status == RM_ERROR)
 241             ok = false;
 242         }
 243     }
 244
 245   return ok;
 246 }
 247
 248 void
 249 usage (int status)
 250 {
 251   if (status != EXIT_SUCCESS)
 252     emit_try_help ();
 253   else
 254     {
 255       printf (_("\
 256 Usage: %s [OPTION]... [-T] SOURCE DEST\n\
 257   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 258   or:  %s [OPTION]... -t DIRECTORY SOURCE...\n\
 259 "),
 260               program_name, program_name, program_name);
 261       fputs (_("\
 262 Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n\
 263 "), stdout);
 264
 265       emit_mandatory_arg_note ();
 266
 267       fputs (_("\
 268       --backup[=CONTROL]       make a backup of each existing destination file\
 269 \n\
 270   -b                           like --backup but does not accept an argument\n\
 271 "), stdout);
 272       fputs (_("\
 273       --debug                  explain how a file is copied.  Implies -v\n\
 274 "), stdout);
 275       fputs (_("\
 276   -f, --force                  do not prompt before overwriting\n\
 277   -i, --interactive            prompt before overwrite\n\
 278   -n, --no-clobber             do not overwrite an existing file\n\
 279 If you specify more than one of -i, -f, -n, only the final one takes effect.\n\
 280 "), stdout);
 281       fputs (_("\
 282       --no-copy                do not copy if renaming fails\n\
 283       --strip-trailing-slashes  remove any trailing slashes from each SOURCE\n\
 284                                  argument\n\
 285   -S, --suffix=SUFFIX          override the usual backup suffix\n\
 286 "), stdout);
 287       fputs (_("\
 288   -t, --target-directory=DIRECTORY  move all SOURCE arguments into DIRECTORY\n\
 289   -T, --no-target-directory    treat DEST as a normal file\n\
 290 "), stdout);
 291       fputs (_("\
 292   --update[=UPDATE]            control which existing files are updated;\n\
 293                                  UPDATE={all,none,older(default)}.  See below\n\
 294   -u                           equivalent to --update[=older]\n\
 295 "), stdout);
 296       fputs (_("\
 297   -v, --verbose                explain what is being done\n\
 298   -Z, --context                set SELinux security context of destination\n\
 299                                  file to default type\n\
 300 "), stdout);
 301       fputs (HELP_OPTION_DESCRIPTION, stdout);
 302       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 303       emit_update_parameters_note ();
 304       emit_backup_suffix_note ();
 305       emit_ancillary_info (PROGRAM_NAME);
 306     }
 307   exit (status);
 308 }
 309
 310 int
 311 main (int argc, char **argv)
 312 {
 313   int c;
 314   bool ok;
 315   bool make_backups = false;
 316   char const *backup_suffix = nullptr;
 317   char *version_control_string = nullptr;
 318   struct cp_options x;
 319   bool remove_trailing_slashes = false;
 320   char const *target_directory = nullptr;
 321   bool no_target_directory = false;
 322   int n_files;
 323   char **file;
 324   bool selinux_enabled = (0 < is_selinux_enabled ());
 325
 326   initialize_main (&argc, &argv);
 327   set_program_name (argv[0]);
 328   setlocale (LC_ALL, "");
 329   bindtextdomain (PACKAGE, LOCALEDIR);
 330   textdomain (PACKAGE);
 331
 332   atexit (close_stdin);
 333
 334   cp_option_init (&x);
 335
 336   /* Try to disable the ability to unlink a directory.  */
 337   priv_set_remove_linkdir ();
 338
 339   while ((c = getopt_long (argc, argv, "bfint:uvS:TZ", long_options, nullptr))
 340          != -1)
 341     {
 342       switch (c)
 343         {
 344         case 'b':
 345           make_backups = true;
 346           if (optarg)
 347             version_control_string = optarg;
 348           break;
 349         case 'f':
 350           x.interactive = I_ALWAYS_YES;
 351           break;
 352         case 'i':
 353           x.interactive = I_ASK_USER;
 354           break;
 355         case 'n':
 356           x.interactive = I_ALWAYS_NO;
 357           break;
 358         case DEBUG_OPTION:
 359           x.debug = x.verbose = true;
 360           break;
 361         case NO_COPY_OPTION:
 362           x.no_copy = true;
 363           break;
 364         case STRIP_TRAILING_SLASHES_OPTION:
 365           remove_trailing_slashes = true;
 366           break;
 367         case 't':
 368           if (target_directory)
 369             error (EXIT_FAILURE, 0, _("multiple target directories specified"));
 370           target_directory = optarg;
 371           break;
 372         case 'T':
 373           no_target_directory = true;
 374           break;
 375         case 'u':
 376           if (optarg == nullptr)
 377             x.update = true;
 378           else if (x.interactive != I_ALWAYS_NO)  /* -n takes precedence.  */
 379             {
 380               enum Update_type update_opt;
 381               update_opt = XARGMATCH ("--update", optarg,
 382                                       update_type_string, update_type);
 383               if (update_opt == UPDATE_ALL)
 384                 {
 385                   /* Default mv operation.  */
 386                   x.update = false;
 387                   x.interactive = I_UNSPECIFIED;
 388                 }
 389               else if (update_opt == UPDATE_NONE)
 390                 {
 391                   x.update = false;
 392                   x.interactive = I_ALWAYS_SKIP;
 393                 }
 394               else if (update_opt == UPDATE_OLDER)
 395                 {
 396                   x.update = true;
 397                   x.interactive = I_UNSPECIFIED;
 398                 }
 399             }
 400           break;
 401         case 'v':
 402           x.verbose = true;
 403           break;
 404         case 'S':
 405           make_backups = true;
 406           backup_suffix = optarg;
 407           break;
 408         case 'Z':
 409           /* As a performance enhancement, don't even bother trying
 410              to "restorecon" when not on an selinux-enabled kernel.  */
 411           if (selinux_enabled)
 412             {
 413               x.preserve_security_context = false;
 414               x.set_security_context = selabel_open (SELABEL_CTX_FILE,
 415                                                      nullptr, 0);
 416               if (! x.set_security_context)
 417                 error (0, errno, _("warning: ignoring --context"));
 418             }
 419           break;
 420         case_GETOPT_HELP_CHAR;
 421         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 422         default:
 423           usage (EXIT_FAILURE);
 424         }
 425     }
 426
 427   n_files = argc - optind;
 428   file = argv + optind;
 429
 430   if (n_files <= !target_directory)
 431     {
 432       if (n_files <= 0)
 433         error (0, 0, _("missing file operand"));
 434       else
 435         error (0, 0, _("missing destination file operand after %s"),
 436                quoteaf (file[0]));
 437       usage (EXIT_FAILURE);
 438     }
 439
 440   struct stat sb;
 441   sb.st_mode = 0;
 442   int target_dirfd = AT_FDCWD;
 443   if (no_target_directory)
 444     {
 445       if (target_directory)
 446         error (EXIT_FAILURE, 0,
 447                _("cannot combine --target-directory (-t) "
 448                  "and --no-target-directory (-T)"));
 449       if (2 < n_files)
 450         {
 451           error (0, 0, _("extra operand %s"), quoteaf (file[2]));
 452           usage (EXIT_FAILURE);
 453         }
 454     }
 455   else if (target_directory)
 456     {
 457       target_dirfd = target_directory_operand (target_directory, &sb);
 458       if (! target_dirfd_valid (target_dirfd))
 459         error (EXIT_FAILURE, errno, _("target directory %s"),
 460                quoteaf (target_directory));
 461     }
 462   else
 463     {
 464       char const *lastfile = file[n_files - 1];
 465       if (n_files == 2)
 466         x.rename_errno = (renameatu (AT_FDCWD, file[0], AT_FDCWD, lastfile,
 467                                      RENAME_NOREPLACE)
 468                           ? errno : 0);
 469       if (x.rename_errno != 0)
 470         {
 471           int fd = target_directory_operand (lastfile, &sb);
 472           if (target_dirfd_valid (fd))
 473             {
 474               x.rename_errno = -1;
 475               target_dirfd = fd;
 476               target_directory = lastfile;
 477               n_files--;
 478             }
 479           else
 480             {
 481               /* The last operand LASTFILE cannot be opened as a directory.
 482                  If there are more than two operands, report an error.
 483
 484                  Also, report an error if LASTFILE is known to be a directory
 485                  even though it could not be opened, which can happen if
 486                  opening failed with EACCES on a platform lacking O_PATH.
 487                  In this case use stat to test whether LASTFILE is a
 488                  directory, in case opening a non-directory with (O_SEARCH
 489                  | O_DIRECTORY) failed with EACCES not ENOTDIR.  */
 490               int err = errno;
 491               if (2 < n_files
 492                   || (O_PATHSEARCH == O_SEARCH && err == EACCES
 493                       && (sb.st_mode != 0 || stat (lastfile, &sb) == 0)
 494                       && S_ISDIR (sb.st_mode)))
 495                 error (EXIT_FAILURE, err, _("target %s"), quoteaf (lastfile));
 496             }
 497         }
 498     }
 499
 500   /* Handle the ambiguity in the semantics of mv induced by the
 501      varying semantics of the rename function.  POSIX-compatible
 502      systems (e.g., GNU/Linux) have a rename function that honors a
 503      trailing slash in the source, while others (Solaris 9, FreeBSD
 504      7.2) have a rename function that ignores it.  */
 505   if (remove_trailing_slashes)
 506     for (int i = 0; i < n_files; i++)
 507       strip_trailing_slashes (file[i]);
 508
 509   if (x.interactive == I_ALWAYS_NO)
 510     x.update = false;
 511
 512   if (make_backups && x.interactive == I_ALWAYS_NO)
 513     {
 514       error (0, 0,
 515              _("options --backup and --no-clobber are mutually exclusive"));
 516       usage (EXIT_FAILURE);
 517     }
 518
 519   x.backup_type = (make_backups
 520                    ? xget_version (_("backup type"),
 521                                    version_control_string)
 522                    : no_backups);
 523   set_simple_backup_suffix (backup_suffix);
 524
 525   hash_init ();
 526
 527   if (target_directory)
 528     {
 529       /* Initialize the hash table only if we'll need it.
 530          The problem it is used to detect can arise only if there are
 531          two or more files to move.  */
 532       if (2 <= n_files)
 533         dest_info_init (&x);
 534
 535       ok = true;
 536       for (int i = 0; i < n_files; ++i)
 537         {
 538           x.last_file = i + 1 == n_files;
 539           char const *source = file[i];
 540           char const *source_basename = last_component (source);
 541           char *dest_relname;
 542           char *dest = file_name_concat (target_directory, source_basename,
 543                                          &dest_relname);
 544           strip_trailing_slashes (dest_relname);
 545           ok &= do_move (source, dest, target_dirfd, dest_relname, &x);
 546           free (dest);
 547         }
 548     }
 549   else
 550     {
 551       x.last_file = true;
 552       ok = do_move (file[0], file[1], AT_FDCWD, file[1], &x);
 553     }
 554
 555   main_exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 556 }