![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpdir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin|
Return to cpdir.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin |
1.1 root 1: /*
2: * Cpdir. Copy hierarchies in a file system, preserving structure.
3: * Define SLOW for 'block at a time copying' - not recommended tho.
4: */
5: #include <stdio.h>
6: #include <errno.h>
7: #include <signal.h>
8: #include <sys/types.h>
9: #include <sys/stat.h>
10: #include <sys/dir.h>
11: #include <ctype.h>
12: #include <access.h>
13: #include <canon.h>
14:
15: #define VERSION "1.1"
16: #define CPBUFSIZ (50*BUFSIZ) /* copy buffer */
17: #define SDSIZ (sizeof(struct direct))
18: #define MAXINT 32767
19: #define SOURCE 0
20: #define TARGET 1
21: #define DEV0 ((dev_t)0)
22: #define INODE0 ((ino_t)0)
23: #define ROOTUID 0
24: #define HASHSIZE 37
25:
26: #define hash(ino) ((ino)%HASHSIZE)
27:
28: #define TRUE (0==0)
29: #define FALSE (0==1)
30:
31: typedef char bool;
32: typedef unsigned char uchar;
33: typedef unsigned int uint;
34: typedef unsigned short ushort;
35: typedef unsigned long ulong;
36:
37: typedef union {
38: struct direct dbuf;
39: char cbuf[SDSIZ + 1];
40: } DIRBUF;
41: #define db_ino dbuf.d_ino
42: #define db_name dbuf.d_name
43:
44: typedef struct link {
45: ino_t l_ino;
46: dev_t l_dev;
47: dev_t l_tdev;
48: struct link *l_next;
49: uint l_nlink;
50: char l_name[];
51: } LINK;
52:
53: typedef struct str {
54: struct str *s_next;
55: char s_str[];
56: } STR;
57:
58:
59:
60: /*
61: * Global variables.
62: */
63: extern int errno;
64: dev_t dir2_dev;
65: ino_t dir2_ino;
66: dev_t src_dev;
67: dev_t tgt_dev;
68: struct stat srcstat;
69: struct stat tgtstat;
70: LINK *srctab[HASHSIZE];
71: LINK *tgttab[HASHSIZE];
72: STR *strtab[HASHSIZE];
73:
74: bool aflag;
75: bool dflag;
76: bool eflag;
77: bool sflag;
78: bool tflag;
79: bool uflag;
80: bool vflag;
81: bool wflag;
82: bool root;
83: bool splitmsg;
84: bool errprefix;
85: bool dir1slash;
86: bool dir2slash;
87:
88: int rlimit = MAXINT;
89: int rlevel = 1;
90: int exitval;
91: int numsuppress;
92: int broken;
93: int srclinks;
94: int tgtlinks;
95: int srcsize;
96: int tgtsize;
97: int dir1len;
98: int dir2len;
99: int interrupted; /* For handling SIGINT and SIGQUIT */
100:
101: short uid;
102: short gid;
103:
104: char *dir1;
105: char *dir2;
106: char *target;
107: char *source;
108:
109: /*
110: * Error message and other strings.
111: */
112: char *dot = ".";
113: char *dotdot = "..";
114: char *fmt1 = "%s\n";
115: char *fmt1a = "%-72s\r";
116: char *fmt2 = "%s: %s\n";
117: char *fmt3 = "%s: %s%s\n";
118: char *fmt4 = "%s: %s%s%s\n";
119: char *usage = "usage: cpdir [options] dir1 dir2";
120: char *devbound = "crossing device boundary";
121: char *writeerr = "write error";
122: char *readerr = "read error";
123: char *supressd = "suppressed";
124: char *linked = "linked";
125: char *notdir = "not a directory";
126: char *nomemory = "out of memory";
127: char *nopermit = "permission denied";
128: char *nomkdir = "cannot make directory";
129: char *nounlink = "cannot unlink ";
130: char *nolink = "cannot link ";
131: char *nocreate = "cannot create";
132: char *nofind = "cannot find";
133: char *noopen = "cannot open";
134:
135: /*
136: * Functions returning non_int.
137: */
138: long lseek();
139: char *tmalloc();
140: char *realloc();
141: char *rindex();
142: char *concat();
143: char *parent();
144: bool suppress();
145: bool isslash();
146: bool dirchecks();
147: bool linkattempt();
148: bool tgtunlink();
149: LINK *linklocate();
150: LINK *linkinstall();
151:
152: main(ac, av) int ac; char *av[];
153: {
154: ac = 0;
155: aarghh(av);
156: init();
157: cpdir();
158: report();
159: if (aflag)
160: printf("%72s\r", "");
161: return (exitval);
162: }
163:
164: aarghh(av)
165: register char *av[];
166: {
167: register char *cp;
168:
169: for (;;) {
170: if ((cp = *++av) == NULL) {
171: errprint(fmt1, usage);
172: exit(1);
173: }
174: if (*cp++ != '-')
175: break;
176: while (*cp)
177: switch (*cp++) {
178: case 'a':
179: aflag = TRUE;
180: break;
181: case 'd':
182: dflag = TRUE;
183: break;
184: case 'e':
185: eflag = TRUE;
186: break;
187: case 'r':
188: if (!isdigit(*cp)) {
189: rlimit = 1;
190: break;
191: }
192: *av = cp;
193: rlimit = new_atoi(av);
194: cp = *av;
195: break;
196: case 's':
197: sflag = TRUE;
198: strinstall(cp);
199: ++numsuppress;
200: goto NEXTARG;
201: break;
202: case 't':
203: tflag = wflag = eflag = TRUE;
204: break;
205: case 'u':
206: uflag = TRUE;
207: break;
208: case 'v':
209: vflag = wflag = TRUE;
210: break;
211: case 'V':
212: fprintf(stderr, "cpdir: V%s\n", VERSION);
213: break;
214: default:
215: errprint(fmt1, usage);
216: exit(1);
217: }
218: NEXTARG:;
219: }
220:
221: if ((dir1=*av++) == NULL || (dir2=*av++) == NULL || *av != NULL) {
222: errprint(fmt1, usage);
223: exit(1);
224: }
225: return;
226: }
227:
228: /*
229: * Actions: Initialize certain flags and the name buffers source and target.
230: * Verify dir1 and dir2 permissions. Dir2 is made if necessary.
231: * Side Effects: On return srcstat contains the status of dir1. If dir2
232: * exists tgtstat contains its status. In the case that tflag is set and dir2
233: * does not exist, tgt_dev and tgtstat.st_dev are the device of target's
234: * parent, the device that target would be created on except for tflag.
235: */
236: init()
237: {
238: struct stat outstat;
239: struct stat errstat;
240:
241: uid = getuid();
242: gid = getgid();
243: root = (uid == ROOTUID);
244: if (root)
245: umask(0);
246:
247: errprefix = !isatty(fileno(stdin));
248: fstat(fileno(stdout), &outstat);
249: fstat(fileno(stderr), &errstat);
250: splitmsg = (outstat.st_ino != errstat.st_ino) ||
251: (outstat.st_dev != errstat.st_dev);
252:
253: dir1len = strlen(dir1);
254: srcsize = (dir1len + 1);
255: source = tmalloc(srcsize);
256: strcpy(source, dir1);
257: dir1slash = isslash(dir1);
258:
259: dir2len = strlen(dir2);
260: tgtsize = dir2len + 1;
261: target = tmalloc(tgtsize);
262: strcpy(target, dir2);
263: dir2slash = isslash(dir2);
264:
265: /*
266: * We must check boundary conditions before we call dirchecks().
267: * These are: source exists and is a directory, and if target does not
268: * exist that we have write and search permission on its parent and
269: * tgt_dev contains the device number of the parent.
270: */
271: if (stat(dir1, &srcstat) < 0) {
272: errprint(fmt2, dir1, nofind);
273: exit(1);
274: }
275: if ((srcstat.st_mode & S_IFMT) != S_IFDIR) {
276: errprint(fmt2, dir1, notdir);
277: exit(1);
278: }
279: if (access(dir2, 0) < 0) {
280: register char *cp;
281: cp = parent(dir2);
282: if (stat(cp, &tgtstat) < 0) {
283: errprint(fmt2, dir2, "cannot find parent");
284: exit(1);
285: }
286: if (access(cp, AWRITE|ASRCH) < 0) {
287: errprint(fmt2, dir2, nomkdir);
288: exit(1);
289: }
290: tgt_dev = tgtstat.st_dev;
291: }
292: if (!dirchecks())
293: exit(1);
294:
295: src_dev = srcstat.st_dev;
296: dir2_dev = tgt_dev = tgtstat.st_dev;
297: if (access(target, 0) == 0)
298: dir2_ino = tgtstat.st_ino;
299: return;
300: }
301:
302:
303: /*
304: * Assume: Source is a directory we can read and search. Srcstat contains its
305: * status. Target is a directory we can write and search. Tgtstat contains its
306: * status. Src_dev and tgt_dev are the devices of the parents of source and
307: * target. If tflag is on target may not exist. In this case tgtstat.st_dev
308: * contains the device where target would have been created if tflag were off.
309: */
310: cpdir()
311: {
312: register int n;
313: register int fd;
314: register DIRBUF *dbp;
315: DIRBUF dirbuf;
316: long address;
317: dev_t sdev;
318: dev_t tdev;
319: struct stat locsrcstat;
320: struct stat loctgtstat;
321:
322: /*
323: * Check for circular copy.
324: */
325: if (srcstat.st_ino == dir2_ino &&
326: srcstat.st_dev == dir2_dev) {
327: if (wflag)
328: printf(fmt2, source,
329: "not copied to avoid circular copy");
330: return;
331: }
332:
333: /*
334: * Open source, and prepare dirbuf.
335: */
336: if ((fd = open(source, 0)) < 0) {
337: errprint(fmt2, source, noopen);
338: return;
339: }
340: dbp = &dirbuf;
341: dbp->cbuf[SDSIZ] = '\0';
342:
343: /*
344: * Save srcstat, src_dev, tgtstat, tgt_dev to restore before exit.
345: */
346: locsrcstat = srcstat;
347: loctgtstat = tgtstat;
348: tdev = tgt_dev;
349: sdev = src_dev;
350:
351: /*
352: * Detect the crossing of device boundaries.
353: */
354: if (tgt_dev != tgtstat.st_dev) {
355: if (wflag)
356: printf(fmt2, target, devbound);
357: tgt_dev = tgtstat.st_dev;
358: }
359: if (src_dev != srcstat.st_dev) {
360: if (wflag)
361: printf(fmt2, source, devbound);
362: src_dev = srcstat.st_dev;
363: }
364:
365: /*
366: * Loop through the directory source.
367: */
368: while ((n = read(fd, dbp->cbuf, SDSIZ)) > 0) {
369: if (n != SDSIZ) {
370: errprint(fmt2, source, readerr);
371: close(fd);
372: goto OUT;
373: }
374:
375: canino(dbp->db_ino);
376: if (dbp->db_ino == INODE0 ||
377: !strcmp(dbp->db_name, dot) ||
378: !strcmp(dbp->db_name, dotdot))
379: continue;
380:
381: grow(dbp->db_name);
382: if (sflag && suppress()) {
383: if (vflag)
384: printf(fmt2, source, supressd);
385: shrink();
386: continue;
387: }
388: if (stat(source, &srcstat) < 0) {
389: errprint(fmt2, source, nofind);
390: shrink();
391: continue;
392: }
393:
394: switch (srcstat.st_mode & S_IFMT) {
395: default:
396: errprint(fmt2, source, "unknown file type");
397: shrink();
398: continue;
399: case S_IFCHR:
400: case S_IFBLK:
401: cpnode();
402: shrink();
403: continue;
404: case S_IFPIP:
405: srcstat.st_rdev = DEV0;
406: cpnode();
407: shrink();
408: continue;
409: case S_IFREG:
410: cpfile();
411: shrink();
412: continue;
413: case S_IFDIR:
414: if (rlevel == rlimit) {
415: if (vflag)
416: printf(fmt2, source, supressd);
417: shrink();
418: continue;
419: }
420: if (!dirchecks()) {
421: shrink();
422: continue;
423: }
424:
425: address = lseek(fd, 0L, 1);
426: close(fd);
427: ++rlevel;
428: cpdir();
429: --rlevel;
430: shrink();
431: if ((fd = open(source, 0)) < 0) {
432: errprint(fmt2, source,
433: "cannot reopen, copy incomplete");
434: goto OUT;
435: }
436: lseek(fd, address, 0);
437: continue;
438: }
439: }
440: close(fd);
441:
442: OUT:
443: vprintf();
444: srcstat = locsrcstat;
445: tgtstat = loctgtstat;
446: tgt_dev = tdev;
447: src_dev = sdev;
448: adjust();
449: return;
450: }
451:
452: /*
453: * Assume source names the file to be copied, srcstat contains its status,
454: * and target is the file to copy to. Target may or may not exist.
455: */
456: cpfile()
457: {
458: #ifndef SLOW
459: register char *ip;
460: #endif
461: register int n;
462: register int i;
463: register int fd1;
464: register int fd2;
465: register fsize_t size;
466: #ifndef SLOW
467: register char *wp; /* write pointer */
468: register int wflag; /* write flag */
469: static char buf[CPBUFSIZ]; /* copy buffer */
470: #else
471: static char buf[BUFSIZ];
472: #endif
473: int intflag, hupflag;
474:
475: if (access(source, AREAD) < 0) {
476: errprint(fmt2, source, noopen);
477: return;
478: }
479:
480: if (uflag && stat(target, &tgtstat) == 0)
481: if (srcstat.st_mtime <= tgtstat.st_mtime) {
482: if (vflag)
483: printf(fmt2, target, "no update");
484: return;
485: }
486:
487: if (!tgtunlink())
488: return;
489: if (srcstat.st_nlink > 1)
490: if (linkattempt())
491: return;
492:
493: if (tflag) {
494: vprintf();
495: return;
496: }
497:
498: intflag = catch(SIGINT);
499: hupflag = catch(SIGHUP);
500: if ((fd1 = open(source, 0)) < 0) {
501: errprint(fmt2, source, noopen);
502: return;
503: }
504: if ((fd2 = creat(target, 0)) < 0) {
505: close(fd1);
506: errprint(fmt2, target, nocreate);
507: return;
508: }
509:
510: size = srcstat.st_size;
511: #ifndef SLOW
512: while ((n = read(fd1, buf, sizeof(buf))) > 0) {
513: #else
514: while ((n = read(fd1, buf, BUFSIZ)) > 0) {
515: #endif
516: /*
517: * Check for blocks of zeroes (holes in a sparse file).
518: * However, a block of zeroes at the end of a file must be
519: * written so the file has correct length.
520: */
521: #ifndef SLOW
522: wp = ip = buf;
523: size -= n;
524: while ((n-BUFSIZ) > 0 || ((n-BUFSIZ) == 0 && size != 0)) {
525: n -= BUFSIZ;
526: wflag = FALSE;
527: ip = wp;
528: for (i = 0; i < BUFSIZ; ++i)
529: if (*ip++ != '\0') {
530: wflag = TRUE;
531: break;
532: }
533: if (wflag) {
534: if (write(fd2, wp, BUFSIZ) < BUFSIZ) {
535: errprint(fmt2, target, writeerr);
536: close(fd1);
537: close(fd2);
538: return (FALSE);
539: }
540: } else {
541: lseek(fd2, (long)BUFSIZ, 1);
542: }
543: wp += BUFSIZ;
544: }
545: if (write(fd2, wp, n) < n) {
546: errprint(fmt2, target, writeerr);
547: close(fd1);
548: close(fd2);
549: return (FALSE);
550: }
551: #else
552: if ((size -= n) == (fsize_t)0)
553: goto WRITE;
554: for (i = 0; i < n; ++i)
555: if (buf[i] != '\0')
556: goto WRITE;
557: lseek(fd2, (long)BUFSIZ, 1);
558: continue;
559:
560: WRITE:
561: if (write(fd2, buf, n) < n) {
562: errprint(fmt2, target, writeerr);
563: close(fd1);
564: close(fd2);
565: return (FALSE);
566: }
567: #endif
568: }
569: close(fd1);
570: close(fd2);
571: adjust();
572: if (intflag)
573: signal(SIGINT, SIG_DFL);
574: if (hupflag)
575: signal(SIGHUP, SIG_DFL);
576: if (interrupted)
577: exit(1);
578:
579: if (n < 0)
580: errprint(fmt2, source, readerr);
581: else vprintf();
582: return;
583: }
584:
585: /*
586: * Copy special nodes and named pipes.
587: */
588: cpnode()
589: {
590: if (!root) {
591: if (vflag)
592: printf(fmt2, source, "not the super-user");
593: return;
594: }
595: if (!tgtunlink())
596: return;
597: if (srcstat.st_nlink > 1)
598: if (linkattempt())
599: return;
600: if (!tflag) {
601: if (mknod(target, srcstat.st_mode, srcstat.st_rdev) < 0) {
602: errprint(fmt2, target, "cannot make node");
603: return;
604: }
605: adjust();
606: }
607: if (vflag)
608: printf(fmt2, target, "copied node");
609: else if (aflag)
610: printf(fmt1a, target);
611: return;
612: }
613:
614:
615: /*
616: * Grow each of target and source by appending '/' and cp.
617: */
618: grow(cp)
619: register char *cp;
620: {
621: register int a;
622: register int b;
623:
624: a = strlen(cp) + 2;
625:
626: b = strlen(source);
627: if (a+b > srcsize) {
628: if ((source = realloc(source, a+b)) == NULL) {
629: errprint(fmt1, nomemory);
630: exit(1);
631: }
632: srcsize = a+b;
633: }
634: if (rlevel > 1 || !dir1slash)
635: source[b++] = '/';
636: strcpy(source+b, cp);
637:
638: b = strlen(target);
639: if (a+b > tgtsize) {
640: if ((target = realloc(target, a+b)) == NULL) {
641: errprint(fmt1, nomemory);
642: exit(1);
643: }
644: tgtsize = a+b;
645: }
646: if (rlevel > 1 || !dir2slash)
647: target[b++] = '/';
648: strcpy(target+b, cp);
649: }
650:
651: /*
652: * Shrink source and target down by the last pathname component.
653: */
654: shrink()
655: {
656: if (rlevel == 1 && dir1slash)
657: source[dir1len] = '\0';
658: else
659: *rindex(source, '/') = '\0';
660: if (rlevel == 1 && dir2slash)
661: target[dir2len] = '\0';
662: else
663: *rindex(target, '/') = '\0';
664: return;
665: }
666:
667:
668: /*
669: * Returns a value equal to atoi(*cpp). Positive decimal integers only.
670: * Leaves *cpp pointing to the character that terminated the digit string.
671: */
672: new_atoi(cpp)
673: char **cpp;
674: {
675: register int sum = 0;
676: register int c;
677: register char *cp;
678:
679: sum = 0;
680: cp = *cpp;
681: while (isdigit(c = *cp++)) {
682: sum *= 10;
683: sum -= '0';
684: sum += c;
685: }
686: *cpp = cp-1;
687: return (sum);
688: }
689:
690: errprint(arg)
691: char *arg[];
692: {
693: register char *format;
694:
695: format = (errprefix) ? "cpdir: %r" : "%r";
696: fprintf(stderr, format, &arg);
697: if (wflag && splitmsg)
698: printf(format, &arg);
699: if (!eflag)
700: exit(1);
701: exitval = 1;
702: return;
703: }
704:
705: /*
706: * Interface to malloc to check for bad returns.
707: */
708: char *
709: tmalloc(n)
710: int n;
711: {
712: register char *cp;
713: if ((cp = malloc(n)) == NULL) {
714: errprint(fmt1, nomemory);
715: exit(1);
716: }
717: return (cp);
718: }
719:
720: /*
721: * Assume: source is a dir, srcstat has its status, we have write and search
722: * permission on target's parent directory, tgt_dev is the device of target's
723: * parent.
724: * Actions: Check permissions on source. Check permissions on target if it
725: * exists. If non-extant and tflag is off, make it.
726: * Side Effects: On return, if target exists, tgtstat contains its status. If
727: * it does not exist, tgtstat.st_dev is the device it would have been created
728: * on if tflag were off.
729: * Return TRUE if everything Aok, FALSE otherwise.
730: */
731: bool
732: dirchecks()
733: {
734: register int n;
735: static int status;
736:
737: if (access(source, AREAD | ASRCH) < 0) {
738: errprint(fmt2, source, nopermit);
739: return (FALSE);
740: }
741:
742: if (stat(target, &tgtstat) == 0) {
743: if ((tgtstat.st_mode & S_IFMT) != S_IFDIR) {
744: errprint(fmt3, source, "target is ", notdir);
745: return (FALSE);
746: }
747: if (access(target, AWRITE | ASRCH) < 0) {
748: errprint(fmt2, target, nopermit);
749: return (FALSE);
750: }
751: return (TRUE);
752: }
753:
754: if (tflag) {
755: tgtstat.st_dev = tgt_dev;
756: return (TRUE);
757: }
758:
759: if (mkdir(target, 0700)) {
760: errprint(fmt2, target, nomkdir);
761: return (FALSE);
762: }
763:
764: if (stat(target, &tgtstat) < 0) {
765: errprint(fmt2, target, "made but cannot stat");
766: return (FALSE);
767: }
768: return (TRUE);
769: }
770:
771: strinstall(cp)
772: register char *cp;
773: {
774: register STR *sp;
775: register int n;
776:
777: n = strhash(cp);
778: for (sp = strtab[n]; sp != NULL; sp = sp->s_next)
779: if (strcmp(cp, sp->s_str) == 0)
780: return;
781: sp = (STR *) tmalloc(sizeof(STR) + strlen(cp) + 1);
782: sp->s_next = strtab[n];
783: strtab[n] = sp;
784: strcpy(sp->s_str, cp);
785: return;
786: }
787:
788: bool
789: suppress()
790: {
791: register char *cp;
792: register STR *sp;
793: register STR **spp;
794:
795: cp = source + dir1len;
796: if (!dir1slash)
797: ++cp;
798: spp = strtab + strhash(cp);
799: if ((sp = *spp) == NULL)
800: return (FALSE);
801: while (sp != NULL) {
802: if (strcmp(cp, sp->s_str) == 0) {
803: *spp = sp->s_next;
804: free(sp);
805: if (--numsuppress == 0)
806: sflag = FALSE;
807: return (TRUE);
808: }
809: spp = &(sp->s_next);
810: sp = *spp;
811: }
812: return (FALSE);
813: }
814:
815: strhash(cp)
816: register uchar *cp;
817: {
818: register uint sum = 0;
819: for (sum = 0; *cp != '\0'; sum += *cp++)
820: ;
821: return (sum % HASHSIZE);
822: }
823:
824: LINK *
825: linklocate(flag)
826: int flag;
827: {
828: register LINK *lp;
829: register struct stat *stp;
830:
831: if (flag == SOURCE) {
832: stp = &srcstat;
833: lp = srctab[hash(stp->st_ino)];
834: }
835: else {
836: stp = &tgtstat;
837: lp = tgttab[hash(stp->st_ino)];
838: }
839:
840: for ( ; lp != NULL; lp = lp->l_next) {
841: if (lp->l_ino != stp->st_ino)
842: continue;
843: if (lp->l_dev != stp->st_dev)
844: continue;
845: --(lp->l_nlink);
846: return (lp);
847: }
848: return (NULL);
849: }
850:
851: LINK *
852: linkinstall(flag)
853: int flag;
854: {
855: register LINK **lpp;
856: register LINK *lp;
857: register struct stat *stp;
858:
859: if (flag == SOURCE) {
860: ++srclinks;
861: stp = &srcstat;
862: lpp = hash(stp->st_ino) + srctab;
863: }
864: else {
865: ++tgtlinks;
866: stp = &tgtstat;
867: lpp = hash(stp->st_ino) + tgttab;
868: }
869:
870: lp = (LINK *) tmalloc(sizeof(LINK) + strlen(target) - dir2len + 1);
871: if (!dir2slash)
872: strcpy(lp->l_name, target + dir2len + 1);
873: else
874: strcpy(lp->l_name, target + dir2len);
875: lp->l_dev = stp->st_dev;
876: lp->l_ino = stp->st_ino;
877: lp->l_tdev = tgt_dev;
878: lp->l_nlink = stp->st_nlink - 1;
879: lp->l_next = *lpp;
880: *lpp = lp;
881: return (lp);
882: }
883:
884: linkpurge(flag, lp)
885: int flag;
886: register LINK *lp;
887: {
888: register LINK *lp1;
889: register LINK **lpp;
890:
891: if (flag == SOURCE) {
892: --srclinks;
893: lpp = hash(srcstat.st_ino) + srctab;
894: }
895: else {
896: --tgtlinks;
897: lpp = hash(tgtstat.st_ino) + tgttab;
898: }
899:
900: for (lp1 = *lpp; lp1 != NULL; *lpp = lp1, lp1 = lp1->l_next) {
901: if (lp1 != lp)
902: continue;
903: *lpp = lp1->l_next;
904: free((char *)lp1);
905: return;
906: }
907: return;
908: }
909:
910: bool
911: linkattempt()
912: {
913: register LINK *lp;
914: register bool ret;
915: register char *cp;
916:
917: if ((lp = linklocate(SOURCE)) == NULL) {
918: linkinstall(SOURCE);
919: return (FALSE);
920: }
921: cp = concat(dir2, lp->l_name);
922:
923: if (tflag) {
924: if (tgt_dev != lp->l_tdev) {
925: errprint(fmt4, target, nolink, " to ", cp);
926: ++broken;
927: ret = FALSE;
928: }
929: else {
930: vprintf();
931: ret = TRUE;
932: }
933: }
934: else if (link(cp, target) == 0) {
935: vprintf();
936: ret = TRUE;
937: }
938: else {
939: errprint(fmt4, target, nolink, " to ", cp);
940: ++broken;
941: ret = FALSE;
942: }
943:
944: if (lp->l_nlink == 0)
945: linkpurge(SOURCE, lp);
946: return (ret);
947: }
948:
949: bool
950: tgtunlink()
951: {
952: register LINK *lp;
953:
954: if (stat(target, &tgtstat) < 0)
955: return (TRUE);
956: if ((tgtstat.st_mode & S_IFMT) == S_IFDIR) {
957: errprint(fmt3, target, nounlink, "directory");
958: return (FALSE);
959: }
960: else if ((tgtstat.st_mode & S_IFMT) != (srcstat.st_mode & S_IFMT)) {
961: errprint(fmt3, source, "file type mismatch with ", target);
962: return (FALSE);
963: }
964:
965: if (!tflag)
966: if (unlink(target) < 0) {
967: errprint(fmt2, target, nounlink);
968: return (FALSE);
969: }
970: if (tflag)
971: printf(fmt2, target, "unlinked");
972:
973: if ((lp = linklocate(TARGET)) != NULL) {
974: if (lp->l_nlink == 0)
975: linkpurge(TARGET, lp);
976: }
977: else if (tgtstat.st_nlink > 1)
978: linkinstall(TARGET);
979: return (TRUE);
980: }
981:
982: report()
983: {
984: register LINK *lp;
985: register LINK **lpp;
986: static char *fmtlinks = "%s external links into hierarchy %s:\n";
987:
988: if (!wflag)
989: return;
990: if (broken)
991: printf("%d internal link%s broken\n", broken,
992: (broken == 1) ? "" : "s");
993: if (srclinks) {
994: printf(fmtlinks, "missed", dir1);
995: for (lpp = srctab; lpp < srctab + HASHSIZE; ++lpp)
996: for (lp = *lpp; lp != NULL; lp = lp->l_next)
997: printf("\t%d\t%s (inode %d)\n", lp->l_nlink,
998: concat(dir1, lp->l_name), lp->l_ino);
999: }
1000: if (tgtlinks) {
1001: printf(fmtlinks, "broken", target);
1002: for (lpp = tgttab; lpp < tgttab + HASHSIZE; ++lpp)
1003: for (lp = *lpp; lp != NULL; lp = lp->l_next)
1004: printf("\t%d\t%s (inode %d)\n", lp->l_nlink,
1005: concat(dir2, lp->l_name), lp->l_ino);
1006: }
1007: return;
1008: }
1009:
1010: /*
1011: * Chown, chmod, and chdate target. Assume srcstat has status of source,
1012: * and tgtstat has status of target if it exists.
1013: */
1014: adjust()
1015: {
1016: time_t date[2];
1017:
1018: if (tflag)
1019: return;
1020: if (root)
1021: chown(target, srcstat.st_uid, srcstat.st_gid);
1022: else
1023: chown(target, uid, gid);
1024: chmod(target, srcstat.st_mode & (root ? 07777 : 06777));
1025: if (dflag) {
1026: time(&date[0]);
1027: date[1] = srcstat.st_mtime;
1028: utime(target, date);
1029: }
1030: return;
1031: }
1032:
1033: /*
1034: * Concatenate pieces of pathnames, a and b. If a is not "/" a '/' char
1035: * is placed between the names. Previous return is freed.
1036: */
1037: char *
1038: concat(a, b)
1039: register char *a;
1040: char *b;
1041: {
1042: static char *ret;
1043: register int a1;
1044: register char *rp;
1045:
1046: if (ret != NULL)
1047: free(ret);
1048: a1 = strlen(a);
1049: rp = ret = tmalloc(a1 + strlen(b) + 2);
1050: strcpy(rp, a);
1051: rp += a1;
1052: if (!isslash(ret))
1053: *rp++ = '/';
1054: strcpy(rp, b);
1055: return (ret);
1056: }
1057:
1058: char *
1059: parent(cp)
1060: register char *cp;
1061: {
1062: static char *ret;
1063: register char *cp0;
1064:
1065: if (ret != NULL)
1066: free(ret);
1067: if ((cp0 = rindex(cp, '/')) == NULL)
1068: return (dot);
1069: ret = tmalloc(cp0 - cp + 1);
1070: strncpy(ret, cp, cp0 - cp);
1071: return (ret);
1072: }
1073:
1074: bool
1075: isslash(cp)
1076: register char *cp;
1077: {
1078: register int c;
1079: while ((c = *cp++) != '\0')
1080: if (c != '/')
1081: return (FALSE);
1082: return (TRUE);
1083: }
1084:
1085: /*
1086: * Routine exectuted when SIGINT or SIGHUP caught.
1087: * Set the interrupted flag.
1088: */
1089: onintr()
1090: {
1091: signal(SIGINT, SIG_IGN);
1092: signal(SIGHUP, SIG_IGN);
1093: ++interrupted;
1094: }
1095:
1096: /*
1097: * If sig's handler is currently SIG_DFL,
1098: * catch it with onintr and return 1.
1099: * If not, leave its handler unchanged and return 0.
1100: */
1101: int
1102: catch(sig) int sig;
1103: {
1104: int (*old)();
1105:
1106: if ((old = signal(sig, SIG_IGN)) == SIG_DFL) {
1107: signal(sig, onintr);
1108: return 1;
1109: }
1110: signal(sig, old);
1111: return 0;
1112: }
1113:
1114: vprintf()
1115: {
1116: if (vflag)
1117: printf(fmt1, target);
1118: else if (aflag) {
1119: printf(fmt1a, target);
1120: fflush(stdout);
1121: }
1122: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.