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