indexer.c 20.6 KB
Newer Older
1
/*
schu committed
2
 * Copyright (C) 2009-2012 the libgit2 contributors
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8 9
#include <zlib.h>

Carlos Martín Nieto committed
10
#include "git2/indexer.h"
11
#include "git2/object.h"
12
#include "git2/oid.h"
Carlos Martín Nieto committed
13

14 15
#include "common.h"
#include "pack.h"
Carlos Martín Nieto committed
16
#include "mwindow.h"
17
#include "posix.h"
18 19 20 21 22
#include "pack.h"
#include "filebuf.h"
#include "sha1.h"

#define UINT31_MAX (0x7FFFFFFF)
23

24
struct entry {
25
	git_oid oid;
26 27 28 29 30
	uint32_t crc;
	uint32_t offset;
	uint64_t offset_long;
};

31
struct git_indexer {
32
	struct git_pack_file *pack;
33 34 35 36 37
	size_t nr_objects;
	git_vector objects;
	git_filebuf file;
	unsigned int fanout[256];
	git_oid hash;
38
};
Carlos Martín Nieto committed
39

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
struct git_indexer_stream {
	unsigned int parsed_header :1,
		opened_pack;
	struct git_pack_file *pack;
	git_filebuf pack_file;
	git_filebuf index_file;
	git_off_t off;
	size_t nr_objects;
	git_vector objects;
	git_vector deltas;
	unsigned int fanout[256];
	git_oid hash;
};

struct delta_info {
55
	git_off_t delta_off;
56 57
};

58 59 60 61 62
const git_oid *git_indexer_hash(git_indexer *idx)
{
	return &idx->hash;
}

63 64 65 66 67
const git_oid *git_indexer_stream_hash(git_indexer_stream *idx)
{
	return &idx->hash;
}

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
static int open_pack(struct git_pack_file **out, const char *filename)
{
	size_t namelen;
	struct git_pack_file *pack;
	struct stat st;
	int fd;

	namelen = strlen(filename);
	pack = git__calloc(1, sizeof(struct git_pack_file) + namelen + 1);
	GITERR_CHECK_ALLOC(pack);

	memcpy(pack->pack_name, filename, namelen + 1);

	if (p_stat(filename, &st) < 0) {
		giterr_set(GITERR_OS, "Failed to stat packfile.");
		goto cleanup;
	}

	if ((fd = p_open(pack->pack_name, O_RDONLY)) < 0) {
		giterr_set(GITERR_OS, "Failed to open packfile.");
		goto cleanup;
	}

	pack->mwf.fd = fd;
	pack->mwf.size = (git_off_t)st.st_size;

	*out = pack;
	return 0;

cleanup:
	git__free(pack);
	return -1;
}

static int parse_header(struct git_pack_header *hdr, struct git_pack_file *pack)
103 104 105 106
{
	int error;

	/* Verify we recognize this pack file format. */
107
	if ((error = p_read(pack->mwf.fd, hdr, sizeof(*hdr))) < 0) {
108 109 110
		giterr_set(GITERR_OS, "Failed to read in pack header");
		return error;
	}
111

112
	if (hdr->hdr_signature != ntohl(PACK_SIGNATURE)) {
113
		giterr_set(GITERR_INDEXER, "Wrong pack signature");
114 115
		return -1;
	}
116

117
	if (!pack_version_ok(hdr->hdr_version)) {
118
		giterr_set(GITERR_INDEXER, "Wrong pack version");
119 120
		return -1;
	}
Carlos Martín Nieto committed
121

122
	return 0;
123 124
}

125
static int objects_cmp(const void *a, const void *b)
126 127 128 129 130 131 132
{
	const struct entry *entrya = a;
	const struct entry *entryb = b;

	return git_oid_cmp(&entrya->oid, &entryb->oid);
}

133 134 135 136 137 138 139 140
static int cache_cmp(const void *a, const void *b)
{
	const struct git_pack_entry *ea = a;
	const struct git_pack_entry *eb = b;

	return git_oid_cmp(&ea->sha1, &eb->sha1);
}

141 142 143 144
int git_indexer_stream_new(git_indexer_stream **out, const char *prefix)
{
	git_indexer_stream *idx;
	git_buf path = GIT_BUF_INIT;
145
	static const char suff[] = "/pack";
146
	int error;
147

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
	idx = git__calloc(1, sizeof(git_indexer_stream));
	GITERR_CHECK_ALLOC(idx);

	error = git_buf_joinpath(&path, prefix, suff);
	if (error < 0)
		goto cleanup;

	error = git_filebuf_open(&idx->pack_file, path.ptr,
				 GIT_FILEBUF_TEMPORARY | GIT_FILEBUF_DO_NOT_BUFFER);
	git_buf_free(&path);
	if (error < 0)
		goto cleanup;

	*out = idx;
	return 0;

cleanup:
	git_buf_free(&path);
	git_filebuf_cleanup(&idx->pack_file);
	git__free(idx);
	return -1;
}

/* Try to store the delta so we can try to resolve it later */
172
static int store_delta(git_indexer_stream *idx, git_off_t entry_start, size_t entry_size, git_otype type)
173
{
174 175
	git_mwindow *w = NULL;
	struct delta_info *delta;
176
	git_rawobj obj;
177
	int error;
178

179
	assert(type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA);
180 181 182 183

	if (type == GIT_OBJ_REF_DELTA) {
		idx->off += GIT_OID_RAWSZ;
	} else {
184 185 186
		git_off_t base_off;

		base_off = get_delta_base(idx->pack, &w, &idx->off, type, entry_start);
187
		git_mwindow_close(&w);
188 189
		if (base_off < 0)
			return (int)base_off;
190
	}
191

192
	error = packfile_unpack_compressed(&obj, idx->pack, &w, &idx->off, entry_size, type);
193
	if (error == GIT_EBUFS) {
194
		idx->off = entry_start;
195
		return GIT_EBUFS;
196
	} else if (error < 0){
197
		return -1;
198 199
	}

200 201 202 203 204 205
	delta = git__calloc(1, sizeof(struct delta_info));
	GITERR_CHECK_ALLOC(delta);
	delta->delta_off = entry_start;

	git__free(obj.data);

206
	if (git_vector_insert(&idx->deltas, delta) < 0)
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
		return -1;

	return 0;
}

static int hash_and_save(git_indexer_stream *idx, git_rawobj *obj, git_off_t entry_start)
{
	int i;
	git_oid oid;
	void *packed;
	size_t entry_size;
	unsigned int left;
	struct entry *entry;
	git_mwindow *w = NULL;
	git_mwindow_file *mwf = &idx->pack->mwf;
	struct git_pack_entry *pentry;

	entry = git__calloc(1, sizeof(*entry));
	GITERR_CHECK_ALLOC(entry);

	if (entry_start > UINT31_MAX) {
		entry->offset = UINT32_MAX;
		entry->offset_long = entry_start;
	} else {
		entry->offset = (uint32_t)entry_start;
	}

	/* FIXME: Parse the object instead of hashing it */
	if (git_odb__hashobj(&oid, obj) < 0) {
236
		giterr_set(GITERR_INDEXER, "Failed to hash object");
237 238 239 240 241 242 243 244 245
		return -1;
	}

	pentry = git__malloc(sizeof(struct git_pack_entry));
	GITERR_CHECK_ALLOC(pentry);

	git_oid_cpy(&pentry->sha1, &oid);
	pentry->offset = entry_start;
	if (git_vector_insert(&idx->pack->cache, pentry) < 0)
246 247
		goto on_error;

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
	git_oid_cpy(&entry->oid, &oid);
	entry->crc = crc32(0L, Z_NULL, 0);

	entry_size = (size_t)(idx->off - entry_start);
	packed = git_mwindow_open(mwf, &w, entry_start, entry_size, &left);
	if (packed == NULL)
		goto on_error;

	entry->crc = htonl(crc32(entry->crc, packed, (uInt)entry_size));
	git_mwindow_close(&w);

	/* Add the object to the list */
	if (git_vector_insert(&idx->objects, entry) < 0)
		goto on_error;

	for (i = oid.id[0]; i < 256; ++i) {
		idx->fanout[i]++;
	}

267
	return 0;
268

269
on_error:
270 271 272
	git__free(entry);
	git__free(pentry);
	git__free(obj->data);
273 274
	return -1;
}
275

276
int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_indexer_stats *stats)
277 278 279
{
	int error;
	struct git_pack_header hdr;
280
	size_t processed; 
281
	git_mwindow_file *mwf = &idx->pack->mwf;
282

283 284
	assert(idx && data && stats);

285 286
	processed = stats->processed;

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
	if (git_filebuf_write(&idx->pack_file, data, size) < 0)
		return -1;

	/* Make sure we set the new size of the pack */
	if (idx->opened_pack) {
		idx->pack->mwf.size += size;
		//printf("\nadding %zu for %zu\n", size, idx->pack->mwf.size);
	} else {
		if (open_pack(&idx->pack, idx->pack_file.path_lock) < 0)
			return -1;
		idx->opened_pack = 1;
		mwf = &idx->pack->mwf;
		if (git_mwindow_file_register(&idx->pack->mwf) < 0)
			return -1;
	}

	if (!idx->parsed_header) {
		if ((unsigned)idx->pack->mwf.size < sizeof(hdr))
			return 0;

		if (parse_header(&hdr, idx->pack) < 0)
			return -1;

		idx->parsed_header = 1;
		idx->nr_objects = ntohl(hdr.hdr_entries);
		idx->off = sizeof(struct git_pack_header);

		/* for now, limit to 2^32 objects */
		assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects));

		if (git_vector_init(&idx->pack->cache, (unsigned int)idx->nr_objects, cache_cmp) < 0)
			return -1;

		idx->pack->has_cache = 1;
		if (git_vector_init(&idx->objects, (unsigned int)idx->nr_objects, objects_cmp) < 0)
			return -1;

		if (git_vector_init(&idx->deltas, (unsigned int)(idx->nr_objects / 2), NULL) < 0)
			return -1;

327
		memset(stats, 0, sizeof(git_indexer_stats));
328 329 330 331 332 333 334 335 336 337
		stats->total = (unsigned int)idx->nr_objects;
	}

	/* Now that we have data in the pack, let's try to parse it */

	/* As the file grows any windows we try to use will be out of date */
	git_mwindow_free_all(mwf);
	while (processed < idx->nr_objects) {
		git_rawobj obj;
		git_off_t entry_start = idx->off;
338 339 340
		size_t entry_size;
		git_otype type;
		git_mwindow *w = NULL;
341

342 343 344
		if (idx->pack->mwf.size <= idx->off + 20)
			return 0;

345
		error = git_packfile_unpack_header(&entry_size, &type, mwf, &w, &idx->off);
346
		if (error == GIT_EBUFS) {
347 348 349
			idx->off = entry_start;
			return 0;
		}
350 351
		if (error < 0)
			return -1;
352

353
		git_mwindow_close(&w);
354

355 356 357 358
		if (type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA) {
			error = store_delta(idx, entry_start, entry_size, type);
			if (error == GIT_EBUFS) {
				idx->off = entry_start;
359
				return 0;
360
			}
361 362
			if (error < 0)
				return error;
363

364
			stats->received++;
365 366 367
			continue;
		}

368 369 370 371 372 373 374 375 376
		idx->off = entry_start;
		error = git_packfile_unpack(&obj, idx->pack, &idx->off);
		if (error == GIT_EBUFS) {
			idx->off = entry_start;
			return 0;
		}
		if (error < 0)
			return -1;

377
		if (hash_and_save(idx, &obj, entry_start) < 0)
378 379
			goto on_error;

380
		git__free(obj.data);
381

Russell Belfer committed
382
		stats->processed = (unsigned int)++processed;
383
		stats->received++;
384
	}
385

386
	return 0;
387

388 389 390 391
on_error:
	git_mwindow_free_all(mwf);
	return -1;
}
392

393 394 395 396
static int index_path_stream(git_buf *path, git_indexer_stream *idx, const char *suffix)
{
	const char prefix[] = "pack-";
	size_t slash = (size_t)path->size;
397

398 399 400
	/* search backwards for '/' */
	while (slash > 0 && path->ptr[slash - 1] != '/')
		slash--;
401

402 403 404 405 406 407
	if (git_buf_grow(path, slash + 1 + strlen(prefix) +
					 GIT_OID_HEXSZ + strlen(suffix) + 1) < 0)
		return -1;

	git_buf_truncate(path, slash);
	git_buf_puts(path, prefix);
nulltoken committed
408
	git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash);
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	path->size += GIT_OID_HEXSZ;
	git_buf_puts(path, suffix);

	return git_buf_oom(path) ? -1 : 0;
}

static int resolve_deltas(git_indexer_stream *idx, git_indexer_stats *stats)
{
	unsigned int i;
	struct delta_info *delta;

	git_vector_foreach(&idx->deltas, i, delta) {
		git_rawobj obj;

		idx->off = delta->delta_off;
		if (git_packfile_unpack(&obj, idx->pack, &idx->off) < 0)
			return -1;

		if (hash_and_save(idx, &obj, delta->delta_off) < 0)
			return -1;
429 430

		git__free(obj.data);
431 432
		stats->processed++;
	}
433

434 435 436 437 438 439 440 441 442 443 444 445 446 447
	return 0;
}

int git_indexer_stream_finalize(git_indexer_stream *idx, git_indexer_stats *stats)
{
	git_mwindow *w = NULL;
	unsigned int i, long_offsets = 0, left;
	struct git_pack_idx_header hdr;
	git_buf filename = GIT_BUF_INIT;
	struct entry *entry;
	void *packfile_hash;
	git_oid file_hash;
	SHA_CTX ctx;

448 449 450 451 452 453
	/* Test for this before resolve_deltas(), as it plays with idx->off */
	if (idx->off < idx->pack->mwf.size - GIT_OID_RAWSZ) {
		giterr_set(GITERR_INDEXER, "Indexing error: junk at the end of the pack");
		return -1;
	}

454 455 456 457
	if (idx->deltas.length > 0)
		if (resolve_deltas(idx, stats) < 0)
			return -1;

458 459 460 461 462
	if (stats->processed != stats->total) {
		giterr_set(GITERR_INDEXER, "Indexing error: early EOF");
		return -1;
	}

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	git_vector_sort(&idx->objects);

	git_buf_sets(&filename, idx->pack->pack_name);
	git_buf_truncate(&filename, filename.size - strlen("pack"));
	git_buf_puts(&filename, "idx");
	if (git_buf_oom(&filename))
		return -1;

	if (git_filebuf_open(&idx->index_file, filename.ptr, GIT_FILEBUF_HASH_CONTENTS) < 0)
		goto on_error;

	/* Write out the header */
	hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
	hdr.idx_version = htonl(2);
	git_filebuf_write(&idx->index_file, &hdr, sizeof(hdr));

	/* Write out the fanout table */
	for (i = 0; i < 256; ++i) {
		uint32_t n = htonl(idx->fanout[i]);
		git_filebuf_write(&idx->index_file, &n, sizeof(n));
483 484
	}

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
	/* Write out the object names (SHA-1 hashes) */
	SHA1_Init(&ctx);
	git_vector_foreach(&idx->objects, i, entry) {
		git_filebuf_write(&idx->index_file, &entry->oid, sizeof(git_oid));
		SHA1_Update(&ctx, &entry->oid, GIT_OID_RAWSZ);
	}
	SHA1_Final(idx->hash.id, &ctx);

	/* Write out the CRC32 values */
	git_vector_foreach(&idx->objects, i, entry) {
		git_filebuf_write(&idx->index_file, &entry->crc, sizeof(uint32_t));
	}

	/* Write out the offsets */
	git_vector_foreach(&idx->objects, i, entry) {
		uint32_t n;

		if (entry->offset == UINT32_MAX)
			n = htonl(0x80000000 | long_offsets++);
		else
			n = htonl(entry->offset);

		git_filebuf_write(&idx->index_file, &n, sizeof(uint32_t));
	}

	/* Write out the long offsets */
	git_vector_foreach(&idx->objects, i, entry) {
		uint32_t split[2];

		if (entry->offset != UINT32_MAX)
			continue;

		split[0] = htonl(entry->offset_long >> 32);
		split[1] = htonl(entry->offset_long & 0xffffffff);

		git_filebuf_write(&idx->index_file, &split, sizeof(uint32_t) * 2);
	}

	/* Write out the packfile trailer */
	packfile_hash = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left);
	if (packfile_hash == NULL) {
		git_mwindow_close(&w);
		goto on_error;
	}

	memcpy(&file_hash, packfile_hash, GIT_OID_RAWSZ);
	git_mwindow_close(&w);

	git_filebuf_write(&idx->index_file, &file_hash, sizeof(git_oid));

	/* Write out the packfile trailer to the idx file as well */
	if (git_filebuf_hash(&file_hash, &idx->index_file) < 0)
		goto on_error;

	git_filebuf_write(&idx->index_file, &file_hash, sizeof(git_oid));

	/* Figure out what the final name should be */
	if (index_path_stream(&filename, idx, ".idx") < 0)
		goto on_error;

	/* Commit file */
	if (git_filebuf_commit_at(&idx->index_file, filename.ptr, GIT_PACK_FILE_MODE) < 0)
		goto on_error;

	git_mwindow_free_all(&idx->pack->mwf);
550
	p_close(idx->pack->mwf.fd);
551 552 553 554 555 556 557 558

	if (index_path_stream(&filename, idx, ".pack") < 0)
		goto on_error;
	/* And don't forget to rename the packfile to its new place. */
	if (git_filebuf_commit_at(&idx->pack_file, filename.ptr, GIT_PACK_FILE_MODE) < 0)
		return -1;

	git_buf_free(&filename);
559 560 561
	return 0;

on_error:
562
	git_mwindow_free_all(&idx->pack->mwf);
563
	p_close(idx->pack->mwf.fd);
564 565
	git_filebuf_cleanup(&idx->index_file);
	git_buf_free(&filename);
566 567 568
	return -1;
}

569 570 571 572 573 574 575 576 577 578 579 580 581
void git_indexer_stream_free(git_indexer_stream *idx)
{
	unsigned int i;
	struct entry *e;
	struct git_pack_entry *pe;
	struct delta_info *delta;

	if (idx == NULL)
		return;

	git_vector_foreach(&idx->objects, i, e)
		git__free(e);
	git_vector_free(&idx->objects);
582 583 584 585 586
	if (idx->pack) {
		git_vector_foreach(&idx->pack->cache, i, pe)
			git__free(pe);
		git_vector_free(&idx->pack->cache);
	}
587 588 589 590 591 592 593
	git_vector_foreach(&idx->deltas, i, delta)
		git__free(delta);
	git_vector_free(&idx->deltas);
	git__free(idx->pack);
	git__free(idx);
}

594 595 596 597 598 599 600 601 602
int git_indexer_new(git_indexer **out, const char *packname)
{
	git_indexer *idx;
	struct git_pack_header hdr;
	int error;

	assert(out && packname);

	if (git_path_root(packname) < 0) {
603
		giterr_set(GITERR_INDEXER, "Path is not absolute");
604
		return -1;
605 606
	}

607 608
	idx = git__calloc(1, sizeof(git_indexer));
	GITERR_CHECK_ALLOC(idx);
609

610 611 612
	open_pack(&idx->pack, packname);

	if ((error = parse_header(&hdr, idx->pack)) < 0)
613 614
		goto cleanup;

615
	idx->nr_objects = ntohl(hdr.hdr_entries);
616

617 618 619 620
	/* for now, limit to 2^32 objects */
	assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects));

	error = git_vector_init(&idx->pack->cache, (unsigned int)idx->nr_objects, cache_cmp);
621
	if (error < 0)
622 623 624
		goto cleanup;

	idx->pack->has_cache = 1;
625
	error = git_vector_init(&idx->objects, (unsigned int)idx->nr_objects, objects_cmp);
626
	if (error < 0)
627 628
		goto cleanup;

629 630
	*out = idx;

631
	return 0;
632 633

cleanup:
634
	git_indexer_free(idx);
635

636
	return -1;
637 638
}

639
static int index_path(git_buf *path, git_indexer *idx)
Carlos Martín Nieto committed
640
{
641
	const char prefix[] = "pack-", suffix[] = ".idx";
642
	size_t slash = (size_t)path->size;
643

644 645 646
	/* search backwards for '/' */
	while (slash > 0 && path->ptr[slash - 1] != '/')
		slash--;
647

648
	if (git_buf_grow(path, slash + 1 + strlen(prefix) +
649 650
					 GIT_OID_HEXSZ + strlen(suffix) + 1) < 0)
		return -1;
651

652
	git_buf_truncate(path, slash);
653
	git_buf_puts(path, prefix);
nulltoken committed
654
	git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash);
655 656 657
	path->size += GIT_OID_HEXSZ;
	git_buf_puts(path, suffix);

658
	return git_buf_oom(path) ? -1 : 0;
659 660
}

661
int git_indexer_write(git_indexer *idx)
662 663
{
	git_mwindow *w = NULL;
664
	int error;
665
	unsigned int i, long_offsets = 0, left;
666
	struct git_pack_idx_header hdr;
667
	git_buf filename = GIT_BUF_INIT;
668 669 670 671 672 673 674
	struct entry *entry;
	void *packfile_hash;
	git_oid file_hash;
	SHA_CTX ctx;

	git_vector_sort(&idx->objects);

675 676 677
	git_buf_sets(&filename, idx->pack->pack_name);
	git_buf_truncate(&filename, filename.size - strlen("pack"));
	git_buf_puts(&filename, "idx");
678
	if (git_buf_oom(&filename))
679
		return -1;
680 681

	error = git_filebuf_open(&idx->file, filename.ptr, GIT_FILEBUF_HASH_CONTENTS);
682
	if (error < 0)
683
		goto cleanup;
684 685 686 687 688

	/* Write out the header */
	hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
	hdr.idx_version = htonl(2);
	error = git_filebuf_write(&idx->file, &hdr, sizeof(hdr));
689
	if (error < 0)
690
		goto cleanup;
691 692 693 694 695

	/* Write out the fanout table */
	for (i = 0; i < 256; ++i) {
		uint32_t n = htonl(idx->fanout[i]);
		error = git_filebuf_write(&idx->file, &n, sizeof(n));
696
		if (error < 0)
697 698 699 700 701 702 703 704
			goto cleanup;
	}

	/* Write out the object names (SHA-1 hashes) */
	SHA1_Init(&ctx);
	git_vector_foreach(&idx->objects, i, entry) {
		error = git_filebuf_write(&idx->file, &entry->oid, sizeof(git_oid));
		SHA1_Update(&ctx, &entry->oid, GIT_OID_RAWSZ);
705
		if (error < 0)
706 707 708 709 710 711 712
			goto cleanup;
	}
	SHA1_Final(idx->hash.id, &ctx);

	/* Write out the CRC32 values */
	git_vector_foreach(&idx->objects, i, entry) {
		error = git_filebuf_write(&idx->file, &entry->crc, sizeof(uint32_t));
713
		if (error < 0)
714 715 716 717 718 719 720 721 722 723 724 725 726
			goto cleanup;
	}

	/* Write out the offsets */
	git_vector_foreach(&idx->objects, i, entry) {
		uint32_t n;

		if (entry->offset == UINT32_MAX)
			n = htonl(0x80000000 | long_offsets++);
		else
			n = htonl(entry->offset);

		error = git_filebuf_write(&idx->file, &n, sizeof(uint32_t));
727
		if (error < 0)
728 729 730 731 732 733 734 735 736 737 738 739 740 741
			goto cleanup;
	}

	/* Write out the long offsets */
	git_vector_foreach(&idx->objects, i, entry) {
		uint32_t split[2];

		if (entry->offset != UINT32_MAX)
			continue;

		split[0] = htonl(entry->offset_long >> 32);
		split[1] = htonl(entry->offset_long & 0xffffffff);

		error = git_filebuf_write(&idx->file, &split, sizeof(uint32_t) * 2);
742
		if (error < 0)
743 744 745 746 747
			goto cleanup;
	}

	/* Write out the packfile trailer */

748
	packfile_hash = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left);
749
	git_mwindow_close(&w);
750
	if (packfile_hash == NULL) {
751
		error = -1;
752 753 754 755 756 757 758 759
		goto cleanup;
	}

	memcpy(&file_hash, packfile_hash, GIT_OID_RAWSZ);

	git_mwindow_close(&w);

	error = git_filebuf_write(&idx->file, &file_hash, sizeof(git_oid));
760 761
	if (error < 0)
		goto cleanup;
762 763 764

	/* Write out the index sha */
	error = git_filebuf_hash(&file_hash, &idx->file);
765
	if (error < 0)
766 767 768
		goto cleanup;

	error = git_filebuf_write(&idx->file, &file_hash, sizeof(git_oid));
769
	if (error < 0)
770 771 772
		goto cleanup;

	/* Figure out what the final name should be */
773
	error = index_path(&filename, idx);
774
	if (error < 0)
775 776
		goto cleanup;

777
	/* Commit file */
778
	error = git_filebuf_commit_at(&idx->file, filename.ptr, GIT_PACK_FILE_MODE);
779 780

cleanup:
781
	git_mwindow_free_all(&idx->pack->mwf);
782
	git_mwindow_file_deregister(&idx->pack->mwf);
783
	if (error < 0)
784
		git_filebuf_cleanup(&idx->file);
785
	git_buf_free(&filename);
786 787 788 789 790 791 792

	return error;
}

int git_indexer_run(git_indexer *idx, git_indexer_stats *stats)
{
	git_mwindow_file *mwf;
793
	git_off_t off = sizeof(struct git_pack_header);
Carlos Martín Nieto committed
794
	int error;
795 796
	struct entry *entry;
	unsigned int left, processed;
Carlos Martín Nieto committed
797

798
	assert(idx && stats);
799

800
	mwf = &idx->pack->mwf;
Carlos Martín Nieto committed
801
	error = git_mwindow_file_register(mwf);
802 803
	if (error < 0)
		return error;
Carlos Martín Nieto committed
804

805
	stats->total = (unsigned int)idx->nr_objects;
806
	stats->processed = processed = 0;
Carlos Martín Nieto committed
807

808
	while (processed < idx->nr_objects) {
809 810
		git_rawobj obj;
		git_oid oid;
811
		struct git_pack_entry *pentry;
812
		git_mwindow *w = NULL;
813
		int i;
814
		git_off_t entry_start = off;
815 816
		void *packed;
		size_t entry_size;
817
		char fmt[GIT_OID_HEXSZ] = {0};
818

819 820
		entry = git__calloc(1, sizeof(*entry));
		GITERR_CHECK_ALLOC(entry);
821 822

		if (off > UINT31_MAX) {
823 824
			entry->offset = UINT32_MAX;
			entry->offset_long = off;
825
		} else {
826
			entry->offset = (uint32_t)off;
827 828 829
		}

		error = git_packfile_unpack(&obj, idx->pack, &off);
830
		if (error < 0)
831 832
			goto cleanup;

833
		/* FIXME: Parse the object instead of hashing it */
834
		error = git_odb__hashobj(&oid, &obj);
835
		if (error < 0) {
836
			giterr_set(GITERR_INDEXER, "Failed to hash object");
837 838 839
			goto cleanup;
		}

840 841
		pentry = git__malloc(sizeof(struct git_pack_entry));
		if (pentry == NULL) {
842
			error = -1;
843 844
			goto cleanup;
		}
845

846 847
		git_oid_cpy(&pentry->sha1, &oid);
		pentry->offset = entry_start;
848
		git_oid_fmt(fmt, &oid);
849
		error = git_vector_insert(&idx->pack->cache, pentry);
850
		if (error < 0)
851 852
			goto cleanup;

853 854 855
		git_oid_cpy(&entry->oid, &oid);
		entry->crc = crc32(0L, Z_NULL, 0);

856
		entry_size = (size_t)(off - entry_start);
857 858
		packed = git_mwindow_open(mwf, &w, entry_start, entry_size, &left);
		if (packed == NULL) {
859
			error = -1;
860 861
			goto cleanup;
		}
862
		entry->crc = htonl(crc32(entry->crc, packed, (uInt)entry_size));
863
		git_mwindow_close(&w);
864

865
		/* Add the object to the list */
866
		error = git_vector_insert(&idx->objects, entry);
867
		if (error < 0)
868
			goto cleanup;
869 870

		for (i = oid.id[0]; i < 256; ++i) {
871
			idx->fanout[i]++;
872 873
		}

874
		git__free(obj.data);
875

876
		stats->processed = ++processed;
877 878 879 880 881
	}

cleanup:
	git_mwindow_free_all(mwf);

Carlos Martín Nieto committed
882
	return error;
883

Carlos Martín Nieto committed
884 885
}

886
void git_indexer_free(git_indexer *idx)
887
{
888 889
	unsigned int i;
	struct entry *e;
890
	struct git_pack_entry *pe;
891

892 893 894
	if (idx == NULL)
		return;

895
	p_close(idx->pack->mwf.fd);
896
	git_mwindow_file_deregister(&idx->pack->mwf);
897
	git_vector_foreach(&idx->objects, i, e)
898
		git__free(e);
899
	git_vector_free(&idx->objects);
900
	git_vector_foreach(&idx->pack->cache, i, pe)
901
		git__free(pe);
902
	git_vector_free(&idx->pack->cache);
903 904
	git__free(idx->pack);
	git__free(idx);
905
}
906