[apple/file_cmds.git] / cp / utils.c

/*	$NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $	*/

/*-
 * Copyright (c) 1991, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)utils.c	8.3 (Berkeley) 4/1/94";
#else
__RCSID("$NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $");
#endif
#endif /* not lint */

#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/time.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <fts.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "extern.h"

int
set_utimes(file, fs)
	const char * file;
	struct stat * fs;
{
    static struct timeval tv[2];

    TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);
    TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);

    if (utimes(file, tv)) {
	warn("utimes: %s", file);
	return (1);
    }
    return (0);
}

int
copy_file(entp, dne)
	FTSENT *entp;
	int dne;
{
	static char buf[MAXBSIZE];
	struct stat to_stat, *fs;
	int ch, checkch, from_fd, rcount, rval, to_fd, wcount;
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
	char *p;
#endif
	
	if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
		warn("%s", entp->fts_path);
		return (1);
	}

	fs = entp->fts_statp;

	/*
	 * If the file exists and we're interactive, verify with the user.
	 * If the file DNE, set the mode to be the from file, minus setuid
	 * bits, modified by the umask; arguably wrong, but it makes copying
	 * executables work right and it's been that way forever.  (The
	 * other choice is 666 or'ed with the execute bits on the from file
	 * modified by the umask.)
	 */
	if (!dne) {
		if (iflag) {
			(void)fprintf(stderr, "overwrite %s? ", to.p_path);
			checkch = ch = getchar();
			while (ch != '\n' && ch != EOF)
				ch = getchar();
			if (checkch != 'y' && checkch != 'Y') {
				(void)close(from_fd);
				return (0);
			}
		}
		/* overwrite existing destination file name */
		to_fd = open(to.p_path, O_WRONLY | O_TRUNC, 0);
	} else
		to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
		    fs->st_mode & ~(S_ISUID | S_ISGID));

	if (to_fd == -1 && fflag) {
		/*
		 * attempt to remove existing destination file name and
		 * create a new file
		 */
		(void)unlink(to.p_path);
		to_fd = open(to.p_path, O_WRONLY | O_TRUNC | O_CREAT,
			     fs->st_mode & ~(S_ISUID | S_ISGID));
	}

	if (to_fd == -1) {
		warn("%s", to.p_path);
		(void)close(from_fd);
		return (1);;
	}

	rval = 0;

	/*
	 * There's no reason to do anything other than close the file
	 * now if it's empty, so let's not bother.
	 */
	if (fs->st_size > 0) {
		/*
		 * Mmap and write if less than 8M (the limit is so we don't totally
		 * trash memory on big files).  This is really a minor hack, but it
		 * wins some CPU back.
		 */
#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
		if (fs->st_size <= 8 * 1048576) {
			if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
			    MAP_FILE|MAP_SHARED, from_fd, (off_t)0)) == (char *)-1) {
				warn("%s", entp->fts_path);
				rval = 1;
			} else {
				if (write(to_fd, p, fs->st_size) != fs->st_size) {
					warn("%s", to.p_path);
					rval = 1;
				}
				/* Some systems don't unmap on close(2). */
				if (munmap(p, fs->st_size) < 0) {
					warn("%s", entp->fts_path);
					rval = 1;
				}
			}
		} else
#endif
		{
			while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
				wcount = write(to_fd, buf, rcount);
				if (rcount != wcount || wcount == -1) {
					warn("%s", to.p_path);
					rval = 1;
					break;
				}
			}
			if (rcount < 0) {
				warn("%s", entp->fts_path);
				rval = 1;
			}
		}
	}

	if (rval == 1) {
		(void)close(from_fd);
		(void)close(to_fd);
		return (1);
	}

	if (pflag && setfile(fs, to_fd))
		rval = 1;
	/*
	 * If the source was setuid or setgid, lose the bits unless the
	 * copy is owned by the same user and group.
	 */
#define	RETAINBITS \
	(S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
	else if (fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {
		if (fstat(to_fd, &to_stat)) {
			warn("%s", to.p_path);
			rval = 1;
		} else if (fs->st_gid == to_stat.st_gid &&
		    fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {
			warn("%s", to.p_path);
			rval = 1;
		}
	}
	(void)close(from_fd);
	if (close(to_fd)) {
		warn("%s", to.p_path);
		rval = 1;
	}
	/* set the mod/access times now after close of the fd */
	if (pflag && set_utimes(to.p_path, fs)) { 
	    rval = 1;
	}
	return (rval);
}

int
copy_link(p, exists)
	FTSENT *p;
	int exists;
{
	int len;
	char target[MAXPATHLEN];

	if ((len = readlink(p->fts_path, target, sizeof(target))) == -1) {
		warn("readlink: %s", p->fts_path);
		return (1);
	}
	target[len] = '\0';
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (symlink(target, to.p_path)) {
		warn("symlink: %s", target);
		return (1);
	}
	return (pflag ? setfile(p->fts_statp, 0) : 0);
}

int
copy_fifo(from_stat, exists)
	struct stat *from_stat;
	int exists;
{
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (mkfifo(to.p_path, from_stat->st_mode)) {
		warn("mkfifo: %s", to.p_path);
		return (1);
	}
	return (pflag ? setfile(from_stat, 0) : 0);
}

int
copy_special(from_stat, exists)
	struct stat *from_stat;
	int exists;
{
	if (exists && unlink(to.p_path)) {
		warn("unlink: %s", to.p_path);
		return (1);
	}
	if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
		warn("mknod: %s", to.p_path);
		return (1);
	}
	return (pflag ? setfile(from_stat, 0) : 0);
}


/*
 * Function: setfile
 *
 * Purpose:
 *   Set the owner/group/permissions for the "to" file to the information
 *   in the stat structure.  If fd is zero, also call set_utimes() to set
 *   the mod/access times.  If fd is non-zero, the caller must do a utimes
 *   itself after close(fd).
 */
int
setfile(fs, fd)
	struct stat *fs;
	int fd;
{
	int rval, islink;

	rval = 0;
	islink = S_ISLNK(fs->st_mode);
	fs->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;

	/*
	 * Changing the ownership probably won't succeed, unless we're root
	 * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid before setting
	 * the mode; current BSD behavior is to remove all setuid bits on
	 * chown.  If chown fails, lose setuid/setgid bits.
	 */
	if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
#ifdef __APPLE__
	    chown(to.p_path, fs->st_uid, fs->st_gid)) {
#else
	    lchown(to.p_path, fs->st_uid, fs->st_gid)) {
#endif
		if (errno != EPERM) {
			warn("chown: %s", to.p_path);
			rval = 1;
		}
		fs->st_mode &= ~(S_ISUID | S_ISGID);
	}
#ifdef __APPLE__
	if (fd ? fchmod(fd, fs->st_mode) : chmod(to.p_path, fs->st_mode)) {
#else
	if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {
#endif
		warn("chmod: %s", to.p_path);
		rval = 1;
	}

	if (!islink) {
		/*
		 * XXX
		 * NFS doesn't support chflags; ignore errors unless
		 * there's reason to believe we're losing bits.
		 * (Note, this still won't be right if the server
		 * supports flags and we were trying to *remove* flags
		 * on a file that we copied, i.e., that we didn't create.)
		 */
		errno = 0;
		if (fd ? fchflags(fd, fs->st_flags) :
		    chflags(to.p_path, fs->st_flags))
			if (errno != EOPNOTSUPP || fs->st_flags != 0) {
				warn("chflags: %s", to.p_path);
				rval = 1;
			}
	}
	/* if fd is non-zero, caller must call set_utimes() after close() */
	if (fd == 0 && set_utimes(to.p_path, fs))
	    rval = 1;
	return (rval);
}

void
usage()
{
	(void)fprintf(stderr, "%s\n%s\n",
	    "usage: cp [-R [-H | -L | -P]] [-f | -i] [-p] src target",
	    "       cp [-R [-H | -L | -P]] [-f | -i] [-p] src1 ... srcN directory");
	exit(1);
	/* NOTREACHED */
}
Commit	Line	Data
44a7a5ab A	1	/* $NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $ */
	2
	3	/*-
	4	* Copyright (c) 1991, 1993, 1994
	5	* The Regents of the University of California. All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	* 1. Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* 2. Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in the
	14	* documentation and/or other materials provided with the distribution.
	15	* 3. All advertising materials mentioning features or use of this software
	16	* must display the following acknowledgement:
	17	* This product includes software developed by the University of
	18	* California, Berkeley and its contributors.
	19	* 4. Neither the name of the University nor the names of its contributors
	20	* may be used to endorse or promote products derived from this software
	21	* without specific prior written permission.
	22	*
	23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	33	* SUCH DAMAGE.
	34	*/
	35
	36	#include <sys/cdefs.h>
	37	#ifndef lint
	38	#if 0
	39	static char sccsid[] = "@(#)utils.c 8.3 (Berkeley) 4/1/94";
	40	#else
	41	__RCSID("$NetBSD: utils.c,v 1.15 1998/08/19 01:29:11 thorpej Exp $");
	42	#endif
	43	#endif /* not lint */
	44
	45	#include <sys/param.h>
	46	#include <sys/stat.h>
	47	#include <sys/mman.h>
	48	#include <sys/time.h>
	49
	50	#include <err.h>
	51	#include <errno.h>
	52	#include <fcntl.h>
	53	#include <fts.h>
	54	#include <stdio.h>
	55	#include <stdlib.h>
	56	#include <string.h>
	57	#include <unistd.h>
	58
	59	#include "extern.h"
	60
	61	int
	62	set_utimes(file, fs)
	63	const char * file;
	64	struct stat * fs;
65	{
66	static struct timeval tv[2];
67
68	TIMESPEC_TO_TIMEVAL(&tv[0], &fs->st_atimespec);
69	TIMESPEC_TO_TIMEVAL(&tv[1], &fs->st_mtimespec);
70
71	if (utimes(file, tv)) {
72	warn("utimes: %s", file);
73	return (1);
74	}
75	return (0);
76	}
77
78	int
79	copy_file(entp, dne)
80	FTSENT *entp;
81	int dne;
82	{
83	static char buf[MAXBSIZE];
84	struct stat to_stat, *fs;
85	int ch, checkch, from_fd, rcount, rval, to_fd, wcount;
86	#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
87	char *p;
88	#endif
89
90	if ((from_fd = open(entp->fts_path, O_RDONLY, 0)) == -1) {
91	warn("%s", entp->fts_path);
92	return (1);
93	}
94
95	fs = entp->fts_statp;
96
97	/*
98	* If the file exists and we're interactive, verify with the user.
99	* If the file DNE, set the mode to be the from file, minus setuid
100	* bits, modified by the umask; arguably wrong, but it makes copying
101	* executables work right and it's been that way forever. (The
102	* other choice is 666 or'ed with the execute bits on the from file
103	* modified by the umask.)
104	*/
105	if (!dne) {
106	if (iflag) {
107	(void)fprintf(stderr, "overwrite %s? ", to.p_path);
108	checkch = ch = getchar();
109	while (ch != '\n' && ch != EOF)
110	ch = getchar();
111	if (checkch != 'y' && checkch != 'Y') {
112	(void)close(from_fd);
113	return (0);
114	}
115	}
116	/* overwrite existing destination file name */
117	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC, 0);
118	} else
119	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC \| O_CREAT,
120	fs->st_mode & ~(S_ISUID \| S_ISGID));
121
122	if (to_fd == -1 && fflag) {
123	/*
124	* attempt to remove existing destination file name and
125	* create a new file
126	*/
127	(void)unlink(to.p_path);
128	to_fd = open(to.p_path, O_WRONLY \| O_TRUNC \| O_CREAT,
129	fs->st_mode & ~(S_ISUID \| S_ISGID));
130	}
131
132	if (to_fd == -1) {
133	warn("%s", to.p_path);
134	(void)close(from_fd);
135	return (1);;
136	}
137
138	rval = 0;
139
140	/*
141	* There's no reason to do anything other than close the file
142	* now if it's empty, so let's not bother.
143	*/
144	if (fs->st_size > 0) {
145	/*
146	* Mmap and write if less than 8M (the limit is so we don't totally
147	* trash memory on big files). This is really a minor hack, but it
148	* wins some CPU back.
149	*/
150	#ifdef VM_AND_BUFFER_CACHE_SYNCHRONIZED
151	if (fs->st_size <= 8 * 1048576) {
152	if ((p = mmap(NULL, (size_t)fs->st_size, PROT_READ,
153	MAP_FILE\|MAP_SHARED, from_fd, (off_t)0)) == (char *)-1) {
154	warn("%s", entp->fts_path);
155	rval = 1;
156	} else {
157	if (write(to_fd, p, fs->st_size) != fs->st_size) {
158	warn("%s", to.p_path);
159	rval = 1;
160	}
161	/* Some systems don't unmap on close(2). */
162	if (munmap(p, fs->st_size) < 0) {
163	warn("%s", entp->fts_path);
164	rval = 1;
165	}
166	}
167	} else
168	#endif
169	{
170	while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
171	wcount = write(to_fd, buf, rcount);
172	if (rcount != wcount \|\| wcount == -1) {
173	warn("%s", to.p_path);
174	rval = 1;
175	break;
176	}
177	}
178	if (rcount < 0) {
179	warn("%s", entp->fts_path);
180	rval = 1;
181	}
182	}
183	}
184
185	if (rval == 1) {
186	(void)close(from_fd);
187	(void)close(to_fd);
188	return (1);
189	}
190
191	if (pflag && setfile(fs, to_fd))
192	rval = 1;
193	/*
194	* If the source was setuid or setgid, lose the bits unless the
195	* copy is owned by the same user and group.
196	*/
197	#define RETAINBITS \
198	(S_ISUID \| S_ISGID \| S_ISVTX \| S_IRWXU \| S_IRWXG \| S_IRWXO)
199	else if (fs->st_mode & (S_ISUID \| S_ISGID) && fs->st_uid == myuid) {
200	if (fstat(to_fd, &to_stat)) {
201	warn("%s", to.p_path);
202	rval = 1;
203	} else if (fs->st_gid == to_stat.st_gid &&
204	fchmod(to_fd, fs->st_mode & RETAINBITS & ~myumask)) {
205	warn("%s", to.p_path);
206	rval = 1;
207	}
208	}
209	(void)close(from_fd);
210	if (close(to_fd)) {
211	warn("%s", to.p_path);
212	rval = 1;
213	}
214	/* set the mod/access times now after close of the fd */
215	if (pflag && set_utimes(to.p_path, fs)) {
216	rval = 1;
217	}
218	return (rval);
219	}
220
221	int
222	copy_link(p, exists)
223	FTSENT *p;
224	int exists;
225	{
226	int len;
227	char target[MAXPATHLEN];
228
229	if ((len = readlink(p->fts_path, target, sizeof(target))) == -1) {
230	warn("readlink: %s", p->fts_path);
231	return (1);
232	}
233	target[len] = '\0';
234	if (exists && unlink(to.p_path)) {
235	warn("unlink: %s", to.p_path);
236	return (1);
237	}
238	if (symlink(target, to.p_path)) {
239	warn("symlink: %s", target);
240	return (1);
241	}
242	return (pflag ? setfile(p->fts_statp, 0) : 0);
243	}
244
245	int
246	copy_fifo(from_stat, exists)
247	struct stat *from_stat;
248	int exists;
249	{
250	if (exists && unlink(to.p_path)) {
251	warn("unlink: %s", to.p_path);
252	return (1);
253	}
254	if (mkfifo(to.p_path, from_stat->st_mode)) {
255	warn("mkfifo: %s", to.p_path);
256	return (1);
257	}
258	return (pflag ? setfile(from_stat, 0) : 0);
259	}
260
261	int
262	copy_special(from_stat, exists)
263	struct stat *from_stat;
264	int exists;
265	{
266	if (exists && unlink(to.p_path)) {
267	warn("unlink: %s", to.p_path);
268	return (1);
269	}
270	if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
271	warn("mknod: %s", to.p_path);
272	return (1);
273	}
274	return (pflag ? setfile(from_stat, 0) : 0);
275	}
276
277
278	/*
279	* Function: setfile
280	*
281	* Purpose:
282	* Set the owner/group/permissions for the "to" file to the information
283	* in the stat structure. If fd is zero, also call set_utimes() to set
284	* the mod/access times. If fd is non-zero, the caller must do a utimes
285	* itself after close(fd).
286	*/
287	int
288	setfile(fs, fd)
289	struct stat *fs;
290	int fd;
291	{
292	int rval, islink;
293
294	rval = 0;
295	islink = S_ISLNK(fs->st_mode);
296	fs->st_mode &= S_ISUID \| S_ISGID \| S_IRWXU \| S_IRWXG \| S_IRWXO;
297
298	/*
299	* Changing the ownership probably won't succeed, unless we're root
300	* or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
301	* the mode; current BSD behavior is to remove all setuid bits on
302	* chown. If chown fails, lose setuid/setgid bits.
303	*/
304	if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
305	#ifdef __APPLE__
306	chown(to.p_path, fs->st_uid, fs->st_gid)) {
307	#else
308	lchown(to.p_path, fs->st_uid, fs->st_gid)) {
309	#endif
310	if (errno != EPERM) {
311	warn("chown: %s", to.p_path);
312	rval = 1;
313	}
314	fs->st_mode &= ~(S_ISUID \| S_ISGID);
315	}
316	#ifdef __APPLE__
317	if (fd ? fchmod(fd, fs->st_mode) : chmod(to.p_path, fs->st_mode)) {
318	#else
319	if (fd ? fchmod(fd, fs->st_mode) : lchmod(to.p_path, fs->st_mode)) {
320	#endif
321	warn("chmod: %s", to.p_path);
322	rval = 1;
323	}
324
325	if (!islink) {
326	/*
327	* XXX
328	* NFS doesn't support chflags; ignore errors unless
329	* there's reason to believe we're losing bits.
330	* (Note, this still won't be right if the server
331	* supports flags and we were trying to remove flags
332	* on a file that we copied, i.e., that we didn't create.)
333	*/
334	errno = 0;
335	if (fd ? fchflags(fd, fs->st_flags) :
336	chflags(to.p_path, fs->st_flags))
337	if (errno != EOPNOTSUPP \|\| fs->st_flags != 0) {
338	warn("chflags: %s", to.p_path);
339	rval = 1;
340	}
341	}
342	/* if fd is non-zero, caller must call set_utimes() after close() */
343	if (fd == 0 && set_utimes(to.p_path, fs))
344	rval = 1;
345	return (rval);
346	}
347
348	void
349	usage()
350	{
351	(void)fprintf(stderr, "%s\n%s\n",
352	"usage: cp [-R [-H \| -L \| -P]] [-f \| -i] [-p] src target",
353	" cp [-R [-H \| -L \| -P]] [-f \| -i] [-p] src1 ... srcN directory");
354	exit(1);
355	/* NOTREACHED */
356	}