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