![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpdir.diff CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / f0|
Return to cpdir.diff CVS log | Up to [MW Coherent from dump] / coherent / f / f0 |
1.1 ! root 1: 2,6 c 2,3 ! 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: > * Cpdir. Copy hierarchies in a file system, preserving structure. ! 9: > * Define SLOW for 'block at a time copying' - not recommended tho. ! 10: 8,13 d 4 ! 11: < ! 12: < /* ! 13: < * Known bug: if dir1/a and dir1/b are linked, and dir2/b exists, ! 14: < * cpdir -u dir1 dir2 creates new dir2/a not linked to dir2/b. ! 15: < */ ! 16: < ! 17: 15,16 d 5 ! 18: < #include <stdlib.h> ! 19: < #include <string.h> ! 20: 21 c 10 ! 21: < #include <sys/uproc.h> ! 22: --- ! 23: > #include <sys/dir.h> ! 24: 26,33 c 15 ! 25: < extern long lseek(); ! 26: < ! 27: < /* Avoid conflicts with headers, bogus nachos. */ ! 28: < #undef hash ! 29: < #undef DIRBUF ! 30: < ! 31: < /* Manifest constants. */ ! 32: < #define VERSION "1.2" ! 33: --- ! 34: > #define VERSION "1.1" ! 35: 43,44 d 24 ! 36: < #define TRUE (0==0) ! 37: < #define FALSE (0==1) ! 38: 46 d 25 ! 39: < /* Macros. */ ! 40: 49,50 c 28,29 ! 41: < /* Type definitions. */ ! 42: < typedef char bool; ! 43: --- ! 44: > #define TRUE (0==0) ! 45: > #define FALSE (0==1) ! 46: 52 c 31,37 ! 47: < typedef union { ! 48: --- ! 49: > typedef char bool; ! 50: > typedef unsigned char uchar; ! 51: > typedef unsigned int uint; ! 52: > typedef unsigned short ushort; ! 53: > typedef unsigned long ulong; ! 54: > ! 55: > typedef union { ! 56: 59 d 43 ! 57: < /* Link tables keep track of whether links have been properly preserved. */ ! 58: 65 c 49 ! 59: < uint_t l_nlink; ! 60: --- ! 61: > uint l_nlink; ! 62: 74 a 59 ! 63: > ! 64: 77 a 63 ! 65: > extern int errno; ! 66: 125 a 112,113 ! 67: > char *dot = "."; ! 68: > char *dotdot = ".."; ! 69: 130 a 119 ! 70: > char *usage = "usage: cpdir [options] dir1 dir2"; ! 71: 136 a 126 ! 72: > char *nomemory = "out of memory"; ! 73: 147 a 138 ! 74: > long lseek(); ! 75: 149,154 c 140,141 ! 76: < bool dirchecks(); ! 77: < bool suppress(); ! 78: < LINK *linklocate(); ! 79: < LINK *linkinstall(); ! 80: < bool linkattempt(); ! 81: < bool tgtunlink(); ! 82: --- ! 83: > char *realloc(); ! 84: > char *rindex(); ! 85: 156 a 144 ! 86: > bool suppress(); ! 87: 157 a 146,150 ! 88: > bool dirchecks(); ! 89: > bool linkattempt(); ! 90: > bool tgtunlink(); ! 91: > LINK *linklocate(); ! 92: > LINK *linkinstall(); ! 93: 168 c 161 ! 94: < return exitval; ! 95: --- ! 96: > return (exitval); ! 97: 177,178 c 170,173 ! 98: < if ((cp = *++av) == NULL) ! 99: < usage(); ! 100: --- ! 101: > if ((cp = *++av) == NULL) { ! 102: > errprint(fmt1, usage); ! 103: > exit(1); ! 104: > } ! 105: 220 c 215,216 ! 106: < usage(); ! 107: --- ! 108: > errprint(fmt1, usage); ! 109: > exit(1); ! 110: 225,226 c 221,225 ! 111: < if ((dir1=*av++) == NULL || (dir2=*av++) == NULL || *av != NULL) ! 112: < usage(); ! 113: --- ! 114: > if ((dir1=*av++) == NULL || (dir2=*av++) == NULL || *av != NULL) { ! 115: > errprint(fmt1, usage); ! 116: > exit(1); ! 117: > } ! 118: > return; ! 119: 272,275 c 271,278 ! 120: < if (stat(dir1, &srcstat) < 0) ! 121: < fatal(fmt2, dir1, nofind); ! 122: < if ((srcstat.st_mode & S_IFMT) != S_IFDIR) ! 123: < fatal(fmt2, dir1, notdir); ! 124: --- ! 125: > if (stat(dir1, &srcstat) < 0) { ! 126: > errprint(fmt2, dir1, nofind); ! 127: > exit(1); ! 128: > } ! 129: > if ((srcstat.st_mode & S_IFMT) != S_IFDIR) { ! 130: > errprint(fmt2, dir1, notdir); ! 131: > exit(1); ! 132: > } ! 133: 279,282 c 282,289 ! 134: < if (stat(cp, &tgtstat) < 0) ! 135: < fatal(fmt2, dir2, "cannot find parent"); ! 136: < if (access(cp, AWRITE|ASRCH) < 0) ! 137: < fatal(fmt2, dir2, nomkdir); ! 138: --- ! 139: > if (stat(cp, &tgtstat) < 0) { ! 140: > errprint(fmt2, dir2, "cannot find parent"); ! 141: > exit(1); ! 142: > } ! 143: > if (access(cp, AWRITE|ASRCH) < 0) { ! 144: > errprint(fmt2, dir2, nomkdir); ! 145: > exit(1); ! 146: > } ! 147: 291 a 299 ! 148: > return; ! 149: 296,300 c 304,307 ! 150: < * Assume: ! 151: < * Source is a directory we can read and search. Srcstat contains its status. ! 152: < * Target is a directory we can write and search. Tgtstat contains its status. ! 153: < * Src_dev and tgt_dev are the devices of the parents of source and target. ! 154: < * If tflag is on target may not exist. In this case tgtstat.st_dev ! 155: --- ! 156: > * Assume: Source is a directory we can read and search. Srcstat contains its ! 157: > * status. Target is a directory we can write and search. Tgtstat contains its ! 158: > * status. Src_dev and tgt_dev are the devices of the parents of source and ! 159: > * target. If tflag is on target may not exist. In this case tgtstat.st_dev ! 160: 370,371 c 377,378 ! 161: < !strcmp(dbp->db_name, ".") || ! 162: < !strcmp(dbp->db_name, "..")) ! 163: --- ! 164: > !strcmp(dbp->db_name, dot) || ! 165: > !strcmp(dbp->db_name, dotdot)) ! 166: 426 c 433 ! 167: < "cannot reopen, copy incomplete"); ! 168: --- ! 169: > "cannot reopen, copy incomplete"); ! 170: 441 a 449 ! 171: > return; ! 172: 466 d 473 ! 173: < LINK *lp; ! 174: 473 c 480 ! 175: < if (uflag && stat(target, &tgtstat) == 0) ! 176: --- ! 177: > if (uflag && stat(target, &tgtstat) == 0) ! 178: 475,478 d 481 ! 179: < /* ! 180: < * Target exists and is not older, do not update. ! 181: < * But watch out for links and keep the link counts sane. ! 182: < */ ! 183: 481,492 d 483 ! 184: < if (srcstat.st_nlink > 1) { ! 185: < if ((lp = linklocate(SOURCE)) == NULL) ! 186: < linkinstall(SOURCE); ! 187: < else if (lp->l_nlink == 0) ! 188: < linkpurge(SOURCE, lp); ! 189: < } ! 190: < if (tgtstat.st_nlink > 1) { ! 191: < if ((lp = linklocate(TARGET)) == NULL) ! 192: < linkinstall(TARGET); ! 193: < else if (lp->l_nlink == 0) ! 194: < linkpurge(TARGET, lp); ! 195: < } ! 196: 547 c 538 ! 197: < return FALSE; ! 198: --- ! 199: > return (FALSE); ! 200: 558 c 549 ! 201: < return FALSE; ! 202: --- ! 203: > return (FALSE); ! 204: 574 c 565 ! 205: < return FALSE; ! 206: --- ! 207: > return (FALSE); ! 208: 590,591 c 581,582 ! 209: < else ! 210: < vprintf(); ! 211: --- ! 212: > else vprintf(); ! 213: > return; ! 214: 619 a 611 ! 215: > return; ! 216: 636,637 c 628,631 ! 217: < if ((source = realloc(source, a+b)) == NULL) ! 218: < nomemory(); ! 219: --- ! 220: > if ((source = realloc(source, a+b)) == NULL) { ! 221: > errprint(fmt1, nomemory); ! 222: > exit(1); ! 223: > } ! 224: 646,647 c 640,643 ! 225: < if ((target = realloc(target, a+b)) == NULL) ! 226: < nomemory(); ! 227: --- ! 228: > if ((target = realloc(target, a+b)) == NULL) { ! 229: > errprint(fmt1, nomemory); ! 230: > exit(1); ! 231: > } ! 232: 667 a 664 ! 233: > return; ! 234: 690 c 687 ! 235: < return sum; ! 236: --- ! 237: > return (sum); ! 238: 704 a 702 ! 239: > return; ! 240: 707,713 d 704 ! 241: < fatal(arg) ! 242: < char *arg[]; ! 243: < { ! 244: < errprint("%r", &arg); ! 245: < exit(1); ! 246: < } ! 247: < ! 248: 722,724 c 713,717 ! 249: < if ((cp = malloc(n)) == NULL) ! 250: < nomemory(); ! 251: < return cp; ! 252: --- ! 253: > if ((cp = malloc(n)) == NULL) { ! 254: > errprint(fmt1, nomemory); ! 255: > exit(1); ! 256: > } ! 257: > return (cp); ! 258: 740 a 734,736 ! 259: > register int n; ! 260: > static int status; ! 261: > ! 262: 743 c 739 ! 263: < return FALSE; ! 264: --- ! 265: > return (FALSE); ! 266: 749 c 745 ! 267: < return FALSE; ! 268: --- ! 269: > return (FALSE); ! 270: 753 c 749 ! 271: < return FALSE; ! 272: --- ! 273: > return (FALSE); ! 274: 755 c 751 ! 275: < return TRUE; ! 276: --- ! 277: > return (TRUE); ! 278: 760 c 756 ! 279: < return TRUE; ! 280: --- ! 281: > return (TRUE); ! 282: 765 c 761 ! 283: < return FALSE; ! 284: --- ! 285: > return (FALSE); ! 286: 770 c 766 ! 287: < return FALSE; ! 288: --- ! 289: > return (FALSE); ! 290: 772 c 768 ! 291: < return TRUE; ! 292: --- ! 293: > return (TRUE); ! 294: 788 a 785 ! 295: > return; ! 296: 803 c 800 ! 297: < return FALSE; ! 298: --- ! 299: > return (FALSE); ! 300: 810 c 807 ! 301: < return TRUE; ! 302: --- ! 303: > return (TRUE); ! 304: 815 c 812 ! 305: < return FALSE; ! 306: --- ! 307: > return (FALSE); ! 308: 819 c 816 ! 309: < register uchar_t *cp; ! 310: --- ! 311: > register uchar *cp; ! 312: 821 c 818 ! 313: < register uint_t sum = 0; ! 314: --- ! 315: > register uint sum = 0; ! 316: 824 c 821 ! 317: < return sum % HASHSIZE; ! 318: --- ! 319: > return (sum % HASHSIZE); ! 320: 827,831 d 823 ! 321: < /* ! 322: < * Look for a LINK entry in the source or target link table. ! 323: < * If found, decrement the link count field and return a pointer to the LINK. ! 324: < * If not found, return NULL. ! 325: < */ ! 326: 842 c 834,835 ! 327: < } else { ! 328: --- ! 329: > } ! 330: > else { ! 331: 853 c 846 ! 332: < return lp; ! 333: --- ! 334: > return (lp); ! 335: 855 c 848 ! 336: < return NULL; ! 337: --- ! 338: > return (NULL); ! 339: 858,861 d 850 ! 340: < /* ! 341: < * Create a new LINK table entry and add it to the source or target LINK table. ! 342: < * Initialize its link count to nlinks - 1. ! 343: < */ ! 344: 892 c 881 ! 345: < return lp; ! 346: --- ! 347: > return (lp); ! 348: 895,897 d 883 ! 349: < /* ! 350: < * Purge LINK entry lp from the source or target LINK table. ! 351: < */ ! 352: 920 a 907 ! 353: > return; ! 354: 923,927 d 909 ! 355: < /* ! 356: < * The source file has a link count greater than 1. ! 357: < * If the source file is not in the source LINK list already, ! 358: < * add it to the list and return FALSE. ! 359: < */ ! 360: 935 d 916 ! 361: < ret = TRUE; ! 362: 937,938 c 918,919 ! 363: < linkinstall(SOURCE); /* add new source LINK */ ! 364: < return FALSE; ! 365: --- ! 366: > linkinstall(SOURCE); ! 367: > return (FALSE); ! 368: 942 c 923 ! 369: < if (tflag) { /* test only */ ! 370: --- ! 371: > if (tflag) { ! 372: 947 c 928,929 ! 373: < } else ! 374: --- ! 375: > } ! 376: > else { ! 377: 949 c 931,934 ! 378: < } else if (link(cp, target) == 0) { /* link succeeded */ ! 379: --- ! 380: > ret = TRUE; ! 381: > } ! 382: > } ! 383: > else if (link(cp, target) == 0) { ! 384: 951 c 936,938 ! 385: < } else { /* link failed */ ! 386: --- ! 387: > ret = TRUE; ! 388: > } ! 389: > else { ! 390: 959 c 946 ! 391: < return ret; ! 392: --- ! 393: > return (ret); ! 394: 962,966 d 948 ! 395: < /* ! 396: < * Unlink the target. ! 397: < * Return TRUE if the unlink is successful (or target does not exist) ! 398: < * or FALSE if the unlink fails. ! 399: < */ ! 400: 973 c 955 ! 401: < return TRUE; ! 402: --- ! 403: > return (TRUE); ! 404: 976,979 c 958 ! 405: < return FALSE; ! 406: < } else if ((tgtstat.st_mode & S_IFMT) != (srcstat.st_mode & S_IFMT)) { ! 407: < errprint(fmt3, source, "file type mismatch with ", target); ! 408: < return FALSE; ! 409: --- ! 410: > return (FALSE); ! 411: 980 a 960,963 ! 412: > else if ((tgtstat.st_mode & S_IFMT) != (srcstat.st_mode & S_IFMT)) { ! 413: > errprint(fmt3, source, "file type mismatch with ", target); ! 414: > return (FALSE); ! 415: > } ! 416: 981 a 965,969 ! 417: > if (!tflag) ! 418: > if (unlink(target) < 0) { ! 419: > errprint(fmt2, target, nounlink); ! 420: > return (FALSE); ! 421: > } ! 422: 984,987 d 971 ! 423: < else if (unlink(target) < 0) { ! 424: < errprint(fmt2, target, nounlink); ! 425: < return FALSE; /* unlink failed */ ! 426: < } ! 427: 989,990 c 973 ! 428: < /* The unlink succeeded, decrement the target link count. */ ! 429: < if ((lp = linklocate(TARGET)) != NULL) { /* target LINK exists */ ! 430: --- ! 431: > if ((lp = linklocate(TARGET)) != NULL) { ! 432: 993,995 c 976,979 ! 433: < } else if (tgtstat.st_nlink > 1) ! 434: < linkinstall(TARGET); /* add new target LINK */ ! 435: < return TRUE; ! 436: --- ! 437: > } ! 438: > else if (tgtstat.st_nlink > 1) ! 439: > linkinstall(TARGET); ! 440: > return (TRUE); ! 441: 998,1001 d 981 ! 442: < /* ! 443: < * Report on link botches. ! 444: < * This information is not known until the actual copying is finished. ! 445: < */ ! 446: 1026 a 1007 ! 447: > return; ! 448: 1048 a 1030 ! 449: > return; ! 450: 1073 c 1055 ! 451: < return ret; ! 452: --- ! 453: > return (ret); ! 454: 1086 c 1068 ! 455: < return "."; ! 456: --- ! 457: > return (dot); ! 458: 1089 c 1071 ! 459: < return ret; ! 460: --- ! 461: > return (ret); ! 462: 1097 d 1078 ! 463: < ! 464: 1100,1101 c 1081,1082 ! 465: < return FALSE; ! 466: < return TRUE; ! 467: --- ! 468: > return (FALSE); ! 469: > return (TRUE); ! 470: 1142,1154 d 1122 ! 471: < ! 472: < usage() ! 473: < { ! 474: < fprintf(stderr, "Usage: cpdir [options] dir1 dir2\n"); ! 475: < exit(1); ! 476: < } ! 477: < ! 478: < nomemory() ! 479: < { ! 480: < fatal(fmt1, "out of memory"); ! 481: < } ! 482: < ! 483: < /* end of cpdir.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.