src/cp.c

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