[thirdparty/git.git] / unpack-objects.c

#include "cache.h"
#include "object.h"
#include "delta.h"

static int dry_run;
static int nr_entries;
static const char *base_name;
static const char unpack_usage[] = "git-unpack-objects basename";

struct pack_entry {
	unsigned int offset; /* network byte order */
	unsigned char sha1[20];
};

static void *pack_base;
static unsigned long pack_size;
static void *index_base;
static unsigned long index_size;

static struct pack_entry **pack_list;

static void *map_file(const char *suffix, unsigned long *sizep)
{
	static char pathname[PATH_MAX];
	unsigned long len;
	int fd;
	struct stat st;
	void *map;

	len = snprintf(pathname, PATH_MAX, "%s.%s", base_name, suffix);
	if (len >= PATH_MAX)
		die("bad pack base-name");
	fd = open(pathname, O_RDONLY);
	if (fd < 0 || fstat(fd, &st))
		die("unable to open '%s'", pathname);
	len = st.st_size;
	if (!len)
		die("bad pack file '%s'", pathname);
	map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
	if (-1 == (int)(long)map)
		die("unable to mmap '%s'", pathname);
	close(fd);
	*sizep = len;
	return map;
}

static int sort_by_offset(const void *_a, const void *_b)
{
	struct pack_entry *a = *(struct pack_entry **)_a;
	struct pack_entry *b = *(struct pack_entry **)_b;
	unsigned int o1, o2;

	o1 = ntohl(a->offset);
	o2 = ntohl(b->offset);
	return o1 < o2 ? -1 : 1;
}

static int check_index(void)
{
	unsigned int *array = index_base;
	unsigned int nr;
	int i;

	if (index_size < 4*256)
		return error("index file too small");
	nr = 0;
	for (i = 0; i < 256; i++) {
		unsigned int n = ntohl(array[i]);
		if (n < nr)
			return error("non-monotonic index");
		nr = n;
	}
	if (index_size != 4*256 + nr * 24) {
		printf("index_size=%lu, expected %u (%u)\n",
		       index_size, 4*256 + nr * 24, nr);
		return error("wrong index file size");
	}

	nr_entries = nr;
	pack_list = xmalloc(nr * sizeof(struct pack_entry *));
	for (i = 0; i < nr; i++)
		pack_list[i] = index_base + 4*256 + i*24;

	qsort(pack_list, nr, sizeof(*pack_list), sort_by_offset);

	printf("%d entries\n", nr);
	return 0;
}

static int unpack_non_delta_entry(struct pack_entry *entry,
				  unsigned char *pack)
{
	int st, kind;
	unsigned long size;
	z_stream stream;
	char *buffer;
	unsigned char sha1[20];
	char *type_s;
	unsigned long offset = ntohl(entry->offset);

	kind = pack[0];
	size = (pack[1] << 24) + (pack[2] << 16) + (pack[3] << 8) + pack[4];
	printf("%s %c %lu\n", sha1_to_hex(entry->sha1), kind, size);
	pack += 5;

	buffer = xmalloc(size + 1);
	buffer[size] = 0;
	memset(&stream, 0, sizeof(stream));
	stream.next_in = pack;
	stream.avail_in = pack_size - offset; /* sheesh. */
	stream.next_out = buffer;
	stream.avail_out = size;

	inflateInit(&stream);
	st = inflate(&stream, Z_FINISH);
	inflateEnd(&stream);
	if ((st != Z_STREAM_END) || stream.total_out != size)
		goto err_finish;
	switch (kind) {
	case 'C': type_s = "commit"; break;
	case 'T': type_s = "tree"; break;
	case 'B': type_s = "blob"; break;
	default: goto err_finish;
	}
	if (write_sha1_file(buffer, size, type_s, sha1) < 0)
		die("failed to write %s (%s)",
		    sha1_to_hex(entry->sha1), type_s);
	printf("%s %s\n", sha1_to_hex(sha1), type_s);
	if (memcmp(sha1, entry->sha1, 20))
		die("resulting %s have wrong SHA1", type_s);

 finish:
	st = 0;
	free(buffer);
	return st;
 err_finish:
	st = -1;
	goto finish;
}

static int find_pack_entry(unsigned char *sha1, struct pack_entry **ent)
{
	int *level1_ofs = index_base;
	int hi = ntohl(level1_ofs[*sha1]);
	int lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
	void *index = index_base + 4*256;

	do {
		int mi = (lo + hi) / 2;
		int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
		if (!cmp) {
			*ent = index + 24 * mi;
			return 1;
		}
		if (cmp < 0)
			hi = mi;
		else
			lo = mi;
	} while (lo < hi);
	return 0;
}

/* forward declaration for a mutually recursive function */
static void unpack_entry(struct pack_entry *);

static int unpack_delta_entry(struct pack_entry *entry, unsigned char *pack)
{
	void *delta_data, *result, *base;
	unsigned long delta_alloc, delta_size, result_size, base_size;
	z_stream stream;
	int st;
	char type[20];
	unsigned char sha1[20];

	printf("%s D", sha1_to_hex(entry->sha1));
	printf(" %s\n", sha1_to_hex(pack+1));

	/* pack+1 is the base sha1, unless we have it, we need to
	 * unpack it first.
	 */
	if (!has_sha1_file(pack+1)) {
		struct pack_entry *base;
		if (!find_pack_entry(pack+1, &base))
			die("cannot find delta-pack base object");
		unpack_entry(base);
	}

	/* pack+1 thru pack+20 is the base sha1 and
	 * pack+21 thru unknown number is the delta data.
	 * we do not even have size of the delta data uncompressed.
	 * sheesh!
	 */
	delta_alloc = 1024;
	delta_data = xmalloc(delta_alloc);

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

	stream.next_in = pack + 21;
	stream.avail_in = pack_size - ntohl(entry->offset); /* sheesh. */
	stream.next_out = delta_data;
	stream.avail_out = delta_alloc;
	delta_size = 0;

	inflateInit(&stream);
	while (1) {
		st = inflate(&stream, Z_FINISH);
		if (st == Z_STREAM_END) {
			delta_size = stream.total_out;
			break;
		}
		if (st < 0)
			break;

		if (delta_alloc <= stream.total_out) {
			delta_alloc = (delta_alloc +1024) * 3 / 2;
			delta_data = xrealloc(delta_data, delta_alloc);
			stream.next_out = delta_data + stream.total_out;
			stream.avail_out = delta_alloc - stream.total_out;
		}
	}
	inflateEnd(&stream);
	if (st != Z_STREAM_END) {
		free(delta_data);
		return -1;
	}

	base = read_sha1_file(pack+1, type, &base_size);
	if (!base)
		die("failed to read delta-pack base object");
	result = patch_delta(base, base_size,
			     delta_data, delta_size,
			     &result_size);
	if (!result)
		die("failed to apply delta");
	free(delta_data);

	if (write_sha1_file(result, result_size, type, sha1) < 0)
		die("failed to write %s (%s)",
		    sha1_to_hex(entry->sha1), type);
	free(result);
	printf("%s %s\n", sha1_to_hex(sha1), type);
	if (memcmp(sha1, entry->sha1, 20))
		die("resulting %s have wrong SHA1", type);
	return 0;
}

static void unpack_entry(struct pack_entry *entry)
{
	unsigned long offset;
	unsigned char *pack;

	/* Have we done this one already due to deltas based on it? */
	if (lookup_object(entry->sha1))
		return;

	offset = ntohl(entry->offset);
	if (offset > pack_size - 5)
		die("object offset outside of pack file");
	pack = pack_base + offset;
	offset = pack_size - offset;
	switch (*pack) {
	case 'C': case 'T': case 'B':
		unpack_non_delta_entry(entry, pack);
		break;
	case 'D':
		unpack_delta_entry(entry, pack);
		break;
	default:
		die("corrupted pack file");
	}
}

/*
 * We unpack from the end, older files first. Now, usually
 * there are deltas etc, so we'll not actually write the
 * objects in that order, but we might as well try..
 */
static void unpack_all(void)
{
	int i = nr_entries;

	while (--i >= 0) {
		struct pack_entry *entry = pack_list[i];
		unpack_entry(entry);
	}
}

int main(int argc, char **argv)
{
	int i;

	for (i = 1 ; i < argc; i++) {
		const char *arg = argv[i];

		if (*arg == '-') {
			if (!strcmp(arg, "-n")) {
				dry_run = 1;
				continue;
			}
			usage(unpack_usage);
		}
		if (base_name)
			usage(unpack_usage);
		base_name = arg;
	}
	if (!base_name)
		usage(unpack_usage);
	index_base = map_file("idx", &index_size);
	pack_base = map_file("pack", &pack_size);
	if (check_index() < 0)
		die("bad index file");
	unpack_all();
	return 0;
}
Commit	Line	Data
bad50dc8	1	#include "cache.h"
74536958	2	#include "object.h"
8ee378a0	3	#include "delta.h"
bad50dc8	4
74536958	5	static int dry_run;
bad50dc8 LT	6	static int nr_entries;
	7	static const char *base_name;
	8	static const char unpack_usage[] = "git-unpack-objects basename";
	9
	10	struct pack_entry {
8ee378a0	11	unsigned int offset; /* network byte order */
bad50dc8 LT	12	unsigned char sha1[20];
	13	};
	14
74536958 LT	15	static void *pack_base;
74536958 LT	16	static unsigned long pack_size;
8ee378a0 JH	17	static void *index_base;
8ee378a0 JH	18	static unsigned long index_size;
74536958	19
bad50dc8 LT	20	static struct pack_entry **pack_list;
	21
	22	static void map_file(const char suffix, unsigned long *sizep)
	23	{
	24	static char pathname[PATH_MAX];
	25	unsigned long len;
	26	int fd;
	27	struct stat st;
	28	void *map;
	29
	30	len = snprintf(pathname, PATH_MAX, "%s.%s", base_name, suffix);
	31	if (len >= PATH_MAX)
	32	die("bad pack base-name");
	33	fd = open(pathname, O_RDONLY);
	34	if (fd < 0 \|\| fstat(fd, &st))
	35	die("unable to open '%s'", pathname);
	36	len = st.st_size;
	37	if (!len)
	38	die("bad pack file '%s'", pathname);
	39	map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
	40	if (-1 == (int)(long)map)
	41	die("unable to mmap '%s'", pathname);
	42	close(fd);
	43	*sizep = len;
	44	return map;
	45	}
	46
	47	static int sort_by_offset(const void _a, const void _b)
	48	{
	49	struct pack_entry a = (struct pack_entry **)_a;
	50	struct pack_entry b = (struct pack_entry **)_b;
	51	unsigned int o1, o2;
	52
	53	o1 = ntohl(a->offset);
	54	o2 = ntohl(b->offset);
	55	return o1 < o2 ? -1 : 1;
	56	}
	57
8ee378a0	58	static int check_index(void)
bad50dc8	59	{
8ee378a0	60	unsigned int *array = index_base;
bad50dc8 LT	61	unsigned int nr;
	62	int i;
	63
8ee378a0	64	if (index_size < 4*256)
bad50dc8 LT	65	return error("index file too small");
	66	nr = 0;
	67	for (i = 0; i < 256; i++) {
	68	unsigned int n = ntohl(array[i]);
	69	if (n < nr)
	70	return error("non-monotonic index");
	71	nr = n;
	72	}
8ee378a0 JH	73	if (index_size != 4256 + nr 24) {
	74	printf("index_size=%lu, expected %u (%u)\n",
	75	index_size, 4256 + nr 24, nr);
bad50dc8 LT	76	return error("wrong index file size");
	77	}
	78
	79	nr_entries = nr;
	80	pack_list = xmalloc(nr * sizeof(struct pack_entry *));
	81	for (i = 0; i < nr; i++)
8ee378a0	82	pack_list[i] = index_base + 4256 + i24;
bad50dc8 LT	83
	84	qsort(pack_list, nr, sizeof(*pack_list), sort_by_offset);
	85
	86	printf("%d entries\n", nr);
	87	return 0;
	88	}
	89
8ee378a0 JH	90	static int unpack_non_delta_entry(struct pack_entry *entry,
8ee378a0 JH	91	unsigned char *pack)
74536958	92	{
8ee378a0	93	int st, kind;
74536958	94	unsigned long size;
8ee378a0 JH	95	z_stream stream;
	96	char *buffer;
	97	unsigned char sha1[20];
	98	char *type_s;
	99	unsigned long offset = ntohl(entry->offset);
	100
	101	kind = pack[0];
	102	size = (pack[1] << 24) + (pack[2] << 16) + (pack[3] << 8) + pack[4];
	103	printf("%s %c %lu\n", sha1_to_hex(entry->sha1), kind, size);
	104	pack += 5;
	105
	106	buffer = xmalloc(size + 1);
	107	buffer[size] = 0;
	108	memset(&stream, 0, sizeof(stream));
	109	stream.next_in = pack;
	110	stream.avail_in = pack_size - offset; /* sheesh. */
	111	stream.next_out = buffer;
	112	stream.avail_out = size;
	113
	114	inflateInit(&stream);
	115	st = inflate(&stream, Z_FINISH);
	116	inflateEnd(&stream);
	117	if ((st != Z_STREAM_END) \|\| stream.total_out != size)
	118	goto err_finish;
	119	switch (kind) {
	120	case 'C': type_s = "commit"; break;
	121	case 'T': type_s = "tree"; break;
	122	case 'B': type_s = "blob"; break;
	123	default: goto err_finish;
	124	}
	125	if (write_sha1_file(buffer, size, type_s, sha1) < 0)
	126	die("failed to write %s (%s)",
	127	sha1_to_hex(entry->sha1), type_s);
	128	printf("%s %s\n", sha1_to_hex(sha1), type_s);
	129	if (memcmp(sha1, entry->sha1, 20))
	130	die("resulting %s have wrong SHA1", type_s);
	131
	132	finish:
	133	st = 0;
	134	free(buffer);
	135	return st;
	136	err_finish:
	137	st = -1;
	138	goto finish;
	139	}
	140
	141	static int find_pack_entry(unsigned char sha1, struct pack_entry *ent)
	142	{
	143	int *level1_ofs = index_base;
	144	int hi = ntohl(level1_ofs[*sha1]);
	145	int lo = ((sha1 == 0x0) ? 0 : ntohl(level1_ofs[sha1 - 1]));
	146	void index = index_base + 4256;
	147
	148	do {
	149	int mi = (lo + hi) / 2;
	150	int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
	151	if (!cmp) {
	152	ent = index + 24 mi;
	153	return 1;
	154	}
	155	if (cmp < 0)
	156	hi = mi;
	157	else
	158	lo = mi;
159	} while (lo < hi);
160	return 0;
161	}
162
163	/* forward declaration for a mutually recursive function */
164	static void unpack_entry(struct pack_entry *);
165
166	static int unpack_delta_entry(struct pack_entry entry, unsigned char pack)
167	{
168	void delta_data, result, *base;
169	unsigned long delta_alloc, delta_size, result_size, base_size;
170	z_stream stream;
171	int st;
172	char type[20];
173	unsigned char sha1[20];
174
175	printf("%s D", sha1_to_hex(entry->sha1));
176	printf(" %s\n", sha1_to_hex(pack+1));
177
178	/* pack+1 is the base sha1, unless we have it, we need to
179	* unpack it first.
180	*/
181	if (!has_sha1_file(pack+1)) {
182	struct pack_entry *base;
183	if (!find_pack_entry(pack+1, &base))
184	die("cannot find delta-pack base object");
185	unpack_entry(base);
186	}
187
188	/* pack+1 thru pack+20 is the base sha1 and
189	* pack+21 thru unknown number is the delta data.
190	* we do not even have size of the delta data uncompressed.
191	* sheesh!
192	*/
193	delta_alloc = 1024;
194	delta_data = xmalloc(delta_alloc);
195
196	memset(&stream, 0, sizeof(stream));
197
198	stream.next_in = pack + 21;
199	stream.avail_in = pack_size - ntohl(entry->offset); /* sheesh. */
200	stream.next_out = delta_data;
201	stream.avail_out = delta_alloc;
202	delta_size = 0;
203
204	inflateInit(&stream);
205	while (1) {
206	st = inflate(&stream, Z_FINISH);
207	if (st == Z_STREAM_END) {
208	delta_size = stream.total_out;
209	break;
210	}
211	if (st < 0)
212	break;
213
214	if (delta_alloc <= stream.total_out) {
215	delta_alloc = (delta_alloc +1024) * 3 / 2;
216	delta_data = xrealloc(delta_data, delta_alloc);
217	stream.next_out = delta_data + stream.total_out;
218	stream.avail_out = delta_alloc - stream.total_out;
219	}
220	}
221	inflateEnd(&stream);
222	if (st != Z_STREAM_END) {
223	free(delta_data);
224	return -1;
225	}
226
227	base = read_sha1_file(pack+1, type, &base_size);
228	if (!base)
229	die("failed to read delta-pack base object");
230	result = patch_delta(base, base_size,
231	delta_data, delta_size,
232	&result_size);
233	if (!result)
234	die("failed to apply delta");
235	free(delta_data);
236
237	if (write_sha1_file(result, result_size, type, sha1) < 0)
238	die("failed to write %s (%s)",
239	sha1_to_hex(entry->sha1), type);
240	free(result);
241	printf("%s %s\n", sha1_to_hex(sha1), type);
242	if (memcmp(sha1, entry->sha1, 20))
243	die("resulting %s have wrong SHA1", type);
244	return 0;
245	}
246
247	static void unpack_entry(struct pack_entry *entry)
248	{
74536958 LT	249	unsigned long offset;
	250	unsigned char *pack;
	251
	252	/* Have we done this one already due to deltas based on it? */
	253	if (lookup_object(entry->sha1))
	254	return;
	255
	256	offset = ntohl(entry->offset);
	257	if (offset > pack_size - 5)
	258	die("object offset outside of pack file");
	259	pack = pack_base + offset;
	260	offset = pack_size - offset;
	261	switch (*pack) {
	262	case 'C': case 'T': case 'B':
8ee378a0	263	unpack_non_delta_entry(entry, pack);
74536958 LT	264	break;
74536958 LT	265	case 'D':
8ee378a0	266	unpack_delta_entry(entry, pack);
74536958 LT	267	break;
	268	default:
	269	die("corrupted pack file");
	270	}
	271	}
	272
	273	/*
	274	* We unpack from the end, older files first. Now, usually
	275	* there are deltas etc, so we'll not actually write the
	276	* objects in that order, but we might as well try..
	277	*/
	278	static void unpack_all(void)
	279	{
	280	int i = nr_entries;
	281
	282	while (--i >= 0) {
	283	struct pack_entry *entry = pack_list[i];
	284	unpack_entry(entry);
	285	}
	286	}
	287
bad50dc8 LT	288	int main(int argc, char **argv)
	289	{
	290	int i;
bad50dc8 LT	291
	292	for (i = 1 ; i < argc; i++) {
	293	const char *arg = argv[i];
	294
	295	if (*arg == '-') {
74536958 LT	296	if (!strcmp(arg, "-n")) {
	297	dry_run = 1;
	298	continue;
	299	}
bad50dc8 LT	300	usage(unpack_usage);
	301	}
	302	if (base_name)
	303	usage(unpack_usage);
	304	base_name = arg;
	305	}
	306	if (!base_name)
	307	usage(unpack_usage);
8ee378a0	308	index_base = map_file("idx", &index_size);
74536958	309	pack_base = map_file("pack", &pack_size);
8ee378a0	310	if (check_index() < 0)
bad50dc8	311	die("bad index file");
74536958	312	unpack_all();
bad50dc8 LT	313	return 0;
bad50dc8 LT	314	}