rugged 0.23.0b2 → 0.23.0b4

data/vendor/libgit2/src/pack-objects.h

@@ -65,6 +65,7 @@ struct git_packbuilder {
 	git_zstream zstream;
 
 	uint32_t nr_objects,
+		 nr_deltified,
 		 nr_alloc,
 		 nr_written,
 		 nr_remaining;

data/vendor/libgit2/src/pack.c

@@ -319,9 +319,9 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 
 static int pack_index_open(struct git_pack_file *p)
 {
-	char *idx_name;
 	int error = 0;
-	size_t name_len, base_len;
+	size_t name_len;
+	git_buf idx_name = GIT_BUF_INIT;
 
 	if (p->index_version > -1)
 		return 0;
@@ -329,22 +329,23 @@ static int pack_index_open(struct git_pack_file *p)
 	name_len = strlen(p->pack_name);
 	assert(name_len > strlen(".pack")); /* checked by git_pack_file alloc */
 
-	if ((idx_name = git__malloc(name_len)) == NULL)
+	git_buf_grow(&idx_name, name_len);
+	git_buf_put(&idx_name, p->pack_name, name_len - strlen(".pack"));
+	git_buf_puts(&idx_name, ".idx");
+	if (git_buf_oom(&idx_name)) {
+		giterr_set_oom();
 		return -1;
-
-	base_len = name_len - strlen(".pack");
-	memcpy(idx_name, p->pack_name, base_len);
-	memcpy(idx_name + base_len, ".idx", sizeof(".idx"));
+	}
 
 	if ((error = git_mutex_lock(&p->lock)) < 0) {
-		git__free(idx_name);
+		git_buf_free(&idx_name);
 		return error;
 	}
 
 	if (p->index_version == -1)
-		error = pack_index_check(idx_name, p);
+		error = pack_index_check(idx_name.ptr, p);
 
-	git__free(idx_name);
+	git_buf_free(&idx_name);
 
 	git_mutex_unlock(&p->lock);
 
@@ -959,8 +960,15 @@ git_off_t get_delta_base(
 			if (k != kh_end(p->idx_cache)) {
 				*curpos += 20;
 				return ((struct git_pack_entry *)kh_value(p->idx_cache, k))->offset;
+			} else {
+				/* If we're building an index, don't try to find the pack
+				 * entry; we just haven't seen it yet.  We'll make
+				 * progress again in the next loop.
+				 */
+				return GIT_PASSTHROUGH;
 			}
 		}
+
 		/* The base entry _must_ be in the same pack */
 		if (pack_entry_find_offset(&base_offset, &unused, p, (git_oid *)base_info, GIT_OID_HEXSZ) < 0)
 			return packfile_error("base entry delta is not in the same pack");

data/vendor/libgit2/src/path.c

@@ -640,7 +640,7 @@ static bool _check_dir_contents(
 	/* leave base valid even if we could not make space for subdir */
 	if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, dir_size, sub_size) ||
 		GIT_ADD_SIZET_OVERFLOW(&alloc_size, alloc_size, 2) ||
-		git_buf_try_grow(dir, alloc_size, false, false) < 0)
+		git_buf_try_grow(dir, alloc_size, false) < 0)
 		return false;
 
 	/* save excursion */
@@ -847,7 +847,7 @@ int git_path_make_relative(git_buf *path, const char *parent)
 
 	/* save the offset as we might realllocate the pointer */
 	offset = p - path->ptr;
-	if (git_buf_try_grow(path, alloclen, 1, 0) < 0)
+	if (git_buf_try_grow(path, alloclen, 1) < 0)
 		return -1;
 	p = path->ptr + offset;
 
@@ -889,9 +889,9 @@ void git_path_iconv_clear(git_path_iconv_t *ic)
 	}
 }
 
-int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen)
+int git_path_iconv(git_path_iconv_t *ic, const char **in, size_t *inlen)
 {
-	char *nfd = *in, *nfc;
+	char *nfd = (char*)*in, *nfc;
 	size_t nfdlen = *inlen, nfclen, wantlen = nfdlen, alloclen, rv;
 	int retry = 1;
 
@@ -1018,8 +1018,7 @@ int git_path_direach(
 	int error = 0;
 	ssize_t wd_len;
 	DIR *dir;
-	path_dirent_data de_data;
-	struct dirent *de, *de_buf = (struct dirent *)&de_data;
+	struct dirent *de;
 
 #ifdef GIT_USE_ICONV
 	git_path_iconv_t ic = GIT_PATH_ICONV_INIT;
@@ -1045,8 +1044,8 @@ int git_path_direach(
 		(void)git_path_iconv_init_precompose(&ic);
 #endif
 
-	while (p_readdir_r(dir, de_buf, &de) == 0 && de != NULL) {
-		char *de_path = de->d_name;
+	while ((de = readdir(dir)) != NULL) {
+		const char *de_path = de->d_name;
 		size_t de_len = strlen(de_path);
 
 		if (git_path_is_dot_or_dotdot(de_path))
@@ -1060,12 +1059,16 @@ int git_path_direach(
 		if ((error = git_buf_put(path, de_path, de_len)) < 0)
 			break;
 
+		giterr_clear();
 		error = fn(arg, path);
 
 		git_buf_truncate(path, wd_len); /* restore path */
 
+		/* Only set our own error if the callback did not set one already */
 		if (error != 0) {
-			giterr_set_after_callback(error);
+			if (!giterr_last())
+				giterr_set_after_callback(error);
+
 			break;
 		}
 	}
@@ -1227,6 +1230,8 @@ void git_path_diriter_free(git_path_diriter *diriter)
 	if (diriter == NULL)
 		return;
 
+	git_buf_free(&diriter->path_utf8);
+
 	if (diriter->handle != INVALID_HANDLE_VALUE) {
 		FindClose(diriter->handle);
 		diriter->handle = INVALID_HANDLE_VALUE;
@@ -1300,7 +1305,7 @@ int git_path_diriter_next(git_path_diriter *diriter)
 
 #ifdef GIT_USE_ICONV
 	if ((diriter->flags & GIT_PATH_DIR_PRECOMPOSE_UNICODE) != 0 &&
-		(error = git_path_iconv(&diriter->ic, (char **)&filename, &filename_len)) < 0)
+		(error = git_path_iconv(&diriter->ic, &filename, &filename_len)) < 0)
 		return error;
 #endif
 
@@ -1469,7 +1474,7 @@ static int32_t next_hfs_char(const char **in, size_t *len)
 		 * the ASCII range, which is perfectly fine, because the
 		 * git folder name can only be composed of ascii characters
 		 */
-		return tolower(codepoint);
+		return git__tolower(codepoint);
 	}
 	return 0; /* NULL byte -- end of string */
 }

data/vendor/libgit2/src/path.h

@@ -407,7 +407,7 @@ extern void git_path_iconv_clear(git_path_iconv_t *ic);
  * pointer internal iconv buffer if rewrite happened.  The `in` pointer
  * will be left unchanged if no rewrite was needed.
  */
-extern int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen);
+extern int git_path_iconv(git_path_iconv_t *ic, const char **in, size_t *inlen);
 
 #endif /* GIT_USE_ICONV */
 

data/vendor/libgit2/src/push.c

@@ -77,30 +77,6 @@ int git_push_set_options(git_push *push, const git_push_options *opts)
 	return 0;
 }
 
-int git_push_set_callbacks(
-	git_push *push,
-	git_packbuilder_progress pack_progress_cb,
-	void *pack_progress_cb_payload,
-	git_push_transfer_progress transfer_progress_cb,
-	void *transfer_progress_cb_payload,
-	git_push_negotiation negotiation_cb,
-	void *negotiation_cb_payload)
-{
-	if (!push)
-		return -1;
-
-	push->pack_progress_cb = pack_progress_cb;
-	push->pack_progress_cb_payload = pack_progress_cb_payload;
-
-	push->transfer_progress_cb = transfer_progress_cb;
-	push->transfer_progress_cb_payload = transfer_progress_cb_payload;
-
-	push->negotiation_cb = negotiation_cb;
-	push->negotiation_cb_payload = negotiation_cb_payload;
-
-	return 0;
-}
-
 static void free_refspec(push_spec *spec)
 {
 	if (spec == NULL)
@@ -179,7 +155,7 @@ int git_push_add_refspec(git_push *push, const char *refspec)
 	return 0;
 }
 
-int git_push_update_tips(git_push *push)
+int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 {
 	git_buf remote_ref_name = GIT_BUF_INIT;
 	size_t i, j;
@@ -236,9 +212,9 @@ int git_push_update_tips(git_push *push)
 			fire_callback = 0;
 		}
 
-		if (fire_callback && push->remote->callbacks.update_tips) {
-			error = push->remote->callbacks.update_tips(git_buf_cstr(&remote_ref_name),
-						&push_spec->roid, &push_spec->loid, push->remote->callbacks.payload);
+		if (fire_callback && callbacks && callbacks->update_tips) {
+			error = callbacks->update_tips(git_buf_cstr(&remote_ref_name),
+						&push_spec->roid, &push_spec->loid, callbacks->payload);
 
 			if (error < 0)
 				goto on_error;
@@ -553,11 +529,12 @@ static int add_update(git_push *push, push_spec *spec)
 
 	u->src_refname = git__strdup(spec->refspec.src);
 	GITERR_CHECK_ALLOC(u->src_refname);
-	u->dst_refname = git__strdup(spec->refspec.src);
+
+	u->dst_refname = git__strdup(spec->refspec.dst);
 	GITERR_CHECK_ALLOC(u->dst_refname);
 
-	git_oid_cpy(&u->src, &spec->loid);
-	git_oid_cpy(&u->dst, &spec->roid);
+	git_oid_cpy(&u->src, &spec->roid);
+	git_oid_cpy(&u->dst, &spec->loid);
 
 	return git_vector_insert(&push->updates, u);
 }
@@ -595,7 +572,7 @@ static int calculate_work(git_push *push)
 	return 0;
 }
 
-static int do_push(git_push *push)
+static int do_push(git_push *push, const git_remote_callbacks *callbacks)
 {
 	int error = 0;
 	git_transport *transport = push->remote->transport;
@@ -617,21 +594,20 @@ static int do_push(git_push *push)
 
 	git_packbuilder_set_threads(push->pb, push->pb_parallelism);
 
-	if (push->pack_progress_cb)
-		if ((error = git_packbuilder_set_callbacks(push->pb, push->pack_progress_cb, push->pack_progress_cb_payload)) < 0)
+	if (callbacks && callbacks->pack_progress)
+		if ((error = git_packbuilder_set_callbacks(push->pb, callbacks->pack_progress, callbacks->payload)) < 0)
 			goto on_error;
 
 	if ((error = calculate_work(push)) < 0)
 		goto on_error;
 
-	if (push->negotiation_cb &&
-	    (error = push->negotiation_cb((const git_push_update **) push->updates.contents,
-					  push->updates.length,
-					  push->negotiation_cb_payload)))
+	if (callbacks && callbacks->push_negotiation &&
+	    (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
+					  push->updates.length, callbacks->payload)) < 0)
 	    goto on_error;
 
 	if ((error = queue_objects(push)) < 0 ||
-	    (error = transport->push(transport, push)) < 0)
+	    (error = transport->push(transport, push, callbacks)) < 0)
 		goto on_error;
 
 on_error:
@@ -657,16 +633,16 @@ static int filter_refs(git_remote *remote)
 	return 0;
 }
 
-int git_push_finish(git_push *push)
+int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 {
 	int error;
 
 	if (!git_remote_connected(push->remote) &&
-		(error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH)) < 0)
+	    (error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH, callbacks)) < 0)
 		return error;
 
 	if ((error = filter_refs(push->remote)) < 0 ||
-		(error = do_push(push)) < 0)
+	    (error = do_push(push, callbacks)) < 0)
 		return error;
 
 	if (!push->unpack_ok) {
@@ -707,6 +683,7 @@ void git_push_free(git_push *push)
 {
 	push_spec *spec;
 	push_status *status;
+	git_push_update *update;
 	unsigned int i;
 
 	if (push == NULL)
@@ -722,6 +699,13 @@ void git_push_free(git_push *push)
 	}
 	git_vector_free(&push->status);
 
+	git_vector_foreach(&push->updates, i, update) {
+		git__free(update->src_refname);
+		git__free(update->dst_refname);
+		git__free(update);
+	}
+	git_vector_free(&push->updates);
+
 	git__free(push);
 }
 

data/vendor/libgit2/src/push.h

@@ -38,13 +38,6 @@ struct git_push {
 
 	/* options */
 	unsigned pb_parallelism;
-
-	git_packbuilder_progress pack_progress_cb;
-	void *pack_progress_cb_payload;
-	git_push_transfer_progress transfer_progress_cb;
-	void *transfer_progress_cb_payload;
-	git_push_negotiation negotiation_cb;
-	void *negotiation_cb_payload;
 };
 
 /**
@@ -76,31 +69,6 @@ int git_push_set_options(
 	git_push *push,
 	const git_push_options *opts);
 
-/**
- * Set the callbacks for a push
- *
- * @param push The push object
- * @param pack_progress_cb Function to call with progress information during
- * pack building. Be aware that this is called inline with pack building
- * operations, so performance may be affected.
- * @param pack_progress_cb_payload Payload for the pack progress callback.
- * @param transfer_progress_cb Function to call with progress information during
- * the upload portion of a push. Be aware that this is called inline with
- * pack building operations, so performance may be affected.
- * @param transfer_progress_cb_payload Payload for the network progress callback.
- * @param push_negotiation_cb Function to call before sending the commands to the remote.
- * @param push_negotiation_cb_payload Payload for the negotiation callback
- * @return 0 or an error code
- */
-int git_push_set_callbacks(
-	git_push *push,
-	git_packbuilder_progress pack_progress_cb,
-	void *pack_progress_cb_payload,
-	git_push_transfer_progress transfer_progress_cb,
-	void *transfer_progress_cb_payload,
-	git_push_negotiation negotiation_cb,
-	void *negotiation_cb_payload);
-
 /**
  * Add a refspec to be pushed
  *
@@ -119,7 +87,7 @@ int git_push_add_refspec(git_push *push, const char *refspec);
  *
  * @return 0 or an error code
  */
-int git_push_update_tips(git_push *push);
+int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks);
 
 /**
  * Perform the push
@@ -135,7 +103,7 @@ int git_push_update_tips(git_push *push);
  *
  * @return 0 or an error code
  */
-int git_push_finish(git_push *push);
+int git_push_finish(git_push *push, const git_remote_callbacks *callbacks);
 
 /**
  * Invoke callback `cb' on each status entry

data/vendor/libgit2/src/rebase.c

@@ -512,7 +512,7 @@ static int rebase_ensure_not_dirty(
 	git_tree *head = NULL;
 	git_index *index = NULL;
 	git_diff *diff = NULL;
-	int error;
+	int error = 0;
 
 	if (check_index) {
 		if ((error = git_repository_head_tree(&head, repo)) < 0 ||

data/vendor/libgit2/src/refs.c

@@ -863,7 +863,7 @@ int git_reference__normalize_name(
 	const char *name,
 	unsigned int flags)
 {
-	char *current;
+	const char *current;
 	int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
 	unsigned int process_flags;
 	bool normalize = (buf != NULL);

data/vendor/libgit2/src/refspec.c

@@ -42,6 +42,12 @@ 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);
+		refspec->src = git__strdup("");
+		GITERR_CHECK_ALLOC(refspec->src);
+		refspec->dst = git__strdup("");
+		GITERR_CHECK_ALLOC(refspec->dst);
 		return 0;
 	}
 

data/vendor/libgit2/src/remote.c

@@ -20,8 +20,15 @@
 #include "fetchhead.h"
 #include "push.h"
 
+#define CONFIG_URL_FMT "remote.%s.url"
+#define CONFIG_PUSHURL_FMT "remote.%s.pushurl"
+#define CONFIG_FETCH_FMT "remote.%s.fetch"
+#define CONFIG_PUSH_FMT "remote.%s.push"
+#define CONFIG_TAGOPT_FMT "remote.%s.tagopt"
+
 static int dwim_refspecs(git_vector *out, git_vector *refspecs, git_vector *refs);
 static int lookup_remote_prune_config(git_remote *remote, git_config *config, const char *name);
+char *apply_insteadof(git_config *config, const char *url, int direction);
 
 static int add_refspec_to(git_vector *vector, const char *string, bool is_fetch)
 {
@@ -56,7 +63,6 @@ static int download_tags_value(git_remote *remote, git_config *cfg)
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
-	/* The 0 value is the default (auto), let's see if we need to change it */
 	if (git_buf_printf(&buf, "remote.%s.tagopt", remote->name) < 0)
 		return -1;
 
@@ -88,6 +94,48 @@ static int ensure_remote_name_is_valid(const char *name)
 	return error;
 }
 
+static int write_add_refspec(git_repository *repo, const char *name, const char *refspec, bool fetch)
+{
+	git_config *cfg;
+	git_buf var = GIT_BUF_INIT;
+	git_refspec spec;
+	const char *fmt;
+	int error;
+
+	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
+	    return error;
+
+	fmt = fetch ? CONFIG_FETCH_FMT : CONFIG_PUSH_FMT;
+
+	if ((error = ensure_remote_name_is_valid(name)) < 0)
+		return error;
+
+	if ((error = git_refspec__parse(&spec, refspec, fetch)) < 0) {
+		if (giterr_last()->klass != GITERR_NOMEMORY)
+			error = GIT_EINVALIDSPEC;
+
+		return error;
+	}
+
+	git_refspec__free(&spec);
+
+	if ((error = git_buf_printf(&var, fmt, name)) < 0)
+		return error;
+
+	/*
+	 * "$^" is a unmatcheable regexp: it will not match anything at all, so
+	 * all values will be considered new and we will not replace any
+	 * present value.
+	 */
+	if ((error = git_config_set_multivar(cfg, var.ptr, "$^", refspec)) < 0) {
+		goto cleanup;
+	}
+
+cleanup:
+	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)
@@ -119,14 +167,18 @@ static int get_check_cert(int *out, git_repository *repo)
 
 static int canonicalize_url(git_buf *out, const char *in)
 {
-#ifdef GIT_WIN32
-	const char *c;
+	if (in == NULL || strlen(in) == 0) {
+		giterr_set(GITERR_INVALID, "cannot set empty URL");
+		return GIT_EINVALIDSPEC;
+	}
 
+#ifdef GIT_WIN32
 	/* Given a UNC path like \\server\path, we need to convert this
 	 * to //server/path for compatibility with core git.
 	 */
 	if (in[0] == '\\' && in[1] == '\\' &&
 		(git__isalpha(in[2]) || git__isdigit(in[2]))) {
+		const char *c;
 		for (c = in; *c; c++)
 			git_buf_putc(out, *c == '\\' ? '/' : *c);
 
@@ -141,31 +193,44 @@ static int create_internal(git_remote **out, git_repository *repo, const char *n
 {
 	git_remote *remote;
 	git_config *config = NULL;
-	git_buf canonical_url = GIT_BUF_INIT, fetchbuf = GIT_BUF_INIT;
+	git_buf canonical_url = GIT_BUF_INIT;
+	git_buf var = GIT_BUF_INIT;
 	int error = -1;
 
 	/* name is optional */
 	assert(out && repo && url);
 
+	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+		return error;
+
 	remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
 	remote->repo = repo;
-	remote->update_fetchhead = 1;
 
 	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
 		canonicalize_url(&canonical_url, url) < 0)
 		goto on_error;
 
-	remote->url = git_buf_detach(&canonical_url);
+	remote->url = apply_insteadof(repo->_config, canonical_url.ptr, GIT_DIRECTION_FETCH);
 
 	if (name != NULL) {
 		remote->name = git__strdup(name);
 		GITERR_CHECK_ALLOC(remote->name);
+
+		if ((error = git_buf_printf(&var, CONFIG_URL_FMT, name)) < 0)
+			goto on_error;
+
+		if ((error = git_config_set_string(config, var.ptr, canonical_url.ptr)) < 0)
+			goto on_error;
 	}
 
 	if (fetch != NULL) {
-		if (add_refspec(remote, fetch, true) < 0)
+		if ((error = add_refspec(remote, fetch, true)) < 0)
+			goto on_error;
+
+		/* only write for non-anonymous remotes */
+		if (name && (error = write_add_refspec(repo, name, fetch, true)) < 0)
 			goto on_error;
 
 		if ((error = git_repository_config_snapshot(&config, repo)) < 0)
@@ -179,9 +244,14 @@ static int create_internal(git_remote **out, git_repository *repo, const char *n
 			goto on_error;
 	}
 
+	/* A remote without a name doesn't download tags */
 	if (!name)
-		/* A remote without a name doesn't download tags */
 		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
+	else
+		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;
+
+
+	git_buf_free(&var);
 
 	*out = remote;
 	error = 0;
@@ -191,8 +261,8 @@ on_error:
 		git_remote_free(remote);
 
 	git_config_free(config);
-	git_buf_free(&fetchbuf);
 	git_buf_free(&canonical_url);
+	git_buf_free(&var);
 	return error;
 }
 
@@ -247,9 +317,6 @@ int git_remote_create_with_fetchspec(git_remote **out, git_repository *repo, con
 	if (create_internal(&remote, repo, name, url, fetch) < 0)
 		goto on_error;
 
-	if (git_remote_save(remote) < 0)
-		goto on_error;
-
 	*out = remote;
 
 	return 0;
@@ -259,22 +326,16 @@ on_error:
 	return -1;
 }
 
-int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url, const char *fetch)
+int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url)
 {
-	int error;
-	git_remote *remote;
-
-	if ((error = create_internal(&remote, repo, NULL, url, fetch)) < 0)
-		return error;
-
-	*out = remote;
-	return 0;
+	return create_internal(out, repo, NULL, url, NULL);
 }
 
 int git_remote_dup(git_remote **dest, git_remote *source)
 {
+	size_t i;
 	int error = 0;
-	git_strarray refspecs = { 0 };
+	git_refspec *spec;
 	git_remote *remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
@@ -285,7 +346,7 @@ int git_remote_dup(git_remote **dest, git_remote *source)
 
 	if (source->url != NULL) {
 		remote->url = git__strdup(source->url);
-		GITERR_CHECK_ALLOC(remote->url);		
+		GITERR_CHECK_ALLOC(remote->url);
 	}
 
 	if (source->pushurl != NULL) {
@@ -293,11 +354,8 @@ int git_remote_dup(git_remote **dest, git_remote *source)
 		GITERR_CHECK_ALLOC(remote->pushurl);
 	}
 
-	remote->transport_cb = source->transport_cb;
-	remote->transport_cb_payload = source->transport_cb_payload;
 	remote->repo = source->repo;
 	remote->download_tags = source->download_tags;
-	remote->update_fetchhead = source->update_fetchhead;
 	remote->prune_refs = source->prune_refs;
 
 	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
@@ -307,22 +365,15 @@ int git_remote_dup(git_remote **dest, git_remote *source)
 		goto cleanup;
 	}
 
-	if ((error = git_remote_get_fetch_refspecs(&refspecs, source)) < 0 ||
-	    (error = git_remote_set_fetch_refspecs(remote, &refspecs)) < 0)
-		goto cleanup;
-
-	git_strarray_free(&refspecs);
-
-	if ((error = git_remote_get_push_refspecs(&refspecs, source)) < 0 ||
-	    (error = git_remote_set_push_refspecs(remote, &refspecs)) < 0)
-		goto cleanup;
+	git_vector_foreach(&source->refspecs, i, spec) {
+		if ((error = add_refspec(remote, spec->string, !spec->push)) < 0)
+			goto cleanup;
+	}
 
 	*dest = remote;
 
 cleanup:
 
-	git_strarray_free(&refspecs);
-
 	if (error < 0)
 		git__free(remote);
 
@@ -387,7 +438,6 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 	remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
-	remote->update_fetchhead = 1;
 	remote->name = git__strdup(name);
 	GITERR_CHECK_ALLOC(remote->name);
 
@@ -408,9 +458,10 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 	optional_setting_found |= found;
 
 	remote->repo = repo;
+	remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;
 
 	if (found && strlen(val) > 0) {
-		remote->url = git__strdup(val);
+		remote->url = apply_insteadof(config, val, GIT_DIRECTION_FETCH);
 		GITERR_CHECK_ALLOC(remote->url);
 	}
 
@@ -430,7 +481,7 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	if (found && strlen(val) > 0) {
-		remote->pushurl = git__strdup(val);
+		remote->pushurl = apply_insteadof(config, val, GIT_DIRECTION_PUSH);
 		GITERR_CHECK_ALLOC(remote->pushurl);
 	}
 
@@ -543,87 +594,6 @@ cleanup:
 	return error;
 }
 
-int git_remote_save(const git_remote *remote)
-{
-	int error;
-	git_config *cfg;
-	const char *tagopt = NULL;
-	git_buf buf = GIT_BUF_INIT;
-	git_config_entry *existing = NULL;
-
-	assert(remote);
-
-	if (!remote->name) {
-		giterr_set(GITERR_INVALID, "Can't save an anonymous remote.");
-		return GIT_EINVALIDSPEC;
-	}
-
-	if ((error = ensure_remote_name_is_valid(remote->name)) < 0)
-		return error;
-
-	if ((error = git_repository_config__weakptr(&cfg, remote->repo)) < 0)
-		return error;
-
-	if ((error = git_buf_printf(&buf, "remote.%s.url", remote->name)) < 0)
-		return error;
-
-	/* after this point, buffer is allocated so end with cleanup */
-
-	if ((error = git_config_set_string(
-			cfg, git_buf_cstr(&buf), remote->url)) < 0)
-		goto cleanup;
-
-	git_buf_clear(&buf);
-	if ((error = git_buf_printf(&buf, "remote.%s.pushurl", remote->name)) < 0)
-		goto cleanup;
-
-	if ((error = git_config__update_entry(
-			cfg, git_buf_cstr(&buf), remote->pushurl, true, false)) < 0)
-		goto cleanup;
-
-	if ((error = update_config_refspec(remote, cfg, GIT_DIRECTION_FETCH)) < 0)
-		goto cleanup;
-
-	if ((error = update_config_refspec(remote, cfg, GIT_DIRECTION_PUSH)) < 0)
-		goto cleanup;
-
-	/*
-	 * What action to take depends on the old and new values. This
-	 * is describes by the table below. tagopt means whether the
-	 * is already a value set in the config
-	 *
-	 *            AUTO     ALL or NONE
-	 *         +-----------------------+
-	 *  tagopt | remove  |     set     |
-	 *         +---------+-------------|
-	 * !tagopt | nothing |     set     |
-	 *         +---------+-------------+
-	 */
-
-	git_buf_clear(&buf);
-	if ((error = git_buf_printf(&buf, "remote.%s.tagopt", remote->name)) < 0)
-		goto cleanup;
-
-	if ((error = git_config__lookup_entry(
-			&existing, cfg, git_buf_cstr(&buf), false)) < 0)
-		goto cleanup;
-
-	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL)
-		tagopt = "--tags";
-	else if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_NONE)
-		tagopt = "--no-tags";
-	else if (existing != NULL)
-		tagopt = NULL;
-
-	error = git_config__update_entry(
-		cfg, git_buf_cstr(&buf), tagopt, true, false);
-
-cleanup:
-	git_config_entry_free(existing);
-	git_buf_free(&buf);
-	return error;
-}
-
 const char *git_remote_name(const git_remote *remote)
 {
 	assert(remote);
@@ -642,16 +612,42 @@ const char *git_remote_url(const git_remote *remote)
 	return remote->url;
 }
 
-int git_remote_set_url(git_remote *remote, const char* url)
+static int set_url(git_repository *repo, const char *remote, const char *pattern, const char *url)
 {
-	assert(remote);
-	assert(url);
+	git_config *cfg;
+	git_buf buf = GIT_BUF_INIT, canonical_url = GIT_BUF_INIT;
+	int error;
 
-	git__free(remote->url);
-	remote->url = git__strdup(url);
-	GITERR_CHECK_ALLOC(remote->url);
+	assert(repo && remote);
 
-	return 0;
+	if ((error = ensure_remote_name_is_valid(remote)) < 0)
+		return error;
+
+	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return error;
+
+	if ((error = git_buf_printf(&buf, pattern, remote)) < 0)
+		return error;
+
+	if (url) {
+		if ((error = canonicalize_url(&canonical_url, url)) < 0)
+			goto cleanup;
+
+		error = git_config_set_string(cfg, buf.ptr, url);
+	} else {
+		error = git_config_delete_entry(cfg, buf.ptr);
+	}
+
+cleanup:
+	git_buf_free(&canonical_url);
+	git_buf_free(&buf);
+
+	return error;
+}
+
+int git_remote_set_url(git_repository *repo, const char *remote, const char *url)
+{
+	return set_url(repo, remote, CONFIG_URL_FMT, url);
 }
 
 const char *git_remote_pushurl(const git_remote *remote)
@@ -660,18 +656,9 @@ const char *git_remote_pushurl(const git_remote *remote)
 	return remote->pushurl;
 }
 
-int git_remote_set_pushurl(git_remote *remote, const char* url)
+int git_remote_set_pushurl(git_repository *repo, const char *remote, const char* url)
 {
-	assert(remote);
-
-	git__free(remote->pushurl);
-	if (url) {
-		remote->pushurl = git__strdup(url);
-		GITERR_CHECK_ALLOC(remote->pushurl);
-	} else {
-		remote->pushurl = NULL;
-	}
-	return 0;
+	return set_url(repo, remote, CONFIG_PUSHURL_FMT, url);
 }
 
 const char* git_remote__urlfordirection(git_remote *remote, int direction)
@@ -691,15 +678,34 @@ const char* git_remote__urlfordirection(git_remote *remote, int direction)
 	return NULL;
 }
 
-int git_remote_connect(git_remote *remote, git_direction direction)
+int set_transport_callbacks(git_transport *t, const git_remote_callbacks *cbs)
+{
+	if (!t->set_callbacks || !cbs)
+		return 0;
+
+	return t->set_callbacks(t, cbs->sideband_progress, NULL,
+				cbs->certificate_check, cbs->payload);
+}
+
+int git_remote_connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks)
 {
 	git_transport *t;
 	const char *url;
 	int flags = GIT_TRANSPORTFLAGS_NONE;
 	int error;
+	void *payload = NULL;
+	git_cred_acquire_cb credentials = NULL;
+	git_transport_cb transport = NULL;
 
 	assert(remote);
 
+	if (callbacks) {
+		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		credentials = callbacks->credentials;
+		transport   = callbacks->transport;
+		payload     = callbacks->payload;
+	}
+
 	t = remote->transport;
 
 	url = git_remote__urlfordirection(remote, direction);
@@ -711,8 +717,8 @@ int git_remote_connect(git_remote *remote, git_direction direction)
 
 	/* If we don't have a transport object yet, and the caller specified a
 	 * custom transport factory, use that */
-	if (!t && remote->transport_cb &&
-		(error = remote->transport_cb(&t, remote, remote->transport_cb_payload)) < 0)
+	if (!t && transport &&
+		(error = transport(&t, remote, payload)) < 0)
 		return error;
 
 	/* If we still don't have a transport, then use the global
@@ -720,11 +726,8 @@ int git_remote_connect(git_remote *remote, git_direction direction)
 	if (!t && (error = git_transport_new(&t, remote, url)) < 0)
 		return error;
 
-	if (t->set_callbacks &&
-	    (error = t->set_callbacks(t, remote->callbacks.sideband_progress, NULL, remote->callbacks.certificate_check, remote->callbacks.payload)) < 0)
-		goto on_error;
-
-	if ((error = t->connect(t, url, remote->callbacks.credentials, remote->callbacks.payload, direction, flags)) != 0)
+	if ((error = set_transport_callbacks(t, callbacks)) < 0 ||
+	    (error = t->connect(t, url, credentials, payload, direction, flags)) != 0)
 		goto on_error;
 
 	remote->transport = t;
@@ -866,14 +869,24 @@ static int ls_to_vector(git_vector *out, git_remote *remote)
 	return 0;
 }
 
-int git_remote_download(git_remote *remote, const git_strarray *refspecs)
+int git_remote_download(git_remote *remote, const git_strarray *refspecs, const git_fetch_options *opts)
 {
 	int error = -1;
 	size_t i;
-	git_vector refs, specs, *to_active;
+	git_vector *to_active, specs = GIT_VECTOR_INIT, refs = GIT_VECTOR_INIT;
+	const git_remote_callbacks *cbs = NULL;
 
 	assert(remote);
 
+	if (opts) {
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		cbs = &opts->callbacks;
+	}
+
+	if (!git_remote_connected(remote) &&
+	    (error = git_remote_connect(remote, GIT_DIRECTION_FETCH, cbs)) < 0)
+		goto on_error;
+
 	if (ls_to_vector(&refs, remote) < 0)
 		return -1;
 
@@ -912,10 +925,10 @@ int git_remote_download(git_remote *remote, const git_strarray *refspecs)
 		remote->push = NULL;
 	}
 
-	if ((error = git_fetch_negotiate(remote)) < 0)
+	if ((error = git_fetch_negotiate(remote, opts)) < 0)
 		return error;
 
-	return git_fetch_download_pack(remote);
+	return git_fetch_download_pack(remote, cbs);
 
 on_error:
 	git_vector_free(&refs);
@@ -927,16 +940,27 @@ on_error:
 int git_remote_fetch(
 		git_remote *remote,
 		const git_strarray *refspecs,
+		const git_fetch_options *opts,
 		const char *reflog_message)
 {
-	int error;
+	int error, update_fetchhead = 1;
+	git_remote_autotag_option_t tagopt = remote->download_tags;
+	bool prune = false;
 	git_buf reflog_msg_buf = GIT_BUF_INIT;
+	const git_remote_callbacks *cbs = NULL;
+
+	if (opts) {
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		cbs = &opts->callbacks;
+		update_fetchhead = opts->update_fetchhead;
+		tagopt = opts->download_tags;
+	}
 
 	/* Connect and download everything */
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) != 0)
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, cbs)) != 0)
 		return error;
 
-	error = git_remote_download(remote, refspecs);
+	error = git_remote_download(remote, refspecs, opts);
 
 	/* We don't need to be connected anymore */
 	git_remote_disconnect(remote);
@@ -954,13 +978,22 @@ int git_remote_fetch(
 	}
 
 	/* Create "remote/foo" branches for all remote branches */
-	error = git_remote_update_tips(remote, git_buf_cstr(&reflog_msg_buf));
+	error = git_remote_update_tips(remote, cbs, update_fetchhead, tagopt, git_buf_cstr(&reflog_msg_buf));
 	git_buf_free(&reflog_msg_buf);
 	if (error < 0)
 		return error;
 
-	if (remote->prune_refs)
-		error = git_remote_prune(remote);
+	if (opts && opts->prune == GIT_FETCH_PRUNE)
+		prune = true;
+	else if (opts && opts->prune == GIT_FETCH_PRUNE_UNSPECIFIED && remote->prune_refs)
+		prune = true;
+	else if (opts && opts->prune == GIT_FETCH_NO_PRUNE)
+		prune = false;
+	else
+		prune = remote->prune_refs;
+
+	if (prune)
+		error = git_remote_prune(remote, cbs);
 
 	return error;
 }
@@ -1156,7 +1189,7 @@ static int find_head(const void *_a, const void *_b)
 	return strcmp(a->name, b->name);
 }
 
-int git_remote_prune(git_remote *remote)
+int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
 {
 	size_t i, j;
 	git_vector remote_refs = GIT_VECTOR_INIT;
@@ -1166,6 +1199,9 @@ int git_remote_prune(git_remote *remote)
 	int error;
 	git_oid zero_id = {{ 0 }};
 
+	if (callbacks)
+		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+
 	if ((error = ls_to_vector(&remote_refs, remote)) < 0)
 		goto cleanup;
 
@@ -1242,8 +1278,8 @@ int git_remote_prune(git_remote *remote)
 		if (error < 0)
 			goto cleanup;
 
-		if (remote->callbacks.update_tips)
-			error = remote->callbacks.update_tips(refname, &id, &zero_id, remote->callbacks.payload);
+		if (callbacks && callbacks->update_tips)
+			error = callbacks->update_tips(refname, &id, &zero_id, callbacks->payload);
 
 		if (error < 0)
 			goto cleanup;
@@ -1257,6 +1293,9 @@ cleanup:
 
 static int update_tips_for_spec(
 		git_remote *remote,
+		const git_remote_callbacks *callbacks,
+		int update_fetchhead,
+		git_remote_autotag_option_t tagopt,
 		git_refspec *spec,
 		git_vector *refs,
 		const char *log_message)
@@ -1292,9 +1331,9 @@ static int update_tips_for_spec(
 			continue;
 
 		if (git_refspec_src_matches(&tagspec, head->name)) {
-			if (remote->download_tags != GIT_REMOTE_DOWNLOAD_TAGS_NONE) {
+			if (tagopt != GIT_REMOTE_DOWNLOAD_TAGS_NONE) {
 
-				if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_AUTO)
+				if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_AUTO)
 					autotag = 1;
 
 				git_buf_clear(&refname);
@@ -1303,9 +1342,20 @@ static int update_tips_for_spec(
 			} else {
 				continue;
 			}
-		} else if (git_refspec_src_matches(spec, head->name) && spec->dst) {
-			if (git_refspec_transform(&refname, spec, head->name) < 0)
-				goto on_error;
+		} else if (git_refspec_src_matches(spec, head->name)) {
+			if (spec->dst) {
+				if (git_refspec_transform(&refname, spec, head->name) < 0)
+					goto on_error;
+			} else {
+				/*
+				 * no rhs mans store it in FETCH_HEAD, even if we don't
+				 update anything else.
+				 */
+				if ((error = git_vector_insert(&update_heads, head)) < 0)
+					goto on_error;
+
+				continue;
+			}
 		} else {
 			continue;
 		}
@@ -1339,13 +1389,13 @@ static int update_tips_for_spec(
 
 		git_reference_free(ref);
 
-		if (remote->callbacks.update_tips != NULL) {
-			if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.payload) < 0)
+		if (callbacks && callbacks->update_tips != NULL) {
+			if (callbacks->update_tips(refname.ptr, &old, &head->oid, callbacks->payload) < 0)
 				goto on_error;
 		}
 	}
 
-	if (git_remote_update_fetchhead(remote) &&
+	if (update_fetchhead &&
 	    (error = git_remote_write_fetchhead(remote, spec, &update_heads)) < 0)
 		goto on_error;
 
@@ -1419,18 +1469,20 @@ static int next_head(const git_remote *remote, git_vector *refs,
 	return GIT_ITEROVER;
 }
 
-static int opportunistic_updates(const git_remote *remote, git_vector *refs, const char *msg)
+static int opportunistic_updates(const git_remote *remote, const git_remote_callbacks *callbacks,
+				 git_vector *refs, const char *msg)
 {
 	size_t i, j, k;
 	git_refspec *spec;
 	git_remote_head *head;
 	git_reference *ref;
 	git_buf refname = GIT_BUF_INIT;
-	int error;
+	int error = 0;
 
 	i = j = k = 0;
 
 	while ((error = next_head(remote, refs, &spec, &head, &i, &j, &k)) == 0) {
+		git_oid old = {{ 0 }};
 		/*
 		 * If we got here, there is a refspec which was used
 		 * for fetching which matches the source of one of the
@@ -1439,32 +1491,56 @@ static int opportunistic_updates(const git_remote *remote, git_vector *refs, con
 		 * FETCH_HEAD
 		 */
 
+		git_buf_clear(&refname);
 		if ((error = git_refspec_transform(&refname, spec, head->name)) < 0)
-			return error;
+			goto cleanup;
 
-		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, true, msg);
-		git_buf_free(&refname);
-		git_reference_free(ref);
+		error = git_reference_name_to_id(&old, remote->repo, refname.ptr);
+		if (error < 0 && error != GIT_ENOTFOUND)
+			goto cleanup;
 
+		if (!git_oid_cmp(&old, &head->oid))
+			continue;
+
+		/* If we did find a current reference, make sure we haven't lost a race */
+		if (error)
+			error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, true, msg);
+		else
+			error = git_reference_create_matching(&ref, remote->repo, refname.ptr, &head->oid, true, &old, msg);
+		git_reference_free(ref);
 		if (error < 0)
-			return error;
+			goto cleanup;
+
+		if (callbacks && callbacks->update_tips != NULL) {
+			if (callbacks->update_tips(refname.ptr, &old, &head->oid, callbacks->payload) < 0)
+				goto cleanup;
+		}
 	}
 
-	return 0;
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+cleanup:
+	git_buf_free(&refname);
+	return error;
 }
 
 int git_remote_update_tips(
 		git_remote *remote,
+		const git_remote_callbacks *callbacks,
+		int update_fetchhead,
+		git_remote_autotag_option_t download_tags,
 		const char *reflog_message)
 {
 	git_refspec *spec, tagspec;
 	git_vector refs = GIT_VECTOR_INIT;
+	git_remote_autotag_option_t tagopt;
 	int error;
 	size_t i;
 
 	/* push has its own logic hidden away in the push object */
 	if (remote->push) {
-		return git_push_update_tips(remote->push);
+		return git_push_update_tips(remote->push, callbacks);
 	}
 
 	if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
@@ -1474,8 +1550,13 @@ int git_remote_update_tips(
 	if ((error = ls_to_vector(&refs, remote)) < 0)
 		goto out;
 
-	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
-		if ((error = update_tips_for_spec(remote, &tagspec, &refs, reflog_message)) < 0)
+	if (download_tags == GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED)
+		tagopt = remote->download_tags;
+	else
+		tagopt = download_tags;
+
+	if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
+		if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, &tagspec, &refs, reflog_message)) < 0)
 			goto out;
 	}
 
@@ -1483,13 +1564,13 @@ int git_remote_update_tips(
 		if (spec->push)
 			continue;
 
-		if ((error = update_tips_for_spec(remote, spec, &refs, reflog_message)) < 0)
+		if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, spec, &refs, reflog_message)) < 0)
 			goto out;
 	}
 
 	/* only try to do opportunisitic updates if the refpec lists differ */
 	if (remote->passed_refspecs)
-		error = opportunistic_updates(remote, &refs, reflog_message);
+		error = opportunistic_updates(remote, callbacks, &refs, reflog_message);
 
 out:
 	git_vector_free(&refs);
@@ -1600,48 +1681,6 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 	return 0;
 }
 
-int git_remote_set_callbacks(git_remote *remote, const git_remote_callbacks *callbacks)
-{
-	assert(remote && callbacks);
-
-	GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
-
-	memcpy(&remote->callbacks, callbacks, sizeof(git_remote_callbacks));
-
-	if (remote->transport && remote->transport->set_callbacks)
-		return remote->transport->set_callbacks(remote->transport,
-			remote->callbacks.sideband_progress,
-			NULL,
-			remote->callbacks.certificate_check,
-			remote->callbacks.payload);
-
-	return 0;
-}
-
-const git_remote_callbacks *git_remote_get_callbacks(git_remote *remote)
-{
-	assert(remote);
-
-	return &remote->callbacks;
-}
-
-int git_remote_set_transport(
-	git_remote *remote,
-	git_transport_cb transport_cb,
-	void *payload)
-{
-	assert(remote);
-
-	if (remote->transport) {
-		giterr_set(GITERR_NET, "A transport is already bound to this remote");
-		return -1;
-	}
-
-	remote->transport_cb = transport_cb;
-	remote->transport_cb_payload = payload;
-	return 0;
-}
-
 const git_transfer_progress* git_remote_stats(git_remote *remote)
 {
 	assert(remote);
@@ -1653,9 +1692,42 @@ git_remote_autotag_option_t git_remote_autotag(const git_remote *remote)
 	return remote->download_tags;
 }
 
-void git_remote_set_autotag(git_remote *remote, git_remote_autotag_option_t value)
+int git_remote_set_autotag(git_repository *repo, const char *remote, git_remote_autotag_option_t value)
 {
-	remote->download_tags = value;
+	git_buf var = GIT_BUF_INIT;
+	git_config *config;
+	int error;
+
+	assert(repo && remote);
+
+	if ((error = ensure_remote_name_is_valid(remote)) < 0)
+		return error;
+
+	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+		return error;
+
+	if ((error = git_buf_printf(&var, CONFIG_TAGOPT_FMT, remote)))
+		return error;
+
+	switch (value) {
+	case GIT_REMOTE_DOWNLOAD_TAGS_NONE:
+		error = git_config_set_string(config, var.ptr, "--no-tags");
+		break;
+	case GIT_REMOTE_DOWNLOAD_TAGS_ALL:
+		error = git_config_set_string(config, var.ptr, "--tags");
+		break;
+	case GIT_REMOTE_DOWNLOAD_TAGS_AUTO:
+		error = git_config_delete_entry(config, var.ptr);
+		if (error == GIT_ENOTFOUND)
+			error = 0;
+		break;
+	default:
+		giterr_set(GITERR_INVALID, "Invalid value for the tagopt setting");
+		error = -1;
+	}
+
+	git_buf_free(&var);
+	return error;
 }
 
 int git_remote_prune_refs(const git_remote *remote)
@@ -1926,16 +1998,6 @@ cleanup:
 	return error;
 }
 
-int git_remote_update_fetchhead(git_remote *remote)
-{
-	return (remote->update_fetchhead != 0);
-}
-
-void git_remote_set_update_fetchhead(git_remote *remote, int value)
-{
-	remote->update_fetchhead = (value != 0);
-}
-
 int git_remote_is_valid_name(
 	const char *remote_name)
 {
@@ -1988,26 +2050,14 @@ git_refspec *git_remote__matching_dst_refspec(git_remote *remote, const char *re
 	return NULL;
 }
 
-void git_remote_clear_refspecs(git_remote *remote)
-{
-	git_refspec *spec;
-	size_t i;
-
-	git_vector_foreach(&remote->refspecs, i, spec) {
-		git_refspec__free(spec);
-		git__free(spec);
-	}
-	git_vector_clear(&remote->refspecs);
-}
-
-int git_remote_add_fetch(git_remote *remote, const char *refspec)
+int git_remote_add_fetch(git_repository *repo, const char *remote, const char *refspec)
 {
-	return add_refspec(remote, refspec, true);
+	return write_add_refspec(repo, remote, refspec, true);
 }
 
-int git_remote_add_push(git_remote *remote, const char *refspec)
+int git_remote_add_push(git_repository *repo, const char *remote, const char *refspec)
 {
-	return add_refspec(remote, refspec, false);
+	return write_add_refspec(repo, remote, refspec, false);
 }
 
 static int set_refspecs(git_remote *remote, git_strarray *array, int push)
@@ -2038,16 +2088,6 @@ static int set_refspecs(git_remote *remote, git_strarray *array, int push)
 	return 0;
 }
 
-int git_remote_set_fetch_refspecs(git_remote *remote, git_strarray *array)
-{
-	return set_refspecs(remote, array, false);
-}
-
-int git_remote_set_push_refspecs(git_remote *remote, git_strarray *array)
-{
-	return set_refspecs(remote, array, true);
-}
-
 static int copy_refspecs(git_strarray *array, const git_remote *remote, unsigned int push)
 {
 	size_t i;
@@ -2321,12 +2361,15 @@ int git_remote_upload(git_remote *remote, const git_strarray *refspecs, const gi
 	int error;
 	git_push *push;
 	git_refspec *spec;
-	git_remote_callbacks *cbs;
+	const git_remote_callbacks *cbs = NULL;
 
 	assert(remote);
 
+	if (opts)
+		cbs = &opts->callbacks;
+
 	if (!git_remote_connected(remote) &&
-	    (error = git_remote_connect(remote, GIT_DIRECTION_PUSH)) < 0)
+	    (error = git_remote_connect(remote, GIT_DIRECTION_PUSH, cbs)) < 0)
 		goto cleanup;
 
 	free_refspecs(&remote->active_refspecs);
@@ -2360,17 +2403,10 @@ int git_remote_upload(git_remote *remote, const git_strarray *refspecs, const gi
 		}
 	}
 
-	cbs = &remote->callbacks;
-	if ((error = git_push_set_callbacks(push,
-					    cbs->pack_progress, cbs->payload,
-					    cbs->push_transfer_progress, cbs->payload,
-					    cbs->push_negotiation, cbs->payload)) < 0)
+	if ((error = git_push_finish(push, cbs)) < 0)
 		goto cleanup;
 
-	if ((error = git_push_finish(push)) < 0)
-		goto cleanup;
-
-	if (cbs->push_update_reference &&
+	if (cbs && cbs->push_update_reference &&
 	    (error = git_push_status_foreach(push, cbs->push_update_reference, cbs->payload)) < 0)
 		goto cleanup;
 
@@ -2381,17 +2417,88 @@ cleanup:
 int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_push_options *opts)
 {
 	int error;
+	const git_remote_callbacks *cbs = NULL;
+
+	if (opts) {
+		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
+		cbs = &opts->callbacks;
+	}
 
 	assert(remote && refspecs);
 
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_PUSH)) < 0)
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_PUSH, cbs)) < 0)
 		return error;
 
 	if ((error = git_remote_upload(remote, refspecs, opts)) < 0)
 		return error;
 
-	error = git_remote_update_tips(remote, NULL);
+	error = git_remote_update_tips(remote, cbs, 0, 0, NULL);
 
 	git_remote_disconnect(remote);
 	return error;
 }
+
+#define PREFIX "url"
+#define SUFFIX_FETCH "insteadof"
+#define SUFFIX_PUSH "pushinsteadof"
+
+char *apply_insteadof(git_config *config, const char *url, int direction)
+{
+	size_t match_length, prefix_length, suffix_length;
+	char *replacement = NULL;
+	const char *regexp;
+
+	git_buf result = GIT_BUF_INIT;
+	git_config_entry *entry;
+	git_config_iterator *iter;
+
+	assert(config);
+	assert(url);
+	assert(direction == GIT_DIRECTION_FETCH || direction == GIT_DIRECTION_PUSH);
+
+	/* Add 1 to prefix/suffix length due to the additional escaped dot */
+	prefix_length = strlen(PREFIX) + 1;
+	if (direction == GIT_DIRECTION_FETCH) {
+		regexp = PREFIX "\\..*\\." SUFFIX_FETCH;
+		suffix_length = strlen(SUFFIX_FETCH) + 1;
+	} else {
+		regexp = PREFIX "\\..*\\." SUFFIX_PUSH;
+		suffix_length = strlen(SUFFIX_PUSH) + 1;
+	}
+
+	if (git_config_iterator_glob_new(&iter, config, regexp) < 0)
+		return NULL;
+
+	match_length = 0;
+	while (git_config_next(&entry, iter) == 0) {
+		size_t n, replacement_length;
+
+		/* Check if entry value is a prefix of URL */
+		if (git__prefixcmp(url, entry->value))
+			continue;
+		/* Check if entry value is longer than previous
+		 * prefixes */
+		if ((n = strlen(entry->value)) <= match_length)
+			continue;
+
+		git__free(replacement);
+		match_length = n;
+
+		/* Cut off prefix and suffix of the value */
+		replacement_length =
+		    strlen(entry->name) - (prefix_length + suffix_length);
+		replacement = git__strndup(entry->name + prefix_length,
+				replacement_length);
+	}
+
+	git_config_iterator_free(iter);
+
+	if (match_length == 0)
+		return git__strdup(url);
+
+	git_buf_printf(&result, "%s%s", replacement, url + match_length);
+
+	git__free(replacement);
+
+	return result.ptr;
+}