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