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   /* Initialize the hash table only if we'll need it.
 486      The problem it is used to detect can arise only if there are
 487      two or more files to copy.  */
 488   if (n_files >= 2)
 489     dest_info_init ();
 490
 491   if (lstat (dest, &sb))
 492     {
 493       if (errno != ENOENT)
 494         {
 495           error (0, errno, _("accessing %s"), quote (dest));
 496           return 1;
 497         }
 498
 499       new_dst = 1;
 500     }
 501   else
 502     {
 503       struct stat sbx;
 504
 505       /* If `dest' is not a symlink to a nonexistent file, use
 506          the results of stat instead of lstat, so we can copy files
 507          into symlinks to directories. */
 508       if (stat (dest, &sbx) == 0)
 509         sb = sbx;
 510
 511       dest_is_dir = S_ISDIR (sb.st_mode);
 512     }
 513
 514   if (!dest_is_dir)
 515     {
 516       if (target_directory)
 517         {
 518           error (0, 0, _("specified target, %s is not a directory"),
 519                  quote (dest));
 520           usage (1);
 521         }
 522
 523       if (n_files > 1)
 524         {
 525           error (0, 0,
 526          _("copying multiple files, but last argument %s is not a directory"),
 527              quote (dest));
 528           usage (1);
 529         }
 530     }
 531
 532   if (dest_is_dir)
 533     {
 534       /* cp file1...filen edir
 535          Copy the files `file1' through `filen'
 536          to the existing directory `edir'. */
 537       int i;
 538
 539       for (i = 0; i < n_files; i++)
 540         {
 541           char *dst_path;
 542           int parent_exists = 1; /* True if dir_name (dst_path) exists. */
 543           struct dir_attr *attr_list;
 544           char *arg_in_concat = NULL;
 545           char *arg = file[i];
 546
 547           /* Trailing slashes are meaningful (i.e., maybe worth preserving)
 548              only in the source file names.  */
 549           if (remove_trailing_slashes)
 550             strip_trailing_slashes (arg);
 551
 552           if (flag_path)
 553             {
 554               char *arg_no_trailing_slash;
 555
 556               /* Use `arg' without trailing slashes in constructing destination
 557                  file names.  Otherwise, we can end up trying to create a
 558                  directory via `mkdir ("dst/foo/"...', which is not portable.
 559                  It fails, due to the trailing slash, on at least
 560                  NetBSD 1.[34] systems.  */
 561               ASSIGN_STRDUPA (arg_no_trailing_slash, arg);
 562               strip_trailing_slashes (arg_no_trailing_slash);
 563
 564               /* Append all of `arg' (minus any trailing slash) to `dest'.  */
 565               dst_path = path_concat (dest, arg_no_trailing_slash,
 566                                       &arg_in_concat);
 567               if (dst_path == NULL)
 568                 xalloc_die ();
 569
 570               /* For --parents, we have to make sure that the directory
 571                  dir_name (dst_path) exists.  We may have to create a few
 572                  leading directories. */
 573               parent_exists = !make_path_private (dst_path,
 574                                                   arg_in_concat - dst_path,
 575                                                   S_IRWXU,
 576                                                   (x->verbose
 577                                                    ? "%s -> %s\n" : NULL),
 578                                                   &attr_list, &new_dst,
 579                                                   x->xstat);
 580             }
 581           else
 582             {
 583               char *arg_base;
 584               /* Append the last component of `arg' to `dest'.  */
 585
 586               ASSIGN_BASENAME_STRDUPA (arg_base, arg);
 587               /* For `cp -R source/.. dest', don't copy into `dest/..'. */
 588               dst_path = (STREQ (arg_base, "..")
 589                           ? xstrdup (dest)
 590                           : path_concat (dest, arg_base, NULL));
 591             }
 592
 593           if (!parent_exists)
 594             {
 595               /* make_path_private failed, so don't even attempt the copy. */
 596               ret = 1;
 597             }
 598           else
 599             {
 600               int copy_into_self;
 601               ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
 602
 603               if (flag_path)
 604                 {
 605                   ret |= re_protect (dst_path, arg_in_concat - dst_path,
 606                                      attr_list, x);
 607                 }
 608             }
 609
 610           free (dst_path);
 611         }
 612       return ret;
 613     }
 614   else /* if (n_files == 1) */
 615     {
 616       char *new_dest;
 617       char *source;
 618       int unused;
 619       struct stat source_stats;
 620
 621       if (flag_path)
 622         {
 623           error (0, 0,
 624                _("when preserving paths, the destination must be a directory"));
 625           usage (1);
 626         }
 627
 628       source = file[0];
 629
 630       /* When the force and backup options have been specified and
 631          the source and destination are the same name for an existing
 632          regular file, convert the user's command, e.g.,
 633          `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
 634          where SUFFIX is determined by any version control options used.  */
 635
 636       if (x->unlink_dest_after_failed_open
 637           && x->backup_type != none
 638           && STREQ (source, dest)
 639           && !new_dst && S_ISREG (sb.st_mode))
 640         {
 641           static struct cp_options x_tmp;
 642
 643           new_dest = find_backup_file_name (dest, x->backup_type);
 644           /* Set x->backup_type to `none' so that the normal backup
 645              mechanism is not used when performing the actual copy.
 646              backup_type must be set to `none' only *after* the above
 647              call to find_backup_file_name -- that function uses
 648              backup_type to determine the suffix it applies.  */
 649           x_tmp = *x;
 650           x_tmp.backup_type = none;
 651           x = &x_tmp;
 652
 653           if (new_dest == NULL)
 654             xalloc_die ();
 655         }
 656
 657       /* When the destination is specified with a trailing slash and the
 658          source exists but is not a directory, convert the user's command
 659          `cp source dest/' to `cp source dest/basename(source)'.  Doing
 660          this ensures that the command `cp non-directory file/' will now
 661          fail rather than performing the copy.  COPY diagnoses the case of
 662          `cp directory non-directory'.  */
 663
 664       else if (dest[strlen (dest) - 1] == '/'
 665           && lstat (source, &source_stats) == 0
 666           && !S_ISDIR (source_stats.st_mode))
 667         {
 668           char *source_base;
 669
 670           ASSIGN_BASENAME_STRDUPA (source_base, source);
 671           new_dest = (char *) alloca (strlen (dest)
 672                                       + strlen (source_base) + 1);
 673           stpcpy (stpcpy (new_dest, dest), source_base);
 674         }
 675       else
 676         {
 677           new_dest = (char *) dest;
 678         }
 679
 680       return copy (source, new_dest, new_dst, x, &unused, NULL);
 681     }
 682
 683   /* unreachable */
 684 }
 685
 686 static void
 687 cp_option_init (struct cp_options *x)
 688 {
 689   x->copy_as_regular = 1;
 690   x->dereference = DEREF_UNDEFINED;
 691   x->unlink_dest_before_opening = 0;
 692   x->unlink_dest_after_failed_open = 0;
 693   x->failed_unlink_is_fatal = 1;
 694   x->hard_link = 0;
 695   x->interactive = I_UNSPECIFIED;
 696   x->myeuid = geteuid ();
 697   x->move_mode = 0;
 698   x->one_file_system = 0;
 699
 700   x->preserve_owner_and_group = 0;
 701   x->preserve_chmod_bits = 0;
 702   x->preserve_timestamps = 0;
 703
 704   x->require_preserve = 0;
 705   x->recursive = 0;
 706   x->sparse_mode = SPARSE_AUTO;
 707   x->symbolic_link = 0;
 708   x->set_mode = 0;
 709   x->mode = 0;
 710
 711   /* Not used.  */
 712   x->stdin_tty = 0;
 713
 714   /* Find out the current file creation mask, to knock the right bits
 715      when using chmod.  The creation mask is set to be liberal, so
 716      that created directories can be written, even if it would not
 717      have been allowed with the mask this process was started with.  */
 718   x->umask_kill = ~ umask (0);
 719
 720   x->update = 0;
 721   x->verbose = 0;
 722 }
 723
 724 int
 725 main (int argc, char **argv)
 726 {
 727   int c;
 728   int make_backups = 0;
 729   char *backup_suffix_string;
 730   char *version_control_string = NULL;
 731   struct cp_options x;
 732   char *target_directory = NULL;
 733   int used_P_option = 0;
 734
 735   program_name = argv[0];
 736   setlocale (LC_ALL, "");
 737   bindtextdomain (PACKAGE, LOCALEDIR);
 738   textdomain (PACKAGE);
 739
 740   atexit (close_stdout);
 741
 742   cp_option_init (&x);
 743
 744   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 745      we'll actually use backup_suffix_string.  */
 746   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 747
 748   while ((c = getopt_long (argc, argv, "abdfHilLprsuvxPRS:V:", long_opts, NULL))
 749          != -1)
 750     {
 751       switch (c)
 752         {
 753         case 0:
 754           break;
 755
 756         case SPARSE_OPTION:
 757           x.sparse_mode = XARGMATCH ("--sparse", optarg,
 758                                      sparse_type_string, sparse_type);
 759           break;
 760
 761         case 'a':               /* Like -dpR. */
 762           x.dereference = DEREF_NEVER;
 763           x.preserve_owner_and_group = 1;
 764           x.preserve_chmod_bits = 1;
 765           x.preserve_timestamps = 1;
 766           x.require_preserve = 1;
 767           x.recursive = 1;
 768           x.copy_as_regular = 0;
 769           break;
 770
 771         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 772           error (0, 0,
 773                  _("warning: --version-control (-V) is obsolete;  support for\
 774  it\nwill be removed in some future release.  Use --backup=%s instead."
 775                    ), optarg);
 776           /* Fall through.  */
 777
 778         case 'b':
 779           make_backups = 1;
 780           if (optarg)
 781             version_control_string = optarg;
 782           break;
 783
 784         case 'd':
 785           x.dereference = DEREF_NEVER;
 786           break;
 787
 788         case 'f':
 789           x.unlink_dest_after_failed_open = 1;
 790           break;
 791
 792         case 'H':
 793           x.dereference = DEREF_COMMAND_LINE_ARGUMENTS;
 794           break;
 795
 796         case 'i':
 797           x.interactive = I_ASK_USER;
 798           break;
 799
 800         case 'l':
 801           x.hard_link = 1;
 802           break;
 803
 804         case 'L':
 805           x.dereference = DEREF_ALWAYS;
 806           break;
 807
 808         case 'p':
 809           x.preserve_owner_and_group = 1;
 810           x.preserve_chmod_bits = 1;
 811           x.preserve_timestamps = 1;
 812           x.require_preserve = 1;
 813           break;
 814
 815         case 'P':
 816           used_P_option = 1;
 817           /* fall through */
 818         case PARENTS_OPTION:
 819           flag_path = 1;
 820           break;
 821
 822         case 'r':
 823           x.recursive = 1;
 824           x.copy_as_regular = 1;
 825           break;
 826
 827         case 'R':
 828           x.recursive = 1;
 829           x.copy_as_regular = 0;
 830           break;
 831
 832         case REPLY_OPTION:
 833           x.interactive = XARGMATCH ("--reply", optarg,
 834                                      reply_args, reply_vals);
 835           break;
 836
 837         case UNLINK_DEST_BEFORE_OPENING:
 838           x.unlink_dest_before_opening = 1;
 839           break;
 840
 841         case STRIP_TRAILING_SLASHES_OPTION:
 842           remove_trailing_slashes = 1;
 843           break;
 844
 845         case 's':
 846 #ifdef S_ISLNK
 847           x.symbolic_link = 1;
 848 #else
 849           error (1, 0, _("symbolic links are not supported on this system"));
 850 #endif
 851           break;
 852
 853         case TARGET_DIRECTORY_OPTION:
 854           target_directory = optarg;
 855           break;
 856
 857         case 'u':
 858           x.update = 1;
 859           break;
 860
 861         case 'v':
 862           x.verbose = 1;
 863           break;
 864
 865         case 'x':
 866           x.one_file_system = 1;
 867           break;
 868
 869         case 'S':
 870           make_backups = 1;
 871           backup_suffix_string = optarg;
 872           break;
 873
 874         case_GETOPT_HELP_CHAR;
 875
 876         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 877
 878         default:
 879           usage (1);
 880         }
 881     }
 882
 883   if (x.hard_link && x.symbolic_link)
 884     {
 885       error (0, 0, _("cannot make both hard and symbolic links"));
 886       usage (1);
 887     }
 888
 889   if (used_P_option)
 890     {
 891       error (0, 0,
 892              _("\
 893 Warning: the meaning of `-P' will change in the future to conform to POSIX.\n\
 894 Use `--parents' for the old meaning, and `--no-dereference' for the new one."));
 895     }
 896
 897   if (backup_suffix_string)
 898     simple_backup_suffix = xstrdup (backup_suffix_string);
 899
 900   x.backup_type = (make_backups
 901                    ? xget_version (_("backup type"),
 902                                    version_control_string)
 903                    : none);
 904
 905   if (x.preserve_chmod_bits == 1)
 906     x.umask_kill = ~ (mode_t) 0;
 907
 908   if (x.dereference == DEREF_UNDEFINED)
 909     {
 910       if (x.recursive)
 911         /* This is compatible with FreeBSD.  */
 912         x.dereference = DEREF_NEVER;
 913       else
 914         x.dereference = DEREF_ALWAYS;
 915     }
 916
 917   /* The key difference between -d (--no-dereference) and not is the version
 918      of `stat' to call.  */
 919
 920   if (x.dereference == DEREF_NEVER)
 921     x.xstat = lstat;
 922   else
 923     {
 924       /* For DEREF_COMMAND_LINE_ARGUMENTS, x.xstat must be stat for
 925          each command line argument, but must later be `lstat' for
 926          any symlinks that are found via recursive traversal.  */
 927       x.xstat = stat;
 928     }
 929
 930   /* If --force (-f) was specified and we're in link-creation mode,
 931      first remove any existing destination file.  */
 932   if (x.unlink_dest_after_failed_open && (x.hard_link || x.symbolic_link))
 933     x.unlink_dest_before_opening = 1;
 934
 935   /* Allocate space for remembering copied and created files.  */
 936
 937   hash_init ();
 938
 939   exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);
 940
 941   exit (exit_status);
 942 }