[thirdparty/git.git] / sha1_file.c

/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 *
 * This handles basic git sha1 object files - packing, unpacking,
 * creation etc.
 */
#include <stdarg.h>
#include "cache.h"

const char *sha1_file_directory = NULL;

#ifndef O_NOATIME
#if defined(__linux__) && (defined(__i386__) || defined(__PPC__))
#define O_NOATIME 01000000
#else
#define O_NOATIME 0
#endif
#endif

static unsigned int sha1_file_open_flag = O_NOATIME;

static unsigned hexval(char c)
{
	if (c >= '0' && c <= '9')
		return c - '0';
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	return ~0;
}

int get_sha1_hex(const char *hex, unsigned char *sha1)
{
	int i;
	for (i = 0; i < 20; i++) {
		unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]);
		if (val & ~0xff)
			return -1;
		*sha1++ = val;
		hex += 2;
	}
	return 0;
}

int get_sha1_file(const char *path, unsigned char *result)
{
	char buffer[60];
	int fd = open(path, O_RDONLY);
	int len;

	if (fd < 0)
		return -1;
	len = read(fd, buffer, sizeof(buffer));
	close(fd);
	if (len < 40)
		return -1;
	return get_sha1_hex(buffer, result);
}

int get_sha1(const char *str, unsigned char *sha1)
{
	static char pathname[PATH_MAX];
	static const char *prefix[] = {
		"",
		"refs",
		"refs/tags",
		"refs/heads",
		"refs/snap",
		NULL
	};
	const char *gitdir;
	const char **p;

	if (!get_sha1_hex(str, sha1))
		return 0;

	gitdir = ".git";
	for (p = prefix; *p; p++) {
		snprintf(pathname, sizeof(pathname), "%s/%s/%s", gitdir, *p, str);
		if (!get_sha1_file(pathname, sha1))
			return 0;
	}

	return -1;
}

char * sha1_to_hex(const unsigned char *sha1)
{
	static char buffer[50];
	static const char hex[] = "0123456789abcdef";
	char *buf = buffer;
	int i;

	for (i = 0; i < 20; i++) {
		unsigned int val = *sha1++;
		*buf++ = hex[val >> 4];
		*buf++ = hex[val & 0xf];
	}
	return buffer;
}

/*
 * NOTE! This returns a statically allocated buffer, so you have to be
 * careful about using it. Do a "strdup()" if you need to save the
 * filename.
 */
char *sha1_file_name(const unsigned char *sha1)
{
	int i;
	static char *name, *base;

	if (!base) {
		char *sha1_file_directory = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT;
		int len = strlen(sha1_file_directory);
		base = xmalloc(len + 60);
		memcpy(base, sha1_file_directory, len);
		memset(base+len, 0, 60);
		base[len] = '/';
		base[len+3] = '/';
		name = base + len + 1;
	}
	for (i = 0; i < 20; i++) {
		static char hex[] = "0123456789abcdef";
		unsigned int val = sha1[i];
		char *pos = name + i*2 + (i > 0);
		*pos++ = hex[val >> 4];
		*pos = hex[val & 0xf];
	}
	return base;
}

int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size, const char *type)
{
	char header[100];
	unsigned char real_sha1[20];
	SHA_CTX c;

	SHA1_Init(&c);
	SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size));
	SHA1_Update(&c, map, size);
	SHA1_Final(real_sha1, &c);
	return memcmp(sha1, real_sha1, 20) ? -1 : 0;
}

void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
{
	char *filename = sha1_file_name(sha1);
	struct stat st;
	void *map;
	int fd;

	fd = open(filename, O_RDONLY | sha1_file_open_flag);
	if (fd < 0) {
		/* See if it works without O_NOATIME */
		switch (sha1_file_open_flag) {
		default:
			fd = open(filename, O_RDONLY);
			if (fd >= 0)
				break;
		/* Fallthrough */
		case 0:
			perror(filename);
			return NULL;
		}

		/* If it failed once, it will probably fail again. Stop using O_NOATIME */
		sha1_file_open_flag = 0;
	}
	if (fstat(fd, &st) < 0) {
		close(fd);
		return NULL;
	}
	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (-1 == (int)(long)map)
		return NULL;
	*size = st.st_size;
	return map;
}

void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size)
{
	int ret, bytes;
	z_stream stream;
	char buffer[8192];
	char *buf;

	/* Get the data stream */
	memset(&stream, 0, sizeof(stream));
	stream.next_in = map;
	stream.avail_in = mapsize;
	stream.next_out = buffer;
	stream.avail_out = sizeof(buffer);

	inflateInit(&stream);
	ret = inflate(&stream, 0);
	if (ret < Z_OK)
		return NULL;
	if (sscanf(buffer, "%10s %lu", type, size) != 2)
		return NULL;

	bytes = strlen(buffer) + 1;
	buf = xmalloc(*size);

	memcpy(buf, buffer + bytes, stream.total_out - bytes);
	bytes = stream.total_out - bytes;
	if (bytes < *size && ret == Z_OK) {
		stream.next_out = buf + bytes;
		stream.avail_out = *size - bytes;
		while (inflate(&stream, Z_FINISH) == Z_OK)
			/* nothing */;
	}
	inflateEnd(&stream);
	return buf;
}

void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
{
	unsigned long mapsize;
	void *map, *buf;

	map = map_sha1_file(sha1, &mapsize);
	if (map) {
		buf = unpack_sha1_file(map, mapsize, type, size);
		munmap(map, mapsize);
		return buf;
	}
	return NULL;
}

void *read_object_with_reference(const unsigned char *sha1,
				 const unsigned char *required_type,
				 unsigned long *size,
				 unsigned char *actual_sha1_return)
{
	char type[20];
	void *buffer;
	unsigned long isize;
	unsigned char actual_sha1[20];

	memcpy(actual_sha1, sha1, 20);
	while (1) {
		int ref_length = -1;
		const char *ref_type = NULL;

		buffer = read_sha1_file(actual_sha1, type, &isize);
		if (!buffer)
			return NULL;
		if (!strcmp(type, required_type)) {
			*size = isize;
			if (actual_sha1_return)
				memcpy(actual_sha1_return, actual_sha1, 20);
			return buffer;
		}
		/* Handle references */
		else if (!strcmp(type, "commit"))
			ref_type = "tree ";
		else if (!strcmp(type, "tag"))
			ref_type = "object ";
		else {
			free(buffer);
			return NULL;
		}
		ref_length = strlen(ref_type);

		if (memcmp(buffer, ref_type, ref_length) ||
		    get_sha1_hex(buffer + ref_length, actual_sha1)) {
			free(buffer);
			return NULL;
		}
		/* Now we have the ID of the referred-to object in
		 * actual_sha1.  Check again. */
	}
}

int write_sha1_file(char *buf, unsigned long len, const char *type, unsigned char *returnsha1)
{
	int size;
	char *compressed;
	z_stream stream;
	unsigned char sha1[20];
	SHA_CTX c;
	char *filename;
	char hdr[50];
	int fd, hdrlen;

	/* Generate the header */
	hdrlen = sprintf(hdr, "%s %lu", type, len)+1;

	/* Sha1.. */
	SHA1_Init(&c);
	SHA1_Update(&c, hdr, hdrlen);
	SHA1_Update(&c, buf, len);
	SHA1_Final(sha1, &c);

	if (returnsha1)
		memcpy(returnsha1, sha1, 20);

	filename = sha1_file_name(sha1);
	fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
	if (fd < 0) {
		if (errno != EEXIST)
			return -1;

		/*
		 * We might do collision checking here, but we'd need to
		 * uncompress the old file and check it. Later.
		 */
		return 0;
	}

	/* Set it up */
	memset(&stream, 0, sizeof(stream));
	deflateInit(&stream, Z_BEST_COMPRESSION);
	size = deflateBound(&stream, len+hdrlen);
	compressed = xmalloc(size);

	/* Compress it */
	stream.next_out = compressed;
	stream.avail_out = size;

	/* First header.. */
	stream.next_in = hdr;
	stream.avail_in = hdrlen;
	while (deflate(&stream, 0) == Z_OK)
		/* nothing */

	/* Then the data itself.. */
	stream.next_in = buf;
	stream.avail_in = len;
	while (deflate(&stream, Z_FINISH) == Z_OK)
		/* nothing */;
	deflateEnd(&stream);
	size = stream.total_out;

	if (write(fd, compressed, size) != size)
		die("unable to write file");
	close(fd);
		
	return 0;
}

static inline int collision_check(char *filename, void *buf, unsigned int size)
{
#ifdef COLLISION_CHECK
	void *map;
	int fd = open(filename, O_RDONLY);
	struct stat st;
	int cmp;

	/* Unreadable object, or object went away? Strange. */
	if (fd < 0)
		return -1;

	if (fstat(fd, &st) < 0 || size != st.st_size)
		return -1;

	map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (map == MAP_FAILED)
		return -1;
	cmp = memcmp(buf, map, size);
	munmap(map, size);
	if (cmp)
		return -1;
#endif
	return 0;
}

int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size)
{
	char *filename = sha1_file_name(sha1);
	int fd;

	fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
	if (fd < 0) {
		if (errno != EEXIST)
			return -1;
		if (collision_check(filename, buf, size))
			return error("SHA1 collision detected!"
					" This is bad, bad, BAD!\a\n");
		return 0;
	}
	write(fd, buf, size);
	close(fd);
	return 0;
}

int write_sha1_from_fd(const unsigned char *sha1, int fd)
{
	char *filename = sha1_file_name(sha1);

	int local;
	z_stream stream;
	unsigned char real_sha1[20];
	char buf[4096];
	char discard[4096];
	int ret;
	SHA_CTX c;

	local = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);

	if (local < 0)
		return error("Couldn't open %s\n", filename);

	memset(&stream, 0, sizeof(stream));

	inflateInit(&stream);

	SHA1_Init(&c);

	do {
		ssize_t size;
		size = read(fd, buf, 4096);
		if (size <= 0) {
			close(local);
			unlink(filename);
			if (!size)
				return error("Connection closed?");
			perror("Reading from connection");
			return -1;
		}
		write(local, buf, size);
		stream.avail_in = size;
		stream.next_in = buf;
		do {
			stream.next_out = discard;
			stream.avail_out = sizeof(discard);
			ret = inflate(&stream, Z_SYNC_FLUSH);
			SHA1_Update(&c, discard, sizeof(discard) -
				    stream.avail_out);
		} while (stream.avail_in && ret == Z_OK);
		
	} while (ret == Z_OK);
	inflateEnd(&stream);

	close(local);
	SHA1_Final(real_sha1, &c);
	if (ret != Z_STREAM_END) {
		unlink(filename);
		return error("File %s corrupted", sha1_to_hex(sha1));
	}
	if (memcmp(sha1, real_sha1, 20)) {
		unlink(filename);
		return error("File %s has bad hash\n", sha1_to_hex(sha1));
	}
	
	return 0;
}

int has_sha1_file(const unsigned char *sha1)
{
	char *filename = sha1_file_name(sha1);
	struct stat st;

	if (!stat(filename, &st))
		return 1;
	return 0;
}

int index_fd(unsigned char *sha1, int fd, struct stat *st)
{
	z_stream stream;
	unsigned long size = st->st_size;
	int max_out_bytes = size + 200;
	void *out = xmalloc(max_out_bytes);
	void *metadata = xmalloc(200);
	int metadata_size;
	void *in;
	SHA_CTX c;

	in = "";
	if (size)
		in = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (!out || (int)(long)in == -1)
		return -1;

	metadata_size = 1+sprintf(metadata, "blob %lu", size);

	SHA1_Init(&c);
	SHA1_Update(&c, metadata, metadata_size);
	SHA1_Update(&c, in, size);
	SHA1_Final(sha1, &c);

	memset(&stream, 0, sizeof(stream));
	deflateInit(&stream, Z_BEST_COMPRESSION);

	/*
	 * ASCII size + nul byte
	 */	
	stream.next_in = metadata;
	stream.avail_in = metadata_size;
	stream.next_out = out;
	stream.avail_out = max_out_bytes;
	while (deflate(&stream, 0) == Z_OK)
		/* nothing */;

	/*
	 * File content
	 */
	stream.next_in = in;
	stream.avail_in = size;
	while (deflate(&stream, Z_FINISH) == Z_OK)
		/*nothing */;

	deflateEnd(&stream);
	
	return write_sha1_buffer(sha1, out, stream.total_out);
}
Commit	Line	Data
0fcfd160 LT	1	/*
	2	* GIT - The information manager from hell
	3	*
	4	* Copyright (C) Linus Torvalds, 2005
	5	*
	6	* This handles basic git sha1 object files - packing, unpacking,
	7	* creation etc.
	8	*/
	9	#include <stdarg.h>
	10	#include "cache.h"
	11
	12	const char *sha1_file_directory = NULL;
	13
144bde78 LT	14	#ifndef O_NOATIME
	15	#if defined(__linux__) && (defined(__i386__) \|\| defined(__PPC__))
	16	#define O_NOATIME 01000000
	17	#else
	18	#define O_NOATIME 0
	19	#endif
	20	#endif
	21
	22	static unsigned int sha1_file_open_flag = O_NOATIME;
	23
0fcfd160 LT	24	static unsigned hexval(char c)
	25	{
	26	if (c >= '0' && c <= '9')
	27	return c - '0';
	28	if (c >= 'a' && c <= 'f')
	29	return c - 'a' + 10;
	30	if (c >= 'A' && c <= 'F')
	31	return c - 'A' + 10;
	32	return ~0;
	33	}
	34
	35	int get_sha1_hex(const char hex, unsigned char sha1)
	36	{
	37	int i;
	38	for (i = 0; i < 20; i++) {
	39	unsigned int val = (hexval(hex[0]) << 4) \| hexval(hex[1]);
	40	if (val & ~0xff)
	41	return -1;
	42	*sha1++ = val;
	43	hex += 2;
	44	}
	45	return 0;
	46	}
	47
3c249c95 LT	48	int get_sha1_file(const char path, unsigned char result)
	49	{
	50	char buffer[60];
	51	int fd = open(path, O_RDONLY);
	52	int len;
	53
	54	if (fd < 0)
	55	return -1;
	56	len = read(fd, buffer, sizeof(buffer));
	57	close(fd);
	58	if (len < 40)
	59	return -1;
	60	return get_sha1_hex(buffer, result);
	61	}
	62
	63	int get_sha1(const char str, unsigned char sha1)
	64	{
	65	static char pathname[PATH_MAX];
35ad3382 LT	66	static const char *prefix[] = {
	67	"",
	68	"refs",
	69	"refs/tags",
	70	"refs/heads",
	71	"refs/snap",
	72	NULL
	73	};
	74	const char *gitdir;
	75	const char **p;
3c249c95 LT	76
	77	if (!get_sha1_hex(str, sha1))
	78	return 0;
35ad3382	79
35ad3382 LT	80	gitdir = ".git";
	81	for (p = prefix; *p; p++) {
	82	snprintf(pathname, sizeof(pathname), "%s/%s/%s", gitdir, *p, str);
	83	if (!get_sha1_file(pathname, sha1))
	84	return 0;
	85	}
	86
3c249c95 LT	87	return -1;
	88	}
	89
0fcfd160 LT	90	char * sha1_to_hex(const unsigned char *sha1)
	91	{
	92	static char buffer[50];
	93	static const char hex[] = "0123456789abcdef";
	94	char *buf = buffer;
	95	int i;
	96
	97	for (i = 0; i < 20; i++) {
	98	unsigned int val = *sha1++;
	99	*buf++ = hex[val >> 4];
	100	*buf++ = hex[val & 0xf];
	101	}
	102	return buffer;
	103	}
	104
	105	/*
	106	* NOTE! This returns a statically allocated buffer, so you have to be
	107	* careful about using it. Do a "strdup()" if you need to save the
	108	* filename.
	109	*/
	110	char sha1_file_name(const unsigned char sha1)
	111	{
	112	int i;
	113	static char name, base;
	114
	115	if (!base) {
	116	char *sha1_file_directory = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT;
	117	int len = strlen(sha1_file_directory);
812666c8	118	base = xmalloc(len + 60);
0fcfd160 LT	119	memcpy(base, sha1_file_directory, len);
	120	memset(base+len, 0, 60);
	121	base[len] = '/';
	122	base[len+3] = '/';
	123	name = base + len + 1;
	124	}
	125	for (i = 0; i < 20; i++) {
	126	static char hex[] = "0123456789abcdef";
	127	unsigned int val = sha1[i];
	128	char pos = name + i2 + (i > 0);
	129	*pos++ = hex[val >> 4];
	130	*pos = hex[val & 0xf];
	131	}
	132	return base;
	133	}
	134
d98b46f8	135	int check_sha1_signature(unsigned char sha1, void map, unsigned long size, const char *type)
0fcfd160	136	{
d98b46f8	137	char header[100];
0fcfd160 LT	138	unsigned char real_sha1[20];
	139	SHA_CTX c;
	140
	141	SHA1_Init(&c);
d98b46f8	142	SHA1_Update(&c, header, 1+sprintf(header, "%s %lu", type, size));
0fcfd160 LT	143	SHA1_Update(&c, map, size);
	144	SHA1_Final(real_sha1, &c);
	145	return memcmp(sha1, real_sha1, 20) ? -1 : 0;
	146	}
	147
	148	void map_sha1_file(const unsigned char sha1, unsigned long *size)
	149	{
	150	char *filename = sha1_file_name(sha1);
0fcfd160 LT	151	struct stat st;
0fcfd160 LT	152	void *map;
144bde78	153	int fd;
0fcfd160	154
144bde78	155	fd = open(filename, O_RDONLY \| sha1_file_open_flag);
0fcfd160	156	if (fd < 0) {
144bde78 LT	157	/* See if it works without O_NOATIME */
	158	switch (sha1_file_open_flag) {
	159	default:
	160	fd = open(filename, O_RDONLY);
	161	if (fd >= 0)
	162	break;
	163	/* Fallthrough */
	164	case 0:
	165	perror(filename);
	166	return NULL;
	167	}
	168
	169	/* If it failed once, it will probably fail again. Stop using O_NOATIME */
	170	sha1_file_open_flag = 0;
0fcfd160 LT	171	}
	172	if (fstat(fd, &st) < 0) {
	173	close(fd);
	174	return NULL;
	175	}
	176	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	177	close(fd);
	178	if (-1 == (int)(long)map)
	179	return NULL;
	180	*size = st.st_size;
	181	return map;
	182	}
	183
	184	void * unpack_sha1_file(void map, unsigned long mapsize, char type, unsigned long *size)
	185	{
	186	int ret, bytes;
	187	z_stream stream;
	188	char buffer[8192];
	189	char *buf;
	190
	191	/* Get the data stream */
	192	memset(&stream, 0, sizeof(stream));
	193	stream.next_in = map;
	194	stream.avail_in = mapsize;
	195	stream.next_out = buffer;
	196	stream.avail_out = sizeof(buffer);
	197
	198	inflateInit(&stream);
	199	ret = inflate(&stream, 0);
a44c9a5e LT	200	if (ret < Z_OK)
a44c9a5e LT	201	return NULL;
0fcfd160 LT	202	if (sscanf(buffer, "%10s %lu", type, size) != 2)
	203	return NULL;
	204
	205	bytes = strlen(buffer) + 1;
812666c8	206	buf = xmalloc(*size);
0fcfd160 LT	207
	208	memcpy(buf, buffer + bytes, stream.total_out - bytes);
	209	bytes = stream.total_out - bytes;
	210	if (bytes < *size && ret == Z_OK) {
	211	stream.next_out = buf + bytes;
	212	stream.avail_out = *size - bytes;
	213	while (inflate(&stream, Z_FINISH) == Z_OK)
	214	/* nothing */;
	215	}
	216	inflateEnd(&stream);
	217	return buf;
	218	}
	219
	220	void * read_sha1_file(const unsigned char sha1, char type, unsigned long *size)
	221	{
	222	unsigned long mapsize;
	223	void map, buf;
	224
	225	map = map_sha1_file(sha1, &mapsize);
	226	if (map) {
	227	buf = unpack_sha1_file(map, mapsize, type, size);
	228	munmap(map, mapsize);
	229	return buf;
	230	}
	231	return NULL;
	232	}
	233
40469ee9 JH	234	void read_object_with_reference(const unsigned char sha1,
	235	const unsigned char *required_type,
	236	unsigned long *size,
	237	unsigned char *actual_sha1_return)
f4913f91 JH	238	{
	239	char type[20];
	240	void *buffer;
	241	unsigned long isize;
40469ee9	242	unsigned char actual_sha1[20];
f4913f91	243
40469ee9 JH	244	memcpy(actual_sha1, sha1, 20);
	245	while (1) {
	246	int ref_length = -1;
	247	const char *ref_type = NULL;
f4913f91	248
40469ee9 JH	249	buffer = read_sha1_file(actual_sha1, type, &isize);
	250	if (!buffer)
	251	return NULL;
	252	if (!strcmp(type, required_type)) {
	253	*size = isize;
	254	if (actual_sha1_return)
	255	memcpy(actual_sha1_return, actual_sha1, 20);
	256	return buffer;
	257	}
	258	/* Handle references */
	259	else if (!strcmp(type, "commit"))
	260	ref_type = "tree ";
	261	else if (!strcmp(type, "tag"))
	262	ref_type = "object ";
	263	else {
	264	free(buffer);
	265	return NULL;
	266	}
	267	ref_length = strlen(ref_type);
f4913f91	268
40469ee9 JH	269	if (memcmp(buffer, ref_type, ref_length) \|\|
	270	get_sha1_hex(buffer + ref_length, actual_sha1)) {
	271	free(buffer);
	272	return NULL;
	273	}
	274	/* Now we have the ID of the referred-to object in
	275	* actual_sha1. Check again. */
f4913f91	276	}
f4913f91 JH	277	}
f4913f91 JH	278
f5b913c9	279	int write_sha1_file(char buf, unsigned long len, const char type, unsigned char *returnsha1)
0fcfd160 LT	280	{
	281	int size;
	282	char *compressed;
	283	z_stream stream;
	284	unsigned char sha1[20];
	285	SHA_CTX c;
706bc531	286	char *filename;
a44c9a5e LT	287	char hdr[50];
	288	int fd, hdrlen;
	289
	290	/* Generate the header */
f5b913c9	291	hdrlen = sprintf(hdr, "%s %lu", type, len)+1;
0fcfd160	292
d98b46f8 LT	293	/* Sha1.. */
d98b46f8 LT	294	SHA1_Init(&c);
a44c9a5e	295	SHA1_Update(&c, hdr, hdrlen);
d98b46f8 LT	296	SHA1_Update(&c, buf, len);
	297	SHA1_Final(sha1, &c);
	298
706bc531 LT	299	if (returnsha1)
	300	memcpy(returnsha1, sha1, 20);
	301
	302	filename = sha1_file_name(sha1);
	303	fd = open(filename, O_WRONLY \| O_CREAT \| O_EXCL, 0666);
	304	if (fd < 0) {
	305	if (errno != EEXIST)
	306	return -1;
	307
	308	/*
	309	* We might do collision checking here, but we'd need to
	310	* uncompress the old file and check it. Later.
	311	*/
	312	return 0;
	313	}
	314
0fcfd160 LT	315	/* Set it up */
	316	memset(&stream, 0, sizeof(stream));
	317	deflateInit(&stream, Z_BEST_COMPRESSION);
a44c9a5e	318	size = deflateBound(&stream, len+hdrlen);
812666c8	319	compressed = xmalloc(size);
0fcfd160 LT	320
0fcfd160 LT	321	/* Compress it */
0fcfd160 LT	322	stream.next_out = compressed;
0fcfd160 LT	323	stream.avail_out = size;
a44c9a5e LT	324
	325	/* First header.. */
	326	stream.next_in = hdr;
	327	stream.avail_in = hdrlen;
	328	while (deflate(&stream, 0) == Z_OK)
	329	/* nothing */
	330
	331	/* Then the data itself.. */
	332	stream.next_in = buf;
	333	stream.avail_in = len;
0fcfd160 LT	334	while (deflate(&stream, Z_FINISH) == Z_OK)
	335	/* nothing */;
	336	deflateEnd(&stream);
	337	size = stream.total_out;
	338
706bc531 LT	339	if (write(fd, compressed, size) != size)
	340	die("unable to write file");
	341	close(fd);
	342
0fcfd160 LT	343	return 0;
	344	}
	345
	346	static inline int collision_check(char filename, void buf, unsigned int size)
	347	{
	348	#ifdef COLLISION_CHECK
	349	void *map;
	350	int fd = open(filename, O_RDONLY);
	351	struct stat st;
	352	int cmp;
	353
	354	/* Unreadable object, or object went away? Strange. */
	355	if (fd < 0)
	356	return -1;
	357
	358	if (fstat(fd, &st) < 0 \|\| size != st.st_size)
	359	return -1;
	360
	361	map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
	362	close(fd);
	363	if (map == MAP_FAILED)
	364	return -1;
	365	cmp = memcmp(buf, map, size);
	366	munmap(map, size);
	367	if (cmp)
	368	return -1;
	369	#endif
	370	return 0;
	371	}
	372
	373	int write_sha1_buffer(const unsigned char sha1, void buf, unsigned int size)
	374	{
	375	char *filename = sha1_file_name(sha1);
	376	int fd;
	377
	378	fd = open(filename, O_WRONLY \| O_CREAT \| O_EXCL, 0666);
	379	if (fd < 0) {
	380	if (errno != EEXIST)
	381	return -1;
	382	if (collision_check(filename, buf, size))
	383	return error("SHA1 collision detected!"
	384	" This is bad, bad, BAD!\a\n");
	385	return 0;
	386	}
	387	write(fd, buf, size);
	388	close(fd);
	389	return 0;
	390	}
8237b185 DB	391
	392	int write_sha1_from_fd(const unsigned char *sha1, int fd)
	393	{
	394	char *filename = sha1_file_name(sha1);
	395
	396	int local;
	397	z_stream stream;
	398	unsigned char real_sha1[20];
	399	char buf[4096];
	400	char discard[4096];
	401	int ret;
	402	SHA_CTX c;
	403
	404	local = open(filename, O_WRONLY \| O_CREAT \| O_EXCL, 0666);
	405
	406	if (local < 0)
	407	return error("Couldn't open %s\n", filename);
	408
	409	memset(&stream, 0, sizeof(stream));
	410
	411	inflateInit(&stream);
	412
	413	SHA1_Init(&c);
	414
	415	do {
	416	ssize_t size;
	417	size = read(fd, buf, 4096);
	418	if (size <= 0) {
	419	close(local);
	420	unlink(filename);
	421	if (!size)
	422	return error("Connection closed?");
	423	perror("Reading from connection");
	424	return -1;
	425	}
	426	write(local, buf, size);
	427	stream.avail_in = size;
	428	stream.next_in = buf;
	429	do {
	430	stream.next_out = discard;
	431	stream.avail_out = sizeof(discard);
	432	ret = inflate(&stream, Z_SYNC_FLUSH);
	433	SHA1_Update(&c, discard, sizeof(discard) -
	434	stream.avail_out);
	435	} while (stream.avail_in && ret == Z_OK);
	436
	437	} while (ret == Z_OK);
	438	inflateEnd(&stream);
	439
	440	close(local);
	441	SHA1_Final(real_sha1, &c);
	442	if (ret != Z_STREAM_END) {
	443	unlink(filename);
	444	return error("File %s corrupted", sha1_to_hex(sha1));
	445	}
	446	if (memcmp(sha1, real_sha1, 20)) {
	447	unlink(filename);
	448	return error("File %s has bad hash\n", sha1_to_hex(sha1));
	449	}
	450
	451	return 0;
	452	}
	453
	454	int has_sha1_file(const unsigned char *sha1)
455	{
456	char *filename = sha1_file_name(sha1);
457	struct stat st;
458
459	if (!stat(filename, &st))
460	return 1;
461	return 0;
462	}
74400e71 JH	463
	464	int index_fd(unsigned char sha1, int fd, struct stat st)
	465	{
	466	z_stream stream;
	467	unsigned long size = st->st_size;
	468	int max_out_bytes = size + 200;
	469	void *out = xmalloc(max_out_bytes);
	470	void *metadata = xmalloc(200);
	471	int metadata_size;
	472	void *in;
	473	SHA_CTX c;
	474
	475	in = "";
	476	if (size)
	477	in = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
	478	close(fd);
	479	if (!out \|\| (int)(long)in == -1)
	480	return -1;
	481
	482	metadata_size = 1+sprintf(metadata, "blob %lu", size);
	483
	484	SHA1_Init(&c);
	485	SHA1_Update(&c, metadata, metadata_size);
	486	SHA1_Update(&c, in, size);
	487	SHA1_Final(sha1, &c);
	488
	489	memset(&stream, 0, sizeof(stream));
	490	deflateInit(&stream, Z_BEST_COMPRESSION);
	491
	492	/*
	493	* ASCII size + nul byte
	494	*/
	495	stream.next_in = metadata;
	496	stream.avail_in = metadata_size;
	497	stream.next_out = out;
	498	stream.avail_out = max_out_bytes;
	499	while (deflate(&stream, 0) == Z_OK)
	500	/* nothing */;
	501
	502	/*
	503	* File content
	504	*/
	505	stream.next_in = in;
	506	stream.avail_in = size;
	507	while (deflate(&stream, Z_FINISH) == Z_OK)
	508	/nothing /;
	509
	510	deflateEnd(&stream);
	511
	512	return write_sha1_buffer(sha1, out, stream.total_out);
	513	}