![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tar.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 tar.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 ! root 1: /* ! 2: * Tape archive ! 3: * tar [0-7bcflmrtuvwx]+ [blocks] [archive] pathname* ! 4: */ ! 5: ! 6: #include <stdio.h> ! 7: #include <sys/types.h> ! 8: #include <errno.h> ! 9: #include <canon.h> ! 10: #include <sys/stat.h> ! 11: #include <sys/dir.h> ! 12: ! 13: #define S_PERM 07777 /* should be in stat.h */ ! 14: ! 15: /* Possible actions for do_checksum_error(). */ ! 16: #define CLEAR 0 /* Print all pending messages. */ ! 17: #define ADD 1 /* Add another pending message. */ ! 18: ! 19: #define MAXBLK 20 ! 20: #define roundup(n, r) (((n)+(r)-1)/(r)) ! 21: ! 22: typedef struct dirhd_t { ! 23: dev_t t_dev; ! 24: ino_t t_ino; ! 25: unsigned short t_nlink, ! 26: t_mode, ! 27: t_uid, ! 28: t_gid; ! 29: fsize_t t_size; ! 30: time_t t_mtime; ! 31: char *t_name; ! 32: struct dirhd_t *t_cont[]; ! 33: } dirhd_t; ! 34: ! 35: typedef union tarhd_t { ! 36: struct { ! 37: char th_name[100], ! 38: th_mode[8], ! 39: th_uid[8], ! 40: th_gid[8], ! 41: th_size[12], ! 42: th_mtime[12], ! 43: th_check[8], ! 44: th_islink, ! 45: th_link[100], ! 46: th_pad[255]; ! 47: } th_info; ! 48: char th_data[BUFSIZ]; ! 49: } tarhd_t; ! 50: ! 51: typedef unsigned short flag_t; /* fastest type for machine */ ! 52: ! 53: flag_t linkmsg = 0, /* message if not all links found */ ! 54: modtime = 1, /* restore modtimes */ ! 55: verbose = 0; ! 56: unixbug = 0; /* avoid bug in U**X tar */ ! 57: FILE *whether = (FILE *)NULL, /* ask about each file */ ! 58: *tarfile; ! 59: char tapedev[10] = '\0'; ! 60: char *archive = &tapedev[0]; ! 61: unsigned short blocking = 1; /* blocking factor */ ! 62: time_t oldtime[2], /* for utime */ ! 63: recently, /* set to 6 months ago for tv key */ ! 64: time(); ! 65: ! 66: dirhd_t *newdirhd(), ! 67: *update(), ! 68: *research(); ! 69: tarhd_t *readhdr(), ! 70: *readblk(), ! 71: *writeblk(); ! 72: char *havelink(); ! 73: long getoctl(); ! 74: extern char *malloc(); ! 75: extern char *ctime(); ! 76: ! 77: main(argc, argv) ! 78: int argc; ! 79: char *argv[]; ! 80: { ! 81: char *key, ! 82: unit = '\0', ! 83: function = 0, ! 84: deffunc, ! 85: prefix[101] = '\0'; ! 86: unsigned short arg = 2; ! 87: dirhd_t *args; ! 88: ! 89: if (argc < 2) { ! 90: fprintf(stderr, ! 91: "Usage: %s [crtux][0-7bflmvw] [blocks] [archive] pathname*\n", ! 92: argv[0]); ! 93: exit(-1); ! 94: } ! 95: for (key = argv[1]; *key != '\0'; key++) switch (*key) { ! 96: case '0': ! 97: case '1': ! 98: case '2': ! 99: case '3': ! 100: case '4': ! 101: case '5': ! 102: case '6': ! 103: case '7': ! 104: unit = *key; ! 105: deffunc = 't'; ! 106: continue; ! 107: case 'b': ! 108: if (argc <= arg) ! 109: fatal("missing blocking factor"); ! 110: else if ((blocking = atoi(argv[arg++])) <= 0 ! 111: || blocking > MAXBLK) ! 112: fatal("illegal blocking factor"); ! 113: deffunc = 'r'; ! 114: continue; ! 115: case 'f': ! 116: if (argc <= arg) ! 117: fatal("missing archive name"); ! 118: else ! 119: archive = argv[arg++]; ! 120: deffunc = 't'; ! 121: continue; ! 122: case 'l': ! 123: linkmsg = 1; ! 124: deffunc = 'r'; ! 125: continue; ! 126: case 'm': ! 127: modtime = 0; ! 128: deffunc = 'x'; ! 129: continue; ! 130: case 'v': ! 131: verbose = 1; ! 132: deffunc = 't'; ! 133: continue; ! 134: case 'U': ! 135: unixbug = 1; ! 136: deffunc = 't'; ! 137: continue; ! 138: case 'w': ! 139: whether = fopen("/dev/tty", "r+w"); ! 140: deffunc = 'x'; ! 141: continue; ! 142: case 'c': ! 143: case 'r': ! 144: case 't': ! 145: case 'u': ! 146: case 'x': ! 147: if (function) ! 148: fatal("keys c, r, t, u, x are mutually exclusive"); ! 149: else ! 150: function = *key; ! 151: continue; ! 152: default: ! 153: fatal("illegal key '%c'", *key); ! 154: } ! 155: if (!function) ! 156: function = deffunc; ! 157: oldtime[0] = time((time_t *)0); ! 158: if (verbose && function=='t') ! 159: recently = oldtime[0] - 6*((time_t)30*24*60*60); ! 160: ! 161: /* construct descriptors for args given */ ! 162: ! 163: args = (dirhd_t *) malloc(sizeof (dirhd_t) ! 164: + (argc-arg)*sizeof (dirhd_t *)); ! 165: if (args == NULL) ! 166: fatal("out of memory"); ! 167: args->t_mode = S_IFDIR; ! 168: args->t_nlink = 0; ! 169: for (; arg < argc; arg++) { ! 170: dirhd_t *argp; ! 171: ! 172: if ((argp = newdirhd(argv[arg], strlen(argv[arg]))) == NULL) ! 173: fprintf(stderr, "Tar: %s: out of memory\n", argv[arg]); ! 174: else ! 175: args->t_cont[args->t_nlink++] = argp; ! 176: } ! 177: ! 178: /* open archive file */ ! 179: ! 180: if (*archive == '\0') ! 181: sprintf(archive, "/dev/%smt%c", blocking==1 ? "" : "r", unit); ! 182: if (function=='t' || function=='x') ! 183: if (strcmp(archive, "-")==0) ! 184: tarfile = stdin; ! 185: else ! 186: tarfile = fopen(archive, "r"); ! 187: else if (function=='c') ! 188: if (strcmp(archive, "-")==0) ! 189: tarfile = stdout; ! 190: else ! 191: tarfile = fopen(archive, "w"); ! 192: else ! 193: tarfile = fopen(archive, "r+w"); ! 194: if (tarfile==NULL) { ! 195: exit(perror("Tar: 1: %s", archive)); ! 196: } ! 197: setbuf(tarfile, NULL); ! 198: ! 199: /* perform required function */ ! 200: ! 201: switch (function) { ! 202: case 't': ! 203: table(args); ! 204: break; ! 205: case 'x': ! 206: extract(args); ! 207: break; ! 208: case 'r': ! 209: while (readblk() != NULL) ! 210: ; ! 211: goto doappend; ! 212: case 'u': ! 213: if ((args = update(prefix, args, readhdr())) == NULL) ! 214: break; ! 215: case 'c': ! 216: doappend: ! 217: append(prefix, args); ! 218: flushtar(); ! 219: } ! 220: /* Flush any remaining checksum messages. */ ! 221: do_checksum_error(NULL, CLEAR); ! 222: ! 223: exit(errno); ! 224: } ! 225: ! 226: fatal(args) ! 227: char *args; ! 228: { ! 229: /* Flush any remaining checksum messages. */ ! 230: do_checksum_error(NULL, CLEAR); ! 231: ! 232: fprintf(stderr, "tar: %r\n", &args); ! 233: exit(-1); ! 234: } ! 235: ! 236: dirhd_t * ! 237: newdirhd(name, len) ! 238: register char *name; ! 239: unsigned short len; ! 240: { ! 241: register dirhd_t *dp; ! 242: ! 243: if ((dp = (dirhd_t *) malloc(sizeof (dirhd_t))) != NULL ! 244: && (dp->t_name = malloc(len+1)) == NULL) { ! 245: free(dp); ! 246: dp = NULL; ! 247: } ! 248: if (dp != NULL) { ! 249: dp->t_nlink = 0; ! 250: strncpy(dp->t_name, name, len); ! 251: dp->t_name[len] = '\0'; ! 252: } ! 253: return (dp); ! 254: } ! 255: int ! 256: perror(args) ! 257: char *args; ! 258: { ! 259: register int err; ! 260: ! 261: if ((err=errno) >= sys_nerr) ! 262: fprintf(stderr, "%r: Bad error number\n", &args); ! 263: else if (err) ! 264: fprintf(stderr, "%r: %s\n", &args, sys_errlist[err]); ! 265: return (err); ! 266: } ! 267: ! 268: table(args) ! 269: register dirhd_t *args; ! 270: { ! 271: register tarhd_t *header; ! 272: ! 273: for (; (header = readhdr()) != NULL; skipfile(header)) { ! 274: if (argcont(args, header->th_info.th_name, 0) < 0) ! 275: continue; ! 276: if (verbose) { ! 277: register unsigned short mode = getoct(header->th_info.th_mode); ! 278: unsigned short uid = getoct(header->th_info.th_uid), ! 279: gid = getoct(header->th_info.th_gid); ! 280: fsize_t size = getoctl(header->th_info.th_size); ! 281: time_t mtime = getoctl(header->th_info.th_mtime); ! 282: char *timestr = ctime(&mtime); ! 283: ! 284: if (header->th_info.th_name[strnlen(header->th_info.th_name, 100)-1] ! 285: == '/') ! 286: putchar('d'); ! 287: else ! 288: putchar('-'); ! 289: printf("%c%c%c", ! 290: mode&S_IREAD ? 'r' : '-', ! 291: mode&S_IWRITE ? 'w' : '-', ! 292: mode&S_ISUID ? 's' : ! 293: mode&S_IEXEC ? 'x' : '-'); ! 294: printf("%c%c%c", ! 295: mode&S_IREAD>>3 ? 'r' : '-', ! 296: mode&S_IWRITE>>3 ? 'w' : '-', ! 297: mode&S_ISGID ? 's' : ! 298: mode&S_IEXEC>>3 ? 'x' : '-'); ! 299: printf("%c%c%c", ! 300: mode&S_IREAD>>6 ? 'r' : '-', ! 301: mode&S_IWRITE>>6 ? 'w' : '-', ! 302: mode&S_ISVTX ? 't' : ! 303: mode&S_IEXEC>>6 ? 'x' : '-'); ! 304: printf("%3d %3d %6ld %.11s%.5s ", ! 305: gid, ! 306: uid, ! 307: size, ! 308: timestr, ! 309: mtime > recently ? timestr+11 : timestr+19); ! 310: } ! 311: printf("%.100s", header->th_info.th_name); ! 312: if (header->th_info.th_islink) ! 313: if (verbose) ! 314: printf("\n%33s link to %s\n", "", ! 315: header->th_info.th_link); ! 316: else ! 317: printf(" link to %s\n", header->th_info.th_link); ! 318: else ! 319: putchar('\n'); ! 320: } ! 321: } ! 322: ! 323: extract(args) ! 324: register dirhd_t *args; ! 325: { ! 326: register tarhd_t *header; ! 327: short skipping = 0; ! 328: ! 329: while ((header = readhdr()) != NULL) { ! 330: register char name[101]; ! 331: unsigned short namelen = strnlen(header->th_info.th_name, 100), ! 332: mode, ! 333: uid, ! 334: gid; ! 335: ! 336: if (!skipping || contains(name, header->th_info.th_name) >= 0) { ! 337: strncpy(name, header->th_info.th_name, namelen); ! 338: name[namelen--] = '\0'; ! 339: if ((skipping = argcont(args, name, 0)) >= 0) ! 340: skipping = disallow('x', name); ! 341: } ! 342: switch (skipping) { ! 343: case -1: ! 344: skipping = 0; ! 345: case 1: ! 346: skipfile(header); ! 347: continue; ! 348: } ! 349: if (verbose) ! 350: printf("x %s\n", name); ! 351: mode = getoct(header->th_info.th_mode); ! 352: uid = getoct(header->th_info.th_uid); ! 353: gid = getoct(header->th_info.th_gid); ! 354: oldtime[1] = getoctl(header->th_info.th_mtime); ! 355: if (name[namelen] == '/') { ! 356: name[namelen] = '\0'; ! 357: makepath(name); ! 358: chmod(name, mode); ! 359: name[namelen] = '/'; ! 360: } else if (header->th_info.th_islink == '\0') { ! 361: int fd = recreate(name, mode); ! 362: fsize_t size = getoctl(header->th_info.th_size); ! 363: ! 364: for (; size > 0; size -= sizeof (tarhd_t)) { ! 365: int my_size; ! 366: ! 367: /* Handle unexpected EOF - mods by [email protected] */ ! 368: if ((header = readblk()) == NULL) { ! 369: fprintf(stderr, ! 370: "Unexpected end of the file %s\n", ! 371: name); ! 372: break; ! 373: } ! 374: if (size > sizeof(tarhd_t)) ! 375: my_size = sizeof(tarhd_t); ! 376: else ! 377: my_size = (int) size; ! 378: if (fd >= 0 && (write(fd, header->th_data, ! 379: my_size) != my_size)) ! 380: ! 381: perror("Tar: 2: %s", name); ! 382: } ! 383: if (fd >= 0) ! 384: close(fd); ! 385: } else { ! 386: struct stat statbuf; ! 387: flag_t xlink = 1; ! 388: ! 389: if (stat(header->th_info.th_link, &statbuf) < 0) ! 390: close(recreate(header->th_info.th_link, mode)); ! 391: else if (havelink(statbuf.st_dev, statbuf.st_ino, 0) ! 392: != NULL) ! 393: xlink = 0; ! 394: if (xlink) ! 395: fprintf(stderr, "Tar: Must extract %s\n", ! 396: header->th_info.th_link); ! 397: unlink(name); ! 398: mkparent(name); ! 399: if (link(header->th_info.th_link, name) < 0) ! 400: fprintf(stderr, "Tar: Can't link %s to %s\n", ! 401: name, header->th_info.th_link); ! 402: } ! 403: if (modtime) ! 404: utime(name, oldtime); ! 405: chown(name, uid, gid); ! 406: } ! 407: } ! 408: ! 409: dirhd_t * ! 410: update(name, args, header) ! 411: char *name; ! 412: register dirhd_t *args; ! 413: tarhd_t *header; ! 414: { ! 415: unsigned short namelen = strlen(name); ! 416: flag_t donedir = 0; ! 417: ! 418: if (header == NULL) ! 419: return (args); ! 420: if (args->t_nlink == 0 && (args = research(name, args)) == NULL) ! 421: return (NULL); ! 422: do switch (args->t_mode&S_IFMT) { ! 423: register short arg; ! 424: register dirhd_t *argp; ! 425: ! 426: case S_IFREG: ! 427: if (args->t_mtime <= getoctl(header->th_info.th_mtime)) ! 428: args->t_nlink = 0; ! 429: skipfile(header); ! 430: continue; ! 431: case S_IFDIR: ! 432: if (namelen != 0 && !donedir) { ! 433: name[namelen] = '/'; ! 434: donedir++; ! 435: } ! 436: if ((arg = argcont(args, header->th_info.th_name+namelen+donedir, -1)) ! 437: >= 0) { ! 438: strcpy(name+namelen+donedir, ! 439: (argp=args->t_cont[arg])->t_name); ! 440: if ((args->t_cont[arg] = update(name, argp, header)) ! 441: == NULL) ! 442: args->t_cont[arg] ! 443: = args->t_cont[--args->t_nlink]; ! 444: } else ! 445: skipfile(header); ! 446: name[namelen+donedir] = '\0'; ! 447: } while ((header=readhdr()) != NULL ! 448: && contains(name, header->th_info.th_name)); ! 449: if (header != NULL) ! 450: ungetblk(); ! 451: if (args->t_nlink == 0) { ! 452: if (namelen != 0) ! 453: free(args->t_name); ! 454: free((char *) args); ! 455: return (NULL); ! 456: } else ! 457: return (args); ! 458: } ! 459: ! 460: append(name, args) ! 461: char *name; ! 462: register dirhd_t *args; ! 463: { ! 464: unsigned short namelen; ! 465: register unsigned short arg; ! 466: register dirhd_t *argp; ! 467: ! 468: if ((namelen = strlen(name)) != 0 && disallow('a', name)) ! 469: return; ! 470: if (args->t_nlink == 0 && (args = research(name, args)) == NULL) ! 471: return; ! 472: switch (args->t_mode&S_IFMT) { ! 473: case S_IFDIR: ! 474: if (namelen != 0) { ! 475: name[namelen++] = '/'; name[namelen] = '\0'; ! 476: writehdr(name, args, ""); ! 477: } ! 478: for (arg = 0; arg < args->t_nlink; arg++) { ! 479: strcpy(name+namelen, (argp=args->t_cont[arg])->t_name); ! 480: append(name, argp); ! 481: } ! 482: break; ! 483: case S_IFREG: ! 484: if (args->t_nlink != 1) { ! 485: char *link; ! 486: ! 487: if ((link=havelink(args->t_dev, ! 488: args->t_ino, 1))!=NULL) { ! 489: writehdr(name, args, link); ! 490: break; ! 491: } else { ! 492: filelink(args->t_dev, ! 493: args->t_ino, ! 494: args->t_nlink, ! 495: name); ! 496: } ! 497: } ! 498: writehdr(name, args, ""); ! 499: writefil(name, args->t_size); ! 500: } ! 501: if (namelen != 0) ! 502: free(args->t_name); ! 503: free((char *) args); ! 504: } ! 505: ! 506: dirhd_t * ! 507: research(name, args) ! 508: char *name; ! 509: register dirhd_t *args; ! 510: { ! 511: unsigned short namelen; ! 512: register short nfile; ! 513: int fd; ! 514: struct stat statbuf; ! 515: ! 516: if ((namelen = strlen(name)) == 0) ! 517: name = "."; ! 518: if (stat(name, &statbuf) < 0) { ! 519: perror("Tar: 3: %s", name); ! 520: return (args); ! 521: } ! 522: args->t_dev = statbuf.st_dev; ! 523: args->t_ino = statbuf.st_ino; ! 524: args->t_nlink = statbuf.st_nlink; ! 525: args->t_uid = statbuf.st_uid; ! 526: args->t_gid = statbuf.st_gid; ! 527: args->t_mtime = statbuf.st_mtime; ! 528: switch ((args->t_mode = statbuf.st_mode)&S_IFMT) { ! 529: case S_IFREG: ! 530: args->t_size = statbuf.st_size; ! 531: return (args); ! 532: default: ! 533: args->t_size = 0; ! 534: return (args); ! 535: case S_IFDIR: ! 536: args->t_size = 0; ! 537: } ! 538: if ((nfile = (short) (statbuf.st_size/sizeof (struct direct))) > 2) { ! 539: args = (dirhd_t *) realloc((char *)args, ! 540: sizeof (dirhd_t) + (nfile-2)*sizeof (dirhd_t *)); ! 541: if (args == NULL) { ! 542: fprintf(stderr, "Tar: %s: out of memory\n", name); ! 543: return (NULL); ! 544: } ! 545: } ! 546: args->t_nlink = 0; ! 547: if ((fd = open(name, 0)) < 0) { ! 548: perror("Tar: 4: %s", name); ! 549: return (args); ! 550: } ! 551: for (; nfile > 0; --nfile) { ! 552: struct direct dir_ent; ! 553: unsigned short arglen; ! 554: dirhd_t *argp; ! 555: ! 556: switch (read(fd, (char *)&dir_ent, sizeof (struct direct))) { ! 557: case -1: ! 558: perror("Tar: 5: %s", name); ! 559: case 0: ! 560: break; ! 561: default: ! 562: if (dir_ent.d_ino == 0 ! 563: || strcmp(dir_ent.d_name, ".") == 0 ! 564: || strcmp(dir_ent.d_name, "..") == 0) ! 565: continue; ! 566: else if ((arglen=strnlen(dir_ent.d_name, DIRSIZ)) ! 567: + namelen > 99) ! 568: fprintf(stderr, ! 569: "Tar: %s/%.*s: name too long\n", ! 570: name, DIRSIZ, dir_ent.d_name); ! 571: else if ((argp = newdirhd(dir_ent.d_name, arglen)) ! 572: == NULL) ! 573: fprintf(stderr, ! 574: "Tar: %s/%.*s: out of memory\n", ! 575: name, DIRSIZ, dir_ent.d_name); ! 576: else ! 577: args->t_cont[args->t_nlink++] = argp; ! 578: continue; ! 579: } ! 580: break; ! 581: } ! 582: close(fd); ! 583: return (args); ! 584: } ! 585: ! 586: int ! 587: argcont(args, name, ret) ! 588: register dirhd_t *args; ! 589: char *name; ! 590: int ret; ! 591: { ! 592: register unsigned short arg; ! 593: ! 594: if (args->t_nlink == 0) ! 595: return (ret); ! 596: else for (arg = 0; arg < args->t_nlink; arg++) ! 597: if (contains(args->t_cont[arg]->t_name, name)) ! 598: return (arg); ! 599: return (-1); ! 600: } ! 601: ! 602: int ! 603: strnlen(str, maxlen) ! 604: register char *str; ! 605: register unsigned short maxlen; ! 606: { ! 607: register unsigned short len = 0; ! 608: ! 609: while (maxlen && *str++ != '\0') { ! 610: --maxlen; ++len; ! 611: } ! 612: return (len); ! 613: } ! 614: ! 615: /* ! 616: * Create file system paths ! 617: */ ! 618: ! 619: int ! 620: makepath(pathname) ! 621: char *pathname; ! 622: { ! 623: struct stat statbuf; ! 624: register int err; ! 625: ! 626: if (stat(pathname, &statbuf) == 0) ! 627: if ((statbuf.st_mode&S_IFMT) == S_IFDIR) ! 628: return (0); ! 629: else ! 630: errno = ENOTDIR; ! 631: else if (errno == ENOENT) { ! 632: errno = 0; ! 633: if ((err=mkparent(pathname)) != 0) ! 634: return err; ! 635: return mkdir(pathname); ! 636: } ! 637: return (perror("Tar: 6: %s", pathname)); ! 638: } ! 639: ! 640: int ! 641: mkparent(pathname) ! 642: register char *pathname; ! 643: { ! 644: register char *pathend = &pathname[strlen(pathname)]; ! 645: ! 646: while (pathend > pathname && *--pathend != '/') ! 647: ; ! 648: if (pathend > pathname) { ! 649: *pathend = '\0'; ! 650: errno = makepath(pathname); ! 651: *pathend = '/'; ! 652: } else ! 653: errno = 0; ! 654: return (errno); ! 655: } ! 656: ! 657: mkdir(pathname) ! 658: char *pathname; ! 659: { ! 660: int status; ! 661: ! 662: switch(fork()) { ! 663: case -1: ! 664: break; ! 665: case 0: ! 666: close(2); ! 667: execl("/bin/mkdir", "mkdir", pathname, NULL); ! 668: exit(errno); ! 669: default: ! 670: wait(&status); ! 671: errno = status>>8; ! 672: } ! 673: return (perror("Tar: 7: %s", pathname)); ! 674: } ! 675: ! 676: int ! 677: recreate(pathname, mode) ! 678: char *pathname; ! 679: unsigned short mode; ! 680: { ! 681: int fd; ! 682: ! 683: if ((fd = create(pathname, mode)) < 0 ! 684: && (errno != ENOENT ! 685: || mkparent(pathname) == 0 && (fd = create(pathname, mode)) < 0)) ! 686: perror("Tar: 8: %s", pathname); ! 687: errno = 0; ! 688: return (fd); ! 689: } ! 690: ! 691: int ! 692: create(pathname, mode) ! 693: char *pathname; ! 694: unsigned short mode; ! 695: { ! 696: int fd; ! 697: ! 698: unlink(pathname); ! 699: if ((fd = creat(pathname, mode)) >= 0) { ! 700: struct stat statbuf; ! 701: ! 702: fstat(fd, &statbuf); ! 703: filelink(statbuf.st_dev, statbuf.st_ino, ! 704: statbuf.st_nlink, pathname); ! 705: } ! 706: return (fd); ! 707: } ! 708: ! 709: /* ! 710: * Ask about current action ! 711: */ ! 712: ! 713: int ! 714: disallow(function, pathname) ! 715: char function, ! 716: *pathname; ! 717: { ! 718: while (whether) { ! 719: register int c1, ! 720: c; ! 721: ! 722: fprintf(whether, "%c %s? ", function, pathname); ! 723: for (c1=c=getc(whether); c!=EOF && c!='\n'; c=getc(whether)) ! 724: ; ! 725: switch (c1) { ! 726: case EOF: ! 727: case 'x': ! 728: if (function == 'a') ! 729: flushtar(); ! 730: exit(errno); ! 731: case '\n': ! 732: case 'n': ! 733: case 'N': ! 734: return (1); ! 735: case 'y': ! 736: case 'Y': ! 737: return (0); ! 738: } ! 739: } ! 740: return (0); ! 741: } ! 742: ! 743: /* ! 744: * High level I/O routines ! 745: */ ! 746: ! 747: tarhd_t * ! 748: readhdr() ! 749: { ! 750: register tarhd_t *header; ! 751: ! 752: while ((header = readblk()) != NULL) { ! 753: if (header->th_info.th_name[0] == '\0') ! 754: if (unixbug) { ! 755: ungetblk(); ! 756: return (NULL); ! 757: } else ! 758: continue; ! 759: else { ! 760: int check = getoct(header->th_info.th_check); ! 761: ! 762: strncpy(header->th_info.th_check, " ", ! 763: sizeof(header->th_info.th_check)); ! 764: if (checksum(header->th_data, sizeof(tarhd_t)) != check){ ! 765: do_checksum_error(header->th_info.th_name, ADD); ! 766: } else { ! 767: do_checksum_error(NULL, CLEAR); ! 768: break; ! 769: } ! 770: } ! 771: } ! 772: /* We shouldn't have to check EVERY header, but if we do it here ! 773: * it gets done for every routine. ! 774: * Newer tar programs use the first eight bytes of the ! 775: * pad field as magic to indicate the type of archive. ! 776: * With old tar archives, these eight characters should be ! 777: * NUL. We'll only check the first one. ! 778: */ ! 779: /* Check to see if this is a v7 style tar archive. */ ! 780: if ((char)0 != header->th_info.th_pad[0]) { ! 781: fatal("%.8s archive, not v7 archive.", ! 782: header->th_info.th_pad); ! 783: ! 784: } ! 785: return (header); ! 786: } ! 787: ! 788: skipfile(header) ! 789: tarhd_t *header; ! 790: { ! 791: register fsize_t size; ! 792: ! 793: if (header->th_info.th_islink) ! 794: return; ! 795: for (size = getoctl(header->th_info.th_size); ! 796: size > 0 && readblk() != NULL; ! 797: size -= sizeof (tarhd_t)) ! 798: ; ! 799: } ! 800: ! 801: writehdr(name, args, link) ! 802: char *name; ! 803: register dirhd_t *args; ! 804: char *link; ! 805: { ! 806: register tarhd_t *header = writeblk(); ! 807: ! 808: if (verbose) ! 809: fprintf(stderr, "a %s", name); ! 810: strncpy(header->th_info.th_name, name, sizeof(header->th_info.th_name)); ! 811: putoct(header->th_info.th_mode, args->t_mode&S_PERM); ! 812: putoct(header->th_info.th_uid, args->t_uid); ! 813: putoct(header->th_info.th_gid, args->t_gid); ! 814: putoctl(header->th_info.th_size, args->t_size); ! 815: putoctl(header->th_info.th_mtime, args->t_mtime); ! 816: strncpy(header->th_info.th_check, " ", sizeof(header->th_info.th_check)); ! 817: if (*link == '\0') { ! 818: header->th_info.th_islink = 0; ! 819: if (verbose) ! 820: if (args->t_size == 0) ! 821: putc('\n', stderr); ! 822: else ! 823: fprintf(stderr, " %ld block%s\n", ! 824: roundup(args->t_size, BUFSIZ), ! 825: args->t_size <= BUFSIZ ? "" : "s"); ! 826: } else { ! 827: header->th_info.th_islink = '1'; ! 828: if (verbose) ! 829: fprintf(stderr, " link to %s\n", link); ! 830: } ! 831: strncpy(header->th_info.th_link, link, sizeof(header->th_info.th_link)); ! 832: strncpy(header->th_info.th_pad, "", sizeof(header->th_info.th_pad)); ! 833: putoct(header->th_info.th_check, checksum(header->th_data, sizeof(tarhd_t))); ! 834: } ! 835: ! 836: writefil(name, size) ! 837: char *name; ! 838: register fsize_t size; ! 839: { ! 840: int fd; ! 841: register tarhd_t *header; ! 842: ! 843: if ((fd = open(name, 0)) < 0) { ! 844: perror("Tar: 9: %s", name); ! 845: } ! 846: for (; size > 0; size -= sizeof (tarhd_t)) { ! 847: header = writeblk(); ! 848: if (fd >= 0) ! 849: read(fd, header->th_data, sizeof (tarhd_t)); ! 850: else ! 851: strncpy(header->th_data, "", sizeof (tarhd_t)); ! 852: } ! 853: if (fd >= 0) ! 854: close(fd); ! 855: } ! 856: ! 857: /* ! 858: * Tape I/O, with record blocking if specified ! 859: */ ! 860: ! 861: tarhd_t buffer[MAXBLK], ! 862: *current = &buffer[0]; ! 863: ! 864: tarhd_t * ! 865: readblk() ! 866: { ! 867: static unsigned short blocks = 0; ! 868: ! 869: if (feof(tarfile)) ! 870: return (NULL); ! 871: if (current == &buffer[blocks]) { ! 872: current = &buffer[0]; ! 873: blocks = fread((char *) buffer, ! 874: sizeof (tarhd_t), MAXBLK, tarfile); ! 875: if (ferror(tarfile)) { ! 876: exit(perror("Tar: 10: %s", archive)); ! 877: } else if (feof(tarfile)) { ! 878: /* This is a hack. We should actually find ! 879: * out why returning NULL is not good enough. ! 880: * ! 881: * Really a pain without a symbolic debugger! ! 882: */ ! 883: exit(0); ! 884: } ! 885: } ! 886: return (current++); ! 887: } ! 888: ! 889: ungetblk() ! 890: { ! 891: --current; ! 892: } ! 893: ! 894: tarhd_t * ! 895: writeblk() ! 896: { ! 897: if (current == &buffer[blocking]) { ! 898: current = &buffer[0]; ! 899: fwrite((char *)buffer, sizeof (tarhd_t), blocking, tarfile); ! 900: if (ferror(tarfile) || feof(tarfile)) { ! 901: exit(perror("Tar: 11: %s", archive)); ! 902: } ! 903: } ! 904: return (current++); ! 905: } ! 906: ! 907: flushtar() ! 908: { ! 909: register tarhd_t *header; ! 910: ! 911: while ((header=writeblk()) != &buffer[0]) ! 912: strncpy(header->th_data, "", sizeof (tarhd_t)); ! 913: if (linkmsg) ! 914: misslink(); ! 915: } ! 916: ! 917: /* ! 918: * Keep track of files by ino in hash table ! 919: */ ! 920: ! 921: typedef struct link_t { ! 922: dev_t t_dev; ! 923: ino_t t_ino; ! 924: unsigned short t_nlink; ! 925: struct link_t *t_next; ! 926: char t_link[]; ! 927: } link_t; ! 928: ! 929: #define NHASH 64 ! 930: ! 931: link_t *linklist[NHASH]; ! 932: ! 933: filelink(dev, ino, nlink, link) ! 934: dev_t dev; ! 935: ino_t ino; ! 936: unsigned short nlink; ! 937: char *link; ! 938: { ! 939: unsigned short id = ino%NHASH; ! 940: register link_t *lp; ! 941: ! 942: lp = (link_t *) malloc(sizeof (link_t) + strlen(link) + 1); ! 943: if (lp == NULL) ! 944: fprintf(stderr, "Tar: %s: note: link info lost\n", link); ! 945: else { ! 946: lp->t_next = linklist[id]; ! 947: linklist[id] = lp; ! 948: lp->t_dev = dev; ! 949: lp->t_ino = ino; ! 950: lp->t_nlink = nlink; ! 951: strcpy(lp->t_link, link); ! 952: } ! 953: } ! 954: ! 955: char * ! 956: havelink(dev, ino, flag) ! 957: dev_t dev; ! 958: ino_t ino; ! 959: flag_t flag; ! 960: { ! 961: register link_t *lp; ! 962: ! 963: for (lp = linklist[ino%NHASH]; lp != NULL; lp = lp->t_next) { ! 964: if (lp->t_ino == ino && lp->t_dev == dev) { ! 965: if (flag) ! 966: --lp->t_nlink; ! 967: return (lp->t_link); ! 968: } ! 969: } ! 970: return (NULL); ! 971: } ! 972: ! 973: misslink() ! 974: { ! 975: unsigned short ino; ! 976: ! 977: for (ino = 0; ino < NHASH; ino++) { ! 978: register link_t *lp; ! 979: ! 980: for (lp = linklist[ino]; lp != NULL; lp=lp->t_next) { ! 981: register short nlink; ! 982: ! 983: if (nlink = lp->t_nlink - 1) ! 984: fprintf(stderr, ! 985: "Tar: missed %d link%s to %s\n", ! 986: nlink, nlink==1 ? "" : "s", ! 987: lp->t_link); ! 988: } ! 989: } ! 990: } ! 991: ! 992: /* ! 993: * Read unsigned octal numbers ! 994: */ ! 995: ! 996: int ! 997: getoct(cp) ! 998: register char *cp; ! 999: { ! 1000: register int val = 0; ! 1001: register char c; ! 1002: ! 1003: while (*cp == ' ') ! 1004: cp++; ! 1005: while ((c = *cp++ - '0') >= 0 && c <= 7) ! 1006: val = val<<3 | c; ! 1007: return (val); ! 1008: } ! 1009: ! 1010: long ! 1011: getoctl(cp) ! 1012: register char *cp; ! 1013: { ! 1014: register long val = 0; ! 1015: register char c; ! 1016: ! 1017: while (*cp==' ') ! 1018: cp++; ! 1019: while ((c = *cp++ - '0') >= 0 && c <= 7) ! 1020: val = val<<3 | c; ! 1021: return (val); ! 1022: } ! 1023: ! 1024: /* ! 1025: * Write unsigned octal numbers ! 1026: * in fixed format ! 1027: */ ! 1028: ! 1029: putoct(str, val) ! 1030: char *str; ! 1031: unsigned short val; ! 1032: { ! 1033: register char *cp; ! 1034: ! 1035: *(cp = &str[7]) = '\0'; ! 1036: *--cp = ' '; ! 1037: *--cp = (val&07) + '0'; ! 1038: while (cp != str) ! 1039: *--cp = (val>>=3) ? (val&07) + '0' : ' '; ! 1040: } ! 1041: ! 1042: putoctl(str, val) ! 1043: char *str; ! 1044: register unsigned long val; ! 1045: { ! 1046: register char *cp; ! 1047: ! 1048: *(cp = &str[11]) = ' '; ! 1049: *--cp = (val&07) + '0'; ! 1050: while (cp != str) ! 1051: *--cp = (val>>=3) ? (val&07) + '0' : ' '; ! 1052: } ! 1053: ! 1054: /* ! 1055: * Compute checksum of string ! 1056: */ ! 1057: int ! 1058: checksum(str, len) ! 1059: register char *str; ! 1060: register int len; ! 1061: { ! 1062: register int check = 0; ! 1063: ! 1064: if (len) do ! 1065: check += *str++; ! 1066: while (--len); ! 1067: return (check); ! 1068: } ! 1069: ! 1070: /* ! 1071: * Return -1 if dname is a directory prefix of fname ! 1072: * 0 if no match ! 1073: * 1 if complete match ! 1074: */ ! 1075: int ! 1076: contains(dname, fname) ! 1077: register char *dname, ! 1078: *fname; ! 1079: { ! 1080: if (*dname=='\0') ! 1081: return (-1); ! 1082: while (*dname!='\0') ! 1083: if (*dname++ != *fname++) ! 1084: return (0); ! 1085: if (*fname=='\0') ! 1086: return (1); ! 1087: else if (*fname=='/' || *--fname=='/') ! 1088: return (-1); ! 1089: else ! 1090: return (0); ! 1091: } ! 1092: ! 1093: /* Handle the processing of a checksum error. ! 1094: * This is special because sometimes end of archive will look like ! 1095: * a lot of checksum errors. ! 1096: */ ! 1097: int ! 1098: do_checksum_error(name, action) ! 1099: char *name; ! 1100: int action; ! 1101: { ! 1102: #define MSG_SIZE (100 + sizeof("Tar: %.100s: bad checksum\n") + 1) ! 1103: #define MAX_CHECKERR 5 /* Give up after 5 consecutive checksum errors. */ ! 1104: ! 1105: static error_count = 0; /* Number of checksums we've seen. */ ! 1106: static char *msg_list = NULL; /* Error message we've queued. */ ! 1107: char tmp_buf[MSG_SIZE]; /* Someplace to build new errors. */ ! 1108: ! 1109: ! 1110: switch (action) { ! 1111: case ADD: ! 1112: /* If there have been too many checksum errors, or if ! 1113: * we can't allocate more memory for more error messages, ! 1114: * throw away the existing messages, and look for another ! 1115: * valid block. ! 1116: */ ! 1117: if (++error_count > MAX_CHECKERR || ! 1118: (msg_list = (char *)realloc(msg_list, ! 1119: strlen(msg_list) + MSG_SIZE +1)) == ! 1120: NULL) { ! 1121: fprintf(stderr, ! 1122: "Tar: %s: This doesn't look like a tar archive.\n", ! 1123: archive); ! 1124: free(msg_list); ! 1125: msg_list = 0; ! 1126: error_count = 0; ! 1127: fprintf(stderr, "Tar: Scanning for next file.\n"); ! 1128: scan_for_next(); ! 1129: } ! 1130: ! 1131: sprintf(tmp_buf, "Tar: %.100s: bad checksum\n", ! 1132: name); ! 1133: strcat(msg_list, tmp_buf); ! 1134: break; ! 1135: case CLEAR: ! 1136: if (NULL != msg_list) { ! 1137: fprintf(stderr, "%s", msg_list); ! 1138: free(msg_list); ! 1139: msg_list = NULL; ! 1140: } ! 1141: error_count = 0; ! 1142: break; ! 1143: } /* switch (action) */ ! 1144: } /* do_checksum_error() */ ! 1145: ! 1146: /* Find the next valid block. */ ! 1147: int ! 1148: scan_for_next() ! 1149: { ! 1150: int check; ! 1151: tarhd_t *header; ! 1152: ! 1153: while ( (header = readblk()) != NULL ) { ! 1154: check = getoct(header->th_info.th_check); ! 1155: ! 1156: strncpy(header->th_info.th_check, " ", ! 1157: sizeof(header->th_info.th_check)); ! 1158: if (checksum(header->th_data, sizeof(tarhd_t)) == check){ ! 1159: /* Found a good header! */ ! 1160: ungetblk(); ! 1161: return; ! 1162: } ! 1163: } /* while (more blocks to read) */ ! 1164: /* If we got here, it means we ran out of things to read. */ ! 1165: fatal("no more valid blocks"); ! 1166: ! 1167: } /* scan_for_next() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.