1 /* cp.c -- file copying (main routines)
2 Copyright (C) 89, 90, 91, 1995-2000 Free Software Foundation.
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)
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.
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.
18 Written by Torbjorn Granlund, David MacKenzie, and Jim Meyering. */
26 #include <sys/types.h>
32 #include "backupfile.h"
37 #include "path-concat.h"
40 #define ASSIGN_BASENAME_STRDUPA(Dest, File_name) \
44 ASSIGN_STRDUPA (tmp_abns_, (File_name)); \
45 strip_trailing_slashes (tmp_abns_); \
46 Dest = base_name (tmp_abns_); \
50 /* The official name of this program (e.g., no `g' prefix). */
51 #define PROGRAM_NAME "cp"
53 #define AUTHORS "Torbjorn Granlund, David MacKenzie, and Jim Meyering"
55 #ifndef _POSIX_VERSION
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. */
66 struct dir_attr *next;
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. */
73 TARGET_DIRECTORY_OPTION = CHAR_MAX + 1,
75 STRIP_TRAILING_SLASHES_OPTION,
77 UNLINK_DEST_BEFORE_OPENING
80 void strip_trailing_slashes ();
82 /* Initial number of entries in each hash table entry's table of inodes. */
83 #define INITIAL_HASH_MODULE 100
85 /* Initial number of entries in the inode hash table. */
86 #define INITIAL_ENTRY_TAB_SIZE 70
88 /* The invocation name of this program. */
91 /* If nonzero, the command "cp x/e_file e_dir" uses "e_dir/x/e_file"
92 as its destination instead of the usual "e_dir/e_file." */
93 static int flag_path = 0;
95 /* Remove any trailing slashes from each SOURCE argument. */
96 static int remove_trailing_slashes;
98 static char const *const sparse_type_string[] =
100 "never", "auto", "always", 0
103 static enum Sparse_type const sparse_type[] =
105 SPARSE_NEVER, SPARSE_AUTO, SPARSE_ALWAYS
108 /* The error code to return to the system. */
109 static int exit_status = 0;
111 static struct option const long_opts[] =
113 {"archive", no_argument, NULL, 'a'},
114 {"backup", optional_argument, NULL, 'b'},
115 {"dereference", no_argument, NULL, 'L'},
116 {"force", no_argument, NULL, 'f'},
117 {"sparse", required_argument, NULL, SPARSE_OPTION},
118 {"interactive", no_argument, NULL, 'i'},
119 {"link", no_argument, NULL, 'l'},
120 {"no-dereference", no_argument, NULL, 'd'},
121 {"one-file-system", no_argument, NULL, 'x'},
122 {"parents", no_argument, NULL, PARENTS_OPTION},
123 {"path", no_argument, NULL, PARENTS_OPTION}, /* Deprecated. */
124 {"preserve", no_argument, NULL, 'p'},
125 {"recursive", no_argument, NULL, 'R'},
126 {"remove-destination", no_argument, NULL, UNLINK_DEST_BEFORE_OPENING},
127 {"strip-trailing-slash", no_argument, NULL, STRIP_TRAILING_SLASHES_OPTION},
128 {"suffix", required_argument, NULL, 'S'},
129 {"symbolic-link", no_argument, NULL, 's'},
130 {"target-directory", required_argument, NULL, TARGET_DIRECTORY_OPTION},
131 {"update", no_argument, NULL, 'u'},
132 {"verbose", no_argument, NULL, 'v'},
133 {"version-control", required_argument, NULL, 'V'}, /* Deprecated. FIXME. */
134 {GETOPT_HELP_OPTION_DECL},
135 {GETOPT_VERSION_OPTION_DECL},
143 fprintf (stderr, _("Try `%s --help' for more information.\n"),
148 Usage: %s [OPTION]... SOURCE DEST\n\
149 or: %s [OPTION]... SOURCE... DIRECTORY\n\
150 or: %s [OPTION]... --target-directory=DIRECTORY SOURCE...\n\
152 program_name, program_name, program_name);
154 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n\
156 -a, --archive same as -dpR\n\
157 --backup[=CONTROL] make a backup of each existing destination file\n\
158 -b like --backup but does not accept an argument\n\
159 -d, --no-dereference preserve links\n\
160 -f, --force if a preexisting destination file cannot be\n\
161 opened, then unlink it and try again\n\
162 -i, --interactive prompt before overwrite\n\
163 -H follow symbolic links that are explicitly\n\
164 specified in the command line, but do not\n\
165 follow symlinks that are found via recursive\n\
167 -l, --link link files instead of copying\n\
168 -L, --dereference always follow symbolic links\n\
169 -p, --preserve preserve file attributes if possible\n\
170 --parents append source path to DIRECTORY\n\
171 -P same as `--parents' for now; soon to change to\n\
172 `--no-dereference' to conform to POSIX\n\
173 -r copy recursively, non-directories as files\n\
174 WARNING: use -R instead when you might copy\n\
175 special files like FIFOs or /dev/zero\n\
176 --remove-destination unlink each preexisting destination file before\n\
177 attempting to open it (contrast with --force)\n\
178 --sparse=WHEN control creation of sparse files\n\
179 -R, --recursive copy directories recursively\n\
180 --strip-trailing-slashes remove any trailing slashes from each SOURCE\n\
182 -s, --symbolic-link make symbolic links instead of copying\n\
183 -S, --suffix=SUFFIX override the usual backup suffix\n\
184 --target-directory=DIRECTORY move all SOURCE arguments into DIRECTORY\n\
185 -u, --update copy only when the SOURCE file is newer\n\
186 than the destination file or when the\n\
187 destination file is missing\n\
188 -v, --verbose explain what is being done\n\
189 -x, --one-file-system stay on this file system\n\
190 --help display this help and exit\n\
191 --version output version information and exit\n\
193 By default, sparse SOURCE files are detected by a crude heuristic and the\n\
194 corresponding DEST file is made sparse as well. That is the behavior\n\
195 selected by --sparse=auto. Specify --sparse=always to create a sparse DEST\n\
196 file whenever the SOURCE file contains a long enough sequence of zero bytes.\n\
197 Use --sparse=never to inhibit creation of sparse files.\n\
201 The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
202 The version control method may be selected via the --backup option or through\n\
203 the VERSION_CONTROL environment variable. Here are the values:\n\
205 none, off never make backups (even if --backup is given)\n\
206 numbered, t make numbered backups\n\
207 existing, nil numbered if numbered backups exist, simple otherwise\n\
208 simple, never always make simple backups\n\
212 As a special case, cp makes a backup of SOURCE when the force and backup\n\
213 options are given and SOURCE and DEST are the same name for an existing,\n\
216 puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
221 /* Ensure that the parent directories of CONST_DST_PATH have the
222 correct protections, for the --parents option. This is done
223 after all copying has been completed, to allow permissions
224 that don't include user write/execute.
226 SRC_OFFSET is the index in CONST_DST_PATH of the beginning of the
227 source directory name.
229 ATTR_LIST is a null-terminated linked list of structures that
230 indicates the end of the filename of each intermediate directory
231 in CONST_DST_PATH that may need to have its attributes changed.
232 The command `cp --parents --preserve a/b/c d/e_dir' changes the
233 attributes of the directories d/e_dir/a and d/e_dir/a/b to match
234 the corresponding source directories regardless of whether they
235 existed before the `cp' command was given.
237 Return 0 if the parent of CONST_DST_PATH and any intermediate
238 directories specified by ATTR_LIST have the proper permissions
239 when done, otherwise 1. */
242 re_protect (const char *const_dst_path, int src_offset,
243 struct dir_attr *attr_list, const struct cp_options *x)
246 char *dst_path; /* A copy of CONST_DST_PATH we can change. */
247 char *src_path; /* The source name in `dst_path'. */
248 uid_t myeuid = geteuid ();
250 dst_path = (char *) alloca (strlen (const_dst_path) + 1);
251 strcpy (dst_path, const_dst_path);
252 src_path = dst_path + src_offset;
254 for (p = attr_list; p; p = p->next)
258 dst_path[p->slash_offset] = '\0';
260 if ((*(x->xstat)) (src_path, &src_sb))
262 error (0, errno, _("getting attributes of %s"),
267 /* Adjust the times (and if possible, ownership) for the copy.
268 chown turns off set[ug]id bits for non-root,
269 so do the chmod last. */
271 if (x->preserve_timestamps)
275 /* There's currently no interface to set file timestamps with
276 better than 1-second resolution, so discard any fractional
277 part of the source timestamp. */
279 utb.actime = src_sb.st_atime;
280 utb.modtime = src_sb.st_mtime;
282 if (utime (dst_path, &utb))
284 error (0, errno, _("preserving times for %s"), quote (dst_path));
289 if (x->preserve_owner_and_group)
291 /* If non-root uses -p, it's ok if we can't preserve ownership.
292 But root probably wants to know, e.g. if NFS disallows it,
293 or if the target system doesn't support file ownership. */
294 if (chown (dst_path, src_sb.st_uid, src_sb.st_gid)
295 && ((errno != EPERM && errno != EINVAL) || myeuid == 0))
297 error (0, errno, _("preserving ownership for %s"),
303 if (x->preserve_chmod_bits || p->is_new_dir)
305 if (chmod (dst_path, src_sb.st_mode & x->umask_kill))
307 error (0, errno, _("preserving permissions for %s"),
313 dst_path[p->slash_offset] = '/';
318 /* Ensure that the parent directory of CONST_DIRPATH exists, for
319 the --parents option.
321 SRC_OFFSET is the index in CONST_DIRPATH (which is a destination
322 path) of the beginning of the source directory name.
323 Create any leading directories that don't already exist,
324 giving them permissions MODE.
325 If VERBOSE_FMT_STRING is nonzero, use it as a printf format
326 string for printing a message after successfully making a directory.
327 The format should take two string arguments: the names of the
328 source and destination directories.
329 Creates a linked list of attributes of intermediate directories,
330 *ATTR_LIST, for re_protect to use after calling copy.
331 Sets *NEW_DST to 1 if this function creates parent of CONST_DIRPATH.
333 Return 0 if parent of CONST_DIRPATH exists as a directory with the proper
334 permissions when done, otherwise 1. */
337 make_path_private (const char *const_dirpath, int src_offset, int mode,
338 const char *verbose_fmt_string, struct dir_attr **attr_list,
339 int *new_dst, int (*xstat)())
342 char *dirpath; /* A copy of CONST_DIRPATH we can change. */
343 char *src; /* Source name in `dirpath'. */
344 char *tmp_dst_dirname; /* Leading path of `dirpath', malloc. */
345 char *dst_dirname; /* Leading path of `dirpath', alloca. */
347 dirpath = (char *) alloca (strlen (const_dirpath) + 1);
348 strcpy (dirpath, const_dirpath);
350 src = dirpath + src_offset;
352 tmp_dst_dirname = dir_name (dirpath);
353 dst_dirname = (char *) alloca (strlen (tmp_dst_dirname) + 1);
354 strcpy (dst_dirname, tmp_dst_dirname);
355 free (tmp_dst_dirname);
359 if ((*xstat) (dst_dirname, &stats))
361 /* Parent of CONST_DIRNAME does not exist.
362 Make all missing intermediate directories. */
366 while (*slash == '/')
368 while ((slash = strchr (slash, '/')))
370 /* Add this directory to the list of directories whose modes need
372 struct dir_attr *new =
373 (struct dir_attr *) xmalloc (sizeof (struct dir_attr));
374 new->slash_offset = slash - dirpath;
375 new->next = *attr_list;
379 if ((*xstat) (dirpath, &stats))
381 /* This element of the path does not exist. We must set
382 *new_dst and new->is_new_dir inside this loop because,
383 for example, in the command `cp --parents ../a/../b/c e_dir',
384 make_path_private creates only e_dir/../a if ./b already
388 if (mkdir (dirpath, mode))
390 error (0, errno, _("cannot make directory %s"),
396 if (verbose_fmt_string != NULL)
397 printf (verbose_fmt_string, src, dirpath);
400 else if (!S_ISDIR (stats.st_mode))
402 error (0, 0, _("%s exists but is not a directory"),
413 /* Avoid unnecessary calls to `stat' when given
414 pathnames containing multiple adjacent slashes. */
415 while (*slash == '/')
420 /* We get here if the parent of `dirpath' already exists. */
422 else if (!S_ISDIR (stats.st_mode))
424 error (0, 0, _("%s exists but is not a directory"), quote (dst_dirname));
434 /* Scan the arguments, and copy each by calling copy.
435 Return 0 if successful, 1 if any errors occur. */
438 do_copy (int n_files, char **file, const char *target_directory,
439 const struct cp_options *x)
449 error (0, 0, _("missing file arguments"));
452 if (n_files == 1 && !target_directory)
454 error (0, 0, _("missing destination file"));
458 if (target_directory)
459 dest = target_directory;
462 dest = file[n_files - 1];
466 if (lstat (dest, &sb))
470 error (0, errno, _("accessing %s"), quote (dest));
480 /* If `dest' is not a symlink to a nonexistent file, use
481 the results of stat instead of lstat, so we can copy files
482 into symlinks to directories. */
483 if (stat (dest, &sbx) == 0)
486 dest_is_dir = S_ISDIR (sb.st_mode);
491 if (target_directory)
493 error (0, 0, _("specified target, %s is not a directory"),
501 _("copying multiple files, but last argument %s is not a directory"),
509 /* cp file1...filen edir
510 Copy the files `file1' through `filen'
511 to the existing directory `edir'. */
514 for (i = 0; i < n_files; i++)
517 int parent_exists = 1; /* True if dir_name (dst_path) exists. */
518 struct dir_attr *attr_list;
519 char *arg_in_concat = NULL;
522 if (remove_trailing_slashes)
523 strip_trailing_slashes (arg);
527 /* Append all of `arg' to `dest'. */
528 dst_path = path_concat (dest, arg, &arg_in_concat);
529 if (dst_path == NULL)
532 /* For --parents, we have to make sure that the directory
533 dir_name (dst_path) exists. We may have to create a few
534 leading directories. */
535 parent_exists = !make_path_private (dst_path,
536 arg_in_concat - dst_path,
539 ? "%s -> %s\n" : NULL),
540 &attr_list, &new_dst,
546 /* Append the last component of `arg' to `dest'. */
548 ASSIGN_BASENAME_STRDUPA (arg_base, arg);
549 /* For `cp -R source/.. dest', don't copy into `dest/..'. */
550 dst_path = (STREQ (arg_base, "..")
552 : path_concat (dest, arg_base, NULL));
557 /* make_path_private failed, so don't even attempt the copy. */
563 ret |= copy (arg, dst_path, new_dst, x, ©_into_self, NULL);
568 ret |= re_protect (dst_path, arg_in_concat - dst_path,
577 else /* if (n_files == 1) */
582 struct stat source_stats;
587 _("when preserving paths, the destination must be a directory"));
593 /* When the force and backup options have been specified and
594 the source and destination are the same name for an existing
595 regular file, convert the user's command, e.g.,
596 `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
597 where SUFFIX is determined by any version control options used. */
599 if (x->unlink_dest_after_failed_open
600 && x->backup_type != none
601 && STREQ (source, dest)
602 && !new_dst && S_ISREG (sb.st_mode))
604 static struct cp_options x_tmp;
606 new_dest = find_backup_file_name (dest, x->backup_type);
607 /* Set x->backup_type to `none' so that the normal backup
608 mechanism is not used when performing the actual copy.
609 backup_type must be set to `none' only *after* the above
610 call to find_backup_file_name -- that function uses
611 backup_type to determine the suffix it applies. */
613 x_tmp.backup_type = none;
616 if (new_dest == NULL)
620 /* When the destination is specified with a trailing slash and the
621 source exists but is not a directory, convert the user's command
622 `cp source dest/' to `cp source dest/basename(source)'. Doing
623 this ensures that the command `cp non-directory file/' will now
624 fail rather than performing the copy. COPY diagnoses the case of
625 `cp directory non-directory'. */
627 else if (dest[strlen (dest) - 1] == '/'
628 && lstat (source, &source_stats) == 0
629 && !S_ISDIR (source_stats.st_mode))
633 ASSIGN_BASENAME_STRDUPA (source_base, source);
634 new_dest = (char *) alloca (strlen (dest)
635 + strlen (source_base) + 1);
636 stpcpy (stpcpy (new_dest, dest), source_base);
640 new_dest = (char *) dest;
643 return copy (source, new_dest, new_dst, x, &unused, NULL);
650 cp_option_init (struct cp_options *x)
652 x->copy_as_regular = 1;
653 x->dereference = DEREF_UNDEFINED;
654 x->unlink_dest_before_opening = 0;
655 x->unlink_dest_after_failed_open = 0;
656 x->failed_unlink_is_fatal = 1;
659 x->myeuid = geteuid ();
661 x->one_file_system = 0;
663 x->preserve_owner_and_group = 0;
664 x->preserve_chmod_bits = 0;
665 x->preserve_timestamps = 0;
667 x->require_preserve = 0;
669 x->sparse_mode = SPARSE_AUTO;
670 x->symbolic_link = 0;
674 /* Find out the current file creation mask, to knock the right bits
675 when using chmod. The creation mask is set to be liberal, so
676 that created directories can be written, even if it would not
677 have been allowed with the mask this process was started with. */
678 x->umask_kill = ~ umask (0);
685 main (int argc, char **argv)
688 int make_backups = 0;
689 char *backup_suffix_string;
690 char *version_control_string = NULL;
692 char *target_directory = NULL;
693 int used_P_option = 0;
695 program_name = argv[0];
696 setlocale (LC_ALL, "");
697 bindtextdomain (PACKAGE, LOCALEDIR);
698 textdomain (PACKAGE);
700 atexit (close_stdout);
704 /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
705 we'll actually use backup_suffix_string. */
706 backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
708 while ((c = getopt_long (argc, argv, "abdfHilLprsuvxPRS:V:", long_opts, NULL))
717 x.sparse_mode = XARGMATCH ("--sparse", optarg,
718 sparse_type_string, sparse_type);
721 case 'a': /* Like -dpR. */
722 x.dereference = DEREF_NEVER;
723 x.preserve_owner_and_group = 1;
724 x.preserve_chmod_bits = 1;
725 x.preserve_timestamps = 1;
726 x.require_preserve = 1;
728 x.copy_as_regular = 0;
731 case 'V': /* FIXME: this is deprecated. Remove it in 2001. */
733 _("warning: --version-control (-V) is obsolete; support for\
734 it\nwill be removed in some future release. Use --backup=%s instead."
741 version_control_string = optarg;
745 x.dereference = DEREF_NEVER;
749 x.unlink_dest_after_failed_open = 1;
753 x.dereference = DEREF_COMMAND_LINE_ARGUMENTS;
765 x.dereference = DEREF_ALWAYS;
769 x.preserve_owner_and_group = 1;
770 x.preserve_chmod_bits = 1;
771 x.preserve_timestamps = 1;
772 x.require_preserve = 1;
784 x.copy_as_regular = 1;
789 x.copy_as_regular = 0;
792 case UNLINK_DEST_BEFORE_OPENING:
793 x.unlink_dest_before_opening = 1;
796 case STRIP_TRAILING_SLASHES_OPTION:
797 remove_trailing_slashes = 1;
804 error (1, 0, _("symbolic links are not supported on this system"));
808 case TARGET_DIRECTORY_OPTION:
809 target_directory = optarg;
821 x.one_file_system = 1;
826 backup_suffix_string = optarg;
829 case_GETOPT_HELP_CHAR;
831 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
838 if (x.hard_link && x.symbolic_link)
840 error (0, 0, _("cannot make both hard and symbolic links"));
848 Warning: the meaning of `-P' will change in the future to conform to POSIX.\n\
849 Use `--parents' for the old meaning, and `--no-dereference' for the new one."));
852 if (backup_suffix_string)
853 simple_backup_suffix = xstrdup (backup_suffix_string);
855 x.backup_type = (make_backups
856 ? xget_version (_("backup type"),
857 version_control_string)
860 if (x.preserve_chmod_bits == 1)
861 x.umask_kill = ~ (mode_t) 0;
863 if (x.dereference == DEREF_UNDEFINED)
866 /* This is compatible with FreeBSD. */
867 x.dereference = DEREF_NEVER;
869 x.dereference = DEREF_ALWAYS;
872 /* The key difference between -d (--no-dereference) and not is the version
873 of `stat' to call. */
875 if (x.dereference == DEREF_NEVER)
879 /* For DEREF_COMMAND_LINE_ARGUMENTS, x.xstat must be stat for
880 each command line argument, but must later be `lstat' for
881 any symlinks that are found via recursive traversal. */
885 /* If --force (-f) was specified and we're in link-creation mode,
886 first remove any existing destination file. */
887 if (x.unlink_dest_after_failed_open && (x.hard_link || x.symbolic_link))
888 x.unlink_dest_before_opening = 1;
890 /* Allocate space for remembering copied and created files. */
892 hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE);
894 exit_status |= do_copy (argc - optind, argv + optind, target_directory, &x);