src/cp.c

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