rugged 0.27.10.1 → 0.28.0

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_REF_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
-#define GIT_REF_FORMAT__VALIDATION_DISABLE	(1u << 15)
+#define GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
+#define GIT_REFERENCE_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_ref_t type;
+	git_reference_t type;
 
 	union {
 		git_oid oid;
@@ -136,4 +136,6 @@ 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

@@ -16,7 +16,7 @@
 
 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);
-		GITERR_CHECK_ALLOC(refspec->string);
+		GIT_ERROR_CHECK_ALLOC(refspec->string);
 		refspec->src = git__strdup("");
-		GITERR_CHECK_ALLOC(refspec->src);
+		GIT_ERROR_CHECK_ALLOC(refspec->src);
 		refspec->dst = git__strdup("");
-		GITERR_CHECK_ALLOC(refspec->dst);
+		GIT_ERROR_CHECK_ALLOC(refspec->dst);
 		return 0;
 	}
 
@@ -69,8 +69,9 @@ 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_REF_FORMAT_ALLOW_ONELEVEL | GIT_REF_FORMAT_REFSPEC_SHORTHAND
-		| (is_glob ? GIT_REF_FORMAT_REFSPEC_PATTERN : 0);
+	flags = GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL |
+		GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND |
+		(is_glob ? GIT_REFERENCE_FORMAT_REFSPEC_PATTERN : 0);
 
 	if (is_fetch) {
 		/*
@@ -131,24 +132,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);
-			GITERR_CHECK_ALLOC(refspec->dst);
+			GIT_ERROR_CHECK_ALLOC(refspec->dst);
 		}
 	}
 
 	refspec->string = git__strdup(input);
-	GITERR_CHECK_ALLOC(refspec->string);
+	GIT_ERROR_CHECK_ALLOC(refspec->string);
 
 	return 0;
 
  invalid:
-        giterr_set(
-                GITERR_INVALID,
+        git_error_set(
+                GIT_ERROR_INVALID,
                 "'%s' is not a valid refspec.", input);
-        git_refspec__free(refspec);
+        git_refspec__dispose(refspec);
 	return -1;
 }
 
-void git_refspec__free(git_refspec *refspec)
+void git_refspec__dispose(git_refspec *refspec)
 {
 	if (refspec == NULL)
 		return;
@@ -160,6 +161,31 @@ void git_refspec__free(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;
@@ -247,12 +273,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)) {
-		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the source", name);
+		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the source", name);
 		return -1;
 	}
 
 	if (!spec->pattern)
-		return git_buf_puts(out, spec->dst);
+		return git_buf_puts(out, spec->dst ? spec->dst : "");
 
 	return refspec_transform(out, spec->src, spec->dst, name);
 }
@@ -263,7 +289,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)) {
-		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the destination", name);
+		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the destination", name);
 		return -1;
 	}
 
@@ -316,7 +342,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));
-	GITERR_CHECK_ALLOC(cur);
+	GIT_ERROR_CHECK_ALLOC(cur);
 
 	cur->force = spec->force;
 	cur->push = spec->push;
@@ -329,7 +355,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);
-			GITERR_CHECK_ALLOC_BUF(&buf);
+			GIT_ERROR_CHECK_ALLOC_BUF(&buf);
 
 			key.name = (char *) git_buf_cstr(&buf);
 			if (!git_vector_search(&pos, refs, &key)) {
@@ -342,7 +368,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);
-		GITERR_CHECK_ALLOC(cur->src);
+		GIT_ERROR_CHECK_ALLOC(cur->src);
 	}
 
 	if (spec->dst && git__prefixcmp(spec->dst, GIT_REFS_DIR)) {
@@ -354,16 +380,16 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		}
 
 		git_buf_puts(&buf, spec->dst);
-		GITERR_CHECK_ALLOC_BUF(&buf);
+		GIT_ERROR_CHECK_ALLOC_BUF(&buf);
 
 		cur->dst = git_buf_detach(&buf);
 	}
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (cur->dst == NULL && spec->dst != NULL) {
 		cur->dst = git__strdup(spec->dst);
-		GITERR_CHECK_ALLOC(cur->dst);
+		GIT_ERROR_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__free(git_refspec *refspec);
+void git_refspec__dispose(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));
-	GITERR_CHECK_ALLOC(spec);
+	GIT_ERROR_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__free(spec);
+		git_refspec__dispose(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_free(&buf);
+	git_buf_dispose(&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)) {
-		giterr_set(
-			GITERR_CONFIG,
+		git_error_set(
+			GIT_ERROR_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 (giterr_last()->klass != GITERR_NOMEMORY)
+		if (git_error_last()->klass != GIT_ERROR_NOMEMORY)
 			error = GIT_EINVALIDSPEC;
 
 		return error;
 	}
 
-	git_refspec__free(&spec);
+	git_refspec__dispose(&spec);
 
 	if ((error = git_buf_printf(&var, fmt, name)) < 0)
 		return error;
@@ -132,7 +132,7 @@ static int write_add_refspec(git_repository *repo, const char *name, const char
 	}
 
 cleanup:
-	git_buf_free(&var);
+	git_buf_dispose(&var);
 	return 0;
 }
 
@@ -168,7 +168,7 @@ static int get_check_cert(int *out, git_repository *repo)
 static int canonicalize_url(git_buf *out, const char *in)
 {
 	if (in == NULL || strlen(in) == 0) {
-		giterr_set(GITERR_INVALID, "cannot set empty URL");
+		git_error_set(GIT_ERROR_INVALID, "cannot set empty URL");
 		return GIT_EINVALIDSPEC;
 	}
 
@@ -189,58 +189,119 @@ static int canonicalize_url(git_buf *out, const char *in)
 	return git_buf_puts(out, in);
 }
 
-static int create_internal(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
+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)
+{
+	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_init_options(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_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 (repo && (error = git_repository_config_snapshot(&config_ro, repo)) < 0)
-		return error;
+	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;
+	}
 
 	remote = git__calloc(1, sizeof(git_remote));
-	GITERR_CHECK_ALLOC(remote);
+	GIT_ERROR_CHECK_ALLOC(remote);
 
-	remote->repo = repo;
+	remote->repo = opts->repository;
 
-	if ((error = git_vector_init(&remote->refs, 32, NULL)) < 0 ||
+	if ((error = git_vector_init(&remote->refs, 8, NULL)) < 0 ||
 		(error = canonicalize_url(&canonical_url, url)) < 0)
 		goto on_error;
 
-	if (repo) {
+	if (opts->repository && !(opts->flags & GIT_REMOTE_CREATE_SKIP_INSTEADOF)) {
 		remote->url = apply_insteadof(config_ro, canonical_url.ptr, GIT_DIRECTION_FETCH);
 	} else {
 		remote->url = git__strdup(canonical_url.ptr);
 	}
-	GITERR_CHECK_ALLOC(remote->url);
-
-	if (name != NULL) {
-		remote->name = git__strdup(name);
-		GITERR_CHECK_ALLOC(remote->name);
+	GIT_ERROR_CHECK_ALLOC(remote->url);
 
-		if ((error = git_buf_printf(&var, CONFIG_URL_FMT, name)) < 0)
-			goto on_error;
+	if (opts->name != NULL) {
+		remote->name = git__strdup(opts->name);
+		GIT_ERROR_CHECK_ALLOC(remote->name);
 
-		if (repo &&
-			((error = git_repository_config__weakptr(&config_rw, repo)) < 0 ||
-			(error = git_config_set_string(config_rw, var.ptr, canonical_url.ptr)) < 0))
+		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))
 			goto on_error;
 	}
 
-	if (fetch != NULL) {
-		if ((error = add_refspec(remote, fetch, true)) < 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;
 
-		/* only write for non-anonymous remotes */
-		if (repo && name && (error = write_add_refspec(repo, name, fetch, true)) < 0)
+			fetch = git_buf_cstr(&specbuf);
+		}
+
+		if ((error = add_refspec(remote, fetch, true)) < 0)
 			goto on_error;
 
-		if (repo && (error = lookup_remote_prune_config(remote, config_ro, name)) < 0)
+		/* 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))
 			goto on_error;
 
 		/* Move the data over to where the matching functions can find them */
@@ -249,13 +310,13 @@ static int create_internal(git_remote **out, git_repository *repo, const char *n
 	}
 
 	/* A remote without a name doesn't download tags */
-	if (!name)
+	if (!opts->name)
 		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
 	else
 		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;
 
 
-	git_buf_free(&var);
+	git_buf_dispose(&var);
 
 	*out = remote;
 	error = 0;
@@ -265,79 +326,65 @@ on_error:
 		git_remote_free(remote);
 
 	git_config_free(config_ro);
-	git_buf_free(&canonical_url);
-	git_buf_free(&var);
+	git_buf_dispose(&specbuf);
+	git_buf_dispose(&canonical_url);
+	git_buf_dispose(&var);
 	return error;
 }
 
-static int ensure_remote_doesnot_exist(git_repository *repo, const char *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;
-	git_remote *remote;
+	git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
 
-	error = git_remote_lookup(&remote, repo, name);
-
-	if (error == GIT_ENOTFOUND)
-		return 0;
-
-	if (error < 0)
+	/* Those 2 tests are duplicated here because of backward-compatibility */
+	if ((error = ensure_remote_name_is_valid(name)) < 0)
 		return error;
 
-	git_remote_free(remote);
-
-	giterr_set(
-		GITERR_CONFIG,
-		"remote '%s' already exists", name);
-
-	return GIT_EEXISTS;
-}
+	if (canonicalize_url(&buf, url) < 0)
+		return GIT_ERROR;
 
+	git_buf_clear(&buf);
 
-int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)
-{
-	git_buf buf = GIT_BUF_INIT;
-	int error;
+	opts.repository = repo;
+	opts.name = name;
 
-	if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
-		return -1;
+	error = git_remote_create_with_opts(out, url, &opts);
 
-	error = git_remote_create_with_fetchspec(out, repo, name, url, git_buf_cstr(&buf));
-	git_buf_free(&buf);
+	git_buf_dispose(&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;
 
-	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;
+	opts.repository = repo;
+	opts.name = name;
+	opts.fetchspec = fetch;
+	opts.flags = GIT_REMOTE_CREATE_SKIP_DEFAULT_FETCHSPEC;
 
-	return 0;
-
-on_error:
-	git_remote_free(remote);
-	return -1;
+	return git_remote_create_with_opts(out, url, &opts);
 }
 
 int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url)
 {
-	return create_internal(out, repo, NULL, url, NULL);
+	git_remote_create_options opts = GIT_REMOTE_CREATE_OPTIONS_INIT;
+
+	opts.repository = repo;
+
+	return git_remote_create_with_opts(out, url, &opts);
 }
 
 int git_remote_create_detached(git_remote **out, const char *url)
 {
-	return create_internal(out, NULL, NULL, url, NULL);
+	return git_remote_create_with_opts(out, url, NULL);
 }
 
 int git_remote_dup(git_remote **dest, git_remote *source)
@@ -346,21 +393,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));
-	GITERR_CHECK_ALLOC(remote);
+	GIT_ERROR_CHECK_ALLOC(remote);
 
 	if (source->name != NULL) {
 		remote->name = git__strdup(source->name);
-		GITERR_CHECK_ALLOC(remote->name);
+		GIT_ERROR_CHECK_ALLOC(remote->name);
 	}
 
 	if (source->url != NULL) {
 		remote->url = git__strdup(source->url);
-		GITERR_CHECK_ALLOC(remote->url);
+		GIT_ERROR_CHECK_ALLOC(remote->url);
 	}
 
 	if (source->pushurl != NULL) {
 		remote->pushurl = git__strdup(source->pushurl);
-		GITERR_CHECK_ALLOC(remote->pushurl);
+		GIT_ERROR_CHECK_ALLOC(remote->pushurl);
 	}
 
 	remote->repo = source->repo;
@@ -419,7 +466,7 @@ static int get_optional_config(
 		*found = !error;
 
 	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
+		git_error_clear();
 		error = 0;
 	}
 
@@ -445,10 +492,10 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 		return error;
 
 	remote = git__calloc(1, sizeof(git_remote));
-	GITERR_CHECK_ALLOC(remote);
+	GIT_ERROR_CHECK_ALLOC(remote);
 
 	remote->name = git__strdup(name);
-	GITERR_CHECK_ALLOC(remote->name);
+	GIT_ERROR_CHECK_ALLOC(remote->name);
 
 	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
 	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||
@@ -471,7 +518,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);
-		GITERR_CHECK_ALLOC(remote->url);
+		GIT_ERROR_CHECK_ALLOC(remote->url);
 	}
 
 	val = NULL;
@@ -485,13 +532,13 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 
 	if (!optional_setting_found) {
 		error = GIT_ENOTFOUND;
-		giterr_set(GITERR_CONFIG, "remote '%s' does not exist", name);
+		git_error_set(GIT_ERROR_CONFIG, "remote '%s' does not exist", name);
 		goto cleanup;
 	}
 
 	if (found && strlen(val) > 0) {
 		remote->pushurl = apply_insteadof(config, val, GIT_DIRECTION_PUSH);
-		GITERR_CHECK_ALLOC(remote->pushurl);
+		GIT_ERROR_CHECK_ALLOC(remote->pushurl);
 	}
 
 	data.remote = remote;
@@ -524,7 +571,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 
 cleanup:
 	git_config_free(config);
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (error < 0)
 		git_remote_free(remote);
@@ -541,18 +588,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) {
-			giterr_clear();
+			git_error_clear();
 
 			if ((error = git_config_get_bool(&remote->prune_refs, config, "fetch.prune")) < 0) {
 				if (error == GIT_ENOTFOUND) {
-					giterr_clear();
+					git_error_clear();
 					error = 0;
 				}
 			}
 		}
 	}
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	return error;
 }
 
@@ -601,8 +648,8 @@ static int set_url(git_repository *repo, const char *remote, const char *pattern
 	}
 
 cleanup:
-	git_buf_free(&canonical_url);
-	git_buf_free(&buf);
+	git_buf_dispose(&canonical_url);
+	git_buf_dispose(&buf);
 
 	return error;
 }
@@ -657,7 +704,7 @@ 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_proxy_options *proxy, const git_strarray *custom_headers)
+int git_remote__connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_remote_connection_opts *conn)
 {
 	git_transport *t;
 	const char *url;
@@ -670,20 +717,20 @@ int git_remote_connect(git_remote *remote, git_direction direction, const git_re
 	assert(remote);
 
 	if (callbacks) {
-		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		credentials = callbacks->credentials;
 		transport   = callbacks->transport;
 		payload     = callbacks->payload;
 	}
 
-	if (proxy)
-		GITERR_CHECK_VERSION(proxy, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+	if (conn->proxy)
+		GIT_ERROR_CHECK_VERSION(conn->proxy, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 
 	t = remote->transport;
 
 	url = git_remote__urlfordirection(remote, direction);
 	if (url == NULL) {
-		giterr_set(GITERR_INVALID,
+		git_error_set(GIT_ERROR_INVALID,
 			"Malformed remote '%s' - missing %s URL",
 			remote->name ? remote->name : "(anonymous)",
 			direction == GIT_DIRECTION_FETCH ? "fetch" : "push");
@@ -701,11 +748,11 @@ int git_remote_connect(git_remote *remote, git_direction direction, const git_re
 	if (!t && (error = git_transport_new(&t, remote, url)) < 0)
 		return error;
 
-	if ((error = set_transport_custom_headers(t, custom_headers)) != 0)
+	if ((error = set_transport_custom_headers(t, conn->custom_headers)) != 0)
 		goto on_error;
 
 	if ((error = set_transport_callbacks(t, callbacks)) < 0 ||
-	    (error = t->connect(t, url, credentials, payload, proxy, direction, flags)) != 0)
+	    (error = t->connect(t, url, credentials, payload, conn->proxy, direction, flags)) != 0)
 		goto on_error;
 
 	remote->transport = t;
@@ -721,12 +768,22 @@ 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) {
-		giterr_set(GITERR_NET, "this remote has never connected");
+		git_error_set(GIT_ERROR_NET, "this remote has never connected");
 		return -1;
 	}
 
@@ -761,7 +818,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_free(&buf);
+		git_buf_dispose(&buf);
 
 		if (error < 0)
 			return error;
@@ -790,7 +847,7 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 
 	if (error < 0) {
 		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
+			git_error_clear();
 			error = 0;
 		}
 
@@ -800,7 +857,7 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 	*proxy_url = git_buf_detach(&val);
 
 found:
-	GITERR_CHECK_ALLOC(*proxy_url);
+	GIT_ERROR_CHECK_ALLOC(*proxy_url);
 	git_config_entry_free(ce);
 
 	return 0;
@@ -826,7 +883,7 @@ static void free_refspecs(git_vector *vec)
 	git_refspec *spec;
 
 	git_vector_foreach(vec, i, spec) {
-		git_refspec__free(spec);
+		git_refspec__dispose(spec);
 		git__free(spec);
 	}
 
@@ -872,15 +929,15 @@ int git_remote_download(git_remote *remote, const git_strarray *refspecs, const
 	assert(remote);
 
 	if (!remote->repo) {
-		giterr_set(GITERR_INVALID, "cannot download detached remote");
+		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
-		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
 		custom_headers = &opts->custom_headers;
-		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 		proxy = &opts->proxy_opts;
 	}
 
@@ -949,21 +1006,20 @@ int git_remote_fetch(
 	bool prune = false;
 	git_buf reflog_msg_buf = GIT_BUF_INIT;
 	const git_remote_callbacks *cbs = NULL;
-	const git_strarray *custom_headers = NULL;
-	const git_proxy_options *proxy = NULL;
+	git_remote_connection_opts conn = GIT_REMOTE_CONNECTION_OPTIONS_INIT;
 
 	if (opts) {
-		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
-		custom_headers = &opts->custom_headers;
+		conn.custom_headers = &opts->custom_headers;
 		update_fetchhead = opts->update_fetchhead;
 		tagopt = opts->download_tags;
-		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
-		proxy = &opts->proxy_opts;
+		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		conn.proxy = &opts->proxy_opts;
 	}
 
 	/* Connect and download everything */
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, cbs, proxy, custom_headers)) != 0)
+	if ((error = git_remote__connect(remote, GIT_DIRECTION_FETCH, cbs, &conn)) != 0)
 		return error;
 
 	error = git_remote_download(remote, refspecs, opts);
@@ -985,7 +1041,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_free(&reflog_msg_buf);
+	git_buf_dispose(&reflog_msg_buf);
 	if (error < 0)
 		return error;
 
@@ -1041,7 +1097,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) {
-			giterr_clear();
+			git_error_clear();
 			error = 0;
 		}
 
@@ -1050,8 +1106,8 @@ static int ref_to_update(int *update, git_buf *remote_name, git_remote *remote,
 		*update = 1;
 	}
 
-	git_buf_free(&upstream_remote);
-	git_buf_free(&upstream_name);
+	git_buf_dispose(&upstream_remote);
+	git_buf_dispose(&upstream_name);
 	return error;
 }
 
@@ -1070,7 +1126,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_REF_SYMBOLIC) {
+	if (error == GIT_ENOTFOUND && git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
 		ref_name = git_reference_symbolic_target(ref);
 		error = 0;
 	} else {
@@ -1084,7 +1140,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_free(&remote_name);
+	git_buf_dispose(&remote_name);
 	git_reference_free(resolved_ref);
 	git_config_free(config);
 	return error;
@@ -1176,7 +1232,7 @@ static int prune_candidates(git_vector *candidates, git_remote *remote)
 			continue;
 
 		refname_dup = git__strdup(refname);
-		GITERR_CHECK_ALLOC(refname_dup);
+		GIT_ERROR_CHECK_ALLOC(refname_dup);
 
 		if ((error = git_vector_insert(candidates, refname_dup)) < 0)
 			goto out;
@@ -1206,7 +1262,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 	git_oid zero_id = {{ 0 }};
 
 	if (callbacks)
-		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 
 	if ((error = ls_to_vector(&remote_refs, remote)) < 0)
 		goto cleanup;
@@ -1235,7 +1291,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_free(&buf);
+			git_buf_dispose(&buf);
 
 			if (error < 0 && error != GIT_ENOTFOUND)
 				goto cleanup;
@@ -1273,7 +1329,7 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 		if (error < 0)
 			goto cleanup;
 
-		if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
+		if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
 			git_reference_free(ref);
 			continue;
 		}
@@ -1394,7 +1450,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)
@@ -1416,14 +1472,14 @@ static int update_tips_for_spec(
 		goto on_error;
 
 	git_vector_free(&update_heads);
-	git_refspec__free(&tagspec);
-	git_buf_free(&refname);
+	git_refspec__dispose(&tagspec);
+	git_buf_dispose(&refname);
 	return 0;
 
 on_error:
 	git_vector_free(&update_heads);
-	git_refspec__free(&tagspec);
-	git_buf_free(&refname);
+	git_refspec__dispose(&tagspec);
+	git_buf_dispose(&refname);
 	return -1;
 
 }
@@ -1537,7 +1593,7 @@ static int opportunistic_updates(const git_remote *remote, const git_remote_call
 		error = 0;
 
 cleanup:
-	git_buf_free(&refname);
+	git_buf_dispose(&refname);
 	return error;
 }
 
@@ -1550,7 +1606,7 @@ static int truncate_fetch_head(const char *gitdir)
 		return error;
 
 	error = git_futils_truncate(path.ptr, GIT_REFS_FILE_MODE);
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 
 	return error;
 }
@@ -1607,7 +1663,7 @@ int git_remote_update_tips(
 
 out:
 	git_vector_free(&refs);
-	git_refspec__free(&tagspec);
+	git_refspec__dispose(&tagspec);
 	return error;
 }
 
@@ -1681,7 +1737,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" */
-	GITERR_CHECK_ALLOC(remote_name);
+	GIT_ERROR_CHECK_ALLOC(remote_name);
 
 	return git_vector_insert(list, remote_name);
 }
@@ -1755,11 +1811,11 @@ int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_
 			error = 0;
 		break;
 	default:
-		giterr_set(GITERR_INVALID, "invalid value for the tagopt setting");
+		git_error_set(GIT_ERROR_INVALID, "invalid value for the tagopt setting");
 		error = -1;
 	}
 
-	git_buf_free(&var);
+	git_buf_dispose(&var);
 	return error;
 }
 
@@ -1790,8 +1846,8 @@ static int rename_remote_config_section(
 		new_name ? git_buf_cstr(&new_section_name) : NULL);
 
 cleanup:
-	git_buf_free(&old_section_name);
-	git_buf_free(&new_section_name);
+	git_buf_dispose(&old_section_name);
+	git_buf_dispose(&new_section_name);
 
 	return error;
 }
@@ -1863,7 +1919,7 @@ static int rename_one_remote_reference(
 					  git_buf_cstr(&log_message))) < 0)
 		goto cleanup;
 
-	if (git_reference_type(ref) != GIT_REF_SYMBOLIC)
+	if (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC)
 		goto cleanup;
 
 	/* Handle refs like origin/HEAD -> origin/master */
@@ -1887,10 +1943,10 @@ static int rename_one_remote_reference(
 cleanup:
 	git_reference_free(reference_in);
 	git_reference_free(ref);
-	git_buf_free(&namespace);
-	git_buf_free(&old_namespace);
-	git_buf_free(&new_name);
-	git_buf_free(&log_message);
+	git_buf_dispose(&namespace);
+	git_buf_dispose(&old_namespace);
+	git_buf_dispose(&new_name);
+	git_buf_dispose(&log_message);
 	return error;
 }
 
@@ -1908,7 +1964,7 @@ static int rename_remote_references(
 		return error;
 
 	error = git_reference_iterator_glob_new(&iter, repo, git_buf_cstr(&buf));
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (error < 0)
 		return error;
@@ -1937,8 +1993,7 @@ 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 = git_buf_printf(
-			&base, "+refs/heads/*:refs/remotes/%s/*", remote->name)) < 0)
+	if ((error = default_fetchspec_for_name(&base, remote->name)) < 0)
 		return error;
 
 	git_vector_foreach(&remote->refspecs, i, spec) {
@@ -1950,7 +2005,7 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 			char *dup;
 
 			dup = git__strdup(spec->string);
-			GITERR_CHECK_ALLOC(dup);
+			GIT_ERROR_CHECK_ALLOC(dup);
 
 			if ((error = git_vector_insert(problems, dup)) < 0)
 				break;
@@ -1963,8 +2018,7 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 		git_buf_clear(&val);
 		git_buf_clear(&var);
 
-		if (git_buf_printf(
-				&val, "+refs/heads/*:refs/remotes/%s/*", new_name) < 0 ||
+		if (default_fetchspec_for_name(&val, new_name) < 0 ||
 			git_buf_printf(&var, "remote.%s.fetch", new_name) < 0)
 		{
 			error = -1;
@@ -1976,9 +2030,9 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
 			break;
 	}
 
-	git_buf_free(&base);
-	git_buf_free(&var);
-	git_buf_free(&val);
+	git_buf_dispose(&base);
+	git_buf_dispose(&var);
+	git_buf_dispose(&val);
 
 	if (error < 0) {
 		char *str;
@@ -2044,10 +2098,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_free(&buf);
-	git_refspec__free(&refspec);
+	git_buf_dispose(&buf);
+	git_refspec__dispose(&refspec);
 
-	giterr_clear();
+	git_error_clear();
 	return error == 0;
 }
 
@@ -2202,7 +2256,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;
-			giterr_clear();
+			git_error_clear();
 		}
 
 		git_buf_clear(&buf);
@@ -2212,14 +2266,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;
-			giterr_clear();
+			git_error_clear();
 		}
 	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	git_config_iterator_free(iter);
 	return error;
 }
@@ -2373,24 +2427,23 @@ 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;
-	const git_strarray *custom_headers = NULL;
-	const git_proxy_options *proxy = NULL;
+	git_remote_connection_opts conn = GIT_REMOTE_CONNECTION_OPTIONS_INIT;
 
 	assert(remote);
 
 	if (!remote->repo) {
-		giterr_set(GITERR_INVALID, "cannot download detached remote");
+		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
 		cbs = &opts->callbacks;
-		custom_headers = &opts->custom_headers;
-		proxy = &opts->proxy_opts;
+		conn.custom_headers = &opts->custom_headers;
+		conn.proxy = &opts->proxy_opts;
 	}
 
 	if (!git_remote_connected(remote) &&
-	    (error = git_remote_connect(remote, GIT_DIRECTION_PUSH, cbs, proxy, custom_headers)) < 0)
+	    (error = git_remote__connect(remote, GIT_DIRECTION_PUSH, cbs, &conn)) < 0)
 		goto cleanup;
 
 	free_refspecs(&remote->active_refspecs);
@@ -2445,15 +2498,15 @@ int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_
 	assert(remote);
 
 	if (!remote->repo) {
-		giterr_set(GITERR_INVALID, "cannot download detached remote");
+		git_error_set(GIT_ERROR_INVALID, "cannot download detached remote");
 		return -1;
 	}
 
 	if (opts) {
-		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		GIT_ERROR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 		cbs = &opts->callbacks;
 		custom_headers = &opts->custom_headers;
-		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
+		GIT_ERROR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");
 		proxy = &opts->proxy_opts;
 	}