rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/refs.h

@@ -55,8 +55,8 @@ extern bool git_reference__enable_symbolic_ref_target_validation;
 #define GIT_STASH_FILE "stash"
 #define GIT_REFS_STASH_FILE GIT_REFS_DIR GIT_STASH_FILE
 
-#define GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
-#define GIT_REFERENCE_FORMAT__VALIDATION_DISABLE	(1u << 15)
+#define GIT_REF_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
+#define GIT_REF_FORMAT__VALIDATION_DISABLE	(1u << 15)
 
 #define GIT_REFNAME_MAX 1024
 
@@ -64,7 +64,7 @@ typedef char git_refname_t[GIT_REFNAME_MAX];
 
 struct git_reference {
 	git_refdb *db;
-	git_reference_t type;
+	git_ref_t type;
 
 	union {
 		git_oid oid;
@@ -136,6 +136,4 @@ int git_reference__update_for_commit(
 	const git_oid *id,
 	const char *operation);
 
-int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_repository *repo);
-
 #endif

data/vendor/libgit2/src/refspec.c

@@ -9,14 +9,14 @@
 
 #include "git2/errors.h"
 
-#include "refs.h"
 #include "util.h"
+#include "posix.h"
+#include "refs.h"
 #include "vector.h"
-#include "wildmatch.h"
 
 int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 {
-	/* Ported from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/remote.c#L518-636 */
+	// Ported from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/remote.c#L518-636
 
 	size_t llen;
 	int is_glob = 0;
@@ -43,11 +43,11 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	if (!is_fetch && rhs == lhs && rhs[1] == '\0') {
 		refspec->matching = 1;
 		refspec->string = git__strdup(input);
-		GIT_ERROR_CHECK_ALLOC(refspec->string);
+		GITERR_CHECK_ALLOC(refspec->string);
 		refspec->src = git__strdup("");
-		GIT_ERROR_CHECK_ALLOC(refspec->src);
+		GITERR_CHECK_ALLOC(refspec->src);
 		refspec->dst = git__strdup("");
-		GIT_ERROR_CHECK_ALLOC(refspec->dst);
+		GITERR_CHECK_ALLOC(refspec->dst);
 		return 0;
 	}
 
@@ -69,9 +69,8 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	refspec->pattern = is_glob;
 	refspec->src = git__strndup(lhs, llen);
-	flags = GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL |
-		GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND |
-		(is_glob ? GIT_REFERENCE_FORMAT_REFSPEC_PATTERN : 0);
+	flags = GIT_REF_FORMAT_ALLOW_ONELEVEL | GIT_REF_FORMAT_REFSPEC_SHORTHAND
+		| (is_glob ? GIT_REF_FORMAT_REFSPEC_PATTERN : 0);
 
 	if (is_fetch) {
 		/*
@@ -132,24 +131,24 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 		/* if the RHS is empty, then it's a copy of the LHS */
 		if (!refspec->dst) {
 			refspec->dst = git__strdup(refspec->src);
-			GIT_ERROR_CHECK_ALLOC(refspec->dst);
+			GITERR_CHECK_ALLOC(refspec->dst);
 		}
 	}
 
 	refspec->string = git__strdup(input);
-	GIT_ERROR_CHECK_ALLOC(refspec->string);
+	GITERR_CHECK_ALLOC(refspec->string);
 
 	return 0;
 
  invalid:
-        git_error_set(
-                GIT_ERROR_INVALID,
+        giterr_set(
+                GITERR_INVALID,
                 "'%s' is not a valid refspec.", input);
-        git_refspec__dispose(refspec);
+        git_refspec__free(refspec);
 	return -1;
 }
 
-void git_refspec__dispose(git_refspec *refspec)
+void git_refspec__free(git_refspec *refspec)
 {
 	if (refspec == NULL)
 		return;
@@ -161,31 +160,6 @@ void git_refspec__dispose(git_refspec *refspec)
 	memset(refspec, 0x0, sizeof(git_refspec));
 }
 
-int git_refspec_parse(git_refspec **out_refspec, const char *input, int is_fetch)
-{
-	git_refspec *refspec;
-	assert(out_refspec && input);
-
-	*out_refspec = NULL;
-
-	refspec = git__malloc(sizeof(git_refspec));
-	GIT_ERROR_CHECK_ALLOC(refspec);
-
-	if (git_refspec__parse(refspec, input, !!is_fetch) != 0) {
-		git__free(refspec);
-		return -1;
-	}
-
-	*out_refspec = refspec;
-	return 0;
-}
-
-void git_refspec_free(git_refspec *refspec)
-{
-	git_refspec__dispose(refspec);
-	git__free(refspec);
-}
-
 const char *git_refspec_src(const git_refspec *refspec)
 {
 	return refspec == NULL ? NULL : refspec->src;
@@ -213,7 +187,7 @@ int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
 	if (refspec == NULL || refspec->src == NULL)
 		return false;
 
-	return (wildmatch(refspec->src, refname, 0) == 0);
+	return (p_fnmatch(refspec->src, refname, 0) == 0);
 }
 
 int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
@@ -221,13 +195,14 @@ int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
 	if (refspec == NULL || refspec->dst == NULL)
 		return false;
 
-	return (wildmatch(refspec->dst, refname, 0) == 0);
+	return (p_fnmatch(refspec->dst, refname, 0) == 0);
 }
 
 static int refspec_transform(
 	git_buf *out, const char *from, const char *to, const char *name)
 {
 	const char *from_star, *to_star;
+	const char *name_slash, *from_slash;
 	size_t replacement_len, star_offset;
 
 	git_buf_sanitize(out);
@@ -250,11 +225,17 @@ static int refspec_transform(
 	/* the first half is copied over */
 	git_buf_put(out, to, to_star - to);
 
-	/*
-	 * Copy over the name, but exclude the trailing part in "from" starting
-	 * after the glob
-	 */
-	replacement_len = strlen(name + star_offset) - strlen(from_star + 1);
+	/* then we copy over the replacement, from the star's offset to the next slash in 'name' */
+	name_slash = strchr(name + star_offset, '/');
+	if (!name_slash)
+		name_slash = strrchr(name, '\0');
+
+	/* if there is no slash after the star in 'from', we want to copy everything over */
+	from_slash = strchr(from + star_offset, '/');
+	if (!from_slash)
+		name_slash = strrchr(name, '\0');
+
+	replacement_len = (name_slash - name) - star_offset;
 	git_buf_put(out, name + star_offset, replacement_len);
 
 	return git_buf_puts(out, to_star + 1);
@@ -266,12 +247,12 @@ int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *nam
 	git_buf_sanitize(out);
 
 	if (!git_refspec_src_matches(spec, name)) {
-		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the source", name);
+		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the source", name);
 		return -1;
 	}
 
 	if (!spec->pattern)
-		return git_buf_puts(out, spec->dst ? spec->dst : "");
+		return git_buf_puts(out, spec->dst);
 
 	return refspec_transform(out, spec->src, spec->dst, name);
 }
@@ -282,7 +263,7 @@ int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *na
 	git_buf_sanitize(out);
 
 	if (!git_refspec_dst_matches(spec, name)) {
-		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the destination", name);
+		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the destination", name);
 		return -1;
 	}
 
@@ -335,7 +316,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 	assert(out && spec && refs);
 
 	cur = git__calloc(1, sizeof(git_refspec));
-	GIT_ERROR_CHECK_ALLOC(cur);
+	GITERR_CHECK_ALLOC(cur);
 
 	cur->force = spec->force;
 	cur->push = spec->push;
@@ -348,7 +329,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		for (j = 0; formatters[j]; j++) {
 			git_buf_clear(&buf);
 			git_buf_printf(&buf, formatters[j], spec->src);
-			GIT_ERROR_CHECK_ALLOC_BUF(&buf);
+			GITERR_CHECK_ALLOC_BUF(&buf);
 
 			key.name = (char *) git_buf_cstr(&buf);
 			if (!git_vector_search(&pos, refs, &key)) {
@@ -361,7 +342,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 	/* No shorthands found, copy over the name */
 	if (cur->src == NULL && spec->src != NULL) {
 		cur->src = git__strdup(spec->src);
-		GIT_ERROR_CHECK_ALLOC(cur->src);
+		GITERR_CHECK_ALLOC(cur->src);
 	}
 
 	if (spec->dst && git__prefixcmp(spec->dst, GIT_REFS_DIR)) {
@@ -373,16 +354,16 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		}
 
 		git_buf_puts(&buf, spec->dst);
-		GIT_ERROR_CHECK_ALLOC_BUF(&buf);
+		GITERR_CHECK_ALLOC_BUF(&buf);
 
 		cur->dst = git_buf_detach(&buf);
 	}
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	if (cur->dst == NULL && spec->dst != NULL) {
 		cur->dst = git__strdup(spec->dst);
-		GIT_ERROR_CHECK_ALLOC(cur->dst);
+		GITERR_CHECK_ALLOC(cur->dst);
 	}
 
 	return git_vector_insert(out, cur);

data/vendor/libgit2/src/refspec.h

@@ -30,7 +30,7 @@ int git_refspec__parse(
 	const char *str,
 	bool is_fetch);
 
-void git_refspec__dispose(git_refspec *refspec);
+void git_refspec__free(git_refspec *refspec);
 
 int git_refspec__serialize(git_buf *out, const git_refspec *refspec);
 

data/vendor/libgit2/src/remote.c

@@ -35,7 +35,7 @@ static int add_refspec_to(git_vector *vector, const char *string, bool is_fetch)
 	git_refspec *spec;
 
 	spec = git__calloc(1, sizeof(git_refspec));
-	GIT_ERROR_CHECK_ALLOC(spec);
+	GITERR_CHECK_ALLOC(spec);
 
 	if (git_refspec__parse(spec, string, is_fetch) < 0) {
 		git__free(spec);
@@ -44,7 +44,7 @@ static int add_refspec_to(git_vector *vector, const char *string, bool is_fetch)
 
 	spec->push = !is_fetch;
 	if (git_vector_insert(vector, spec) < 0) {
-		git_refspec__dispose(spec);
+		git_refspec__free(spec);
 		git__free(spec);
 		return -1;
 	}
@@ -67,7 +67,7 @@ static int download_tags_value(git_remote *remote, git_config *cfg)
 		return -1;
 
 	error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	if (!error && ce && ce->value) {
 		if (!strcmp(ce->value, "--no-tags"))
@@ -85,8 +85,8 @@ static int ensure_remote_name_is_valid(const char *name)
 	int error = 0;
 
 	if (!git_remote_is_valid_name(name)) {
-		git_error_set(
-			GIT_ERROR_CONFIG,
+		giterr_set(
+			GITERR_CONFIG,
 			"'%s' is not a valid remote name.", name ? name : "(null)");
 		error = GIT_EINVALIDSPEC;
 	}
@@ -111,13 +111,13 @@ static int write_add_refspec(git_repository *repo, const char *name, const char
 		return error;
 
 	if ((error = git_refspec__parse(&spec, refspec, fetch)) < 0) {
-		if (git_error_last()->klass != GIT_ERROR_NOMEMORY)
+		if (giterr_last()->klass != GITERR_NOMEMORY)
 			error = GIT_EINVALIDSPEC;
 
 		return error;
 	}
 
-	git_refspec__dispose(&spec);
+	git_refspec__free(&spec);
 
 	if ((error = git_buf_printf(&var, fmt, name)) < 0)
 		return error;
@@ -132,14 +132,43 @@ static int write_add_refspec(git_repository *repo, const char *name, const char
 	}
 
 cleanup:
-	git_buf_dispose(&var);
+	git_buf_free(&var);
 	return 0;
 }
 
+#if 0
+/* We could export this as a helper */
+static int get_check_cert(int *out, git_repository *repo)
+{
+	git_config *cfg;
+	const char *val;
+	int error = 0;
+
+	assert(out && repo);
+
+	/* By default, we *DO* want to verify the certificate. */
+	*out = 1;
+
+	/* Go through the possible sources for SSL verification settings, from
+	 * most specific to least specific. */
+
+	/* GIT_SSL_NO_VERIFY environment variable */
+	if ((val = p_getenv("GIT_SSL_NO_VERIFY")) != NULL)
+		return git_config_parse_bool(out, val);
+
+	/* http.sslVerify config setting */
+	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return error;
+
+	*out = git_config__get_bool_force(cfg, "http.sslverify", 1);
+	return 0;
+}
+#endif
+
 static int canonicalize_url(git_buf *out, const char *in)
 {
 	if (in == NULL || strlen(in) == 0) {
-		git_error_set(GIT_ERROR_INVALID, "cannot set empty URL");
+		giterr_set(GITERR_INVALID, "cannot set empty URL");
 		return GIT_EINVALIDSPEC;
 	}
 
@@ -160,124 +189,58 @@ static int canonicalize_url(git_buf *out, const char *in)
 	return git_buf_puts(out, in);
 }
 
-static int default_fetchspec_for_name(git_buf *buf, const char *name)
-{
-	if (git_buf_printf(buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
-		return -1;
-
-	return 0;
-}
-
-static int ensure_remote_doesnot_exist(git_repository *repo, const char *name)
+static int create_internal(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
 {
-	int error;
 	git_remote *remote;
-
-	error = git_remote_lookup(&remote, repo, name);
-
-	if (error == GIT_ENOTFOUND)
-		return 0;
-
-	if (error < 0)
-		return error;
-
-	git_remote_free(remote);
-
-	git_error_set(GIT_ERROR_CONFIG, "remote '%s' already exists", name);
-
-	return GIT_EEXISTS;
-}
-
-int git_remote_create_options_init(git_remote_create_options *opts, unsigned int version)
-{
-	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
-		opts, version, git_remote_create_options, GIT_REMOTE_CREATE_OPTIONS_INIT);
-	return 0;
-}
-
-int git_remote_create_init_options(git_remote_create_options *opts, unsigned int version)
-{
-	return git_remote_create_options_init(opts, version);
-}
-
-int git_remote_create_with_opts(git_remote **out, const char *url, const git_remote_create_options *opts)
-{
-	git_remote *remote = NULL;
 	git_config *config_ro = NULL, *config_rw;
 	git_buf canonical_url = GIT_BUF_INIT;
 	git_buf var = GIT_BUF_INIT;
-	git_buf specbuf = GIT_BUF_INIT;
-	const git_remote_create_options dummy_opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
 	int error = -1;
 
+	/* repo, name, and fetch are optional */
 	assert(out && url);
 
-	if (!opts) {
-		opts = &dummy_opts;
-	}
-
-	GIT_ERROR_CHECK_VERSION(opts, GIT_REMOTE_CREATE_OPTIONS_VERSION, "git_remote_create_options");
-
-	if (opts->name != NULL) {
-		if ((error = ensure_remote_name_is_valid(opts->name)) < 0)
-			return error;
-
-		if (opts->repository &&
-		    (error = ensure_remote_doesnot_exist(opts->repository, opts->name)) < 0)
-			return error;
-	}
-
-	if (opts->repository) {
-		if ((error = git_repository_config_snapshot(&config_ro, opts->repository)) < 0)
-			goto on_error;
-	}
+	if (repo && (error = git_repository_config_snapshot(&config_ro, repo)) < 0)
+		return error;
 
 	remote = git__calloc(1, sizeof(git_remote));
-	GIT_ERROR_CHECK_ALLOC(remote);
+	GITERR_CHECK_ALLOC(remote);
 
-	remote->repo = opts->repository;
+	remote->repo = repo;
 
-	if ((error = git_vector_init(&remote->refs, 8, NULL)) < 0 ||
+	if ((error = git_vector_init(&remote->refs, 32, NULL)) < 0 ||
 		(error = canonicalize_url(&canonical_url, url)) < 0)
 		goto on_error;
 
-	if (opts->repository && !(opts->flags & GIT_REMOTE_CREATE_SKIP_INSTEADOF)) {
+	if (repo) {
 		remote->url = apply_insteadof(config_ro, canonical_url.ptr, GIT_DIRECTION_FETCH);
 	} else {
 		remote->url = git__strdup(canonical_url.ptr);
 	}
-	GIT_ERROR_CHECK_ALLOC(remote->url);
+	GITERR_CHECK_ALLOC(remote->url);
 
-	if (opts->name != NULL) {
-		remote->name = git__strdup(opts->name);
-		GIT_ERROR_CHECK_ALLOC(remote->name);
+	if (name != NULL) {
+		remote->name = git__strdup(name);
+		GITERR_CHECK_ALLOC(remote->name);
 
-		if (opts->repository &&
-		    ((error = git_buf_printf(&var, CONFIG_URL_FMT, opts->name)) < 0 ||
-		    (error = git_repository_config__weakptr(&config_rw, opts->repository)) < 0 ||
-		    (error = git_config_set_string(config_rw, var.ptr, canonical_url.ptr)) < 0))
+		if ((error = git_buf_printf(&var, CONFIG_URL_FMT, name)) < 0)
 			goto on_error;
-	}
-
-	if (opts->fetchspec != NULL ||
-	    (opts->name && !(opts->flags & GIT_REMOTE_CREATE_SKIP_DEFAULT_FETCHSPEC))) {
-		const char *fetch = NULL;
-		if (opts->fetchspec) {
-			fetch = opts->fetchspec;
-		} else {
-			if ((error = default_fetchspec_for_name(&specbuf, opts->name)) < 0)
-				goto on_error;
 
-			fetch = git_buf_cstr(&specbuf);
-		}
+		if (repo &&
+			((error = git_repository_config__weakptr(&config_rw, repo)) < 0 ||
+			(error = git_config_set_string(config_rw, var.ptr, canonical_url.ptr)) < 0))
+			goto on_error;
+	}
 
+	if (fetch != NULL) {
 		if ((error = add_refspec(remote, fetch, true)) < 0)
 			goto on_error;
 
-		/* only write for named remotes with a repository */
-		if (opts->repository && opts->name &&
-		    ((error = write_add_refspec(opts->repository, opts->name, fetch, true)) < 0 ||
-		    (error = lookup_remote_prune_config(remote, config_ro, opts->name)) < 0))
+		/* only write for non-anonymous remotes */
+		if (repo && name && (error = write_add_refspec(repo, name, fetch, true)) < 0)
+			goto on_error;
+
+		if (repo && (error = lookup_remote_prune_config(remote, config_ro, name)) < 0)
 			goto on_error;
 
 		/* Move the data over to where the matching functions can find them */
@@ -286,13 +249,13 @@ int git_remote_create_with_opts(git_remote **out, const char *url, const git_rem
 	}
 
 	/* A remote without a name doesn't download tags */
-	if (!opts->name)
+	if (!name)
 		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
 	else
 		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;
 
 
-	git_buf_dispose(&var);
+	git_buf_free(&var);
 
 	*out = remote;
 	error = 0;
@@ -302,65 +265,79 @@ on_error:
 		git_remote_free(remote);
 
 	git_config_free(config_ro);
-	git_buf_dispose(&specbuf);
-	git_buf_dispose(&canonical_url);
-	git_buf_dispose(&var);
+	git_buf_free(&canonical_url);
+	git_buf_free(&var);
 	return error;
 }
 
-int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)
+static int ensure_remote_doesnot_exist(git_repository *repo, const char *name)
 {
-	git_buf buf = GIT_BUF_INIT;
 	int error;
-	git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
+	git_remote *remote;
 
-	/* Those 2 tests are duplicated here because of backward-compatibility */
-	if ((error = ensure_remote_name_is_valid(name)) < 0)
+	error = git_remote_lookup(&remote, repo, name);
+
+	if (error == GIT_ENOTFOUND)
+		return 0;
+
+	if (error < 0)
 		return error;
 
-	if (canonicalize_url(&buf, url) < 0)
-		return GIT_ERROR;
+	git_remote_free(remote);
+
+	giterr_set(
+		GITERR_CONFIG,
+		"remote '%s' already exists", name);
+
+	return GIT_EEXISTS;
+}
 
-	git_buf_clear(&buf);
 
-	opts.repository = repo;
-	opts.name = name;
+int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)
+{
+	git_buf buf = GIT_BUF_INIT;
+	int error;
 
-	error = git_remote_create_with_opts(out, url, &opts);
+	if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
+		return -1;
 
-	git_buf_dispose(&buf);
+	error = git_remote_create_with_fetchspec(out, repo, name, url, git_buf_cstr(&buf));
+	git_buf_free(&buf);
 
 	return error;
 }
 
 int git_remote_create_with_fetchspec(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
 {
+	git_remote *remote = NULL;
 	int error;
-	git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
 
 	if ((error = ensure_remote_name_is_valid(name)) < 0)
 		return error;
 
-	opts.repository = repo;
-	opts.name = name;
-	opts.fetchspec = fetch;
-	opts.flags = GIT_REMOTE_CREATE_SKIP_DEFAULT_FETCHSPEC;
+	if ((error = ensure_remote_doesnot_exist(repo, name)) < 0)
+		return error;
+
+	if (create_internal(&remote, repo, name, url, fetch) < 0)
+		goto on_error;
+
+	*out = remote;
+
+	return 0;
 
-	return git_remote_create_with_opts(out, url, &opts);
+on_error:
+	git_remote_free(remote);
+	return -1;
 }
 
 int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url)
 {
-	git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
-
-	opts.repository = repo;
-
-	return git_remote_create_with_opts(out, url, &opts);
+	return create_internal(out, repo, NULL, url, NULL);
 }
 
 int git_remote_create_detached(git_remote **out, const char *url)
 {
-	return git_remote_create_with_opts(out, url, NULL);
+	return create_internal(out, NULL, NULL, url, NULL);
 }
 
 int git_remote_dup(git_remote **dest, git_remote *source)
@@ -369,21 +346,21 @@ int git_remote_dup(git_remote **dest, git_remote *source)
 	int error = 0;
 	git_refspec *spec;
 	git_remote *remote = git__calloc(1, sizeof(git_remote));
-	GIT_ERROR_CHECK_ALLOC(remote);
+	GITERR_CHECK_ALLOC(remote);
 
 	if (source->name != NULL) {
 		remote->name = git__strdup(source->name);
-		GIT_ERROR_CHECK_ALLOC(remote->name);
+		GITERR_CHECK_ALLOC(remote->name);
 	}
 
 	if (source->url != NULL) {
 		remote->url = git__strdup(source->url);
-		GIT_ERROR_CHECK_ALLOC(remote->url);
+		GITERR_CHECK_ALLOC(remote->url);
 	}
 
 	if (source->pushurl != NULL) {
 		remote->pushurl = git__strdup(source->pushurl);
-		GIT_ERROR_CHECK_ALLOC(remote->pushurl);
+		GITERR_CHECK_ALLOC(remote->pushurl);
 	}
 
 	remote->repo = source->repo;
@@ -442,7 +419,7 @@ static int get_optional_config(
 		*found = !error;
 
 	if (error == GIT_ENOTFOUND) {
-		git_error_clear();
+		giterr_clear();
 		error = 0;
 	}
 
@@ -468,10 +445,10 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 		return error;
 
 	remote = git__calloc(1, sizeof(git_remote));
-	GIT_ERROR_CHECK_ALLOC(remote);
+	GITERR_CHECK_ALLOC(remote);
 
 	remote->name = git__strdup(name);
-	GIT_ERROR_CHECK_ALLOC(remote->name);
+	GITERR_CHECK_ALLOC(remote->name);
 
 	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
 	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||
@@ -494,7 +471,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 
 	if (found && strlen(val) > 0) {
 		remote->url = apply_insteadof(config, val, GIT_DIRECTION_FETCH);
-		GIT_ERROR_CHECK_ALLOC(remote->url);
+		GITERR_CHECK_ALLOC(remote->url);
 	}
 
 	val = NULL;
@@ -508,13 +485,13 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 
 	if (!optional_setting_found) {
 		error = GIT_ENOTFOUND;
-		git_error_set(GIT_ERROR_CONFIG, "remote '%s' does not exist", name);
+		giterr_set(GITERR_CONFIG, "remote '%s' does not exist", name);
 		goto cleanup;
 	}
 
 	if (found && strlen(val) > 0) {
 		remote->pushurl = apply_insteadof(config, val, GIT_DIRECTION_PUSH);
-		GIT_ERROR_CHECK_ALLOC(remote->pushurl);
+		GITERR_CHECK_ALLOC(remote->pushurl);
 	}
 
 	data.remote = remote;
@@ -547,7 +524,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 
 cleanup:
 	git_config_free(config);
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	if (error < 0)
 		git_remote_free(remote);
@@ -564,18 +541,18 @@ static int lookup_remote_prune_config(git_remote *remote, git_config *config, co
 
 	if ((error = git_config_get_bool(&remote->prune_refs, config, git_buf_cstr(&buf))) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 
 			if ((error = git_config_get_bool(&remote->prune_refs, config, "fetch.prune")) < 0) {
 				if (error == GIT_ENOTFOUND) {
-					git_error_clear();
+					giterr_clear();
 					error = 0;
 				}
 			}
 		}
 	}
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	return error;
 }
 
@@ -624,8 +601,8 @@ static int set_url(git_repository *repo, const char *remote, const char *pattern
 	}
 
 cleanup:
-	git_buf_dispose(&canonical_url);
-	git_buf_dispose(&buf);
+	git_buf_free(&canonical_url);
+	git_buf_free(&buf);
 
 	return error;
 }
@@ -646,44 +623,21 @@ int git_remote_set_pushurl(git_repository *repo, const char *remote, const char*
 	return set_url(repo, remote, CONFIG_PUSHURL_FMT, url);
 }
 
-static int resolve_url(git_buf *resolved_url, const char *url, int direction, const git_remote_callbacks *callbacks)
+const char* git_remote__urlfordirection(git_remote *remote, int direction)
 {
-	int status;
-
-	if (callbacks && callbacks->resolve_url) {
-		git_buf_clear(resolved_url);
-		status = callbacks->resolve_url(resolved_url, url, direction, callbacks->payload);
-		if (status != GIT_PASSTHROUGH) {
-			git_error_set_after_callback_function(status, "git_resolve_url_cb");
-			git_buf_sanitize(resolved_url);
-			return status;
-		}
-	}
-
-	return git_buf_sets(resolved_url, url);
-}
-
-int git_remote__urlfordirection(git_buf *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks)
-{
-	const char *url = NULL;
-
 	assert(remote);
+
 	assert(direction == GIT_DIRECTION_FETCH || direction == GIT_DIRECTION_PUSH);
 
 	if (direction == GIT_DIRECTION_FETCH) {
-		url = remote->url;
-	} else if (direction == GIT_DIRECTION_PUSH) {
-		url = remote->pushurl ? remote->pushurl : remote->url;
+		return remote->url;
 	}
 
-	if (!url) {
-		git_error_set(GIT_ERROR_INVALID,
-			"malformed remote '%s' - missing %s URL",
-			remote->name ? remote->name : "(anonymous)",
-			direction == GIT_DIRECTION_FETCH ? "fetch" : "push");
-		return GIT_EINVALID;
+	if (direction == GIT_DIRECTION_PUSH) {
+		return remote->pushurl ? remote->pushurl : remote->url;
 	}
-	return resolve_url(url_out, url, direction, callbacks);
+
+	return NULL;
 }
 
 int set_transport_callbacks(git_transport *t, const git_remote_callbacks *cbs)
@@ -703,10 +657,10 @@ static int set_transport_custom_headers(git_transport *t, const git_strarray *cu
 	return t->set_custom_headers(t, custom_headers);
 }
 
-int git_remote__connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_remote_connection_opts *conn)
+int git_remote_connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_proxy_options *proxy, const git_strarray *custom_headers)
 {
 	git_transport *t;
-	git_buf url = GIT_BUF_INIT;
+	const char *url;
 	int flags = GIT_TRANSPORTFLAGS_NONE;
 	int error;
 	void *payload = NULL;
@@ -716,49 +670,50 @@ int git_remote__connect(git_remote *remote, git_direction direction, const git_r
 	assert(remote);
 
 	if (callbacks) {
-		GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		credentials = callbacks->credentials;
 		transport   = callbacks->transport;
 		payload     = callbacks->payload;
 	}
 
-	if (conn->proxy)
-		GIT_ERROR_CHECK_VERSION(conn->proxy, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+	if (proxy)
+		GITERR_CHECK_VERSION(proxy, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 
 	t = remote->transport;
 
-	if ((error = git_remote__urlfordirection(&url, remote, direction, callbacks)) < 0)
-		goto on_error;
+	url = git_remote__urlfordirection(remote, direction);
+	if (url == NULL) {
+		giterr_set(GITERR_INVALID,
+			"Malformed remote '%s' - missing %s URL",
+			remote->name ? remote->name : "(anonymous)",
+			direction == GIT_DIRECTION_FETCH ? "fetch" : "push");
+		return -1;
+	}
 
 	/* If we don't have a transport object yet, and the caller specified a
 	 * custom transport factory, use that */
 	if (!t && transport &&
 		(error = transport(&t, remote, payload)) < 0)
-		goto on_error;
+		return error;
 
 	/* If we still don't have a transport, then use the global
 	 * transport registrations which map URI schemes to transport factories */
-	if (!t && (error = git_transport_new(&t, remote, url.ptr)) < 0)
-		goto on_error;
+	if (!t && (error = git_transport_new(&t, remote, url)) < 0)
+		return error;
 
-	if ((error = set_transport_custom_headers(t, conn->custom_headers)) != 0)
+	if ((error = set_transport_custom_headers(t, custom_headers)) != 0)
 		goto on_error;
 
 	if ((error = set_transport_callbacks(t, callbacks)) < 0 ||
-	    (error = t->connect(t, url.ptr, credentials, payload, conn->proxy, direction, flags)) != 0)
+	    (error = t->connect(t, url, credentials, payload, proxy, direction, flags)) != 0)
 		goto on_error;
 
 	remote->transport = t;
 
-	git_buf_dispose(&url);
-
 	return 0;
 
 on_error:
-	if (t)
-		t->free(t);
-
-	git_buf_dispose(&url);
+	t->free(t);
 
 	if (t == remote->transport)
 		remote->transport = NULL;
@@ -766,22 +721,12 @@ on_error:
 	return error;
 }
 
-int git_remote_connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_proxy_options *proxy, const git_strarray *custom_headers)
-{
-	git_remote_connection_opts conn;
-
-	conn.proxy = proxy;
-	conn.custom_headers = custom_headers;
-
-	return git_remote__connect(remote, direction, callbacks, &conn);
-}
-
 int git_remote_ls(const git_remote_head ***out, size_t *size, git_remote *remote)
 {
 	assert(remote);
 
 	if (!remote->transport) {
-		git_error_set(GIT_ERROR_NET, "this remote has never connected");
+		giterr_set(GITERR_NET, "this remote has never connected");
 		return -1;
 	}
 
@@ -816,7 +761,7 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 			return error;
 
 		error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);
-		git_buf_dispose(&buf);
+		git_buf_free(&buf);
 
 		if (error < 0)
 			return error;
@@ -845,7 +790,7 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 
 	if (error < 0) {
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 
@@ -855,7 +800,7 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 	*proxy_url = git_buf_detach(&val);
 
 found:
-	GIT_ERROR_CHECK_ALLOC(*proxy_url);
+	GITERR_CHECK_ALLOC(*proxy_url);
 	git_config_entry_free(ce);
 
 	return 0;
@@ -881,7 +826,7 @@ static void free_refspecs(git_vector *vec)
 	git_refspec *spec;
 
 	git_vector_foreach(vec, i, spec) {
-		git_refspec__dispose(spec);
+		git_refspec__free(spec);
 		git__free(spec);
 	}
 
@@ -927,15 +872,15 @@ int git_remote_download(git_remote *remote, const git_strarray *refspecs, const
 	assert(remote);
 
 	if (!remote->repo) {
-		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
+		giterr_set(GITERR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
-		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
 		custom_headers = &opts->custom_headers;
-		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 		proxy = &opts->proxy_opts;
 	}
 
@@ -1004,20 +949,21 @@ int git_remote_fetch(
 	bool prune = false;
 	git_buf reflog_msg_buf = GIT_BUF_INIT;
 	const git_remote_callbacks *cbs = NULL;
-	git_remote_connection_opts conn = GIT_REMOTE_CONNECTION_OPTIONS_INIT;
+	const git_strarray *custom_headers = NULL;
+	const git_proxy_options *proxy = NULL;
 
 	if (opts) {
-		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
-		conn.custom_headers = &opts->custom_headers;
+		custom_headers = &opts->custom_headers;
 		update_fetchhead = opts->update_fetchhead;
 		tagopt = opts->download_tags;
-		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
-		conn.proxy = &opts->proxy_opts;
+		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		proxy = &opts->proxy_opts;
 	}
 
 	/* Connect and download everything */
-	if ((error = git_remote__connect(remote, GIT_DIRECTION_FETCH, cbs, &conn)) != 0)
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, cbs, proxy, custom_headers)) != 0)
 		return error;
 
 	error = git_remote_download(remote, refspecs, opts);
@@ -1039,7 +985,7 @@ int git_remote_fetch(
 
 	/* Create "remote/foo" branches for all remote branches */
 	error = git_remote_update_tips(remote, cbs, update_fetchhead, tagopt, git_buf_cstr(&reflog_msg_buf));
-	git_buf_dispose(&reflog_msg_buf);
+	git_buf_free(&reflog_msg_buf);
 	if (error < 0)
 		return error;
 
@@ -1095,7 +1041,7 @@ static int ref_to_update(int *update, git_buf *remote_name, git_remote *remote,
 	    (error = git_refspec_rtransform(remote_name, spec, upstream_name.ptr)) < 0) {
 		/* Not an error if there is no upstream */
 		if (error == GIT_ENOTFOUND) {
-			git_error_clear();
+			giterr_clear();
 			error = 0;
 		}
 
@@ -1104,8 +1050,8 @@ static int ref_to_update(int *update, git_buf *remote_name, git_remote *remote,
 		*update = 1;
 	}
 
-	git_buf_dispose(&upstream_remote);
-	git_buf_dispose(&upstream_name);
+	git_buf_free(&upstream_remote);
+	git_buf_free(&upstream_name);
 	return error;
 }
 
@@ -1124,7 +1070,7 @@ static int remote_head_for_ref(git_remote_head **out, git_remote *remote, git_re
 	error = git_reference_resolve(&resolved_ref, ref);
 
 	/* If we're in an unborn branch, let's pretend nothing happened */
-	if (error == GIT_ENOTFOUND && git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
+	if (error == GIT_ENOTFOUND && git_reference_type(ref) == GIT_REF_SYMBOLIC) {
 		ref_name = git_reference_symbolic_target(ref);
 		error = 0;
 	} else {
@@ -1138,7 +1084,7 @@ static int remote_head_for_ref(git_remote_head **out, git_remote *remote, git_re
 		error = remote_head_for_fetchspec_src(out, update_heads, git_buf_cstr(&remote_name));
 
 cleanup:
-	git_buf_dispose(&remote_name);
+	git_buf_free(&remote_name);
 	git_reference_free(resolved_ref);
 	git_config_free(config);
 	return error;
@@ -1230,7 +1176,7 @@ static int prune_candidates(git_vector *candidates, git_remote *remote)
 			continue;
 
 		refname_dup = git__strdup(refname);
-		GIT_ERROR_CHECK_ALLOC(refname_dup);
+		GITERR_CHECK_ALLOC(refname_dup);
 
 		if ((error = git_vector_insert(candidates, refname_dup)) < 0)
 			goto out;
@@ -1260,7 +1206,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 	git_oid zero_id = {{ 0 }};
 
 	if (callbacks)
-		GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 
 	if ((error = ls_to_vector(&remote_refs, remote)) < 0)
 		goto cleanup;
@@ -1289,7 +1235,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 
 			key.name = (char *) git_buf_cstr(&buf);
 			error = git_vector_bsearch(&pos, &remote_refs, &key);
-			git_buf_dispose(&buf);
+			git_buf_free(&buf);
 
 			if (error < 0 && error != GIT_ENOTFOUND)
 				goto cleanup;
@@ -1327,7 +1273,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 		if (error < 0)
 			goto cleanup;
 
-		if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
+		if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
 			git_reference_free(ref);
 			continue;
 		}
@@ -1448,7 +1394,7 @@ static int update_tips_for_spec(
 			continue;
 
 		/* In autotag mode, don't overwrite any locally-existing tags */
-		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag,
+		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, 
 				log_message);
 
 		if (error == GIT_EEXISTS)
@@ -1470,14 +1416,14 @@ static int update_tips_for_spec(
 		goto on_error;
 
 	git_vector_free(&update_heads);
-	git_refspec__dispose(&tagspec);
-	git_buf_dispose(&refname);
+	git_refspec__free(&tagspec);
+	git_buf_free(&refname);
 	return 0;
 
 on_error:
 	git_vector_free(&update_heads);
-	git_refspec__dispose(&tagspec);
-	git_buf_dispose(&refname);
+	git_refspec__free(&tagspec);
+	git_buf_free(&refname);
 	return -1;
 
 }
@@ -1591,7 +1537,7 @@ static int opportunistic_updates(const git_remote *remote, const git_remote_call
 		error = 0;
 
 cleanup:
-	git_buf_dispose(&refname);
+	git_buf_free(&refname);
 	return error;
 }
 
@@ -1604,7 +1550,7 @@ static int truncate_fetch_head(const char *gitdir)
 		return error;
 
 	error = git_futils_truncate(path.ptr, GIT_REFS_FILE_MODE);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
@@ -1661,7 +1607,7 @@ int git_remote_update_tips(
 
 out:
 	git_vector_free(&refs);
-	git_refspec__dispose(&tagspec);
+	git_refspec__free(&tagspec);
 	return error;
 }
 
@@ -1735,7 +1681,7 @@ static int remote_list_cb(const git_config_entry *entry, void *payload)
 		remote_name = git__strndup(name, namelen - 4); /* strip ".url" */
 	else
 		remote_name = git__strndup(name, namelen - 8); /* strip ".pushurl" */
-	GIT_ERROR_CHECK_ALLOC(remote_name);
+	GITERR_CHECK_ALLOC(remote_name);
 
 	return git_vector_insert(list, remote_name);
 }
@@ -1768,7 +1714,7 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 	return 0;
 }
 
-const git_indexer_progress *git_remote_stats(git_remote *remote)
+const git_transfer_progress* git_remote_stats(git_remote *remote)
 {
 	assert(remote);
 	return &remote->stats;
@@ -1809,11 +1755,11 @@ int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_
 			error = 0;
 		break;
 	default:
-		git_error_set(GIT_ERROR_INVALID, "invalid value for the tagopt setting");
+		giterr_set(GITERR_INVALID, "invalid value for the tagopt setting");
 		error = -1;
 	}
 
-	git_buf_dispose(&var);
+	git_buf_free(&var);
 	return error;
 }
 
@@ -1844,8 +1790,8 @@ static int rename_remote_config_section(
 		new_name ? git_buf_cstr(&new_section_name) : NULL);
 
 cleanup:
-	git_buf_dispose(&old_section_name);
-	git_buf_dispose(&new_section_name);
+	git_buf_free(&old_section_name);
+	git_buf_free(&new_section_name);
 
 	return error;
 }
@@ -1917,7 +1863,7 @@ static int rename_one_remote_reference(
 					  git_buf_cstr(&log_message))) < 0)
 		goto cleanup;
 
-	if (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC)
+	if (git_reference_type(ref) != GIT_REF_SYMBOLIC)
 		goto cleanup;
 
 	/* Handle refs like origin/HEAD -> origin/master */
@@ -1941,10 +1887,10 @@ static int rename_one_remote_reference(
 cleanup:
 	git_reference_free(reference_in);
 	git_reference_free(ref);
-	git_buf_dispose(&namespace);
-	git_buf_dispose(&old_namespace);
-	git_buf_dispose(&new_name);
-	git_buf_dispose(&log_message);
+	git_buf_free(&namespace);
+	git_buf_free(&old_namespace);
+	git_buf_free(&new_name);
+	git_buf_free(&log_message);
 	return error;
 }
 
@@ -1962,7 +1908,7 @@ static int rename_remote_references(
 		return error;
 
 	error = git_reference_iterator_glob_new(&iter, repo, git_buf_cstr(&buf));
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 
 	if (error < 0)
 		return error;
@@ -1991,7 +1937,8 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 	if ((error = git_vector_init(problems, 1, NULL)) < 0)
 		return error;
 
-	if ((error = default_fetchspec_for_name(&base, remote->name)) < 0)
+	if ((error = git_buf_printf(
+			&base, "+refs/heads/*:refs/remotes/%s/*", remote->name)) < 0)
 		return error;
 
 	git_vector_foreach(&remote->refspecs, i, spec) {
@@ -2003,7 +1950,7 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 			char *dup;
 
 			dup = git__strdup(spec->string);
-			GIT_ERROR_CHECK_ALLOC(dup);
+			GITERR_CHECK_ALLOC(dup);
 
 			if ((error = git_vector_insert(problems, dup)) < 0)
 				break;
@@ -2016,7 +1963,8 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 		git_buf_clear(&val);
 		git_buf_clear(&var);
 
-		if (default_fetchspec_for_name(&val, new_name) < 0 ||
+		if (git_buf_printf(
+				&val, "+refs/heads/*:refs/remotes/%s/*", new_name) < 0 ||
 			git_buf_printf(&var, "remote.%s.fetch", new_name) < 0)
 		{
 			error = -1;
@@ -2028,9 +1976,9 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 			break;
 	}
 
-	git_buf_dispose(&base);
-	git_buf_dispose(&var);
-	git_buf_dispose(&val);
+	git_buf_free(&base);
+	git_buf_free(&var);
+	git_buf_free(&val);
 
 	if (error < 0) {
 		char *str;
@@ -2096,10 +2044,10 @@ int git_remote_is_valid_name(
 	git_buf_printf(&buf, "refs/heads/test:refs/remotes/%s/test", remote_name);
 	error = git_refspec__parse(&refspec, git_buf_cstr(&buf), true);
 
-	git_buf_dispose(&buf);
-	git_refspec__dispose(&refspec);
+	git_buf_free(&buf);
+	git_refspec__free(&refspec);
 
-	git_error_clear();
+	giterr_clear();
 	return error == 0;
 }
 
@@ -2254,7 +2202,7 @@ static int remove_branch_config_related_entries(
 		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) {
 			if (error != GIT_ENOTFOUND)
 				break;
-			git_error_clear();
+			giterr_clear();
 		}
 
 		git_buf_clear(&buf);
@@ -2264,14 +2212,14 @@ static int remove_branch_config_related_entries(
 		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) {
 			if (error != GIT_ENOTFOUND)
 				break;
-			git_error_clear();
+			giterr_clear();
 		}
 	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-	git_buf_dispose(&buf);
+	git_buf_free(&buf);
 	git_config_iterator_free(iter);
 	return error;
 }
@@ -2425,23 +2373,24 @@ int git_remote_upload(git_remote *remote, const git_strarray *refspecs, const gi
 	git_push *push;
 	git_refspec *spec;
 	const git_remote_callbacks *cbs = NULL;
-	git_remote_connection_opts conn = GIT_REMOTE_CONNECTION_OPTIONS_INIT;
+	const git_strarray *custom_headers = NULL;
+	const git_proxy_options *proxy = NULL;
 
 	assert(remote);
 
 	if (!remote->repo) {
-		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
+		giterr_set(GITERR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
 		cbs = &opts->callbacks;
-		conn.custom_headers = &opts->custom_headers;
-		conn.proxy = &opts->proxy_opts;
+		custom_headers = &opts->custom_headers;
+		proxy = &opts->proxy_opts;
 	}
 
 	if (!git_remote_connected(remote) &&
-	    (error = git_remote__connect(remote, GIT_DIRECTION_PUSH, cbs, &conn)) < 0)
+	    (error = git_remote_connect(remote, GIT_DIRECTION_PUSH, cbs, proxy, custom_headers)) < 0)
 		goto cleanup;
 
 	free_refspecs(&remote->active_refspecs);
@@ -2496,15 +2445,15 @@ int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_
 	assert(remote);
 
 	if (!remote->repo) {
-		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
+		giterr_set(GITERR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
-		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
 		custom_headers = &opts->custom_headers;
-		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 		proxy = &opts->proxy_opts;
 	}