rugged 1.3.1 → 1.9.0

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;
@@ -50,11 +51,17 @@ typedef struct git_midx_file {
 	/* The number of entries in the Object Large Offsets table. Each entry has an 8-byte with an offset */
 	size_t num_object_large_offsets;
 
-	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
-	git_oid checksum;
+	/*
+	 * The trailer of the file. Contains the checksum of the whole
+	 * file, in the repository's object format hash.
+	 */
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+
+	/* The type of object IDs in the midx. */
+	git_oid_t oid_type;
 
 	/* something like ".git/objects/pack/multi-pack-index". */
-	git_buf filename;
+	git_str filename;
 } git_midx_file;
 
 /*
@@ -77,15 +84,19 @@ 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;
+
+	/* The object ID type of the writer. */
+	git_oid_t oid_type;
 };
 
 int git_midx_open(
 		git_midx_file **idx_out,
-		const char *path);
+		const char *path,
+		git_oid_t oid_type);
 bool git_midx_needs_refresh(
 		const git_midx_file *idx,
 		const char *path);

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

@@ -11,7 +11,6 @@
 #include "futils.h"
 #include "map.h"
 #include "runtime.h"
-#include "strmap.h"
 #include "pack.h"
 
 #define DEFAULT_WINDOW_SIZE \
@@ -29,39 +28,36 @@ size_t git_mwindow__window_size = DEFAULT_WINDOW_SIZE;
 size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
 size_t git_mwindow__file_limit = DEFAULT_FILE_LIMIT;
 
-/* Mutex to control access to `git_mwindow__mem_ctl` and `git__pack_cache`. */
-git_mutex git__mwindow_mutex;
+/* Mutex to control access to `git_mwindow__mem_ctl` and `git_mwindow__pack_cache`. */
+git_mutex git_mwindow__mutex;
 
-/* Whenever you want to read or modify this, grab `git__mwindow_mutex` */
+/* Whenever you want to read or modify this, grab `git_mwindow__mutex` */
 git_mwindow_ctl git_mwindow__mem_ctl;
 
 /* Global list of mwindow files, to open packs once across repos */
-git_strmap *git__pack_cache = NULL;
+GIT_HASHMAP_STR_FUNCTIONS(git_mwindow_packmap, , struct git_pack_file *);
+git_mwindow_packmap git_mwindow__pack_cache;
 
 static void git_mwindow_global_shutdown(void)
 {
-	git_strmap *tmp = git__pack_cache;
-
-	git_mutex_free(&git__mwindow_mutex);
-
-	git__pack_cache = NULL;
-	git_strmap_free(tmp);
+	git_mutex_free(&git_mwindow__mutex);
+	git_mwindow_packmap_dispose(&git_mwindow__pack_cache);
 }
 
 int git_mwindow_global_init(void)
 {
 	int error;
 
-	GIT_ASSERT(!git__pack_cache);
-
-	if ((error = git_mutex_init(&git__mwindow_mutex)) < 0 ||
-	    (error = git_strmap_new(&git__pack_cache)) < 0)
+	if ((error = git_mutex_init(&git_mwindow__mutex)) < 0)
 	    return error;
 
 	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;
@@ -70,31 +66,34 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 	if ((error = git_packfile__name(&packname, path)) < 0)
 		return error;
 
-	if (git_mutex_lock(&git__mwindow_mutex) < 0) {
+	if (git_mutex_lock(&git_mwindow__mutex) < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
 		return -1;
 	}
 
-	pack = git_strmap_get(git__pack_cache, packname);
+	error = git_mwindow_packmap_get(&pack, &git_mwindow__pack_cache, packname);
 	git__free(packname);
 
-	if (pack != NULL) {
+	if (error == 0) {
 		git_atomic32_inc(&pack->refcount);
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		*out = pack;
 		return 0;
+	} else if (error != GIT_ENOTFOUND) {
+		return error;
 	}
 
 	/* If we didn't find it, we need to create it */
-	if ((error = git_packfile_alloc(&pack, path)) < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
+	if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) {
+		git_mutex_unlock(&git_mwindow__mutex);
 		return error;
 	}
 
 	git_atomic32_inc(&pack->refcount);
 
-	error = git_strmap_set(git__pack_cache, pack->pack_name, pack);
-	git_mutex_unlock(&git__mwindow_mutex);
+	error = git_mwindow_packmap_put(&git_mwindow__pack_cache, pack->pack_name, pack);
+	git_mutex_unlock(&git_mwindow__mutex);
+
 	if (error < 0) {
 		git_packfile_free(pack, false);
 		return error;
@@ -109,21 +108,18 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
 	int count, error;
 	struct git_pack_file *pack_to_delete = NULL;
 
-	if ((error = git_mutex_lock(&git__mwindow_mutex)) < 0)
+	if ((error = git_mutex_lock(&git_mwindow__mutex)) < 0)
 		return error;
 
-	/* put before get would be a corrupted state */
-	GIT_ASSERT(git__pack_cache);
-
 	/* if we cannot find it, the state is corrupted */
-	GIT_ASSERT(git_strmap_exists(git__pack_cache, pack->pack_name));
+	GIT_ASSERT(git_mwindow_packmap_contains(&git_mwindow__pack_cache, pack->pack_name));
 
 	count = git_atomic32_dec(&pack->refcount);
 	if (count == 0) {
-		git_strmap_delete(git__pack_cache, pack->pack_name);
+		git_mwindow_packmap_remove(&git_mwindow__pack_cache, pack->pack_name);
 		pack_to_delete = pack;
 	}
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	git_packfile_free(pack_to_delete, false);
 
 	return 0;
@@ -131,7 +127,7 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
 
 /*
  * Free all the windows in a sequence, typically because we're done
- * with the file. Needs to hold the git__mwindow_mutex.
+ * with the file. Needs to hold the git_mwindow__mutex.
  */
 static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
 {
@@ -149,7 +145,7 @@ static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
 	}
 
 	if (ctl->windowfiles.length == 0) {
-		git_vector_free(&ctl->windowfiles);
+		git_vector_dispose(&ctl->windowfiles);
 		ctl->windowfiles.contents = NULL;
 	}
 
@@ -173,26 +169,29 @@ int git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	int error;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
 	error = git_mwindow_free_all_locked(mwf);
 
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 
 	return error;
 }
 
 /*
- * 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 +236,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;
@@ -401,19 +398,18 @@ unsigned char *git_mwindow_open(
 	git_mwindow_ctl *ctl = &git_mwindow__mem_ctl;
 	git_mwindow *w = *cursor;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		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;
 		}
 
@@ -424,7 +420,7 @@ unsigned char *git_mwindow_open(
 		if (!w) {
 			w = new_window_locked(mwf->fd, mwf->size, offset);
 			if (w == NULL) {
-				git_mutex_unlock(&git__mwindow_mutex);
+				git_mutex_unlock(&git_mwindow__mutex);
 				return NULL;
 			}
 			w->next = mwf->windows;
@@ -444,7 +440,7 @@ unsigned char *git_mwindow_open(
 	if (left)
 		*left = (unsigned int)(w->window_map.len - offset);
 
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	return (unsigned char *) w->window_map.data + offset;
 }
 
@@ -456,14 +452,14 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	size_t i;
 	git_mwindow_file *closed_file = NULL;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
 	if (ctl->windowfiles.length == 0 &&
 	    (error = git_vector_init(&ctl->windowfiles, 8, NULL)) < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		goto cleanup;
 	}
 
@@ -473,7 +469,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;
@@ -483,7 +479,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	}
 
 	error = git_vector_insert(&ctl->windowfiles, mwf);
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	if (error < 0)
 		goto cleanup;
 
@@ -502,7 +498,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	}
 
 cleanup:
-	git_vector_free(&closed_files);
+	git_vector_dispose(&closed_files);
 	return error;
 }
 
@@ -512,30 +508,30 @@ void git_mwindow_file_deregister(git_mwindow_file *mwf)
 	git_mwindow_file *cur;
 	size_t i;
 
-	if (git_mutex_lock(&git__mwindow_mutex))
+	if (git_mutex_lock(&git_mwindow__mutex))
 		return;
 
 	git_vector_foreach(&ctl->windowfiles, i, cur) {
 		if (cur == mwf) {
 			git_vector_remove(&ctl->windowfiles, i);
-			git_mutex_unlock(&git__mwindow_mutex);
+			git_mutex_unlock(&git_mwindow__mutex);
 			return;
 		}
 	}
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 }
 
 void git_mwindow_close(git_mwindow **window)
 {
 	git_mwindow *w = *window;
 	if (w) {
-		if (git_mutex_lock(&git__mwindow_mutex)) {
+		if (git_mutex_lock(&git_mwindow__mutex)) {
 			git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 			return;
 		}
 
 		w->inuse_cnt--;
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		*window = NULL;
 	}
 }

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

@@ -12,6 +12,10 @@
 
 #include "map.h"
 #include "vector.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_STRUCT(git_mwindow_packmap, struct git_pack_file *);
+GIT_HASHMAP_STR_PROTOTYPES(git_mwindow_packmap, struct git_pack_file *);
 
 typedef struct git_mwindow {
 	struct git_mwindow *next;
@@ -38,7 +42,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 +52,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/{notes.c → libgit2/notes.c}

@@ -7,7 +7,7 @@
 
 #include "notes.h"
 
-#include "git2.h"
+#include "buf.h"
 #include "refs.h"
 #include "config.h"
 #include "iterator.h"
@@ -407,7 +407,7 @@ cleanup:
 	return error;
 }
 
-static int note_get_default_ref(git_buf *out, git_repository *repo)
+static int note_get_default_ref(git_str *out, git_repository *repo)
 {
 	git_config *cfg;
 	int error;
@@ -415,25 +415,25 @@ static int note_get_default_ref(git_buf *out, git_repository *repo)
 	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 		return error;
 
-	error = git_config_get_string_buf(out, cfg, "core.notesref");
+	error = git_config__get_string_buf(out, cfg, "core.notesref");
 
 	if (error == GIT_ENOTFOUND)
-		error = git_buf_puts(out, GIT_NOTES_DEFAULT_REF);
+		error = git_str_puts(out, GIT_NOTES_DEFAULT_REF);
 
 	return error;
 }
 
-static int normalize_namespace(git_buf *out, git_repository *repo, const char *notes_ref)
+static int normalize_namespace(git_str *out, git_repository *repo, const char *notes_ref)
 {
 	if (notes_ref)
-		return git_buf_puts(out, notes_ref);
+		return git_str_puts(out, notes_ref);
 
 	return note_get_default_ref(out, repo);
 }
 
 static int retrieve_note_commit(
 	git_commit **commit_out,
-	git_buf *notes_ref_out,
+	git_str *notes_ref_out,
 	git_repository *repo,
 	const char *notes_ref)
 {
@@ -460,7 +460,7 @@ int git_note_commit_read(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -478,7 +478,7 @@ int git_note_read(git_note **out, git_repository *repo,
 		  const char *notes_ref_in, const git_oid *oid)
 {
 	int error;
-	git_buf notes_ref = GIT_BUF_INIT;
+	git_str notes_ref = GIT_STR_INIT;
 	git_commit *commit = NULL;
 
 	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
@@ -489,7 +489,7 @@ int git_note_read(git_note **out, git_repository *repo,
 	error = git_note_commit_read(out, repo, commit, oid);
 
 cleanup:
-	git_buf_dispose(&notes_ref);
+	git_str_dispose(&notes_ref);
 	git_commit_free(commit);
 	return error;
 }
@@ -507,7 +507,7 @@ int git_note_commit_create(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -536,7 +536,7 @@ int git_note_create(
 	int allow_note_overwrite)
 {
 	int error;
-	git_buf notes_ref = GIT_BUF_INIT;
+	git_str notes_ref = GIT_STR_INIT;
 	git_commit *existing_notes_commit = NULL;
 	git_reference *ref = NULL;
 	git_oid notes_blob_oid, notes_commit_oid;
@@ -562,7 +562,7 @@ int git_note_create(
 		git_oid_cpy(out, &notes_blob_oid);
 
 cleanup:
-	git_buf_dispose(&notes_ref);
+	git_str_dispose(&notes_ref);
 	git_commit_free(existing_notes_commit);
 	git_reference_free(ref);
 	return error;
@@ -578,7 +578,7 @@ int git_note_commit_remove(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -598,7 +598,7 @@ int git_note_remove(git_repository *repo, const char *notes_ref_in,
 		const git_oid *oid)
 {
 	int error;
-	git_buf notes_ref_target = GIT_BUF_INIT;
+	git_str notes_ref_target = GIT_STR_INIT;
 	git_commit *existing_notes_commit = NULL;
 	git_oid new_notes_commit;
 	git_reference *notes_ref = NULL;
@@ -618,7 +618,7 @@ int git_note_remove(git_repository *repo, const char *notes_ref_in,
 			&new_notes_commit, 1, NULL);
 
 cleanup:
-	git_buf_dispose(&notes_ref_target);
+	git_str_dispose(&notes_ref_target);
 	git_reference_free(notes_ref);
 	git_commit_free(existing_notes_commit);
 	return error;
@@ -626,16 +626,7 @@ cleanup:
 
 int git_note_default_ref(git_buf *out, git_repository *repo)
 {
-	int error;
-
-	GIT_ASSERT_ARG(out);
-	GIT_ASSERT_ARG(repo);
-
-	if ((error = git_buf_sanitize(out)) < 0 ||
-	    (error = note_get_default_ref(out, repo)) < 0)
-		git_buf_dispose(out);
-
-	return error;
+	GIT_BUF_WRAP_PRIVATE(out, note_get_default_ref, repo);
 }
 
 const git_signature *git_note_committer(const git_note *note)
@@ -674,17 +665,18 @@ void git_note_free(git_note *note)
 }
 
 static int process_entry_path(
-	const char *entry_path,
-	git_oid *annotated_object_id)
+	git_oid *annotated_object_id,
+	git_note_iterator *it,
+	const char *entry_path)
 {
 	int error = 0;
 	size_t i = 0, j = 0, len;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
-	if ((error = git_buf_puts(&buf, entry_path)) < 0)
+	if ((error = git_str_puts(&buf, entry_path)) < 0)
 		goto cleanup;
 
-	len = git_buf_len(&buf);
+	len = git_str_len(&buf);
 
 	while (i < len) {
 		if (buf.ptr[i] == '/') {
@@ -707,15 +699,15 @@ static int process_entry_path(
 	buf.ptr[j] = '\0';
 	buf.size = j;
 
-	if (j != GIT_OID_HEXSZ) {
+	if (j != git_oid_hexsize(it->repo->oid_type)) {
 		/* This is not a note entry */
 		goto cleanup;
 	}
 
-	error = git_oid_fromstr(annotated_object_id, buf.ptr);
+	error = git_oid__fromstr(annotated_object_id, buf.ptr, it->repo->oid_type);
 
 cleanup:
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	return error;
 }
 
@@ -780,7 +772,7 @@ int git_note_iterator_new(
 {
 	int error;
 	git_commit *commit = NULL;
-	git_buf notes_ref = GIT_BUF_INIT;
+	git_str notes_ref = GIT_STR_INIT;
 
 	error = retrieve_note_commit(&commit, &notes_ref, repo, notes_ref_in);
 	if (error < 0)
@@ -789,7 +781,7 @@ int git_note_iterator_new(
 	error = git_note_commit_iterator_new(it, commit);
 
 cleanup:
-	git_buf_dispose(&notes_ref);
+	git_str_dispose(&notes_ref);
 	git_commit_free(commit);
 
 	return error;
@@ -808,7 +800,7 @@ int git_note_next(
 
 	git_oid_cpy(note_id, &item->id);
 
-	if ((error = process_entry_path(item->path, annotated_id)) < 0)
+	if ((error = process_entry_path(annotated_id, it, item->path)) < 0)
 		return error;
 
 	if ((error = git_iterator_advance(NULL, it)) < 0 && error != GIT_ITEROVER)