src/cp.c

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