indexer.c 18.3 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
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"
Carlos Martín Nieto committed
12

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

#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 32
struct git_indexer_stream {
	unsigned int parsed_header :1,
33
		opened_pack :1,
34 35
		have_stream :1,
		have_delta :1;
36 37 38
	struct git_pack_file *pack;
	git_filebuf pack_file;
	git_off_t off;
39 40
	git_off_t entry_start;
	git_packfile_stream stream;
41 42 43 44
	size_t nr_objects;
	git_vector objects;
	git_vector deltas;
	unsigned int fanout[256];
45
	git_hash_ctx hash_ctx;
46
	git_oid hash;
47
	git_transfer_progress_callback progress_cb;
48
	void *progress_payload;
49
	char objbuf[8*1024];
50 51 52

	/* Fields for calculating the packfile trailer (hash of everything before it) */
	char inbuf[GIT_OID_RAWSZ];
53
	size_t inbuf_len;
54
	git_hash_ctx trailer;
55 56 57
};

struct delta_info {
58
	git_off_t delta_off;
59 60
};

Ben Straub committed
61
const git_oid *git_indexer_stream_hash(const git_indexer_stream *idx)
62 63 64 65
{
	return &idx->hash;
}

66 67 68 69
static int open_pack(struct git_pack_file **out, const char *filename)
{
	struct git_pack_file *pack;

70
	if (git_packfile_alloc(&pack, filename) < 0)
71
		return -1;
72

73
	if ((pack->mwf.fd = p_open(pack->pack_name, O_RDONLY)) < 0) {
74
		giterr_set(GITERR_OS, "Failed to open packfile.");
75 76
		git_packfile_free(pack);
		return -1;
77 78 79 80 81 82 83
	}

	*out = pack;
	return 0;
}

static int parse_header(struct git_pack_header *hdr, struct git_pack_file *pack)
84 85 86 87
{
	int error;

	/* Verify we recognize this pack file format. */
88
	if ((error = p_read(pack->mwf.fd, hdr, sizeof(*hdr))) < 0) {
89 90 91
		giterr_set(GITERR_OS, "Failed to read in pack header");
		return error;
	}
92

93
	if (hdr->hdr_signature != ntohl(PACK_SIGNATURE)) {
94
		giterr_set(GITERR_INDEXER, "Wrong pack signature");
95 96
		return -1;
	}
97

98
	if (!pack_version_ok(hdr->hdr_version)) {
99
		giterr_set(GITERR_INDEXER, "Wrong pack version");
100 101
		return -1;
	}
Carlos Martín Nieto committed
102

103
	return 0;
104 105
}

106
static int objects_cmp(const void *a, const void *b)
107 108 109 110
{
	const struct entry *entrya = a;
	const struct entry *entryb = b;

111
	return git_oid__cmp(&entrya->oid, &entryb->oid);
112 113
}

114 115 116
int git_indexer_stream_new(
		git_indexer_stream **out,
		const char *prefix,
117
		git_transfer_progress_callback progress_cb,
118
		void *progress_payload)
119 120 121
{
	git_indexer_stream *idx;
	git_buf path = GIT_BUF_INIT;
122
	static const char suff[] = "/pack";
123
	int error;
124

125 126
	idx = git__calloc(1, sizeof(git_indexer_stream));
	GITERR_CHECK_ALLOC(idx);
127 128
	idx->progress_cb = progress_cb;
	idx->progress_payload = progress_payload;
129
	git_hash_ctx_init(&idx->trailer);
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151

	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 */
152
static int store_delta(git_indexer_stream *idx)
153
{
154 155
	struct delta_info *delta;

156 157
	delta = git__calloc(1, sizeof(struct delta_info));
	GITERR_CHECK_ALLOC(delta);
158
	delta->delta_off = idx->entry_start;
159

160
	if (git_vector_insert(&idx->deltas, delta) < 0)
161 162 163 164 165
		return -1;

	return 0;
}

166 167 168 169 170
static void hash_header(git_hash_ctx *ctx, git_off_t len, git_otype type)
{
	char buffer[64];
	size_t hdrlen;

171
	hdrlen = git_odb__format_object_header(buffer, sizeof(buffer), (size_t)len, type);
172 173 174
	git_hash_update(ctx, buffer, hdrlen);
}

175
static int hash_object_stream(git_indexer_stream *idx, git_packfile_stream *stream)
176 177 178
{
	ssize_t read;

179
	assert(idx && stream);
180 181

	do {
182
		if ((read = git_packfile_stream_read(stream, idx->objbuf, sizeof(idx->objbuf))) < 0)
183 184
			break;

185
		git_hash_update(&idx->hash_ctx, idx->objbuf, read);
186 187 188 189 190 191 192 193
	} while (read > 0);

	if (read < 0)
		return (int)read;

	return 0;
}

194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
/* In order to create the packfile stream, we need to skip over the delta base description */
static int advance_delta_offset(git_indexer_stream *idx, git_otype type)
{
	git_mwindow *w = NULL;

	assert(type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA);

	if (type == GIT_OBJ_REF_DELTA) {
		idx->off += GIT_OID_RAWSZ;
	} else {
		git_off_t base_off = get_delta_base(idx->pack, &w, &idx->off, type, idx->entry_start);
		git_mwindow_close(&w);
		if (base_off < 0)
			return (int)base_off;
	}

	return 0;
}

/* Read from the stream and discard any output */
214
static int read_object_stream(git_indexer_stream *idx, git_packfile_stream *stream)
215 216 217 218 219 220
{
	ssize_t read;

	assert(stream);

	do {
221
		read = git_packfile_stream_read(stream, idx->objbuf, sizeof(idx->objbuf));
222 223 224 225 226 227 228 229
	} while (read > 0);

	if (read < 0)
		return (int)read;

	return 0;
}

230 231 232 233 234 235 236 237 238
static int crc_object(uint32_t *crc_out, git_mwindow_file *mwf, git_off_t start, git_off_t size)
{
	void *ptr;
	uint32_t crc;
	unsigned int left, len;
	git_mwindow *w = NULL;

	crc = crc32(0L, Z_NULL, 0);
	while (size) {
239
		ptr = git_mwindow_open(mwf, &w, start, (size_t)size, &left);
240 241 242
		if (ptr == NULL)
			return -1;

243
		len = min(left, (unsigned int)size);
244 245 246 247 248 249 250 251 252 253
		crc = crc32(crc, ptr, len);
		size -= len;
		start += len;
		git_mwindow_close(&w);
	}

	*crc_out = htonl(crc);
	return 0;
}

254
static int store_object(git_indexer_stream *idx)
255
{
256 257
	int i, error;
	khiter_t k;
258 259 260 261
	git_oid oid;
	struct entry *entry;
	git_off_t entry_size;
	struct git_pack_entry *pentry;
262 263
	git_hash_ctx *ctx = &idx->hash_ctx;
	git_off_t entry_start = idx->entry_start;
264 265 266 267

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

Linquize committed
268
	pentry = git__calloc(1, sizeof(struct git_pack_entry));
269 270 271 272 273 274 275 276 277 278 279 280 281
	GITERR_CHECK_ALLOC(pentry);

	git_hash_final(&oid, ctx);
	entry_size = idx->off - entry_start;
	if (entry_start > UINT31_MAX) {
		entry->offset = UINT32_MAX;
		entry->offset_long = entry_start;
	} else {
		entry->offset = (uint32_t)entry_start;
	}

	git_oid_cpy(&pentry->sha1, &oid);
	pentry->offset = entry_start;
282 283 284

	k = kh_put(oid, idx->pack->idx_cache, &pentry->sha1, &error);
	if (!error) {
285
		git__free(pentry);
286
		goto on_error;
287
	}
288

289 290
	kh_value(idx->pack->idx_cache, k) = pentry;

291 292
	git_oid_cpy(&entry->oid, &oid);

293
	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
		goto on_error;

	/* 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]++;
	}

	return 0;

on_error:
	git__free(entry);

	return -1;
}

312 313
static int hash_and_save(git_indexer_stream *idx, git_rawobj *obj, git_off_t entry_start)
{
314 315
	int i, error;
	khiter_t k;
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
	git_oid oid;
	size_t entry_size;
	struct entry *entry;
	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;
	}

	if (git_odb__hashobj(&oid, obj) < 0) {
332
		giterr_set(GITERR_INDEXER, "Failed to hash object");
333
		goto on_error;
334 335
	}

Linquize committed
336
	pentry = git__calloc(1, sizeof(struct git_pack_entry));
337 338 339 340
	GITERR_CHECK_ALLOC(pentry);

	git_oid_cpy(&pentry->sha1, &oid);
	pentry->offset = entry_start;
341 342
	k = kh_put(oid, idx->pack->idx_cache, &pentry->sha1, &error);
	if (!error) {
343
		git__free(pentry);
344
		goto on_error;
345
	}
346

347 348
	kh_value(idx->pack->idx_cache, k) = pentry;

349 350 351 352
	git_oid_cpy(&entry->oid, &oid);
	entry->crc = crc32(0L, Z_NULL, 0);

	entry_size = (size_t)(idx->off - entry_start);
353
	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
354 355 356 357 358 359 360 361 362 363
		goto on_error;

	/* 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]++;
	}

364
	return 0;
365

366
on_error:
367 368
	git__free(entry);
	git__free(obj->data);
369 370
	return -1;
}
371

372
static int do_progress_callback(git_indexer_stream *idx, git_transfer_progress *stats)
373
{
374 375
	if (!idx->progress_cb) return 0;
	return idx->progress_cb(stats, idx->progress_payload);
376 377
}

378
/* Hash everything but the last 20B of input */
379
static void hash_partially(git_indexer_stream *idx, const uint8_t *data, size_t size)
380
{
381
	size_t to_expell, to_keep;
382 383 384 385 386

	if (size == 0)
		return;

	/* Easy case, dump the buffer and the data minus the last 20 bytes */
387
	if (size >= GIT_OID_RAWSZ) {
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
		git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len);
		git_hash_update(&idx->trailer, data, size - GIT_OID_RAWSZ);

		data += size - GIT_OID_RAWSZ;
		memcpy(idx->inbuf, data, GIT_OID_RAWSZ);
		idx->inbuf_len = GIT_OID_RAWSZ;
		return;
	}

	/* We can just append */
	if (idx->inbuf_len + size <= GIT_OID_RAWSZ) {
		memcpy(idx->inbuf + idx->inbuf_len, data, size);
		idx->inbuf_len += size;
		return;
	}

	/* We need to partially drain the buffer and then append */
405 406
	to_keep   = GIT_OID_RAWSZ - size;
	to_expell = idx->inbuf_len - to_keep;
407 408 409 410 411 412 413 414

	git_hash_update(&idx->trailer, idx->inbuf, to_expell);

	memmove(idx->inbuf, idx->inbuf + to_expell, to_keep);
	memcpy(idx->inbuf + to_keep, data, size);
	idx->inbuf_len += size - to_expell;
}

415
int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t size, git_transfer_progress *stats)
416
{
417
	int error = -1;
418
	struct git_pack_header hdr;
419
	size_t processed;
420
	git_mwindow_file *mwf = &idx->pack->mwf;
421

422 423
	assert(idx && data && stats);

424
	processed = stats->indexed_objects;
425

426 427 428
	if (git_filebuf_write(&idx->pack_file, data, size) < 0)
		return -1;

nulltoken committed
429
	hash_partially(idx, data, (int)size);
430

431 432 433 434 435 436 437 438 439 440 441 442 443
	/* Make sure we set the new size of the pack */
	if (idx->opened_pack) {
		idx->pack->mwf.size += 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) {
444 445
		unsigned int total_objects;

446 447 448 449 450 451 452 453 454 455 456 457
		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));
458 459 460 461
		if (idx->nr_objects == (size_t)((unsigned int)idx->nr_objects))
			total_objects = (unsigned int)idx->nr_objects;
		else
			total_objects = UINT_MAX;
462

463 464
		idx->pack->idx_cache = git_oidmap_alloc();
		GITERR_CHECK_ALLOC(idx->pack->idx_cache);
465 466

		idx->pack->has_cache = 1;
467
		if (git_vector_init(&idx->objects, total_objects, objects_cmp) < 0)
468 469
			return -1;

470
		if (git_vector_init(&idx->deltas, total_objects / 2, NULL) < 0)
471 472
			return -1;

473
		stats->received_objects = 0;
474
		processed = stats->indexed_objects = 0;
475
		stats->total_objects = total_objects;
476
		do_progress_callback(idx, stats);
477 478 479 480 481 482 483
	}

	/* 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) {
484
		git_packfile_stream *stream = &idx->stream;
485
		git_off_t entry_start = idx->off;
486 487 488
		size_t entry_size;
		git_otype type;
		git_mwindow *w = NULL;
489

490 491 492
		if (idx->pack->mwf.size <= idx->off + 20)
			return 0;

493 494
		if (!idx->have_stream) {
			error = git_packfile_unpack_header(&entry_size, &type, mwf, &w, &idx->off);
495 496
			if (error == GIT_EBUFS) {
				idx->off = entry_start;
497
				return 0;
498
			}
499
			if (error < 0)
500 501 502 503
				return -1;

			git_mwindow_close(&w);
			idx->entry_start = entry_start;
504
			git_hash_ctx_init(&idx->hash_ctx);
505 506

			if (type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA) {
507
				error = advance_delta_offset(idx, type);
508 509 510 511 512
				if (error == GIT_EBUFS) {
					idx->off = entry_start;
					return 0;
				}
				if (error < 0)
513
					return -1;
514

515 516 517 518
				idx->have_delta = 1;
			} else {
				idx->have_delta = 0;
				hash_header(&idx->hash_ctx, entry_size, type);
519
			}
520

521 522 523
			idx->have_stream = 1;
			if (git_packfile_stream_open(stream, idx->pack, idx->off) < 0)
				goto on_error;
524 525 526 527

		}

		if (idx->have_delta) {
528
			error = read_object_stream(idx, stream);
529
		} else {
530
			error = hash_object_stream(idx, stream);
531 532
		}

533
		idx->off = stream->curpos;
534
		if (error == GIT_EBUFS)
535
			return 0;
536 537 538 539 540

		/* We want to free the stream reasorces no matter what here */
		idx->have_stream = 0;
		git_packfile_stream_free(stream);

541
		if (error < 0)
542 543
			goto on_error;

544 545 546 547 548 549 550
		if (idx->have_delta) {
			error = store_delta(idx);
		} else {
			error = store_object(idx);
		}

		if (error < 0)
551
			goto on_error;
552

553 554 555
		if (!idx->have_delta) {
			stats->indexed_objects = (unsigned int)++processed;
		}
556
		stats->received_objects++;
557

558
		if (do_progress_callback(idx, stats) != 0) {
559
			giterr_clear();
560 561 562
			error = GIT_EUSER;
			goto on_error;
		}
563
	}
564

565
	return 0;
566

567 568
on_error:
	git_mwindow_free_all(mwf);
569
	return error;
570
}
571

572 573 574 575
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;
576

577 578 579
	/* search backwards for '/' */
	while (slash > 0 && path->ptr[slash - 1] != '/')
		slash--;
580

581 582 583 584 585 586
	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
587
	git_oid_fmt(path->ptr + git_buf_len(path), &idx->hash);
588 589 590 591 592 593
	path->size += GIT_OID_HEXSZ;
	git_buf_puts(path, suffix);

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

594
static int resolve_deltas(git_indexer_stream *idx, git_transfer_progress *stats)
595 596 597 598 599 600 601 602 603 604 605 606 607
{
	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;
608 609

		git__free(obj.data);
610
		stats->indexed_objects++;
611
		do_progress_callback(idx, stats);
612
	}
613

614 615 616
	return 0;
}

617
int git_indexer_stream_finalize(git_indexer_stream *idx, git_transfer_progress *stats)
618 619 620 621 622 623
{
	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;
624
	git_oid trailer_hash, file_hash;
625
	git_hash_ctx ctx;
626
	git_filebuf index_file = {0};
627
	void *packfile_trailer;
628

629 630
	if (git_hash_ctx_init(&ctx) < 0)
		return -1;
631

632
	/* Test for this before resolve_deltas(), as it plays with idx->off */
633
	if (idx->off < idx->pack->mwf.size - 20) {
634
		giterr_set(GITERR_INDEXER, "unexpected data at the end of the pack");
635 636 637
		return -1;
	}

638 639 640 641 642 643 644 645 646 647 648 649
	packfile_trailer = git_mwindow_open(&idx->pack->mwf, &w, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ, &left);
	if (packfile_trailer == NULL) {
		git_mwindow_close(&w);
		goto on_error;
	}

	/* Compare the packfile trailer as it was sent to us and what we calculated */
	git_oid_fromraw(&file_hash, packfile_trailer);
	git_mwindow_close(&w);

	git_hash_final(&trailer_hash, &idx->trailer);
	if (git_oid_cmp(&file_hash, &trailer_hash)) {
650
		giterr_set(GITERR_INDEXER, "packfile trailer mismatch");
651 652 653
		return -1;
	}

654 655 656 657
	if (idx->deltas.length > 0)
		if (resolve_deltas(idx, stats) < 0)
			return -1;

658
	if (stats->indexed_objects != stats->total_objects) {
659
		giterr_set(GITERR_INDEXER, "early EOF");
660 661 662
		return -1;
	}

663 664 665
	git_vector_sort(&idx->objects);

	git_buf_sets(&filename, idx->pack->pack_name);
666
	git_buf_shorten(&filename, strlen("pack"));
667 668 669 670
	git_buf_puts(&filename, "idx");
	if (git_buf_oom(&filename))
		return -1;

671
	if (git_filebuf_open(&index_file, filename.ptr, GIT_FILEBUF_HASH_CONTENTS) < 0)
672 673 674 675 676
		goto on_error;

	/* Write out the header */
	hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
	hdr.idx_version = htonl(2);
677
	git_filebuf_write(&index_file, &hdr, sizeof(hdr));
678 679 680 681

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

685 686
	/* Write out the object names (SHA-1 hashes) */
	git_vector_foreach(&idx->objects, i, entry) {
687
		git_filebuf_write(&index_file, &entry->oid, sizeof(git_oid));
688
		git_hash_update(&ctx, &entry->oid, GIT_OID_RAWSZ);
689
	}
690
	git_hash_final(&idx->hash, &ctx);
691 692 693

	/* Write out the CRC32 values */
	git_vector_foreach(&idx->objects, i, entry) {
694
		git_filebuf_write(&index_file, &entry->crc, sizeof(uint32_t));
695 696 697 698 699 700 701 702 703 704 705
	}

	/* 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);

706
		git_filebuf_write(&index_file, &n, sizeof(uint32_t));
707 708 709 710 711 712 713 714 715 716 717 718
	}

	/* 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);

719
		git_filebuf_write(&index_file, &split, sizeof(uint32_t) * 2);
720 721
	}

722 723
	/* Write out the packfile trailer to the index */
	if (git_filebuf_write(&index_file, &trailer_hash, GIT_OID_RAWSZ) < 0)
724 725
		goto on_error;

726 727
	/* Write out the hash of the idx */
	if (git_filebuf_hash(&trailer_hash, &index_file) < 0)
728 729
		goto on_error;

730
	git_filebuf_write(&index_file, &trailer_hash, sizeof(git_oid));
731 732 733 734 735 736

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

	/* Commit file */
737
	if (git_filebuf_commit_at(&index_file, filename.ptr, GIT_PACK_FILE_MODE) < 0)
738 739 740
		goto on_error;

	git_mwindow_free_all(&idx->pack->mwf);
741
	/* We need to close the descriptor here so Windows doesn't choke on commit_at */
742
	p_close(idx->pack->mwf.fd);
743
	idx->pack->mwf.fd = -1;
744 745 746 747 748 749 750 751

	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);
752 753 754
	return 0;

on_error:
755
	git_mwindow_free_all(&idx->pack->mwf);
756
	git_filebuf_cleanup(&index_file);
757
	git_buf_free(&filename);
758
	git_hash_ctx_cleanup(&ctx);
759 760 761
	return -1;
}

762 763
void git_indexer_stream_free(git_indexer_stream *idx)
{
764
	khiter_t k;
765 766 767 768 769 770 771 772 773 774
	unsigned int i;
	struct entry *e;
	struct delta_info *delta;

	if (idx == NULL)
		return;

	git_vector_foreach(&idx->objects, i, e)
		git__free(e);
	git_vector_free(&idx->objects);
775

776
	if (idx->pack) {
777 778 779 780 781 782
		for (k = kh_begin(idx->pack->idx_cache); k != kh_end(idx->pack->idx_cache); k++) {
			if (kh_exist(idx->pack->idx_cache, k))
				git__free(kh_value(idx->pack->idx_cache, k));
		}

		git_oidmap_free(idx->pack->idx_cache);
783
	}
784

785 786 787
	git_vector_foreach(&idx->deltas, i, delta)
		git__free(delta);
	git_vector_free(&idx->deltas);
788
	git_packfile_free(idx->pack);
789
	git_filebuf_cleanup(&idx->pack_file);
790 791
	git__free(idx);
}