![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ar.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 ar.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 ! root 1: /* ! 2: * Archive manager. ! 3: * Also manages libraries for the ! 4: * link editor, ! 5: * including ranlib header updates. ! 6: */ ! 7: #define RUNRSX 0 ! 8: #define FMTRSX 0 /* Achives in COHERENT format */ ! 9: ! 10: #include <stdio.h> ! 11: #include <ar.h> ! 12: #include <canon.h> ! 13: #include <sys/types.h> ! 14: #if !RUNRSX ! 15: #include <sys/stat.h> ! 16: #endif ! 17: ! 18: #define RO 0 ! 19: #define RW 1 ! 20: ! 21: #define NONE 0 ! 22: #define BEFORE 1 ! 23: #define AFTER 2 ! 24: ! 25: #define ALLOK 0 ! 26: #define NOTALL 1 ! 27: #define ERROR 2 ! 28: ! 29: #define aechk() { if(ferror(afp)) ioerr(anp); } ! 30: #define techk() { if(ferror(tfp)) ioerr(tnp); } ! 31: ! 32: char nwork[] = "No work"; ! 33: char found[] = "found"; ! 34: char copen[] = "%s: cannot open"; ! 35: char ccrea[] = "%s: cannot create"; ! 36: char creop[] = "%s: cannot reopen"; ! 37: ! 38: FILE *afp; ! 39: FILE *tfp; ! 40: FILE *rfp; ! 41: struct ar_hdr ahb; ! 42: int nname; ! 43: char **namep; ! 44: char *ctime(); ! 45: int usage(); ! 46: long fsize(); ! 47: long ftell(); ! 48: int cflag; ! 49: int kflag; ! 50: int lflag; ! 51: int sflag; ! 52: int uflag; ! 53: int vflag; ! 54: char *pnp; ! 55: char *anp; ! 56: char *tnp; ! 57: char rnp[] = HDRNAME; ! 58: int xstat = ALLOK; ! 59: int pos = NONE; ! 60: int (*ffp)() = usage; ! 61: ! 62: #if RUNRSX ! 63: struct header fhb; ! 64: time_t fmdate(); ! 65: time_t getmdate(); ! 66: #else ! 67: char state[] = "%s: stat error"; ! 68: #endif ! 69: ! 70: main(argc, argv) ! 71: char *argv[]; ! 72: { ! 73: register char *p; ! 74: register i; ! 75: int usage(), rfunc(); ! 76: ! 77: if (argc < 2) ! 78: usage(); ! 79: key(argv[1]); ! 80: nname = argc-2; ! 81: namep = &argv[2]; ! 82: for (i=2; i<argc; ++i) { ! 83: p = argv[i]; ! 84: if (pos!=NONE && pnp==NULL) { ! 85: pnp = p; ! 86: ++namep; ! 87: --nname; ! 88: } else if (anp == NULL) { ! 89: anp = p; ! 90: ++namep; ! 91: --nname; ! 92: } ! 93: } ! 94: if (anp == NULL) ! 95: usage(); ! 96: if (pos != NONE) { ! 97: if (pnp == NULL) ! 98: usage(); ! 99: if (ffp == usage) ! 100: ffp = rfunc; ! 101: } ! 102: (*ffp)(); ! 103: delexit(xstat); ! 104: } ! 105: ! 106: /* ! 107: * Decode key. ! 108: * Save function name in 'ffp'. ! 109: * Set 'c', 'l', 'k' and 'v' flags. ! 110: */ ! 111: key(p) ! 112: register char *p; ! 113: { ! 114: register c; ! 115: int dfunc(), rfunc(), qfunc(), tfunc(); ! 116: int mfunc(), xfunc(), pfunc(); ! 117: ! 118: while (c = *p++) { ! 119: switch (c) { ! 120: ! 121: case 'd': /* Delete */ ! 122: ffp = dfunc; ! 123: break; ! 124: ! 125: case 'r': /* Replace */ ! 126: ffp = rfunc; ! 127: break; ! 128: ! 129: case 'q': /* Quick append */ ! 130: ffp = qfunc; ! 131: break; ! 132: ! 133: case 't': /* Tabulate */ ! 134: ffp = tfunc; ! 135: break; ! 136: ! 137: case 'p': /* Print */ ! 138: ffp = pfunc; ! 139: break; ! 140: ! 141: case 'm': /* Move */ ! 142: ffp = mfunc; ! 143: break; ! 144: ! 145: case 'x': /* Extract */ ! 146: ffp = xfunc; ! 147: break; ! 148: ! 149: case 'c': /* no create message */ ! 150: ++cflag; ! 151: break; ! 152: ! 153: case 'k': /* keep dates */ ! 154: ++kflag; ! 155: break; ! 156: ! 157: case 'l': /* local temp file */ ! 158: ++lflag; ! 159: break; ! 160: ! 161: case 's': /* ranlib symbol table */ ! 162: ++sflag; ! 163: break; ! 164: ! 165: case 'u': /* update replace */ ! 166: ++uflag; ! 167: break; ! 168: ! 169: case 'v': /* verbose */ ! 170: ++vflag; ! 171: break; ! 172: ! 173: case 'a': /* after position or append */ ! 174: pos = AFTER; ! 175: break; ! 176: ! 177: case 'b': /* before position */ ! 178: case 'i': /* insert */ ! 179: pos = BEFORE; ! 180: break; ! 181: ! 182: default: ! 183: usage(); ! 184: } ! 185: } ! 186: } ! 187: ! 188: /* ! 189: * Replace. ! 190: * Eliminate dead stuff if 'u'. ! 191: * Copy up to insert point. ! 192: * Copy in new files. ! 193: * Copy the rest of the file. ! 194: * Copy back. ! 195: */ ! 196: rfunc() ! 197: { ! 198: register char *qfn; ! 199: register i, nef; ! 200: FILE *qfp; ! 201: ! 202: if (nname == 0) ! 203: diag(1, nwork); ! 204: aopen(RW); ! 205: ropen(); ! 206: if (uflag) { ! 207: update(); ! 208: fseek(afp, (long)sizeof(int), 0); ! 209: if (rfp != NULL) { ! 210: geth(); ! 211: if (eqh(rnp)) ! 212: fseek(afp, (long)ahb.ar_size, 1); ! 213: else ! 214: fseek(afp, (long)sizeof(int), 0); ! 215: } ! 216: } ! 217: topen(); ! 218: while (nef = geth()) { ! 219: if (pos==BEFORE && eqh(pnp)) { ! 220: fseek(afp, (long)-sizeof(struct ar_hdr), 1); ! 221: break; ! 222: } ! 223: if (pos == NONE) { ! 224: for (i=0; i<nname; ++i) { ! 225: if ((qfn=namep[i])!=NULL && eqh(qfn)) ! 226: break; ! 227: } ! 228: if (i != nname) { ! 229: fseek(afp, ahb.ar_size, 1); ! 230: namep[i] = NULL; ! 231: remove(i, qfn); ! 232: if ((qfp = fopen(qfn, "rb")) == NULL) ! 233: diag(1, copen, qfn); ! 234: makeh(qfn, qfp); ! 235: if (vflag) ! 236: printf("%s: in place replace.\n", qfn); ! 237: puth(); ! 238: ffcopy(tfp, tnp, qfp, qfn, fsize(qfp, qfn)); ! 239: fclose(qfp); ! 240: continue; ! 241: } ! 242: } ! 243: mmove(0); ! 244: if (pos==AFTER && eqh(pnp)) ! 245: break; ! 246: } ! 247: if (nef==0 && pos!=NONE) ! 248: diag(1, "%s: not in archive", pnp); ! 249: for (i=0; i<nname; ++i) { ! 250: if ((qfn=namep[i]) == NULL) ! 251: continue; ! 252: remove(i, qfn); ! 253: if ((qfp=fopen(qfn, "rb")) == NULL) ! 254: diag(1, copen, qfn); ! 255: makeh(qfn, qfp); ! 256: if (vflag) ! 257: printf("%s: replaced.\n", qfn); ! 258: puth(); ! 259: ffcopy(tfp, tnp, qfp, qfn, fsize(qfp, qfn)); ! 260: fclose(qfp); ! 261: } ! 262: while (geth()) ! 263: mmove(0); ! 264: tacopy(); ! 265: } ! 266: ! 267: /* ! 268: * Handle the 'u' option. ! 269: * Read through the archive, comparing ! 270: * the dates in the headers to the last ! 271: * modification dates of the files in ! 272: * the command line. Make some files ! 273: * go away. ! 274: */ ! 275: update() ! 276: { ! 277: register char *p; ! 278: register i; ! 279: #if !RUNRSX ! 280: struct stat sb; ! 281: #endif ! 282: ! 283: while (geth()) { ! 284: for (i=0; i<nname; ++i) { ! 285: p = namep[i]; ! 286: if (p!=NULL && eqh(p)) { ! 287: #if RUNRSX ! 288: if (ahb.ar_date >= fmdate(p)) { ! 289: #else ! 290: if (stat(p, &sb) < 0) ! 291: diag(1, state, p); ! 292: if (ahb.ar_date >= sb.st_mtime) { ! 293: #endif ! 294: if (vflag) ! 295: printf("%s: no update.\n", p); ! 296: namep[i] = NULL; ! 297: remove(i, p); ! 298: } ! 299: } ! 300: } ! 301: fseek(afp, ahb.ar_size, 1); ! 302: } ! 303: for (i=0; i<nname && namep[i]==NULL; ++i) ! 304: ; ! 305: if (i >= nname) { ! 306: if (vflag) ! 307: fprintf(stderr, "%s.\n", nwork); ! 308: delexit(ALLOK); ! 309: } ! 310: } ! 311: ! 312: /* ! 313: * Move. ! 314: * Copy stuff before insert. ! 315: * Copy moved stuff. ! 316: * Copy remainder. ! 317: * Copy back to archive. ! 318: */ ! 319: mfunc() ! 320: { ! 321: register nef; ! 322: long s; ! 323: ! 324: aopen(RW); ! 325: ropen(); ! 326: topen(); ! 327: while (nef = geth()) { ! 328: if (pos==BEFORE && eqh(pnp)) ! 329: break; ! 330: mmove(0); ! 331: if (pos==AFTER && eqh(pnp)) ! 332: break; ! 333: } ! 334: if (nef==0 && pos!=NONE) ! 335: diag(1, "%s: not in archive", pnp); ! 336: s = ftell(afp); ! 337: if (pos == BEFORE) ! 338: s -= sizeof(struct ar_hdr); ! 339: fseek(afp, (long)sizeof(int), 0); ! 340: while (geth()) ! 341: mmove(1); ! 342: if (nef) { ! 343: fseek(afp, s, 0); ! 344: while (geth()) ! 345: mmove(0); ! 346: } ! 347: tacopy(); ! 348: } ! 349: ! 350: /* ! 351: * Conditional move to the ! 352: * temp file from the archive ! 353: * file. Used by move and replace ! 354: */ ! 355: mmove(f1) ! 356: register f1; ! 357: { ! 358: register f2, i; ! 359: register long size; ! 360: ! 361: f2 = 0; ! 362: for (i=0; i<nname; ++i) { ! 363: if (eqh(namep[i])) { ! 364: ++f2; ! 365: break; ! 366: } ! 367: } ! 368: if (f1 == f2) { ! 369: if (vflag) ! 370: amsg("copied"); ! 371: size = ahb.ar_size; ! 372: puth(); ! 373: ffcopy(tfp, tnp, afp, anp, size); ! 374: } else { ! 375: if (vflag) ! 376: amsg("skipped"); ! 377: fseek(afp, ahb.ar_size, 1); ! 378: } ! 379: } ! 380: ! 381: /* ! 382: * Print. ! 383: */ ! 384: pfunc() ! 385: { ! 386: aopen(RO); ! 387: while (geth()) { ! 388: if (nname==0 || match()) ! 389: pfile(); ! 390: else ! 391: fseek(afp, ahb.ar_size, 1); ! 392: } ! 393: if (nname != 0) ! 394: notdone(found); ! 395: } ! 396: ! 397: pfile() ! 398: { ! 399: #if FMTRSX ! 400: register char *rb; ! 401: register i; ! 402: long s; ! 403: int n; ! 404: ! 405: if (vflag) ! 406: amsg(NULL); ! 407: if ((rb = malloc(ahb.ar_ufat.f_rsiz)) == NULL) ! 408: diag(1, "Out of space"); ! 409: s = ahb.ar_size; ! 410: while (s != 0) { ! 411: if (ahb.ar_ufat.f_rtyp == R_FIX) ! 412: n = ahb.ar_ufat.f_rsiz; ! 413: else { ! 414: fread(&n, sizeof(int), 1, afp); ! 415: s -= sizeof(int); ! 416: } ! 417: fread(rb, sizeof(char), n, afp); ! 418: for (i=0; i<n; ++i) ! 419: putchar(rb[i]); ! 420: if ((ahb.ar_ufat.f_ratt&FD_CR) != 0) ! 421: putchar('\n'); ! 422: if ((n&01) != 0) { ! 423: ++n; ! 424: fseek(afp, (long)1, 1); ! 425: } ! 426: s -= n; ! 427: } ! 428: free(rb); ! 429: #else ! 430: if (vflag) ! 431: amsg(NULL); ! 432: ffcopy(stdout, "Stdout", afp, anp, ahb.ar_size); ! 433: #endif ! 434: } ! 435: ! 436: /* ! 437: * Delete. ! 438: * Copy archive to temp, deleting ! 439: * members along the way. If all of ! 440: * the files have been deleted then ! 441: * copy back. ! 442: */ ! 443: dfunc() ! 444: { ! 445: register long size; ! 446: ! 447: if (nname == 0) ! 448: diag(1, nwork); ! 449: aopen(RW); ! 450: ropen(); ! 451: topen(); ! 452: while (geth()) { ! 453: if (match()) { ! 454: if (vflag) ! 455: amsg("deleted"); ! 456: fseek(afp, ahb.ar_size, 1); ! 457: continue; ! 458: } ! 459: if (vflag) ! 460: amsg("copied"); ! 461: size = ahb.ar_size; ! 462: puth(); ! 463: ffcopy(tfp, tnp, afp, anp, size); ! 464: } ! 465: if (notdone("deleted")) ! 466: delexit(ERROR); ! 467: tacopy(); ! 468: } ! 469: ! 470: /* ! 471: * Quick insert. ! 472: * Copy archive to temp file. ! 473: * Tack new files onto the end. ! 474: * If no errors, copy back. ! 475: */ ! 476: qfunc() ! 477: { ! 478: register char *qfn; ! 479: register FILE *qfp; ! 480: register i; ! 481: ! 482: if (nname == 0) ! 483: diag(1, nwork); ! 484: aopen(RW); ! 485: if (geth() != 0 && eqh(rnp)) { ! 486: fseek(afp, (long)-sizeof(ahb), 1); ! 487: ahb.ar_date = 0; ! 488: aputh(); ! 489: } ! 490: fseek(afp, (long)0, 2); ! 491: for (i=0; i<nname; ++i) { ! 492: if ((qfn=namep[i]) == NULL) ! 493: continue; ! 494: remove(i, qfn); ! 495: if ((qfp=fopen(qfn, "rb")) == NULL) ! 496: diag(1, copen, qfn); ! 497: makeh(qfn, qfp); ! 498: if (vflag) ! 499: printf("%s: quick insert.\n", qfn); ! 500: aputh(); ! 501: ffcopy(afp, anp, qfp, qfn, fsize(qfp, qfn)); ! 502: fclose(qfp); ! 503: } ! 504: } ! 505: ! 506: /* ! 507: * Table. ! 508: * Read through archive. ! 509: * If good member print its name. ! 510: * If verbose, print extra stuff. ! 511: */ ! 512: tfunc() ! 513: { ! 514: register char *p; ! 515: register c, n; ! 516: ! 517: aopen(RO); ! 518: while (geth()) { ! 519: if (nname==0 || match()) { ! 520: n = 0; ! 521: p = ahb.ar_name; ! 522: while (n<DIRSIZ && (c=*p++)) { ! 523: putchar(c); ! 524: ++n; ! 525: } ! 526: if (vflag) { ! 527: while (n++ < DIRSIZ+1) ! 528: putchar(' '); ! 529: #if FMTRSX ! 530: printf("[%03o,%03o] ", ahb.ar_gid, ahb.ar_uid); ! 531: printf("%06o ", ahb.ar_mode); ! 532: #else ! 533: printf("%5d %5d ", ahb.ar_gid, ahb.ar_uid); ! 534: printf("%03o ", ahb.ar_mode); ! 535: #endif ! 536: printf("%10ld ", ahb.ar_size); ! 537: printf("%s", ctime(&ahb.ar_date)); ! 538: } else ! 539: putchar('\n'); ! 540: } ! 541: fseek(afp, ahb.ar_size, 1); ! 542: } ! 543: if (nname != 0) ! 544: notdone(found); ! 545: } ! 546: ! 547: /* ! 548: * Extract. ! 549: * Read through archive. ! 550: * Extract any files you find. ! 551: * At end, mutter about files ! 552: * that were not there. ! 553: */ ! 554: xfunc() ! 555: { ! 556: register char *p1, *p2; ! 557: register c; ! 558: char fnb[DIRSIZ+1]; ! 559: FILE *xfp; ! 560: ! 561: aopen(RO); ! 562: while (geth()) { ! 563: if (nname==0 || match()) { ! 564: p1 = ahb.ar_name; ! 565: p2 = fnb; ! 566: while (p1<&ahb.ar_name[DIRSIZ] && (c=*p1++)) ! 567: *p2++ = c; ! 568: *p2 = 0; ! 569: if ((xfp=fopen(fnb, "wb")) == NULL) { ! 570: diag(0, ccrea, fnb); ! 571: fseek(afp, ahb.ar_size, 1); ! 572: continue; ! 573: } ! 574: if (vflag) ! 575: amsg("extracting"); ! 576: ffcopy(xfp, fnb, afp, anp, ahb.ar_size); ! 577: #if RUNRSX && FMTRSX ! 578: fseek(xfp, (long)0, 0); ! 579: xfp->v_rtyp = ahb.ar_ufat.f_rtyp; ! 580: xfp->v_ratt = ahb.ar_ufat.f_ratt; ! 581: xfp->v_rsiz = ahb.ar_ufat.f_rsiz; ! 582: xfp->v_hibk = ahb.ar_ufat.f_hibk; ! 583: xfp->v_efbk = ahb.ar_ufat.f_efbk; ! 584: xfp->v_ffby = ahb.ar_ufat.f_ffby; ! 585: #endif ! 586: #if !RUNRSX && !FMTRSX ! 587: chmod(fnb, ahb.ar_mode); ! 588: #endif ! 589: fclose(xfp); ! 590: if (kflag) { ! 591: #if !RUNRSX && !FMTRSX ! 592: time_t times[2]; ! 593: time_t time(); ! 594: ! 595: time(times+0); ! 596: times[1] = ahb.ar_date; ! 597: if (utime(fnb, times) < 0) ! 598: diag(0, "Unable to set time for %s", ! 599: fnb); ! 600: #endif ! 601: } ! 602: } else ! 603: fseek(afp, ahb.ar_size, 1); ! 604: } ! 605: if (nname != 0) ! 606: notdone(found); ! 607: } ! 608: ! 609: /* ! 610: * Make an archive header. ! 611: * Put it in the external archive ! 612: * header buffer 'ahb'. The arg. ! 613: * 'fn' is the file name. The file ! 614: * is open on 'fp'. ! 615: */ ! 616: makeh(fn, fp) ! 617: char *fn; ! 618: FILE *fp; ! 619: { ! 620: register char *p1, *p2; ! 621: register c; ! 622: #if !RUNRSX ! 623: struct stat sb; ! 624: #endif ! 625: ! 626: for (p1=fn; *p1++; ) ! 627: ; ! 628: while (p1 > fn) { ! 629: c = p1[-1]; ! 630: #if RUNRSX ! 631: if (c==':' || c==']') ! 632: break; ! 633: #endif ! 634: #if COHERENT ! 635: if (c == '/') ! 636: break; ! 637: #endif ! 638: #if GEMDOS ! 639: if (c == '\\') ! 640: break; ! 641: #endif ! 642: --p1; ! 643: } ! 644: p2 = ahb.ar_name; ! 645: while (c = *p1++) { ! 646: if (p2 < &ahb.ar_name[DIRSIZ]) ! 647: *p2++ = c; ! 648: } ! 649: while (p2 < &ahb.ar_name[DIRSIZ]) ! 650: *p2++ = 0; ! 651: #if RUNRSX ! 652: if (ratt(fp, &fhb) == 0) ! 653: diag(1, "%s: ratt failed", fn); ! 654: ahb.ar_date = getmdate(&fhb); ! 655: ahb.ar_size = fsize(fp, fn); ! 656: #if FMTRSX ! 657: ahb.ar_uid = fhb.h_prog; ! 658: ahb.ar_gid = fhb.h_proj; ! 659: ahb.ar_mode = fhb.h_fpro; ! 660: ahb.ar_ufat.f_rtyp = fp->v_rtyp; ! 661: ahb.ar_ufat.f_ratt = fp->v_ratt; ! 662: ahb.ar_ufat.f_rsiz = fp->v_rsiz; ! 663: ahb.ar_ufat.f_hibk = fp->v_hibk; ! 664: ahb.ar_ufat.f_efbk = fp->v_efbk; ! 665: ahb.ar_ufat.f_ffby = fp->v_ffby; ! 666: #else ! 667: ahb.ar_uid = 0; ! 668: ahb.ar_gid = 0; ! 669: ahb.ar_mode = 0644; ! 670: #endif ! 671: #else ! 672: #if GEMDOS ! 673: if (stat(fn, &sb) < 0) ! 674: #else ! 675: if (fstat(fileno(fp), &sb) < 0) ! 676: #endif ! 677: diag(1, state, fn); ! 678: if (kflag) ! 679: ahb.ar_date = sb.st_mtime; ! 680: else ! 681: time(&ahb.ar_date); ! 682: ahb.ar_uid = sb.st_uid; ! 683: ahb.ar_gid = sb.st_gid; ! 684: ahb.ar_mode = sb.st_mode&0777; ! 685: ahb.ar_size = sb.st_size; ! 686: #endif ! 687: } ! 688: ! 689: /* ! 690: * Test if the member whose ! 691: * header is held in the archive ! 692: * header buffer is mentioned in ! 693: * the user's list of members. ! 694: * Return the number of matches. ! 695: * All matches are NULLed. ! 696: */ ! 697: match() ! 698: { ! 699: register char *p; ! 700: register i, n; ! 701: ! 702: n = 0; ! 703: for (i=0; i<nname; ++i) { ! 704: if ((p=namep[i]) == NULL) ! 705: continue; ! 706: if (eqh(p)) { ! 707: ++n; ! 708: namep[i] = NULL; ! 709: } ! 710: } ! 711: return (n); ! 712: } ! 713: ! 714: /* ! 715: * Remove all instances of name ! 716: * 'fn' from the list of names that ! 717: * is described by 'namep' and ! 718: * 'nname'. ! 719: * Start at index 'i+1'. ! 720: */ ! 721: remove(i, fn) ! 722: register i; ! 723: register char *fn; ! 724: { ! 725: register char *p; ! 726: ! 727: for (++i; i<nname; ++i) { ! 728: if ((p=namep[i]) == NULL) ! 729: continue; ! 730: if (strcmp(fn, p) == 0) ! 731: namep[i] = NULL; ! 732: } ! 733: } ! 734: ! 735: /* ! 736: * This routine digs through the ! 737: * list of names described by 'namep' ! 738: * and 'nname' looking for names that ! 739: * have not been NULLed out. If any ! 740: * are found it prints a title and ! 741: * the names. The number of names that ! 742: * were found is returned. ! 743: */ ! 744: notdone(s) ! 745: char *s; ! 746: { ! 747: register char *p; ! 748: register i, n; ! 749: ! 750: n = 0; ! 751: for (i=0; i<nname; ++i) { ! 752: p = namep[i]; ! 753: if (p != NULL) { ! 754: if (n++ == 0) ! 755: fprintf(stderr, "Not %s:\n", s); ! 756: fprintf(stderr, "%s\n", p); ! 757: } ! 758: } ! 759: return (n); ! 760: } ! 761: ! 762: /* ! 763: * File to file copy. ! 764: * With ranlib construction. ! 765: */ ! 766: ffcopy(tfp, tfn, ffp, ffn, s) ! 767: FILE *tfp, *ffp; ! 768: char *tfn, *ffn; ! 769: long s; ! 770: { ! 771: register n; ! 772: static char fb[BUFSIZ]; ! 773: ! 774: if (rfp != NULL) raddmod(tfp, ffp); ! 775: while (s != 0) { ! 776: n = (s>BUFSIZ) ? BUFSIZ : s; ! 777: if (fread (fb, sizeof(char), n, ffp) != n) ! 778: ioerr(ffn); ! 779: if (fwrite(fb, sizeof(char), n, tfp) != n) ! 780: ioerr(tfn); ! 781: s -= n; ! 782: } ! 783: } ! 784: ! 785: /* ! 786: * Get the next archive header ! 787: * into 'ahb'. Check for any I/O ! 788: * errors. Return true if a header ! 789: * was read and false on EOF. ! 790: */ ! 791: geth() ! 792: { ! 793: if (fread(&ahb, sizeof(ahb), 1, afp) != 1) { ! 794: aechk(); ! 795: return (0); ! 796: } ! 797: cantime(ahb.ar_date); ! 798: canshort(ahb.ar_gid); ! 799: canshort(ahb.ar_uid); ! 800: canshort(ahb.ar_mode); ! 801: cansize(ahb.ar_size); ! 802: return (1); ! 803: } ! 804: ! 805: /* ! 806: * Write the header in 'ahb' to ! 807: * the temp file. ! 808: */ ! 809: puth() ! 810: { ! 811: cantime(ahb.ar_date); ! 812: canshort(ahb.ar_gid); ! 813: canshort(ahb.ar_uid); ! 814: canshort(ahb.ar_mode); ! 815: cansize(ahb.ar_size); ! 816: fwrite(&ahb, sizeof(ahb), 1, tfp); ! 817: techk(); ! 818: } ! 819: ! 820: /* ! 821: * Write the header in 'ahb' to ! 822: * the archive file. from qfunc. ! 823: */ ! 824: aputh() ! 825: { ! 826: cantime(ahb.ar_date); ! 827: canshort(ahb.ar_gid); ! 828: canshort(ahb.ar_uid); ! 829: canshort(ahb.ar_mode); ! 830: cansize(ahb.ar_size); ! 831: fwrite(&ahb, sizeof(ahb), 1, afp); ! 832: aechk(); ! 833: } ! 834: ! 835: /* ! 836: * Compare a string to the name ! 837: * of the member in the archive header ! 838: * buffer. True return if same. ! 839: */ ! 840: eqh(p) ! 841: char *p; ! 842: { ! 843: register char *p1, *p2; ! 844: register c; ! 845: ! 846: if ((p1 = p) == NULL) ! 847: return (0); ! 848: while (*p1++) ! 849: ; ! 850: while (p1 > p) { ! 851: c = p1[-1]; ! 852: #if RUNRSX ! 853: if (c==':' || c==']') ! 854: break; ! 855: #endif ! 856: #if COHERENT ! 857: if (c == '/') ! 858: break; ! 859: #endif ! 860: #if GEMDOS ! 861: if (c == '\\') ! 862: break; ! 863: #endif ! 864: --p1; ! 865: } ! 866: p2 = ahb.ar_name; ! 867: c = DIRSIZ; ! 868: while (c && *p1 == *p2++) { ! 869: if (*p1++ == 0) ! 870: return (1); ! 871: --c; ! 872: } ! 873: if (c == 0) ! 874: return (1); ! 875: return (0); ! 876: } ! 877: ! 878: /* ! 879: * Open archive. ! 880: * The argument 'aam' is the ! 881: * access mode (RO or RW). ! 882: */ ! 883: aopen(aam) ! 884: { ! 885: int i; ! 886: ! 887: if ((afp=fopen(anp, "rb")) == NULL) { ! 888: if (aam == RO) ! 889: diag(1, copen, anp); ! 890: if ((afp=fopen(anp, "wb"))==NULL ! 891: || (afp=freopen(anp, "wrb", afp))==NULL) ! 892: diag(1, ccrea, anp); ! 893: if (cflag == 0) ! 894: printf("%s: new archive.\n", anp); ! 895: i = ARMAG; ! 896: canint(i); ! 897: fwrite(&i, sizeof(i), 1, afp); ! 898: aechk(); ! 899: return; ! 900: } ! 901: if (aam != RO) { ! 902: fclose(afp); ! 903: if ((afp=fopen(anp, "rwb"))==NULL) ! 904: diag(1, copen, anp); ! 905: } ! 906: fread(&i, sizeof(i), 1, afp); ! 907: aechk(); ! 908: canint(i); ! 909: if (i != ARMAG) ! 910: diag(1, "%s: not an archive", anp); ! 911: } ! 912: ! 913: /* ! 914: * Open tempfile. ! 915: * Stash the name in 'tnp' for ! 916: * the benefit of 'delexit'. ! 917: * Honour the 'l' option w.r.t. ! 918: * file placement. ! 919: */ ! 920: topen() ! 921: { ! 922: int i; ! 923: ! 924: #if COHERENT || GEMDOS ! 925: extern char *tempnam(); ! 926: tnp = tempnam((lflag ? "." : NULL), "v"); ! 927: #endif ! 928: #if RUNRSX ! 929: tnp = "ar.tmp"; ! 930: #endif ! 931: if ((tfp=fopen(tnp, "wb")) == NULL) ! 932: diag(1, ccrea, tnp); ! 933: i = ARMAG; ! 934: canint(i); ! 935: fwrite(&i, sizeof(i), 1, tfp); ! 936: techk(); ! 937: } ! 938: ! 939: /* ! 940: * Copy tempfile back to the ! 941: * archive. ! 942: */ ! 943: tacopy() ! 944: { ! 945: register FILE *xtp; ! 946: int i; ! 947: ! 948: fclose(tfp); ! 949: tfp = NULL; /* Scare off delexit */ ! 950: fclose(afp); ! 951: if ((xtp=fopen(tnp, "rb")) == NULL) ! 952: diag(1, creop, tnp); ! 953: if ((afp=fopen(anp, "wb")) == NULL) ! 954: diag(1, creop, anp); ! 955: if (vflag) ! 956: printf("%s: copy back.\n", anp); ! 957: if (fread(&i, sizeof(i), 1, xtp) != 1) ! 958: ioerr(tnp); ! 959: if (fwrite(&i, sizeof(i), 1, afp) != 1) ! 960: ioerr(anp); ! 961: if (rfp != NULL) rcopy(); ! 962: ffcopy(afp, anp, xtp, tnp, fsize(xtp, tnp)-sizeof(int)); ! 963: tfp = xtp; /* Delete */ ! 964: } ! 965: ! 966: /* ! 967: * Write diagnostic. ! 968: * The flag 'f' marks fatal errors. ! 969: */ ! 970: diag(f, a) ! 971: { ! 972: fprintf(stderr, "%r", &a); ! 973: fprintf(stderr, ".\n"); ! 974: if (f) ! 975: delexit(ERROR); ! 976: xstat = NOTALL; ! 977: } ! 978: ! 979: /* ! 980: * Print a message for a ! 981: * given archive member. The header ! 982: * is in the header buffer. ! 983: */ ! 984: amsg(s) ! 985: char *s; ! 986: { ! 987: register char *p; ! 988: register c; ! 989: ! 990: p = ahb.ar_name; ! 991: while (p<&ahb.ar_name[DIRSIZ] && (c=*p++)!=0) ! 992: putchar(c); ! 993: putchar(':'); ! 994: if (s != NULL) ! 995: printf(" %s.", s); ! 996: putchar('\n'); ! 997: } ! 998: ! 999: /* ! 1000: * Exit. ! 1001: * Delete the tempfile if ! 1002: * present. ! 1003: */ ! 1004: delexit(s) ! 1005: { ! 1006: #if RUNRSX ! 1007: if (tfp != NULL) ! 1008: fmkdl(tfp); ! 1009: #else ! 1010: if (tfp != NULL) ! 1011: unlink(tnp); ! 1012: #endif ! 1013: #ifdef DEBUG ! 1014: if (s) ! 1015: abort(); ! 1016: #endif ! 1017: exit(s); ! 1018: } ! 1019: ! 1020: /* ! 1021: * Mutter about an I/O error ! 1022: * on file 's'. ! 1023: */ ! 1024: ioerr(s) ! 1025: char *s; ! 1026: { ! 1027: diag(1, "%s: I/O error", s); ! 1028: } ! 1029: ! 1030: /* ! 1031: * Print usage message. ! 1032: */ ! 1033: usage() ! 1034: { ! 1035: fprintf(stderr, "Usage: ar options [posname] afile [name ...].\n"); ! 1036: delexit(ERROR); ! 1037: } ! 1038: ! 1039: /* ! 1040: * Compute the size of a file. ! 1041: * In bytes. ! 1042: * The file must not be seeked. ! 1043: */ ! 1044: long ! 1045: fsize(fp, fn) ! 1046: register FILE *fp; ! 1047: char *fn; ! 1048: { ! 1049: #if RUNRSX ! 1050: return (((fp->v_efbk-1)<<9) + fp->v_ffby); ! 1051: #else ! 1052: struct stat sb; ! 1053: ! 1054: #if GEMDOS ! 1055: if (stat(fn, &sb) < 0) ! 1056: #endif ! 1057: #if COHERENT ! 1058: if (fstat(fileno(fp), &sb) < 0) ! 1059: #endif ! 1060: diag(1, state, fn); ! 1061: return (sb.st_size); ! 1062: #endif ! 1063: } ! 1064: ! 1065: #if RUNRSX ! 1066: /* ! 1067: * The following routines simulate ! 1068: * some aspects of Coherent under the ! 1069: * dreaded RSX. ! 1070: */ ! 1071: #define DAY (24L*60L*60L) ! 1072: ! 1073: time_t ! 1074: fmdate(fn) ! 1075: char *fn; ! 1076: { ! 1077: register FILE *fp; ! 1078: register s; ! 1079: ! 1080: if ((fp=fopen(fn, "rb")) == NULL) ! 1081: diag(1, copen, fn); ! 1082: s = ratt(fp, &fhb); ! 1083: fclose(fp); ! 1084: if (s == 0) ! 1085: diag(1, "%s: ratt failed", fn); ! 1086: return (getmdate(&fhb)); ! 1087: } ! 1088: ! 1089: time_t ! 1090: getmdate(fhp) ! 1091: register struct header *fhp; ! 1092: { ! 1093: register i; ! 1094: time_t date; ! 1095: int rsxdate[8]; ! 1096: static char *mtab[] = { ! 1097: "JAN", "FEB", "MAR", "APR", "MAY", "JUN", ! 1098: "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" ! 1099: }; ! 1100: ! 1101: rsxdate[0] = (fhp->i_rvdt[5]-'0')*10+fhp->i_rvdt[6]-'0'; ! 1102: for (i=0; i<12; ++i) { ! 1103: if (cmp3(&fhp->i_rvdt[2], mtab[i])) { ! 1104: rsxdate[1] = i+1; ! 1105: break; ! 1106: } ! 1107: } ! 1108: rsxdate[2] = (fhp->i_rvdt[0]-'0')*10+fhp->i_rvdt[1]-'0'; ! 1109: rsxdate[3] = (fhp->i_rvti[0]-'0')*10+fhp->i_rvti[1]-'0'; ! 1110: rsxdate[4] = (fhp->i_rvti[2]-'0')*10+fhp->i_rvti[3]-'0'; ! 1111: rsxdate[5] = (fhp->i_rvti[4]-'0')*10+fhp->i_rvti[5]-'0'; ! 1112: cvttime(&date, rsxdate); ! 1113: return (date); ! 1114: } ! 1115: ! 1116: cmp3(p1, p2) ! 1117: register char *p1, *p2; ! 1118: { ! 1119: if (*p1++==*p2++ && *p1++==*p2++ && *p1++==*p2++) ! 1120: return (1); ! 1121: return (0); ! 1122: } ! 1123: ! 1124: /* ! 1125: * Convert rsx date to Coherent ! 1126: * format. This routine assumes that ! 1127: * the timezone is CST. ! 1128: * Courtesy of Tom Duff. ! 1129: */ ! 1130: cvttime(date, rsxdate) ! 1131: register long *date; ! 1132: int rsxdate[8]; ! 1133: { ! 1134: register i; ! 1135: ! 1136: *date = 0; ! 1137: for (i=70; i!=rsxdate[0]; i++) { ! 1138: if (i%4==0) ! 1139: *date += 366L*DAY; else ! 1140: *date += 365L*DAY; ! 1141: } ! 1142: for (i=1; i!=rsxdate[1]; i++) ! 1143: switch (i){ ! 1144: case 9: /* Sep */ ! 1145: case 4: /* Apr */ ! 1146: case 6: /* Jun */ ! 1147: case 11: /* Nov */ ! 1148: *date += 30L*DAY; ! 1149: break; ! 1150: ! 1151: case 2: /* Feb */ ! 1152: if (rsxdate[0]%4 == 0) ! 1153: *date += 29L*DAY; else ! 1154: *date += 28L*DAY; ! 1155: break; ! 1156: ! 1157: default: ! 1158: *date += 31L*DAY; ! 1159: } ! 1160: *date += (rsxdate[2]-1)*DAY; ! 1161: *date += rsxdate[3]*60L*60L; ! 1162: *date += rsxdate[4]*60L; ! 1163: *date += rsxdate[5]; ! 1164: *date += 6L*60L*60L; /* adjust cst to gmt */ ! 1165: } ! 1166: #endif ! 1167: ! 1168: /* ! 1169: * Ranlib stuff. ! 1170: * If the current archive has HDRNAME as first module, ! 1171: * then skip it and open rfp for creation of new ranlib header, ! 1172: * otherwise backup and make a vanilla archive. ! 1173: * Unless sflag was set as an option, ! 1174: * in which case make rfp anyway. ! 1175: * Unless HDRNAME matches the name list and ffp == dfunc, ! 1176: * in which case make rfp only if sflag was set. ! 1177: */ ! 1178: ropen() ! 1179: { ! 1180: extern int dfunc(); ! 1181: ! 1182: if (geth() != 0) { /* Must not be end of file */ ! 1183: if (eqh(rnp)) { ! 1184: fseek(afp, (long)ahb.ar_size, 1); ! 1185: if (ffp == dfunc && match()) { ! 1186: if (vflag) ! 1187: amsg("deleted"); ! 1188: } else ! 1189: ++sflag; ! 1190: } else { ! 1191: fseek(afp, (long)-sizeof(ahb), 1); ! 1192: if (sflag && ffp == dfunc) { ! 1193: strcpy(ahb.ar_name, rnp); ! 1194: match(); ! 1195: } ! 1196: } ! 1197: } ! 1198: if (sflag && (rfp = fopen(rnp, "wb")) == NULL) ! 1199: diag(1, ccrea, rnp); ! 1200: } ! 1201: ! 1202: /* ! 1203: * Add the symbols in mfp to the ranlib header, ! 1204: * and seek mfp back to where it began. ! 1205: * The postion of this module in the archive ! 1206: * is -sizeof(arhdr) from current position of afp. ! 1207: */ ! 1208: struct ldheader ldh; ! 1209: struct ldsym lds; ! 1210: struct ar_sym ars; ! 1211: ! 1212: xwrite() ! 1213: { ! 1214: if (fwrite(lds.ls_id, sizeof(lds.ls_id), 1, rfp) != 1 ! 1215: || fwrite(&ars.ar_off, sizeof(ars.ar_off), 1, rfp) != 1) ! 1216: ioerr(rnp); ! 1217: } ! 1218: ! 1219: xread(fp) register FILE *fp; ! 1220: { ! 1221: register int r; ! 1222: union { long l; unsigned u[2]; } u; ! 1223: ! 1224: if ((ldh.l_flag & LF_32) == 0) { ! 1225: r = fread(&lds, sizeof(lds)-sizeof(short), 1, fp); ! 1226: u.l = lds.ls_addr; ! 1227: canshort(u.u[0]); ! 1228: lds.ls_addr = u.u[0]; ! 1229: } else { ! 1230: r = fread(&lds, sizeof(lds), 1, fp); ! 1231: canlong(lds.ls_addr); ! 1232: } ! 1233: canshort(lds.ls_type); ! 1234: return (r); ! 1235: } ! 1236: ! 1237: raddmod(afp, mfp) FILE *afp, *mfp; ! 1238: { ! 1239: fsize_t off, offset; ! 1240: int seg, nsym; ! 1241: ! 1242: ars.ar_off = ftell(afp) - sizeof(ahb) - sizeof(int); ! 1243: cansize(ars.ar_off); ! 1244: off = ftell(mfp); ! 1245: ldh.l_magic = 0; /* in case fread fails */ ! 1246: if (fread(&ldh, sizeof ldh, 1, mfp) != 1) ! 1247: goto done; ! 1248: canshort(ldh.l_magic); ! 1249: if (ldh.l_magic != L_MAGIC) ! 1250: goto done; ! 1251: canshort(ldh.l_flag); ! 1252: if ((ldh.l_flag & LF_32) == 0) ! 1253: ldh.l_tbase = sizeof(ldh) - 2*sizeof(short); ! 1254: else ! 1255: canshort(ldh.l_tbase); ! 1256: offset = ldh.l_tbase - (fsize_t)sizeof(ldh); ! 1257: for (seg=0; seg<L_SYM; seg++) { ! 1258: if (seg==L_BSSI || seg==L_BSSD) ! 1259: continue; ! 1260: cansize(ldh.l_ssize[seg]); ! 1261: offset += ldh.l_ssize[seg]; ! 1262: } ! 1263: fseek(mfp, offset, 1); ! 1264: cansize(ldh.l_ssize[L_SYM]); ! 1265: if ((ldh.l_flag & LF_32) == 0) ! 1266: nsym = ldh.l_ssize[L_SYM] ! 1267: / (sizeof(struct ldsym) - sizeof(short)); ! 1268: else ! 1269: nsym = ldh.l_ssize[L_SYM]/sizeof(struct ldsym); ! 1270: while (nsym--) { ! 1271: if (xread(mfp) == 0) ! 1272: diag(1, "truncated module %.*s", DIRSIZ, ahb.ar_name); ! 1273: if ((lds.ls_type&L_GLOBAL) == 0) ! 1274: continue; ! 1275: if ((lds.ls_type&LR_SEG) != L_REF) ! 1276: xwrite(); ! 1277: } ! 1278: done: ! 1279: fseek(mfp, off, 0); /* back to beginning of module */ ! 1280: } ! 1281: ! 1282: /* ! 1283: * Copy the ranlib header to the output archive ! 1284: * close and null the ranlib file pointer. ! 1285: */ ! 1286: rcopy() ! 1287: { ! 1288: register FILE *fp; ! 1289: fclose(rfp); ! 1290: rfp = NULL; ! 1291: if ((fp = fopen(rnp, "rb")) == NULL) ! 1292: diag(1, creop, rnp); ! 1293: makeh(rnp, fp); ! 1294: time(&ahb.ar_date); ! 1295: ahb.ar_date += (long)(10*365+3)*24*60*60; ! 1296: tfp = afp; ! 1297: puth(); ! 1298: tfp = NULL; ! 1299: ffcopy(afp, anp, fp, rnp, fsize(fp, rnp)); ! 1300: fclose(fp); ! 1301: unlink(rnp); ! 1302: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.