sys/src/cmd/ar.c

   1 /*
   2  * ar - portable (ascii) format version
   3  */
   4 #include <u.h>
   5 #include <libc.h>
   6 #include <bio.h>
   7 #include <mach.h>
   8 #include <ar.h>
   9
  10 /*
  11  *      The algorithm uses up to 3 temp files.  The "pivot member" is the
  12  *      archive member specified by and a, b, or i option.  The temp files are
  13  *      astart - contains existing members up to and including the pivot member.
  14  *      amiddle - contains new files moved or inserted behind the pivot.
  15  *      aend - contains the existing members that follow the pivot member.
  16  *      When all members have been processed, function 'install' streams the
  17  *      temp files, in order, back into the archive.
  18  */
  19
  20 typedef struct  Arsymref
  21 {
  22         char    *name;
  23         int     type;
  24         int     len;
  25         vlong   offset;
  26         struct  Arsymref *next;
  27 } Arsymref;
  28
  29 typedef struct  Armember        /* Temp file entry - one per archive member */
  30 {
  31         struct Armember *next;
  32         struct ar_hdr   hdr;
  33         long            size;
  34         long            date;
  35         void            *member;
  36 } Armember;
  37
  38 typedef struct Arfile           /* Temp file control block - one per tempfile */
  39 {
  40         int     paged;          /* set when some data paged to disk */
  41         char    *fname;         /* paging file name */
  42         int     fd;             /* paging file descriptor */
  43         vlong   size;
  44         Armember *head;         /* head of member chain */
  45         Armember *tail;         /* tail of member chain */
  46         Arsymref *sym;          /* head of defined symbol chain */
  47 } Arfile;
  48
  49 typedef struct Hashchain
  50 {
  51         char    *name;
  52         struct Hashchain *next;
  53 } Hashchain;
  54
  55 #define NHASH   1024
  56
  57 /*
  58  *      macro to portably read/write archive header.
  59  *      'cmd' is read/write/Bread/Bwrite, etc.
  60  */
  61 #define HEADER_IO(cmd, f, h)    cmd(f, h.name, sizeof(h.name)) != sizeof(h.name)\
  62                                 || cmd(f, h.date, sizeof(h.date)) != sizeof(h.date)\
  63                                 || cmd(f, h.uid, sizeof(h.uid)) != sizeof(h.uid)\
  64                                 || cmd(f, h.gid, sizeof(h.gid)) != sizeof(h.gid)\
  65                                 || cmd(f, h.mode, sizeof(h.mode)) != sizeof(h.mode)\
  66                                 || cmd(f, h.size, sizeof(h.size)) != sizeof(h.size)\
  67                                 || cmd(f, h.fmag, sizeof(h.fmag)) != sizeof(h.fmag)
  68
  69                 /* constants and flags */
  70 char    *man =          "mrxtdpq";
  71 char    *opt =          "uvnbailo";
  72 char    artemp[] =      "/tmp/vXXXXX";
  73 char    movtemp[] =     "/tmp/v1XXXXX";
  74 char    tailtemp[] =    "/tmp/v2XXXXX";
  75 char    symdef[] =      "__.SYMDEF";
  76
  77 int     aflag;                          /* command line flags */
  78 int     bflag;
  79 int     cflag;
  80 int     oflag;
  81 int     uflag;
  82 int     vflag;
  83
  84 Arfile *astart, *amiddle, *aend;        /* Temp file control block pointers */
  85 int     allobj = 1;                     /* set when all members are object files of the same type */
  86 int     symdefsize;                     /* size of symdef file */
  87 int     dupfound;                       /* flag for duplicate symbol */
  88 Hashchain       *hash[NHASH];           /* hash table of text symbols */
  89
  90 #define ARNAMESIZE      sizeof(astart->tail->hdr.name)
  91
  92 char    poname[ARNAMESIZE+1];           /* name of pivot member */
  93 char    *file;                          /* current file or member being worked on */
  94 Biobuf  bout;
  95 Biobuf bar;
  96
  97 void    arcopy(Biobuf*, Arfile*, Armember*);
  98 int     arcreate(char*);
  99 void    arfree(Arfile*);
 100 void    arinsert(Arfile*, Armember*);
 101 char    *armalloc(int);
 102 void    armove(Biobuf*, Arfile*, Armember*);
 103 void    arread(Biobuf*, Armember*, int);
 104 void    arstream(int, Arfile*);
 105 int     arwrite(int, Armember*);
 106 int     bamatch(char*, char*);
 107 int     duplicate(char*);
 108 Armember *getdir(Biobuf*);
 109 int     getspace(void);
 110 void    install(char*, Arfile*, Arfile*, Arfile*, int);
 111 void    longt(Armember*);
 112 int     match(int, char**);
 113 void    mesg(int, char*);
 114 Arfile  *newtempfile(char*);
 115 Armember *newmember(void);
 116 void    objsym(Sym*, void*);
 117 int     openar(char*, int, int);
 118 int     page(Arfile*);
 119 void    pmode(long);
 120 void    rl(int);
 121 void    scanobj(Biobuf*, Arfile*, long);
 122 void    select(int*, long);
 123 void    setcom(void(*)(char*, int, char**));
 124 void    skip(Biobuf*, vlong);
 125 int     symcomp(void*, void*);
 126 void    trim(char*, char*, int);
 127 void    usage(void);
 128 void    wrerr(void);
 129 void    wrsym(Biobuf*, long, Arsymref*);
 130
 131 void    rcmd(char*, int, char**);               /* command processing */
 132 void    dcmd(char*, int, char**);
 133 void    xcmd(char*, int, char**);
 134 void    tcmd(char*, int, char**);
 135 void    pcmd(char*, int, char**);
 136 void    mcmd(char*, int, char**);
 137 void    qcmd(char*, int, char**);
 138 void    (*comfun)(char*, int, char**);
 139
 140 void
 141 main(int argc, char *argv[])
 142 {
 143         char *cp;
 144
 145         Binit(&bout, 1, OWRITE);
 146         if(argc < 3)
 147                 usage();
 148         for (cp = argv[1]; *cp; cp++) {
 149                 switch(*cp) {
 150                 case 'a':       aflag = 1;      break;
 151                 case 'b':       bflag = 1;      break;
 152                 case 'c':       cflag = 1;      break;
 153                 case 'd':       setcom(dcmd);   break;
 154                 case 'i':       bflag = 1;      break;
 155                 case 'l':
 156                                 strcpy(artemp, "vXXXXX");
 157                                 strcpy(movtemp, "v1XXXXX");
 158                                 strcpy(tailtemp, "v2XXXXX");
 159                                 break;
 160                 case 'm':       setcom(mcmd);   break;
 161                 case 'o':       oflag = 1;      break;
 162                 case 'p':       setcom(pcmd);   break;
 163                 case 'q':       setcom(qcmd);   break;
 164                 case 'r':       setcom(rcmd);   break;
 165                 case 't':       setcom(tcmd);   break;
 166                 case 'u':       uflag = 1;      break;
 167                 case 'v':       vflag = 1;      break;
 168                 case 'x':       setcom(xcmd);   break;
 169                 default:
 170                         fprint(2, "ar: bad option `%c'\n", *cp);
 171                         exits("error");
 172                 }
 173         }
 174         if (aflag && bflag) {
 175                 fprint(2, "ar: only one of 'a' and 'b' can be specified\n");
 176                 usage();
 177         }
 178         if(aflag || bflag) {
 179                 trim(argv[2], poname, sizeof(poname));
 180                 argv++;
 181                 argc--;
 182                 if(argc < 3)
 183                         usage();
 184         }
 185         if(comfun == 0) {
 186                 if(uflag == 0) {
 187                         fprint(2, "ar: one of [%s] must be specified\n", man);
 188                         usage();
 189                 }
 190                 setcom(rcmd);
 191         }
 192         cp = argv[2];
 193         argc -= 3;
 194         argv += 3;
 195         (*comfun)(cp, argc, argv);      /* do the command */
 196         cp = 0;
 197         while (argc--) {
 198                 if (*argv) {
 199                         fprint(2, "ar: %s not found\n", *argv);
 200                         cp = "error";
 201                 }
 202                 argv++;
 203         }
 204         exits(cp);
 205 }
 206 /*
 207  *      select a command
 208  */
 209 void
 210 setcom(void (*fun)(char *, int, char**))
 211 {
 212
 213         if(comfun != 0) {
 214                 fprint(2, "ar: only one of [%s] allowed\n", man);
 215                 usage();
 216         }
 217         comfun = fun;
 218 }
 219 /*
 220  *      perform the 'r' and 'u' commands
 221  */
 222 void
 223 rcmd(char *arname, int count, char **files)
 224 {
 225         int fd;
 226         int i;
 227         Arfile *ap;
 228         Armember *bp;
 229         Dir *d;
 230         Biobuf *bfile;
 231
 232         fd = openar(arname, ORDWR, 1);
 233         if (fd >= 0) {
 234                 Binit(&bar, fd, OREAD);
 235                 Bseek(&bar,seek(fd,0,1), 1);
 236         }
 237         astart = newtempfile(artemp);
 238         ap = astart;
 239         aend = 0;
 240         for(i = 0; fd >= 0; i++) {
 241                 bp = getdir(&bar);
 242                 if (!bp)
 243                         break;
 244                 if (bamatch(file, poname)) {            /* check for pivot */
 245                         aend = newtempfile(tailtemp);
 246                         ap = aend;
 247                 }
 248                         /* pitch symdef file */
 249                 if (i == 0 && strcmp(file, symdef) == 0) {
 250                         skip(&bar, bp->size);
 251                         continue;
 252                 }
 253                 if (count && !match(count, files)) {
 254                         scanobj(&bar, ap, bp->size);
 255                         arcopy(&bar, ap, bp);
 256                         continue;
 257                 }
 258                 bfile = Bopen(file, OREAD);
 259                 if (!bfile) {
 260                         if (count != 0)
 261                                 fprint(2, "ar: cannot open %s\n", file);
 262                         scanobj(&bar, ap, bp->size);
 263                         arcopy(&bar, ap, bp);
 264                         continue;
 265                 }
 266                 d = dirfstat(Bfildes(bfile));
 267                 if(d == nil)
 268                         fprint(2, "ar: cannot stat %s: %r\n", file);
 269                 if (uflag && (d==nil || d->mtime <= bp->date)) {
 270                         scanobj(&bar, ap, bp->size);
 271                         arcopy(&bar, ap, bp);
 272                         Bterm(bfile);
 273                         free(d);
 274                         continue;
 275                 }
 276                 mesg('r', file);
 277                 skip(&bar, bp->size);
 278                 scanobj(bfile, ap, d->length);
 279                 free(d);
 280                 armove(bfile, ap, bp);
 281                 Bterm(bfile);
 282         }
 283         if(fd >= 0)
 284                 close(fd);
 285                 /* copy in remaining files named on command line */
 286         for (i = 0; i < count; i++) {
 287                 file = files[i];
 288                 if(file == 0)
 289                         continue;
 290                 files[i] = 0;
 291                 bfile = Bopen(file, OREAD);
 292                 if (!bfile)
 293                         fprint(2, "ar: %s cannot open\n", file);
 294                 else {
 295                         mesg('a', file);
 296                         d = dirfstat(Bfildes(bfile));
 297                         if (d == nil)
 298                                 fprint(2, "can't stat %s\n", file);
 299                         else {
 300                                 scanobj(bfile, astart, d->length);
 301                                 armove(bfile, astart, newmember());
 302                                 free(d);
 303                         }
 304                         Bterm(bfile);
 305                 }
 306         }
 307         if(fd < 0 && !cflag)
 308                 install(arname, astart, 0, aend, 1);    /* issue 'creating' msg */
 309         else
 310                 install(arname, astart, 0, aend, 0);
 311 }
 312
 313 void
 314 dcmd(char *arname, int count, char **files)
 315 {
 316         Armember *bp;
 317         int fd, i;
 318
 319         if (!count)
 320                 return;
 321         fd = openar(arname, ORDWR, 0);
 322         Binit(&bar, fd, OREAD);
 323         Bseek(&bar,seek(fd,0,1), 1);
 324         astart = newtempfile(artemp);
 325         for (i = 0; bp = getdir(&bar); i++) {
 326                 if(match(count, files)) {
 327                         mesg('d', file);
 328                         skip(&bar, bp->size);
 329                         if (strcmp(file, symdef) == 0)
 330                                 allobj = 0;
 331                 } else if (i == 0 && strcmp(file, symdef) == 0)
 332                                 skip(&bar, bp->size);
 333                 else {
 334                         scanobj(&bar, astart, bp->size);
 335                         arcopy(&bar, astart, bp);
 336                 }
 337         }
 338         close(fd);
 339         install(arname, astart, 0, 0, 0);
 340 }
 341
 342 void
 343 xcmd(char *arname, int count, char **files)
 344 {
 345         int fd, f, mode, i;
 346         Armember *bp;
 347         Dir dx;
 348
 349         fd = openar(arname, OREAD, 0);
 350         Binit(&bar, fd, OREAD);
 351         Bseek(&bar,seek(fd,0,1), 1);
 352         i = 0;
 353         while (bp = getdir(&bar)) {
 354                 if(count == 0 || match(count, files)) {
 355                         mode = strtoul(bp->hdr.mode, 0, 8) & 0777;
 356                         f = create(file, OWRITE, mode);
 357                         if(f < 0) {
 358                                 fprint(2, "ar: %s cannot create\n", file);
 359                                 skip(&bar, bp->size);
 360                         } else {
 361                                 mesg('x', file);
 362                                 arcopy(&bar, 0, bp);
 363                                 if (write(f, bp->member, bp->size) < 0)
 364                                         wrerr();
 365                                 if(oflag) {
 366                                         nulldir(&dx);
 367                                         dx.atime = bp->date;
 368                                         dx.mtime = bp->date;
 369                                         if(dirwstat(file, &dx) < 0)
 370                                                 perror(file);
 371                                 }
 372                                 free(bp->member);
 373                                 close(f);
 374                         }
 375                         free(bp);
 376                         if (count && ++i >= count)
 377                                 break;
 378                 } else {
 379                         skip(&bar, bp->size);
 380                         free(bp);
 381                 }
 382         }
 383         close(fd);
 384 }
 385 void
 386 pcmd(char *arname, int count, char **files)
 387 {
 388         int fd;
 389         Armember *bp;
 390
 391         fd = openar(arname, OREAD, 0);
 392         Binit(&bar, fd, OREAD);
 393         Bseek(&bar,seek(fd,0,1), 1);
 394         while(bp = getdir(&bar)) {
 395                 if(count == 0 || match(count, files)) {
 396                         if(vflag)
 397                                 print("\n<%s>\n\n", file);
 398                         arcopy(&bar, 0, bp);
 399                         if (write(1, bp->member, bp->size) < 0)
 400                                 wrerr();
 401                 } else
 402                         skip(&bar, bp->size);
 403                 free(bp);
 404         }
 405         close(fd);
 406 }
 407 void
 408 mcmd(char *arname, int count, char **files)
 409 {
 410         int fd, i;
 411         Arfile *ap;
 412         Armember *bp;
 413
 414         if (count == 0)
 415                 return;
 416         fd = openar(arname, ORDWR, 0);
 417         Binit(&bar, fd, OREAD);
 418         Bseek(&bar,seek(fd,0,1), 1);
 419         astart = newtempfile(artemp);
 420         amiddle = newtempfile(movtemp);
 421         aend = 0;
 422         ap = astart;
 423         for (i = 0; bp = getdir(&bar); i++) {
 424                 if (bamatch(file, poname)) {
 425                         aend = newtempfile(tailtemp);
 426                         ap = aend;
 427                 }
 428                 if(match(count, files)) {
 429                         mesg('m', file);
 430                         scanobj(&bar, amiddle, bp->size);
 431                         arcopy(&bar, amiddle, bp);
 432                 } else
 433                         /*
 434                          * pitch the symdef file if it is at the beginning
 435                          * of the archive and we aren't inserting in front
 436                          * of it (ap == astart).
 437                          */
 438                 if (ap == astart && i == 0 && strcmp(file, symdef) == 0)
 439                         skip(&bar, bp->size);
 440                 else {
 441                         scanobj(&bar, ap, bp->size);
 442                         arcopy(&bar, ap, bp);
 443                 }
 444         }
 445         close(fd);
 446         if (poname[0] && aend == 0)
 447                 fprint(2, "ar: %s not found - files moved to end.\n", poname);
 448         install(arname, astart, amiddle, aend, 0);
 449 }
 450 void
 451 tcmd(char *arname, int count, char **files)
 452 {
 453         int fd;
 454         Armember *bp;
 455         char name[ARNAMESIZE+1];
 456
 457         fd = openar(arname, OREAD, 0);
 458         Binit(&bar, fd, OREAD);
 459         Bseek(&bar,seek(fd,0,1), 1);
 460         while(bp = getdir(&bar)) {
 461                 if(count == 0 || match(count, files)) {
 462                         if(vflag)
 463                                 longt(bp);
 464                         trim(file, name, ARNAMESIZE);
 465                         Bprint(&bout, "%s\n", name);
 466                 }
 467                 skip(&bar, bp->size);
 468                 free(bp);
 469         }
 470         close(fd);
 471 }
 472 void
 473 qcmd(char *arname, int count, char **files)
 474 {
 475         int fd, i;
 476         Armember *bp;
 477         Biobuf *bfile;
 478
 479         if(aflag || bflag) {
 480                 fprint(2, "ar: abi not allowed with q\n");
 481                 exits("error");
 482         }
 483         fd = openar(arname, ORDWR, 1);
 484         if (fd < 0) {
 485                 if(!cflag)
 486                         fprint(2, "ar: creating %s\n", arname);
 487                 fd = arcreate(arname);
 488         }
 489         Binit(&bar, fd, OREAD);
 490         Bseek(&bar,seek(fd,0,1), 1);
 491         /* leave note group behind when writing archive; i.e. sidestep interrupts */
 492         rfork(RFNOTEG);
 493         Bseek(&bar, 0, 2);
 494         bp = newmember();
 495         for(i=0; i<count && files[i]; i++) {
 496                 file = files[i];
 497                 files[i] = 0;
 498                 bfile = Bopen(file, OREAD);
 499                 if(!bfile)
 500                         fprint(2, "ar: %s cannot open\n", file);
 501                 else {
 502                         mesg('q', file);
 503                         armove(bfile, 0, bp);
 504                         if (!arwrite(fd, bp))
 505                                 wrerr();
 506                         free(bp->member);
 507                         bp->member = 0;
 508                         Bterm(bfile);
 509                 }
 510         }
 511         free(bp);
 512         close(fd);
 513 }
 514
 515 /*
 516  *      extract the symbol references from an object file
 517  */
 518 void
 519 scanobj(Biobuf *b, Arfile *ap, long size)
 520 {
 521         int obj;
 522         vlong offset;
 523         Dir *d;
 524         static int lastobj = -1;
 525
 526         if (!allobj)                    /* non-object file encountered */
 527                 return;
 528         offset = Boffset(b);
 529         obj = objtype(b, 0);
 530         if (obj < 0) {                  /* not an object file */
 531                 allobj = 0;
 532                 d = dirfstat(Bfildes(b));
 533                 if (d != nil && d->length == 0)
 534                         fprint(2, "ar: zero length file %s\n", file);
 535                 free(d);
 536                 Bseek(b, offset, 0);
 537                 return;
 538         }
 539         if (lastobj >= 0 && obj != lastobj) {
 540                 fprint(2, "ar: inconsistent object file %s\n", file);
 541                 allobj = 0;
 542                 Bseek(b, offset, 0);
 543                 return;
 544         }
 545         lastobj = obj;
 546         if (!readar(b, obj, offset+size, 0)) {
 547                 fprint(2, "ar: invalid symbol reference in file %s\n", file);
 548                 allobj = 0;
 549                 Bseek(b, offset, 0);
 550                 return;
 551         }
 552         Bseek(b, offset, 0);
 553         objtraverse(objsym, ap);
 554 }
 555
 556 /*
 557  *      add text and data symbols to the symbol list
 558  */
 559 void
 560 objsym(Sym *s, void *p)
 561 {
 562         int n;
 563         Arsymref *as;
 564         Arfile *ap;
 565
 566         if (s->type != 'T' &&  s->type != 'D')
 567                 return;
 568         ap = (Arfile*)p;
 569         as = (Arsymref*)armalloc(sizeof(Arsymref));
 570         as->offset = ap->size;
 571         n = strlen(s->name);
 572         as->name = armalloc(n+1);
 573         strcpy(as->name, s->name);
 574         if(s->type == 'T' && duplicate(as->name)) {
 575                 dupfound = 1;
 576                 fprint(2, "duplicate text symbol: %s\n", as->name);
 577                 free(as->name);
 578                 free(as);
 579                 return;
 580         }
 581         as->type = s->type;
 582         symdefsize += 4+(n+1)+1;
 583         as->len = n;
 584         as->next = ap->sym;
 585         ap->sym = as;
 586 }
 587
 588 /*
 589  *      Check the symbol table for duplicate text symbols
 590  */
 591 int
 592 duplicate(char *name)
 593 {
 594         Hashchain *p;
 595         char *cp;
 596         int h;
 597
 598         h = 0;
 599         for(cp = name; *cp; h += *cp++)
 600                 h *= 1119;
 601         if(h < 0)
 602                 h = ~h;
 603         h %= NHASH;
 604
 605         for(p = hash[h]; p; p = p->next)
 606                 if(strcmp(p->name, name) == 0)
 607                         return 1;
 608         p = (Hashchain*) armalloc(sizeof(Hashchain));
 609         p->next = hash[h];
 610         p->name = name;
 611         hash[h] = p;
 612         return 0;
 613 }
 614
 615 /*
 616  *      open an archive and validate its header
 617  */
 618 int
 619 openar(char *arname, int mode, int errok)
 620 {
 621         int fd;
 622         char mbuf[SARMAG];
 623
 624         fd = open(arname, mode);
 625         if(fd >= 0){
 626                 if(read(fd, mbuf, SARMAG) != SARMAG || strncmp(mbuf, ARMAG, SARMAG)) {
 627                         fprint(2, "ar: %s not in archive format\n", arname);
 628                         exits("error");
 629                 }
 630         }else if(!errok){
 631                 fprint(2, "ar: cannot open %s: %r\n", arname);
 632                 exits("error");
 633         }
 634         return fd;
 635 }
 636
 637 /*
 638  *      create an archive and set its header
 639  */
 640 int
 641 arcreate(char *arname)
 642 {
 643         int fd;
 644
 645         fd = create(arname, OWRITE, 0664);
 646         if(fd < 0){
 647                 fprint(2, "ar: cannot create %s: %r\n", arname);
 648                 exits("error");
 649         }
 650         if(write(fd, ARMAG, SARMAG) != SARMAG)
 651                 wrerr();
 652         return fd;
 653 }
 654
 655 /*
 656  *              error handling
 657  */
 658 void
 659 wrerr(void)
 660 {
 661         perror("ar: write error");
 662         exits("error");
 663 }
 664
 665 void
 666 rderr(void)
 667 {
 668         perror("ar: read error");
 669         exits("error");
 670 }
 671
 672 void
 673 phaseerr(int offset)
 674 {
 675         fprint(2, "ar: phase error at offset %d\n", offset);
 676         exits("error");
 677 }
 678
 679 void
 680 usage(void)
 681 {
 682         fprint(2, "usage: ar [%s][%s] archive files ...\n", opt, man);
 683         exits("error");
 684 }
 685
 686 /*
 687  *      read the header for the next archive member
 688  */
 689 Armember *
 690 getdir(Biobuf *b)
 691 {
 692         Armember *bp;
 693         char *cp;
 694         static char name[ARNAMESIZE+1];
 695
 696         bp = newmember();
 697         if(HEADER_IO(Bread, b, bp->hdr)) {
 698                 free(bp);
 699                 return 0;
 700         }
 701         if(strncmp(bp->hdr.fmag, ARFMAG, sizeof(bp->hdr.fmag)) != 0)
 702                 phaseerr(Boffset(b));
 703         strncpy(name, bp->hdr.name, sizeof(bp->hdr.name));
 704         cp = name+sizeof(name)-1;
 705         *cp = '\0';
 706         /* skip trailing spaces and (gnu-produced) slashes */
 707         while(*--cp == ' ' || *cp == '/')
 708                 ;
 709         cp[1] = '\0';
 710         file = name;
 711         bp->date = strtol(bp->hdr.date, 0, 0);
 712         bp->size = strtol(bp->hdr.size, 0, 0);
 713         return bp;
 714 }
 715
 716 /*
 717  *      Copy the file referenced by fd to the temp file
 718  */
 719 void
 720 armove(Biobuf *b, Arfile *ap, Armember *bp)
 721 {
 722         char *cp;
 723         Dir *d;
 724
 725         d = dirfstat(Bfildes(b));
 726         if (d == nil) {
 727                 fprint(2, "ar: cannot stat %s\n", file);
 728                 return;
 729         }
 730         trim(file, bp->hdr.name, sizeof(bp->hdr.name));
 731         for (cp = strchr(bp->hdr.name, 0);              /* blank pad on right */
 732                 cp < bp->hdr.name+sizeof(bp->hdr.name); cp++)
 733                         *cp = ' ';
 734         sprint(bp->hdr.date, "%-12ld", d->mtime);
 735         sprint(bp->hdr.uid, "%-6d", 0);
 736         sprint(bp->hdr.gid, "%-6d", 0);
 737         sprint(bp->hdr.mode, "%-8lo", d->mode);
 738         sprint(bp->hdr.size, "%-10lld", d->length);
 739         strncpy(bp->hdr.fmag, ARFMAG, 2);
 740         bp->size = d->length;
 741         arread(b, bp, bp->size);
 742         if (d->length&0x01)
 743                 d->length++;
 744         if (ap) {
 745                 arinsert(ap, bp);
 746                 ap->size += d->length+SAR_HDR;
 747         }
 748         free(d);
 749 }
 750
 751 /*
 752  *      Copy the archive member at the current offset into the temp file.
 753  */
 754 void
 755 arcopy(Biobuf *b, Arfile *ap, Armember *bp)
 756 {
 757         long n;
 758
 759         n = bp->size;
 760         if (n & 01)
 761                 n++;
 762         arread(b, bp, n);
 763         if (ap) {
 764                 arinsert(ap, bp);
 765                 ap->size += n+SAR_HDR;
 766         }
 767 }
 768
 769 /*
 770  *      Skip an archive member
 771  */
 772 void
 773 skip(Biobuf *bp, vlong len)
 774 {
 775         if (len & 01)
 776                 len++;
 777         Bseek(bp, len, 1);
 778 }
 779
 780 /*
 781  *      Stream the three temp files to an archive
 782  */
 783 void
 784 install(char *arname, Arfile *astart, Arfile *amiddle, Arfile *aend, int createflag)
 785 {
 786         int fd;
 787
 788         if(allobj && dupfound) {
 789                 fprint(2, "%s not changed\n", arname);
 790                 return;
 791         }
 792         /* leave note group behind when copying back; i.e. sidestep interrupts */
 793         rfork(RFNOTEG);
 794
 795         if(createflag)
 796                 fprint(2, "ar: creating %s\n", arname);
 797         fd = arcreate(arname);
 798
 799         if(allobj)
 800                 rl(fd);
 801
 802         if (astart) {
 803                 arstream(fd, astart);
 804                 arfree(astart);
 805         }
 806         if (amiddle) {
 807                 arstream(fd, amiddle);
 808                 arfree(amiddle);
 809         }
 810         if (aend) {
 811                 arstream(fd, aend);
 812                 arfree(aend);
 813         }
 814         close(fd);
 815 }
 816
 817 void
 818 rl(int fd)
 819 {
 820
 821         Biobuf b;
 822         char *cp;
 823         struct ar_hdr a;
 824         long len;
 825
 826         Binit(&b, fd, OWRITE);
 827         Bseek(&b,seek(fd,0,1), 0);
 828
 829         len = symdefsize;
 830         if(len&01)
 831                 len++;
 832         sprint(a.date, "%-12ld", time(0));
 833         sprint(a.uid, "%-6d", 0);
 834         sprint(a.gid, "%-6d", 0);
 835         sprint(a.mode, "%-8lo", 0644L);
 836         sprint(a.size, "%-10ld", len);
 837         strncpy(a.fmag, ARFMAG, 2);
 838         strcpy(a.name, symdef);
 839         for (cp = strchr(a.name, 0);            /* blank pad on right */
 840                 cp < a.name+sizeof(a.name); cp++)
 841                         *cp = ' ';
 842         if(HEADER_IO(Bwrite, &b, a))
 843                         wrerr();
 844
 845         len += Boffset(&b);
 846         if (astart) {
 847                 wrsym(&b, len, astart->sym);
 848                 len += astart->size;
 849         }
 850         if(amiddle) {
 851                 wrsym(&b, len, amiddle->sym);
 852                 len += amiddle->size;
 853         }
 854         if(aend)
 855                 wrsym(&b, len, aend->sym);
 856
 857         if(symdefsize&0x01)
 858                 Bputc(&b, 0);
 859         Bterm(&b);
 860 }
 861
 862 /*
 863  *      Write the defined symbols to the symdef file
 864  */
 865 void
 866 wrsym(Biobuf *bp, long offset, Arsymref *as)
 867 {
 868         int off;
 869
 870         while(as) {
 871                 Bputc(bp, as->type);
 872                 off = as->offset+offset;
 873                 Bputc(bp, off);
 874                 Bputc(bp, off>>8);
 875                 Bputc(bp, off>>16);
 876                 Bputc(bp, off>>24);
 877                 if (Bwrite(bp, as->name, as->len+1) != as->len+1)
 878                         wrerr();
 879                 as = as->next;
 880         }
 881 }
 882
 883 /*
 884  *      Check if the archive member matches an entry on the command line.
 885  */
 886 int
 887 match(int count, char **files)
 888 {
 889         int i;
 890         char name[ARNAMESIZE+1];
 891
 892         for(i=0; i<count; i++) {
 893                 if(files[i] == 0)
 894                         continue;
 895                 trim(files[i], name, ARNAMESIZE);
 896                 if(strncmp(name, file, ARNAMESIZE) == 0) {
 897                         file = files[i];
 898                         files[i] = 0;
 899                         return 1;
 900                 }
 901         }
 902         return 0;
 903 }
 904
 905 /*
 906  *      compare the current member to the name of the pivot member
 907  */
 908 int
 909 bamatch(char *file, char *pivot)
 910 {
 911         static int state = 0;
 912
 913         switch(state)
 914         {
 915         case 0:                 /* looking for position file */
 916                 if (aflag) {
 917                         if (strncmp(file, pivot, ARNAMESIZE) == 0)
 918                                 state = 1;
 919                 } else if (bflag) {
 920                         if (strncmp(file, pivot, ARNAMESIZE) == 0) {
 921                                 state = 2;      /* found */
 922                                 return 1;
 923                         }
 924                 }
 925                 break;
 926         case 1:                 /* found - after previous file */
 927                 state = 2;
 928                 return 1;
 929         case 2:                 /* already found position file */
 930                 break;
 931         }
 932         return 0;
 933 }
 934
 935 /*
 936  *      output a message, if 'v' option was specified
 937  */
 938 void
 939 mesg(int c, char *file)
 940 {
 941
 942         if(vflag)
 943                 Bprint(&bout, "%c - %s\n", c, file);
 944 }
 945
 946 /*
 947  *      isolate file name by stripping leading directories and trailing slashes
 948  */
 949 void
 950 trim(char *s, char *buf, int n)
 951 {
 952         char *p;
 953
 954         for(;;) {
 955                 p = strrchr(s, '/');
 956                 if (!p) {               /* no slash in name */
 957                         strncpy(buf, s, n);
 958                         return;
 959                 }
 960                 if (p[1] != 0) {        /* p+1 is first char of file name */
 961                         strncpy(buf, p+1, n);
 962                         return;
 963                 }
 964                 *p = 0;                 /* strip trailing slash */
 965         }
 966 }
 967
 968 /*
 969  *      utilities for printing long form of 't' command
 970  */
 971 #define SUID    04000
 972 #define SGID    02000
 973 #define ROWN    0400
 974 #define WOWN    0200
 975 #define XOWN    0100
 976 #define RGRP    040
 977 #define WGRP    020
 978 #define XGRP    010
 979 #define ROTH    04
 980 #define WOTH    02
 981 #define XOTH    01
 982 #define STXT    01000
 983
 984 void
 985 longt(Armember *bp)
 986 {
 987         char *cp;
 988
 989         pmode(strtoul(bp->hdr.mode, 0, 8));
 990         Bprint(&bout, "%3ld/%1ld", strtol(bp->hdr.uid, 0, 0), strtol(bp->hdr.gid, 0, 0));
 991         Bprint(&bout, "%7ld", bp->size);
 992         cp = ctime(bp->date);
 993         Bprint(&bout, " %-12.12s %-4.4s ", cp+4, cp+24);
 994 }
 995
 996 int     m1[] = { 1, ROWN, 'r', '-' };
 997 int     m2[] = { 1, WOWN, 'w', '-' };
 998 int     m3[] = { 2, SUID, 's', XOWN, 'x', '-' };
 999 int     m4[] = { 1, RGRP, 'r', '-' };
1000 int     m5[] = { 1, WGRP, 'w', '-' };
1001 int     m6[] = { 2, SGID, 's', XGRP, 'x', '-' };
1002 int     m7[] = { 1, ROTH, 'r', '-' };
1003 int     m8[] = { 1, WOTH, 'w', '-' };
1004 int     m9[] = { 2, STXT, 't', XOTH, 'x', '-' };
1005
1006 int     *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
1007
1008 void
1009 pmode(long mode)
1010 {
1011         int **mp;
1012
1013         for(mp = &m[0]; mp < &m[9];)
1014                 select(*mp++, mode);
1015 }
1016
1017 void
1018 select(int *ap, long mode)
1019 {
1020         int n;
1021
1022         n = *ap++;
1023         while(--n>=0 && (mode&*ap++)==0)
1024                 ap++;
1025         Bputc(&bout, *ap);
1026 }
1027
1028 /*
1029  *      Temp file I/O subsystem.  We attempt to cache all three temp files in
1030  *      core.  When we run out of memory we spill to disk.
1031  *      The I/O model assumes that temp files:
1032  *              1) are only written on the end
1033  *              2) are only read from the beginning
1034  *              3) are only read after all writing is complete.
1035  *      The architecture uses one control block per temp file.  Each control
1036  *      block anchors a chain of buffers, each containing an archive member.
1037  */
1038 Arfile *
1039 newtempfile(char *name)         /* allocate a file control block */
1040 {
1041         Arfile *ap;
1042
1043         ap = (Arfile *) armalloc(sizeof(Arfile));
1044         ap->fname = name;
1045         return ap;
1046 }
1047
1048 Armember *
1049 newmember(void)                 /* allocate a member buffer */
1050 {
1051         return (Armember *)armalloc(sizeof(Armember));
1052 }
1053
1054 void
1055 arread(Biobuf *b, Armember *bp, int n)  /* read an image into a member buffer */
1056 {
1057         int i;
1058
1059         bp->member = armalloc(n);
1060         i = Bread(b, bp->member, n);
1061         if (i < 0) {
1062                 free(bp->member);
1063                 bp->member = 0;
1064                 rderr();
1065         }
1066 }
1067
1068 /*
1069  * insert a member buffer into the member chain
1070  */
1071 void
1072 arinsert(Arfile *ap, Armember *bp)
1073 {
1074         bp->next = 0;
1075         if (!ap->tail)
1076                 ap->head = bp;
1077         else
1078                 ap->tail->next = bp;
1079         ap->tail = bp;
1080 }
1081
1082 /*
1083  *      stream the members in a temp file to the file referenced by 'fd'.
1084  */
1085 void
1086 arstream(int fd, Arfile *ap)
1087 {
1088         Armember *bp;
1089         int i;
1090         char buf[8192];
1091
1092         if (ap->paged) {                /* copy from disk */
1093                 seek(ap->fd, 0, 0);
1094                 for (;;) {
1095                         i = read(ap->fd, buf, sizeof(buf));
1096                         if (i < 0)
1097                                 rderr();
1098                         if (i == 0)
1099                                 break;
1100                         if (write(fd, buf, i) != i)
1101                                 wrerr();
1102                 }
1103                 close(ap->fd);
1104                 ap->paged = 0;
1105         }
1106                 /* dump the in-core buffers */
1107         for (bp = ap->head; bp; bp = bp->next) {
1108                 if (!arwrite(fd, bp))
1109                         wrerr();
1110         }
1111 }
1112
1113 /*
1114  *      write a member to 'fd'.
1115  */
1116 int
1117 arwrite(int fd, Armember *bp)
1118 {
1119         int len;
1120
1121         if(HEADER_IO(write, fd, bp->hdr))
1122                 return 0;
1123         len = bp->size;
1124         if (len & 01)
1125                 len++;
1126         if (write(fd, bp->member, len) != len)
1127                 return 0;
1128         return 1;
1129 }
1130
1131 /*
1132  *      Spill a member to a disk copy of a temp file
1133  */
1134 int
1135 page(Arfile *ap)
1136 {
1137         Armember *bp;
1138
1139         bp = ap->head;
1140         if (!ap->paged) {               /* not yet paged - create file */
1141                 ap->fname = mktemp(ap->fname);
1142                 ap->fd = create(ap->fname, ORDWR|ORCLOSE, 0600);
1143                 if (ap->fd < 0) {
1144                         fprint(2,"ar: can't create temp file\n");
1145                         return 0;
1146                 }
1147                 ap->paged = 1;
1148         }
1149         if (!arwrite(ap->fd, bp))       /* write member and free buffer block */
1150                 return 0;
1151         ap->head = bp->next;
1152         if (ap->tail == bp)
1153                 ap->tail = bp->next;
1154         free(bp->member);
1155         free(bp);
1156         return 1;
1157 }
1158
1159 /*
1160  *      try to reclaim space by paging.  we try to spill the start, middle,
1161  *      and end files, in that order.  there is no particular reason for the
1162  *      ordering.
1163  */
1164 int
1165 getspace(void)
1166 {
1167         if (astart && astart->head && page(astart))
1168                         return 1;
1169         if (amiddle && amiddle->head && page(amiddle))
1170                         return 1;
1171         if (aend && aend->head && page(aend))
1172                         return 1;
1173         return 0;
1174 }
1175
1176 void
1177 arfree(Arfile *ap)              /* free a member buffer */
1178 {
1179         Armember *bp, *next;
1180
1181         for (bp = ap->head; bp; bp = next) {
1182                 next = bp->next;
1183                 if (bp->member)
1184                         free(bp->member);
1185                 free(bp);
1186         }
1187         free(ap);
1188 }
1189
1190 /*
1191  *      allocate space for a control block or member buffer.  if the malloc
1192  *      fails we try to reclaim space by spilling previously allocated
1193  *      member buffers.
1194  */
1195 char *
1196 armalloc(int n)
1197 {
1198         char *cp;
1199
1200         do {
1201                 cp = malloc(n);
1202                 if (cp) {
1203                         memset(cp, 0, n);
1204                         return cp;
1205                 }
1206         } while (getspace());
1207         fprint(2, "ar: out of memory\n");
1208         exits("malloc");
1209         return 0;
1210 }