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