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