Home | History | Annotate | Line # | Download | only in cp
cp.c revision 1.38
      1 /* $NetBSD: cp.c,v 1.38 2005/10/15 18:22:18 christos Exp $ */
      2 
      3 /*
      4  * Copyright (c) 1988, 1993, 1994
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This code is derived from software contributed to Berkeley by
      8  * David Hitz of Auspex Systems Inc.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. Neither the name of the University nor the names of its contributors
     19  *    may be used to endorse or promote products derived from this software
     20  *    without specific prior written permission.
     21  *
     22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     32  * SUCH DAMAGE.
     33  */
     34 
     35 #include <sys/cdefs.h>
     36 #ifndef lint
     37 __COPYRIGHT(
     38 "@(#) Copyright (c) 1988, 1993, 1994\n\
     39 	The Regents of the University of California.  All rights reserved.\n");
     40 #endif /* not lint */
     41 
     42 #ifndef lint
     43 #if 0
     44 static char sccsid[] = "@(#)cp.c	8.5 (Berkeley) 4/29/95";
     45 #else
     46 __RCSID("$NetBSD: cp.c,v 1.38 2005/10/15 18:22:18 christos Exp $");
     47 #endif
     48 #endif /* not lint */
     49 
     50 /*
     51  * Cp copies source files to target files.
     52  *
     53  * The global PATH_T structure "to" always contains the path to the
     54  * current target file.  Since fts(3) does not change directories,
     55  * this path can be either absolute or dot-relative.
     56  *
     57  * The basic algorithm is to initialize "to" and use fts(3) to traverse
     58  * the file hierarchy rooted in the argument list.  A trivial case is the
     59  * case of 'cp file1 file2'.  The more interesting case is the case of
     60  * 'cp file1 file2 ... fileN dir' where the hierarchy is traversed and the
     61  * path (relative to the root of the traversal) is appended to dir (stored
     62  * in "to") to form the final target path.
     63  */
     64 
     65 #include <sys/param.h>
     66 #include <sys/stat.h>
     67 
     68 #include <err.h>
     69 #include <errno.h>
     70 #include <fts.h>
     71 #include <locale.h>
     72 #include <stdlib.h>
     73 #include <stdio.h>
     74 #include <string.h>
     75 #include <unistd.h>
     76 
     77 #include "extern.h"
     78 
     79 #define	STRIP_TRAILING_SLASH(p) {					\
     80         while ((p).p_end > (p).p_path + 1 && (p).p_end[-1] == '/')	\
     81                 *--(p).p_end = '\0';					\
     82 }
     83 
     84 static char empty[] = "";
     85 PATH_T to = { to.p_path, empty };
     86 
     87 uid_t myuid;
     88 int Rflag, fflag, iflag, pflag, rflag, vflag, Nflag;
     89 mode_t myumask;
     90 
     91 enum op { FILE_TO_FILE, FILE_TO_DIR, DIR_TO_DNE };
     92 
     93 int 	main(int, char *[]);
     94 int 	copy(char *[], enum op, int);
     95 int 	mastercmp(const FTSENT **, const FTSENT **);
     96 
     97 int
     98 main(int argc, char *argv[])
     99 {
    100 	struct stat to_stat, tmp_stat;
    101 	enum op type;
    102 	int Hflag, Lflag, Pflag, ch, fts_options, r;
    103 	char *target;
    104 
    105 	(void)setlocale(LC_ALL, "");
    106 
    107 	Hflag = Lflag = Pflag = Rflag = 0;
    108 	while ((ch = getopt(argc, argv, "HLNPRfiprv")) != -1)
    109 		switch (ch) {
    110 		case 'H':
    111 			Hflag = 1;
    112 			Lflag = Pflag = 0;
    113 			break;
    114 		case 'L':
    115 			Lflag = 1;
    116 			Hflag = Pflag = 0;
    117 			break;
    118 		case 'N':
    119 			Nflag = 1;
    120 			break;
    121 		case 'P':
    122 			Pflag = 1;
    123 			Hflag = Lflag = 0;
    124 			break;
    125 		case 'R':
    126 			Rflag = 1;
    127 			break;
    128 		case 'f':
    129 			fflag = 1;
    130 			iflag = 0;
    131 			break;
    132 		case 'i':
    133 			iflag = isatty(fileno(stdin));
    134 			fflag = 0;
    135 			break;
    136 		case 'p':
    137 			pflag = 1;
    138 			break;
    139 		case 'r':
    140 			rflag = 1;
    141 			break;
    142 		case 'v':
    143 			vflag = 1;
    144 			break;
    145 		case '?':
    146 		default:
    147 			usage();
    148 			/* NOTREACHED */
    149 		}
    150 	argc -= optind;
    151 	argv += optind;
    152 
    153 	if (argc < 2)
    154 		usage();
    155 
    156 	fts_options = FTS_NOCHDIR | FTS_PHYSICAL;
    157 	if (rflag) {
    158 		if (Rflag) {
    159 			errx(EXIT_FAILURE,
    160 		    "the -R and -r options may not be specified together.");
    161 			/* NOTREACHED */
    162 		}
    163 		if (Hflag || Lflag || Pflag) {
    164 			errx(EXIT_FAILURE,
    165 	"the -H, -L, and -P options may not be specified with the -r option.");
    166 			/* NOTREACHED */
    167 		}
    168 		fts_options &= ~FTS_PHYSICAL;
    169 		fts_options |= FTS_LOGICAL;
    170 	}
    171 	if (Rflag) {
    172 		if (Hflag)
    173 			fts_options |= FTS_COMFOLLOW;
    174 		if (Lflag) {
    175 			fts_options &= ~FTS_PHYSICAL;
    176 			fts_options |= FTS_LOGICAL;
    177 		}
    178 	} else {
    179 		fts_options &= ~FTS_PHYSICAL;
    180 		fts_options |= FTS_LOGICAL | FTS_COMFOLLOW;
    181 	}
    182 
    183 	myuid = getuid();
    184 
    185 	/* Copy the umask for explicit mode setting. */
    186 	myumask = umask(0);
    187 	(void)umask(myumask);
    188 
    189 	/* Save the target base in "to". */
    190 	target = argv[--argc];
    191 	if (strlen(target) > MAXPATHLEN) {
    192 		errx(EXIT_FAILURE, "%s: name too long", target);
    193 		/* NOTREACHED */
    194 	}
    195 	(void)strcpy(to.p_path, target);
    196 	to.p_end = to.p_path + strlen(to.p_path);
    197         if (to.p_path == to.p_end) {
    198 		*to.p_end++ = '.';
    199 		*to.p_end = 0;
    200 	}
    201         STRIP_TRAILING_SLASH(to);
    202 	to.target_end = to.p_end;
    203 
    204 	/* Set end of argument list for fts(3). */
    205 	argv[argc] = NULL;
    206 
    207 	/*
    208 	 * Cp has two distinct cases:
    209 	 *
    210 	 * cp [-R] source target
    211 	 * cp [-R] source1 ... sourceN directory
    212 	 *
    213 	 * In both cases, source can be either a file or a directory.
    214 	 *
    215 	 * In (1), the target becomes a copy of the source. That is, if the
    216 	 * source is a file, the target will be a file, and likewise for
    217 	 * directories.
    218 	 *
    219 	 * In (2), the real target is not directory, but "directory/source".
    220 	 */
    221 	r = stat(to.p_path, &to_stat);
    222 	if (r == -1 && errno != ENOENT) {
    223 		err(EXIT_FAILURE, "%s", to.p_path);
    224 		/* NOTREACHED */
    225 	}
    226 	if (r == -1 || !S_ISDIR(to_stat.st_mode)) {
    227 		/*
    228 		 * Case (1).  Target is not a directory.
    229 		 */
    230 		if (argc > 1)
    231 			usage();
    232 		/*
    233 		 * Need to detect the case:
    234 		 *	cp -R dir foo
    235 		 * Where dir is a directory and foo does not exist, where
    236 		 * we want pathname concatenations turned on but not for
    237 		 * the initial mkdir().
    238 		 */
    239 		if (r == -1) {
    240 			if (rflag || (Rflag && (Lflag || Hflag)))
    241 				r = stat(*argv, &tmp_stat);
    242 			else
    243 				r = lstat(*argv, &tmp_stat);
    244 			if (r == -1) {
    245 				err(EXIT_FAILURE, "%s", *argv);
    246 				/* NOTREACHED */
    247 			}
    248 
    249 			if (S_ISDIR(tmp_stat.st_mode) && (Rflag || rflag))
    250 				type = DIR_TO_DNE;
    251 			else
    252 				type = FILE_TO_FILE;
    253 		} else
    254 			type = FILE_TO_FILE;
    255 	} else {
    256 		/*
    257 		 * Case (2).  Target is a directory.
    258 		 */
    259 		type = FILE_TO_DIR;
    260 	}
    261 
    262 	exit(copy(argv, type, fts_options));
    263 	/* NOTREACHED */
    264 }
    265 
    266 int
    267 copy(char *argv[], enum op type, int fts_options)
    268 {
    269 	struct stat to_stat;
    270 	FTS *ftsp;
    271 	FTSENT *curr;
    272 	int base, dne, rval;
    273 	size_t nlen;
    274 	char *p, *tmp;
    275 
    276 	base = 0;	/* XXX gcc -Wuninitialized (see comment below) */
    277 
    278 	if ((ftsp = fts_open(argv, fts_options, mastercmp)) == NULL)
    279 		err(EXIT_FAILURE, "%s", argv[0]);
    280 		/* NOTREACHED */
    281 	for (rval = 0; (curr = fts_read(ftsp)) != NULL;) {
    282 		switch (curr->fts_info) {
    283 		case FTS_NS:
    284 		case FTS_DNR:
    285 		case FTS_ERR:
    286 			warnx("%s: %s", curr->fts_path,
    287 					strerror(curr->fts_errno));
    288 			rval = 1;
    289 			continue;
    290 		case FTS_DC:			/* Warn, continue. */
    291 			warnx("%s: directory causes a cycle", curr->fts_path);
    292 			rval = 1;
    293 			continue;
    294 		}
    295 
    296 		/*
    297 		 * If we are in case (2) or (3) above, we need to append the
    298                  * source name to the target name.
    299                  */
    300 		if (type != FILE_TO_FILE) {
    301 			if ((curr->fts_namelen +
    302 			    to.target_end - to.p_path + 1) > MAXPATHLEN) {
    303 				warnx("%s/%s: name too long (not copied)",
    304 						to.p_path, curr->fts_name);
    305 				rval = 1;
    306 				continue;
    307 			}
    308 
    309 			/*
    310 			 * Need to remember the roots of traversals to create
    311 			 * correct pathnames.  If there's a directory being
    312 			 * copied to a non-existent directory, e.g.
    313 			 *	cp -R a/dir noexist
    314 			 * the resulting path name should be noexist/foo, not
    315 			 * noexist/dir/foo (where foo is a file in dir), which
    316 			 * is the case where the target exists.
    317 			 *
    318 			 * Also, check for "..".  This is for correct path
    319 			 * concatentation for paths ending in "..", e.g.
    320 			 *	cp -R .. /tmp
    321 			 * Paths ending in ".." are changed to ".".  This is
    322 			 * tricky, but seems the easiest way to fix the problem.
    323 			 *
    324 			 * XXX
    325 			 * Since the first level MUST be FTS_ROOTLEVEL, base
    326 			 * is always initialized.
    327 			 */
    328 			if (curr->fts_level == FTS_ROOTLEVEL) {
    329 				if (type != DIR_TO_DNE) {
    330 					p = strrchr(curr->fts_path, '/');
    331 					base = (p == NULL) ? 0 :
    332 					    (int)(p - curr->fts_path + 1);
    333 
    334 					if (!strcmp(&curr->fts_path[base],
    335 					    ".."))
    336 						base += 1;
    337 				} else
    338 					base = curr->fts_pathlen;
    339 			}
    340 
    341 			p = &curr->fts_path[base];
    342 			nlen = curr->fts_pathlen - base;
    343 
    344 			tmp = to.target_end;
    345 			if (*p != '/' && *(tmp - 1) != '/')
    346 				*tmp++ = '/';
    347 			*tmp = 0;
    348 
    349 			(void)strncat(tmp, p, nlen);
    350 			to.p_end = tmp + nlen;
    351 			*to.p_end = 0;
    352 			STRIP_TRAILING_SLASH(to);
    353 		}
    354 
    355 		/* Not an error but need to remember it happened */
    356 		if (stat(to.p_path, &to_stat) == -1)
    357 			dne = 1;
    358 		else {
    359 			if (to_stat.st_dev == curr->fts_statp->st_dev &&
    360 			    to_stat.st_ino == curr->fts_statp->st_ino) {
    361 				warnx("%s and %s are identical (not copied).",
    362 				    to.p_path, curr->fts_path);
    363 				rval = 1;
    364 				if (S_ISDIR(curr->fts_statp->st_mode))
    365 					(void)fts_set(ftsp, curr, FTS_SKIP);
    366 				continue;
    367 			}
    368 			if (!S_ISDIR(curr->fts_statp->st_mode) &&
    369 			    S_ISDIR(to_stat.st_mode)) {
    370 		warnx("cannot overwrite directory %s with non-directory %s",
    371 				    to.p_path, curr->fts_path);
    372 				rval = 1;
    373 				continue;
    374 			}
    375 			dne = 0;
    376 		}
    377 
    378 		switch (curr->fts_statp->st_mode & S_IFMT) {
    379 		case S_IFLNK:
    380 			/* Catch special case of a non dangling symlink */
    381 			if((fts_options & FTS_LOGICAL) ||
    382 			   ((fts_options & FTS_COMFOLLOW) && curr->fts_level == 0)) {
    383 				if (copy_file(curr, dne))
    384 					rval = 1;
    385 			} else {
    386 				if (copy_link(curr, !dne))
    387 					rval = 1;
    388 			}
    389 			break;
    390 		case S_IFDIR:
    391 			if (!Rflag && !rflag) {
    392 				if (curr->fts_info == FTS_D)
    393 					warnx("%s is a directory (not copied).",
    394 					    curr->fts_path);
    395 				(void)fts_set(ftsp, curr, FTS_SKIP);
    396 				rval = 1;
    397 				break;
    398 			}
    399 
    400                         /*
    401                          * Directories get noticed twice:
    402                          *  In the first pass, create it if needed.
    403                          *  In the second pass, after the children have been copied, set the permissions.
    404                          */
    405 			if (curr->fts_info == FTS_D) /* First pass */
    406 			{
    407 				/*
    408 				 * If the directory doesn't exist, create the new
    409 				 * one with the from file mode plus owner RWX bits,
    410 				 * modified by the umask.  Trade-off between being
    411 				 * able to write the directory (if from directory is
    412 				 * 555) and not causing a permissions race.  If the
    413 				 * umask blocks owner writes, we fail..
    414 				 */
    415 				if (dne) {
    416 					if (mkdir(to.p_path,
    417 					    curr->fts_statp->st_mode | S_IRWXU) < 0)
    418 						err(EXIT_FAILURE, "%s",
    419 						    to.p_path);
    420 						/* NOTREACHED */
    421 				} else if (!S_ISDIR(to_stat.st_mode)) {
    422 					errno = ENOTDIR;
    423 					err(EXIT_FAILURE, "%s",
    424 						to.p_path);
    425 					/* NOTREACHED */
    426 				}
    427 			}
    428 			else if (curr->fts_info == FTS_DP) /* Second pass */
    429 			{
    430 	                        /*
    431 				 * If not -p and directory didn't exist, set it to be
    432 				 * the same as the from directory, umodified by the
    433                         	 * umask; arguably wrong, but it's been that way
    434                         	 * forever.
    435 				 */
    436 				if (pflag && setfile(curr->fts_statp, 0))
    437 					rval = 1;
    438 				else if (dne)
    439 					(void)chmod(to.p_path,
    440 					    curr->fts_statp->st_mode);
    441 			}
    442 			else
    443                         {
    444                         	warnx("directory %s encountered when not expected.",
    445 						curr->fts_path);
    446                         	rval = 1;
    447                                 break;
    448                         }
    449 
    450 			break;
    451 		case S_IFBLK:
    452 		case S_IFCHR:
    453 			if (Rflag) {
    454 				if (copy_special(curr->fts_statp, !dne))
    455 					rval = 1;
    456 			} else
    457 				if (copy_file(curr, dne))
    458 					rval = 1;
    459 			break;
    460 		case S_IFIFO:
    461 			if (Rflag) {
    462 				if (copy_fifo(curr->fts_statp, !dne))
    463 					rval = 1;
    464 			} else
    465 				if (copy_file(curr, dne))
    466 					rval = 1;
    467 			break;
    468 		default:
    469 			if (copy_file(curr, dne))
    470 				rval = 1;
    471 			break;
    472 		}
    473 		if (vflag && !rval)
    474 			(void)printf("%s -> %s\n", curr->fts_path, to.p_path);
    475 	}
    476 	if (errno) {
    477 		err(EXIT_FAILURE, "fts_read");
    478 		/* NOTREACHED */
    479 	}
    480 	return (rval);
    481 }
    482 
    483 /*
    484  * mastercmp --
    485  *	The comparison function for the copy order.  The order is to copy
    486  *	non-directory files before directory files.  The reason for this
    487  *	is because files tend to be in the same cylinder group as their
    488  *	parent directory, whereas directories tend not to be.  Copying the
    489  *	files first reduces seeking.
    490  */
    491 int
    492 mastercmp(const FTSENT **a, const FTSENT **b)
    493 {
    494 	int a_info, b_info;
    495 
    496 	a_info = (*a)->fts_info;
    497 	if (a_info == FTS_ERR || a_info == FTS_NS || a_info == FTS_DNR)
    498 		return (0);
    499 	b_info = (*b)->fts_info;
    500 	if (b_info == FTS_ERR || b_info == FTS_NS || b_info == FTS_DNR)
    501 		return (0);
    502 	if (a_info == FTS_D)
    503 		return (-1);
    504 	if (b_info == FTS_D)
    505 		return (1);
    506 	return (0);
    507 }
    508