#include <u.h>#include <libc.h>#include <ctype.h> #include "git.h" typedef struct Buf	Buf;typedef struct Metavec	Metavec;typedef struct Meta	Meta;typedef struct Compout	Compout;typedef struct Packf	Packf; #define max(x, y) ((x) > (y) ? (x) : (y)) struct Metavec {	Meta	**meta;	int	nmeta;	int	metasz;}; struct Meta {	Object	*obj;	vlong	path;	vlong	mtime; 	/* The best delta we picked */	Meta	*head;	Meta	*prev;	Delta	*delta;	int	ndelta;	int	nchain; 	/* Only used for delta window */	Dtab 	dtab; 	/* Only used for writing offset deltas */	vlong	off;}; struct Compout {	Biobuf *bfd;	DigestState *st;}; struct Buf {	int len;	int sz;	int off;	char *data;}; struct Packf {	char	path[128];	char	*idx;	vlong	nidx; 	int	refs;	Biobuf	*pack;	vlong	opentm;}; static int	readpacked(Biobuf *, Object *, int);static Object	*readidxobject(Biobuf *, Hash, int); Objset objcache;Object *lruhead;Object *lrutail;vlong	ncache;vlong	cachemax = 128*MiB;Packf	*packf;int	npackf;int	openpacks; static voidclear(Object *o){	if(!o)		return; 	assert(o->refs == 0);	assert((o->flag & Ccache) == 0);	assert(o->flag & Cloaded);	switch(o->type){	case GCommit:		if(!o->commit)			break;		free(o->commit->parent);		free(o->commit->author);		free(o->commit->committer);		free(o->commit);		o->commit = nil;		break;	case GTree:		if(!o->tree)			break;		free(o->tree->ent);		free(o->tree);		o->tree = nil;		break;	default:		break;	} 	free(o->all);	o->all = nil;	o->data = nil;	o->flag &= ~(Cloaded|Cparsed);} voidunref(Object *o){	if(!o)		return;	o->refs--;	if(o->refs == 0)		clear(o);} Object*ref(Object *o){	o->refs++;	return o;} voidcache(Object *o){	Object *p; 	if(o == lruhead)		return;	if(o == lrutail)		lrutail = lrutail->prev;	if(!(o->flag & Cexist)){		osadd(&objcache, o);		o->id = objcache.nobj;		o->flag |= Cexist;	}	if(o->prev != nil)		o->prev->next = o->next;	if(o->next != nil)		o->next->prev = o->prev;	if(lrutail == o){		lrutail = o->prev;		if(lrutail != nil)			lrutail->next = nil;	}else if(lrutail == nil)		lrutail = o;	if(lruhead)		lruhead->prev = o;	o->next = lruhead;	o->prev = nil;	lruhead = o; 	if(!(o->flag & Ccache)){		o->flag |= Ccache;		ref(o);		ncache += o->size;	}	while(ncache > cachemax && lrutail != lruhead){		p = lrutail;		lrutail = p->prev;		if(lrutail != nil)			lrutail->next = nil;		p->flag &= ~Ccache;		p->prev = nil;		p->next = nil;		ncache -= p->size;		unref(p);	}		} static intloadpack(Packf *pf, char *name){	char buf[128];	int i, ifd;	Dir *d; 	memset(pf, 0, sizeof(Packf));	snprint(buf, sizeof(buf), ".git/objects/pack/%s.idx", name);	snprint(pf->path, sizeof(pf->path), ".git/objects/pack/%s.pack", name);	/*	 * if we already have the pack open, just	 * steal the loaded info	 */	for(i = 0; i < npackf; i++){		if(strcmp(pf->path, packf[i].path) == 0){			pf->pack = packf[i].pack;			pf->idx = packf[i].idx;			pf->nidx = packf[i].nidx;			packf[i].idx = nil;			packf[i].pack = nil;			return 0;		}	}	if((ifd = open(buf, OREAD)) == -1)		return -1;	if((d = dirfstat(ifd)) == nil){		close(ifd);		return -1;	}	pf->nidx = d->length;	pf->idx = emalloc(pf->nidx);	if(readn(ifd, pf->idx, pf->nidx) != pf->nidx){		close(ifd);		free(pf->idx);		free(d);		return -1;	}	close(ifd);	free(d);	return 0;} static voidrefreshpacks(void){	Packf *pf, *new;	int i, n, l, nnew;	Dir *d; 	if((n = slurpdir(".git/objects/pack", &d)) == -1)		return;	nnew = 0;	new = eamalloc(n, sizeof(Packf));	for(i = 0; i < n; i++){		l = strlen(d[i].name);		if(l > 4 && strcmp(d[i].name + l - 4, ".idx") != 0)			continue;		d[i].name[l - 4] = 0;		if(loadpack(&new[nnew], d[i].name) != -1)			nnew++;	}	for(i = 0; i < npackf; i++){		pf = &packf[i];		free(pf->idx);		if(pf->pack != nil)			Bterm(pf->pack);	}	free(packf);	packf = new;	npackf = nnew;	free(d);} static Biobuf*openpack(Packf *pf){	vlong t;	int i, best; 	if(pf->pack != nil){		pf->refs++;		return pf->pack;	}	/*	 * If we've got more packs open	 * than we want cached, try to	 * free up the oldest ones.	 *	 * If we can't find a slot, this	 * isn't fatal; we can just use	 * another fd.	 */	while(openpacks >= Npackcache){		t = (1ull<<62)-1;		best = -1;		for(i = 0; i < npackf; i++){			if(&packf[i] != pf			&& packf[i].pack != nil			&& packf[i].opentm < t			&& packf[i].refs == 0){				t = packf[i].opentm;				best = i;			}		}		if(best == -1){			fprint(2, "no available pack slots\n");			break;		}		Bterm(packf[best].pack);		packf[best].pack = nil;		openpacks--;	}	openpacks++;	pf->opentm = nsec();	pf->refs++;	if((pf->pack = Bopen(pf->path, OREAD)) == nil)		return nil;	return pf->pack;} static voidclosepack(Packf *pf){	pf->refs--;} static u32intcrc32(u32int crc, char *b, int nb){	static u32int crctab[256] = {		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 		0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 		0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 		0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 		0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 		0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 		0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 		0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 		0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 		0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 		0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 		0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 		0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 		0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 		0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 		0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 		0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 		0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 		0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 		0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 		0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 		0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 		0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 		0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 		0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 		0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 		0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 		0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 		0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 		0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 		0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 		0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 		0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 		0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 		0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 		0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 		0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d	};	int i; 	crc ^=  0xFFFFFFFF;	for(i = 0; i < nb; i++)		crc = (crc >> 8) ^ crctab[(crc ^ b[i]) & 0xFF];	return crc ^ 0xFFFFFFFF;} intbappend(void *p, void *src, int len){	Buf *b = p;	char *n; 	while(b->len + len >= b->sz){		b->sz = b->sz*2 + 64;		n = realloc(b->data, b->sz);		if(n == nil)			return -1;		b->data = n;	}	memmove(b->data + b->len, src, len);	b->len += len;	return len;} intbreadc(void *p){	return Bgetc(p);} intbdecompress(Buf *d, Biobuf *b, vlong *csz){	vlong o; 	o = Boffset(b);	if(inflatezlib(d, bappend, b, breadc) == -1 || d->data == nil){		free(d->data);		return -1;	}	if (csz)		*csz = Boffset(b) - o;	return d->len;} intdecompress(void **p, Biobuf *b, vlong *csz){	Buf d = {.len=0, .data=nil, .sz=0}; 	if(bdecompress(&d, b, csz) == -1){		free(d.data);		return -1;	}	*p = d.data;	return d.len;} static vlongreadvint(char *p, char *ep, char **pp){	int s, c;	vlong n;		s = 0;	n = 0;	do {		if(p == ep)			return -1;		c = *p++;		n |= (vlong)(c & 0x7f) << s;		s += 7;	} while (c & 0x80 && s < 63);	*pp = p;	return n;} static intapplydelta(Object *dst, Object *base, char *d, int nd){	char *r, *b, *ed, *er;	vlong o, l,  n, nr, c; 	ed = d + nd;	b = base->data;	n = readvint(d, ed, &d);	if(n == -1 || n >= 1LL << 31 || n != base->size){		werrstr("mismatched source size");		return -1;	} 	nr = readvint(d, ed, &d);	if(nr == -1 || nr >= 1LL << 31){		werrstr("invalid pack: %r");		return -1;	}	r = emalloc(nr + 64);	n = snprint(r, 64, "%T %lld", base->type, nr) + 1;	dst->all = r;	dst->type = base->type;	dst->data = r + n;	dst->size = nr;	er = dst->data + nr;	r = dst->data; 	while(d != ed){		c = *d++;		/* copy from base */		if(c & 0x80){			o = 0;			l = 0;			/* Offset in base */			if(d != ed && (c & 0x01)) o |= *(uchar*)d++ <<  0;			if(d != ed && (c & 0x02)) o |= *(uchar*)d++ <<  8;			if(d != ed && (c & 0x04)) o |= *(uchar*)d++ << 16;			if(d != ed && (c & 0x08)) o |= *(uchar*)d++ << 24; 			/* Length to copy */			if(d != ed && (c & 0x10)) l |= *(uchar*)d++ <<  0;			if(d != ed && (c & 0x20)) l |= *(uchar*)d++ <<  8;			if(d != ed && (c & 0x40)) l |= *(uchar*)d++ << 16;			if(l == 0) l = 0x10000; 			if(o < 0 || l < 0 || l > er - r || o + l > base->size){				werrstr("garbled delta: out of bounds copy");				return -1;			}			memmove(r, b + o, l);			r += l;		/* inline data */		}else{			if(c > ed - d || c > er - r){				werrstr("garbled delta: write past object");				return -1;			}			memmove(r, d, c);			d += c;			r += c;		}	}	if(r != er){		werrstr("truncated delta");		return -1;	} 	return nr;} static intreadrdelta(Biobuf *f, Object *o, int nd, int flag){	Object *b;	Hash h;	char *d;	int n;

Lines 1–500 of 1841. Load more