ref: 39f18c9d88f52a22373790dec5721fa3521d3f00
dir: /sys/src/cmd/ar.c/
/*
* ar - portable (ascii) format version
*/
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <mach.h>
#include <ar.h>
/*
* The algorithm uses up to 3 temp files. The "pivot member" is the
* archive member specified by and a, b, or i option. The temp files are
* astart - contains existing members up to and including the pivot member.
* amiddle - contains new files moved or inserted behind the pivot.
* aend - contains the existing members that follow the pivot member.
* When all members have been processed, function 'install' streams the
* temp files, in order, back into the archive.
*/
typedef struct Arsymref
{
char *name;
int type;
int len;
vlong offset;
struct Arsymref *next;
} Arsymref;
typedef struct Armember /* Temp file entry - one per archive member */
{
struct Armember *next;
struct ar_hdr hdr;
long size;
long date;
void *member;
} Armember;
typedef struct Arfile /* Temp file control block - one per tempfile */
{
int paged; /* set when some data paged to disk */
char *fname; /* paging file name */
int fd; /* paging file descriptor */
vlong size;
Armember *head; /* head of member chain */
Armember *tail; /* tail of member chain */
Arsymref *sym; /* head of defined symbol chain */
} Arfile;
typedef struct Hashchain
{
char *name;
struct Hashchain *next;
} Hashchain;
#define NHASH 1024
/*
* macro to portably read/write archive header.
* 'cmd' is read/write/Bread/Bwrite, etc.
*/
#define HEADER_IO(cmd, f, h) cmd(f, h.name, sizeof(h.name)) != sizeof(h.name)\
|| cmd(f, h.date, sizeof(h.date)) != sizeof(h.date)\
|| cmd(f, h.uid, sizeof(h.uid)) != sizeof(h.uid)\
|| cmd(f, h.gid, sizeof(h.gid)) != sizeof(h.gid)\
|| cmd(f, h.mode, sizeof(h.mode)) != sizeof(h.mode)\
|| cmd(f, h.size, sizeof(h.size)) != sizeof(h.size)\
|| cmd(f, h.fmag, sizeof(h.fmag)) != sizeof(h.fmag)
/* constants and flags */
char *man = "mrxtdpq";
char *opt = "uvnbailo";
char artemp[] = "/tmp/vXXXXX";
char movtemp[] = "/tmp/v1XXXXX";
char tailtemp[] = "/tmp/v2XXXXX";
char symdef[] = "__.SYMDEF";
int aflag; /* command line flags */
int bflag;
int cflag;
int oflag;
int uflag;
int vflag;
Arfile *astart, *amiddle, *aend; /* Temp file control block pointers */
int allobj = 1; /* set when all members are object files of the same type */
int symdefsize; /* size of symdef file */
int dupfound; /* flag for duplicate symbol */
Hashchain *hash[NHASH]; /* hash table of text symbols */
#define ARNAMESIZE sizeof(astart->tail->hdr.name)
char poname[ARNAMESIZE+1]; /* name of pivot member */
char *file; /* current file or member being worked on */
Biobuf bout;
Biobuf bar;
void arcopy(Biobuf*, Arfile*, Armember*);
int arcreate(char*);
void arfree(Arfile*);
void arinsert(Arfile*, Armember*);
char *armalloc(int);
void armove(Biobuf*, Arfile*, Armember*);
void arread(Biobuf*, Armember*, int);
void arstream(int, Arfile*);
int arwrite(int, Armember*);
int bamatch(char*, char*);
int duplicate(char*);
Armember *getdir(Biobuf*);
int getspace(void);
void install(char*, Arfile*, Arfile*, Arfile*, int);
void longt(Armember*);
int match(int, char**);
void mesg(int, char*);
Arfile *newtempfile(char*);
Armember *newmember(void);
void objsym(Sym*, void*);
int openar(char*, int, int);
int page(Arfile*);
void pmode(long);
void rl(int);
void scanobj(Biobuf*, Arfile*, long);
void select(int*, long);
void setcom(void(*)(char*, int, char**));
void skip(Biobuf*, vlong);
int symcomp(void*, void*);
void trim(char*, char*, int);
void usage(void);
void wrerr(void);
void wrsym(Biobuf*, long, Arsymref*);
void rcmd(char*, int, char**); /* command processing */
void dcmd(char*, int, char**);
void xcmd(char*, int, char**);
void tcmd(char*, int, char**);
void pcmd(char*, int, char**);
void mcmd(char*, int, char**);
void qcmd(char*, int, char**);
void (*comfun)(char*, int, char**);
void
main(int argc, char *argv[])
{
char *cp;
Binit(&bout, 1, OWRITE);
if(argc < 3)
usage();
for (cp = argv[1]; *cp; cp++) {
switch(*cp) {
case 'a': aflag = 1; break;
case 'b': bflag = 1; break;
case 'c': cflag = 1; break;
case 'd': setcom(dcmd); break;
case 'i': bflag = 1; break;
case 'l':
strcpy(artemp, "vXXXXX");
strcpy(movtemp, "v1XXXXX");
strcpy(tailtemp, "v2XXXXX");
break;
case 'm': setcom(mcmd); break;
case 'o': oflag = 1; break;
case 'p': setcom(pcmd); break;
case 'q': setcom(qcmd); break;
case 'r': setcom(rcmd); break;
case 't': setcom(tcmd); break;
case 'u': uflag = 1; break;
case 'v': vflag = 1; break;
case 'x': setcom(xcmd); break;
default:
fprint(2, "ar: bad option `%c'\n", *cp);
exits("error");
}
}
if (aflag && bflag) {
fprint(2, "ar: only one of 'a' and 'b' can be specified\n");
usage();
}
if(aflag || bflag) {
trim(argv[2], poname, sizeof(poname));
argv++;
argc--;
if(argc < 3)
usage();
}
if(comfun == 0) {
if(uflag == 0) {
fprint(2, "ar: one of [%s] must be specified\n", man);
usage();
}
setcom(rcmd);
}
cp = argv[2];
argc -= 3;
argv += 3;
(*comfun)(cp, argc, argv); /* do the command */
cp = 0;
while (argc--) {
if (*argv) {
fprint(2, "ar: %s not found\n", *argv);
cp = "error";
}
argv++;
}
exits(cp);
}
/*
* select a command
*/
void
setcom(void (*fun)(char *, int, char**))
{
if(comfun != 0) {
fprint(2, "ar: only one of [%s] allowed\n", man);
usage();
}
comfun = fun;
}
/*
* perform the 'r' and 'u' commands
*/
void
rcmd(char *arname, int count, char **files)
{
int fd;
int i;
Arfile *ap;
Armember *bp;
Dir *d;
Biobuf *bfile;
fd = openar(arname, ORDWR, 1);
if (fd >= 0) {
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
}
astart = newtempfile(artemp);
ap = astart;
aend = 0;
for(i = 0; fd >= 0; i++) {
bp = getdir(&bar);
if (!bp)
break;
if (bamatch(file, poname)) { /* check for pivot */
aend = newtempfile(tailtemp);
ap = aend;
}
/* pitch symdef file */
if (i == 0 && strcmp(file, symdef) == 0) {
skip(&bar, bp->size);
continue;
}
if (count && !match(count, files)) {
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
continue;
}
bfile = Bopen(file, OREAD);
if (!bfile) {
if (count != 0)
fprint(2, "ar: cannot open %s\n", file);
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
continue;
}
d = dirfstat(Bfildes(bfile));
if(d == nil)
fprint(2, "ar: cannot stat %s: %r\n", file);
if (uflag && (d==nil || d->mtime <= bp->date)) {
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
Bterm(bfile);
free(d);
continue;
}
mesg('r', file);
skip(&bar, bp->size);
scanobj(bfile, ap, d->length);
free(d);
armove(bfile, ap, bp);
Bterm(bfile);
}
if(fd >= 0)
close(fd);
/* copy in remaining files named on command line */
for (i = 0; i < count; i++) {
file = files[i];
if(file == 0)
continue;
files[i] = 0;
bfile = Bopen(file, OREAD);
if (!bfile)
fprint(2, "ar: %s cannot open\n", file);
else {
mesg('a', file);
d = dirfstat(Bfildes(bfile));
if (d == nil)
fprint(2, "can't stat %s\n", file);
else {
scanobj(bfile, astart, d->length);
armove(bfile, astart, newmember());
free(d);
}
Bterm(bfile);
}
}
if(fd < 0 && !cflag)
install(arname, astart, 0, aend, 1); /* issue 'creating' msg */
else
install(arname, astart, 0, aend, 0);
}
void
dcmd(char *arname, int count, char **files)
{
Armember *bp;
int fd, i;
if (!count)
return;
fd = openar(arname, ORDWR, 0);
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
astart = newtempfile(artemp);
for (i = 0; bp = getdir(&bar); i++) {
if(match(count, files)) {
mesg('d', file);
skip(&bar, bp->size);
if (strcmp(file, symdef) == 0)
allobj = 0;
} else if (i == 0 && strcmp(file, symdef) == 0)
skip(&bar, bp->size);
else {
scanobj(&bar, astart, bp->size);
arcopy(&bar, astart, bp);
}
}
close(fd);
install(arname, astart, 0, 0, 0);
}
void
xcmd(char *arname, int count, char **files)
{
int fd, f, mode, i;
Armember *bp;
Dir dx;
fd = openar(arname, OREAD, 0);
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
i = 0;
while (bp = getdir(&bar)) {
if(count == 0 || match(count, files)) {
mode = strtoul(bp->hdr.mode, 0, 8) & 0777;
f = create(file, OWRITE, mode);
if(f < 0) {
fprint(2, "ar: %s cannot create\n", file);
skip(&bar, bp->size);
} else {
mesg('x', file);
arcopy(&bar, 0, bp);
if (write(f, bp->member, bp->size) < 0)
wrerr();
if(oflag) {
nulldir(&dx);
dx.atime = bp->date;
dx.mtime = bp->date;
if(dirwstat(file, &dx) < 0)
perror(file);
}
free(bp->member);
close(f);
}
free(bp);
if (count && ++i >= count)
break;
} else {
skip(&bar, bp->size);
free(bp);
}
}
close(fd);
}
void
pcmd(char *arname, int count, char **files)
{
int fd;
Armember *bp;
fd = openar(arname, OREAD, 0);
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
while(bp = getdir(&bar)) {
if(count == 0 || match(count, files)) {
if(vflag)
print("\n<%s>\n\n", file);
arcopy(&bar, 0, bp);
if (write(1, bp->member, bp->size) < 0)
wrerr();
} else
skip(&bar, bp->size);
free(bp);
}
close(fd);
}
void
mcmd(char *arname, int count, char **files)
{
int fd, i;
Arfile *ap;
Armember *bp;
if (count == 0)
return;
fd = openar(arname, ORDWR, 0);
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
astart = newtempfile(artemp);
amiddle = newtempfile(movtemp);
aend = 0;
ap = astart;
for (i = 0; bp = getdir(&bar); i++) {
if (bamatch(file, poname)) {
aend = newtempfile(tailtemp);
ap = aend;
}
if(match(count, files)) {
mesg('m', file);
scanobj(&bar, amiddle, bp->size);
arcopy(&bar, amiddle, bp);
} else
/*
* pitch the symdef file if it is at the beginning
* of the archive and we aren't inserting in front
* of it (ap == astart).
*/
if (ap == astart && i == 0 && strcmp(file, symdef) == 0)
skip(&bar, bp->size);
else {
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
}
}
close(fd);
if (poname[0] && aend == 0)
fprint(2, "ar: %s not found - files moved to end.\n", poname);
install(arname, astart, amiddle, aend, 0);
}
void
tcmd(char *arname, int count, char **files)
{
int fd;
Armember *bp;
char name[ARNAMESIZE+1];
fd = openar(arname, OREAD, 0);
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
while(bp = getdir(&bar)) {
if(count == 0 || match(count, files)) {
if(vflag)
longt(bp);
trim(file, name, ARNAMESIZE);
Bprint(&bout, "%s\n", name);
}
skip(&bar, bp->size);
free(bp);
}
close(fd);
}
void
qcmd(char *arname, int count, char **files)
{
int fd, i;
Armember *bp;
Biobuf *bfile;
if(aflag || bflag) {
fprint(2, "ar: abi not allowed with q\n");
exits("error");
}
fd = openar(arname, ORDWR, 1);
if (fd < 0) {
if(!cflag)
fprint(2, "ar: creating %s\n", arname);
fd = arcreate(arname);
}
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
/* leave note group behind when writing archive; i.e. sidestep interrupts */
rfork(RFNOTEG);
Bseek(&bar, 0, 2);
bp = newmember();
for(i=0; i<count && files[i]; i++) {
file = files[i];
files[i] = 0;
bfile = Bopen(file, OREAD);
if(!bfile)
fprint(2, "ar: %s cannot open\n", file);
else {
mesg('q', file);
armove(bfile, 0, bp);
if (!arwrite(fd, bp))
wrerr();
free(bp->member);
bp->member = 0;
Bterm(bfile);
}
}
free(bp);
close(fd);
}
/*
* extract the symbol references from an object file
*/
void
scanobj(Biobuf *b, Arfile *ap, long size)
{
int obj;
vlong offset;
Dir *d;
static int lastobj = -1;
if (!allobj) /* non-object file encountered */
return;
offset = Boffset(b);
obj = objtype(b, 0);
if (obj < 0) { /* not an object file */
allobj = 0;
d = dirfstat(Bfildes(b));
if (d != nil && d->length == 0)
fprint(2, "ar: zero length file %s\n", file);
free(d);
Bseek(b, offset, 0);
return;
}
if (lastobj >= 0 && obj != lastobj) {
fprint(2, "ar: inconsistent object file %s\n", file);
allobj = 0;
Bseek(b, offset, 0);
return;
}
lastobj = obj;
if (!readar(b, obj, offset+size, 0)) {
fprint(2, "ar: invalid symbol reference in file %s\n", file);
allobj = 0;
Bseek(b, offset, 0);
return;
}
Bseek(b, offset, 0);
objtraverse(objsym, ap);
}
/*
* add text and data symbols to the symbol list
*/
void
objsym(Sym *s, void *p)
{
int n;
Arsymref *as;
Arfile *ap;
if (s->type != 'T' && s->type != 'D')
return;
ap = (Arfile*)p;
as = (Arsymref*)armalloc(sizeof(Arsymref));
as->offset = ap->size;
n = strlen(s->name);
as->name = armalloc(n+1);
strcpy(as->name, s->name);
if(s->type == 'T' && duplicate(as->name)) {
dupfound = 1;
fprint(2, "duplicate text symbol: %s\n", as->name);
free(as->name);
free(as);
return;
}
as->type = s->type;
symdefsize += 4+(n+1)+1;
as->len = n;
as->next = ap->sym;
ap->sym = as;
}
/*
* Check the symbol table for duplicate text symbols
*/
int
duplicate(char *name)
{
Hashchain *p;
char *cp;
int h;
h = 0;
for(cp = name; *cp; h += *cp++)
h *= 1119;
if(h < 0)
h = ~h;
h %= NHASH;
for(p = hash[h]; p; p = p->next)
if(strcmp(p->name, name) == 0)
return 1;
p = (Hashchain*) armalloc(sizeof(Hashchain));
p->next = hash[h];
p->name = name;
hash[h] = p;
return 0;
}
/*
* open an archive and validate its header
*/
int
openar(char *arname, int mode, int errok)
{
int fd;
char mbuf[SARMAG];
fd = open(arname, mode);
if(fd >= 0){
if(read(fd, mbuf, SARMAG) != SARMAG || strncmp(mbuf, ARMAG, SARMAG)) {
fprint(2, "ar: %s not in archive format\n", arname);
exits("error");
}
}else if(!errok){
fprint(2, "ar: cannot open %s: %r\n", arname);
exits("error");
}
return fd;
}
/*
* create an archive and set its header
*/
int
arcreate(char *arname)
{
int fd;
fd = create(arname, OWRITE, 0664);
if(fd < 0){
fprint(2, "ar: cannot create %s: %r\n", arname);
exits("error");
}
if(write(fd, ARMAG, SARMAG) != SARMAG)
wrerr();
return fd;
}
/*
* error handling
*/
void
wrerr(void)
{
perror("ar: write error");
exits("error");
}
void
rderr(void)
{
perror("ar: read error");
exits("error");
}
void
phaseerr(int offset)
{
fprint(2, "ar: phase error at offset %d\n", offset);
exits("error");
}
void
usage(void)
{
fprint(2, "usage: ar [%s][%s] archive files ...\n", opt, man);
exits("error");
}
/*
* read the header for the next archive member
*/
Armember *
getdir(Biobuf *b)
{
Armember *bp;
char *cp;
static char name[ARNAMESIZE+1];
bp = newmember();
if(HEADER_IO(Bread, b, bp->hdr)) {
free(bp);
return 0;
}
if(strncmp(bp->hdr.fmag, ARFMAG, sizeof(bp->hdr.fmag)) != 0)
phaseerr(Boffset(b));
strncpy(name, bp->hdr.name, sizeof(bp->hdr.name));
cp = name+sizeof(name)-1;
*cp = '\0';
/* skip trailing spaces and (gnu-produced) slashes */
while(*--cp == ' ' || *cp == '/')
;
cp[1] = '\0';
file = name;
bp->date = strtol(bp->hdr.date, 0, 0);
bp->size = strtol(bp->hdr.size, 0, 0);
return bp;
}
/*
* Copy the file referenced by fd to the temp file
*/
void
armove(Biobuf *b, Arfile *ap, Armember *bp)
{
char *cp;
Dir *d;
d = dirfstat(Bfildes(b));
if (d == nil) {
fprint(2, "ar: cannot stat %s\n", file);
return;
}
trim(file, bp->hdr.name, sizeof(bp->hdr.name));
for (cp = strchr(bp->hdr.name, 0); /* blank pad on right */
cp < bp->hdr.name+sizeof(bp->hdr.name); cp++)
*cp = ' ';
sprint(bp->hdr.date, "%-12ld", d->mtime);
sprint(bp->hdr.uid, "%-6d", 0);
sprint(bp->hdr.gid, "%-6d", 0);
sprint(bp->hdr.mode, "%-8lo", d->mode);
sprint(bp->hdr.size, "%-10lld", d->length);
strncpy(bp->hdr.fmag, ARFMAG, 2);
bp->size = d->length;
arread(b, bp, bp->size);
if (d->length&0x01)
d->length++;
if (ap) {
arinsert(ap, bp);
ap->size += d->length+SAR_HDR;
}
free(d);
}
/*
* Copy the archive member at the current offset into the temp file.
*/
void
arcopy(Biobuf *b, Arfile *ap, Armember *bp)
{
long n;
n = bp->size;
if (n & 01)
n++;
arread(b, bp, n);
if (ap) {
arinsert(ap, bp);
ap->size += n+SAR_HDR;
}
}
/*
* Skip an archive member
*/
void
skip(Biobuf *bp, vlong len)
{
if (len & 01)
len++;
Bseek(bp, len, 1);
}
/*
* Stream the three temp files to an archive
*/
void
install(char *arname, Arfile *astart, Arfile *amiddle, Arfile *aend, int createflag)
{
int fd;
if(allobj && dupfound) {
fprint(2, "%s not changed\n", arname);
return;
}
/* leave note group behind when copying back; i.e. sidestep interrupts */
rfork(RFNOTEG);
if(createflag)
fprint(2, "ar: creating %s\n", arname);
fd = arcreate(arname);
if(allobj)
rl(fd);
if (astart) {
arstream(fd, astart);
arfree(astart);
}
if (amiddle) {
arstream(fd, amiddle);
arfree(amiddle);
}
if (aend) {
arstream(fd, aend);
arfree(aend);
}
close(fd);
}
void
rl(int fd)
{
Biobuf b;
char *cp;
struct ar_hdr a;
long len;
Binit(&b, fd, OWRITE);
Bseek(&b,seek(fd,0,1), 0);
len = symdefsize;
if(len&01)
len++;
sprint(a.date, "%-12ld", time(0));
sprint(a.uid, "%-6d", 0);
sprint(a.gid, "%-6d", 0);
sprint(a.mode, "%-8lo", 0644L);
sprint(a.size, "%-10ld", len);
strncpy(a.fmag, ARFMAG, 2);
strcpy(a.name, symdef);
for (cp = strchr(a.name, 0); /* blank pad on right */
cp < a.name+sizeof(a.name); cp++)
*cp = ' ';
if(HEADER_IO(Bwrite, &b, a))
wrerr();
len += Boffset(&b);
if (astart) {
wrsym(&b, len, astart->sym);
len += astart->size;
}
if(amiddle) {
wrsym(&b, len, amiddle->sym);
len += amiddle->size;
}
if(aend)
wrsym(&b, len, aend->sym);
if(symdefsize&0x01)
Bputc(&b, 0);
Bterm(&b);
}
/*
* Write the defined symbols to the symdef file
*/
void
wrsym(Biobuf *bp, long offset, Arsymref *as)
{
int off;
while(as) {
Bputc(bp, as->type);
off = as->offset+offset;
Bputc(bp, off);
Bputc(bp, off>>8);
Bputc(bp, off>>16);
Bputc(bp, off>>24);
if (Bwrite(bp, as->name, as->len+1) != as->len+1)
wrerr();
as = as->next;
}
}
/*
* Check if the archive member matches an entry on the command line.
*/
int
match(int count, char **files)
{
int i;
char name[ARNAMESIZE+1];
for(i=0; i<count; i++) {
if(files[i] == 0)
continue;
trim(files[i], name, ARNAMESIZE);
if(strncmp(name, file, ARNAMESIZE) == 0) {
file = files[i];
files[i] = 0;
return 1;
}
}
return 0;
}
/*
* compare the current member to the name of the pivot member
*/
int
bamatch(char *file, char *pivot)
{
static int state = 0;
switch(state)
{
case 0: /* looking for position file */
if (aflag) {
if (strncmp(file, pivot, ARNAMESIZE) == 0)
state = 1;
} else if (bflag) {
if (strncmp(file, pivot, ARNAMESIZE) == 0) {
state = 2; /* found */
return 1;
}
}
break;
case 1: /* found - after previous file */
state = 2;
return 1;
case 2: /* already found position file */
break;
}
return 0;
}
/*
* output a message, if 'v' option was specified
*/
void
mesg(int c, char *file)
{
if(vflag)
Bprint(&bout, "%c - %s\n", c, file);
}
/*
* isolate file name by stripping leading directories and trailing slashes
*/
void
trim(char *s, char *buf, int n)
{
char *p;
for(;;) {
p = strrchr(s, '/');
if (!p) { /* no slash in name */
strncpy(buf, s, n);
return;
}
if (p[1] != 0) { /* p+1 is first char of file name */
strncpy(buf, p+1, n);
return;
}
*p = 0; /* strip trailing slash */
}
}
/*
* utilities for printing long form of 't' command
*/
#define SUID 04000
#define SGID 02000
#define ROWN 0400
#define WOWN 0200
#define XOWN 0100
#define RGRP 040
#define WGRP 020
#define XGRP 010
#define ROTH 04
#define WOTH 02
#define XOTH 01
#define STXT 01000
void
longt(Armember *bp)
{
char *cp;
pmode(strtoul(bp->hdr.mode, 0, 8));
Bprint(&bout, "%3ld/%1ld", strtol(bp->hdr.uid, 0, 0), strtol(bp->hdr.gid, 0, 0));
Bprint(&bout, "%7ld", bp->size);
cp = ctime(bp->date);
Bprint(&bout, " %-12.12s %-4.4s ", cp+4, cp+24);
}
int m1[] = { 1, ROWN, 'r', '-' };
int m2[] = { 1, WOWN, 'w', '-' };
int m3[] = { 2, SUID, 's', XOWN, 'x', '-' };
int m4[] = { 1, RGRP, 'r', '-' };
int m5[] = { 1, WGRP, 'w', '-' };
int m6[] = { 2, SGID, 's', XGRP, 'x', '-' };
int m7[] = { 1, ROTH, 'r', '-' };
int m8[] = { 1, WOTH, 'w', '-' };
int m9[] = { 2, STXT, 't', XOTH, 'x', '-' };
int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
void
pmode(long mode)
{
int **mp;
for(mp = &m[0]; mp < &m[9];)
select(*mp++, mode);
}
void
select(int *ap, long mode)
{
int n;
n = *ap++;
while(--n>=0 && (mode&*ap++)==0)
ap++;
Bputc(&bout, *ap);
}
/*
* Temp file I/O subsystem. We attempt to cache all three temp files in
* core. When we run out of memory we spill to disk.
* The I/O model assumes that temp files:
* 1) are only written on the end
* 2) are only read from the beginning
* 3) are only read after all writing is complete.
* The architecture uses one control block per temp file. Each control
* block anchors a chain of buffers, each containing an archive member.
*/
Arfile *
newtempfile(char *name) /* allocate a file control block */
{
Arfile *ap;
ap = (Arfile *) armalloc(sizeof(Arfile));
ap->fname = name;
return ap;
}
Armember *
newmember(void) /* allocate a member buffer */
{
return (Armember *)armalloc(sizeof(Armember));
}
void
arread(Biobuf *b, Armember *bp, int n) /* read an image into a member buffer */
{
int i;
bp->member = armalloc(n);
i = Bread(b, bp->member, n);
if (i < 0) {
free(bp->member);
bp->member = 0;
rderr();
}
}
/*
* insert a member buffer into the member chain
*/
void
arinsert(Arfile *ap, Armember *bp)
{
bp->next = 0;
if (!ap->tail)
ap->head = bp;
else
ap->tail->next = bp;
ap->tail = bp;
}
/*
* stream the members in a temp file to the file referenced by 'fd'.
*/
void
arstream(int fd, Arfile *ap)
{
Armember *bp;
int i;
char buf[8192];
if (ap->paged) { /* copy from disk */
seek(ap->fd, 0, 0);
for (;;) {
i = read(ap->fd, buf, sizeof(buf));
if (i < 0)
rderr();
if (i == 0)
break;
if (write(fd, buf, i) != i)
wrerr();
}
close(ap->fd);
ap->paged = 0;
}
/* dump the in-core buffers */
for (bp = ap->head; bp; bp = bp->next) {
if (!arwrite(fd, bp))
wrerr();
}
}
/*
* write a member to 'fd'.
*/
int
arwrite(int fd, Armember *bp)
{
int len;
if(HEADER_IO(write, fd, bp->hdr))
return 0;
len = bp->size;
if (len & 01)
len++;
if (write(fd, bp->member, len) != len)
return 0;
return 1;
}
/*
* Spill a member to a disk copy of a temp file
*/
int
page(Arfile *ap)
{
Armember *bp;
bp = ap->head;
if (!ap->paged) { /* not yet paged - create file */
ap->fname = mktemp(ap->fname);
ap->fd = create(ap->fname, ORDWR|ORCLOSE, 0600);
if (ap->fd < 0) {
fprint(2,"ar: can't create temp file\n");
return 0;
}
ap->paged = 1;
}
if (!arwrite(ap->fd, bp)) /* write member and free buffer block */
return 0;
ap->head = bp->next;
if (ap->tail == bp)
ap->tail = bp->next;
free(bp->member);
free(bp);
return 1;
}
/*
* try to reclaim space by paging. we try to spill the start, middle,
* and end files, in that order. there is no particular reason for the
* ordering.
*/
int
getspace(void)
{
if (astart && astart->head && page(astart))
return 1;
if (amiddle && amiddle->head && page(amiddle))
return 1;
if (aend && aend->head && page(aend))
return 1;
return 0;
}
void
arfree(Arfile *ap) /* free a member buffer */
{
Armember *bp, *next;
for (bp = ap->head; bp; bp = next) {
next = bp->next;
if (bp->member)
free(bp->member);
free(bp);
}
free(ap);
}
/*
* allocate space for a control block or member buffer. if the malloc
* fails we try to reclaim space by spilling previously allocated
* member buffers.
*/
char *
armalloc(int n)
{
char *cp;
do {
cp = malloc(n);
if (cp) {
memset(cp, 0, n);
return cp;
}
} while (getspace());
fprint(2, "ar: out of memory\n");
exits("malloc");
return 0;
}