rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/{allocators/stdalloc.c → stdalloc.c}

@@ -88,10 +88,11 @@ static void *stdalloc__reallocarray(void *ptr, size_t nelem, size_t elsize, cons
 {
 	size_t newsize;
 
-	if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
-		return NULL;
+	GIT_UNUSED(file);
+	GIT_UNUSED(line);
 
-	return stdalloc__realloc(ptr, newsize, file, line);
+	return GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize) ?
+		NULL : realloc(ptr, newsize);
 }
 
 static void *stdalloc__mallocarray(size_t nelem, size_t elsize, const char *file, int line)

data/vendor/libgit2/src/{allocators/stdalloc.h → stdalloc.h}

@@ -5,13 +5,13 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifndef INCLUDE_allocators_stdalloc_h__
-#define INCLUDE_allocators_stdalloc_h__
-
-#include "common.h"
+#ifndef INCLUDE_stdalloc_h__
+#define INCLUDE_stdalloc_h__
 
 #include "alloc.h"
 
+#include "common.h"
+
 int git_stdalloc_init_allocator(git_allocator *allocator);
 
 #endif

data/vendor/libgit2/src/streams/openssl.c

@@ -30,10 +30,6 @@
 #include <openssl/x509v3.h>
 #include <openssl/bio.h>
 
-#ifdef VALGRIND
-# include <valgrind/memcheck.h>
-#endif
-
 SSL_CTX *git__ssl_ctx;
 
 #define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
@@ -315,10 +311,6 @@ static int bio_write(BIO *b, const char *buf, int len)
 {
 	git_stream *io = (git_stream *) BIO_get_data(b);
 
-#ifdef VALGRIND
-	VALGRIND_MAKE_MEM_DEFINED(buf, len);
-#endif
-
 	return (int) git_stream_write(io, buf, len, 0);
 }
 
@@ -595,10 +587,6 @@ static int openssl_connect(git_stream *stream)
 	BIO_set_data(bio, st->io);
 	SSL_set_bio(st->ssl, bio, bio);
 
-#ifdef VALGRIND
-	VALGRIND_MAKE_MEM_DEFINED(st->ssl, sizeof(SSL));
-#endif
-
 	/* specify the host in case SNI is needed */
 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
 	SSL_set_tlsext_host_name(st->ssl, st->host);
@@ -609,10 +597,6 @@ static int openssl_connect(git_stream *stream)
 
 	st->connected = true;
 
-#ifdef VALGRIND
-	VALGRIND_MAKE_MEM_DEFINED(st->ssl, sizeof(SSL));
-#endif
-
 	return verify_server_cert(st->ssl, st->host);
 }
 
@@ -679,10 +663,6 @@ static ssize_t openssl_read(git_stream *stream, void *data, size_t len)
 	if ((ret = SSL_read(st->ssl, data, len)) <= 0)
 		return ssl_set_error(st->ssl, ret);
 
-#ifdef VALGRIND
-	VALGRIND_MAKE_MEM_DEFINED(data, ret);
-#endif
-
 	return ret;
 }
 

data/vendor/libgit2/src/streams/socket.c

@@ -138,7 +138,7 @@ static ssize_t socket_write(git_stream *stream, const char *data, size_t len, in
 	errno = 0;
 
 	if ((written = p_send(st->s, data, len, flags)) < 0) {
-		net_set_error("error sending data");
+		net_set_error("Error sending data");
 		return -1;
 	}
 
@@ -151,7 +151,7 @@ static ssize_t socket_read(git_stream *stream, void *data, size_t len)
 	git_socket_stream *st = (git_socket_stream *) stream;
 
 	if ((ret = p_recv(st->s, data, len, 0)) < 0)
-		net_set_error("error receiving socket data");
+		net_set_error("Error receiving socket data");
 
 	return ret;
 }

data/vendor/libgit2/src/strmap.c

@@ -18,10 +18,12 @@ __KHASH_TYPE(str, const char *, void *)
 
 __KHASH_IMPL(str, static kh_inline, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal)
 
-int git_strmap_new(git_strmap **out)
+int git_strmap_alloc(git_strmap **map)
 {
-	*out = kh_init(str);
-	GIT_ERROR_CHECK_ALLOC(*out);
+	if ((*map = kh_init(str)) == NULL) {
+		git_error_set_oom();
+		return -1;
+	}
 
 	return 0;
 }
@@ -36,65 +38,110 @@ void git_strmap_clear(git_strmap *map)
 	kh_clear(str, map);
 }
 
-size_t git_strmap_size(git_strmap *map)
+size_t git_strmap_num_entries(git_strmap *map)
 {
 	return kh_size(map);
 }
 
-void *git_strmap_get(git_strmap *map, const char *key)
+size_t git_strmap_lookup_index(git_strmap *map, const char *key)
 {
-	size_t idx = kh_get(str, map, key);
-	if (idx == kh_end(map) || !kh_exist(map, idx))
-		return NULL;
-	return kh_val(map, idx);
+	return kh_get(str, map, key);
 }
 
-int git_strmap_set(git_strmap *map, const char *key, void *value)
+int git_strmap_valid_index(git_strmap *map, size_t idx)
 {
-	size_t idx;
-	int rval;
+	return idx != kh_end(map);
+}
 
-	idx = kh_put(str, map, key, &rval);
-	if (rval < 0)
-		return -1;
+int git_strmap_exists(git_strmap *map, const char *key)
+{
+	return kh_get(str, map, key) != kh_end(map);
+}
+
+int git_strmap_has_data(git_strmap *map, size_t idx)
+{
+	return kh_exist(map, idx);
+}
 
-	if (rval == 0)
-		kh_key(map, idx) = key;
+const char *git_strmap_key(git_strmap *map, size_t idx)
+{
+	return kh_key(map, idx);
+}
 
-	kh_val(map, idx) = value;
+void git_strmap_set_key_at(git_strmap *map, size_t idx, char *key)
+{
+	kh_val(map, idx) = key;
+}
 
-	return 0;
+void *git_strmap_value_at(git_strmap *map, size_t idx)
+{
+	return kh_val(map, idx);
+}
+
+void git_strmap_set_value_at(git_strmap *map, size_t idx, void *value)
+{
+	kh_val(map, idx) = value;
 }
 
-int git_strmap_delete(git_strmap *map, const char *key)
+void git_strmap_delete_at(git_strmap *map, size_t idx)
 {
-	khiter_t idx = kh_get(str, map, key);
-	if (idx == kh_end(map))
-		return GIT_ENOTFOUND;
 	kh_del(str, map, idx);
+}
+
+int git_strmap_put(git_strmap *map, const char *key, int *err)
+{
+	return kh_put(str, map, key, err);
+}
+
+void git_strmap_insert(git_strmap *map, const char *key, void *value, int *rval)
+{
+	khiter_t idx = kh_put(str, map, key, rval);
+
+	if ((*rval) >= 0) {
+		if ((*rval) == 0)
+			kh_key(map, idx) = key;
+		kh_val(map, idx) = value;
+	}
+}
+
+void git_strmap_delete(git_strmap *map, const char *key)
+{
+	khiter_t idx = git_strmap_lookup_index(map, key);
+	if (git_strmap_valid_index(map, idx))
+		git_strmap_delete_at(map, idx);
+}
+
+size_t git_strmap_begin(git_strmap *map)
+{
+	GIT_UNUSED(map);
 	return 0;
 }
 
-int git_strmap_exists(git_strmap *map, const char *key)
+size_t git_strmap_end(git_strmap *map)
 {
-	return kh_get(str, map, key) != kh_end(map);
+	return map->n_buckets;
 }
 
-int git_strmap_iterate(void **value, git_strmap *map, size_t *iter, const char **key)
+int git_strmap_next(
+	void **data,
+	size_t* iter,
+	git_strmap *map)
 {
-	size_t i = *iter;
+	if (!map)
+		return GIT_ERROR;
 
-	while (i < map->n_buckets && !kh_exist(map, i))
-		i++;
+	while (*iter != git_strmap_end(map)) {
+		if (!(git_strmap_has_data(map, *iter))) {
+			++(*iter);
+			continue;
+		}
 
-	if (i >= map->n_buckets)
-		return GIT_ITEROVER;
+		*data = git_strmap_value_at(map, *iter);
 
-	if (key)
-		*key = kh_key(map, i);
-	if (value)
-		*value = kh_val(map, i);
-	*iter = ++i;
+		++(*iter);
 
-	return 0;
+		return GIT_OK;
+	}
+
+	return GIT_ITEROVER;
 }

data/vendor/libgit2/src/strmap.h

@@ -9,123 +9,51 @@
 
 #include "common.h"
 
-/** A map with C strings as key. */
 typedef struct kh_str_s git_strmap;
 
-/**
- * Allocate a new string map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_strmap_new(git_strmap **out);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free keys or values added
- * to this map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- *            `NULL`.
- */
+int git_strmap_alloc(git_strmap **map);
 void git_strmap_free(git_strmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- *            `NULL`.
- */
 void git_strmap_clear(git_strmap *map);
 
-/**
- * Return the number of elements in the map.
- *
- * @parameter map map containing the elements
- * @return number of elements in the map
- */
-size_t git_strmap_size(git_strmap *map);
+size_t git_strmap_num_entries(git_strmap *map);
 
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_strmap_get(git_strmap *map, const char *key);
+size_t git_strmap_lookup_index(git_strmap *map, const char *key);
+int git_strmap_valid_index(git_strmap *map, size_t idx);
 
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- *         code otherwise
- */
-int git_strmap_set(git_strmap *map, const char *key, void *value);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- *         such key was found, a negative code in case of an
- *         error
- */
-int git_strmap_delete(git_strmap *map, const char *key);
-
-/**
- * Check whether a key exists in the given map.
- *
- * @param map map to query for the key
- * @param key key to search for
- * @return 0 if the key has not been found, 1 otherwise
- */
 int git_strmap_exists(git_strmap *map, const char *key);
-
-/**
- * Iterate over entries of the map.
- *
- * This functions allows to iterate over all key-value entries of
- * the map. The current position is stored in the `iter` variable
- * and should be initialized to `0` before the first call to this
- * function.
- *
- * @param map map to iterate over
- * @param value pointer to the variable where to store the current
- *            value. May be NULL.
- * @param iter iterator storing the current position. Initialize
- *             with zero previous to the first call.
- * @param key pointer to the variable where to store the current
- *            key. May be NULL.
- * @return `0` if the next entry was correctly retrieved.
- *        GIT_ITEROVER if no entries are left. A negative error
- *        code otherwise.
- */
-int git_strmap_iterate(void **value, git_strmap *map, size_t *iter, const char **key);
-
-#define git_strmap_foreach(h, kvar, vvar, code) { size_t __i = 0;		\
-	while (git_strmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) {	\
+int git_strmap_has_data(git_strmap *map, size_t idx);
+
+const char *git_strmap_key(git_strmap *map, size_t idx);
+void git_strmap_set_key_at(git_strmap *map, size_t idx, char *key);
+void *git_strmap_value_at(git_strmap *map, size_t idx);
+void git_strmap_set_value_at(git_strmap *map, size_t idx, void *value);
+void git_strmap_delete_at(git_strmap *map, size_t idx);
+
+int git_strmap_put(git_strmap *map, const char *key, int *err);
+void git_strmap_insert(git_strmap *map, const char *key, void *value, int *rval);
+void git_strmap_delete(git_strmap *map, const char *key);
+
+#define git_strmap_foreach(h, kvar, vvar, code) { size_t __i;			\
+	for (__i = git_strmap_begin(h); __i != git_strmap_end(h); ++__i) {	\
+		if (!git_strmap_has_data(h,__i)) continue;			\
+		(kvar) = git_strmap_key(h,__i);					\
+		(vvar) = git_strmap_value_at(h,__i);				\
 		code;								\
 	} }
 
-#define git_strmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
-	while (git_strmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
+#define git_strmap_foreach_value(h, vvar, code) { size_t __i;			\
+	for (__i = git_strmap_begin(h); __i != git_strmap_end(h); ++__i) {	\
+		if (!git_strmap_has_data(h,__i)) continue;			\
+		(vvar) = git_strmap_value_at(h,__i);				\
 		code;								\
 	} }
 
+size_t git_strmap_begin(git_strmap *map);
+size_t git_strmap_end(git_strmap *map);
+
+int git_strmap_next(
+	void **data,
+	size_t *iter,
+	git_strmap *map);
+
 #endif

data/vendor/libgit2/src/submodule.c

@@ -23,32 +23,31 @@
 #include "path.h"
 #include "index.h"
 #include "worktree.h"
-#include "clone.h"
 
 #define GIT_MODULES_FILE ".gitmodules"
 
-static git_configmap _sm_update_map[] = {
-	{GIT_CONFIGMAP_STRING, "checkout", GIT_SUBMODULE_UPDATE_CHECKOUT},
-	{GIT_CONFIGMAP_STRING, "rebase", GIT_SUBMODULE_UPDATE_REBASE},
-	{GIT_CONFIGMAP_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE},
-	{GIT_CONFIGMAP_STRING, "none", GIT_SUBMODULE_UPDATE_NONE},
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_SUBMODULE_UPDATE_NONE},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_SUBMODULE_UPDATE_CHECKOUT},
+static git_cvar_map _sm_update_map[] = {
+	{GIT_CVAR_STRING, "checkout", GIT_SUBMODULE_UPDATE_CHECKOUT},
+	{GIT_CVAR_STRING, "rebase", GIT_SUBMODULE_UPDATE_REBASE},
+	{GIT_CVAR_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE},
+	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_UPDATE_NONE},
+	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_UPDATE_NONE},
+	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_UPDATE_CHECKOUT},
 };
 
-static git_configmap _sm_ignore_map[] = {
-	{GIT_CONFIGMAP_STRING, "none", GIT_SUBMODULE_IGNORE_NONE},
-	{GIT_CONFIGMAP_STRING, "untracked", GIT_SUBMODULE_IGNORE_UNTRACKED},
-	{GIT_CONFIGMAP_STRING, "dirty", GIT_SUBMODULE_IGNORE_DIRTY},
-	{GIT_CONFIGMAP_STRING, "all", GIT_SUBMODULE_IGNORE_ALL},
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_SUBMODULE_IGNORE_NONE},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_SUBMODULE_IGNORE_ALL},
+static git_cvar_map _sm_ignore_map[] = {
+	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_IGNORE_NONE},
+	{GIT_CVAR_STRING, "untracked", GIT_SUBMODULE_IGNORE_UNTRACKED},
+	{GIT_CVAR_STRING, "dirty", GIT_SUBMODULE_IGNORE_DIRTY},
+	{GIT_CVAR_STRING, "all", GIT_SUBMODULE_IGNORE_ALL},
+	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_IGNORE_NONE},
+	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_IGNORE_ALL},
 };
 
-static git_configmap _sm_recurse_map[] = {
-	{GIT_CONFIGMAP_STRING, "on-demand", GIT_SUBMODULE_RECURSE_ONDEMAND},
-	{GIT_CONFIGMAP_FALSE, NULL, GIT_SUBMODULE_RECURSE_NO},
-	{GIT_CONFIGMAP_TRUE, NULL, GIT_SUBMODULE_RECURSE_YES},
+static git_cvar_map _sm_recurse_map[] = {
+	{GIT_CVAR_STRING, "on-demand", GIT_SUBMODULE_RECURSE_ONDEMAND},
+	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_RECURSE_NO},
+	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_RECURSE_YES},
 };
 
 enum {
@@ -198,11 +197,12 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 	git_config_entry *entry;
 	git_buf buf = GIT_BUF_INIT;
 	git_strmap *names;
-	int isvalid, error;
+	int rval, isvalid;
+	int error = 0;
 
 	*out = NULL;
 
-	if ((error = git_strmap_new(&names)) < 0)
+	if ((error = git_strmap_alloc(&names)) < 0)
 		goto out;
 
 	if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
@@ -230,7 +230,8 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 		if (!isvalid)
 			continue;
 
-		if ((error = git_strmap_set(names, git__strdup(entry->value), git_buf_detach(&buf))) < 0) {
+		git_strmap_insert(names, git__strdup(entry->value), git_buf_detach(&buf), &rval);
+		if (rval < 0) {
 			git_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table");
 			error = -1;
 			goto out;
@@ -266,9 +267,10 @@ int git_submodule_lookup(
 	}
 
 	if (repo->submodule_cache != NULL) {
-		if ((sm = git_strmap_get(repo->submodule_cache, name)) != NULL) {
+		size_t pos = git_strmap_lookup_index(repo->submodule_cache, name);
+		if (git_strmap_valid_index(repo->submodule_cache, pos)) {
 			if (out) {
-				*out = sm;
+				*out = git_strmap_value_at(repo->submodule_cache, pos);
 				GIT_REFCOUNT_INC(*out);
 			}
 			return 0;
@@ -393,21 +395,30 @@ static void submodule_free_dup(void *sm)
 
 static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name)
 {
+	int error = 0;
+	size_t pos;
 	git_submodule *sm = NULL;
-	int error;
 
-	if ((sm = git_strmap_get(map, name)) != NULL)
+	pos = git_strmap_lookup_index(map, name);
+	if (git_strmap_valid_index(map, pos)) {
+		sm = git_strmap_value_at(map, pos);
 		goto done;
+	}
 
 	/* if the submodule doesn't exist yet in the map, create it */
 	if ((error = submodule_alloc(&sm, repo, name)) < 0)
 		return error;
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0) {
+	pos = git_strmap_put(map, sm->name, &error);
+	/* nobody can beat us to adding it */
+	assert(error != 0);
+	if (error < 0) {
 		git_submodule_free(sm);
 		return error;
 	}
 
+	git_strmap_set_value_at(map, pos, sm);
+
 done:
 	GIT_REFCOUNT_INC(sm);
 	*out = sm;
@@ -428,18 +439,26 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 		goto done;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
+		size_t pos = git_strmap_lookup_index(map, entry->path);
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_strmap_valid_index(map, pos)) {
+			sm = git_strmap_value_at(map, pos);
+
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_index_entry(sm, entry);
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
+			size_t name_pos;
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			name_pos = git_strmap_lookup_index(names, entry->path);
+			if (git_strmap_valid_index(names, name_pos)) {
+				name = git_strmap_value_at(names, name_pos);
+			} else {
 				name = entry->path;
+			}
 
 			if (!submodule_get_or_create(&sm, git_index_owner(idx), map, name)) {
 				submodule_update_from_index_entry(sm, entry);
@@ -472,18 +491,26 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 		goto done;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
+		size_t pos = git_strmap_lookup_index(map, entry->path);
 		git_submodule *sm;
 
-		if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+		if (git_strmap_valid_index(map, pos)) {
+			sm = git_strmap_value_at(map, pos);
+
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_head_data(sm, entry->mode, &entry->id);
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
+			size_t name_pos;
 			const char *name;
 
-			if ((name = git_strmap_get(names, entry->path)) == NULL)
+			name_pos = git_strmap_lookup_index(names, entry->path);
+			if (git_strmap_valid_index(names, name_pos)) {
+				name = git_strmap_value_at(names, name_pos);
+			} else {
 				name = entry->path;
+			}
 
 			if (!submodule_get_or_create(&sm, git_tree_owner(head), map, name)) {
 				submodule_update_from_head_data(
@@ -591,14 +618,14 @@ int git_submodule_foreach(
 		return -1;
 	}
 
-	if ((error = git_strmap_new(&submodules)) < 0)
+	if ((error = git_strmap_alloc(&submodules)) < 0)
 		return error;
 
 	if ((error = git_submodule__map(repo, submodules)) < 0)
 		goto done;
 
 	if (!(error = git_vector_init(
-			&snapshot, git_strmap_size(submodules), submodule_cmp))) {
+			&snapshot, git_strmap_num_entries(submodules), submodule_cmp))) {
 
 		git_strmap_foreach_value(submodules, sm, {
 			if ((error = git_vector_insert(&snapshot, sm)) < 0)
@@ -816,64 +843,6 @@ done:
 	return error;
 }
 
-static int clone_return_origin(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload)
-{
-	GIT_UNUSED(url);
-	GIT_UNUSED(payload);
-	return git_remote_lookup(out, repo, name);
-}
-
-static int clone_return_repo(git_repository **out, const char *path, int bare, void *payload)
-{
-	git_submodule *sm = payload;
-
-	GIT_UNUSED(path);
-	GIT_UNUSED(bare);
-	return git_submodule_open(out, sm);
-}
-
-int git_submodule_clone(git_repository **out, git_submodule *submodule, const git_submodule_update_options *given_opts)
-{
-	int error;
-	git_repository *clone;
-	git_buf rel_path = GIT_BUF_INIT;
-	git_submodule_update_options sub_opts = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
-	git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
-
-	assert(submodule);
-
-	if (given_opts)
-		memcpy(&sub_opts, given_opts, sizeof(sub_opts));
-
-	GIT_ERROR_CHECK_VERSION(&sub_opts, GIT_SUBMODULE_UPDATE_OPTIONS_VERSION, "git_submodule_update_options");
-
-	memcpy(&opts.checkout_opts, &sub_opts.checkout_opts, sizeof(sub_opts.checkout_opts));
-	memcpy(&opts.fetch_opts, &sub_opts.fetch_opts, sizeof(sub_opts.fetch_opts));
-	opts.repository_cb = clone_return_repo;
-	opts.repository_cb_payload = submodule;
-	opts.remote_cb = clone_return_origin;
-	opts.remote_cb_payload = submodule;
-
-	git_buf_puts(&rel_path, git_repository_workdir(git_submodule_owner(submodule)));
-	git_buf_joinpath(&rel_path, git_buf_cstr(&rel_path), git_submodule_path(submodule));
-
-	GIT_ERROR_CHECK_ALLOC_BUF(&rel_path);
-
-	error = git_clone__submodule(&clone, git_submodule_url(submodule), git_buf_cstr(&rel_path), &opts);
-	if (error < 0)
-		goto cleanup;
-
-	if (!out)
-		git_repository_free(clone);
-	else
-		*out = clone;
-
-cleanup:
-	git_buf_dispose(&rel_path);
-
-	return error;
-}
-
 int git_submodule_add_finalize(git_submodule *sm)
 {
 	int error;
@@ -1048,9 +1017,9 @@ cleanup:
 	return error;
 }
 
-static int write_mapped_var(git_repository *repo, const char *name, git_configmap *maps, size_t nmaps, const char *var, int ival)
+static int write_mapped_var(git_repository *repo, const char *name, git_cvar_map *maps, size_t nmaps, const char *var, int ival)
 {
-	git_configmap_t type;
+	git_cvar_t type;
 	const char *val;
 
 	if (git_config_lookup_map_enum(&type, &val, maps, nmaps, ival) < 0) {
@@ -1058,7 +1027,7 @@ static int write_mapped_var(git_repository *repo, const char *name, git_configma
 		return -1;
 	}
 
-	if (type == GIT_CONFIGMAP_TRUE)
+	if (type == GIT_CVAR_TRUE)
 		val = "true";
 
 	return write_var(repo, name, var, val);
@@ -1233,18 +1202,13 @@ static int git_submodule_update_repo_init_cb(
 	return submodule_repo_create(out, sm->repo, path);
 }
 
-int git_submodule_update_options_init(git_submodule_update_options *opts, unsigned int version)
+int git_submodule_update_init_options(git_submodule_update_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_submodule_update_options, GIT_SUBMODULE_UPDATE_OPTIONS_INIT);
 	return 0;
 }
 
-int git_submodule_update_init_options(git_submodule_update_options *opts, unsigned int version)
-{
-	return git_submodule_update_options_init(opts, version);
-}
-
 int git_submodule_update(git_submodule *sm, int init, git_submodule_update_options *_update_options)
 {
 	int error;
@@ -1971,6 +1935,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 {
 	lfc_data *data = payload;
 	const char *namestart, *property;
+	size_t pos;
 	git_strmap *map = data->map;
 	git_buf name = GIT_BUF_INIT;
 	git_submodule *sm;
@@ -2002,7 +1967,8 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 	 * a new submodule, load the config and insert it. If it's
 	 * already inserted, we've already loaded it, so we skip.
 	 */
-	if (git_strmap_exists(map, name.ptr)) {
+	pos = git_strmap_lookup_index(map, name.ptr);
+	if (git_strmap_valid_index(map, pos)) {
 		error = 0;
 		goto done;
 	}
@@ -2015,7 +1981,9 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 		goto done;
 	}
 
-	if ((error = git_strmap_set(map, sm->name, sm)) < 0)
+	git_strmap_insert(map, sm->name, sm, &error);
+	assert(error != 0);
+	if (error < 0)
 		goto done;
 
 	error = 0;