src/cp.c

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