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               forget_all ();
 603
 604               if (flag_path)
 605                 {
 606                   ret |= re_protect (dst_path, arg_in_concat - dst_path,
 607                                      attr_list, x);
 608                 }
 609             }
 610
 611           free (dst_path);
 612         }
 613       return ret;
 614     }
 615   else /* if (n_files == 1) */
 616     {
 617       char *new_dest;
 618       char *source;
 619       int unused;
 620       struct stat source_stats;
 621
 622       if (flag_path)
 623         {
 624           error (0, 0,
 625                _("when preserving paths, the destination must be a directory"));
 626           usage (1);
 627         }
 628
 629       source = file[0];
 630
 631       /* When the force and backup options have been specified and
 632          the source and destination are the same name for an existing
 633          regular file, convert the user's command, e.g.,
 634          `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
 635          where SUFFIX is determined by any version control options used.  */
 636
 637       if (x->unlink_dest_after_failed_open
 638           && x->backup_type != none
 639           && STREQ (source, dest)
 640           && !new_dst && S_ISREG (sb.st_mode))
 641         {
 642           static struct cp_options x_tmp;
 643
 644           new_dest = find_backup_file_name (dest, x->backup_type);
 645           /* Set x->backup_type to `none' so that the normal backup
 646              mechanism is not used when performing the actual copy.
 647              backup_type must be set to `none' only *after* the above
 648              call to find_backup_file_name -- that function uses
 649              backup_type to determine the suffix it applies.  */
 650           x_tmp = *x;
 651           x_tmp.backup_type = none;
 652           x = &x_tmp;
 653
 654           if (new_dest == NULL)
 655             xalloc_die ();
 656         }
 657
 658       /* When the destination is specified with a trailing slash and the
 659          source exists but is not a directory, convert the user's command
 660          `cp source dest/' to `cp source dest/basename(source)'.  Doing
 661          this ensures that the command `cp non-directory file/' will now
 662          fail rather than performing the copy.  COPY diagnoses the case of
 663          `cp directory non-directory'.  */
 664
 665       else if (dest[strlen (dest) - 1] == '/'
 666           && lstat (source, &source_stats) == 0
 667           && !S_ISDIR (source_stats.st_mode))
 668         {
 669           char *source_base;
 670
 671           ASSIGN_BASENAME_STRDUPA (source_base, source);
 672           new_dest = (char *) alloca (strlen (dest)
 673                                       + strlen (source_base) + 1);
 674           stpcpy (stpcpy (new_dest, dest), source_base);
 675         }
 676       else
 677         {
 678           new_dest = (char *) dest;
 679         }
 680
 681       return copy (source, new_dest, new_dst, x, &unused, NULL);
 682     }
 683
 684   /* unreachable */
 685 }
 686
 687 static void
 688 cp_option_init (struct cp_options *x)
 689 {
 690   x->copy_as_regular = 1;
 691   x->dereference = DEREF_UNDEFINED;
 692   x->unlink_dest_before_opening = 0;
 693   x->unlink_dest_after_failed_open = 0;
 694   x->failed_unlink_is_fatal = 1;
 695   x->hard_link = 0;
 696   x->interactive = I_UNSPECIFIED;
 697   x->myeuid = geteuid ();
 698   x->move_mode = 0;
 699   x->one_file_system = 0;
 700
 701   x->preserve_owner_and_group = 0;
 702   x->preserve_chmod_bits = 0;
 703   x->preserve_timestamps = 0;
 704
 705   x->require_preserve = 0;
 706   x->recursive = 0;
 707   x->sparse_mode = SPARSE_AUTO;
 708   x->symbolic_link = 0;
 709   x->set_mode = 0;
 710   x->mode = 0;
 711
 712   /* Not used.  */
 713   x->stdin_tty = 0;
 714
 715   /* Find out the current file creation mask, to knock the right bits
 716      when using chmod.  The creation mask is set to be liberal, so
 717      that created directories can be written, even if it would not
 718      have been allowed with the mask this process was started with.  */
 719   x->umask_kill = ~ umask (0);
 720
 721   x->update = 0;
 722   x->verbose = 0;
 723 }
 724
 725 int
 726 main (int argc, char **argv)
 727 {
 728   int c;
 729   int make_backups = 0;
 730   char *backup_suffix_string;
 731   char *version_control_string = NULL;
 732   struct cp_options x;
 733   char *target_directory = NULL;
 734   int used_P_option = 0;
 735
 736   program_name = argv[0];
 737   setlocale (LC_ALL, "");
 738   bindtextdomain (PACKAGE, LOCALEDIR);
 739   textdomain (PACKAGE);
 740
 741   atexit (close_stdout);
 742
 743   cp_option_init (&x);
 744
 745   /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
 746      we'll actually use backup_suffix_string.  */
 747   backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
 748
 749   while ((c = getopt_long (argc, argv, "abdfHilLprsuvxPRS:V:", long_opts, NULL))
 750          != -1)
 751     {
 752       switch (c)
 753         {
 754         case 0:
 755           break;
 756
 757         case SPARSE_OPTION:
 758           x.sparse_mode = XARGMATCH ("--sparse", optarg,
 759                                      sparse_type_string, sparse_type);
 760           break;
 761
 762         case 'a':               /* Like -dpR. */
 763           x.dereference = DEREF_NEVER;
 764           x.preserve_owner_and_group = 1;
 765           x.preserve_chmod_bits = 1;
 766           x.preserve_timestamps = 1;
 767           x.require_preserve = 1;
 768           x.recursive = 1;
 769           x.copy_as_regular = 0;
 770           break;
 771
 772         case 'V':  /* FIXME: this is deprecated.  Remove it in 2001.  */
 773           error (0, 0,
 774                  _("warning: --version-control (-V) is obsolete;  support for\
 775  it\nwill be removed in some future release.  Use --backup=%s instead."
 776                    ), optarg);
 777           /* Fall through.  */
 778
 779         case 'b':
 780           make_backups = 1;
 781           if (optarg)
 782             version_control_string = optarg;
 783           break;
 784
 785         case 'd':
 786           x.dereference = DEREF_NEVER;
 787           break;
 788
 789         case 'f':
 790           x.unlink_dest_after_failed_open = 1;
 791           break;
 792
 793         case 'H':
 794           x.dereference = DEREF_COMMAND_LINE_ARGUMENTS;
 795           break;
 796
 797         case 'i':
 798           x.interactive = I_ASK_USER;
 799           break;
 800
 801         case 'l':
 802           x.hard_link = 1;
 803           break;
 804
 805         case 'L':
 806           x.dereference = DEREF_ALWAYS;
 807           break;
 808
 809         case 'p':
 810           x.preserve_owner_and_group = 1;
 811           x.preserve_chmod_bits = 1;
 812           x.preserve_timestamps = 1;
 813           x.require_preserve = 1;
 814           break;
 815
 816         case 'P':
 817           used_P_option = 1;
 818           /* fall through */
 819         case PARENTS_OPTION:
 820           flag_path = 1;
 821           break;
 822
 823         case 'r':
 824           x.recursive = 1;
 825           x.copy_as_regular = 1;
 826           break;
 827
 828         case 'R':
 829           x.recursive = 1;
 830           x.copy_as_regular = 0;
 831           break;
 832
 833         case REPLY_OPTION:
 834           x.interactive = XARGMATCH ("--reply", optarg,
 835                                      reply_args, reply_vals);
 836           break;
 837
 838         case UNLINK_DEST_BEFORE_OPENING:
 839           x.unlink_dest_before_opening = 1;
 840           break;
 841
 842         case STRIP_TRAILING_SLASHES_OPTION:
 843           remove_trailing_slashes = 1;
 844           break;
 845
 846         case 's':
 847 #ifdef S_ISLNK
 848           x.symbolic_link = 1;
 849 #else
 850           error (1, 0, _("symbolic links are not supported on this system"));
 851 #endif
 852           break;
 853
 854         case TARGET_DIRECTORY_OPTION:
 855           target_directory = optarg;
 856           break;
 857
 858         case 'u':
 859           x.update = 1;
 860           break;
 861
 862         case 'v':
 863           x.verbose = 1;
 864           break;
 865
 866         case 'x':
 867           x.one_file_system = 1;
 868           break;
 869
 870         case 'S':
 871           make_backups = 1;
 872           backup_suffix_string = optarg;
 873           break;
 874
 875         case_GETOPT_HELP_CHAR;
 876
 877         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 878
 879         default:
 880           usage (1);
 881         }
 882     }
 883
 884   if (x.hard_link && x.symbolic_link)
 885     {
 886       error (0, 0, _("cannot make both hard and symbolic links"));
 887       usage (1);
 888     }
 889
 890   if (used_P_option)
 891     {
 892       error (0, 0,
 893              _("\
 894 Warning: the meaning of `-P' will change in the future to conform to POSIX.\n\
 895 Use `--parents' for the old meaning, and `--no-dereference' for the new one."));
 896     }
 897
 898   if (backup_suffix_string)
 899     simple_backup_suffix = xstrdup (backup_suffix_string);
 900
 901   x.backup_type = (make_backups
 902                    ? xget_version (_("backup type"),
 903                                    version_control_string)
 904                    : none);
 905
 906   if (x.preserve_chmod_bits == 1)
 907     x.umask_kill = ~ (mode_t) 0;
 908
 909   if (x.dereference == DEREF_UNDEFINED)
 910     {
 911       if (x.recursive)
 912         /* This is compatible with FreeBSD.  */
 913         x.dereference = DEREF_NEVER;
 914       else
 915         x.dereference = DEREF_ALWAYS;
 916     }
 917
 918   /* The key difference between -d (--no-dereference) and not is the version
 919      of `stat' to call.  */
 920
 921   if (x.dereference == DEREF_NEVER)
 922     x.xstat = lstat;
 923   else
 924     {
 925       /* For DEREF_COMMAND_LINE_ARGUMENTS, x.xstat must be stat for
 926          each command line argument, but must later be `lstat' for
 927          any symlinks that are found via recursive traversal.  */
 928       x.xstat = stat;
 929     }
 930
 931   /* If --force (-f) was specified and we're in link-creation mode,
 932      first remove any existing destination file.  */
 933   if (x.unlink_dest_after_failed_open && (x.hard_link || x.symbolic_link))
 934     x.unlink_dest_before_opening = 1;
 935
 936   /* Allocate space for remembering copied and created files.  */
 937
 938   hash_init ();
 939
 940   exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);
 941
 942   exit (exit_status);
 943 }