![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reccp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd|
Return to reccp.c CVS log | Up to [Research Unix] / researchv9 / cmd |
1.1 root 1: /*
2: * reccp [-z] source dest
3: *
4: * or
5: *
6: * reccp [-z] source1 ... sourcen dest
7: *
8: * In the first case, dest must not be a directory (else we have a
9: * degenerate version of the second case). In the second case,
10: * dest must be a directory; the resulting objects will be
11: * named dest/source1 ... dest/sourcen.
12: *
13: * If any source is a directory, the tree structure under it
14: * will be (recursively) copied; this process will attempt to
15: * preserve any links that exist within the hierarchy.
16: *
17: * This version of reccp copies symbolic links as symbolic links.
18: *
19: * -z ==> copy blocks of zeros as holes.
20: */
21:
22: #include <stdio.h>
23: #include <sys/types.h>
24: #include <sys/stat.h>
25: #include <signal.h>
26:
27: #define FTW_more_to_come 1
28: #include <ftw.h>
29: /* rest of struct FTW: */
30: int obase; /* added to give basename offset of output file */
31: };
32: /* #include "ftw.body" */
33: /*
34: * Struct FTW (whose definition starts at the end of ftw.h) must
35: * must include at least the integers quit, base, and level.
36: */
37:
38: #define FTW_PATHLEN0 1000
39: #define FTW_PATHINC 1000
40: #ifndef S_IFLNK
41: #define lstat stat
42: #endif
43: #ifdef S_IFSOCK
44: #include <sys/dir.h>
45: #else
46: #include "ndir.h"
47: #endif
48: #ifndef ENOMEM
49: #include <errno.h>
50: #endif
51:
52: extern int errno;
53:
54: /*
55: * Each generation of ftw1 (the real ftw) allocates one copy, R, of the
56: * following structure; it passes a pointer to this structure when it
57: * recursively invokes itself. These structures are chained together,
58: * so that if it becomes necessary to recycle file descriptors, then
59: * the oldest descriptor (the one at the shallowest depth still open)
60: * can be recycled.
61: */
62:
63: struct FTW_rec {
64: struct FTW_rec *prev;
65: long here; /* seek to here when reopening at this level */
66: DIR *fd; /* file descriptor at this level */
67: };
68:
69: /*
70: * One instance, T, of the following structure is allocated by ftw; a
71: * pointer to it is passed to all generations of ftw1 (the real ftw).
72: * T could often be a global variable, but this way the parameter fn
73: * can invoke ftw for an independent tree walk.
74: * Component T->path points to storage for the object path-names;
75: * this storage may be relocated by realloc if T->path needs to be
76: * more than T->pathlast characters long.
77: * T->path[T->pathnext] is the next free character in the pathnames.
78: * T->depth = parameter depth to ftw. T->lastout is the deepest level at
79: * which a file descriptor has been recycled.
80: */
81:
82: struct FTW_top {
83: int (*fn)();
84: char *path;
85: unsigned pathlast, pathnext;
86: int lastout;
87: int depth;
88: };
89:
90: int
91: ftw (path, fn, depth)
92: char *path;
93: int (*fn)();
94: int depth;
95: {
96: struct FTW_top T;
97: struct FTW_rec R;
98: struct FTW S;
99: int rc;
100: char *malloc(), *strcpy();
101:
102: T.depth = depth;
103: T.lastout = -1;
104: T.fn = fn;
105: S.quit = 0;
106: S.level = -1;
107:
108: /* initialize S.base, T.pathnext... */
109: {
110: register char c, *p, *q;
111: for (p = q = path; c = *p; p++) if (c == '/') q = p + 1;
112: S.base = q - path;
113: T.pathnext = p - path;
114: }
115:
116: T.pathlast = T.pathnext + FTW_PATHLEN0;
117: T.path = malloc(T.pathlast);
118: if (!T.path) { errno = ENOMEM; return -1; }
119: strcpy(T.path, path);
120: rc = ftw_1_(&R, &T, 0, &S);
121: free(T.path);
122: return rc;
123: }
124:
125: int
126: ftw_1_ (R, T, level, S1)
127: register struct FTW_rec *R;
128: register struct FTW_top *T;
129: int level;
130: struct FTW *S1;
131: {
132: int rc, n;
133: DIR *fd;
134: struct direct *dirp;
135: char *component, *path;
136: struct stat sb;
137: struct FTW_rec mr;
138: unsigned nextsave;
139: struct FTW S;
140: char *realloc();
141: long lseek();
142:
143: mr.prev = R;
144: path = T->path;
145: S.level = level;
146: S.quit = 0;
147: S.base = S1->base;
148:
149: /* Try to get file status. If unsuccessful, errno will say why. */
150: if (lstat(path, &sb) < 0) {
151: badstat: rc = -1;
152: if (errno == EACCES) {
153: rc = (*T->fn) (path, &sb, FTW_NS, &S);
154: S1->quit = S.quit;
155: }
156: return rc;
157: };
158:
159: /*
160: * The stat succeeded, so we know the object exists.
161: * If not a directory, call the user function and return.
162: */
163: #ifdef S_IFLNK
164: if ((sb.st_mode & S_IFMT) == S_IFLNK) {
165: rc = (*T->fn) (path, &sb, FTW_SL, &S);
166: S1->quit = S.quit;
167: if (rc || S.quit == FTW_SKR) return rc;
168: if (S.quit != FTW_FOLLOW) return 0;
169: S1->quit = S.quit = 0;
170: if (stat(path, &sb) < 0) goto badstat;
171: }
172: #endif
173:
174: if ((sb.st_mode & S_IFMT) != S_IFDIR) {
175: rc = (*T->fn) (path, &sb, FTW_F, &S);
176: S1->quit = S.quit;
177: return rc;
178: }
179:
180: /*
181: * The object was a directory.
182: *
183: * Open a file to read the directory
184: */
185: mr.fd = fd = opendir(path);
186:
187: /*
188: * Call the user function, telling it whether
189: * the directory can be read. If it can't be read
190: * call the user function or indicate an error,
191: * depending on the reason it couldn't be read.
192: */
193: if (!fd) {
194: rc = -1;
195: if (errno == EACCES) {
196: rc = (*T->fn) (path, &sb, FTW_DNR, &S);
197: S1->quit = S.quit;
198: }
199: return rc;
200: }
201:
202: /* We could read the directory. Call user function. */
203: rc = (*T->fn) (path, &sb, FTW_D, &S);
204: if (rc != 0)
205: return rc;
206: if (S.quit == FTW_SKD) return 0;
207: if (S.quit == FTW_SKR) {S1->quit = FTW_SKR; return 0;}
208:
209: /* Make sure path is big enough to hold generated pathnames. */
210:
211: n = nextsave = T->pathnext;
212: if (n + MAXNAMLEN + 1 >= T->pathlast) {
213: T->pathlast += FTW_PATHINC;
214: path = T->path = realloc(T->path, T->pathlast);
215: if (!path) {
216: (void) closedir(fd);
217: errno = ENOMEM;
218: return -1;
219: }
220: }
221:
222: /* Create a prefix to which we will append component names */
223:
224: if (n > 0 && path[n-1] != '/') path[n++] = '/';
225: component = path + n;
226:
227: /*
228: * Read the directory one component at a time.
229: * We must ignore "." and "..", but other than that,
230: * just create a path name and call self to check it out.
231: */
232: while (dirp = readdir(fd)) {
233: if (dirp->d_ino != 0
234: && strcmp (dirp->d_name, ".") != 0
235: && strcmp (dirp->d_name, "..") != 0) {
236: int i;
237: struct FTW_rec *pr;
238:
239: /* Append the component name to the working path */
240: strcpy(component, dirp->d_name);
241: T->pathnext = n + strlen(dirp->d_name);
242:
243: /*
244: * If we are about to exceed our depth,
245: * remember where we are and close the file.
246: */
247: if (level - T->lastout >= T->depth) {
248: pr = &mr;
249: i = T->lastout++;
250: while (++i < level) pr = pr->prev;
251: pr->here = telldir(pr->fd);
252: closedir(pr->fd);
253: }
254:
255: /*
256: * Do a recursive call to process the file.
257: */
258: S.quit = 0;
259: S.base = n;
260: rc = ftw_1_(&mr, T, level+1, &S);
261: if (rc != 0 || S.quit == FTW_SKR) {
262: if (level > T->lastout) closedir(fd);
263: T->pathnext = nextsave;
264: return rc;
265: }
266:
267: /*
268: * If we closed the file, try to reopen it.
269: */
270: if (level <= T->lastout) {
271: char c = path[nextsave];
272: path[nextsave] = 0;
273: T->lastout = level - 1;
274: mr.fd = fd = opendir(path);
275: if (!fd) return -1;
276: path[nextsave] = c;
277: seekdir(fd, mr.here);
278: }
279: }
280: }
281: T->pathnext = nextsave;
282: path[nextsave] = 0;
283:
284: /*
285: * We got out of the subdirectory loop. Call the user
286: * function again at the end and clean up.
287: */
288:
289: rc = (*T->fn) (path, &sb, FTW_DP, &S);
290: closedir(fd);
291: S1->quit = S.quit;
292: return rc;
293: }
294:
295: #define BLKSIZE BUFSIZ
296: char zero[BLKSIZE]; /* keep as zero */
297: int zflag;
298:
299: /* destination path-name buffer initial value, increment */
300: #define PATHLEN0 1000
301: #define PATHINC 1000
302: #define IHTABLEN 287
303: #define SBUFLEN 1000
304:
305: /* Non-zero if stat buffer b refers to a directory, zero otherwise */
306: #define isdir(b) (((b).st_mode & S_IFMT) == S_IFDIR)
307:
308: char *malloc(), *realloc(), *strcpy(), *strcat();
309: int copy();
310:
311: char symbuf[SBUFLEN]; /* Buffer for symbolic link names */
312: int firstyell = 1;
313: int destlen; /* length of destination (last arg) */
314: int iamsu;
315: char *dest;
316: char *destdir; /* Storage for output pathname -- handled like
317: * the source pathname in ftw, subject to being
318: * relocated by realloc.
319: */
320: unsigned dlast, dnext; /* Offsets of next available, last+1 chars of
321: * output pathname.
322: */
323:
324: /* Final component of the path name by which we were invoked */
325: char *pgmname;
326:
327: struct inodetab { /* for keeping track of links */
328: struct inodetab *nextint;
329: ino_t i_ino;
330: dev_t i_dev;
331: char iname[1];
332: };
333:
334: struct inodetab *ihtab[IHTABLEN]; /* hash table for remembering links */
335:
336: int retcode;
337:
338: main(argc, argv)
339: int argc;
340: char **argv;
341: {
342: char *p, *q;
343: struct stat *argbufs, destbuf, statbuf, rootbuf;
344: int i;
345:
346: umask(0);
347: pgmname = argv[0];
348:
349: if (argc > 1 && !strcmp(argv[1],"-z")) {
350: zflag = 1;
351: --argc;
352: ++argv;
353: }
354:
355: /*
356: * Start validity checking
357: */
358:
359: /* Check for too few arguments given */
360: if (argc < 3) {
361: fprintf(stderr,
362: "usage: %s [-z] f1 f2 or %s [-z] f1 ... fn d\n",
363: pgmname, pgmname);
364: return 1;
365: }
366:
367: /*
368: * If the last argument is a non-directory, we require
369: * argc == 3 (in the case of: cp f1 f2)
370: */
371: dest = argv[argc-1];
372: destbuf.st_mode = 0; /* Force isdir(destbuf) false */
373: if ((stat (dest, &destbuf) < 0 || !isdir(destbuf)) && argc != 3) {
374: scream ("%s not a directory", dest);
375: return 1;
376: }
377:
378: /*
379: * Allocate storage for a stat buffer for each argument
380: * but the last. This will be used to check for trying to
381: * copy something into a subdirectory of itself.
382: */
383: argbufs = (struct stat *)
384: malloc ((unsigned) (sizeof (struct stat) * (argc-2)));
385: if (argbufs == NULL) {
386: scream ("insufficient storage", "");
387: return 1;
388: }
389: iamsu = (getuid() == 0);
390:
391: for (i = 0; i < argc-2; i++) {
392: if (lstat (argv[i+1], &argbufs[i]) < 0) {
393: scream ("cannot access %s", argv[i+1]);
394: return 1;
395: }
396: }
397:
398: /*
399: * Now run back from the destination to the root directory,
400: * checking along the way for any matches with anything in
401: * the argbufs array. If we find any, we tried a forbidden
402: * operation. If the destination is not already a directory,
403: * we must start from its parent. Note that even in this case,
404: * we can't elide the test, because otherwise we wouldn't get
405: *
406: * cp . x
407: *
408: * This code also handles pathological but legal destinations
409: * properly; in particular note that the null string is a
410: * valid name for the current directory. Sigh.
411: *
412: * First figure out the name of the directory to check.
413: */
414: dnext = destlen = strlen(dest);
415: dlast = destlen + 2;
416: if (dlast < PATHLEN0) dlast = PATHLEN0;
417: destdir = malloc(dlast);
418: if (!destdir) { scream ("no storage", ""); return 1; }
419: strcpy (destdir, dest);
420: if (!isdir (destbuf)) {
421: p = q = destdir;
422: while (*q) {
423: if (*q++ == '/')
424: p = q - 1;
425: }
426: if (p == destdir) {
427: strcpy (destdir, ".");
428: dnext = 1;
429: }
430: else {
431: *p = '\0';
432: dnext = p - destdir;
433: }
434: }
435:
436: /* Now stat the root directory for later use */
437: if (stat ("/", &rootbuf) < 0) {
438: scream ("cannot access root directory", "");
439: return 1;
440: }
441:
442: /* Now run back from destdir to the root, checking against argbufs */
443: do {
444: if (stat (destdir, &statbuf) < 0) {
445: scream ("cannot stat %s", destdir);
446: return 1;
447: }
448: for (i = 0; i < argc-2; i++)
449: if (argbufs[i].st_dev == statbuf.st_dev
450: && argbufs[i].st_ino == statbuf.st_ino) {
451: fprintf (stderr, "%s: %s contains %s\n",
452: pgmname, argv[i+1], dest);
453: return 1;
454: }
455: dcheck(3, "initial arg checking");
456: strcpy(destdir+dnext, "/..");
457: dnext += 3;
458: } while (statbuf.st_dev != rootbuf.st_dev
459: || statbuf.st_ino != rootbuf.st_ino);
460:
461: /*
462: * End of validity checking
463: */
464:
465: strcpy(destdir, dest);
466: for (i = 0; i < IHTABLEN; i++) ihtab[i] = 0;
467: if (isdir(destbuf)) {
468: destdir[destlen] = '/';
469: dnext = destlen + 1;
470: for (i = 1; i < argc-1; i++) {
471:
472: char *p, *q;
473:
474: p = q = argv[i];
475: while (*p)
476: if (*p++ == '/')
477: q = p;
478: dnext = destlen + (p - q) + 1;
479:
480: p = destdir + destlen;
481: *p = '/';
482: strcpy(p+1, q);
483: retcode |= ftw(argv[i], copy, 12);
484: }
485: }
486:
487: else {
488: dnext = destlen;
489: retcode = ftw(argv[1], copy, 12);
490: }
491:
492: return retcode;
493: }
494:
495: int
496: copy(source, srcbuf, code, S)
497: char *source;
498: struct stat *srcbuf;
499: int code;
500: struct FTW *S;
501: {
502: char *s;
503: int rc, slen;
504:
505: switch(code) {
506:
507: case FTW_F: /* nondirectory */
508:
509: dcheck(MAXNAMLEN+1,source);
510: if (S->level)
511: strcpy(destdir + dnext, source + S->base);
512: return copy1(source, srcbuf, destdir);
513:
514: case FTW_D: /* new directory */
515:
516: dcheck(MAXNAMLEN+1,source);
517: S->obase = dnext;
518: s = destdir+dnext;
519: if (S->level) {
520: for (source += S->base; *s = *source;)
521: { s++, source++; }
522: }
523: dnext = s - destdir;
524: if (mkdir(destdir,0700)) {
525: scream("can't mkdir %s", destdir);
526: return 1;
527: }
528: *s++ = '/'; *s = 0;
529: ++dnext;
530: return 0;
531:
532: case FTW_DNR: /* unreadable directory */
533:
534: scream("can't read %s", source);
535: return 1;
536:
537: case FTW_NS: /* unstatable file */
538:
539: scream("can't stat %s", source);
540: return 1;
541:
542: case FTW_DP: /* end of directory */
543:
544: destdir[dnext-1] = 0;
545: dnext = S->obase;
546: if (chmod(destdir, (int)srcbuf->st_mode))
547: scream("can't chmod %s", destdir);
548: if(iamsu && chown(destdir, srcbuf->st_uid,
549: srcbuf->st_gid))
550: scream("can't chown %s", destdir);
551: return settime(srcbuf, destdir);
552:
553: #ifdef S_IFLNK
554: case FTW_SL: /* symbolic link */
555:
556: slen = readlink(source, symbuf, SBUFLEN);
557: if (slen >= SBUFLEN) {
558: scream("Symbolic path to %s too long.",
559: source);
560: return 1;
561: }
562: dcheck(MAXNAMLEN+1,source);
563: symbuf[slen] = 0;
564: if (S->level) strcpy(destdir + dnext,
565: source + S->base);
566: rc = 0;
567: umask(~(int)srcbuf->st_mode);
568: if (symlink(symbuf,destdir)) {
569: fprintf(stderr,
570: "%s: can't symbolically link %s to %s\n",
571: pgmname, destdir, symbuf);
572: rc = 1;
573: }
574: umask(0);
575: return rc;
576: #endif
577:
578: default: /* bug */
579: fprintf(stderr,"%s: unknown code = %d from ftw\n",
580: pgmname, code);
581: exit(1);
582: }
583: }
584:
585: /*
586: * Copy a file. The source file name is in "source",
587: * and the destination file name is in "dest". "srcbuf" points to
588: * a stat buffer for the source.
589: */
590:
591: int
592: copy1(source, srcbuf, dest)
593: char *source, *dest;
594: struct stat *srcbuf;
595: {
596: int bsize, inf, outf, n, type, zsize;
597: char buffer[BLKSIZE];
598: struct stat destbuf;
599: long lseek();
600:
601: if (stat (dest, &destbuf) >= 0
602: && srcbuf->st_dev == destbuf.st_dev
603: && srcbuf->st_ino == destbuf.st_ino) {
604: scream ("cannot copy %s to itself", source);
605: return 1;
606: }
607:
608: switch(type = srcbuf->st_mode & S_IFMT) {
609:
610: case S_IFCHR: /* character special */
611: case S_IFBLK: /* block special */
612: if (!iamsu) {
613: scream("can't copy special file %s", source);
614: return 1;
615: }
616: if (n = linkchk(srcbuf,destdir)) return n-1;
617: if (mknod(destdir, (int) srcbuf->st_mode,
618: (int) srcbuf->st_rdev)) {
619: scream("can't create %s", destdir);
620: return 1;
621: }
622: goto finish;
623:
624: case S_IFREG: /* regular file */
625: if (n = linkchk(srcbuf,destdir)) return n-1;
626: break;
627:
628: default:
629: fprintf(stderr,
630: "%s: unknown file type 0x%x for %s\n",
631: pgmname, type, source);
632: return 1;
633: }
634:
635: /* Now copy the file, whether or not there was a link */
636:
637: if ((outf = creat (dest, (int) (srcbuf->st_mode & 0777))) < 0) {
638: scream ("cannot create %s", dest);
639: return 1;
640: }
641: if ((inf = open (source, 0)) < 0) {
642: scream ("cannot open %s", source);
643: close(outf);
644: return 1;
645: }
646: if (zflag) {
647: fstat(outf, &destbuf);
648: bsize = BSIZE(destbuf.st_dev);
649: if (bsize > BLKSIZE) {
650: fprintf(stderr, "%s: BSIZE(%s) > %d\n", pgmname,
651: dest, BLKSIZE);
652: return 1;
653: }
654: }
655: else bsize = BLKSIZE;
656: zsize = 0;
657: while ((n = read (inf, buffer, bsize)) > 0) {
658: if (zflag && (n == bsize) && !memcmp(buffer, zero, bsize)) {
659: if (lseek(outf, (long)bsize, 1) < 0) {
660: scream("lseek (for block of 0's) failed on %s",
661: dest);
662: goto endit;
663: }
664: zsize = bsize;
665: }
666: else if (write (outf, buffer, n) != n) {
667: scream ("output error on %s", dest);
668: endit:
669: close (inf);
670: close (outf);
671: return 1;
672: }
673: else zsize = 0;
674: }
675: if (n < 0) {
676: scream ("input error on %s", source);
677: goto endit;
678: }
679: if (zsize && (lseek(outf, (long)-zsize, 1) < 0
680: || write(outf,zero,zsize) != zsize)) {
681: scream("error writing trailing 0's from %s", source);
682: goto endit;
683: }
684: if (close (outf) < 0) {
685: scream ("cannot close %s", dest);
686: close (inf);
687: return 1;
688: }
689: if (close (inf) < 0) {
690: scream ("cannot close %s", source);
691: return 1;
692: }
693:
694: finish:
695: if(iamsu && chown(dest, srcbuf->st_uid, srcbuf->st_gid)) {
696: scream("can't chown %s", dest);
697: return 1;
698: }
699: return settime(srcbuf, dest);
700: }
701:
702: scream (s1, s2)
703: char *s1, *s2;
704: {
705: fprintf (stderr, "%s: ", pgmname);
706: fprintf (stderr, s1, s2);
707: putc ('\n', stderr);
708: retcode |= 1;
709: }
710:
711: dcheck(len, source)
712: int len;
713: char *source;
714: {
715: int dnext1 = dnext + len;
716: if (dnext1 >= dlast) {
717: dlast += PATHINC;
718: destdir = realloc(destdir, dlast);
719: if (!destdir) {
720: scream("malloc failed on %s",source);
721: exit(1);
722: }
723: }
724: }
725:
726: int
727: linkchk(sb,d)
728: struct stat *sb;
729: char *d;
730: {
731: register struct inodetab *p, *p0;
732: struct stat buf;
733:
734: if (sb->st_nlink < 2) return 0;
735:
736: p0 = (struct inodetab *)
737: (((sb->st_dev + sb->st_ino) % IHTABLEN) + ihtab);
738: while ((p = p0->nextint) &&
739: (p->i_ino != sb->st_ino || p->i_dev != sb->st_dev)) p0 = p;
740:
741: if (p) {/* If this is a link to a file already seen... */
742: if (link(p->iname, d)) {
743:
744: /* unlink d and try again, unless d is a directory */
745:
746: if (lstat(d,&buf)
747: || (buf.st_mode & S_IFMT) == S_IFDIR
748: || unlink(d)
749: || link(p->iname,d)) {
750: fprintf(stderr,"%s: can't link %s to %s\n",
751: pgmname, p->iname, d);
752: return 2;
753: }
754: }
755: return 1;
756: }
757:
758: /* This file has more than one link to it -- add it to the list */
759: /* of files that may be seen later. */
760:
761: p = (struct inodetab *)
762: malloc((unsigned) (sizeof(struct inodetab) + strlen(d)));
763: if (!p) {
764: if (firstyell) {
765: firstyell = 0;
766: scream("storage for links exhausted with %s", d);
767: }
768: return 0;
769: }
770:
771: p0->nextint = p;
772: p->nextint = 0;
773: p->i_ino = sb->st_ino;
774: p->i_dev = sb->st_dev;
775: strcpy(p->iname, d);
776: return 0;
777: }
778:
779: settime(srcbuf, dest) /* set time and mode of dest */
780: struct stat *srcbuf;
781: char *dest;
782: {
783: time_t utimbuf[2];
784: int m, rc = 0;
785:
786: utimbuf[0] = srcbuf->st_atime;
787: utimbuf[1] = srcbuf->st_mtime;
788: utime (dest, utimbuf);
789:
790: m = srcbuf->st_mode;
791: #ifdef S_ISVTX
792: if (m & S_ISVTX && !iamsu) {
793: scream("can't set save-text bit of %s", dest);
794: m &= ~S_ISVTX;
795: }
796: if ((m & (S_ISUID | S_ISGID | S_ISVTX)) && (rc = chmod(dest,m)))
797: #else
798: if ((m & (S_ISUID | S_ISGID)) && (rc = chmod(dest,m)))
799: #endif
800: scream("can't set mode of %s", dest);
801: return rc;
802: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.