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 "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 void strip_trailing_slashes ();
  81
  82 /* Initial number of entries in each hash table entry's table of inodes.  */
  83 #define INITIAL_HASH_MODULE 100
  84
  85 /* Initial number of entries in the inode hash table.  */
  86 #define INITIAL_ENTRY_TAB_SIZE 70
  87
  88 /* The invocation name of this program.  */
  89 char *program_name;
  90
  91 /* If nonzero, the command "cp x/e_file e_dir" uses "e_dir/x/e_file"
  92    as its destination instead of the usual "e_dir/e_file." */
  93 static int flag_path = 0;
  94
  95 /* Remove any trailing slashes from each SOURCE argument.  */
  96 static int remove_trailing_slashes;
  97
  98 static char const *const sparse_type_string[] =
  99 {
 100   "never", "auto", "always", 0
 101 };
 102
 103 static enum Sparse_type const sparse_type[] =
 104 {
 105   SPARSE_NEVER, SPARSE_AUTO, SPARSE_ALWAYS
 106 };
 107
 108 /* The error code to return to the system. */
 109 static int exit_status = 0;
 110
 111 static struct option const long_opts[] =
 112 {
 113   {"archive", no_argument, NULL, 'a'},
 114   {"backup", optional_argument, NULL, 'b'},
 115   {"dereference", no_argument, NULL, 'L'},
 116   {"force", no_argument, NULL, 'f'},
 117   {"sparse", required_argument, NULL, SPARSE_OPTION},
 118   {"interactive", no_argument, NULL, 'i'},
 119   {"link", no_argument, NULL, 'l'},
 120   {"no-dereference", no_argument, NULL, 'd'},
 121   {"one-file-system", no_argument, NULL, 'x'},
 122   {"parents", no_argument, NULL, PARENTS_OPTION},
 123   {"path", no_argument, NULL, PARENTS_OPTION},   /* Deprecated.  */
 124   {"preserve", no_argument, NULL, 'p'},
 125   {"recursive", no_argument, NULL, 'R'},
 126   {"remove-destination", no_argument, NULL, UNLINK_DEST_BEFORE_OPENING},
 127   {"strip-trailing-slashes", no_argument, NULL, STRIP_TRAILING_SLASHES_OPTION},
 128   {"suffix", required_argument, NULL, 'S'},
 129   {"symbolic-link", no_argument, NULL, 's'},
 130   {"target-directory", required_argument, NULL, TARGET_DIRECTORY_OPTION},
 131   {"update", no_argument, NULL, 'u'},
 132   {"verbose", no_argument, NULL, 'v'},
 133   {"version-control", required_argument, NULL, 'V'}, /* Deprecated. FIXME. */
 134   {GETOPT_HELP_OPTION_DECL},
 135   {GETOPT_VERSION_OPTION_DECL},
 136   {NULL, 0, NULL, 0}
 137 };
 138
 139 void
 140 usage (int status)
 141 {
 142   if (status != 0)
 143     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 144              program_name);
 145   else
 146     {
 147       printf (_("\
 148 Usage: %s [OPTION]... SOURCE DEST\n\
 149   or:  %s [OPTION]... SOURCE... DIRECTORY\n\
 150   or:  %s [OPTION]... --target-directory=DIRECTORY SOURCE...\n\
 151 "),
 152               program_name, program_name, program_name);
 153       printf (_("\
 154 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n\
 155 \n\
 156   -a, --archive                same as -dpR\n\
 157       --backup[=CONTROL]       make a backup of each existing destination file\n\
 158   -b                           like --backup but does not accept an argument\n\
 159   -d, --no-dereference         never follow symbolic links\n\
 160   -f, --force                  if an existing destination file cannot be\n\
 161                                    opened, remove it and try again\n\
 162   -i, --interactive            prompt before overwrite\n\
 163   -H                           follow command-line symbolic links\n\
 164   -l, --link                   link files instead of copying\n\
 165   -L, --dereference            always follow symbolic links\n\
 166   -p, --preserve               preserve file attributes if possible\n\
 167       --parents                append source path to DIRECTORY\n\
 168   -P                           same as `--parents' for now; soon to change to\n\
 169                                  `--no-dereference' to conform to POSIX\n\
 170   -r                           copy recursively, non-directories as files\n\
 171                                  WARNING: use -R instead when you might copy\n\
 172                                  special files like FIFOs or /dev/zero\n\
 173       --remove-destination     remove each existing destination file before\n\
 174                                  attempting to open it (contrast with --force)\n\
 175 "));
 176       printf (_("\
 177       --sparse=WHEN            control creation of sparse files\n\
 178   -R, --recursive              copy directories recursively\n\
 179       --strip-trailing-slashes remove any trailing slashes from each SOURCE\n\
 180                                  argument\n\
 181   -s, --symbolic-link          make symbolic links instead of copying\n\
 182   -S, --suffix=SUFFIX          override the usual backup suffix\n\
 183       --target-directory=DIRECTORY  move all SOURCE arguments into DIRECTORY\n\
 184   -u, --update                 copy only when the SOURCE file is newer\n\
 185                                  than the destination file or when the\n\
 186                                  destination file is missing\n\
 187   -v, --verbose                explain what is being done\n\
 188   -x, --one-file-system        stay on this file system\n\
 189       --help                   display this help and exit\n\
 190       --version                output version information and exit\n\
 191 \n\
 192 By default, sparse SOURCE files are detected by a crude heuristic and the\n\
 193 corresponding DEST file is made sparse as well.  That is the behavior\n\
 194 selected by --sparse=auto.  Specify --sparse=always to create a sparse DEST\n\
 195 file whenever the SOURCE file contains a long enough sequence of zero bytes.\n\
 196 Use --sparse=never to inhibit creation of sparse files.\n\
 197 \n\
 198 "));
 199       printf (_("\
 200 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 201 The version control method may be selected via the --backup option or through\n\
 202 the VERSION_CONTROL environment variable.  Here are the values:\n\
 203 \n\
 204   none, off       never make backups (even if --backup is given)\n\
 205   numbered, t     make numbered backups\n\
 206   existing, nil   numbered if numbered backups exist, simple otherwise\n\
 207   simple, never   always make simple backups\n\
 208 "));
 209       printf (_("\
 210 \n\
 211 As a special case, cp makes a backup of SOURCE when the force and backup\n\
 212 options are given and SOURCE and DEST are the same name for an existing,\n\
 213 regular file.\n\
 214 "));
 215       puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
 216     }
 217   exit (status);
 218 }
 219
 220 /* Ensure that the parent directories of CONST_DST_PATH have the
 221    correct protections, for the --parents option.  This is done
 222    after all copying has been completed, to allow permissions
 223    that don't include user write/execute.
 224
 225    SRC_OFFSET is the index in CONST_DST_PATH of the beginning of the
 226    source directory name.
 227
 228    ATTR_LIST is a null-terminated linked list of structures that
 229    indicates the end of the filename of each intermediate directory
 230    in CONST_DST_PATH that may need to have its attributes changed.
 231    The command `cp --parents --preserve a/b/c d/e_dir' changes the
 232    attributes of the directories d/e_dir/a and d/e_dir/a/b to match
 233    the corresponding source directories regardless of whether they
 234    existed before the `cp' command was given.
 235
 236    Return 0 if the parent of CONST_DST_PATH and any intermediate
 237    directories specified by ATTR_LIST have the proper permissions
 238    when done, otherwise 1. */
 239
 240 static int
 241 re_protect (const char *const_dst_path, int src_offset,
 242             struct dir_attr *attr_list, const struct cp_options *x)
 243 {
 244   struct dir_attr *p;
 245   char *dst_path;               /* A copy of CONST_DST_PATH we can change. */
 246   char *src_path;               /* The source name in `dst_path'. */
 247   uid_t myeuid = geteuid ();
 248
 249   dst_path = (char *) alloca (strlen (const_dst_path) + 1);
 250   strcpy (dst_path, const_dst_path);
 251   src_path = dst_path + src_offset;
 252
 253   for (p = attr_list; p; p = p->next)
 254     {
 255       struct stat src_sb;
 256
 257       dst_path[p->slash_offset] = '\0';
 258
 259       if ((*(x->xstat)) (src_path, &src_sb))
 260         {
 261           error (0, errno, _("getting attributes of %s"),
 262                  quote (src_path));
 263           return 1;
 264         }
 265
 266       /* Adjust the times (and if possible, ownership) for the copy.
 267          chown turns off set[ug]id bits for non-root,
 268          so do the chmod last.  */
 269
 270       if (x->preserve_timestamps)
 271         {
 272           struct utimbuf utb;
 273
 274           /* There's currently no interface to set file timestamps with
 275              better than 1-second resolution, so discard any fractional
 276              part of the source timestamp.  */
 277
 278           utb.actime = src_sb.st_atime;
 279           utb.modtime = src_sb.st_mtime;
 280
 281           if (utime (dst_path, &utb))
 282             {
 283               error (0, errno, _("preserving times for %s"), quote (dst_path));
 284               return 1;
 285             }
 286         }
 287
 288       if (x->preserve_owner_and_group)
 289         {
 290           /* If non-root uses -p, it's ok if we can't preserve ownership.
 291              But root probably wants to know, e.g. if NFS disallows it,
 292              or if the target system doesn't support file ownership.  */
 293           if (chown (dst_path, src_sb.st_uid, src_sb.st_gid)
 294               && ((errno != EPERM && errno != EINVAL) || myeuid == 0))
 295             {
 296               error (0, errno, _("preserving ownership for %s"),
 297                      quote (dst_path));
 298               return 1;
 299             }
 300         }
 301
 302       if (x->preserve_chmod_bits || p->is_new_dir)
 303         {
 304           if (chmod (dst_path, src_sb.st_mode & x->umask_kill))
 305             {
 306               error (0, errno, _("preserving permissions for %s"),
 307                      quote (dst_path));
 308               return 1;
 309             }
 310         }
 311
 312       dst_path[p->slash_offset] = '/';
 313     }
 314   return 0;
 315 }
 316
 317 /* Ensure that the parent directory of CONST_DIRPATH exists, for
 318    the --parents option.
 319
 320    SRC_OFFSET is the index in CONST_DIRPATH (which is a destination
 321    path) of the beginning of the source directory name.
 322    Create any leading directories that don't already exist,
 323    giving them permissions MODE.
 324    If VERBOSE_FMT_STRING is nonzero, use it as a printf format
 325    string for printing a message after successfully making a directory.
 326    The format should take two string arguments: the names of the
 327    source and destination directories.
 328    Creates a linked list of attributes of intermediate directories,
 329    *ATTR_LIST, for re_protect to use after calling copy.
 330    Sets *NEW_DST to 1 if this function creates parent of CONST_DIRPATH.
 331
 332    Return 0 if parent of CONST_DIRPATH exists as a directory with the proper
 333    permissions when done, otherwise 1. */
 334
 335 /* FIXME: find a way to synch this function with the one in lib/makepath.c. */
 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           /* Trailing slashes are meaningful (i.e., maybe worth preserving)
 524              only in the source file names.  */
 525           if (remove_trailing_slashes)
 526             strip_trailing_slashes (arg);
 527
 528           if (flag_path)
 529             {
 530               char *arg_no_trailing_slash;
 531
 532               /* Use `arg' without trailing slashes in constructing destination
 533                  file names.  Otherwise, we can end up trying to create a
 534                  directory via `mkdir ("dst/foo/"...', which is not portable.
 535                  It fails, due to the trailing slash, on at least
 536                  NetBSD 1.[34] systems.  */
 537               ASSIGN_STRDUPA (arg_no_trailing_slash, arg);
 538               strip_trailing_slashes (arg_no_trailing_slash);
 539
 540               /* Append all of `arg' (minus any trailing slash) to `dest'.  */
 541               dst_path = path_concat (dest, arg_no_trailing_slash,
 542                                       &arg_in_concat);
 543               if (dst_path == NULL)
 544                 xalloc_die ();
 545
 546               /* For --parents, we have to make sure that the directory
 547                  dir_name (dst_path) exists.  We may have to create a few
 548                  leading directories. */
 549               parent_exists = !make_path_private (dst_path,
 550                                                   arg_in_concat - dst_path,
 551                                                   S_IRWXU,
 552                                                   (x->verbose
 553                                                    ? "%s -> %s\n" : NULL),
 554                                                   &attr_list, &new_dst,
 555                                                   x->xstat);
 556             }
 557           else
 558             {
 559               char *arg_base;
 560               /* Append the last component of `arg' to `dest'.  */
 561
 562               ASSIGN_BASENAME_STRDUPA (arg_base, arg);
 563               /* For `cp -R source/.. dest', don't copy into `dest/..'. */
 564               dst_path = (STREQ (arg_base, "..")
 565                           ? xstrdup (dest)
 566                           : path_concat (dest, arg_base, NULL));
 567             }
 568
 569           if (!parent_exists)
 570             {
 571               /* make_path_private failed, so don't even attempt the copy. */
 572               ret = 1;
 573             }
 574           else
 575             {
 576               int copy_into_self;
 577               ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
 578               forget_all ();
 579
 580               if (flag_path)
 581                 {
 582                   ret |= re_protect (dst_path, arg_in_concat - dst_path,
 583                                      attr_list, x);
 584                 }
 585             }
 586
 587           free (dst_path);
 588         }
 589       return ret;
 590     }
 591   else /* if (n_files == 1) */
 592     {
 593       char *new_dest;
 594       char *source;
 595       int unused;
 596       struct stat source_stats;
 597
 598       if (flag_path)
 599         {
 600           error (0, 0,
 601                _("when preserving paths, the destination must be a directory"));
 602           usage (1);
 603         }
 604
 605       source = file[0];
 606
 607       /* When the force and backup options have been specified and
 608          the source and destination are the same name for an existing
 609          regular file, convert the user's command, e.g.,
 610          `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
 611          where SUFFIX is determined by any version control options used.  */
 612
 613       if (x->unlink_dest_after_failed_open
 614           && x->backup_type != none
 615           && STREQ (source, dest)
 616           && !new_dst && S_ISREG (sb.st_mode))
 617         {
 618           static struct cp_options x_tmp;
 619
 620           new_dest = find_backup_file_name (dest, x->backup_type);
 621           /* Set x->backup_type to `none' so that the normal backup
 622              mechanism is not used when performing the actual copy.
 623              backup_type must be set to `none' only *after* the above
 624              call to find_backup_file_name -- that function uses
 625              backup_type to determine the suffix it applies.  */
 626           x_tmp = *x;
 627           x_tmp.backup_type = none;
 628           x = &x_tmp;
 629
 630           if (new_dest == NULL)
 631             xalloc_die ();
 632         }
 633
 634       /* When the destination is specified with a trailing slash and the
 635          source exists but is not a directory, convert the user's command
 636          `cp source dest/' to `cp source dest/basename(source)'.  Doing
 637          this ensures that the command `cp non-directory file/' will now
 638          fail rather than performing the copy.  COPY diagnoses the case of
 639          `cp directory non-directory'.  */
 640
 641       else if (dest[strlen (dest) - 1] == '/'
 642           && lstat (source, &source_stats) == 0
 643           && !S_ISDIR (source_stats.st_mode))
 644         {
 645           char *source_base;
 646
 647           ASSIGN_BASENAME_STRDUPA (source_base, source);
 648           new_dest = (char *) alloca (strlen (dest)
 649                                       + strlen (source_base) + 1);
 650           stpcpy (stpcpy (new_dest, dest), source_base);
 651         }
 652       else
 653         {
 654           new_dest = (char *) dest;
 655         }
 656
 657       return copy (source, new_dest, new_dst, x, &unused, NULL);
 658     }
 659
 660   /* unreachable */
 661 }
 662
 663 static void
 664 cp_option_init (struct cp_options *x)
 665 {
 666   x->copy_as_regular = 1;
 667   x->dereference = DEREF_UNDEFINED;
 668   x->unlink_dest_before_opening = 0;
 669   x->unlink_dest_after_failed_open = 0;
 670   x->failed_unlink_is_fatal = 1;
 671   x->hard_link = 0;
 672   x->interactive = 0;
 673   x->myeuid = geteuid ();
 674   x->move_mode = 0;
 675   x->one_file_system = 0;
 676
 677   x->preserve_owner_and_group = 0;
 678   x->preserve_chmod_bits = 0;
 679   x->preserve_timestamps = 0;
 680
 681   x->require_preserve = 0;
 682   x->recursive = 0;
 683   x->sparse_mode = SPARSE_AUTO;
 684   x->symbolic_link = 0;
 685   x->set_mode = 0;
 686   x->mode = 0;
 687
 688   /* Find out the current file creation mask, to knock the right bits
 689      when using chmod.  The creation mask is set to be liberal, so
 690      that created directories can be written, even if it would not
 691      have been allowed with the mask this process was started with.  */
 692   x->umask_kill = ~ umask (0);
 693
 694   x->update = 0;
 695   x->verbose = 0;
 696 }
 697
 698 int
 699 main (int argc, char **argv)
 700 {
 701   int c;
 702   int make_backups = 0;
 703   char *backup_suffix_string;
 704   char *version_control_string = NULL;
 705   struct cp_options x;
 706   char *target_directory = NULL;
 707   int used_P_option = 0;
 708
 709   program_name = argv[0];
 710   setlocale (LC_ALL, "");
 711   bindtextdomain (PACKAGE, LOCALEDIR);
 712   textdomain (PACKAGE);
 713
 714   atexit (close_stdout);
 715
 716   cp_option_init (&x);
 717
 718   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 719      we'll actually use backup_suffix_string.  */
 720   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 721
 722   while ((c = getopt_long (argc, argv, "abdfHilLprsuvxPRS:V:", long_opts, NULL))
 723          != -1)
 724     {
 725       switch (c)
 726         {
 727         case 0:
 728           break;
 729
 730         case SPARSE_OPTION:
 731           x.sparse_mode = XARGMATCH ("--sparse", optarg,
 732                                      sparse_type_string, sparse_type);
 733           break;
 734
 735         case 'a':               /* Like -dpR. */
 736           x.dereference = DEREF_NEVER;
 737           x.preserve_owner_and_group = 1;
 738           x.preserve_chmod_bits = 1;
 739           x.preserve_timestamps = 1;
 740           x.require_preserve = 1;
 741           x.recursive = 1;
 742           x.copy_as_regular = 0;
 743           break;
 744
 745         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 746           error (0, 0,
 747                  _("warning: --version-control (-V) is obsolete;  support for\
 748  it\nwill be removed in some future release.  Use --backup=%s instead."
 749                    ), optarg);
 750           /* Fall through.  */
 751
 752         case 'b':
 753           make_backups = 1;
 754           if (optarg)
 755             version_control_string = optarg;
 756           break;
 757
 758         case 'd':
 759           x.dereference = DEREF_NEVER;
 760           break;
 761
 762         case 'f':
 763           x.unlink_dest_after_failed_open = 1;
 764           break;
 765
 766         case 'H':
 767           x.dereference = DEREF_COMMAND_LINE_ARGUMENTS;
 768           break;
 769
 770         case 'i':
 771           x.interactive = 1;
 772           break;
 773
 774         case 'l':
 775           x.hard_link = 1;
 776           break;
 777
 778         case 'L':
 779           x.dereference = DEREF_ALWAYS;
 780           break;
 781
 782         case 'p':
 783           x.preserve_owner_and_group = 1;
 784           x.preserve_chmod_bits = 1;
 785           x.preserve_timestamps = 1;
 786           x.require_preserve = 1;
 787           break;
 788
 789         case 'P':
 790           used_P_option = 1;
 791           /* fall through */
 792         case PARENTS_OPTION:
 793           flag_path = 1;
 794           break;
 795
 796         case 'r':
 797           x.recursive = 1;
 798           x.copy_as_regular = 1;
 799           break;
 800
 801         case 'R':
 802           x.recursive = 1;
 803           x.copy_as_regular = 0;
 804           break;
 805
 806         case UNLINK_DEST_BEFORE_OPENING:
 807           x.unlink_dest_before_opening = 1;
 808           break;
 809
 810         case STRIP_TRAILING_SLASHES_OPTION:
 811           remove_trailing_slashes = 1;
 812           break;
 813
 814         case 's':
 815 #ifdef S_ISLNK
 816           x.symbolic_link = 1;
 817 #else
 818           error (1, 0, _("symbolic links are not supported on this system"));
 819 #endif
 820           break;
 821
 822         case TARGET_DIRECTORY_OPTION:
 823           target_directory = optarg;
 824           break;
 825
 826         case 'u':
 827           x.update = 1;
 828           break;
 829
 830         case 'v':
 831           x.verbose = 1;
 832           break;
 833
 834         case 'x':
 835           x.one_file_system = 1;
 836           break;
 837
 838         case 'S':
 839           make_backups = 1;
 840           backup_suffix_string = optarg;
 841           break;
 842
 843         case_GETOPT_HELP_CHAR;
 844
 845         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 846
 847         default:
 848           usage (1);
 849         }
 850     }
 851
 852   if (x.hard_link && x.symbolic_link)
 853     {
 854       error (0, 0, _("cannot make both hard and symbolic links"));
 855       usage (1);
 856     }
 857
 858   if (used_P_option)
 859     {
 860       error (0, 0,
 861              _("\
 862 Warning: the meaning of `-P' will change in the future to conform to POSIX.\n\
 863 Use `--parents' for the old meaning, and `--no-dereference' for the new one."));
 864     }
 865
 866   if (backup_suffix_string)
 867     simple_backup_suffix = xstrdup (backup_suffix_string);
 868
 869   x.backup_type = (make_backups
 870                    ? xget_version (_("backup type"),
 871                                    version_control_string)
 872                    : none);
 873
 874   if (x.preserve_chmod_bits == 1)
 875     x.umask_kill = ~ (mode_t) 0;
 876
 877   if (x.dereference == DEREF_UNDEFINED)
 878     {
 879       if (x.recursive)
 880         /* This is compatible with FreeBSD.  */
 881         x.dereference = DEREF_NEVER;
 882       else
 883         x.dereference = DEREF_ALWAYS;
 884     }
 885
 886   /* The key difference between -d (--no-dereference) and not is the version
 887      of `stat' to call.  */
 888
 889   if (x.dereference == DEREF_NEVER)
 890     x.xstat = lstat;
 891   else
 892     {
 893       /* For DEREF_COMMAND_LINE_ARGUMENTS, x.xstat must be stat for
 894          each command line argument, but must later be `lstat' for
 895          any symlinks that are found via recursive traversal.  */
 896       x.xstat = stat;
 897     }
 898
 899   /* If --force (-f) was specified and we're in link-creation mode,
 900      first remove any existing destination file.  */
 901   if (x.unlink_dest_after_failed_open && (x.hard_link || x.symbolic_link))
 902     x.unlink_dest_before_opening = 1;
 903
 904   /* Allocate space for remembering copied and created files.  */
 905
 906   hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE);
 907
 908   exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);
 909
 910   exit (exit_status);
 911 }