rugged 1.3.1 → 1.6.2

data/vendor/libgit2/src/{midx.c → libgit2/midx.c}

@@ -8,14 +8,15 @@
 #include "midx.h"
 
 #include "array.h"
-#include "buffer.h"
+#include "buf.h"
 #include "filebuf.h"
 #include "futils.h"
 #include "hash.h"
 #include "odb.h"
 #include "pack.h"
-#include "path.h"
+#include "fs_path.h"
 #include "repository.h"
+#include "str.h"
 
 #define MIDX_SIGNATURE 0x4d494458 /* "MIDX" */
 #define MIDX_VERSION 1
@@ -114,19 +115,19 @@ static int midx_parse_oid_lookup(
 		struct git_midx_chunk *chunk_oid_lookup)
 {
 	uint32_t i;
-	git_oid *oid, *prev_oid, zero_oid = {{0}};
+	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
 
 	if (chunk_oid_lookup->offset == 0)
 		return midx_error("missing OID Lookup chunk");
 	if (chunk_oid_lookup->length == 0)
 		return midx_error("empty OID Lookup chunk");
-	if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_RAWSZ)
+	if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_SHA1_SIZE)
 		return midx_error("OID Lookup chunk has wrong length");
 
-	idx->oid_lookup = oid = (git_oid *)(data + chunk_oid_lookup->offset);
-	prev_oid = &zero_oid;
-	for (i = 0; i < idx->num_objects; ++i, ++oid) {
-		if (git_oid_cmp(prev_oid, oid) >= 0)
+	idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
+	prev_oid = zero_oid;
+	for (i = 0; i < idx->num_objects; ++i, oid += GIT_OID_SHA1_SIZE) {
+		if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0)
 			return midx_error("OID Lookup index is non-monotonic");
 		prev_oid = oid;
 	}
@@ -177,7 +178,7 @@ int git_midx_parse(
 	struct git_midx_chunk *last_chunk;
 	uint32_t i;
 	off64_t last_chunk_offset, chunk_offset, trailer_offset;
-	git_oid idx_checksum = {{0}};
+	size_t checksum_size;
 	int error;
 	struct git_midx_chunk chunk_packfile_names = {0},
 					 chunk_oid_fanout = {0},
@@ -187,7 +188,7 @@ int git_midx_parse(
 
 	GIT_ASSERT_ARG(idx);
 
-	if (size < sizeof(struct git_midx_header) + GIT_OID_RAWSZ)
+	if (size < sizeof(struct git_midx_header) + GIT_OID_SHA1_SIZE)
 		return midx_error("multi-pack index is too short");
 
 	hdr = ((struct git_midx_header *)data);
@@ -207,21 +208,24 @@ int git_midx_parse(
 	last_chunk_offset =
 			sizeof(struct git_midx_header) +
 			(1 + hdr->chunks) * 12;
-	trailer_offset = size - GIT_OID_RAWSZ;
+
+	checksum_size = GIT_HASH_SHA1_SIZE;
+	trailer_offset = size - checksum_size;
+
 	if (trailer_offset < last_chunk_offset)
 		return midx_error("wrong index size");
-	git_oid_cpy(&idx->checksum, (git_oid *)(data + trailer_offset));
-
-	if (git_hash_buf(&idx_checksum, data, (size_t)trailer_offset) < 0)
-		return midx_error("could not calculate signature");
-	if (!git_oid_equal(&idx_checksum, &idx->checksum))
-		return midx_error("index signature mismatch");
+	memcpy(idx->checksum, data + trailer_offset, checksum_size);
 
 	chunk_hdr = data + sizeof(struct git_midx_header);
 	last_chunk = NULL;
 	for (i = 0; i < hdr->chunks; ++i, chunk_hdr += 12) {
-		chunk_offset = ((off64_t)ntohl(*((uint32_t *)(chunk_hdr + 4)))) << 32 |
-				((off64_t)ntohl(*((uint32_t *)(chunk_hdr + 8))));
+		uint32_t chunk_id = ntohl(*((uint32_t *)(chunk_hdr + 0)));
+		uint64_t high_offset = ((uint64_t)ntohl(*((uint32_t *)(chunk_hdr + 4)))) & 0xffffffffu;
+		uint64_t low_offset = ((uint64_t)ntohl(*((uint32_t *)(chunk_hdr + 8)))) & 0xffffffffu;
+
+		if (high_offset >= INT32_MAX)
+			return midx_error("chunk offset out of range");
+		chunk_offset = (off64_t)(high_offset << 32 | low_offset);
 		if (chunk_offset < last_chunk_offset)
 			return midx_error("chunks are non-monotonic");
 		if (chunk_offset >= trailer_offset)
@@ -230,7 +234,7 @@ int git_midx_parse(
 			last_chunk->length = (size_t)(chunk_offset - last_chunk_offset);
 		last_chunk_offset = chunk_offset;
 
-		switch (ntohl(*((uint32_t *)(chunk_hdr + 0)))) {
+		switch (chunk_id) {
 		case MIDX_PACKFILE_NAMES_ID:
 			chunk_packfile_names.offset = last_chunk_offset;
 			last_chunk = &chunk_packfile_names;
@@ -313,7 +317,7 @@ int git_midx_open(
 	idx = git__calloc(1, sizeof(git_midx_file));
 	GIT_ERROR_CHECK_ALLOC(idx);
 
-	error = git_buf_sets(&idx->filename, path);
+	error = git_str_sets(&idx->filename, path);
 	if (error < 0)
 		return error;
 
@@ -340,7 +344,8 @@ bool git_midx_needs_refresh(
 	git_file fd = -1;
 	struct stat st;
 	ssize_t bytes_read;
-	git_oid idx_checksum = {{0}};
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	size_t checksum_size;
 
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
@@ -359,13 +364,14 @@ bool git_midx_needs_refresh(
 		return true;
 	}
 
-	bytes_read = p_pread(fd, &idx_checksum, GIT_OID_RAWSZ, st.st_size - GIT_OID_RAWSZ);
+	checksum_size = GIT_HASH_SHA1_SIZE;
+	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - GIT_OID_SHA1_SIZE);
 	p_close(fd);
 
-	if (bytes_read != GIT_OID_RAWSZ)
+	if (bytes_read != (ssize_t)checksum_size)
 		return true;
 
-	return !git_oid_equal(&idx_checksum, &idx->checksum);
+	return (memcmp(checksum, idx->checksum, checksum_size) != 0);
 }
 
 int git_midx_entry_find(
@@ -377,7 +383,7 @@ int git_midx_entry_find(
 	int pos, found = 0;
 	size_t pack_index;
 	uint32_t hi, lo;
-	const git_oid *current = NULL;
+	unsigned char *current = NULL;
 	const unsigned char *object_offset;
 	off64_t offset;
 
@@ -386,31 +392,30 @@ int git_midx_entry_find(
 	hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1]));
 
-	pos = git_pack__lookup_sha1(idx->oid_lookup, GIT_OID_RAWSZ, lo, hi, short_oid->id);
+	pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = idx->oid_lookup + pos;
+		current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
 	} else {
 		/* No object was found */
 		/* pos refers to the object with the "closest" oid to short_oid */
 		pos = -1 - pos;
 		if (pos < (int)idx->num_objects) {
-			current = idx->oid_lookup + pos;
+			current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
 
-			if (!git_oid_ncmp(short_oid, current, len))
+			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)idx->num_objects) {
+	if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)idx->num_objects) {
 		/* Check for ambiguousity */
-		const git_oid *next = current + 1;
+		const unsigned char *next = current + GIT_OID_SHA1_SIZE;
 
-		if (!git_oid_ncmp(short_oid, next, len)) {
+		if (!git_oid_raw_ncmp(short_oid->id, next, len))
 			found = 2;
-		}
 	}
 
 	if (!found)
@@ -420,8 +425,8 @@ int git_midx_entry_find(
 
 	object_offset = idx->object_offsets + pos * 8;
 	offset = ntohl(*((uint32_t *)(object_offset + 4)));
-	if (offset & 0x80000000) {
-		uint32_t object_large_offsets_pos = offset & 0x7fffffff;
+	if (idx->object_large_offsets && offset & 0x80000000) {
+		uint32_t object_large_offsets_pos = (uint32_t) (offset ^ 0x80000000);
 		const unsigned char *object_large_offsets_index = idx->object_large_offsets;
 
 		/* Make sure we're not being sent out of bounds */
@@ -438,7 +443,7 @@ int git_midx_entry_find(
 		return midx_error("invalid index into the packfile names table");
 	e->pack_index = pack_index;
 	e->offset = offset;
-	git_oid_cpy(&e->sha1, current);
+	git_oid__fromraw(&e->sha1, current, GIT_OID_SHA1);
 	return 0;
 }
 
@@ -447,13 +452,17 @@ int git_midx_foreach_entry(
 		git_odb_foreach_cb cb,
 		void *data)
 {
+	git_oid oid;
 	size_t i;
 	int error;
 
 	GIT_ASSERT_ARG(idx);
 
 	for (i = 0; i < idx->num_objects; ++i) {
-		if ((error = cb(&idx->oid_lookup[i], data)) != 0)
+		if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * GIT_OID_SHA1_SIZE], GIT_OID_SHA1)) < 0)
+			return error;
+
+		if ((error = cb(&oid, data)) != 0)
 			return git_error_set_after_callback(error);
 	}
 
@@ -477,7 +486,7 @@ void git_midx_free(git_midx_file *idx)
 	if (!idx)
 		return;
 
-	git_buf_dispose(&idx->filename);
+	git_str_dispose(&idx->filename);
 	git_midx_close(idx);
 	git__free(idx);
 }
@@ -497,14 +506,14 @@ int git_midx_writer_new(
 	git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer));
 	GIT_ERROR_CHECK_ALLOC(w);
 
-	if (git_buf_sets(&w->pack_dir, pack_dir) < 0) {
+	if (git_str_sets(&w->pack_dir, pack_dir) < 0) {
 		git__free(w);
 		return -1;
 	}
-	git_path_squash_slashes(&w->pack_dir);
+	git_fs_path_squash_slashes(&w->pack_dir);
 
 	if (git_vector_init(&w->packs, 0, packfile__cmp) < 0) {
-		git_buf_dispose(&w->pack_dir);
+		git_str_dispose(&w->pack_dir);
 		git__free(w);
 		return -1;
 	}
@@ -524,7 +533,7 @@ void git_midx_writer_free(git_midx_writer *w)
 	git_vector_foreach (&w->packs, i, p)
 		git_mwindow_put_pack(p);
 	git_vector_free(&w->packs);
-	git_buf_dispose(&w->pack_dir);
+	git_str_dispose(&w->pack_dir);
 	git__free(w);
 }
 
@@ -532,16 +541,17 @@ int git_midx_writer_add(
 		git_midx_writer *w,
 		const char *idx_path)
 {
-	git_buf idx_path_buf = GIT_BUF_INIT;
+	git_str idx_path_buf = GIT_STR_INIT;
 	int error;
 	struct git_pack_file *p;
 
-	error = git_path_prettify(&idx_path_buf, idx_path, git_buf_cstr(&w->pack_dir));
+	error = git_fs_path_prettify(&idx_path_buf, idx_path, git_str_cstr(&w->pack_dir));
 	if (error < 0)
 		return error;
 
-	error = git_mwindow_get_pack(&p, git_buf_cstr(&idx_path_buf));
-	git_buf_dispose(&idx_path_buf);
+	/* TODO: SHA256 */
+	error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf), 0);
+	git_str_dispose(&idx_path_buf);
 	if (error < 0)
 		return error;
 
@@ -613,8 +623,8 @@ static int write_chunk_header(int chunk_id, off64_t offset, midx_write_cb write_
 
 static int midx_write_buf(const char *buf, size_t size, void *data)
 {
-	git_buf *b = (git_buf *)data;
-	return git_buf_put(b, buf, size);
+	git_str *b = (git_str *)data;
+	return git_str_put(b, buf, size);
 }
 
 struct midx_write_hash_context {
@@ -648,11 +658,12 @@ static int midx_write(
 	uint32_t object_large_offsets_count;
 	uint32_t oid_fanout[256];
 	off64_t offset;
-	git_buf packfile_names = GIT_BUF_INIT,
-		oid_lookup = GIT_BUF_INIT,
-		object_offsets = GIT_BUF_INIT,
-		object_large_offsets = GIT_BUF_INIT;
-	git_oid idx_checksum = {{0}};
+	git_str packfile_names = GIT_STR_INIT,
+		oid_lookup = GIT_STR_INIT,
+		object_offsets = GIT_STR_INIT,
+		object_large_offsets = GIT_STR_INIT;
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	size_t checksum_size;
 	git_midx_entry *entry;
 	object_entry_array_t object_entries_array = GIT_ARRAY_INIT;
 	git_vector object_entries = GIT_VECTOR_INIT;
@@ -668,7 +679,8 @@ static int midx_write(
 	hash_cb_data.cb_data = cb_data;
 	hash_cb_data.ctx = &ctx;
 
-	error = git_hash_ctx_init(&ctx);
+	checksum_size = GIT_HASH_SHA1_SIZE;
+	error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
 	if (error < 0)
 		return error;
 	cb_data = &hash_cb_data;
@@ -676,34 +688,34 @@ static int midx_write(
 
 	git_vector_sort(&w->packs);
 	git_vector_foreach (&w->packs, i, p) {
-		git_buf relative_index = GIT_BUF_INIT;
+		git_str relative_index = GIT_STR_INIT;
 		struct object_entry_cb_state state = {0};
 		size_t path_len;
 
 		state.pack_index = (uint32_t)i;
 		state.object_entries_array = &object_entries_array;
 
-		error = git_buf_sets(&relative_index, p->pack_name);
+		error = git_str_sets(&relative_index, p->pack_name);
 		if (error < 0)
 			goto cleanup;
-		error = git_path_make_relative(&relative_index, git_buf_cstr(&w->pack_dir));
+		error = git_fs_path_make_relative(&relative_index, git_str_cstr(&w->pack_dir));
 		if (error < 0) {
-			git_buf_dispose(&relative_index);
+			git_str_dispose(&relative_index);
 			goto cleanup;
 		}
-		path_len = git_buf_len(&relative_index);
-		if (path_len <= strlen(".pack") || git__suffixcmp(git_buf_cstr(&relative_index), ".pack") != 0) {
-			git_buf_dispose(&relative_index);
+		path_len = git_str_len(&relative_index);
+		if (path_len <= strlen(".pack") || git__suffixcmp(git_str_cstr(&relative_index), ".pack") != 0) {
+			git_str_dispose(&relative_index);
 			git_error_set(GIT_ERROR_INVALID, "invalid packfile name: '%s'", p->pack_name);
 			error = -1;
 			goto cleanup;
 		}
 		path_len -= strlen(".pack");
 
-		git_buf_put(&packfile_names, git_buf_cstr(&relative_index), path_len);
-		git_buf_puts(&packfile_names, ".idx");
-		git_buf_putc(&packfile_names, '\0');
-		git_buf_dispose(&relative_index);
+		git_str_put(&packfile_names, git_str_cstr(&relative_index), path_len);
+		git_str_puts(&packfile_names, ".idx");
+		git_str_putc(&packfile_names, '\0');
+		git_str_dispose(&relative_index);
 
 		error = git_pack_foreach_entry_offset(p, object_entry__cb, &state);
 		if (error < 0)
@@ -723,8 +735,8 @@ static int midx_write(
 	git_vector_uniq(&object_entries, NULL);
 
 	/* Pad the packfile names so it is a multiple of four. */
-	while (git_buf_len(&packfile_names) & 3)
-		git_buf_putc(&packfile_names, '\0');
+	while (git_str_len(&packfile_names) & 3)
+		git_str_putc(&packfile_names, '\0');
 
 	/* Fill the OID Fanout table. */
 	oid_fanout_count = 0;
@@ -737,7 +749,7 @@ static int midx_write(
 
 	/* Fill the OID Lookup table. */
 	git_vector_foreach (&object_entries, i, entry) {
-		error = git_buf_put(&oid_lookup, (const char *)&entry->sha1, sizeof(entry->sha1));
+		error = git_str_put(&oid_lookup, (char *)&entry->sha1.id, GIT_OID_SHA1_SIZE);
 		if (error < 0)
 			goto cleanup;
 	}
@@ -748,7 +760,7 @@ static int midx_write(
 		uint32_t word;
 
 		word = htonl((uint32_t)entry->pack_index);
-		error = git_buf_put(&object_offsets, (const char *)&word, sizeof(word));
+		error = git_str_put(&object_offsets, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
 		if (entry->offset >= 0x80000000l) {
@@ -759,7 +771,7 @@ static int midx_write(
 			word = htonl((uint32_t)entry->offset & 0x7fffffffu);
 		}
 
-		error = git_buf_put(&object_offsets, (const char *)&word, sizeof(word));
+		error = git_str_put(&object_offsets, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
 	}
@@ -767,7 +779,7 @@ static int midx_write(
 	/* Write the header. */
 	hdr.packfiles = htonl((uint32_t)git_vector_length(&w->packs));
 	hdr.chunks = 4;
-	if (git_buf_len(&object_large_offsets) > 0)
+	if (git_str_len(&object_large_offsets) > 0)
 		hdr.chunks++;
 	error = write_cb((const char *)&hdr, sizeof(hdr), cb_data);
 	if (error < 0)
@@ -778,7 +790,7 @@ static int midx_write(
 	error = write_chunk_header(MIDX_PACKFILE_NAMES_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
-	offset += git_buf_len(&packfile_names);
+	offset += git_str_len(&packfile_names);
 	error = write_chunk_header(MIDX_OID_FANOUT_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
@@ -786,53 +798,53 @@ static int midx_write(
 	error = write_chunk_header(MIDX_OID_LOOKUP_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
-	offset += git_buf_len(&oid_lookup);
+	offset += git_str_len(&oid_lookup);
 	error = write_chunk_header(MIDX_OBJECT_OFFSETS_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
-	offset += git_buf_len(&object_offsets);
-	if (git_buf_len(&object_large_offsets) > 0) {
+	offset += git_str_len(&object_offsets);
+	if (git_str_len(&object_large_offsets) > 0) {
 		error = write_chunk_header(MIDX_OBJECT_LARGE_OFFSETS_ID, offset, write_cb, cb_data);
 		if (error < 0)
 			goto cleanup;
-		offset += git_buf_len(&object_large_offsets);
+		offset += git_str_len(&object_large_offsets);
 	}
 	error = write_chunk_header(0, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
 
 	/* Write all the chunks. */
-	error = write_cb(git_buf_cstr(&packfile_names), git_buf_len(&packfile_names), cb_data);
+	error = write_cb(git_str_cstr(&packfile_names), git_str_len(&packfile_names), cb_data);
 	if (error < 0)
 		goto cleanup;
 	error = write_cb((const char *)oid_fanout, sizeof(oid_fanout), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&oid_lookup), git_buf_len(&oid_lookup), cb_data);
+	error = write_cb(git_str_cstr(&oid_lookup), git_str_len(&oid_lookup), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&object_offsets), git_buf_len(&object_offsets), cb_data);
+	error = write_cb(git_str_cstr(&object_offsets), git_str_len(&object_offsets), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&object_large_offsets), git_buf_len(&object_large_offsets), cb_data);
+	error = write_cb(git_str_cstr(&object_large_offsets), git_str_len(&object_large_offsets), cb_data);
 	if (error < 0)
 		goto cleanup;
 
 	/* Finalize the checksum and write the trailer. */
-	error = git_hash_final(&idx_checksum, &ctx);
+	error = git_hash_final(checksum, &ctx);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb((const char *)&idx_checksum, sizeof(idx_checksum), cb_data);
+	error = write_cb((char *)checksum, checksum_size, cb_data);
 	if (error < 0)
 		goto cleanup;
 
 cleanup:
 	git_array_clear(object_entries_array);
 	git_vector_free(&object_entries);
-	git_buf_dispose(&packfile_names);
-	git_buf_dispose(&oid_lookup);
-	git_buf_dispose(&object_offsets);
-	git_buf_dispose(&object_large_offsets);
+	git_str_dispose(&packfile_names);
+	git_str_dispose(&oid_lookup);
+	git_str_dispose(&object_offsets);
+	git_str_dispose(&object_large_offsets);
 	git_hash_ctx_cleanup(&ctx);
 	return error;
 }
@@ -848,17 +860,17 @@ int git_midx_writer_commit(
 {
 	int error;
 	int filebuf_flags = GIT_FILEBUF_DO_NOT_BUFFER;
-	git_buf midx_path = GIT_BUF_INIT;
+	git_str midx_path = GIT_STR_INIT;
 	git_filebuf output = GIT_FILEBUF_INIT;
 
-	error = git_buf_joinpath(&midx_path, git_buf_cstr(&w->pack_dir), "multi-pack-index");
+	error = git_str_joinpath(&midx_path, git_str_cstr(&w->pack_dir), "multi-pack-index");
 	if (error < 0)
 		return error;
 
 	if (git_repository__fsync_gitdir)
 		filebuf_flags |= GIT_FILEBUF_FSYNC;
-	error = git_filebuf_open(&output, git_buf_cstr(&midx_path), filebuf_flags, 0644);
-	git_buf_dispose(&midx_path);
+	error = git_filebuf_open(&output, git_str_cstr(&midx_path), filebuf_flags, 0644);
+	git_str_dispose(&midx_path);
 	if (error < 0)
 		return error;
 
@@ -875,5 +887,13 @@ int git_midx_writer_dump(
 		git_buf *midx,
 		git_midx_writer *w)
 {
-	return midx_write(w, midx_write_buf, midx);
+	git_str str = GIT_STR_INIT;
+	int error;
+
+	if ((error = git_buf_tostr(&str, midx)) < 0 ||
+	    (error = midx_write(w, midx_write_buf, &str)) == 0)
+		error = git_buf_fromstr(midx, &str);
+
+	git_str_dispose(&str);
+	return error;
 }

data/vendor/libgit2/src/{midx.h → libgit2/midx.h}

@@ -17,6 +17,7 @@
 #include "map.h"
 #include "mwindow.h"
 #include "odb.h"
+#include "oid.h"
 
 /*
  * A multi-pack-index file.
@@ -40,7 +41,7 @@ typedef struct git_midx_file {
 	uint32_t num_objects;
 
 	/* The OID Lookup table. */
-	git_oid *oid_lookup;
+	unsigned char *oid_lookup;
 
 	/* The Object Offsets table. Each entry has two 4-byte fields with the pack index and the offset. */
 	const unsigned char *object_offsets;
@@ -51,10 +52,10 @@ typedef struct git_midx_file {
 	size_t num_object_large_offsets;
 
 	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
-	git_oid checksum;
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
 
 	/* something like ".git/objects/pack/multi-pack-index". */
-	git_buf filename;
+	git_str filename;
 } git_midx_file;
 
 /*
@@ -77,7 +78,7 @@ struct git_midx_writer {
 	 * The path of the directory where the .pack/.idx files are stored. The
 	 * `multi-pack-index` file will be written to the same directory.
 	 */
-	git_buf pack_dir;
+	git_str pack_dir;
 
 	/* The list of `git_pack_file`s. */
 	git_vector packs;

data/vendor/libgit2/src/{mwindow.c → libgit2/mwindow.c}

@@ -61,7 +61,10 @@ int git_mwindow_global_init(void)
 	return git_runtime_shutdown_register(git_mwindow_global_shutdown);
 }
 
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
+int git_mwindow_get_pack(
+	struct git_pack_file **out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	struct git_pack_file *pack;
 	char *packname;
@@ -86,7 +89,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 	}
 
 	/* If we didn't find it, we need to create it */
-	if ((error = git_packfile_alloc(&pack, path)) < 0) {
+	if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) {
 		git_mutex_unlock(&git__mwindow_mutex);
 		return error;
 	}
@@ -186,13 +189,16 @@ int git_mwindow_free_all(git_mwindow_file *mwf)
 }
 
 /*
- * Check if a window 'win' contains the address 'offset'
+ * Check if a window 'win' contains both the address 'offset' and 'extra'.
+ *
+ * 'extra' is the size of the hash we're using as we always want to make sure
+ * that it's contained.
  */
-int git_mwindow_contains(git_mwindow *win, off64_t offset)
+int git_mwindow_contains(git_mwindow *win, off64_t offset, off64_t extra)
 {
 	off64_t win_off = win->offset;
 	return win_off <= offset
-		&& offset <= (off64_t)(win_off + win->window_map.len);
+		&& (offset + extra) <= (off64_t)(win_off + win->window_map.len);
 }
 
 #define GIT_MWINDOW__LRU -1
@@ -237,9 +243,7 @@ static bool git_mwindow_scan_recently_used(
 		 * store it in the output parameter. If lru_window is NULL,
 		 * it's the first loop, so store it as well.
 		 */
-		if (!lru_window ||
-				(comparison_sign == GIT_MWINDOW__LRU && lru_window->last_used > w->last_used) ||
-				(comparison_sign == GIT_MWINDOW__MRU && lru_window->last_used < w->last_used)) {
+		if (!lru_window || (comparison_sign * w->last_used) > lru_window->last_used) {
 			lru_window = w;
 			lru_last = w_last;
 			found = true;
@@ -406,14 +410,13 @@ unsigned char *git_mwindow_open(
 		return NULL;
 	}
 
-	if (!w || !(git_mwindow_contains(w, offset) && git_mwindow_contains(w, offset + extra))) {
+	if (!w || !(git_mwindow_contains(w, offset, extra))) {
 		if (w) {
 			w->inuse_cnt--;
 		}
 
 		for (w = mwf->windows; w; w = w->next) {
-			if (git_mwindow_contains(w, offset) &&
-				git_mwindow_contains(w, offset + extra))
+			if (git_mwindow_contains(w, offset, extra))
 				break;
 		}
 
@@ -473,7 +476,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 				git_mwindow_find_lru_file_locked(&lru_file) == 0) {
 			if ((error = git_vector_insert(&closed_files, lru_file)) < 0) {
 				/*
-				 * Exceeding the file limit seems preferrable to being open to
+				 * Exceeding the file limit seems preferable to being open to
 				 * data races that can end up corrupting the heap.
 				 */
 				break;

data/vendor/libgit2/src/{mwindow.h → libgit2/mwindow.h}

@@ -38,7 +38,7 @@ typedef struct git_mwindow_ctl {
 	git_vector windowfiles;
 } git_mwindow_ctl;
 
-int git_mwindow_contains(git_mwindow *win, off64_t offset);
+int git_mwindow_contains(git_mwindow *win, off64_t offset, off64_t extra);
 int git_mwindow_free_all(git_mwindow_file *mwf); /* locks */
 unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, off64_t offset, size_t extra, unsigned int *left);
 int git_mwindow_file_register(git_mwindow_file *mwf);
@@ -48,7 +48,10 @@ void git_mwindow_close(git_mwindow **w_cursor);
 extern int git_mwindow_global_init(void);
 
 struct git_pack_file; /* just declaration to avoid cyclical includes */
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path);
+int git_mwindow_get_pack(
+	struct git_pack_file **out,
+	const char *path,
+	git_oid_t oid_type);
 int git_mwindow_put_pack(struct git_pack_file *pack);
 
 #endif

data/vendor/libgit2/src/{netops.c → libgit2/netops.c}

@@ -11,8 +11,7 @@
 #include "git2/errors.h"
 
 #include "posix.h"
-#include "buffer.h"
-#include "http_parser.h"
+#include "str.h"
 #include "runtime.h"
 
 int gitno_recv(gitno_buffer *buf)

data/vendor/libgit2/src/{netops.h → libgit2/netops.h}

@@ -42,7 +42,7 @@ typedef struct gitno_buffer {
 /* Flags to gitno_connect */
 enum {
 	/* Attempt to create an SSL connection. */
-	GITNO_CONNECT_SSL = 1,
+	GITNO_CONNECT_SSL = 1
 };
 
 /**