![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / cp|
Return to cp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / cp |
1.1 root 1: /*
2: * Copyright (c) 1988 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * David Hitz of Auspex Systems Inc.
7: *
8: * Redistribution and use in source and binary forms are permitted provided
9: * that: (1) source distributions retain this entire copyright notice and
10: * comment, and (2) distributions including binaries display the following
11: * acknowledgement: ``This product includes software developed by the
12: * University of California, Berkeley and its contributors'' in the
13: * documentation or other materials provided with the distribution and in
14: * all advertising materials mentioning features or use of this software.
15: * Neither the name of the University nor the names of its contributors may
16: * be used to endorse or promote products derived from this software without
17: * specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: char copyright[] =
25: "@(#) Copyright (c) 1988 The Regents of the University of California.\n\
26: All rights reserved.\n";
27: #endif /* not lint */
28:
29: #ifndef lint
30: static char sccsid[] = "@(#)cp.c 5.20 (Berkeley) 6/29/90";
31: #endif /* not lint */
32:
33: /*
34: * cp copies source files to target files.
35: *
36: * The global PATH_T structures "to" and "from" always contain paths to the
37: * current source and target files, respectively. Since cp does not change
38: * directories, these paths can be either absolute or dot-realative.
39: *
40: * The basic algorithm is to initialize "to" and "from", and then call the
41: * recursive copy() function to do the actual work. If "from" is a file,
42: * copy copies the data. If "from" is a directory, copy creates the
43: * corresponding "to" directory, and calls itself recursively on all of
44: * the entries in the "from" directory.
45: */
46:
47: #include <sys/param.h>
48: #include <sys/stat.h>
49: #include <sys/file.h>
50: #include <sys/dir.h>
51: #include <sys/time.h>
52: #include <stdio.h>
53: #include <errno.h>
54: #include <stdlib.h>
55: #include <string.h>
56:
57: #define type(st) ((st).st_mode & S_IFMT)
58:
59: typedef struct {
60: char p_path[MAXPATHLEN + 1]; /* pointer to the start of a path. */
61: char *p_end; /* pointer to NULL at end of path. */
62: } PATH_T;
63:
64: PATH_T from = { "", from.p_path };
65: PATH_T to = { "", to.p_path };
66:
67: uid_t myuid;
68: int exit_val, myumask;
69: int iflag, pflag, orflag, rflag;
70: int (*statfcn)();
71: char *buf, *pname;
72: char *path_append(), *path_basename();
73:
74: main(argc, argv)
75: int argc;
76: char **argv;
77: {
78: extern int optind;
79: struct stat to_stat;
80: register int c, r;
81: int symfollow, lstat(), stat();
82: char *old_to, *p;
83:
84: /*
85: * cp is used by mv(1) -- except for usage statements, print
86: * the "called as" program name.
87: */
88: pname = (p = rindex(*argv,'/')) ? ++p : *argv;
89:
90: symfollow = 0;
91: while ((c = getopt(argc, argv, "Rfhipr")) != EOF) {
92: switch ((char)c) {
93: case 'f':
94: iflag = 0;
95: break;
96: case 'h':
97: symfollow = 1;
98: break;
99: case 'i':
100: iflag = isatty(fileno(stdin));
101: break;
102: case 'p':
103: pflag = 1;
104: break;
105: case 'R':
106: rflag = 1;
107: break;
108: case 'r':
109: orflag = 1;
110: break;
111: case '?':
112: default:
113: usage();
114: break;
115: }
116: }
117: argc -= optind;
118: argv += optind;
119:
120: if (argc < 2)
121: usage();
122:
123: if (rflag && orflag) {
124: (void)fprintf(stderr,
125: "cp: the -R and -r options are mutually exclusive.\n");
126: exit(1);
127: }
128:
129: buf = (char *)malloc(MAXBSIZE);
130: if (!buf) {
131: (void)fprintf(stderr, "%s: out of space.\n", pname);
132: exit(1);
133: }
134:
135: myuid = getuid();
136:
137: /* copy the umask for explicit mode setting */
138: myumask = umask(0);
139: (void)umask(myumask);
140:
141: /* consume last argument first. */
142: if (!path_set(&to, argv[--argc]))
143: exit(exit_val);
144:
145: statfcn = symfollow || !rflag ? stat : lstat;
146:
147: /*
148: * Cp has two distinct cases:
149: *
150: * Case (1) $ cp [-rip] source target
151: *
152: * Case (2) $ cp [-rip] source1 ... directory
153: *
154: * In both cases, source can be either a file or a directory.
155: *
156: * In (1), the target becomes a copy of the source. That is, if the
157: * source is a file, the target will be a file, and likewise for
158: * directories.
159: *
160: * In (2), the real target is not directory, but "directory/source".
161: */
162:
163: r = stat(to.p_path, &to_stat);
164: if (r == -1 && errno != ENOENT) {
165: error(to.p_path);
166: exit(1);
167: }
168: if (r == -1 || type(to_stat) != S_IFDIR) {
169: /*
170: * Case (1). Target is not a directory.
171: */
172: if (argc > 1) {
173: usage();
174: exit(1);
175: }
176: if (!path_set(&from, *argv))
177: exit(exit_val);
178: copy();
179: }
180: else {
181: /*
182: * Case (2). Target is a directory.
183: */
184: for (;; ++argv) {
185: if (!path_set(&from, *argv))
186: continue;
187: old_to = path_append(&to, path_basename(&from), -1);
188: if (!old_to)
189: continue;
190: copy();
191: if (!--argc)
192: break;
193: path_restore(&to, old_to);
194: }
195: }
196: exit(exit_val);
197: }
198:
199: /* copy file or directory at "from" to "to". */
200: copy()
201: {
202: struct stat from_stat, to_stat;
203: int dne, statval;
204:
205: statval = statfcn(from.p_path, &from_stat);
206: if (statval == -1) {
207: error(from.p_path);
208: return;
209: }
210:
211: /* not an error, but need to remember it happened */
212: if (stat(to.p_path, &to_stat) == -1)
213: dne = 1;
214: else {
215: if (to_stat.st_dev == from_stat.st_dev &&
216: to_stat.st_ino == from_stat.st_ino) {
217: (void)fprintf(stderr,
218: "%s: %s and %s are identical (not copied).\n",
219: pname, to.p_path, from.p_path);
220: exit_val = 1;
221: return;
222: }
223: dne = 0;
224: }
225:
226: switch(type(from_stat)) {
227: case S_IFLNK:
228: copy_link(!dne);
229: return;
230: case S_IFDIR:
231: if (!rflag && !orflag) {
232: (void)fprintf(stderr,
233: "%s: %s is a directory (not copied).\n",
234: pname, from.p_path);
235: exit_val = 1;
236: return;
237: }
238: if (dne) {
239: /*
240: * If the directory doesn't exist, create the new
241: * one with the from file mode plus owner RWX bits,
242: * modified by the umask. Trade-off between being
243: * able to write the directory (if from directory is
244: * 555) and not causing a permissions race. If the
245: * umask blocks owner writes cp fails.
246: */
247: if (mkdir(to.p_path, from_stat.st_mode|S_IRWXU) < 0) {
248: error(to.p_path);
249: return;
250: }
251: }
252: else if (type(to_stat) != S_IFDIR) {
253: (void)fprintf(stderr, "%s: %s: not a directory.\n",
254: pname, to.p_path);
255: return;
256: }
257: copy_dir();
258: /*
259: * If not -p and directory didn't exist, set it to be the
260: * same as the from directory, umodified by the umask;
261: * arguably wrong, but it's been that way forever.
262: */
263: if (pflag)
264: setfile(&from_stat, 0);
265: else if (dne)
266: (void)chmod(to.p_path, from_stat.st_mode);
267: return;
268: case S_IFCHR:
269: case S_IFBLK:
270: if (rflag) {
271: copy_special(&from_stat, !dne);
272: return;
273: }
274: break;
275: case S_IFIFO:
276: if (rflag) {
277: copy_fifo(&from_stat, !dne);
278: return;
279: }
280: break;
281: }
282: copy_file(&from_stat, dne);
283: }
284:
285: copy_file(fs, dne)
286: struct stat *fs;
287: int dne;
288: {
289: register int from_fd, to_fd, rcount, wcount;
290: struct stat to_stat;
291:
292: if ((from_fd = open(from.p_path, O_RDONLY, 0)) == -1) {
293: error(from.p_path);
294: return;
295: }
296:
297: /*
298: * If the file exists and we're interactive, verify with the user.
299: * If the file DNE, set the mode to be the from file, minus setuid
300: * bits, modified by the umask; arguably wrong, but it makes copying
301: * executables work right and it's been that way forever. (The
302: * other choice is 666 or'ed with the execute bits on the from file
303: * modified by the umask.)
304: */
305: if (!dne) {
306: if (iflag) {
307: int checkch, ch;
308:
309: (void)fprintf(stderr, "overwrite %s? ", to.p_path);
310: checkch = ch = getchar();
311: while (ch != '\n' && ch != EOF)
312: ch = getchar();
313: if (checkch != 'y') {
314: (void)close(from_fd);
315: return;
316: }
317: }
318: to_fd = open(to.p_path, O_WRONLY|O_TRUNC, 0);
319: } else
320: to_fd = open(to.p_path, O_WRONLY|O_CREAT|O_TRUNC,
321: fs->st_mode & ~(S_ISUID|S_ISGID));
322:
323: if (to_fd == -1) {
324: error(to.p_path);
325: (void)close(from_fd);
326: return;
327: }
328:
329: while ((rcount = read(from_fd, buf, MAXBSIZE)) > 0) {
330: wcount = write(to_fd, buf, rcount);
331: if (rcount != wcount || wcount == -1) {
332: error(to.p_path);
333: break;
334: }
335: }
336: if (rcount < 0)
337: error(from.p_path);
338: if (pflag)
339: setfile(fs, to_fd);
340: /*
341: * If the source was setuid or setgid, lose the bits unless the
342: * copy is owned by the same user and group.
343: */
344: else if (fs->st_mode & (S_ISUID|S_ISGID) && fs->st_uid == myuid)
345: if (fstat(to_fd, &to_stat))
346: error(to.p_path);
347: #define RETAINBITS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
348: else if (fs->st_gid == to_stat.st_gid && fchmod(to_fd,
349: fs->st_mode & RETAINBITS & ~myumask))
350: error(to.p_path);
351: (void)close(from_fd);
352: (void)close(to_fd);
353: }
354:
355: copy_dir()
356: {
357: struct stat from_stat;
358: struct direct *dp, **dir_list;
359: register int dir_cnt, i;
360: char *old_from, *old_to;
361:
362: dir_cnt = scandir(from.p_path, &dir_list, NULL, NULL);
363: if (dir_cnt == -1) {
364: (void)fprintf(stderr, "%s: can't read directory %s.\n",
365: pname, from.p_path);
366: exit_val = 1;
367: }
368:
369: /*
370: * Instead of handling directory entries in the order they appear
371: * on disk, do non-directory files before directory files.
372: * There are two reasons to do directories last. The first is
373: * efficiency. Files tend to be in the same cylinder group as
374: * their parent, whereas directories tend not to be. Copying files
375: * all at once reduces seeking. Second, deeply nested tree's
376: * could use up all the file descriptors if we didn't close one
377: * directory before recursivly starting on the next.
378: */
379: /* copy files */
380: for (i = 0; i < dir_cnt; ++i) {
381: dp = dir_list[i];
382: if (dp->d_namlen <= 2 && dp->d_name[0] == '.'
383: && (dp->d_name[1] == NULL || dp->d_name[1] == '.'))
384: goto done;
385: old_from = path_append(&from, dp->d_name, (int)dp->d_namlen);
386: if (!old_from)
387: goto done;
388:
389: if (statfcn(from.p_path, &from_stat) < 0) {
390: error(dp->d_name);
391: path_restore(&from, old_from);
392: goto done;
393: }
394: if (type(from_stat) == S_IFDIR) {
395: path_restore(&from, old_from);
396: continue;
397: }
398: old_to = path_append(&to, dp->d_name, (int)dp->d_namlen);
399: if (old_to) {
400: copy();
401: path_restore(&to, old_to);
402: }
403: path_restore(&from, old_from);
404: done: dir_list[i] = NULL;
405: (void)free((void *)dp);
406: }
407:
408: /* copy directories */
409: for (i = 0; i < dir_cnt; ++i) {
410: dp = dir_list[i];
411: if (!dp)
412: continue;
413: old_from = path_append(&from, dp->d_name, (int) dp->d_namlen);
414: if (!old_from) {
415: (void)free((void *)dp);
416: continue;
417: }
418: old_to = path_append(&to, dp->d_name, (int) dp->d_namlen);
419: if (!old_to) {
420: (void)free((void *)dp);
421: path_restore(&from, old_from);
422: continue;
423: }
424: copy();
425: free((void *)dp);
426: path_restore(&from, old_from);
427: path_restore(&to, old_to);
428: }
429: free((void *)dir_list);
430: }
431:
432: copy_link(exists)
433: int exists;
434: {
435: int len;
436: char link[MAXPATHLEN];
437:
438: if ((len = readlink(from.p_path, link, sizeof(link))) == -1) {
439: error(from.p_path);
440: return;
441: }
442: link[len] = '\0';
443: if (exists && unlink(to.p_path)) {
444: error(to.p_path);
445: return;
446: }
447: if (symlink(link, to.p_path)) {
448: error(link);
449: return;
450: }
451: }
452:
453: copy_fifo(from_stat, exists)
454: struct stat *from_stat;
455: int exists;
456: {
457: if (exists && unlink(to.p_path)) {
458: error(to.p_path);
459: return;
460: }
461: if (mkfifo(to.p_path, from_stat->st_mode)) {
462: error(to.p_path);
463: return;
464: }
465: if (pflag)
466: setfile(from_stat, 0);
467: }
468:
469: copy_special(from_stat, exists)
470: struct stat *from_stat;
471: int exists;
472: {
473: if (exists && unlink(to.p_path)) {
474: error(to.p_path);
475: return;
476: }
477: if (mknod(to.p_path, from_stat->st_mode, from_stat->st_rdev)) {
478: error(to.p_path);
479: return;
480: }
481: if (pflag)
482: setfile(from_stat, 0);
483: }
484:
485: setfile(fs, fd)
486: register struct stat *fs;
487: int fd;
488: {
489: static struct timeval tv[2];
490:
491: fs->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
492:
493: tv[0].tv_sec = fs->st_atime;
494: tv[1].tv_sec = fs->st_mtime;
495: if (utimes(to.p_path, tv))
496: error(to.p_path);
497: /*
498: * Changing the ownership probably won't succeed, unless we're root
499: * or POSIX_CHOWN_RESTRICTED is not set. Set uid/gid before setting
500: * the mode; current BSD behavior is to remove all setuid bits on
501: * chown. If chown fails, lose setuid/setgid bits.
502: */
503: if (fd ? fchown(fd, fs->st_uid, fs->st_gid) :
504: chown(to.p_path, fs->st_uid, fs->st_gid)) {
505: if (errno != EPERM)
506: error(to.p_path);
507: fs->st_mode &= ~(S_ISUID|S_ISGID);
508: }
509: if (fd ? fchmod(fd, fs->st_mode) : chmod(to.p_path, fs->st_mode))
510: error(to.p_path);
511: }
512:
513: ismember(gid)
514: gid_t gid;
515: {
516: register int cnt;
517: static int ngroups, groups[NGROUPS];
518:
519: if (!ngroups) {
520: ngroups = getgroups(NGROUPS, groups);
521: if (ngroups == -1) {
522: ngroups = 0;
523: exit_val = 1;
524: (void)fprintf(stderr, "%s: %s\n",
525: pname, strerror(errno));
526: return(0);
527: }
528: }
529: for (cnt = ngroups; cnt--;)
530: if (gid == groups[cnt])
531: return(1);
532: return(0);
533: }
534:
535: error(s)
536: char *s;
537: {
538: exit_val = 1;
539: (void)fprintf(stderr, "%s: %s: %s\n", pname, s, strerror(errno));
540: }
541:
542: /********************************************************************
543: * Path Manipulation Routines.
544: ********************************************************************/
545:
546: /*
547: * These functions manipulate paths in PATH_T structures.
548: *
549: * They eliminate multiple slashes in paths when they notice them, and keep
550: * the path non-slash terminated.
551: *
552: * Both path_set() and path_append() return 0 if the requested name
553: * would be too long.
554: */
555:
556: #define STRIP_TRAILING_SLASH(p) { \
557: while ((p)->p_end > (p)->p_path && (p)->p_end[-1] == '/') \
558: *--(p)->p_end = 0; \
559: }
560:
561: /*
562: * Move specified string into path. Convert "" to "." to handle BSD
563: * semantics for a null path. Strip trailing slashes.
564: */
565: path_set(p, string)
566: register PATH_T *p;
567: char *string;
568: {
569: if (strlen(string) > MAXPATHLEN) {
570: (void)fprintf(stderr, "%s: %s: name too long.\n",
571: pname, string);
572: exit_val = 1;
573: return(0);
574: }
575:
576: (void)strcpy(p->p_path, string);
577: p->p_end = p->p_path + strlen(p->p_path);
578:
579: if (p->p_path == p->p_end) {
580: *p->p_end++ = '.';
581: *p->p_end = 0;
582: }
583:
584: STRIP_TRAILING_SLASH(p);
585: return(1);
586: }
587:
588: /*
589: * Append specified string to path, inserting '/' if necessary. Return a
590: * pointer to the old end of path for restoration.
591: */
592: char *
593: path_append(p, name, len)
594: register PATH_T *p;
595: char *name;
596: int len;
597: {
598: char *old;
599:
600: old = p->p_end;
601: if (len == -1)
602: len = strlen(name);
603:
604: /*
605: * The final "+ 1" accounts for the '/' between old path and name.
606: */
607: if ((len + p->p_end - p->p_path + 1) > MAXPATHLEN) {
608: (void)fprintf(stderr,
609: "%s: %s/%s: name too long.\n", pname, p->p_path, name);
610: exit_val = 1;
611: return(0);
612: }
613:
614: /*
615: * This code should always be executed, since paths shouldn't
616: * end in '/'.
617: */
618: if (p->p_end[-1] != '/') {
619: *p->p_end++ = '/';
620: *p->p_end = 0;
621: }
622:
623: (void)strncat(p->p_end, name, len);
624: p->p_end += len;
625: *p->p_end = 0;
626:
627: STRIP_TRAILING_SLASH(p);
628: return(old);
629: }
630:
631: /*
632: * Restore path to previous value. (As returned by path_append.)
633: */
634: path_restore(p, old)
635: PATH_T *p;
636: char *old;
637: {
638: p->p_end = old;
639: *p->p_end = 0;
640: }
641:
642: /*
643: * Return basename of path. (Like basename(1).)
644: */
645: char *
646: path_basename(p)
647: PATH_T *p;
648: {
649: char *basename;
650:
651: basename = rindex(p->p_path, '/');
652: return(basename ? ++basename : p->p_path);
653: }
654:
655: usage()
656: {
657: (void)fprintf(stderr,
658: "usage: cp [-Rfhip] src target;\n or: cp [-Rfhip] src1 ... srcN directory\n");
659: exit(1);
660: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.