rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/streams/stransport.h

@@ -11,11 +11,6 @@
 
 #include "git2/sys/stream.h"
 
-#ifdef GIT_SECURE_TRANSPORT
-
 extern int git_stransport_stream_new(git_stream **out, const char *host, const char *port);
-extern int git_stransport_stream_wrap(git_stream **out, git_stream *in, const char *host);
-
-#endif
 
 #endif

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

@@ -5,69 +5,38 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#include "streams/tls.h"
+
 #include "git2/errors.h"
 
-#include "common.h"
-#include "global.h"
-#include "streams/registry.h"
-#include "streams/tls.h"
-#include "streams/mbedtls.h"
 #include "streams/openssl.h"
 #include "streams/stransport.h"
 
-int git_tls_stream_new(git_stream **out, const char *host, const char *port)
-{
-	int (*init)(git_stream **, const char *, const char *) = NULL;
-	git_stream_registration custom = {0};
-	int error;
-
-	assert(out && host && port);
-
-	if ((error = git_stream_registry_lookup(&custom, GIT_STREAM_TLS)) == 0) {
-		init = custom.init;
-	} else if (error == GIT_ENOTFOUND) {
-#ifdef GIT_SECURE_TRANSPORT
-		init = git_stransport_stream_new;
-#elif defined(GIT_OPENSSL)
-		init = git_openssl_stream_new;
-#elif defined(GIT_MBEDTLS)
-		init = git_mbedtls_stream_new;
-#endif
-	} else {
-		return error;
-	}
+static git_stream_cb tls_ctor;
 
-	if (!init) {
-		git_error_set(GIT_ERROR_SSL, "there is no TLS stream available");
-		return -1;
-	}
+int git_stream_register_tls(git_stream_cb ctor)
+{
+	tls_ctor = ctor;
 
-	return init(out, host, port);
+	return 0;
 }
 
-int git_tls_stream_wrap(git_stream **out, git_stream *in, const char *host)
+int git_tls_stream_new(git_stream **out, const char *host, const char *port)
 {
-	int (*wrap)(git_stream **, git_stream *, const char *) = NULL;
-	git_stream_registration custom = {0};
 
-	assert(out && in);
+	if (tls_ctor)
+		return tls_ctor(out, host, port);
 
-	if (git_stream_registry_lookup(&custom, GIT_STREAM_TLS) == 0) {
-		wrap = custom.wrap;
-	} else {
 #ifdef GIT_SECURE_TRANSPORT
-		wrap = git_stransport_stream_wrap;
+	return git_stransport_stream_new(out, host, port);
 #elif defined(GIT_OPENSSL)
-		wrap = git_openssl_stream_wrap;
-#elif defined(GIT_MBEDTLS)
-		wrap = git_mbedtls_stream_wrap;
+	return git_openssl_stream_new(out, host, port);
+#else
+	GIT_UNUSED(out);
+	GIT_UNUSED(host);
+	GIT_UNUSED(port);
+
+	giterr_set(GITERR_SSL, "there is no TLS stream available");
+	return -1;
 #endif
-	}
-
-	if (!wrap) {
-		git_error_set(GIT_ERROR_SSL, "there is no TLS stream available");
-		return -1;
-	}
-
-	return wrap(out, in, host);
 }

data/vendor/libgit2/src/streams/tls.h

@@ -13,19 +13,11 @@
 
 /**
  * Create a TLS stream with the most appropriate backend available for
- * the current platform, whether that's SecureTransport on macOS,
- * OpenSSL or mbedTLS on other Unixes, or something else entirely.
- */
-extern int git_tls_stream_new(git_stream **out, const char *host, const char *port);
-
-/**
- * Create a TLS stream on top of an existing insecure stream, using
- * the most appropriate backend available for the current platform.
+ * the current platform.
  *
- * This allows us to create a CONNECT stream on top of a proxy;
- * using SecureTransport on macOS, OpenSSL or mbedTLS on other
- * Unixes, or something else entirely.
+ * This allows us to ask for a SecureTransport or OpenSSL stream
+ * according to being on general Unix vs OS X.
  */
-extern int git_tls_stream_wrap(git_stream **out, git_stream *in, const char *host);
+extern int git_tls_stream_new(git_stream **out, const char *host, const char *port);
 
 #endif

data/vendor/libgit2/src/strmap.c

@@ -7,21 +7,14 @@
 
 #include "strmap.h"
 
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__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) {
+		giterr_set_oom();
+		return -1;
+	}
 
 	return 0;
 }
@@ -36,65 +29,99 @@ 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);
+}
 
-	if (rval == 0)
-		kh_key(map, idx) = key;
+int git_strmap_has_data(git_strmap *map, size_t idx)
+{
+	return kh_exist(map, idx);
+}
 
-	kh_val(map, idx) = value;
+const char *git_strmap_key(git_strmap *map, size_t idx)
+{
+	return kh_key(map, idx);
+}
 
-	return 0;
+void git_strmap_set_key_at(git_strmap *map, size_t idx, char *key)
+{
+	kh_val(map, idx) = key;
 }
 
-int git_strmap_delete(git_strmap *map, const char *key)
+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;
+}
+
+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);
-	return 0;
 }
 
-int git_strmap_exists(git_strmap *map, const char *key)
+int git_strmap_put(git_strmap *map, const char *key, int *err)
 {
-	return kh_get(str, map, key) != kh_end(map);
+	return kh_put(str, map, key, err);
 }
 
-int git_strmap_iterate(void **value, git_strmap *map, size_t *iter, const char **key)
+void git_strmap_insert(git_strmap *map, const char *key, void *value, int *rval)
 {
-	size_t i = *iter;
+	khiter_t idx = kh_put(str, map, key, rval);
 
-	while (i < map->n_buckets && !kh_exist(map, i))
-		i++;
+	if ((*rval) >= 0) {
+		if ((*rval) == 0)
+			kh_key(map, idx) = key;
+		kh_val(map, idx) = value;
+	}
+}
 
-	if (i >= map->n_buckets)
-		return GIT_ITEROVER;
+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);
+}
 
-	if (key)
-		*key = kh_key(map, i);
-	if (value)
-		*value = kh_val(map, i);
-	*iter = ++i;
+int git_strmap_next(
+	void **data,
+	git_strmap_iter* iter,
+	git_strmap *map)
+{
+	if (!map)
+		return GIT_ERROR;
 
-	return 0;
+	while (*iter != git_strmap_end(map)) {
+		if (!(git_strmap_has_data(map, *iter))) {
+			++(*iter);
+			continue;
+		}
+
+		*data = git_strmap_value_at(map, *iter);
+
+		++(*iter);
+
+		return GIT_OK;
+	}
+
+	return GIT_ITEROVER;
 }

data/vendor/libgit2/src/strmap.h

@@ -9,123 +9,48 @@
 
 #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`.
- */
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kreallocarray git__reallocarray
+#define kfree git__free
+#include "khash.h"
+
+__KHASH_TYPE(str, const char *, void *)
+typedef khash_t(str) git_strmap;
+typedef khiter_t git_strmap_iter;
+
+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);
+int git_strmap_exists(git_strmap *map, const char *key);
+int git_strmap_has_data(git_strmap *map, size_t idx);
 
-/**
- * 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);
+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);
 
-/**
- * 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);
+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);
 
-/**
- * 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		kh_foreach
+#define git_strmap_foreach_value	kh_foreach_value
 
-#define git_strmap_foreach(h, kvar, vvar, code) { size_t __i = 0;		\
-	while (git_strmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) {	\
-		code;								\
-	} }
+#define git_strmap_begin		kh_begin
+#define git_strmap_end		kh_end
 
-#define git_strmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
-	while (git_strmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
-		code;								\
-	} }
+int git_strmap_next(
+	void **data,
+	git_strmap_iter* iter,
+	git_strmap *map);
 
 #endif

data/vendor/libgit2/src/submodule.c

@@ -15,7 +15,7 @@
 #include "buf_text.h"
 #include "vector.h"
 #include "posix.h"
-#include "config_backend.h"
+#include "config_file.h"
 #include "config.h"
 #include "repository.h"
 #include "tree.h"
@@ -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 {
@@ -61,6 +60,35 @@ enum {
 	GITMODULES_CREATE = 1,
 };
 
+static kh_inline khint_t str_hash_no_trailing_slash(const char *s)
+{
+	khint_t h;
+
+	for (h = 0; *s; ++s)
+		if (s[1] != '\0' || *s != '/')
+			h = (h << 5) - h + *s;
+
+	return h;
+}
+
+static kh_inline int str_equal_no_trailing_slash(const char *a, const char *b)
+{
+	size_t alen = a ? strlen(a) : 0;
+	size_t blen = b ? strlen(b) : 0;
+
+	if (alen > 0 && a[alen - 1] == '/')
+		alen--;
+	if (blen > 0 && b[blen - 1] == '/')
+		blen--;
+
+	return (alen == 0 && blen == 0) ||
+		(alen == blen && strncmp(a, b, alen) == 0);
+}
+
+__KHASH_IMPL(
+	str, static kh_inline, const char *, void *, 1,
+	str_hash_no_trailing_slash, str_equal_no_trailing_slash)
+
 static int submodule_alloc(git_submodule **out, git_repository *repo, const char *name);
 static git_config_backend *open_gitmodules(git_repository *repo, int gitmod);
 static int gitmodules_snapshot(git_config **snap, git_repository *repo);
@@ -96,7 +124,7 @@ static void submodule_set_lookup_error(int error, const char *name)
 	if (!error)
 		return;
 
-	git_error_set(GIT_ERROR_SUBMODULE, (error == GIT_ENOTFOUND) ?
+	giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
 		"no submodule named '%s'" :
 		"submodule '%s' has not been added yet", name);
 }
@@ -115,74 +143,24 @@ static int find_by_path(const git_config_entry *entry, void *payload)
 		fdot = strchr(entry->name, '.');
 		ldot = strrchr(entry->name, '.');
 		data->name = git__strndup(fdot + 1, ldot - fdot - 1);
-		GIT_ERROR_CHECK_ALLOC(data->name);
+		GITERR_CHECK_ALLOC(data->name);
 	}
 
 	return 0;
 }
 
-/*
- * Checks to see if the submodule shares its name with a file or directory that
- * already exists on the index. If so, the submodule cannot be added.
- */
-static int is_path_occupied(bool *occupied, git_repository *repo, const char *path)
-{
-	int error = 0;
-	git_index *index;
-	git_buf dir = GIT_BUF_INIT;
-	*occupied = false;
-
-	if ((error = git_repository_index__weakptr(&index, repo)) < 0)
-		goto out;
-
-	if ((error = git_index_find(NULL, index, path)) != GIT_ENOTFOUND) {
-		if (!error) {
-			git_error_set(GIT_ERROR_SUBMODULE,
-				"File '%s' already exists in the index", path);
-			*occupied = true;
-		}
-		goto out;
-	}
-
-	if ((error = git_buf_sets(&dir, path)) < 0)
-		goto out;
-
-	if ((error = git_path_to_dir(&dir)) < 0)
-		goto out;
-
-	if ((error = git_index_find_prefix(NULL, index, dir.ptr)) != GIT_ENOTFOUND) {
-		if (!error) {
-			git_error_set(GIT_ERROR_SUBMODULE,
-				"Directory '%s' already exists in the index", path);
-			*occupied = true;
-		}
-		goto out;
-	}
-
-	error = 0;
-
-out:
-	git_buf_dispose(&dir);
-	return error;
-}
-
 /**
  * Release the name map returned by 'load_submodule_names'.
  */
 static void free_submodule_names(git_strmap *names)
 {
-	const char *key;
-	char *value;
-
+	git_buf *name = 0;
 	if (names == NULL)
 		return;
-
-	git_strmap_foreach(names, key, value, {
-		git__free((char *) key);
-		git__free(value);
+	git_strmap_foreach_value(names, name, {
+		git__free(name);
 	});
 	git_strmap_free(names);
-
 	return;
 }
 
@@ -191,30 +169,25 @@ static void free_submodule_names(git_strmap *names)
  * TODO: for some use-cases, this might need case-folding on a
  * case-insensitive filesystem
  */
-static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg)
+static int load_submodule_names(git_strmap *out, git_repository *repo, git_config *cfg)
 {
 	const char *key = "submodule\\..*\\.path";
-	git_config_iterator *iter = NULL;
+	git_config_iterator *iter;
 	git_config_entry *entry;
 	git_buf buf = GIT_BUF_INIT;
-	git_strmap *names;
-	int isvalid, error;
-
-	*out = NULL;
-
-	if ((error = git_strmap_new(&names)) < 0)
-		goto out;
+	int rval, isvalid;
+	int error = 0;
 
 	if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
-		goto out;
+		return error;
 
 	while ((error = git_config_next(&entry, iter)) == 0) {
 		const char *fdot, *ldot;
 		fdot = strchr(entry->name, '.');
 		ldot = strrchr(entry->name, '.');
 
-		if (git_strmap_exists(names, entry->value)) {
-			git_error_set(GIT_ERROR_SUBMODULE,
+		if (git_strmap_exists(out, entry->value)) {
+			giterr_set(GITERR_SUBMODULE,
 				   "duplicated submodule path '%s'", entry->value);
 			error = -1;
 			goto out;
@@ -230,21 +203,17 @@ 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_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table");
-			error = -1;
-			goto out;
+		git_strmap_insert(out, entry->value, git_buf_detach(&buf), &rval);
+		if (rval < 0) {
+			giterr_set(GITERR_NOMEMORY, "error inserting submodule into hash table");
+			return -1;
 		}
 	}
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-	*out = names;
-	names = NULL;
-
 out:
-	free_submodule_names(names);
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	git_config_iterator_free(iter);
 	return error;
 }
@@ -261,14 +230,15 @@ int git_submodule_lookup(
 	assert(repo && name);
 
 	if (repo->is_bare) {
-		git_error_set(GIT_ERROR_SUBMODULE, "cannot get submodules without a working tree");
+		giterr_set(GITERR_SUBMODULE, "cannot get submodules without a working tree");
 		return -1;
 	}
 
 	if (repo->submodule_cache != NULL) {
-		if ((sm = git_strmap_get(repo->submodule_cache, name)) != NULL) {
+		khiter_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;
@@ -304,13 +274,13 @@ int git_submodule_lookup(
 		mods = open_gitmodules(repo, GITMODULES_EXISTING);
 
 		if (mods)
-			error = git_config_backend_foreach_match(mods, pattern, find_by_path, &data);
+			error = git_config_file_foreach_match(mods, pattern, find_by_path, &data);
 
-		git_config_backend_free(mods);
+		git_config_file_free(mods);
 
 		if (error < 0) {
 			git_submodule_free(sm);
-			git_buf_dispose(&path);
+			git_buf_free(&path);
 			return error;
 		}
 
@@ -326,7 +296,7 @@ int git_submodule_lookup(
 			}
 		}
 
-		git_buf_dispose(&path);
+		git_buf_free(&path);
 	}
 
 	if ((error = git_submodule_location(&location, sm)) < 0) {
@@ -349,7 +319,7 @@ int git_submodule_lookup(
 			if (git_path_exists(path.ptr))
 				error = GIT_EEXISTS;
 
-			git_buf_dispose(&path);
+			git_buf_free(&path);
 		}
 
 		submodule_set_lookup_error(error, name);
@@ -381,7 +351,7 @@ int git_submodule_name_is_valid(git_repository *repo, const char *name, int flag
 	}
 
 	isvalid =  git_path_isvalid(repo, buf.ptr, 0, flags);
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	return isvalid;
 }
@@ -393,21 +363,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;
+	khiter_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;
@@ -419,27 +398,36 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
+	git_strmap *names = 0;
 
-	if ((error = load_submodule_names(&names, git_index_owner(idx), cfg)))
+	git_strmap_alloc(&names);
+	if ((error = load_submodule_names(names, git_index_owner(idx), cfg)))
 		goto done;
 
 	if ((error = git_iterator_for_index(&i, git_index_owner(idx), idx, NULL)) < 0)
 		goto done;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
+		khiter_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)) {
+			khiter_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);
@@ -463,27 +451,35 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
 	int error;
 	git_iterator *i = NULL;
 	const git_index_entry *entry;
-	git_strmap *names;
-
-	if ((error = load_submodule_names(&names, git_tree_owner(head), cfg)))
+	git_strmap *names = 0;
+	git_strmap_alloc(&names);
+	if ((error = load_submodule_names(names, git_tree_owner(head), cfg)))
 		goto done;
 
 	if ((error = git_iterator_for_tree(&i, head, NULL)) < 0)
 		goto done;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
+		khiter_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)) {
+			khiter_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(
@@ -519,19 +515,36 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 	git_buf path = GIT_BUF_INIT;
 	git_submodule *sm;
 	git_config *mods = NULL;
+	uint32_t mask;
 
 	assert(repo && map);
 
 	/* get sources that we will need to check */
 	if (git_repository_index(&idx, repo) < 0)
-		git_error_clear();
+		giterr_clear();
 	if (git_repository_head_tree(&head, repo) < 0)
-		git_error_clear();
+		giterr_clear();
 
 	wd = git_repository_workdir(repo);
 	if (wd && (error = git_buf_joinpath(&path, wd, GIT_MODULES_FILE)) < 0)
 		goto cleanup;
 
+	/* clear submodule flags that are to be refreshed */
+	mask = 0;
+	mask |= GIT_SUBMODULE_STATUS_IN_INDEX |
+		GIT_SUBMODULE_STATUS__INDEX_FLAGS |
+		GIT_SUBMODULE_STATUS__INDEX_OID_VALID |
+		GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES;
+
+	mask |= GIT_SUBMODULE_STATUS_IN_HEAD |
+		GIT_SUBMODULE_STATUS__HEAD_OID_VALID;
+	mask |= GIT_SUBMODULE_STATUS_IN_CONFIG;
+	if (mask != 0)
+		mask |= GIT_SUBMODULE_STATUS_IN_WD |
+			GIT_SUBMODULE_STATUS__WD_SCANNED |
+			GIT_SUBMODULE_STATUS__WD_FLAGS |
+			GIT_SUBMODULE_STATUS__WD_OID_VALID;
+
 	/* add submodule information from .gitmodules */
 	if (wd) {
 		lfc_data data = { 0 };
@@ -560,7 +573,7 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
 			goto cleanup;
 	}
 	/* shallow scan submodules in work tree as needed */
-	if (wd) {
+	if (wd && mask != 0) {
 		git_strmap_foreach_value(map, sm, {
 				submodule_load_from_wd_lite(sm);
 			});
@@ -571,7 +584,7 @@ cleanup:
 	/* TODO: if we got an error, mark submodule config as invalid? */
 	git_index_free(idx);
 	git_tree_free(head);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return error;
 }
 
@@ -587,18 +600,18 @@ int git_submodule_foreach(
 	size_t i;
 
 	if (repo->is_bare) {
-		git_error_set(GIT_ERROR_SUBMODULE, "cannot get submodules without a working tree");
+		giterr_set(GITERR_SUBMODULE, "cannot get submodules without a working tree");
 		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)
@@ -614,7 +627,7 @@ int git_submodule_foreach(
 
 	git_vector_foreach(&snapshot, i, sm) {
 		if ((error = callback(sm, sm->name, payload)) != 0) {
-			git_error_set_after_callback(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -676,8 +689,8 @@ static int submodule_repo_init(
 		error = git_repository_init_ext(&subrepo, workdir.ptr, &initopt);
 
 cleanup:
-	git_buf_dispose(&workdir);
-	git_buf_dispose(&repodir);
+	git_buf_free(&workdir);
+	git_buf_free(&repodir);
 
 	*out = subrepo;
 
@@ -696,16 +709,15 @@ int git_submodule_add_setup(
 	git_submodule *sm = NULL;
 	git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
 	git_repository *subrepo = NULL;
-	bool path_occupied;
 
 	assert(repo && url && path);
 
 	/* see if there is already an entry for this submodule */
 
 	if (git_submodule_lookup(NULL, repo, path) < 0)
-		git_error_clear();
+		giterr_clear();
 	else {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"attempt to add submodule '%s' that already exists", path);
 		return GIT_EEXISTS;
 	}
@@ -716,33 +728,25 @@ int git_submodule_add_setup(
 		path += strlen(git_repository_workdir(repo));
 
 	if (git_path_root(path) >= 0) {
-		git_error_set(GIT_ERROR_SUBMODULE, "submodule path must be a relative path");
+		giterr_set(GITERR_SUBMODULE, "submodule path must be a relative path");
 		error = -1;
 		goto cleanup;
 	}
 
-	if ((error = is_path_occupied(&path_occupied, repo, path)) < 0)
-		goto cleanup;
-
-	if (path_occupied) {
-		error = GIT_EEXISTS;
-		goto cleanup;
-	}
-
 	/* update .gitmodules */
 
 	if (!(mods = open_gitmodules(repo, GITMODULES_CREATE))) {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"adding submodules to a bare repository is not supported");
 		return -1;
 	}
 
 	if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 ||
-		(error = git_config_backend_set_string(mods, name.ptr, path)) < 0)
+		(error = git_config_file_set_string(mods, name.ptr, path)) < 0)
 		goto cleanup;
 
 	if ((error = submodule_config_key_trunc_puts(&name, "url")) < 0 ||
-		(error = git_config_backend_set_string(mods, name.ptr, url)) < 0)
+		(error = git_config_file_set_string(mods, name.ptr, url)) < 0)
 		goto cleanup;
 
 	git_buf_clear(&name);
@@ -780,10 +784,10 @@ cleanup:
 	if (out != NULL)
 		*out = sm;
 
-	git_config_backend_free(mods);
+	git_config_file_free(mods);
 	git_repository_free(subrepo);
-	git_buf_dispose(&real_url);
-	git_buf_dispose(&name);
+	git_buf_free(&real_url);
+	git_buf_free(&name);
 
 	return error;
 }
@@ -812,65 +816,7 @@ int git_submodule_repo_init(
 
 done:
 	git_config_free(cfg);
-	git_buf_dispose(&buf);
-	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);
-
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -911,7 +857,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 
 	/* read stat information for submodule working directory */
 	if (p_stat(path.ptr, &st) < 0) {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"cannot add submodule without working directory");
 		error = -1;
 		goto cleanup;
@@ -920,11 +866,11 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 	memset(&entry, 0, sizeof(entry));
 	entry.path = sm->path;
 	git_index_entry__init_from_stat(
-		&entry, &st, !(git_index_caps(index) & GIT_INDEX_CAPABILITY_NO_FILEMODE));
+		&entry, &st, !(git_index_caps(index) & GIT_INDEXCAP_NO_FILEMODE));
 
 	/* calling git_submodule_open will have set sm->wd_oid if possible */
 	if ((sm->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID) == 0) {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"cannot add submodule without HEAD to index");
 		error = -1;
 		goto cleanup;
@@ -954,7 +900,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 
 cleanup:
 	git_repository_free(sm_repo);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return error;
 }
 
@@ -1015,11 +961,11 @@ int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *ur
 	} else if (strchr(url, ':') != NULL || url[0] == '/') {
 		error = git_buf_sets(out, url);
 	} else {
-		git_error_set(GIT_ERROR_SUBMODULE, "invalid format for submodule URL");
+		giterr_set(GITERR_SUBMODULE, "invalid format for submodule URL");
 		error = -1;
 	}
 
-	git_buf_dispose(&normalized);
+	git_buf_free(&normalized);
 	return error;
 }
 
@@ -1037,28 +983,28 @@ static int write_var(git_repository *repo, const char *name, const char *var, co
 		goto cleanup;
 
 	if (val)
-		error = git_config_backend_set_string(mods, key.ptr, val);
+		error = git_config_file_set_string(mods, key.ptr, val);
 	else
-		error = git_config_backend_delete(mods, key.ptr);
+		error = git_config_file_delete(mods, key.ptr);
 
-	git_buf_dispose(&key);
+	git_buf_free(&key);
 
 cleanup:
-	git_config_backend_free(mods);
+	git_config_file_free(mods);
 	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) {
-		git_error_set(GIT_ERROR_SUBMODULE, "invalid value for %s", var);
+		giterr_set(GITERR_SUBMODULE, "invalid value for %s", var);
 		return -1;
 	}
 
-	if (type == GIT_CONFIGMAP_TRUE)
+	if (type == GIT_CVAR_TRUE)
 		val = "true";
 
 	return write_var(repo, name, var, val);
@@ -1117,7 +1063,7 @@ const git_oid *git_submodule_wd_id(git_submodule *submodule)
 		if (!git_submodule_open_bare(&subrepo, submodule))
 			git_repository_free(subrepo);
 		else
-			git_error_clear();
+			giterr_clear();
 	}
 
 	if (submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)
@@ -1206,8 +1152,8 @@ static int submodule_repo_create(
 	error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt);
 
 cleanup:
-	git_buf_dispose(&workdir);
-	git_buf_dispose(&repodir);
+	git_buf_free(&workdir);
+	git_buf_free(&repodir);
 
 	*out = subrepo;
 
@@ -1233,18 +1179,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;
@@ -1263,7 +1204,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	if (_update_options)
 		memcpy(&update_options, _update_options, sizeof(git_submodule_update_options));
 
-	GIT_ERROR_CHECK_VERSION(&update_options, GIT_SUBMODULE_UPDATE_OPTIONS_VERSION, "git_submodule_update_options");
+	GITERR_CHECK_VERSION(&update_options, GIT_SUBMODULE_UPDATE_OPTIONS_VERSION, "git_submodule_update_options");
 
 	/* Copy over the remote callbacks */
 	memcpy(&clone_options.fetch_opts, &update_options.fetch_opts, sizeof(git_fetch_options));
@@ -1294,7 +1235,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 				goto done;
 
 			if (!init) {
-				git_error_set(GIT_ERROR_SUBMODULE, "submodule is not initialized");
+				giterr_set(GITERR_SUBMODULE, "submodule is not initialized");
 				error = GIT_ERROR;
 				goto done;
 			}
@@ -1338,18 +1279,18 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 			goto done;
 
 		if ((oid = git_submodule_index_id(sm)) == NULL) {
-			git_error_set(GIT_ERROR_SUBMODULE, "could not get ID of submodule in index");
+			giterr_set(GITERR_SUBMODULE, "could not get ID of submodule in index");
 			error = -1;
 			goto done;
 		}
 
 		/* Look up the target commit in the submodule. */
-		if ((error = git_object_lookup(&target_commit, sub_repo, oid, GIT_OBJECT_COMMIT)) < 0) {
+		if ((error = git_object_lookup(&target_commit, sub_repo, oid, GIT_OBJ_COMMIT)) < 0) {
 			/* If it isn't found then fetch and try again. */
 			if (error != GIT_ENOTFOUND || !update_options.allow_fetch ||
 				(error = lookup_default_remote(&remote, sub_repo)) < 0 ||
 				(error = git_remote_fetch(remote, NULL, &update_options.fetch_opts, NULL)) < 0 ||
-				(error = git_object_lookup(&target_commit, sub_repo, git_submodule_index_id(sm), GIT_OBJECT_COMMIT)) < 0)
+				(error = git_object_lookup(&target_commit, sub_repo, git_submodule_index_id(sm), GIT_OBJ_COMMIT)) < 0)
 				goto done;
 		}
 
@@ -1365,7 +1306,7 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
 	}
 
 done:
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	git_config_free(config);
 	git_object_free(target_commit);
 	git_remote_free(remote);
@@ -1382,7 +1323,7 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 	git_config *cfg = NULL;
 
 	if (!sm->url) {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"no URL configured for submodule '%s'", sm->name);
 		return -1;
 	}
@@ -1412,8 +1353,8 @@ int git_submodule_init(git_submodule *sm, int overwrite)
 
 cleanup:
 	git_config_free(cfg);
-	git_buf_dispose(&key);
-	git_buf_dispose(&effective_submodule_url);
+	git_buf_free(&key);
+	git_buf_free(&effective_submodule_url);
 
 	return error;
 }
@@ -1426,7 +1367,7 @@ int git_submodule_sync(git_submodule *sm)
 	git_repository *smrepo = NULL;
 
 	if (!sm->url) {
-		git_error_set(GIT_ERROR_SUBMODULE,
+		giterr_set(GITERR_SUBMODULE,
 			"no URL configured for submodule '%s'", sm->name);
 		return -1;
 	}
@@ -1448,12 +1389,12 @@ int git_submodule_sync(git_submodule *sm)
 		if ((error = git_repository_config__weakptr(&cfg, smrepo)) < 0)
 			/* return error from reading submodule config */;
 		else if ((error = lookup_head_remote_key(&remote_name, smrepo)) < 0) {
-			git_error_clear();
+			giterr_clear();
 			error = git_buf_sets(&key, "remote.origin.url");
 		} else {
 			error = git_buf_join3(
 				&key, '.', "remote", remote_name.ptr, "url");
-			git_buf_dispose(&remote_name);
+			git_buf_free(&remote_name);
 		}
 
 		if (!error)
@@ -1462,7 +1403,7 @@ int git_submodule_sync(git_submodule *sm)
 		git_repository_free(smrepo);
 	}
 
-	git_buf_dispose(&key);
+	git_buf_free(&key);
 
 	return error;
 }
@@ -1505,7 +1446,7 @@ static int git_submodule__open(
 		if (!git_reference_name_to_id(&sm->wd_oid, *subrepo, GIT_HEAD_FILE))
 			sm->flags |= GIT_SUBMODULE_STATUS__WD_OID_VALID;
 		else
-			git_error_clear();
+			giterr_clear();
 	} else if (git_path_exists(path.ptr)) {
 		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED |
 			GIT_SUBMODULE_STATUS_IN_WD;
@@ -1516,7 +1457,7 @@ static int git_submodule__open(
 			sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
 	}
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -1595,7 +1536,7 @@ static int submodule_update_head(git_submodule *submodule)
 	/* if we can't look up file in current head, then done */
 	if (git_repository_head_tree(&head, submodule->repo) < 0 ||
 		git_tree_entry_bypath(&te, head, submodule->path) < 0)
-		git_error_clear();
+		giterr_clear();
 	else
 		submodule_update_from_head_data(submodule, te->attr, git_tree_entry_id(te));
 
@@ -1698,12 +1639,12 @@ int git_submodule__status(
 	if (ign == GIT_SUBMODULE_IGNORE_DIRTY) {
 		/* git_submodule_open_bare will load WD OID data */
 		if (git_submodule_open_bare(&smrepo, sm) < 0)
-			git_error_clear();
+			giterr_clear();
 		else
 			git_repository_free(smrepo);
 		smrepo = NULL;
 	} else if (git_submodule_open(&smrepo, sm) < 0) {
-		git_error_clear();
+		giterr_clear();
 		smrepo = NULL;
 	}
 
@@ -1761,12 +1702,12 @@ static int submodule_alloc(
 	git_submodule *sm;
 
 	if (!name || !(namelen = strlen(name))) {
-		git_error_set(GIT_ERROR_SUBMODULE, "invalid submodule name");
+		giterr_set(GITERR_SUBMODULE, "invalid submodule name");
 		return -1;
 	}
 
 	sm = git__calloc(1, sizeof(git_submodule));
-	GIT_ERROR_CHECK_ALLOC(sm);
+	GITERR_CHECK_ALLOC(sm);
 
 	sm->name = sm->path = git__strdup(name);
 	if (!sm->name) {
@@ -1812,7 +1753,7 @@ void git_submodule_free(git_submodule *sm)
 
 static int submodule_config_error(const char *property, const char *value)
 {
-	git_error_set(GIT_ERROR_INVALID,
+	giterr_set(GITERR_INVALID,
 		"invalid value for submodule '%s' property: '%s'", property, value);
 	return -1;
 }
@@ -1903,7 +1844,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg)
 				if (sm->path != sm->name)
 					git__free(sm->path);
 				sm->path = git__strdup(value);
-				GIT_ERROR_CHECK_ALLOC(sm->path);
+				GITERR_CHECK_ALLOC(sm->path);
 			}
 
 		}
@@ -1916,7 +1857,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg)
 		if (!looks_like_command_line_option(value)) {
 			in_config = 1;
 			sm->url = git__strdup(value);
-			GIT_ERROR_CHECK_ALLOC(sm->url);
+			GITERR_CHECK_ALLOC(sm->url);
 		}
 	} else if (error != GIT_ENOTFOUND) {
 		goto cleanup;
@@ -1925,7 +1866,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg)
 	if ((error = get_value(&value, cfg, &key, sm->name, "branch")) == 0) {
 		in_config = 1;
 		sm->branch = git__strdup(value);
-		GIT_ERROR_CHECK_ALLOC(sm->branch);
+		GITERR_CHECK_ALLOC(sm->branch);
 	} else if (error != GIT_ENOTFOUND) {
 		goto cleanup;
 	}
@@ -1963,7 +1904,7 @@ static int submodule_read_config(git_submodule *sm, git_config *cfg)
 	error = 0;
 
 cleanup:
-	git_buf_dispose(&key);
+	git_buf_free(&key);
 	return error;
 }
 
@@ -1971,6 +1912,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
 {
 	lfc_data *data = payload;
 	const char *namestart, *property;
+	git_strmap_iter pos;
 	git_strmap *map = data->map;
 	git_buf name = GIT_BUF_INIT;
 	git_submodule *sm;
@@ -2002,7 +1944,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,13 +1958,15 @@ 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;
 
 done:
-	git_buf_dispose(&name);
+	git_buf_free(&name);
 	return error;
 }
 
@@ -2038,7 +1983,7 @@ static int submodule_load_from_wd_lite(git_submodule *sm)
 	if (git_path_contains(&path, DOT_GIT))
 		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD;
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return 0;
 }
 
@@ -2062,7 +2007,6 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo)
 
 	if ((error = git_config_open_ondisk(&mods, path.ptr)) < 0)
 		goto cleanup;
-	git_buf_dispose(&path);
 
 	if ((error = git_config_snapshot(snap, mods)) < 0)
 		goto cleanup;
@@ -2072,7 +2016,7 @@ static int gitmodules_snapshot(git_config **snap, git_repository *repo)
 cleanup:
 	if (mods)
 		git_config_free(mods);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -2090,18 +2034,18 @@ static git_config_backend *open_gitmodules(
 			return NULL;
 
 		if (okay_to_create || git_path_isfile(path.ptr)) {
-			/* git_config_backend_from_file should only fail if OOM */
-			if (git_config_backend_from_file(&mods, path.ptr) < 0)
+			/* git_config_file__ondisk should only fail if OOM */
+			if (git_config_file__ondisk(&mods, path.ptr) < 0)
 				mods = NULL;
 			/* open should only fail here if the file is malformed */
-			else if (git_config_backend_open(mods, GIT_CONFIG_LEVEL_LOCAL, repo) < 0) {
-				git_config_backend_free(mods);
+			else if (git_config_file_open(mods, GIT_CONFIG_LEVEL_LOCAL, repo) < 0) {
+				git_config_file_free(mods);
 				mods = NULL;
 			}
 		}
 	}
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return mods;
 }
@@ -2123,7 +2067,7 @@ static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
 	 * a remote key for the local tracking branch HEAD points to.
 	 **/
 	if (!git_reference_is_branch(head)) {
-		git_error_set(GIT_ERROR_INVALID,
+		giterr_set(GITERR_INVALID,
 			"HEAD does not refer to a branch.");
 		error = GIT_ENOTFOUND;
 		goto done;
@@ -2141,7 +2085,7 @@ static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
 		goto done;
 
 done:
-	git_buf_dispose(&upstream_name);
+	git_buf_free(&upstream_name);
 	git_reference_free(head);
 
 	return error;
@@ -2157,7 +2101,7 @@ static int lookup_head_remote(git_remote **remote, git_repository *repo)
 	if (!(error = lookup_head_remote_key(&remote_name, repo)))
 		error = git_remote_lookup(remote, repo, remote_name.ptr);
 
-	git_buf_dispose(&remote_name);
+	git_buf_free(&remote_name);
 
 	return error;
 }
@@ -2172,8 +2116,8 @@ static int lookup_default_remote(git_remote **remote, git_repository *repo)
 		error = git_remote_lookup(remote, repo, "origin");
 
 	if (error == GIT_ENOTFOUND)
-		git_error_set(
-			GIT_ERROR_SUBMODULE,
+		giterr_set(
+			GITERR_SUBMODULE,
 			"cannot get default remote for submodule - no local tracking "
 			"branch for HEAD and origin does not exist");
 
@@ -2192,7 +2136,7 @@ static int get_url_base(git_buf *url, git_repository *repo)
 	} else if (error != GIT_ENOTFOUND)
 		goto out;
 	else
-		git_error_clear();
+		giterr_clear();
 
 	/* if repository does not have a default remote, use workdir instead */
 	if (git_repository_is_worktree(repo)) {
@@ -2273,11 +2217,11 @@ static void submodule_get_wd_status(
 
 	/* if we don't have an unborn head, check diff with index */
 	if (git_repository_head_tree(&sm_head, sm_repo) < 0)
-		git_error_clear();
+		giterr_clear();
 	else {
 		/* perform head to index diff on submodule */
 		if (git_diff_tree_to_index(&diff, sm_repo, sm_head, index, &opt) < 0)
-			git_error_clear();
+			giterr_clear();
 		else {
 			if (git_diff_num_deltas(diff) > 0)
 				*status |= GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED;
@@ -2290,7 +2234,7 @@ static void submodule_get_wd_status(
 
 	/* perform index-to-workdir diff on submodule */
 	if (git_diff_index_to_workdir(&diff, sm_repo, index, &opt) < 0)
-		git_error_clear();
+		giterr_clear();
 	else {
 		size_t untracked =
 			git_diff_num_deltas_of_type(diff, GIT_DELTA_UNTRACKED);