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