rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/refs.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -10,6 +10,7 @@
 #include "common.h"
 #include "git2/oid.h"
 #include "git2/refs.h"
+#include "git2/refdb.h"
 #include "strmap.h"
 #include "buffer.h"
 
@@ -28,35 +29,43 @@
 #define GIT_PACKEDREFS_FILE_MODE 0666
 
 #define GIT_HEAD_FILE "HEAD"
+#define GIT_ORIG_HEAD_FILE "ORIG_HEAD"
 #define GIT_FETCH_HEAD_FILE "FETCH_HEAD"
 #define GIT_MERGE_HEAD_FILE "MERGE_HEAD"
+#define GIT_REVERT_HEAD_FILE "REVERT_HEAD"
+#define GIT_CHERRY_PICK_HEAD_FILE "CHERRY_PICK_HEAD"
+#define GIT_BISECT_LOG_FILE "BISECT_LOG"
+#define GIT_REBASE_MERGE_DIR "rebase-merge/"
+#define GIT_REBASE_MERGE_INTERACTIVE_FILE GIT_REBASE_MERGE_DIR "interactive"
+#define GIT_REBASE_APPLY_DIR "rebase-apply/"
+#define GIT_REBASE_APPLY_REBASING_FILE GIT_REBASE_APPLY_DIR "rebasing"
+#define GIT_REBASE_APPLY_APPLYING_FILE GIT_REBASE_APPLY_DIR "applying"
 #define GIT_REFS_HEADS_MASTER_FILE GIT_REFS_HEADS_DIR "master"
 
+#define GIT_STASH_FILE "stash"
+#define GIT_REFS_STASH_FILE GIT_REFS_DIR GIT_STASH_FILE
+
 #define GIT_REFNAME_MAX 1024
 
 struct git_reference {
-	unsigned int flags;
-	git_repository *owner;
-	char *name;
-	time_t mtime;
+	git_refdb *db;
+	git_ref_t type;
 
 	union {
 		git_oid oid;
 		char *symbolic;
 	} target;
-};
 
-typedef struct {
-	git_strmap *packfile;
-	time_t packfile_time;
-} git_refcache;
-
-void git_repository__refcache_free(git_refcache *refs);
+	git_oid peel;
+	char name[0];
+};
 
 int git_reference__normalize_name_lax(char *buffer_out, size_t out_size, const char *name);
 int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags);
+int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid);
 int git_reference__is_valid_name(const char *refname, unsigned int flags);
-int git_reference__update(git_repository *repo, const git_oid *oid, const char *ref_name);
+int git_reference__is_branch(const char *ref_name);
+int git_reference__is_remote(const char *ref_name);
 
 /**
  * Lookup a reference by name and try to resolve to an OID.

data/vendor/libgit2/src/refspec.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -127,6 +127,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 void git_refspec__free(git_refspec *refspec)
 {
+	if (refspec == NULL)
+		return;
+
 	git__free(refspec->src);
 	git__free(refspec->dst);
 }
@@ -156,11 +159,19 @@ int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
 	return (p_fnmatch(refspec->src, refname, 0) == 0);
 }
 
-int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name)
+int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
+{
+	if (refspec == NULL || refspec->dst == NULL)
+		return false;
+
+	return (p_fnmatch(refspec->dst, refname, 0) == 0);
+}
+
+static int refspec_transform_internal(char *out, size_t outlen, const char *from, const char *to, const char *name)
 {
 	size_t baselen, namelen;
 
-	baselen = strlen(spec->dst);
+	baselen = strlen(to);
 	if (outlen <= baselen) {
 		giterr_set(GITERR_INVALID, "Reference name too long");
 		return GIT_EBUFS;
@@ -170,8 +181,8 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 	 * No '*' at the end means that it's mapped to one specific local
 	 * branch, so no actual transformation is needed.
 	 */
-	if (spec->dst[baselen - 1] != '*') {
-		memcpy(out, spec->dst, baselen + 1); /* include '\0' */
+	if (to[baselen - 1] != '*') {
+		memcpy(out, to, baselen + 1); /* include '\0' */
 		return 0;
 	}
 
@@ -179,7 +190,7 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 	baselen--;
 
 	/* skip the prefix, -1 is for the '*' */
-	name += strlen(spec->src) - 1;
+	name += strlen(from) - 1;
 
 	namelen = strlen(name);
 
@@ -188,12 +199,22 @@ int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, con
 		return GIT_EBUFS;
 	}
 
-	memcpy(out, spec->dst, baselen);
+	memcpy(out, to, baselen);
 	memcpy(out + baselen, name, namelen + 1);
 
 	return 0;
 }
 
+int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name)
+{
+	return refspec_transform_internal(out, outlen, spec->src, spec->dst, name);
+}
+
+int git_refspec_rtransform(char *out, size_t outlen, const git_refspec *spec, const char *name)
+{
+	return refspec_transform_internal(out, outlen, spec->dst, spec->src, name);
+}
+
 static int refspec_transform(git_buf *out, const char *from, const char *to, const char *name)
 {
 	if (git_buf_sets(out, to) < 0)
@@ -225,3 +246,21 @@ int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *n
 	return refspec_transform(out, spec->dst, spec->src, name);
 }
 
+int git_refspec__serialize(git_buf *out, const git_refspec *refspec)
+{
+	if (refspec->force)
+		git_buf_putc(out, '+');
+
+	git_buf_printf(out, "%s:%s",
+		refspec->src != NULL ? refspec->src : "",
+		refspec->dst != NULL ? refspec->dst : "");
+
+	return git_buf_oom(out) == false;
+}
+
+int git_refspec_is_wildcard(const git_refspec *spec)
+{
+	assert(spec && spec->src);
+
+	return (spec->src[strlen(spec->src) - 1] == '*');
+}

data/vendor/libgit2/src/refspec.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -51,4 +51,14 @@ int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *n
  */
 int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *name);
 
+int git_refspec__serialize(git_buf *out, const git_refspec *refspec);
+
+/**
+ * Determines if a refspec is a wildcard refspec.
+ *
+ * @param spec the refspec
+ * @return 1 if the refspec is a wildcard, 0 otherwise
+ */
+int git_refspec_is_wildcard(const git_refspec *spec);
+
 #endif

data/vendor/libgit2/src/remote.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -14,7 +14,8 @@
 #include "remote.h"
 #include "fetch.h"
 #include "refs.h"
-#include "pkt.h"
+#include "refspec.h"
+#include "fetchhead.h"
 
 #include <regex.h>
 
@@ -56,22 +57,38 @@ static int download_tags_value(git_remote *remote, git_config *cfg)
 	return error;
 }
 
-int git_remote_new(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
+static int ensure_remote_name_is_valid(const char *name)
+{
+	int error = 0;
+
+	if (!git_remote_is_valid_name(name)) {
+		giterr_set(
+			GITERR_CONFIG,
+			"'%s' is not a valid remote name.", name);
+		error = GIT_EINVALIDSPEC;
+	}
+
+	return error;
+}
+
+static int create_internal(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)
 {
 	git_remote *remote;
+	git_buf fetchbuf = GIT_BUF_INIT;
+	int error = -1;
 
 	/* name is optional */
 	assert(out && repo && url);
 
-	remote = git__malloc(sizeof(git_remote));
+	remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
-	memset(remote, 0x0, sizeof(git_remote));
 	remote->repo = repo;
 	remote->check_cert = 1;
+	remote->update_fetchhead = 1;
 
 	if (git_vector_init(&remote->refs, 32, NULL) < 0)
-		return -1;
+		goto on_error;
 
 	remote->url = git__strdup(url);
 	GITERR_CHECK_ALLOC(remote->url);
@@ -92,13 +109,83 @@ int git_remote_new(git_remote **out, git_repository *repo, const char *name, con
 	}
 
 	*out = remote;
+	git_buf_free(&fetchbuf);
+	return 0;
+
+on_error:
+	git_remote_free(remote);
+	git_buf_free(&fetchbuf);
+	return error;
+}
+
+static int ensure_remote_doesnot_exist(git_repository *repo, const char *name)
+{
+	int error;
+	git_remote *remote;
+
+	error = git_remote_load(&remote, repo, name);
+
+	if (error == GIT_ENOTFOUND)
+		return 0;
+
+	if (error < 0)
+		return error;
+
+	git_remote_free(remote);
+
+	giterr_set(
+		GITERR_CONFIG,
+		"Remote '%s' already exists.", name);
+
+	return GIT_EEXISTS;
+}
+
+
+int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)
+{
+	git_buf buf = GIT_BUF_INIT;
+	git_remote *remote = NULL;
+	int error;
+
+	if ((error = ensure_remote_name_is_valid(name)) < 0)
+		return error;
+
+	if ((error = ensure_remote_doesnot_exist(repo, name)) < 0)
+		return error;
+
+	if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
+		return -1;
+
+	if (create_internal(&remote, repo, name, url, git_buf_cstr(&buf)) < 0)
+		goto on_error;
+
+	git_buf_free(&buf);
+
+	if (git_remote_save(remote) < 0)
+		goto on_error;
+
+	*out = remote;
+
 	return 0;
 
 on_error:
+	git_buf_free(&buf);
 	git_remote_free(remote);
 	return -1;
 }
 
+int git_remote_create_inmemory(git_remote **out, git_repository *repo, const char *fetch, const char *url)
+{
+	int error;
+	git_remote *remote;
+
+	if ((error = create_internal(&remote, repo, NULL, url, fetch)) < 0)
+		return error;
+
+	*out = remote;
+	return 0;
+}
+
 int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 {
 	git_remote *remote;
@@ -109,6 +196,9 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 
 	assert(out && repo && name);
 
+	if ((error = ensure_remote_name_is_valid(name)) < 0)
+		return error;
+
 	if (git_repository_config__weakptr(&config, repo) < 0)
 		return -1;
 
@@ -117,6 +207,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 
 	memset(remote, 0x0, sizeof(git_remote));
 	remote->check_cert = 1;
+	remote->update_fetchhead = 1;
 	remote->name = git__strdup(name);
 	GITERR_CHECK_ALLOC(remote->name);
 
@@ -132,6 +223,12 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 
 	if ((error = git_config_get_string(&val, config, git_buf_cstr(&buf))) < 0)
 		goto cleanup;
+	
+	if (strlen(val) == 0) {
+		giterr_set(GITERR_INVALID, "Malformed remote '%s' - missing URL", name);
+		error = -1;
+		goto cleanup;
+	}
 
 	remote->repo = repo;
 	remote->url = git__strdup(val);
@@ -144,8 +241,10 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	}
 
 	error = git_config_get_string(&val, config, git_buf_cstr(&buf));
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_ENOTFOUND) {
+		val = NULL;
 		error = 0;
+	}
 
 	if (error < 0) {
 		error = -1;
@@ -201,12 +300,56 @@ cleanup:
 	return error;
 }
 
+static int update_config_refspec(
+	git_config *config,
+	const char *remote_name,
+	const git_refspec *refspec,
+	int git_direction)
+{
+	git_buf name = GIT_BUF_INIT, value = GIT_BUF_INIT;
+	int error = -1;
+
+	if (refspec->src == NULL || refspec->dst == NULL)
+		return 0;
+
+	if (git_buf_printf(
+		&name,
+		"remote.%s.%s",
+		remote_name,
+		git_direction == GIT_DIRECTION_FETCH ? "fetch" : "push") < 0)
+			goto cleanup;
+
+	if (git_refspec__serialize(&value, refspec) < 0)
+		goto cleanup;
+
+	error = git_config_set_string(
+		config,
+		git_buf_cstr(&name),
+		git_buf_cstr(&value));
+
+cleanup:
+	git_buf_free(&name);
+	git_buf_free(&value);
+
+	return error;
+}
+
 int git_remote_save(const git_remote *remote)
 {
 	int error;
 	git_config *config;
 	const char *tagopt = NULL;
-	git_buf buf = GIT_BUF_INIT, value = GIT_BUF_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	assert(remote);
+
+	if (!remote->name) {
+		giterr_set(GITERR_INVALID, "Can't save an in-memory remote.");
+		return GIT_EINVALIDSPEC;
+	}
+
+	if ((error = ensure_remote_name_is_valid(remote->name)) < 0)
+		return error;
 
 	if (git_repository_config__weakptr(&config, remote->repo) < 0)
 		return -1;
@@ -229,9 +372,10 @@ int git_remote_save(const git_remote *remote)
 			return -1;
 		}
 	} else {
-		int error = git_config_delete(config, git_buf_cstr(&buf));
+		int error = git_config_delete_entry(config, git_buf_cstr(&buf));
 		if (error == GIT_ENOTFOUND) {
 			error = 0;
+			giterr_clear();
 		}
 		if (error < 0) {
 			git_buf_free(&buf);
@@ -239,33 +383,19 @@ int git_remote_save(const git_remote *remote)
 		}
 	}
 
-	if (remote->fetch.src != NULL && remote->fetch.dst != NULL) {
-		git_buf_clear(&buf);
-		git_buf_clear(&value);
-		git_buf_printf(&buf, "remote.%s.fetch", remote->name);
-		if (remote->fetch.force)
-			git_buf_putc(&value, '+');
-		git_buf_printf(&value, "%s:%s", remote->fetch.src, remote->fetch.dst);
-		if (git_buf_oom(&buf) || git_buf_oom(&value))
-			return -1;
-
-		if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0)
+	if (update_config_refspec(
+		config,
+		remote->name,
+		&remote->fetch,
+		GIT_DIRECTION_FETCH) < 0)
 			goto on_error;
-	}
 
-	if (remote->push.src != NULL && remote->push.dst != NULL) {
-		git_buf_clear(&buf);
-		git_buf_clear(&value);
-		git_buf_printf(&buf, "remote.%s.push", remote->name);
-		if (remote->push.force)
-			git_buf_putc(&value, '+');
-		git_buf_printf(&value, "%s:%s", remote->push.src, remote->push.dst);
-		if (git_buf_oom(&buf) || git_buf_oom(&value))
-			return -1;
-
-		if (git_config_set_string(config, git_buf_cstr(&buf), git_buf_cstr(&value)) < 0)
+	if (update_config_refspec(
+		config,
+		remote->name,
+		&remote->push,
+		GIT_DIRECTION_PUSH) < 0)
 			goto on_error;
-	}
 
 	/*
 	 * What action to take depends on the old and new values. This
@@ -295,28 +425,26 @@ int git_remote_save(const git_remote *remote)
 		if (git_config_set_string(config, git_buf_cstr(&buf), "--no-tags") < 0)
 			goto on_error;
 	} else if (tagopt) {
-		if (git_config_delete(config, git_buf_cstr(&buf)) < 0)
+		if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
 			goto on_error;
 	}
 
 	git_buf_free(&buf);
-	git_buf_free(&value);
 
 	return 0;
 
 on_error:
 	git_buf_free(&buf);
-	git_buf_free(&value);
 	return -1;
 }
 
-const char *git_remote_name(git_remote *remote)
+const char *git_remote_name(const git_remote *remote)
 {
 	assert(remote);
 	return remote->name;
 }
 
-const char *git_remote_url(git_remote *remote)
+const char *git_remote_url(const git_remote *remote)
 {
 	assert(remote);
 	return remote->url;
@@ -334,7 +462,7 @@ int git_remote_set_url(git_remote *remote, const char* url)
 	return 0;
 }
 
-const char *git_remote_pushurl(git_remote *remote)
+const char *git_remote_pushurl(const git_remote *remote)
 {
 	assert(remote);
 	return remote->pushurl;
@@ -364,13 +492,12 @@ int git_remote_set_fetchspec(git_remote *remote, const char *spec)
 		return -1;
 
 	git_refspec__free(&remote->fetch);
-	remote->fetch.src = refspec.src;
-	remote->fetch.dst = refspec.dst;
+	memcpy(&remote->fetch, &refspec, sizeof(git_refspec));
 
 	return 0;
 }
 
-const git_refspec *git_remote_fetchspec(git_remote *remote)
+const git_refspec *git_remote_fetchspec(const git_remote *remote)
 {
 	assert(remote);
 	return &remote->fetch;
@@ -392,7 +519,7 @@ int git_remote_set_pushspec(git_remote *remote, const char *spec)
 	return 0;
 }
 
-const git_refspec *git_remote_pushspec(git_remote *remote)
+const git_refspec *git_remote_pushspec(const git_remote *remote)
 {
 	assert(remote);
 	return &remote->push;
@@ -402,38 +529,45 @@ const char* git_remote__urlfordirection(git_remote *remote, int direction)
 {
 	assert(remote);
 
-	if (direction == GIT_DIR_FETCH) {
+	if (direction == GIT_DIRECTION_FETCH) {
 		return remote->url;
 	}
 
-	if (direction == GIT_DIR_PUSH) {
+	if (direction == GIT_DIRECTION_PUSH) {
 		return remote->pushurl ? remote->pushurl : remote->url;
 	}
 
 	return NULL;
 }
 
-int git_remote_connect(git_remote *remote, int direction)
+int git_remote_connect(git_remote *remote, git_direction direction)
 {
 	git_transport *t;
 	const char *url;
+	int flags = GIT_TRANSPORTFLAGS_NONE;
 
 	assert(remote);
 
+	t = remote->transport;
+
 	url = git_remote__urlfordirection(remote, direction);
 	if (url == NULL )
 		return -1;
 
-	if (git_transport_new(&t, url) < 0)
+	/* A transport could have been supplied in advance with
+	 * git_remote_set_transport */
+	if (!t && git_transport_new(&t, remote, url) < 0)
 		return -1;
 
-	t->progress_cb = remote->callbacks.progress;
-	t->cb_data = remote->callbacks.data;
+	if (t->set_callbacks &&
+		t->set_callbacks(t, remote->callbacks.progress, NULL, remote->callbacks.payload) < 0)
+		goto on_error;
+
+	if (!remote->check_cert)
+		flags |= GIT_TRANSPORTFLAGS_NO_CHECK_CERT;
 
-	t->check_cert = remote->check_cert;
-	if (t->connect(t, direction) < 0) {
+	if (t->connect(t, url, remote->cred_acquire_cb, remote->cred_acquire_payload, direction, flags) < 0)
 		goto on_error;
-	}
 
 	remote->transport = t;
 
@@ -441,47 +575,215 @@ int git_remote_connect(git_remote *remote, int direction)
 
 on_error:
 	t->free(t);
+
+	if (t == remote->transport)
+		remote->transport = NULL;
+
 	return -1;
 }
 
 int git_remote_ls(git_remote *remote, git_headlist_cb list_cb, void *payload)
 {
-	git_vector *refs = &remote->transport->refs;
-	unsigned int i;
-	git_pkt *p = NULL;
+	assert(remote);
+
+	return remote->transport->ls(remote->transport, list_cb, payload);
+}
+
+int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_url)
+{
+	git_config *cfg;
+	const char *val;
 
 	assert(remote);
 
-	if (!remote->transport || !remote->transport->connected) {
-		giterr_set(GITERR_NET, "The remote is not connected");
+	if (!proxy_url || !remote->repo)
 		return -1;
-	}
 
-	git_vector_foreach(refs, i, p) {
-		git_pkt_ref *pkt = NULL;
+	*proxy_url = NULL;
 
-		if (p->type != GIT_PKT_REF)
-			continue;
+	if (git_repository_config__weakptr(&cfg, remote->repo) < 0)
+		return -1;
+
+	/* Go through the possible sources for proxy configuration, from most specific
+	 * to least specific. */
+
+	/* remote.<name>.proxy config setting */
+	if (remote->name && 0 != *(remote->name)) {
+		git_buf buf = GIT_BUF_INIT;
+
+		if (git_buf_printf(&buf, "remote.%s.proxy", remote->name) < 0)
+			return -1;
 
-		pkt = (git_pkt_ref *)p;
+		if (!git_config_get_string(&val, cfg, git_buf_cstr(&buf)) &&
+			val && ('\0' != *val)) {
+			git_buf_free(&buf);
+
+			*proxy_url = git__strdup(val);
+			GITERR_CHECK_ALLOC(*proxy_url);
+			return 0;
+		}
 
-		if (list_cb(&pkt->head, payload))
-			return GIT_EUSER;
+		git_buf_free(&buf);
+	}
+
+	/* http.proxy config setting */
+	if (!git_config_get_string(&val, cfg, "http.proxy") &&
+		val && ('\0' != *val)) {
+		*proxy_url = git__strdup(val);
+		GITERR_CHECK_ALLOC(*proxy_url);
+		return 0;
+	}
+
+	/* HTTP_PROXY / HTTPS_PROXY environment variables */
+	val = use_ssl ? getenv("HTTPS_PROXY") : getenv("HTTP_PROXY");
+
+	if (val && ('\0' != *val)) {
+		*proxy_url = git__strdup(val);
+		GITERR_CHECK_ALLOC(*proxy_url);
+		return 0;
 	}
 
 	return 0;
 }
 
-int git_remote_download(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats)
+int git_remote_download(
+		git_remote *remote,
+		git_transfer_progress_callback progress_cb,
+		void *progress_payload)
 {
 	int error;
 
-	assert(remote && bytes && stats);
+	assert(remote);
 
 	if ((error = git_fetch_negotiate(remote)) < 0)
 		return error;
 
-	return git_fetch_download_pack(remote, bytes, stats);
+	return git_fetch_download_pack(remote, progress_cb, progress_payload);
+}
+
+static int update_tips_callback(git_remote_head *head, void *payload)
+{
+	git_vector *refs = (git_vector *)payload;
+
+	return git_vector_insert(refs, head);
+}
+
+static int remote_head_for_fetchspec_src(git_remote_head **out, git_vector *update_heads, const char *fetchspec_src)
+{
+	unsigned int i;
+	git_remote_head *remote_ref;
+
+	assert(update_heads && fetchspec_src);
+
+	*out = NULL;
+
+	git_vector_foreach(update_heads, i, remote_ref) {
+		if (strcmp(remote_ref->name, fetchspec_src) == 0) {
+			*out = remote_ref;
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static int remote_head_for_ref(git_remote_head **out, git_remote *remote, git_vector *update_heads, git_reference *ref)
+{
+	git_reference *resolved_ref = NULL;
+	git_reference *tracking_ref = NULL;
+	git_buf remote_name = GIT_BUF_INIT;
+	int error = 0;
+
+	assert(out && remote && ref);
+
+	*out = NULL;
+
+	if ((error = git_reference_resolve(&resolved_ref, ref)) < 0 ||
+		(!git_reference_is_branch(resolved_ref)) ||
+		(error = git_branch_upstream(&tracking_ref, resolved_ref)) < 0 ||
+		(error = git_refspec_transform_l(&remote_name, &remote->fetch, git_reference_name(tracking_ref))) < 0) {
+		/* Not an error if HEAD is orphaned or no tracking branch */
+		if (error == GIT_ENOTFOUND)
+			error = 0;
+
+		goto cleanup;
+	}
+
+	error = remote_head_for_fetchspec_src(out, update_heads, git_buf_cstr(&remote_name));
+
+cleanup:
+	git_reference_free(tracking_ref);
+	git_reference_free(resolved_ref);
+	git_buf_free(&remote_name);
+	return error;
+}
+
+static int git_remote_write_fetchhead(git_remote *remote, git_vector *update_heads)
+{
+	struct git_refspec *spec;
+	git_reference *head_ref = NULL;
+	git_fetchhead_ref *fetchhead_ref;
+	git_remote_head *remote_ref, *merge_remote_ref;
+	git_vector fetchhead_refs;
+	bool include_all_fetchheads;
+	unsigned int i = 0;
+	int error = 0;
+
+	assert(remote);
+
+	/* no heads, nothing to do */
+	if (update_heads->length == 0)
+		return 0;
+
+	spec = &remote->fetch;
+
+	if (git_vector_init(&fetchhead_refs, update_heads->length, git_fetchhead_ref_cmp) < 0)
+		return -1;
+
+	/* Iff refspec is * (but not subdir slash star), include tags */
+	include_all_fetchheads = (strcmp(GIT_REFS_HEADS_DIR "*", git_refspec_src(spec)) == 0);
+
+	/* Determine what to merge: if refspec was a wildcard, just use HEAD */
+	if (git_refspec_is_wildcard(spec)) {
+		if ((error = git_reference_lookup(&head_ref, remote->repo, GIT_HEAD_FILE)) < 0 ||
+			(error = remote_head_for_ref(&merge_remote_ref, remote, update_heads, head_ref)) < 0)
+				goto cleanup;
+	} else {
+		/* If we're fetching a single refspec, that's the only thing that should be in FETCH_HEAD. */
+		if ((error = remote_head_for_fetchspec_src(&merge_remote_ref, update_heads, git_refspec_src(spec))) < 0)
+			goto cleanup;
+	}
+
+	/* Create the FETCH_HEAD file */
+	git_vector_foreach(update_heads, i, remote_ref) {
+		int merge_this_fetchhead = (merge_remote_ref == remote_ref);
+
+		if (!include_all_fetchheads &&
+			!git_refspec_src_matches(spec, remote_ref->name) &&
+			!merge_this_fetchhead)
+			continue;
+
+		if (git_fetchhead_ref_create(&fetchhead_ref,
+			&remote_ref->oid,
+			merge_this_fetchhead,
+			remote_ref->name,
+			git_remote_url(remote)) < 0)
+			goto cleanup;
+
+		if (git_vector_insert(&fetchhead_refs, fetchhead_ref) < 0)
+			goto cleanup;
+	}
+
+	git_fetchhead_write(remote->repo, &fetchhead_refs);
+
+cleanup:
+	for (i = 0; i < fetchhead_refs.length; ++i)
+		git_fetchhead_ref_free(fetchhead_refs.contents[i]);
+
+	git_vector_free(&fetchhead_refs);
+	git_reference_free(head_ref);
+
+	return error;
 }
 
 int git_remote_update_tips(git_remote *remote)
@@ -490,48 +792,48 @@ int git_remote_update_tips(git_remote *remote)
 	unsigned int i = 0;
 	git_buf refname = GIT_BUF_INIT;
 	git_oid old;
-	git_pkt *pkt;
 	git_odb *odb;
-	git_vector *refs;
 	git_remote_head *head;
 	git_reference *ref;
 	struct git_refspec *spec;
 	git_refspec tagspec;
+	git_vector refs, update_heads;
 
 	assert(remote);
 
-	refs = &remote->transport->refs;
 	spec = &remote->fetch;
-
-	if (refs->length == 0)
-		return 0;
-
+	
 	if (git_repository_odb__weakptr(&odb, remote->repo) < 0)
 		return -1;
 
 	if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
 		return -1;
 
-	/* HEAD is only allowed to be the first in the list */
-	pkt = refs->contents[0];
-	head = &((git_pkt_ref *)pkt)->head;
-	if (!strcmp(head->name, GIT_HEAD_FILE)) {
-		if (git_reference_create_oid(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1) < 0)
-			return -1;
+	/* Make a copy of the transport's refs */
+	if (git_vector_init(&refs, 16, NULL) < 0 ||
+		git_vector_init(&update_heads, 16, NULL) < 0)
+		return -1;
 
-		i = 1;
-		git_reference_free(ref);
+	if (git_remote_ls(remote, update_tips_callback, &refs) < 0)
+		goto on_error;
+
+	/* Let's go find HEAD, if it exists. Check only the first ref in the vector. */
+	if (refs.length > 0) {
+		head = (git_remote_head *)refs.contents[0];
+
+		if (!strcmp(head->name, GIT_HEAD_FILE))	{
+			if (git_reference_create(&ref, remote->repo, GIT_FETCH_HEAD_FILE, &head->oid, 1) < 0)
+				goto on_error;
+
+			i = 1;
+			git_reference_free(ref);
+		}
 	}
 
-	for (; i < refs->length; ++i) {
-		git_pkt *pkt = refs->contents[i];
+	for (; i < refs.length; ++i) {
+		head = (git_remote_head *)refs.contents[i];
 		autotag = 0;
 
-		if (pkt->type == GIT_PKT_REF)
-			head = &((git_pkt_ref *)pkt)->head;
-		else
-			continue;
-
 		/* Ignore malformed ref names (which also saves us from tag^{} */
 		if (!git_reference_is_valid_name(head->name))
 			continue;
@@ -557,7 +859,10 @@ int git_remote_update_tips(git_remote *remote)
 		if (autotag && !git_odb_exists(odb, &head->oid))
 			continue;
 
-		error = git_reference_name_to_oid(&old, remote->repo, refname.ptr);
+		if (git_vector_insert(&update_heads, head) < 0)
+			goto on_error;
+
+		error = git_reference_name_to_id(&old, remote->repo, refname.ptr);
 		if (error < 0 && error != GIT_ENOTFOUND)
 			goto on_error;
 
@@ -568,23 +873,31 @@ int git_remote_update_tips(git_remote *remote)
 			continue;
 
 		/* In autotag mode, don't overwrite any locally-existing tags */
-		error = git_reference_create_oid(&ref, remote->repo, refname.ptr, &head->oid, !autotag);
+		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag);
 		if (error < 0 && error != GIT_EEXISTS)
 			goto on_error;
 
 		git_reference_free(ref);
 
 		if (remote->callbacks.update_tips != NULL) {
-			if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.data) < 0)
+			if (remote->callbacks.update_tips(refname.ptr, &old, &head->oid, remote->callbacks.payload) < 0)
 				goto on_error;
 		}
 	}
 
+	if (git_remote_update_fetchhead(remote) &&
+		(error = git_remote_write_fetchhead(remote, &update_heads)) < 0)
+		goto on_error;
+
+	git_vector_free(&refs);
+	git_vector_free(&update_heads);
 	git_refspec__free(&tagspec);
 	git_buf_free(&refname);
 	return 0;
 
 on_error:
+	git_vector_free(&refs);
+	git_vector_free(&update_heads);
 	git_refspec__free(&tagspec);
 	git_buf_free(&refname);
 	return -1;
@@ -594,20 +907,28 @@ on_error:
 int git_remote_connected(git_remote *remote)
 {
 	assert(remote);
-	return remote->transport == NULL ? 0 : remote->transport->connected;
+
+	if (!remote->transport || !remote->transport->is_connected)
+		return 0;
+
+	/* Ask the transport if it's connected. */
+	return remote->transport->is_connected(remote->transport);
 }
 
 void git_remote_stop(git_remote *remote)
 {
-	git_atomic_set(&remote->transport->cancel, 1);
+	assert(remote);
+
+	if (remote->transport && remote->transport->cancel)
+		remote->transport->cancel(remote->transport);
 }
 
 void git_remote_disconnect(git_remote *remote)
 {
 	assert(remote);
 
-	if (remote->transport != NULL && remote->transport->connected)
-			remote->transport->close(remote->transport);
+	if (git_remote_connected(remote))
+		remote->transport->close(remote->transport);
 }
 
 void git_remote_free(git_remote *remote)
@@ -700,54 +1021,371 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 	return 0;
 }
 
-int git_remote_add(git_remote **out, git_repository *repo, const char *name, const char *url)
+void git_remote_check_cert(git_remote *remote, int check)
 {
-	git_buf buf = GIT_BUF_INIT;
+	assert(remote);
 
-	if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)
-		return -1;
+	remote->check_cert = check;
+}
 
-	if (git_remote_new(out, repo, name, url, git_buf_cstr(&buf)) < 0)
-		goto on_error;
+int git_remote_set_callbacks(git_remote *remote, git_remote_callbacks *callbacks)
+{
+	assert(remote && callbacks);
 
-	git_buf_free(&buf);
+	GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
 
-	if (git_remote_save(*out) < 0)
-		goto on_error;
+	memcpy(&remote->callbacks, callbacks, sizeof(git_remote_callbacks));
 
-	return 0;
+	if (remote->transport && remote->transport->set_callbacks)
+		remote->transport->set_callbacks(remote->transport,
+			remote->callbacks.progress,
+			NULL,
+			remote->callbacks.payload);
 
-on_error:
-	git_buf_free(&buf);
-	git_remote_free(*out);
-	return -1;
+	return 0;
 }
 
-void git_remote_check_cert(git_remote *remote, int check)
+void git_remote_set_cred_acquire_cb(
+	git_remote *remote,
+	git_cred_acquire_cb cred_acquire_cb,
+	void *payload)
 {
 	assert(remote);
 
-	remote->check_cert = check;
+	remote->cred_acquire_cb = cred_acquire_cb;
+	remote->cred_acquire_payload = payload;
 }
 
-void git_remote_set_callbacks(git_remote *remote, git_remote_callbacks *callbacks)
+int git_remote_set_transport(git_remote *remote, git_transport *transport)
 {
-	assert(remote && callbacks);
+	assert(remote && transport);
 
-	memcpy(&remote->callbacks, callbacks, sizeof(git_remote_callbacks));
+	GITERR_CHECK_VERSION(transport, GIT_TRANSPORT_VERSION, "git_transport");
 
 	if (remote->transport) {
-		remote->transport->progress_cb = remote->callbacks.progress;
-		remote->transport->cb_data = remote->callbacks.data;
+		giterr_set(GITERR_NET, "A transport is already bound to this remote");
+		return -1;
 	}
+
+	remote->transport = transport;
+	return 0;
+}
+
+const git_transfer_progress* git_remote_stats(git_remote *remote)
+{
+	assert(remote);
+	return &remote->stats;
 }
 
-int git_remote_autotag(git_remote *remote)
+git_remote_autotag_option_t git_remote_autotag(git_remote *remote)
 {
 	return remote->download_tags;
 }
 
-void git_remote_set_autotag(git_remote *remote, int value)
+void git_remote_set_autotag(git_remote *remote, git_remote_autotag_option_t value)
 {
 	remote->download_tags = value;
 }
+
+static int rename_remote_config_section(
+	git_repository *repo,
+	const char *old_name,
+	const char *new_name)
+{
+	git_buf old_section_name = GIT_BUF_INIT,
+		new_section_name = GIT_BUF_INIT;
+	int error = -1;
+
+	if (git_buf_printf(&old_section_name, "remote.%s", old_name) < 0)
+		goto cleanup;
+
+	if (git_buf_printf(&new_section_name, "remote.%s", new_name) < 0)
+		goto cleanup;
+
+	error = git_config_rename_section(
+		repo,
+		git_buf_cstr(&old_section_name),
+		git_buf_cstr(&new_section_name));
+
+cleanup:
+	git_buf_free(&old_section_name);
+	git_buf_free(&new_section_name);
+
+	return error;
+}
+
+struct update_data
+{
+	git_config *config;
+	const char *old_remote_name;
+	const char *new_remote_name;
+};
+
+static int update_config_entries_cb(
+	const git_config_entry *entry,
+	void *payload)
+{
+	struct update_data *data = (struct update_data *)payload;
+
+	if (strcmp(entry->value, data->old_remote_name))
+		return 0;
+
+	return git_config_set_string(
+		data->config,
+		entry->name,
+		data->new_remote_name);
+}
+
+static int update_branch_remote_config_entry(
+	git_repository *repo,
+	const char *old_name,
+	const char *new_name)
+{
+	git_config *config;
+	struct update_data data;
+
+	if (git_repository_config__weakptr(&config, repo) < 0)
+		return -1;
+
+	data.config = config;
+	data.old_remote_name = old_name;
+	data.new_remote_name = new_name;
+
+	return git_config_foreach_match(
+		config,
+		"branch\\..+\\.remote",
+		update_config_entries_cb, &data);
+}
+
+static int rename_cb(const char *ref, void *data)
+{
+	if (git__prefixcmp(ref, GIT_REFS_REMOTES_DIR))
+		return 0;
+	
+	return git_vector_insert((git_vector *)data, git__strdup(ref));
+}
+
+static int rename_one_remote_reference(
+	git_repository *repo,
+	const char *reference_name,
+	const char *old_remote_name,
+	const char *new_remote_name)
+{
+	int error = -1;
+	git_buf new_name = GIT_BUF_INIT;
+	git_reference *reference = NULL;
+	git_reference *newref = NULL;
+
+	if (git_buf_printf(
+		&new_name,
+		GIT_REFS_REMOTES_DIR "%s%s",
+		new_remote_name,
+		reference_name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name)) < 0)
+			return -1;
+
+	if (git_reference_lookup(&reference, repo, reference_name) < 0)
+		goto cleanup;
+
+	error = git_reference_rename(&newref, reference, git_buf_cstr(&new_name), 0);
+	git_reference_free(reference);
+
+cleanup:
+	git_reference_free(newref);
+	git_buf_free(&new_name);
+	return error;
+}
+
+static int rename_remote_references(
+	git_repository *repo,
+	const char *old_name,
+	const char *new_name)
+{
+	git_vector refnames;
+	int error = -1;
+	unsigned int i;
+	char *name;
+
+	if (git_vector_init(&refnames, 8, NULL) < 0)
+		goto cleanup;
+
+	if (git_reference_foreach(
+		repo,
+		GIT_REF_LISTALL,
+		rename_cb,
+		&refnames) < 0)
+			goto cleanup;
+
+	git_vector_foreach(&refnames, i, name) {
+		if ((error = rename_one_remote_reference(repo, name, old_name, new_name)) < 0)
+			goto cleanup;
+	}
+
+	error = 0;
+cleanup:
+	git_vector_foreach(&refnames, i, name) {
+		git__free(name);
+	}
+
+	git_vector_free(&refnames);
+	return error;
+}
+
+static int rename_fetch_refspecs(
+	git_remote *remote,
+	const char *new_name,
+	int (*callback)(const char *problematic_refspec, void *payload),
+	void *payload)
+{
+	git_config *config;
+	const git_refspec *fetch_refspec;
+	git_buf dst_prefix = GIT_BUF_INIT, serialized = GIT_BUF_INIT;
+	const char* pos;
+	int error = -1;
+
+	fetch_refspec = git_remote_fetchspec(remote);
+
+	/* Is there a refspec to deal with? */
+	if (fetch_refspec->src == NULL &&
+		fetch_refspec->dst == NULL)
+		return 0;
+
+	if (git_refspec__serialize(&serialized, fetch_refspec) < 0)
+		goto cleanup;
+
+	/* Is it an in-memory remote? */
+	if (!remote->name) {
+		error = (callback(git_buf_cstr(&serialized), payload) < 0) ? GIT_EUSER : 0;
+		goto cleanup;
+	}
+
+	if (git_buf_printf(&dst_prefix, ":refs/remotes/%s/", remote->name) < 0)
+		goto cleanup;
+
+	pos = strstr(git_buf_cstr(&serialized), git_buf_cstr(&dst_prefix));
+
+	/* Does the dst part of the refspec follow the extected standard format? */
+	if (!pos) {
+		error = (callback(git_buf_cstr(&serialized), payload) < 0) ? GIT_EUSER : 0;
+		goto cleanup;
+	}
+
+	if (git_buf_splice(
+		&serialized,
+		pos - git_buf_cstr(&serialized) + strlen(":refs/remotes/"),
+		strlen(remote->name), new_name,
+		strlen(new_name)) < 0)
+			goto cleanup;
+
+	git_refspec__free(&remote->fetch);
+
+	if (git_refspec__parse(&remote->fetch, git_buf_cstr(&serialized), true) < 0)
+		goto cleanup;
+
+	if (git_repository_config__weakptr(&config, remote->repo) < 0)
+		goto cleanup;
+
+	error = update_config_refspec(config, new_name, &remote->fetch, GIT_DIRECTION_FETCH);
+
+cleanup:
+	git_buf_free(&serialized);
+	git_buf_free(&dst_prefix);
+	return error;
+}
+
+int git_remote_rename(
+	git_remote *remote,
+	const char *new_name,
+	git_remote_rename_problem_cb callback,
+	void *payload)
+{
+	int error;
+
+	assert(remote && new_name);
+
+	if (!remote->name) {
+		giterr_set(GITERR_INVALID, "Can't rename an in-memory remote.");
+		return GIT_EINVALIDSPEC;
+	}
+
+	if ((error = ensure_remote_name_is_valid(new_name)) < 0)
+		return error;
+
+	if (remote->repo) {
+		if ((error = ensure_remote_doesnot_exist(remote->repo, new_name)) < 0)
+			return error;
+
+		if (!remote->name) {
+			if ((error = rename_fetch_refspecs(
+				remote,
+				new_name,
+				callback,
+				payload)) < 0)
+				return error;
+
+			remote->name = git__strdup(new_name);
+
+			if (!remote->name) return 0;
+			return git_remote_save(remote);
+		}
+
+		if ((error = rename_remote_config_section(
+			remote->repo,
+			remote->name,
+			new_name)) < 0)
+				return error;
+
+		if ((error = update_branch_remote_config_entry(
+			remote->repo,
+			remote->name,
+			new_name)) < 0)
+				return error;
+
+		if ((error = rename_remote_references(
+			remote->repo,
+			remote->name,
+			new_name)) < 0)
+				return error;
+
+		if ((error = rename_fetch_refspecs(
+			remote,
+			new_name,
+			callback,
+			payload)) < 0)
+			return error;
+	}
+
+	git__free(remote->name);
+	remote->name = git__strdup(new_name);
+
+	return 0;
+}
+
+int git_remote_update_fetchhead(git_remote *remote)
+{
+	return remote->update_fetchhead;
+}
+
+void git_remote_set_update_fetchhead(git_remote *remote, int value)
+{
+	remote->update_fetchhead = value;
+}
+
+int git_remote_is_valid_name(
+	const char *remote_name)
+{
+	git_buf buf = GIT_BUF_INIT;
+	git_refspec refspec;
+	int error = -1;
+
+	if (!remote_name || *remote_name == '\0')
+		return 0;
+
+	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);
+
+	giterr_clear();
+	return error == 0;
+}