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