src/cp.c

   1 /* cp.c  -- file copying (main routines)
   2    Copyright (C) 89, 90, 91, 1995-1999 Free Software Foundation.
   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 Torbjorn Granlund, 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 <sys/types.h>
  27 #include <assert.h>
  28 #include <getopt.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 "error.h"
  36 #include "dirname.h"
  37 #include "path-concat.h"
  38
  39 /* The official name of this program (e.g., no `g' prefix).  */
  40 #define PROGRAM_NAME "cp"
  41
  42 #define AUTHORS "Torbjorn Granlund, David MacKenzie, and Jim Meyering"
  43
  44 #ifndef _POSIX_VERSION
  45 uid_t geteuid ();
  46 #endif
  47
  48 /* Used by do_copy, make_path_private, and re_protect
  49    to keep a list of leading directories whose protections
  50    need to be fixed after copying. */
  51 struct dir_attr
  52 {
  53   int is_new_dir;
  54   int slash_offset;
  55   struct dir_attr *next;
  56 };
  57
  58 /* For long options that have no equivalent short option, use a
  59    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  60 enum
  61 {
  62   TARGET_DIRECTORY_OPTION = CHAR_MAX + 1,
  63   SPARSE_OPTION
  64 };
  65
  66 int stat ();
  67 int lstat ();
  68
  69 void strip_trailing_slashes ();
  70
  71 /* Initial number of entries in each hash table entry's table of inodes.  */
  72 #define INITIAL_HASH_MODULE 100
  73
  74 /* Initial number of entries in the inode hash table.  */
  75 #define INITIAL_ENTRY_TAB_SIZE 70
  76
  77 /* The invocation name of this program.  */
  78 char *program_name;
  79
  80 /* If nonzero, the command "cp x/e_file e_dir" uses "e_dir/x/e_file"
  81    as its destination instead of the usual "e_dir/e_file." */
  82 static int flag_path = 0;
  83
  84 static char const *const sparse_type_string[] =
  85 {
  86   "never", "auto", "always", 0
  87 };
  88
  89 static enum Sparse_type const sparse_type[] =
  90 {
  91   SPARSE_NEVER, SPARSE_AUTO, SPARSE_ALWAYS
  92 };
  93
  94 /* The error code to return to the system. */
  95 static int exit_status = 0;
  96
  97 static struct option const long_opts[] =
  98 {
  99   {"archive", no_argument, NULL, 'a'},
 100   {"backup", optional_argument, NULL, 'b'},
 101   {"force", no_argument, NULL, 'f'},
 102   {"sparse", required_argument, NULL, SPARSE_OPTION},
 103   {"interactive", no_argument, NULL, 'i'},
 104   {"link", no_argument, NULL, 'l'},
 105   {"no-dereference", no_argument, NULL, 'd'},
 106   {"one-file-system", no_argument, NULL, 'x'},
 107   {"parents", no_argument, NULL, 'P'},
 108   {"path", no_argument, NULL, 'P'},
 109   {"preserve", no_argument, NULL, 'p'},
 110   {"recursive", no_argument, NULL, 'R'},
 111   {"suffix", required_argument, NULL, 'S'},
 112   {"symbolic-link", no_argument, NULL, 's'},
 113   {"target-directory", required_argument, NULL, TARGET_DIRECTORY_OPTION},
 114   {"update", no_argument, NULL, 'u'},
 115   {"verbose", no_argument, NULL, 'v'},
 116   {"version-control", required_argument, NULL, 'V'}, /* Deprecated. FIXME. */
 117   {GETOPT_HELP_OPTION_DECL},
 118   {GETOPT_VERSION_OPTION_DECL},
 119   {NULL, 0, NULL, 0}
 120 };
 121
 122 void
 123 usage (int status)
 124 {
 125   if (status != 0)
 126     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 127              program_name);
 128   else
 129     {
 130       printf (_("\
 131 Usage: %s [OPTION]... SOURCE DEST\n\
 132   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 133   or:  %s [OPTION]... --target-directory=DIRECTORY SOURCE...\n\
 134 "),
 135               program_name, program_name, program_name);
 136       printf (_("\
 137 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n\
 138 \n\
 139   -a, --archive                same as -dpR\n\
 140   -b, --backup[=CONTROL]       make a backup of each existing destination file\n\
 141   -d, --no-dereference         preserve links\n\
 142   -f, --force                  remove existing destinations, never prompt\n\
 143   -i, --interactive            prompt before overwrite\n\
 144   -l, --link                   link files instead of copying\n\
 145   -p, --preserve               preserve file attributes if possible\n\
 146   -P, --parents                append source path to DIRECTORY\n\
 147   -r                           copy recursively, non-directories as files\n\
 148                                  WARNING: use -R instead when you might copy\n\
 149                                  special files like FIFOs or /dev/zero\n\
 150       --sparse=WHEN            control creation of sparse files\n\
 151   -R, --recursive              copy directories recursively\n\
 152   -s, --symbolic-link          make symbolic links instead of copying\n\
 153   -S, --suffix=SUFFIX          override the usual backup suffix\n\
 154       --target-directory=DIRECTORY  move all SOURCE arguments into DIRECTORY\n\
 155   -u, --update                 copy only when the SOURCE file is newer\n\
 156                                  than the destination file or when the\n\
 157                                  destination file is missing\n\
 158   -v, --verbose                explain what is being done\n\
 159   -x, --one-file-system        stay on this file system\n\
 160       --help                   display this help and exit\n\
 161       --version                output version information and exit\n\
 162 \n\
 163 By default, sparse SOURCE files are detected by a crude heuristic and the\n\
 164 corresponding DEST file is made sparse as well.  That is the behavior\n\
 165 selected by --sparse=auto.  Specify --sparse=always to create a sparse DEST\n\
 166 file whenever the SOURCE file contains a long enough sequence of zero bytes.\n\
 167 Use --sparse=never to inhibit creation of sparse files.\n\
 168 \n\
 169 "));
 170       printf (_("\
 171 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 172 The version control method may be selected via the --backup option or through\n\
 173 the VERSION_CONTROL environment variable.  Here are the values:\n\
 174 \n\
 175   none, off       never make backups (even if --backup is given)\n\
 176   numbered, t     make numbered backups\n\
 177   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 178   simple, never   always make simple backups\n\
 179 "));
 180       printf (_("\
 181 \n\
 182 As a special case, cp makes a backup of SOURCE when the force and backup\n\
 183 options are given and SOURCE and DEST are the same name for an existing,\n\
 184 regular file.\n\
 185 "));
 186       puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
 187       close_stdout ();
 188     }
 189   exit (status);
 190 }
 191
 192 /* Ensure that the parent directories of CONST_DST_PATH have the
 193    correct protections, for the --parents option.  This is done
 194    after all copying has been completed, to allow permissions
 195    that don't include user write/execute.
 196
 197    SRC_OFFSET is the index in CONST_DST_PATH of the beginning of the
 198    source directory name.
 199
 200    ATTR_LIST is a null-terminated linked list of structures that
 201    indicates the end of the filename of each intermediate directory
 202    in CONST_DST_PATH that may need to have its attributes changed.
 203    The command `cp --parents --preserve a/b/c d/e_dir' changes the
 204    attributes of the directories d/e_dir/a and d/e_dir/a/b to match
 205    the corresponding source directories regardless of whether they
 206    existed before the `cp' command was given.
 207
 208    Return 0 if the parent of CONST_DST_PATH and any intermediate
 209    directories specified by ATTR_LIST have the proper permissions
 210    when done, otherwise 1. */
 211
 212 static int
 213 re_protect (const char *const_dst_path, int src_offset,
 214             struct dir_attr *attr_list, const struct cp_options *x)
 215 {
 216   struct dir_attr *p;
 217   char *dst_path;               /* A copy of CONST_DST_PATH we can change. */
 218   char *src_path;               /* The source name in `dst_path'. */
 219   uid_t myeuid = geteuid ();
 220
 221   dst_path = (char *) alloca (strlen (const_dst_path) + 1);
 222   strcpy (dst_path, const_dst_path);
 223   src_path = dst_path + src_offset;
 224
 225   for (p = attr_list; p; p = p->next)
 226     {
 227       struct stat src_sb;
 228
 229       dst_path[p->slash_offset] = '\0';
 230
 231       if ((*(x->xstat)) (src_path, &src_sb))
 232         {
 233           error (0, errno, "%s", src_path);
 234           return 1;
 235         }
 236
 237       /* Adjust the times (and if possible, ownership) for the copy.
 238          chown turns off set[ug]id bits for non-root,
 239          so do the chmod last.  */
 240
 241       if (x->preserve_timestamps)
 242         {
 243           struct utimbuf utb;
 244
 245           /* There's currently no interface to set file timestamps with
 246              better than 1-second resolution, so discard any fractional
 247              part of the source timestamp.  */
 248
 249           utb.actime = src_sb.st_atime;
 250           utb.modtime = src_sb.st_mtime;
 251
 252           if (utime (dst_path, &utb))
 253             {
 254               error (0, errno, _("preserving times for %s"), dst_path);
 255               return 1;
 256             }
 257         }
 258
 259       if (x->preserve_owner_and_group)
 260         {
 261           /* If non-root uses -p, it's ok if we can't preserve ownership.
 262              But root probably wants to know, e.g. if NFS disallows it,
 263              or if the target system doesn't support file ownership.  */
 264           if (chown (dst_path, src_sb.st_uid, src_sb.st_gid)
 265               && ((errno != EPERM && errno != EINVAL) || myeuid == 0))
 266             {
 267               error (0, errno, _("preserving ownership for %s"), dst_path);
 268               return 1;
 269             }
 270         }
 271
 272       if (x->preserve_chmod_bits || p->is_new_dir)
 273         {
 274           if (chmod (dst_path, src_sb.st_mode & x->umask_kill))
 275             {
 276               error (0, errno, _("preserving permissions for %s"), dst_path);
 277               return 1;
 278             }
 279         }
 280
 281       dst_path[p->slash_offset] = '/';
 282     }
 283   return 0;
 284 }
 285
 286 /* Ensure that the parent directory of CONST_DIRPATH exists, for
 287    the --parents option.
 288
 289    SRC_OFFSET is the index in CONST_DIRPATH (which is a destination
 290    path) of the beginning of the source directory name.
 291    Create any leading directories that don't already exist,
 292    giving them permissions MODE.
 293    If VERBOSE_FMT_STRING is nonzero, use it as a printf format
 294    string for printing a message after successfully making a directory.
 295    The format should take two string arguments: the names of the
 296    source and destination directories.
 297    Creates a linked list of attributes of intermediate directories,
 298    *ATTR_LIST, for re_protect to use after calling copy.
 299    Sets *NEW_DST to 1 if this function creates parent of CONST_DIRPATH.
 300
 301    Return 0 if parent of CONST_DIRPATH exists as a directory with the proper
 302    permissions when done, otherwise 1. */
 303
 304 static int
 305 make_path_private (const char *const_dirpath, int src_offset, int mode,
 306                    const char *verbose_fmt_string, struct dir_attr **attr_list,
 307                    int *new_dst, int (*xstat)())
 308 {
 309   struct stat stats;
 310   char *dirpath;                /* A copy of CONST_DIRPATH we can change. */
 311   char *src;                    /* Source name in `dirpath'. */
 312   char *tmp_dst_dirname;        /* Leading path of `dirpath', malloc. */
 313   char *dst_dirname;            /* Leading path of `dirpath', alloca. */
 314
 315   dirpath = (char *) alloca (strlen (const_dirpath) + 1);
 316   strcpy (dirpath, const_dirpath);
 317
 318   src = dirpath + src_offset;
 319
 320   tmp_dst_dirname = dir_name (dirpath);
 321   dst_dirname = (char *) alloca (strlen (tmp_dst_dirname) + 1);
 322   strcpy (dst_dirname, tmp_dst_dirname);
 323   free (tmp_dst_dirname);
 324
 325   *attr_list = NULL;
 326
 327   if ((*xstat) (dst_dirname, &stats))
 328     {
 329       /* Parent of CONST_DIRNAME does not exist.
 330          Make all missing intermediate directories. */
 331       char *slash;
 332
 333       slash = src;
 334       while (*slash == '/')
 335         slash++;
 336       while ((slash = strchr (slash, '/')))
 337         {
 338           /* Add this directory to the list of directories whose modes need
 339              fixing later. */
 340           struct dir_attr *new =
 341             (struct dir_attr *) xmalloc (sizeof (struct dir_attr));
 342           new->slash_offset = slash - dirpath;
 343           new->next = *attr_list;
 344           *attr_list = new;
 345
 346           *slash = '\0';
 347           if ((*xstat) (dirpath, &stats))
 348             {
 349               /* This element of the path does not exist.  We must set
 350                  *new_dst and new->is_new_dir inside this loop because,
 351                  for example, in the command `cp --parents ../a/../b/c e_dir',
 352                  make_path_private creates only e_dir/../a if ./b already
 353                  exists. */
 354               *new_dst = 1;
 355               new->is_new_dir = 1;
 356               if (mkdir (dirpath, mode))
 357                 {
 358                   error (0, errno, _("cannot make directory `%s'"), dirpath);
 359                   return 1;
 360                 }
 361               else
 362                 {
 363                   if (verbose_fmt_string != NULL)
 364                     printf (verbose_fmt_string, src, dirpath);
 365                 }
 366             }
 367           else if (!S_ISDIR (stats.st_mode))
 368             {
 369               error (0, 0, _("`%s' exists but is not a directory"), dirpath);
 370               return 1;
 371             }
 372           else
 373             {
 374               new->is_new_dir = 0;
 375               *new_dst = 0;
 376             }
 377           *slash++ = '/';
 378
 379           /* Avoid unnecessary calls to `stat' when given
 380              pathnames containing multiple adjacent slashes.  */
 381           while (*slash == '/')
 382             slash++;
 383         }
 384     }
 385
 386   /* We get here if the parent of `dirpath' already exists. */
 387
 388   else if (!S_ISDIR (stats.st_mode))
 389     {
 390       error (0, 0, _("`%s' exists but is not a directory"), dst_dirname);
 391       return 1;
 392     }
 393   else
 394     {
 395       *new_dst = 0;
 396     }
 397   return 0;
 398 }
 399
 400 /* Scan the arguments, and copy each by calling copy.
 401    Return 0 if successful, 1 if any errors occur. */
 402
 403 static int
 404 do_copy (int n_files, char **file, const char *target_directory,
 405          const struct cp_options *x)
 406 {
 407   const char *dest;
 408   struct stat sb;
 409   int new_dst = 0;
 410   int ret = 0;
 411   int dest_is_dir = 0;
 412
 413   if (n_files <= 0)
 414     {
 415       error (0, 0, _("missing file arguments"));
 416       usage (1);
 417     }
 418   if (n_files == 1 && !target_directory)
 419     {
 420       error (0, 0, _("missing destination file"));
 421       usage (1);
 422     }
 423
 424   if (target_directory)
 425     dest = target_directory;
 426   else
 427     {
 428       dest = file[n_files - 1];
 429       --n_files;
 430     }
 431
 432   if (lstat (dest, &sb))
 433     {
 434       if (errno != ENOENT)
 435         {
 436           error (0, errno, "%s", dest);
 437           return 1;
 438         }
 439
 440       new_dst = 1;
 441     }
 442   else
 443     {
 444       struct stat sbx;
 445
 446       /* If `dest' is not a symlink to a nonexistent file, use
 447          the results of stat instead of lstat, so we can copy files
 448          into symlinks to directories. */
 449       if (stat (dest, &sbx) == 0)
 450         sb = sbx;
 451
 452       dest_is_dir = S_ISDIR (sb.st_mode);
 453     }
 454
 455   if (!dest_is_dir)
 456     {
 457       if (target_directory)
 458         {
 459           error (0, 0, _("specified target, `%s' is not a directory"), dest);
 460           usage (1);
 461         }
 462
 463       if (n_files > 1)
 464         {
 465           error (0, 0,
 466          _("copying multiple files, but last argument (%s) is not a directory"),
 467              dest);
 468           usage (1);
 469         }
 470     }
 471
 472   if (dest_is_dir)
 473     {
 474       /* cp file1...filen edir
 475          Copy the files `file1' through `filen'
 476          to the existing directory `edir'. */
 477       int i;
 478
 479       for (i = 0; i < n_files; i++)
 480         {
 481           char *ap;
 482           char *dst_path;
 483           int parent_exists = 1; /* True if dir_name (dst_path) exists. */
 484           struct dir_attr *attr_list;
 485           char *arg_in_concat = NULL;
 486           char *arg = file[i];
 487
 488           strip_trailing_slashes (arg);
 489
 490           if (flag_path)
 491             {
 492               /* Append all of `arg' to `dest'.  */
 493               dst_path = path_concat (dest, arg, &arg_in_concat);
 494               if (dst_path == NULL)
 495                 error (1, 0, _("virtual memory exhausted"));
 496
 497               /* For --parents, we have to make sure that the directory
 498                  dir_name (dst_path) exists.  We may have to create a few
 499                  leading directories. */
 500               parent_exists = !make_path_private (dst_path,
 501                                                   arg_in_concat - dst_path,
 502                                                   S_IRWXU,
 503                                                   (x->verbose
 504                                                    ? "%s -> %s\n" : NULL),
 505                                                   &attr_list, &new_dst,
 506                                                   x->xstat);
 507             }
 508           else
 509             {
 510               /* Append the last component of `arg' to `dest'.  */
 511
 512               ap = base_name (arg);
 513               /* For `cp -R source/.. dest', don't copy into `dest/..'. */
 514               dst_path = (STREQ (ap, "..")
 515                           ? xstrdup (dest)
 516                           : path_concat (dest, ap, NULL));
 517             }
 518
 519           if (!parent_exists)
 520             {
 521               /* make_path_private failed, so don't even attempt the copy. */
 522               ret = 1;
 523             }
 524           else
 525             {
 526               int copy_into_self;
 527               ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
 528               forget_all ();
 529
 530               if (flag_path)
 531                 {
 532                   ret |= re_protect (dst_path, arg_in_concat - dst_path,
 533                                      attr_list, x);
 534                 }
 535             }
 536
 537           free (dst_path);
 538         }
 539       return ret;
 540     }
 541   else /* if (n_files == 1) */
 542     {
 543       char *new_dest;
 544       char *source;
 545       int unused;
 546       struct stat source_stats;
 547
 548       if (flag_path)
 549         {
 550           error (0, 0,
 551                _("when preserving paths, the destination must be a directory"));
 552           usage (1);
 553         }
 554
 555       source = file[0];
 556
 557       /* When the force and backup options have been specified and
 558          the source and destination are the same name for an existing
 559          regular file, convert the user's command, e.g.,
 560          `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
 561          where SUFFIX is determined by any version control options used.  */
 562
 563       if (x->force
 564           && x->backup_type != none
 565           && STREQ (source, dest)
 566           && !new_dst && S_ISREG (sb.st_mode))
 567         {
 568           static struct cp_options x_tmp;
 569
 570           new_dest = find_backup_file_name (dest, x->backup_type);
 571           /* Set x->backup_type to `none' so that the normal backup
 572              mechanism is not used when performing the actual copy.
 573              backup_type must be set to `none' only *after* the above
 574              call to find_backup_file_name -- that function uses
 575              backup_type to determine the suffix it applies.  */
 576           x_tmp = *x;
 577           x_tmp.backup_type = none;
 578           x = &x_tmp;
 579
 580           if (new_dest == NULL)
 581             error (1, 0, _("virtual memory exhausted"));
 582         }
 583
 584       /* When the destination is specified with a trailing slash and the
 585          source exists but is not a directory, convert the user's command
 586          `cp source dest/' to `cp source dest/basename(source)'.  Doing
 587          this ensures that the command `cp non-directory file/' will now
 588          fail rather than performing the copy.  COPY diagnoses the case of
 589          `cp directory non-directory'.  */
 590
 591       else if (dest[strlen (dest) - 1] == '/'
 592           && lstat (source, &source_stats) == 0
 593           && !S_ISDIR (source_stats.st_mode))
 594         {
 595           char *source_base;
 596           char *tmp_source;
 597
 598           tmp_source = (char *) alloca (strlen (source) + 1);
 599           strcpy (tmp_source, source);
 600           strip_trailing_slashes (tmp_source);
 601           source_base = base_name (tmp_source);
 602
 603           new_dest = (char *) alloca (strlen (dest)
 604                                       + strlen (source_base) + 1);
 605           stpcpy (stpcpy (new_dest, dest), source_base);
 606         }
 607       else
 608         {
 609           new_dest = (char *) dest;
 610         }
 611
 612       return copy (source, new_dest, new_dst, x, &unused, NULL);
 613     }
 614
 615   /* unreachable */
 616 }
 617
 618 static void
 619 cp_option_init (struct cp_options *x)
 620 {
 621   x->copy_as_regular = 1;
 622   x->dereference = 1;
 623   x->force = 0;
 624   x->failed_unlink_is_fatal = 1;
 625   x->hard_link = 0;
 626   x->interactive = 0;
 627   x->myeuid = geteuid ();
 628   x->move_mode = 0;
 629   x->one_file_system = 0;
 630
 631   x->preserve_owner_and_group = 0;
 632   x->preserve_chmod_bits = 0;
 633   x->preserve_timestamps = 0;
 634
 635   x->require_preserve = 0;
 636   x->recursive = 0;
 637   x->sparse_mode = SPARSE_AUTO;
 638   x->symbolic_link = 0;
 639   x->set_mode = 0;
 640   x->mode = 0;
 641
 642   /* Find out the current file creation mask, to knock the right bits
 643      when using chmod.  The creation mask is set to be liberal, so
 644      that created directories can be written, even if it would not
 645      have been allowed with the mask this process was started with.  */
 646   x->umask_kill = ~ umask (0);
 647
 648   x->update = 0;
 649   x->verbose = 0;
 650 }
 651
 652 int
 653 main (int argc, char **argv)
 654 {
 655   int c;
 656   int make_backups = 0;
 657   char *backup_suffix_string;
 658   char *version_control_string = NULL;
 659   struct cp_options x;
 660   char *target_directory = NULL;
 661
 662   program_name = argv[0];
 663   setlocale (LC_ALL, "");
 664   bindtextdomain (PACKAGE, LOCALEDIR);
 665   textdomain (PACKAGE);
 666
 667   cp_option_init (&x);
 668
 669   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 670      we'll actually use backup_suffix_string.  */
 671   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 672
 673   while ((c = getopt_long (argc, argv, "abdfilprsuvxPRS:V:", long_opts, NULL))
 674          != -1)
 675     {
 676       switch (c)
 677         {
 678         case 0:
 679           break;
 680
 681         case SPARSE_OPTION:
 682           x.sparse_mode = XARGMATCH ("--sparse", optarg,
 683                                      sparse_type_string, sparse_type);
 684           break;
 685
 686         case 'a':               /* Like -dpR. */
 687           x.dereference = 0;
 688           x.preserve_owner_and_group = 1;
 689           x.preserve_chmod_bits = 1;
 690           x.preserve_timestamps = 1;
 691           x.require_preserve = 1;
 692           x.recursive = 1;
 693           x.copy_as_regular = 0;
 694           break;
 695
 696         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 697           error (0, 0,
 698                  _("warning: --version-control (-V) is obsolete;  support for\
 699  it\nwill be removed in some future release.  Use --backup=%s instead."
 700                    ), optarg);
 701           /* Fall through.  */
 702
 703         case 'b':
 704           make_backups = 1;
 705           if (optarg)
 706             version_control_string = optarg;
 707           break;
 708
 709         case 'd':
 710           x.dereference = 0;
 711           break;
 712
 713         case 'f':
 714           x.force = 1;
 715           x.interactive = 0;
 716           break;
 717
 718         case 'i':
 719           x.force = 0;
 720           x.interactive = 1;
 721           break;
 722
 723         case 'l':
 724           x.hard_link = 1;
 725           break;
 726
 727         case 'p':
 728           x.preserve_owner_and_group = 1;
 729           x.preserve_chmod_bits = 1;
 730           x.preserve_timestamps = 1;
 731           x.require_preserve = 1;
 732           break;
 733
 734         case 'P':
 735           flag_path = 1;
 736           break;
 737
 738         case 'r':
 739           x.recursive = 1;
 740           x.copy_as_regular = 1;
 741           break;
 742
 743         case 'R':
 744           x.recursive = 1;
 745           x.copy_as_regular = 0;
 746           break;
 747
 748         case 's':
 749 #ifdef S_ISLNK
 750           x.symbolic_link = 1;
 751 #else
 752           error (1, 0, _("symbolic links are not supported on this system"));
 753 #endif
 754           break;
 755
 756         case TARGET_DIRECTORY_OPTION:
 757           target_directory = optarg;
 758           break;
 759
 760         case 'u':
 761           x.update = 1;
 762           break;
 763
 764         case 'v':
 765           x.verbose = 1;
 766           break;
 767
 768         case 'x':
 769           x.one_file_system = 1;
 770           break;
 771
 772         case 'S':
 773           make_backups = 1;
 774           backup_suffix_string = optarg;
 775           break;
 776
 777         case_GETOPT_HELP_CHAR;
 778
 779         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 780
 781         default:
 782           usage (1);
 783         }
 784     }
 785
 786   if (x.hard_link && x.symbolic_link)
 787     {
 788       error (0, 0, _("cannot make both hard and symbolic links"));
 789       usage (1);
 790     }
 791
 792   if (backup_suffix_string)
 793     simple_backup_suffix = xstrdup (backup_suffix_string);
 794
 795   x.backup_type = (make_backups
 796                    ? xget_version (_("--version-control"),
 797                                    version_control_string)
 798                    : none);
 799
 800   if (x.preserve_chmod_bits == 1)
 801     x.umask_kill = ~ (mode_t) 0;
 802
 803   /* The key difference between -d (--no-dereference) and not is the version
 804      of `stat' to call.  */
 805
 806   if (x.dereference)
 807     x.xstat = stat;
 808   else
 809     x.xstat = lstat;
 810
 811   /* Allocate space for remembering copied and created files.  */
 812
 813   hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE);
 814
 815   exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);
 816
 817   if (x.verbose)
 818     close_stdout ();
 819   exit (exit_status);
 820 }