rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/transports/ssh_libssh2.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_transports_libssh2_h__
+#define INCLUDE_transports_libssh2_h__
+
+#include "common.h"
+
+#include "git2.h"
+#include "git2/transport.h"
+#include "git2/sys/transport.h"
+
+int git_transport_ssh_libssh2_global_init(void);
+
+int git_smart_subtransport_ssh_libssh2(
+	git_smart_subtransport **out,
+	git_transport *owner,
+	void *param);
+
+int git_smart_subtransport_ssh_libssh2_set_paths(
+	git_smart_subtransport *subtransport,
+	const char *cmd_uploadpack,
+	const char *cmd_receivepack);
+
+#endif

data/vendor/libgit2/src/libgit2/transports/winhttp.c

@@ -13,7 +13,6 @@
 #include "git2/transport.h"
 #include "posix.h"
 #include "str.h"
-#include "netops.h"
 #include "smart.h"
 #include "remote.h"
 #include "repository.h"
@@ -158,10 +157,10 @@ static int apply_userpass_credentials(HINTERNET request, DWORD target, int mecha
 		goto done;
 	}
 
-	if ((error = user_len = git__utf8_to_16_alloc(&user, c->username)) < 0)
+	if ((error = user_len = git_utf8_to_16_alloc(&user, c->username)) < 0)
 		goto done;
 
-	if ((error = pass_len = git__utf8_to_16_alloc(&pass, c->password)) < 0)
+	if ((error = pass_len = git_utf8_to_16_alloc(&pass, c->password)) < 0)
 		goto done;
 
 	if (!WinHttpSetCredentials(request, target, native_scheme, user, pass, NULL)) {
@@ -242,7 +241,7 @@ static int acquire_fallback_cred(
 		HRESULT hCoInitResult;
 
 		/* Convert URL to wide characters */
-		if (git__utf8_to_16_alloc(&wide_url, url) < 0) {
+		if (git_utf8_to_16_alloc(&wide_url, url) < 0) {
 			git_error_set(GIT_ERROR_OS, "failed to convert string to wide form");
 			return -1;
 		}
@@ -294,7 +293,7 @@ static int certificate_check(winhttp_stream *s, int valid)
 
 	/* If there is no override, we should fail if WinHTTP doesn't think it's fine */
 	if (t->owner->connect_opts.callbacks.certificate_check == NULL && !valid) {
-		if (!git_error_last())
+		if (git_error_last()->klass == GIT_ERROR_NONE)
 			git_error_set(GIT_ERROR_HTTP, "unknown certificate check failure");
 
 		return GIT_ECERTIFICATE;
@@ -318,7 +317,7 @@ static int certificate_check(winhttp_stream *s, int valid)
 	if (error == GIT_PASSTHROUGH)
 		error = valid ? 0 : GIT_ECERTIFICATE;
 
-	if (error < 0 && !git_error_last())
+	if (error < 0 && git_error_last()->klass == GIT_ERROR_NONE)
 		git_error_set(GIT_ERROR_HTTP, "user cancelled certificate check");
 
 	return error;
@@ -397,7 +396,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		return -1;
 
 	/* Convert URL to wide characters */
-	if (git__utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) {
+	if (git_utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to convert string to wide form");
 		goto on_error;
 	}
@@ -437,17 +436,17 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		GIT_ERROR_CHECK_ALLOC(proxy_url);
 	}
 
-	if (proxy_url) {
+	if (proxy_url && *proxy_url) {
 		git_str processed_url = GIT_STR_INIT;
 		WINHTTP_PROXY_INFO proxy_info;
 		wchar_t *proxy_wide;
 
 		git_net_url_dispose(&t->proxy.url);
 
-		if ((error = git_net_url_parse(&t->proxy.url, proxy_url)) < 0)
+		if ((error = git_net_url_parse_http(&t->proxy.url, proxy_url)) < 0)
 			goto on_error;
 
-		if (strcmp(t->proxy.url.scheme, "http") != 0 && strcmp(t->proxy.url.scheme, "https") != 0) {
+		if (!git_net_url_valid(&t->proxy.url)) {
 			git_error_set(GIT_ERROR_HTTP, "invalid URL: '%s'", proxy_url);
 			error = -1;
 			goto on_error;
@@ -473,7 +472,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		}
 
 		/* Convert URL to wide characters */
-		error = git__utf8_to_16_alloc(&proxy_wide, processed_url.ptr);
+		error = git_utf8_to_16_alloc(&proxy_wide, processed_url.ptr);
 		git_str_dispose(&processed_url);
 		if (error < 0)
 			goto on_error;
@@ -531,7 +530,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 			s->service) < 0)
 			goto on_error;
 
-		if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
+		if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
 			git_error_set(GIT_ERROR_OS, "failed to convert content-type to wide characters");
 			goto on_error;
 		}
@@ -548,7 +547,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 			s->service) < 0)
 			goto on_error;
 
-		if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
+		if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
 			git_error_set(GIT_ERROR_OS, "failed to convert accept header to wide characters");
 			goto on_error;
 		}
@@ -568,7 +567,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 			git_str_puts(&buf, t->owner->connect_opts.custom_headers.strings[i]);
 
 			/* Convert header to wide characters */
-			if ((error = git__utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0)
+			if ((error = git_utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0)
 				goto on_error;
 
 			if (!WinHttpAddRequestHeaders(s->request, custom_header_wide, (ULONG)-1L,
@@ -747,6 +746,33 @@ static void CALLBACK winhttp_status(
 	}
 }
 
+static int user_agent(bool *exists, git_str *out)
+{
+	const char *product = git_settings__user_agent_product();
+	const char *comment = git_settings__user_agent();
+
+	GIT_ASSERT(product && comment);
+
+	if (!*product) {
+		*exists = false;
+		return 0;
+	}
+
+	git_str_puts(out, product);
+
+	if (*comment) {
+		git_str_puts(out, " (");
+		git_str_puts(out, comment);
+		git_str_puts(out, ")");
+	}
+
+	if (git_str_oom(out))
+		return -1;
+
+	*exists = true;
+	return 0;
+}
+
 static int winhttp_connect(
 	winhttp_subtransport *t)
 {
@@ -758,6 +784,7 @@ static int winhttp_connect(
 	int error = -1;
 	int default_timeout = TIMEOUT_INFINITE;
 	int default_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
+	bool has_ua = true;
 	DWORD protocols =
 		WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 |
 		WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 |
@@ -783,16 +810,16 @@ static int winhttp_connect(
 	}
 
 	/* Prepare host */
-	if (git__utf8_to_16_alloc(&wide_host, host) < 0) {
+	if (git_utf8_to_16_alloc(&wide_host, host) < 0) {
 		git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters");
 		goto on_error;
 	}
 
-
-	if (git_http__user_agent(&ua) < 0)
+	if (user_agent(&has_ua, &ua) < 0)
 		goto on_error;
 
-	if (git__utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
+	if (has_ua &&
+	    git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
 		git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters");
 		goto on_error;
 	}
@@ -934,7 +961,7 @@ static int send_request(winhttp_stream *s, size_t len, bool chunked)
 			(!request_failed && s->status_sending_request_reached)) {
 			git_error_clear();
 			if ((error = certificate_check(s, cert_valid)) < 0) {
-				if (!git_error_last())
+				if (git_error_last()->klass == GIT_ERROR_NONE)
 					git_error_set(GIT_ERROR_OS, "user cancelled certificate check");
 
 				return error;
@@ -1182,7 +1209,7 @@ replay:
 			}
 
 			/* Convert the Location header to UTF-8 */
-			if (git__utf16_to_8_alloc(&location8, location) < 0) {
+			if (git_utf8_from_16_alloc(&location8, location) < 0) {
 				git_error_set(GIT_ERROR_OS, "failed to convert Location header to UTF-8");
 				git__free(location);
 				return -1;
@@ -1254,7 +1281,7 @@ replay:
 		else
 			p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service);
 
-		if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
+		if (git_utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
 			git_error_set(GIT_ERROR_OS, "failed to convert expected content-type to wide characters");
 			return -1;
 		}

data/vendor/libgit2/src/libgit2/tree-cache.c

@@ -71,12 +71,16 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char
 	}
 }
 
-static int read_tree_internal(git_tree_cache **out,
-			      const char **buffer_in, const char *buffer_end,
-			      git_pool *pool)
+static int read_tree_internal(
+	git_tree_cache **out,
+	const char **buffer_in,
+	const char *buffer_end,
+	git_oid_t oid_type,
+	git_pool *pool)
 {
 	git_tree_cache *tree = NULL;
 	const char *name_start, *buffer;
+	size_t oid_size = git_oid_size(oid_type);
 	int count;
 
 	buffer = name_start = *buffer_in;
@@ -87,7 +91,7 @@ static int read_tree_internal(git_tree_cache **out,
 	if (++buffer >= buffer_end)
 		goto corrupted;
 
-	if (git_tree_cache_new(&tree, name_start, pool) < 0)
+	if (git_tree_cache_new(&tree, name_start, oid_type, pool) < 0)
 		return -1;
 
 	/* Blank-terminated ASCII decimal number of entries in this tree */
@@ -108,14 +112,14 @@ static int read_tree_internal(git_tree_cache **out,
 	if (*buffer != '\n' || ++buffer > buffer_end)
 		goto corrupted;
 
-	/* The SHA1 is only there if it's not invalidated */
+	/* The OID is only there if it's not invalidated */
 	if (tree->entry_count >= 0) {
 		/* 160-bit SHA-1 for this tree and it's children */
-		if (buffer + GIT_OID_SHA1_SIZE > buffer_end)
+		if (buffer + oid_size > buffer_end)
 			goto corrupted;
 
-		git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, GIT_OID_SHA1);
-		buffer += GIT_OID_SHA1_SIZE;
+		git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, oid_type);
+		buffer += oid_size;
 	}
 
 	/* Parse children: */
@@ -130,7 +134,7 @@ static int read_tree_internal(git_tree_cache **out,
 		memset(tree->children, 0x0, bufsize);
 
 		for (i = 0; i < tree->children_count; ++i) {
-			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
+			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, oid_type, pool) < 0)
 				goto corrupted;
 		}
 	}
@@ -144,11 +148,16 @@ static int read_tree_internal(git_tree_cache **out,
 	return -1;
 }
 
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool)
+int git_tree_cache_read(
+	git_tree_cache **tree,
+	const char *buffer,
+	size_t buffer_size,
+	git_oid_t oid_type,
+	git_pool *pool)
 {
 	const char *buffer_end = buffer + buffer_size;
 
-	if (read_tree_internal(tree, &buffer, buffer_end, pool) < 0)
+	if (read_tree_internal(tree, &buffer, buffer_end, oid_type, pool) < 0)
 		return -1;
 
 	if (buffer < buffer_end) {
@@ -201,7 +210,7 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
 			continue;
 		}
 
-		if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0)
+		if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), cache->oid_type, pool)) < 0)
 			return error;
 
 		if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0)
@@ -219,12 +228,12 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
 	return 0;
 }
 
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool)
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool)
 {
 	int error;
 	git_tree_cache *cache;
 
-	if ((error = git_tree_cache_new(&cache, "", pool)) < 0)
+	if ((error = git_tree_cache_new(&cache, "", oid_type, pool)) < 0)
 		return error;
 
 	if ((error = read_tree_recursive(cache, tree, pool)) < 0)
@@ -234,7 +243,7 @@ int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_poo
 	return 0;
 }
 
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool)
 {
 	size_t name_len, alloc_size;
 	git_tree_cache *tree;
@@ -248,6 +257,7 @@ int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
 
 	memset(tree, 0x0, sizeof(git_tree_cache));
 	/* NUL-terminated tree name */
+	tree->oid_type = oid_type;
 	tree->namelen = name_len;
 	memcpy(tree->name, name, name_len);
 	tree->name[name_len] = '\0';
@@ -263,7 +273,7 @@ static void write_tree(git_str *out, git_tree_cache *tree)
 	git_str_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count);
 
 	if (tree->entry_count != -1)
-		git_str_put(out, (char *)&tree->oid.id, GIT_OID_SHA1_SIZE);
+		git_str_put(out, (char *)&tree->oid.id, git_oid_size(tree->oid_type));
 
 	for (i = 0; i < tree->children_count; i++)
 		write_tree(out, tree->children[i]);

data/vendor/libgit2/src/libgit2/tree-cache.h

@@ -18,6 +18,8 @@ typedef struct git_tree_cache {
 	struct git_tree_cache **children;
 	size_t children_count;
 
+	git_oid_t oid_type;
+
 	ssize_t entry_count;
 	git_oid oid;
 	size_t namelen;
@@ -25,14 +27,14 @@ typedef struct git_tree_cache {
 } git_tree_cache;
 
 int git_tree_cache_write(git_str *out, git_tree_cache *tree);
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool);
+int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_oid_t oid_type, git_pool *pool);
 void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path);
 const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path);
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool);
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool);
 /**
  * Read a tree as the root of the tree cache (like for `git read-tree`)
  */
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool);
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool);
 void git_tree_cache_free(git_tree_cache *tree);
 
 #endif

data/vendor/libgit2/src/libgit2/tree.c

@@ -21,6 +21,8 @@
 #define TREE_ENTRY_CHECK_NAMELEN(n) \
 	if (n > UINT16_MAX) { git_error_set(GIT_ERROR_INVALID, "tree entry path too long"); }
 
+GIT_HASHMAP_STR_FUNCTIONS(git_treebuilder_entrymap, GIT_HASHMAP_INLINE, git_tree_entry *);
+
 static bool valid_filemode(const int filemode)
 {
 	return (filemode == GIT_FILEMODE_TREE
@@ -347,7 +349,7 @@ size_t git_treebuilder_entrycount(git_treebuilder *bld)
 {
 	GIT_ASSERT_ARG_WITH_RETVAL(bld, 0);
 
-	return git_strmap_size(bld->map);
+	return git_treebuilder_entrymap_size(&bld->map);
 }
 
 GIT_INLINE(void) set_error(const char *str, const char *path)
@@ -381,7 +383,7 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len,
 	if ((error = git__strntol32(&mode, buffer, buffer_len, buffer_out, 8)) < 0)
 		return error;
 
-	if (mode < 0 || mode > UINT16_MAX)
+	if (mode < 0 || (uint32_t)mode > UINT16_MAX)
 		return -1;
 
 	*mode_out = mode;
@@ -512,10 +514,12 @@ static int git_treebuilder__write_with_buffer(
 	git_tree_entry *entry;
 	git_vector entries = GIT_VECTOR_INIT;
 	size_t oid_size = git_oid_size(bld->repo->oid_type);
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	git_str_clear(buf);
 
-	entrycount = git_strmap_size(bld->map);
+	entrycount = git_treebuilder_entrymap_size(&bld->map);
+
 	if ((error = git_vector_init(&entries, entrycount, entry_sort_cmp)) < 0)
 		goto out;
 
@@ -523,10 +527,10 @@ static int git_treebuilder__write_with_buffer(
 	    (error = git_str_grow(buf, entrycount * 72)) < 0)
 		goto out;
 
-	git_strmap_foreach_value(bld->map, entry, {
+	while (git_treebuilder_entrymap_iterate(&iter, NULL, &entry, &bld->map) == 0) {
 		if ((error = git_vector_insert(&entries, entry)) < 0)
 			goto out;
-	});
+	}
 
 	git_vector_sort(&entries);
 
@@ -547,7 +551,7 @@ static int git_treebuilder__write_with_buffer(
 		error = git_odb_write(oid, odb, buf->ptr, buf->size, GIT_OBJECT_TREE);
 
 out:
-	git_vector_free(&entries);
+	git_vector_dispose(&entries);
 
 	return error;
 }
@@ -570,7 +574,7 @@ static int append_entry(
 
 	entry->attr = (uint16_t)filemode;
 
-	if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+	if ((error = git_treebuilder_entrymap_put(&bld->map, entry->filename, entry)) < 0) {
 		git_tree_entry_free(entry);
 		git_error_set(GIT_ERROR_TREE, "failed to append entry %s to the tree builder", filename);
 		return -1;
@@ -731,7 +735,7 @@ int git_tree__write_index(
 		return ret;
 
 	/* Read the tree cache into the index */
-	ret = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
+	ret = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool);
 	git_tree_free(tree);
 
 	return ret;
@@ -753,11 +757,6 @@ int git_treebuilder_new(
 
 	bld->repo = repo;
 
-	if (git_strmap_new(&bld->map) < 0) {
-		git__free(bld);
-		return -1;
-	}
-
 	if (source != NULL) {
 		git_tree_entry *entry_src;
 
@@ -796,13 +795,13 @@ int git_treebuilder_insert(
 	if ((error = check_entry(bld->repo, filename, id, filemode)) < 0)
 		return error;
 
-	if ((entry = git_strmap_get(bld->map, filename)) != NULL) {
+	if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) == 0) {
 		git_oid_cpy(&entry->oid, id);
 	} else {
 		entry = alloc_entry(filename, strlen(filename), id);
 		GIT_ERROR_CHECK_ALLOC(entry);
 
-		if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+		if (git_treebuilder_entrymap_put(&bld->map, entry->filename, entry) < 0) {
 			git_tree_entry_free(entry);
 			git_error_set(GIT_ERROR_TREE, "failed to insert %s", filename);
 			return -1;
@@ -819,10 +818,15 @@ int git_treebuilder_insert(
 
 static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename)
 {
+	git_tree_entry *entry;
+
 	GIT_ASSERT_ARG_WITH_RETVAL(bld, NULL);
 	GIT_ASSERT_ARG_WITH_RETVAL(filename, NULL);
 
-	return git_strmap_get(bld->map, filename);
+	if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) != 0)
+		return NULL;
+
+	return entry;
 }
 
 const git_tree_entry *git_treebuilder_get(git_treebuilder *bld, const char *filename)
@@ -837,7 +841,7 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename)
 	if (entry == NULL)
 		return tree_error("failed to remove entry: file isn't in the tree", filename);
 
-	git_strmap_delete(bld->map, filename);
+	git_treebuilder_entrymap_remove(&bld->map, filename);
 	git_tree_entry_free(entry);
 
 	return 0;
@@ -858,16 +862,17 @@ int git_treebuilder_filter(
 {
 	const char *filename;
 	git_tree_entry *entry;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	GIT_ASSERT_ARG(bld);
 	GIT_ASSERT_ARG(filter);
 
-	git_strmap_foreach(bld->map, filename, entry, {
-			if (filter(entry, payload)) {
-				git_strmap_delete(bld->map, filename);
-				git_tree_entry_free(entry);
-			}
-	});
+	while (git_treebuilder_entrymap_iterate(&iter, &filename, &entry, &bld->map) == 0) {
+		if (filter(entry, payload)) {
+			git_treebuilder_entrymap_remove(&bld->map, filename);
+			git_tree_entry_free(entry);
+		}
+	}
 
 	return 0;
 }
@@ -875,11 +880,14 @@ int git_treebuilder_filter(
 int git_treebuilder_clear(git_treebuilder *bld)
 {
 	git_tree_entry *e;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	GIT_ASSERT_ARG(bld);
 
-	git_strmap_foreach_value(bld->map, e, git_tree_entry_free(e));
-	git_strmap_clear(bld->map);
+	while (git_treebuilder_entrymap_iterate(&iter, NULL, &e, &bld->map) == 0)
+		git_tree_entry_free(e);
+
+	git_treebuilder_entrymap_clear(&bld->map);
 
 	return 0;
 }
@@ -891,7 +899,7 @@ void git_treebuilder_free(git_treebuilder *bld)
 
 	git_str_dispose(&bld->write_cache);
 	git_treebuilder_clear(bld);
-	git_strmap_free(bld->map);
+	git_treebuilder_entrymap_dispose(&bld->map);
 	git__free(bld);
 }
 
@@ -1312,7 +1320,7 @@ cleanup:
 
 	git_str_dispose(&component);
 	git_array_clear(stack);
-	git_vector_free(&entries);
+	git_vector_dispose(&entries);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/tree.h

@@ -13,7 +13,6 @@
 #include "repository.h"
 #include "odb.h"
 #include "vector.h"
-#include "strmap.h"
 #include "pool.h"
 
 struct git_tree_entry {
@@ -29,9 +28,11 @@ struct git_tree {
 	git_array_t(git_tree_entry) entries;
 };
 
+GIT_HASHMAP_STR_STRUCT(git_treebuilder_entrymap, git_tree_entry *);
+
 struct git_treebuilder {
 	git_repository *repo;
-	git_strmap *map;
+	git_treebuilder_entrymap map;
 	git_str write_cache;
 };
 

data/vendor/libgit2/src/libgit2/worktree.c

@@ -335,11 +335,21 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
 			goto out;
 		}
 
-		if (git_branch_is_checked_out(wtopts.ref)) {
-			git_error_set(GIT_ERROR_WORKTREE, "reference is already checked out");
-			err = -1;
+		if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
 			goto out;
-		}
+	} else if (wtopts.checkout_existing && git_branch_lookup(&ref, repo, name, GIT_BRANCH_LOCAL) == 0) {
+		/* Do nothing */
+	} else if ((err = git_repository_head(&head, repo)) < 0 ||
+		   (err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0 ||
+		   (err = git_branch_create(&ref, repo, name, commit, false)) < 0) {
+			goto out;
+	}
+
+	if (git_branch_is_checked_out(ref)) {
+		git_error_set(GIT_ERROR_WORKTREE, "reference %s is already checked out",
+			      git_reference_name(ref));
+		err = -1;
+		goto out;
 	}
 
 	/* Create gitdir directory ".git/worktrees/<name>" */
@@ -392,19 +402,6 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
 	    || (err = write_wtfile(gitdir.ptr, "gitdir", &buf)) < 0)
 		goto out;
 
-	/* Set up worktree reference */
-	if (wtopts.ref) {
-		if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
-			goto out;
-	} else {
-		if ((err = git_repository_head(&head, repo)) < 0)
-			goto out;
-		if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0)
-			goto out;
-		if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0)
-			goto out;
-	}
-
 	/* Set worktree's HEAD */
 	if ((err = git_repository_create_head(gitdir.ptr, git_reference_name(ref))) < 0)
 		goto out;
@@ -565,6 +562,8 @@ int git_worktree_is_prunable(git_worktree *wt,
 	git_worktree_prune_options *opts)
 {
 	git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT;
+	git_str path = GIT_STR_INIT;
+	int ret = 0;
 
 	GIT_ERROR_CHECK_VERSION(
 		opts, GIT_WORKTREE_PRUNE_OPTIONS_VERSION,
@@ -575,27 +574,40 @@ int git_worktree_is_prunable(git_worktree *wt,
 
 	if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) {
 		git_str reason = GIT_STR_INIT;
-		int error;
 
-		if ((error = git_worktree__is_locked(&reason, wt)) < 0)
-			return error;
+		if ((ret = git_worktree__is_locked(&reason, wt)) < 0)
+			goto out;
+
+		if (ret) {
+			git_error_set(GIT_ERROR_WORKTREE,
+				"not pruning locked working tree: '%s'",
+				reason.size ?  reason.ptr : "is locked");
 
-		if (error) {
-			if (!reason.size)
-				git_str_attach_notowned(&reason, "no reason given", 15);
-			git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr);
 			git_str_dispose(&reason);
-			return 0;
+			ret = 0;
+			goto out;
 		}
 	}
 
 	if ((popts.flags & GIT_WORKTREE_PRUNE_VALID) == 0 &&
 	    git_worktree_validate(wt) == 0) {
 		git_error_set(GIT_ERROR_WORKTREE, "not pruning valid working tree");
-		return 0;
+		goto out;
+	}
+
+	if ((ret = git_str_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0))
+		goto out;
+
+	if (!git_fs_path_exists(path.ptr)) {
+		git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir ('%s') does not exist", path.ptr);
+		goto out;
 	}
 
-	return 1;
+	ret = 1;
+
+out:
+	git_str_dispose(&path);
+	return ret;
 }
 
 int git_worktree_prune(git_worktree *wt,