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   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-slash", 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       --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 static int
 334 make_path_private (const char *const_dirpath, int src_offset, int mode,
 335                    const char *verbose_fmt_string, struct dir_attr **attr_list,
 336                    int *new_dst, int (*xstat)())
 337 {
 338   struct stat stats;
 339   char *dirpath;                /* A copy of CONST_DIRPATH we can change. */
 340   char *src;                    /* Source name in `dirpath'. */
 341   char *tmp_dst_dirname;        /* Leading path of `dirpath', malloc. */
 342   char *dst_dirname;            /* Leading path of `dirpath', alloca. */
 343
 344   dirpath = (char *) alloca (strlen (const_dirpath) + 1);
 345   strcpy (dirpath, const_dirpath);
 346
 347   src = dirpath + src_offset;
 348
 349   tmp_dst_dirname = dir_name (dirpath);
 350   dst_dirname = (char *) alloca (strlen (tmp_dst_dirname) + 1);
 351   strcpy (dst_dirname, tmp_dst_dirname);
 352   free (tmp_dst_dirname);
 353
 354   *attr_list = NULL;
 355
 356   if ((*xstat) (dst_dirname, &stats))
 357     {
 358       /* Parent of CONST_DIRNAME does not exist.
 359          Make all missing intermediate directories. */
 360       char *slash;
 361
 362       slash = src;
 363       while (*slash == '/')
 364         slash++;
 365       while ((slash = strchr (slash, '/')))
 366         {
 367           /* Add this directory to the list of directories whose modes need
 368              fixing later. */
 369           struct dir_attr *new =
 370             (struct dir_attr *) xmalloc (sizeof (struct dir_attr));
 371           new->slash_offset = slash - dirpath;
 372           new->next = *attr_list;
 373           *attr_list = new;
 374
 375           *slash = '\0';
 376           if ((*xstat) (dirpath, &stats))
 377             {
 378               /* This element of the path does not exist.  We must set
 379                  *new_dst and new->is_new_dir inside this loop because,
 380                  for example, in the command `cp --parents ../a/../b/c e_dir',
 381                  make_path_private creates only e_dir/../a if ./b already
 382                  exists. */
 383               *new_dst = 1;
 384               new->is_new_dir = 1;
 385               if (mkdir (dirpath, mode))
 386                 {
 387                   error (0, errno, _("cannot make directory %s"),
 388                          quote (dirpath));
 389                   return 1;
 390                 }
 391               else
 392                 {
 393                   if (verbose_fmt_string != NULL)
 394                     printf (verbose_fmt_string, src, dirpath);
 395                 }
 396             }
 397           else if (!S_ISDIR (stats.st_mode))
 398             {
 399               error (0, 0, _("%s exists but is not a directory"),
 400                      quote (dirpath));
 401               return 1;
 402             }
 403           else
 404             {
 405               new->is_new_dir = 0;
 406               *new_dst = 0;
 407             }
 408           *slash++ = '/';
 409
 410           /* Avoid unnecessary calls to `stat' when given
 411              pathnames containing multiple adjacent slashes.  */
 412           while (*slash == '/')
 413             slash++;
 414         }
 415     }
 416
 417   /* We get here if the parent of `dirpath' already exists. */
 418
 419   else if (!S_ISDIR (stats.st_mode))
 420     {
 421       error (0, 0, _("%s exists but is not a directory"), quote (dst_dirname));
 422       return 1;
 423     }
 424   else
 425     {
 426       *new_dst = 0;
 427     }
 428   return 0;
 429 }
 430
 431 /* Scan the arguments, and copy each by calling copy.
 432    Return 0 if successful, 1 if any errors occur. */
 433
 434 static int
 435 do_copy (int n_files, char **file, const char *target_directory,
 436          const struct cp_options *x)
 437 {
 438   const char *dest;
 439   struct stat sb;
 440   int new_dst = 0;
 441   int ret = 0;
 442   int dest_is_dir = 0;
 443
 444   if (n_files <= 0)
 445     {
 446       error (0, 0, _("missing file arguments"));
 447       usage (1);
 448     }
 449   if (n_files == 1 && !target_directory)
 450     {
 451       error (0, 0, _("missing destination file"));
 452       usage (1);
 453     }
 454
 455   if (target_directory)
 456     dest = target_directory;
 457   else
 458     {
 459       dest = file[n_files - 1];
 460       --n_files;
 461     }
 462
 463   if (lstat (dest, &sb))
 464     {
 465       if (errno != ENOENT)
 466         {
 467           error (0, errno, _("accessing %s"), quote (dest));
 468           return 1;
 469         }
 470
 471       new_dst = 1;
 472     }
 473   else
 474     {
 475       struct stat sbx;
 476
 477       /* If `dest' is not a symlink to a nonexistent file, use
 478          the results of stat instead of lstat, so we can copy files
 479          into symlinks to directories. */
 480       if (stat (dest, &sbx) == 0)
 481         sb = sbx;
 482
 483       dest_is_dir = S_ISDIR (sb.st_mode);
 484     }
 485
 486   if (!dest_is_dir)
 487     {
 488       if (target_directory)
 489         {
 490           error (0, 0, _("specified target, %s is not a directory"),
 491                  quote (dest));
 492           usage (1);
 493         }
 494
 495       if (n_files > 1)
 496         {
 497           error (0, 0,
 498          _("copying multiple files, but last argument %s is not a directory"),
 499              quote (dest));
 500           usage (1);
 501         }
 502     }
 503
 504   if (dest_is_dir)
 505     {
 506       /* cp file1...filen edir
 507          Copy the files `file1' through `filen'
 508          to the existing directory `edir'. */
 509       int i;
 510
 511       for (i = 0; i < n_files; i++)
 512         {
 513           char *dst_path;
 514           int parent_exists = 1; /* True if dir_name (dst_path) exists. */
 515           struct dir_attr *attr_list;
 516           char *arg_in_concat = NULL;
 517           char *arg = file[i];
 518
 519           if (remove_trailing_slashes)
 520             strip_trailing_slashes (arg);
 521
 522           if (flag_path)
 523             {
 524               /* Append all of `arg' to `dest'.  */
 525               dst_path = path_concat (dest, arg, &arg_in_concat);
 526               if (dst_path == NULL)
 527                 xalloc_die ();
 528
 529               /* For --parents, we have to make sure that the directory
 530                  dir_name (dst_path) exists.  We may have to create a few
 531                  leading directories. */
 532               parent_exists = !make_path_private (dst_path,
 533                                                   arg_in_concat - dst_path,
 534                                                   S_IRWXU,
 535                                                   (x->verbose
 536                                                    ? "%s -> %s\n" : NULL),
 537                                                   &attr_list, &new_dst,
 538                                                   x->xstat);
 539             }
 540           else
 541             {
 542               char *arg_base;
 543               /* Append the last component of `arg' to `dest'.  */
 544
 545               ASSIGN_BASENAME_STRDUPA (arg_base, arg);
 546               /* For `cp -R source/.. dest', don't copy into `dest/..'. */
 547               dst_path = (STREQ (arg_base, "..")
 548                           ? xstrdup (dest)
 549                           : path_concat (dest, arg_base, NULL));
 550             }
 551
 552           if (!parent_exists)
 553             {
 554               /* make_path_private failed, so don't even attempt the copy. */
 555               ret = 1;
 556             }
 557           else
 558             {
 559               int copy_into_self;
 560               ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
 561               forget_all ();
 562
 563               if (flag_path)
 564                 {
 565                   ret |= re_protect (dst_path, arg_in_concat - dst_path,
 566                                      attr_list, x);
 567                 }
 568             }
 569
 570           free (dst_path);
 571         }
 572       return ret;
 573     }
 574   else /* if (n_files == 1) */
 575     {
 576       char *new_dest;
 577       char *source;
 578       int unused;
 579       struct stat source_stats;
 580
 581       if (flag_path)
 582         {
 583           error (0, 0,
 584                _("when preserving paths, the destination must be a directory"));
 585           usage (1);
 586         }
 587
 588       source = file[0];
 589
 590       /* When the force and backup options have been specified and
 591          the source and destination are the same name for an existing
 592          regular file, convert the user's command, e.g.,
 593          `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
 594          where SUFFIX is determined by any version control options used.  */
 595
 596       if (x->unlink_dest_after_failed_open
 597           && x->backup_type != none
 598           && STREQ (source, dest)
 599           && !new_dst && S_ISREG (sb.st_mode))
 600         {
 601           static struct cp_options x_tmp;
 602
 603           new_dest = find_backup_file_name (dest, x->backup_type);
 604           /* Set x->backup_type to `none' so that the normal backup
 605              mechanism is not used when performing the actual copy.
 606              backup_type must be set to `none' only *after* the above
 607              call to find_backup_file_name -- that function uses
 608              backup_type to determine the suffix it applies.  */
 609           x_tmp = *x;
 610           x_tmp.backup_type = none;
 611           x = &x_tmp;
 612
 613           if (new_dest == NULL)
 614             xalloc_die ();
 615         }
 616
 617       /* When the destination is specified with a trailing slash and the
 618          source exists but is not a directory, convert the user's command
 619          `cp source dest/' to `cp source dest/basename(source)'.  Doing
 620          this ensures that the command `cp non-directory file/' will now
 621          fail rather than performing the copy.  COPY diagnoses the case of
 622          `cp directory non-directory'.  */
 623
 624       else if (dest[strlen (dest) - 1] == '/'
 625           && lstat (source, &source_stats) == 0
 626           && !S_ISDIR (source_stats.st_mode))
 627         {
 628           char *source_base;
 629
 630           ASSIGN_BASENAME_STRDUPA (source_base, source);
 631           new_dest = (char *) alloca (strlen (dest)
 632                                       + strlen (source_base) + 1);
 633           stpcpy (stpcpy (new_dest, dest), source_base);
 634         }
 635       else
 636         {
 637           new_dest = (char *) dest;
 638         }
 639
 640       return copy (source, new_dest, new_dst, x, &unused, NULL);
 641     }
 642
 643   /* unreachable */
 644 }
 645
 646 static void
 647 cp_option_init (struct cp_options *x)
 648 {
 649   x->copy_as_regular = 1;
 650   x->dereference = DEREF_UNDEFINED;
 651   x->unlink_dest_before_opening = 0;
 652   x->unlink_dest_after_failed_open = 0;
 653   x->failed_unlink_is_fatal = 1;
 654   x->hard_link = 0;
 655   x->interactive = 0;
 656   x->myeuid = geteuid ();
 657   x->move_mode = 0;
 658   x->one_file_system = 0;
 659
 660   x->preserve_owner_and_group = 0;
 661   x->preserve_chmod_bits = 0;
 662   x->preserve_timestamps = 0;
 663
 664   x->require_preserve = 0;
 665   x->recursive = 0;
 666   x->sparse_mode = SPARSE_AUTO;
 667   x->symbolic_link = 0;
 668   x->set_mode = 0;
 669   x->mode = 0;
 670
 671   /* Find out the current file creation mask, to knock the right bits
 672      when using chmod.  The creation mask is set to be liberal, so
 673      that created directories can be written, even if it would not
 674      have been allowed with the mask this process was started with.  */
 675   x->umask_kill = ~ umask (0);
 676
 677   x->update = 0;
 678   x->verbose = 0;
 679 }
 680
 681 int
 682 main (int argc, char **argv)
 683 {
 684   int c;
 685   int make_backups = 0;
 686   char *backup_suffix_string;
 687   char *version_control_string = NULL;
 688   struct cp_options x;
 689   char *target_directory = NULL;
 690   int used_P_option = 0;
 691
 692   program_name = argv[0];
 693   setlocale (LC_ALL, "");
 694   bindtextdomain (PACKAGE, LOCALEDIR);
 695   textdomain (PACKAGE);
 696
 697   atexit (close_stdout);
 698
 699   cp_option_init (&x);
 700
 701   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 702      we'll actually use backup_suffix_string.  */
 703   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 704
 705   while ((c = getopt_long (argc, argv, "abdfHilLprsuvxPRS:V:", long_opts, NULL))
 706          != -1)
 707     {
 708       switch (c)
 709         {
 710         case 0:
 711           break;
 712
 713         case SPARSE_OPTION:
 714           x.sparse_mode = XARGMATCH ("--sparse", optarg,
 715                                      sparse_type_string, sparse_type);
 716           break;
 717
 718         case 'a':               /* Like -dpR. */
 719           x.dereference = DEREF_NEVER;
 720           x.preserve_owner_and_group = 1;
 721           x.preserve_chmod_bits = 1;
 722           x.preserve_timestamps = 1;
 723           x.require_preserve = 1;
 724           x.recursive = 1;
 725           x.copy_as_regular = 0;
 726           break;
 727
 728         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 729           error (0, 0,
 730                  _("warning: --version-control (-V) is obsolete;  support for\
 731  it\nwill be removed in some future release.  Use --backup=%s instead."
 732                    ), optarg);
 733           /* Fall through.  */
 734
 735         case 'b':
 736           make_backups = 1;
 737           if (optarg)
 738             version_control_string = optarg;
 739           break;
 740
 741         case 'd':
 742           x.dereference = DEREF_NEVER;
 743           break;
 744
 745         case 'f':
 746           x.unlink_dest_after_failed_open = 1;
 747           break;
 748
 749         case 'H':
 750           x.dereference = DEREF_COMMAND_LINE_ARGUMENTS;
 751           break;
 752
 753         case 'i':
 754           x.interactive = 1;
 755           break;
 756
 757         case 'l':
 758           x.hard_link = 1;
 759           break;
 760
 761         case 'L':
 762           x.dereference = DEREF_ALWAYS;
 763           break;
 764
 765         case 'p':
 766           x.preserve_owner_and_group = 1;
 767           x.preserve_chmod_bits = 1;
 768           x.preserve_timestamps = 1;
 769           x.require_preserve = 1;
 770           break;
 771
 772         case 'P':
 773           used_P_option = 1;
 774           /* fall through */
 775         case PARENTS_OPTION:
 776           flag_path = 1;
 777           break;
 778
 779         case 'r':
 780           x.recursive = 1;
 781           x.copy_as_regular = 1;
 782           break;
 783
 784         case 'R':
 785           x.recursive = 1;
 786           x.copy_as_regular = 0;
 787           break;
 788
 789         case UNLINK_DEST_BEFORE_OPENING:
 790           x.unlink_dest_before_opening = 1;
 791           break;
 792
 793         case STRIP_TRAILING_SLASHES_OPTION:
 794           remove_trailing_slashes = 1;
 795           break;
 796
 797         case 's':
 798 #ifdef S_ISLNK
 799           x.symbolic_link = 1;
 800 #else
 801           error (1, 0, _("symbolic links are not supported on this system"));
 802 #endif
 803           break;
 804
 805         case TARGET_DIRECTORY_OPTION:
 806           target_directory = optarg;
 807           break;
 808
 809         case 'u':
 810           x.update = 1;
 811           break;
 812
 813         case 'v':
 814           x.verbose = 1;
 815           break;
 816
 817         case 'x':
 818           x.one_file_system = 1;
 819           break;
 820
 821         case 'S':
 822           make_backups = 1;
 823           backup_suffix_string = optarg;
 824           break;
 825
 826         case_GETOPT_HELP_CHAR;
 827
 828         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 829
 830         default:
 831           usage (1);
 832         }
 833     }
 834
 835   if (x.hard_link && x.symbolic_link)
 836     {
 837       error (0, 0, _("cannot make both hard and symbolic links"));
 838       usage (1);
 839     }
 840
 841   if (used_P_option)
 842     {
 843       error (0, 0,
 844              _("\
 845 Warning: the meaning of `-P' will change in the future to conform to POSIX.\n\
 846 Use `--parents' for the old meaning, and `--no-dereference' for the new one."));
 847     }
 848
 849   if (backup_suffix_string)
 850     simple_backup_suffix = xstrdup (backup_suffix_string);
 851
 852   x.backup_type = (make_backups
 853                    ? xget_version (_("backup type"),
 854                                    version_control_string)
 855                    : none);
 856
 857   if (x.preserve_chmod_bits == 1)
 858     x.umask_kill = ~ (mode_t) 0;
 859
 860   if (x.dereference == DEREF_UNDEFINED)
 861     {
 862       if (x.recursive)
 863         /* This is compatible with FreeBSD.  */
 864         x.dereference = DEREF_NEVER;
 865       else
 866         x.dereference = DEREF_ALWAYS;
 867     }
 868
 869   /* The key difference between -d (--no-dereference) and not is the version
 870      of `stat' to call.  */
 871
 872   if (x.dereference == DEREF_NEVER)
 873     x.xstat = lstat;
 874   else
 875     {
 876       /* For DEREF_COMMAND_LINE_ARGUMENTS, x.xstat must be stat for
 877          each command line argument, but must later be `lstat' for
 878          any symlinks that are found via recursive traversal.  */
 879       x.xstat = stat;
 880     }
 881
 882   /* If --force (-f) was specified and we're in link-creation mode,
 883      first remove any existing destination file.  */
 884   if (x.unlink_dest_after_failed_open && (x.hard_link || x.symbolic_link))
 885     x.unlink_dest_before_opening = 1;
 886
 887   /* Allocate space for remembering copied and created files.  */
 888
 889   hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE);
 890
 891   exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);
 892
 893   exit (exit_status);
 894 }