*** empty log message ***
[coreutils.git] / src / cp.c
blob1792d489bc8e748a32bd461b49db76c9f25eb041
1 /* cp.c -- file copying (main routines)
2 Copyright (C) 89, 90, 91, 95, 96, 97, 1998, 1999 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)
7 any later version.
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. */
20 #ifdef _AIX
21 #pragma alloca
22 #endif
24 #include <config.h>
25 #include <stdio.h>
26 #include <sys/types.h>
27 #include <assert.h>
28 #include <getopt.h>
30 #include "system.h"
31 #include "backupfile.h"
32 #include "argmatch.h"
33 #include "path-concat.h"
34 #include "closeout.h"
35 #include "cp-hash.h"
36 #include "copy.h"
37 #include "error.h"
38 #include "dirname.h"
40 #ifndef _POSIX_VERSION
41 uid_t geteuid ();
42 #endif
44 /* Used by do_copy, make_path_private, and re_protect
45 to keep a list of leading directories whose protections
46 need to be fixed after copying. */
47 struct dir_attr
49 int is_new_dir;
50 int slash_offset;
51 struct dir_attr *next;
54 int stat ();
55 int lstat ();
57 void strip_trailing_slashes ();
58 char *xstrdup ();
60 /* Initial number of entries in each hash table entry's table of inodes. */
61 #define INITIAL_HASH_MODULE 100
63 /* Initial number of entries in the inode hash table. */
64 #define INITIAL_ENTRY_TAB_SIZE 70
66 /* The invocation name of this program. */
67 char *program_name;
69 /* If nonzero, the command "cp x/e_file e_dir" uses "e_dir/x/e_file"
70 as its destination instead of the usual "e_dir/e_file." */
71 static int flag_path = 0;
73 static char const *const sparse_type_string[] =
75 "never", "auto", "always", 0
78 static enum Sparse_type const sparse_type[] =
80 SPARSE_NEVER, SPARSE_AUTO, SPARSE_ALWAYS
83 /* The error code to return to the system. */
84 static int exit_status = 0;
86 /* If nonzero, display usage information and exit. */
87 static int show_help;
89 /* If nonzero, print the version on standard output and exit. */
90 static int show_version;
92 static struct option const long_opts[] =
94 {"archive", no_argument, NULL, 'a'},
95 {"backup", no_argument, NULL, 'b'},
96 {"force", no_argument, NULL, 'f'},
97 {"sparse", required_argument, NULL, CHAR_MAX + 1},
98 {"interactive", no_argument, NULL, 'i'},
99 {"link", no_argument, NULL, 'l'},
100 {"no-dereference", no_argument, NULL, 'd'},
101 {"one-file-system", no_argument, NULL, 'x'},
102 {"parents", no_argument, NULL, 'P'},
103 {"path", no_argument, NULL, 'P'},
104 {"preserve", no_argument, NULL, 'p'},
105 {"recursive", no_argument, NULL, 'R'},
106 {"suffix", required_argument, NULL, 'S'},
107 {"symbolic-link", no_argument, NULL, 's'},
108 {"update", no_argument, NULL, 'u'},
109 {"verbose", no_argument, NULL, 'v'},
110 {"version-control", required_argument, NULL, 'V'},
111 {"help", no_argument, &show_help, 1},
112 {"version", no_argument, &show_version, 1},
113 {NULL, 0, NULL, 0}
116 void
117 usage (int status)
119 if (status != 0)
120 fprintf (stderr, _("Try `%s --help' for more information.\n"),
121 program_name);
122 else
124 printf (_("\
125 Usage: %s [OPTION]... SOURCE DEST\n\
126 or: %s [OPTION]... SOURCE... DIRECTORY\n\
128 program_name, program_name);
129 printf (_("\
130 Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n\
132 -a, --archive same as -dpR\n\
133 -b, --backup make backup before removal\n\
134 -d, --no-dereference preserve links\n\
135 -f, --force remove existing destinations, never prompt\n\
136 -i, --interactive prompt before overwrite\n\
137 -l, --link link files instead of copying\n\
138 -p, --preserve preserve file attributes if possible\n\
139 -P, --parents append source path to DIRECTORY\n\
140 -r copy recursively, non-directories as files\n\
141 --sparse=WHEN control creation of sparse files\n\
142 -R, --recursive copy directories recursively\n\
143 -s, --symbolic-link make symbolic links instead of copying\n\
144 -S, --suffix=SUFFIX override the usual backup suffix\n\
145 -u, --update copy only when the SOURCE file is newer\n\
146 than the destination file or when the\n\
147 destination file is missing\n\
148 -v, --verbose explain what is being done\n\
149 -V, --version-control=WORD override the usual version control\n\
150 -x, --one-file-system stay on this file system\n\
151 --help display this help and exit\n\
152 --version output version information and exit\n\
154 By default, sparse SOURCE files are detected by a crude heuristic and the\n\
155 corresponding DEST file is made sparse as well. That is the behavior\n\
156 selected by --sparse=auto. Specify --sparse=always to create a sparse DEST\n\
157 file whenever the SOURCE file contains a long enough sequence of zero bytes.\n\
158 Use --sparse=never to inhibit creation of sparse files.\n\
160 "));
161 printf (_("\
162 The backup suffix is ~, unless set with SIMPLE_BACKUP_SUFFIX. The\n\
163 version control may be set with VERSION_CONTROL, values are:\n\
165 none, off never make backups (even if --backup is given)\n\
166 numbered, t make numbered backups\n\
167 existing, nil numbered if numbered backups exist, simple otherwise\n\
168 simple, never always make simple backups\n\
169 "));
170 printf (_("\
172 As a special case, cp makes a backup of SOURCE when the force and backup\n\
173 options are given and SOURCE and DEST are the same name for an existing,\n\
174 regular file.\n\
175 "));
176 puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
177 close_stdout ();
179 exit (status);
182 /* Ensure that the parent directories of CONST_DST_PATH have the
183 correct protections, for the --parents option. This is done
184 after all copying has been completed, to allow permissions
185 that don't include user write/execute.
187 SRC_OFFSET is the index in CONST_DST_PATH of the beginning of the
188 source directory name.
190 ATTR_LIST is a null-terminated linked list of structures that
191 indicates the end of the filename of each intermediate directory
192 in CONST_DST_PATH that may need to have its attributes changed.
193 The command `cp --parents --preserve a/b/c d/e_dir' changes the
194 attributes of the directories d/e_dir/a and d/e_dir/a/b to match
195 the corresponding source directories regardless of whether they
196 existed before the `cp' command was given.
198 Return 0 if the parent of CONST_DST_PATH and any intermediate
199 directories specified by ATTR_LIST have the proper permissions
200 when done, otherwise 1. */
202 static int
203 re_protect (const char *const_dst_path, int src_offset,
204 struct dir_attr *attr_list, const struct cp_options *x)
206 struct dir_attr *p;
207 char *dst_path; /* A copy of CONST_DST_PATH we can change. */
208 char *src_path; /* The source name in `dst_path'. */
209 uid_t myeuid = geteuid ();
211 dst_path = (char *) alloca (strlen (const_dst_path) + 1);
212 strcpy (dst_path, const_dst_path);
213 src_path = dst_path + src_offset;
215 for (p = attr_list; p; p = p->next)
217 struct stat src_sb;
219 dst_path[p->slash_offset] = '\0';
221 if ((*(x->xstat)) (src_path, &src_sb))
223 error (0, errno, "%s", src_path);
224 return 1;
227 /* Adjust the times (and if possible, ownership) for the copy.
228 chown turns off set[ug]id bits for non-root,
229 so do the chmod last. */
231 if (x->preserve_timestamps)
233 struct utimbuf utb;
235 /* There's currently no interface to set file timestamps with
236 better than 1-second resolution, so discard any fractional
237 part of the source timestamp. */
239 utb.actime = src_sb.st_atime;
240 utb.modtime = src_sb.st_mtime;
242 if (utime (dst_path, &utb))
244 error (0, errno, _("preserving times for %s"), dst_path);
245 return 1;
249 if (x->preserve_owner_and_group)
251 /* If non-root uses -p, it's ok if we can't preserve ownership.
252 But root probably wants to know, e.g. if NFS disallows it,
253 or if the target system doesn't support file ownership. */
254 if (chown (dst_path, src_sb.st_uid, src_sb.st_gid)
255 && ((errno != EPERM && errno != EINVAL) || myeuid == 0))
257 error (0, errno, _("preserving ownership for %s"), dst_path);
258 return 1;
262 if (x->preserve_chmod_bits || p->is_new_dir)
264 if (chmod (dst_path, src_sb.st_mode & x->umask_kill))
266 error (0, errno, _("preserving permissions for %s"), dst_path);
267 return 1;
271 dst_path[p->slash_offset] = '/';
273 return 0;
276 /* Ensure that the parent directory of CONST_DIRPATH exists, for
277 the --parents option.
279 SRC_OFFSET is the index in CONST_DIRPATH (which is a destination
280 path) of the beginning of the source directory name.
281 Create any leading directories that don't already exist,
282 giving them permissions MODE.
283 If VERBOSE_FMT_STRING is nonzero, use it as a printf format
284 string for printing a message after successfully making a directory.
285 The format should take two string arguments: the names of the
286 source and destination directories.
287 Creates a linked list of attributes of intermediate directories,
288 *ATTR_LIST, for re_protect to use after calling copy.
289 Sets *NEW_DST to 1 if this function creates parent of CONST_DIRPATH.
291 Return 0 if parent of CONST_DIRPATH exists as a directory with the proper
292 permissions when done, otherwise 1. */
294 static int
295 make_path_private (const char *const_dirpath, int src_offset, int mode,
296 const char *verbose_fmt_string, struct dir_attr **attr_list,
297 int *new_dst, int (*xstat)())
299 struct stat stats;
300 char *dirpath; /* A copy of CONST_DIRPATH we can change. */
301 char *src; /* Source name in `dirpath'. */
302 char *tmp_dst_dirname; /* Leading path of `dirpath', malloc. */
303 char *dst_dirname; /* Leading path of `dirpath', alloca. */
305 dirpath = (char *) alloca (strlen (const_dirpath) + 1);
306 strcpy (dirpath, const_dirpath);
308 src = dirpath + src_offset;
310 tmp_dst_dirname = dir_name (dirpath);
311 dst_dirname = (char *) alloca (strlen (tmp_dst_dirname) + 1);
312 strcpy (dst_dirname, tmp_dst_dirname);
313 free (tmp_dst_dirname);
315 *attr_list = NULL;
317 if ((*xstat) (dst_dirname, &stats))
319 /* Parent of CONST_DIRNAME does not exist.
320 Make all missing intermediate directories. */
321 char *slash;
323 slash = src;
324 while (*slash == '/')
325 slash++;
326 while ((slash = strchr (slash, '/')))
328 /* Add this directory to the list of directories whose modes need
329 fixing later. */
330 struct dir_attr *new =
331 (struct dir_attr *) xmalloc (sizeof (struct dir_attr));
332 new->slash_offset = slash - dirpath;
333 new->next = *attr_list;
334 *attr_list = new;
336 *slash = '\0';
337 if ((*xstat) (dirpath, &stats))
339 /* This element of the path does not exist. We must set
340 *new_dst and new->is_new_dir inside this loop because,
341 for example, in the command `cp --parents ../a/../b/c e_dir',
342 make_path_private creates only e_dir/../a if ./b already
343 exists. */
344 *new_dst = 1;
345 new->is_new_dir = 1;
346 if (mkdir (dirpath, mode))
348 error (0, errno, _("cannot make directory `%s'"), dirpath);
349 return 1;
351 else
353 if (verbose_fmt_string != NULL)
354 printf (verbose_fmt_string, src, dirpath);
357 else if (!S_ISDIR (stats.st_mode))
359 error (0, 0, _("`%s' exists but is not a directory"), dirpath);
360 return 1;
362 else
364 new->is_new_dir = 0;
365 *new_dst = 0;
367 *slash++ = '/';
369 /* Avoid unnecessary calls to `stat' when given
370 pathnames containing multiple adjacent slashes. */
371 while (*slash == '/')
372 slash++;
376 /* We get here if the parent of `dirpath' already exists. */
378 else if (!S_ISDIR (stats.st_mode))
380 error (0, 0, _("`%s' exists but is not a directory"), dst_dirname);
381 return 1;
383 else
385 *new_dst = 0;
387 return 0;
390 /* Scan the arguments, and copy each by calling copy.
391 Return 0 if successful, 1 if any errors occur. */
393 static int
394 do_copy (int argc, char **argv, const struct cp_options *x)
396 char *dest;
397 struct stat sb;
398 int new_dst = 0;
399 int ret = 0;
401 if (optind >= argc)
403 error (0, 0, _("missing file arguments"));
404 usage (1);
406 if (optind >= argc - 1)
408 error (0, 0, _("missing destination file"));
409 usage (1);
412 dest = argv[argc - 1];
414 if (lstat (dest, &sb))
416 if (errno != ENOENT)
418 error (0, errno, "%s", dest);
419 return 1;
421 else
422 new_dst = 1;
424 else
426 struct stat sbx;
428 /* If `dest' is not a symlink to a nonexistent file, use
429 the results of stat instead of lstat, so we can copy files
430 into symlinks to directories. */
431 if (stat (dest, &sbx) == 0)
432 sb = sbx;
435 if (!new_dst && S_ISDIR (sb.st_mode))
437 /* cp file1...filen edir
438 Copy the files `file1' through `filen'
439 to the existing directory `edir'. */
441 for (;;)
443 char *arg;
444 char *ap;
445 char *dst_path;
446 int parent_exists = 1; /* True if dir_name (dst_path) exists. */
447 struct dir_attr *attr_list;
448 char *arg_in_concat = NULL;
450 arg = argv[optind];
452 strip_trailing_slashes (arg);
454 if (flag_path)
456 /* Append all of `arg' to `dest'. */
457 dst_path = path_concat (dest, arg, &arg_in_concat);
458 if (dst_path == NULL)
459 error (1, 0, _("virtual memory exhausted"));
461 /* For --parents, we have to make sure that the directory
462 dir_name (dst_path) exists. We may have to create a few
463 leading directories. */
464 parent_exists = !make_path_private (dst_path,
465 arg_in_concat - dst_path,
466 0700,
467 (x->verbose
468 ? "%s -> %s\n" : NULL),
469 &attr_list, &new_dst,
470 x->xstat);
472 else
474 /* Append the last component of `arg' to `dest'. */
476 ap = base_name (arg);
477 /* For `cp -R source/.. dest', don't copy into `dest/..'. */
478 dst_path = (STREQ (ap, "..")
479 ? xstrdup (dest)
480 : path_concat (dest, ap, NULL));
483 if (!parent_exists)
485 /* make_path_private failed, so don't even attempt the copy. */
486 ret = 1;
488 else
490 int copy_into_self;
491 ret |= copy (arg, dst_path, new_dst, x, &copy_into_self, NULL);
492 forget_all ();
494 if (flag_path)
496 ret |= re_protect (dst_path, arg_in_concat - dst_path,
497 attr_list, x);
501 free (dst_path);
502 ++optind;
503 if (optind == argc - 1)
504 break;
506 return ret;
508 else if (argc - optind == 2)
510 char *new_dest;
511 char *source;
512 int unused;
513 struct stat source_stats;
515 if (flag_path)
517 error (0, 0,
518 _("when preserving paths, last argument must be a directory"));
519 usage (1);
522 source = argv[optind];
524 /* When the force and backup options have been specified and
525 the source and destination are the same name for an existing
526 regular file, convert the user's command, e.g.,
527 `cp --force --backup foo foo' to `cp --force foo fooSUFFIX'
528 where SUFFIX is determined by any version control options used. */
530 if (x->force
531 && x->backup_type != none
532 && STREQ (source, dest)
533 && !new_dst && S_ISREG (sb.st_mode))
535 static struct cp_options x_tmp;
537 new_dest = find_backup_file_name (dest, x->backup_type);
538 /* Set x->backup_type to `none' so that the normal backup
539 mechanism is not used when performing the actual copy.
540 backup_type must be set to `none' only *after* the above
541 call to find_backup_file_name -- that function uses
542 backup_type to determine the suffix it applies. */
543 x_tmp = *x;
544 x_tmp.backup_type = none;
545 x = &x_tmp;
547 if (new_dest == NULL)
548 error (1, 0, _("virtual memory exhausted"));
551 /* When the destination is specified with a trailing slash and the
552 source exists but is not a directory, convert the user's command
553 `cp source dest/' to `cp source dest/basename(source)'. Doing
554 this ensures that the command `cp non-directory file/' will now
555 fail rather than performing the copy. COPY diagnoses the case of
556 `cp directory non-directory'. */
558 else if (dest[strlen (dest) - 1] == '/'
559 && lstat (source, &source_stats) == 0
560 && !S_ISDIR (source_stats.st_mode))
562 char *source_base;
563 char *tmp_source;
565 tmp_source = (char *) alloca (strlen (source) + 1);
566 strcpy (tmp_source, source);
567 strip_trailing_slashes (tmp_source);
568 source_base = base_name (tmp_source);
570 new_dest = (char *) alloca (strlen (dest)
571 + strlen (source_base) + 1);
572 stpcpy (stpcpy (new_dest, dest), source_base);
574 else
576 new_dest = dest;
579 return copy (source, new_dest, new_dst, x, &unused, NULL);
581 else
583 error (0, 0,
584 _("copying multiple files, but last argument (%s) \
585 is not a directory"),
586 dest);
587 usage (1);
590 /* unreachable */
591 return 0;
594 static void
595 cp_option_init (struct cp_options *x)
597 x->copy_as_regular = 1;
598 x->dereference = 1;
599 x->force = 0;
600 x->failed_unlink_is_fatal = 1;
601 x->hard_link = 0;
602 x->interactive = 0;
603 x->myeuid = geteuid ();
604 x->move_mode = 0;
605 x->one_file_system = 0;
607 x->preserve_owner_and_group = 0;
608 x->preserve_chmod_bits = 0;
609 x->preserve_timestamps = 0;
611 x->require_preserve = 0;
612 x->recursive = 0;
613 x->sparse_mode = SPARSE_AUTO;
614 x->symbolic_link = 0;
615 x->set_mode = 0;
616 x->mode = 0;
618 /* Find out the current file creation mask, to knock the right bits
619 when using chmod. The creation mask is set to be liberal, so
620 that created directories can be written, even if it would not
621 have been allowed with the mask this process was started with. */
622 x->umask_kill = 0777777 ^ umask (0);
624 x->update = 0;
625 x->verbose = 0;
629 main (int argc, char **argv)
631 int c;
632 int make_backups = 0;
633 char *version;
634 struct cp_options x;
636 program_name = argv[0];
637 setlocale (LC_ALL, "");
638 bindtextdomain (PACKAGE, LOCALEDIR);
639 textdomain (PACKAGE);
641 cp_option_init (&x);
643 /* FIXME: consider not calling getenv for SIMPLE_BACKUP_SUFFIX unless
644 we'll actually use simple_backup_suffix. */
645 version = getenv ("SIMPLE_BACKUP_SUFFIX");
646 if (version)
647 simple_backup_suffix = version;
648 version = NULL;
650 while ((c = getopt_long (argc, argv, "abdfilprsuvxPRS:V:", long_opts, NULL))
651 != -1)
653 switch (c)
655 case 0:
656 break;
658 case CHAR_MAX + 1:
659 x.sparse_mode = XARGMATCH ("--sparse", optarg,
660 sparse_type_string, sparse_type);
661 break;
663 case 'a': /* Like -dpR. */
664 x.dereference = 0;
665 x.preserve_owner_and_group = 1;
666 x.preserve_chmod_bits = 1;
667 x.preserve_timestamps = 1;
668 x.require_preserve = 1;
669 x.recursive = 1;
670 x.copy_as_regular = 0;
671 break;
673 case 'b':
674 make_backups = 1;
675 break;
677 case 'd':
678 x.dereference = 0;
679 break;
681 case 'f':
682 x.force = 1;
683 x.interactive = 0;
684 break;
686 case 'i':
687 x.force = 0;
688 x.interactive = 1;
689 break;
691 case 'l':
692 x.hard_link = 1;
693 break;
695 case 'p':
696 x.preserve_owner_and_group = 1;
697 x.preserve_chmod_bits = 1;
698 x.preserve_timestamps = 1;
699 x.require_preserve = 1;
700 break;
702 case 'P':
703 flag_path = 1;
704 break;
706 case 'r':
707 x.recursive = 1;
708 x.copy_as_regular = 1;
709 break;
711 case 'R':
712 x.recursive = 1;
713 x.copy_as_regular = 0;
714 break;
716 case 's':
717 #ifdef S_ISLNK
718 x.symbolic_link = 1;
719 #else
720 error (1, 0, _("symbolic links are not supported on this system"));
721 #endif
722 break;
724 case 'u':
725 x.update = 1;
726 break;
728 case 'v':
729 x.verbose = 1;
730 break;
732 case 'x':
733 x.one_file_system = 1;
734 break;
736 case 'S':
737 simple_backup_suffix = optarg;
738 break;
740 case 'V':
741 version = optarg;
742 break;
744 default:
745 usage (1);
749 if (show_version)
751 printf ("cp (%s) %s\n", GNU_PACKAGE, VERSION);
752 close_stdout ();
753 exit (0);
756 if (show_help)
757 usage (0);
759 if (x.hard_link && x.symbolic_link)
761 error (0, 0, _("cannot make both hard and symbolic links"));
762 usage (1);
765 x.backup_type = (make_backups
766 ? xget_version (_("--version-control"), version)
767 : none);
769 if (x.preserve_chmod_bits == 1)
770 x.umask_kill = 0777777;
772 /* The key difference between -d (--no-dereference) and not is the version
773 of `stat' to call. */
775 if (x.dereference)
776 x.xstat = stat;
777 else
778 x.xstat = lstat;
780 /* Allocate space for remembering copied and created files. */
782 hash_init (INITIAL_HASH_MODULE, INITIAL_ENTRY_TAB_SIZE);
784 exit_status |= do_copy (argc, argv, &x);
786 if (x.verbose)
787 close_stdout ();
788 exit (exit_status);