6 files changed, 747 insertions, 361 deletions

diff --git a/Documentation/git-cvsimport.txt b/Documentation/git-cvsimport.txt
index dfe86ceea3..57027b448f 100644
--- a/Documentation/git-cvsimport.txt
+++ b/Documentation/git-cvsimport.txt
@@ -22,6 +22,12 @@ repository, or incrementally import into an existing one.
 Splitting the CVS log into patch sets is done by 'cvsps'.
 At least version 2.1 is required.
 
+You should *never* do any work of your own on the branches that are
+created by git-cvsimport. The initial import will create and populate a
+"master" branch from the CVS repository's main branch which you're free
+to work with; after that, you need to 'git merge' incremental imports, or
+any CVS branches, yourself.
+
 OPTIONS
 -------
 -d <CVSROOT>::
diff --git a/Makefile b/Makefile
index ab2890d638..8e2a496757 100644
--- a/Makefile
+++ b/Makefile
@@ -526,7 +526,7 @@ git-http-fetch$X: fetch.o http.o http-fetch.o $(LIB_FILE)
 	$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
 		$(LIBS) $(CURL_LIBCURL)
 
-git-http-push$X: http.o http-push.o $(LIB_FILE)
+git-http-push$X: revision.o http.o http-push.o $(LIB_FILE)
 	$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
 		$(LIBS) $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
 
diff --git a/git-cvsimport.perl b/git-cvsimport.perl
index b46469ab32..02d1928ada 100755
--- a/git-cvsimport.perl
+++ b/git-cvsimport.perl
@@ -452,7 +452,6 @@ chdir($git_tree);
 
 my $last_branch = "";
 my $orig_branch = "";
-my $forward_master = 0;
 my %branch_date;
 
 my $git_dir = $ENV{"GIT_DIR"} || ".git";
@@ -488,21 +487,6 @@ unless(-d $git_dir) {
 		$last_branch = "master";
 	}
 	$orig_branch = $last_branch;
-	if (-f "$git_dir/CVS2GIT_HEAD") {
-		die <<EOM;
-CVS2GIT_HEAD exists.
-Make sure your working directory corresponds to HEAD and remove CVS2GIT_HEAD.
-You may need to run
-
-    git read-tree -m -u CVS2GIT_HEAD HEAD
-EOM
-	}
-	system('cp', "$git_dir/HEAD", "$git_dir/CVS2GIT_HEAD");
-
-	$forward_master =
-	    $opt_o ne 'master' && -f "$git_dir/refs/heads/master" &&
-	    system('cmp', '-s', "$git_dir/refs/heads/master", 
-				"$git_dir/refs/heads/$opt_o") == 0;
 
 	# populate index
 	system('git-read-tree', $last_branch);
@@ -889,17 +873,11 @@ if (defined $orig_git_index) {
 
 # Now switch back to the branch we were in before all of this happened
 if($orig_branch) {
-	print "DONE\n" if $opt_v;
-	system("cp","$git_dir/refs/heads/$opt_o","$git_dir/refs/heads/master")
-		if $forward_master;
-	unless ($opt_i) {
-		system('git-read-tree', '-m', '-u', 'CVS2GIT_HEAD', 'HEAD');
-		die "read-tree failed: $?\n" if $?;
-	}
+	print "DONE; you may need to merge manually.\n" if $opt_v;
 } else {
 	$orig_branch = "master";
 	print "DONE; creating $orig_branch branch\n" if $opt_v;
-	system("cp","$git_dir/refs/heads/$opt_o","$git_dir/refs/heads/master")
+	system("git-update-ref", "refs/heads/master", "refs/heads/$opt_o")
 		unless -f "$git_dir/refs/heads/master";
 	system('git-update-ref', 'HEAD', "$orig_branch");
 	unless ($opt_i) {
@@ -907,4 +885,3 @@ if($orig_branch) {
 		die "checkout failed: $?\n" if $?;
 	}
 }
-unlink("$git_dir/CVS2GIT_HEAD");
diff --git a/http-push.c b/http-push.c
index fe925609b4..226d71966d 100644
--- a/http-push.c
+++ b/http-push.c
@@ -5,6 +5,8 @@
 #include "tag.h"
 #include "blob.h"
 #include "http.h"
+#include "refs.h"
+#include "revision.h"
 
 #include <expat.h>
 
@@ -42,14 +44,24 @@ enum XML_Status {
 #define DAV_ACTIVELOCK_OWNER ".prop.lockdiscovery.activelock.owner.href"
 #define DAV_ACTIVELOCK_TIMEOUT ".prop.lockdiscovery.activelock.timeout"
 #define DAV_ACTIVELOCK_TOKEN ".prop.lockdiscovery.activelock.locktoken.href"
+#define DAV_PROPFIND_RESP ".multistatus.response"
+#define DAV_PROPFIND_NAME ".multistatus.response.href"
+#define DAV_PROPFIND_COLLECTION ".multistatus.response.propstat.prop.resourcetype.collection"
 
 /* DAV request body templates */
-#define PROPFIND_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop xmlns:R=\"%s\">\n<D:supportedlock/>\n</D:prop>\n</D:propfind>"
+#define PROPFIND_SUPPORTEDLOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop xmlns:R=\"%s\">\n<D:supportedlock/>\n</D:prop>\n</D:propfind>"
+#define PROPFIND_ALL_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/>\n</D:propfind>"
 #define LOCK_REQUEST "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:lockinfo xmlns:D=\"DAV:\">\n<D:lockscope><D:exclusive/></D:lockscope>\n<D:locktype><D:write/></D:locktype>\n<D:owner>\n<D:href>mailto:%s</D:href>\n</D:owner>\n</D:lockinfo>"
 
 #define LOCK_TIME 600
 #define LOCK_REFRESH 30
 
+/* bits #0-4 in revision.h */
+
+#define LOCAL   (1u << 5)
+#define REMOTE  (1u << 6)
+#define PUSHING (1u << 7)
+
 static int pushing = 0;
 static int aborted = 0;
 static char remote_dir_exists[256];
@@ -61,17 +73,19 @@ static int push_verbosely = 0;
 static int push_all = 0;
 static int force_all = 0;
 
+static struct object_list *objects = NULL;
+
 struct repo
 {
 	char *url;
+	int path_len;
 	struct packed_git *packs;
 };
 
 static struct repo *remote = NULL;
+static struct remote_lock *remote_locks = NULL;
 
 enum transfer_state {
-	NEED_CHECK,
-	RUN_HEAD,
 	NEED_PUSH,
 	RUN_MKCOL,
 	RUN_PUT,
@@ -82,10 +96,10 @@ enum transfer_state {
 
 struct transfer_request
 {
-	unsigned char sha1[20];
+	struct object *obj;
 	char *url;
 	char *dest;
-	struct active_lock *lock;
+	struct remote_lock *lock;
 	struct curl_slist *headers;
 	struct buffer buffer;
 	char filename[PATH_MAX];
@@ -114,14 +128,23 @@ struct xml_ctx
 	void *userData;
 };
 
-struct active_lock
+struct remote_lock
 {
 	char *url;
 	char *owner;
 	char *token;
 	time_t start_time;
 	long timeout;
+	int active;
 	int refreshing;
+	struct remote_lock *next;
+};
+
+struct remote_dentry
+{
+	char *base;
+	char *name;
+	int is_dir;
 };
 
 static void finish_request(struct transfer_request *request);
@@ -134,42 +157,9 @@ static void process_response(void *callback_data)
 	finish_request(request);
 }
 
-static void start_check(struct transfer_request *request)
-{
-	char *hex = sha1_to_hex(request->sha1);
-	struct active_request_slot *slot;
-	char *posn;
-
-	request->url = xmalloc(strlen(remote->url) + 55);
-	strcpy(request->url, remote->url);
-	posn = request->url + strlen(remote->url);
-	strcpy(posn, "objects/");
-	posn += 8;
-	memcpy(posn, hex, 2);
-	posn += 2;
-	*(posn++) = '/';
-	strcpy(posn, hex + 2);
-
-	slot = get_active_slot();
-	slot->callback_func = process_response;
-	slot->callback_data = request;
-	curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
-	curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
-	curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
-
-	if (start_active_slot(slot)) {
-		request->slot = slot;
-		request->state = RUN_HEAD;
-	} else {
-		request->state = ABORTED;
-		free(request->url);
-		request->url = NULL;
-	}
-}
-
 static void start_mkcol(struct transfer_request *request)
 {
-	char *hex = sha1_to_hex(request->sha1);
+	char *hex = sha1_to_hex(request->obj->sha1);
 	struct active_request_slot *slot;
 	char *posn;
 
@@ -203,7 +193,7 @@ static void start_mkcol(struct transfer_request *request)
 
 static void start_put(struct transfer_request *request)
 {
-	char *hex = sha1_to_hex(request->sha1);
+	char *hex = sha1_to_hex(request->obj->sha1);
 	struct active_request_slot *slot;
 	char *posn;
 	char type[20];
@@ -214,7 +204,7 @@ static void start_put(struct transfer_request *request)
 	ssize_t size;
 	z_stream stream;
 
-	unpacked = read_sha1_file(request->sha1, type, &len);
+	unpacked = read_sha1_file(request->obj->sha1, type, &len);
 	hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
 
 	/* Set it up */
@@ -309,64 +299,90 @@ static void start_move(struct transfer_request *request)
 	}
 }
 
-static int refresh_lock(struct active_lock *lock)
+static int refresh_lock(struct remote_lock *check_lock)
 {
 	struct active_request_slot *slot;
 	char *if_header;
 	char timeout_header[25];
 	struct curl_slist *dav_headers = NULL;
-	int rc = 0;
+	struct remote_lock *lock;
+	int time_remaining;
+	time_t current_time;
 
-	lock->refreshing = 1;
+	/* Refresh all active locks if they're close to expiring */
+	for (lock = remote_locks; lock; lock = lock->next) {
+		if (!lock->active)
+			continue;
 
-	if_header = xmalloc(strlen(lock->token) + 25);
-	sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
-	sprintf(timeout_header, "Timeout: Second-%ld", lock->timeout);
-	dav_headers = curl_slist_append(dav_headers, if_header);
-	dav_headers = curl_slist_append(dav_headers, timeout_header);
+		current_time = time(NULL);
+		time_remaining = lock->start_time + lock->timeout
+			- current_time;
+		if (time_remaining > LOCK_REFRESH)
+			continue;
 
-	slot = get_active_slot();
-	curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
-	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
-	curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
-	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
-	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+		lock->refreshing = 1;
 
-	if (start_active_slot(slot)) {
-		run_active_slot(slot);
-		if (slot->curl_result != CURLE_OK) {
-			fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
-		} else {
-			lock->start_time = time(NULL);
-			rc = 1;
+		if_header = xmalloc(strlen(lock->token) + 25);
+		sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
+		sprintf(timeout_header, "Timeout: Second-%ld", lock->timeout);
+		dav_headers = curl_slist_append(dav_headers, if_header);
+		dav_headers = curl_slist_append(dav_headers, timeout_header);
+
+		slot = get_active_slot();
+		curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
+		curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
+		curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
+		curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
+		curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+
+		if (start_active_slot(slot)) {
+			run_active_slot(slot);
+			if (slot->curl_result != CURLE_OK) {
+				fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
+				lock->active = 0;
+			} else {
+				lock->active = 1;
+				lock->start_time = time(NULL);
+			}
 		}
+
+		lock->refreshing = 0;
+		curl_slist_free_all(dav_headers);
+		free(if_header);
 	}
 
-	lock->refreshing = 0;
-	curl_slist_free_all(dav_headers);
-	free(if_header);
+	if (check_lock)
+		return check_lock->active;
+	else
+		return 0;
+}
 
-	return rc;
+static void release_request(struct transfer_request *request)
+{
+	struct transfer_request *entry = request_queue_head;
+
+	if (request == request_queue_head) {
+		request_queue_head = request->next;
+	} else {
+		while (entry->next != NULL && entry->next != request)
+			entry = entry->next;
+		if (entry->next == request)
+			entry->next = entry->next->next;
+	}
+
+	if (request->url != NULL)
+		free(request->url);
+	free(request);
 }
 
 static void finish_request(struct transfer_request *request)
 {
-	time_t current_time = time(NULL);
-	int time_remaining;
-
 	request->curl_result =	request->slot->curl_result;
 	request->http_code = request->slot->http_code;
 	request->slot = NULL;
 
-	/* Refresh the lock if it is close to timing out */
-	time_remaining = request->lock->start_time + request->lock->timeout
-		- current_time;
-	if (time_remaining < LOCK_REFRESH && !request->lock->refreshing) {
-		if (!refresh_lock(request->lock)) {
-			fprintf(stderr, "Unable to refresh remote lock\n");
-			aborted = 1;
-		}
-	}
+	/* Keep locks active */
+	refresh_lock(request->lock);
 
 	if (request->headers != NULL)
 		curl_slist_free_all(request->headers);
@@ -375,29 +391,16 @@ static void finish_request(struct transfer_request *request)
 	if (request->state != RUN_PUT) {
 		free(request->url);
 		request->url = NULL;
-	}		
+	}
 
-	if (request->state == RUN_HEAD) {
-		if (request->http_code == 404) {
-			request->state = NEED_PUSH;
-		} else if (request->curl_result == CURLE_OK) {
-			remote_dir_exists[request->sha1[0]] = 1;
-			request->state = COMPLETE;
-		} else {
-			fprintf(stderr, "HEAD %s failed, aborting (%d/%ld)\n",
-				sha1_to_hex(request->sha1),
-				request->curl_result, request->http_code);
-			request->state = ABORTED;
-			aborted = 1;
-		}
-	} else if (request->state == RUN_MKCOL) {
+	if (request->state == RUN_MKCOL) {
 		if (request->curl_result == CURLE_OK ||
 		    request->http_code == 405) {
-			remote_dir_exists[request->sha1[0]] = 1;
+			remote_dir_exists[request->obj->sha1[0]] = 1;
 			start_put(request);
 		} else {
 			fprintf(stderr, "MKCOL %s failed, aborting (%d/%ld)\n",
-				sha1_to_hex(request->sha1),
+				sha1_to_hex(request->obj->sha1),
 				request->curl_result, request->http_code);
 			request->state = ABORTED;
 			aborted = 1;
@@ -407,21 +410,21 @@ static void finish_request(struct transfer_request *request)
 			start_move(request);
 		} else {
 			fprintf(stderr,	"PUT %s failed, aborting (%d/%ld)\n",
-				sha1_to_hex(request->sha1),
+				sha1_to_hex(request->obj->sha1),
 				request->curl_result, request->http_code);
 			request->state = ABORTED;
 			aborted = 1;
 		}
 	} else if (request->state == RUN_MOVE) {
 		if (request->curl_result == CURLE_OK) {
-			if (push_verbosely)
-				fprintf(stderr,
-					"sent %s\n",
-					sha1_to_hex(request->sha1));
+			fprintf(stderr, "    sent %s\n",
+				sha1_to_hex(request->obj->sha1));
 			request->state = COMPLETE;
+			request->obj->flags |= REMOTE;
+			release_request(request);
 		} else {
 			fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
-				sha1_to_hex(request->sha1),
+				sha1_to_hex(request->obj->sha1),
 				request->curl_result, request->http_code);
 			request->state = ABORTED;
 			aborted = 1;
@@ -429,24 +432,6 @@ static void finish_request(struct transfer_request *request)
 	}
 }
 
-static void release_request(struct transfer_request *request)
-{
-	struct transfer_request *entry = request_queue_head;
-
-	if (request == request_queue_head) {
-		request_queue_head = request->next;
-	} else {
-		while (entry->next != NULL && entry->next != request)
-			entry = entry->next;
-		if (entry->next == request)
-			entry->next = entry->next->next;
-	}
-
-	if (request->url != NULL)
-		free(request->url);
-	free(request);
-}
-
 void fill_active_slots(void)
 {
 	struct transfer_request *request = request_queue_head;
@@ -457,14 +442,12 @@ void fill_active_slots(void)
 		return;
 
 	while (active_requests < max_requests && request != NULL) {
-		if (!pushing && request->state == NEED_CHECK) {
-			start_check(request);
-			curl_multi_perform(curlm, &num_transfers);
-		} else if (pushing && request->state == NEED_PUSH) {
-			if (remote_dir_exists[request->sha1[0]])
+		if (pushing && request->state == NEED_PUSH) {
+			if (remote_dir_exists[request->obj->sha1[0]] == 1) {
 				start_put(request);
-			else
+			} else {
 				start_mkcol(request);
+			}
 			curl_multi_perform(curlm, &num_transfers);
 		}
 		request = request->next;
@@ -476,29 +459,37 @@ void fill_active_slots(void)
 			slot->curl = NULL;
 		}
 		slot = slot->next;
-	}				
+	}
 }
 
-static void add_request(unsigned char *sha1, struct active_lock *lock)
+static void get_remote_object_list(unsigned char parent);
+
+static void add_request(struct object *obj, struct remote_lock *lock)
 {
 	struct transfer_request *request = request_queue_head;
 	struct packed_git *target;
-	
-	while (request != NULL && memcmp(request->sha1, sha1, 20))
-		request = request->next;
-	if (request != NULL)
-		return;
 
-	target = find_sha1_pack(sha1, remote->packs);
-	if (target)
+	/*
+	 * Don't push the object if it's known to exist on the remote
+	 * or is already in the request queue
+	 */
+	if (remote_dir_exists[obj->sha1[0]] == -1)
+		get_remote_object_list(obj->sha1[0]);
+	if (obj->flags & (REMOTE | PUSHING))
+		return;
+	target = find_sha1_pack(obj->sha1, remote->packs);
+	if (target) {
+		obj->flags |= REMOTE;
 		return;
+	}
 
+	obj->flags |= PUSHING;
 	request = xmalloc(sizeof(*request));
-	memcpy(request->sha1, sha1, 20);
+	request->obj = obj;
 	request->url = NULL;
 	request->lock = lock;
 	request->headers = NULL;
-	request->state = NEED_CHECK;
+	request->state = NEED_PUSH;
 	request->next = request_queue_head;
 	request_queue_head = request;
 
@@ -698,14 +689,13 @@ static char *quote_ref_url(const char *base, const char *ref)
 	int len, baselen, ch;
 
 	baselen = strlen(base);
-	len = baselen + 12; /* "refs/heads/" + NUL */
+	len = baselen + 1;
 	for (cp = ref; (ch = *cp) != 0; cp++, len++)
 		if (needs_quote(ch))
 			len += 2; /* extra two hex plus replacement % */
 	qref = xmalloc(len);
 	memcpy(qref, base, baselen);
-	memcpy(qref + baselen, "refs/heads/", 11);
-	for (cp = ref, dp = qref + baselen + 11; (ch = *cp) != 0; cp++) {
+	for (cp = ref, dp = qref + baselen; (ch = *cp) != 0; cp++) {
 		if (needs_quote(ch)) {
 			*dp++ = '%';
 			*dp++ = hex((ch >> 4) & 0xF);
@@ -751,6 +741,27 @@ int fetch_ref(char *ref, unsigned char *sha1)
         return 0;
 }
 
+static void one_remote_object(const char *hex)
+{
+	unsigned char sha1[20];
+	struct object *obj;
+
+	if (get_sha1_hex(hex, sha1) != 0)
+		return;
+
+	obj = lookup_object(sha1);
+	if (!obj)
+		obj = parse_object(sha1);
+
+	/* Ignore remote objects that don't exist locally */
+	if (!obj)
+		return;
+
+	obj->flags |= REMOTE;
+	if (!object_list_contains(objects, obj))
+		add_object(obj, &objects, NULL, "");
+}
+
 static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
 {
 	int *lock_flags = (int *)ctx->userData;
@@ -772,7 +783,7 @@ static void handle_lockprop_ctx(struct xml_ctx *ctx, int tag_closed)
 
 static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
 {
-	struct active_lock *lock = (struct active_lock *)ctx->userData;
+	struct remote_lock *lock = (struct remote_lock *)ctx->userData;
 
 	if (tag_closed && ctx->cdata) {
 		if (!strcmp(ctx->name, DAV_ACTIVELOCK_OWNER)) {
@@ -791,6 +802,57 @@ static void handle_new_lock_ctx(struct xml_ctx *ctx, int tag_closed)
 	}
 }
 
+static void one_remote_ref(char *refname);
+static void crawl_remote_refs(char *path);
+
+static void handle_crawl_ref_ctx(struct xml_ctx *ctx, int tag_closed)
+{
+	struct remote_dentry *dentry = (struct remote_dentry *)ctx->userData;
+
+
+	if (tag_closed) {
+		if (!strcmp(ctx->name, DAV_PROPFIND_RESP) && dentry->name) {
+			if (dentry->is_dir) {
+				if (strcmp(dentry->name, dentry->base)) {
+					crawl_remote_refs(dentry->name);
+				}
+			} else {
+				one_remote_ref(dentry->name);
+			}
+		} else if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
+			dentry->name = xmalloc(strlen(ctx->cdata) -
+					       remote->path_len + 1);
+			strcpy(dentry->name,
+			       ctx->cdata + remote->path_len);
+		} else if (!strcmp(ctx->name, DAV_PROPFIND_COLLECTION)) {
+			dentry->is_dir = 1;
+		}
+	} else if (!strcmp(ctx->name, DAV_PROPFIND_RESP)) {
+		dentry->name = NULL;
+		dentry->is_dir = 0;
+	}
+}
+
+static void handle_remote_object_list_ctx(struct xml_ctx *ctx, int tag_closed)
+{
+	char *path;
+	char *obj_hex;
+
+	if (tag_closed) {
+		if (!strcmp(ctx->name, DAV_PROPFIND_NAME) && ctx->cdata) {
+			path = ctx->cdata + remote->path_len;
+			if (strlen(path) != 50)
+				return;
+			path += 9;
+			obj_hex = xmalloc(strlen(path));
+			strncpy(obj_hex, path, 2);
+			strcpy(obj_hex + 2, path + 3);
+			one_remote_object(obj_hex);
+			free(obj_hex);
+		}
+	}
+}
+
 static void
 xml_start_tag(void *userData, const char *name, const char **atts)
 {
@@ -848,7 +910,7 @@ xml_cdata(void *userData, const XML_Char *s, int len)
 	strncpy(ctx->cdata, s, len);
 }
 
-static struct active_lock *lock_remote(char *file, long timeout)
+static struct remote_lock *lock_remote(char *path, long timeout)
 {
 	struct active_request_slot *slot;
 	struct buffer out_buffer;
@@ -858,14 +920,26 @@ static struct active_lock *lock_remote(char *file, long timeout)
 	char *url;
 	char *ep;
 	char timeout_header[25];
-	struct active_lock *new_lock = NULL;
+	struct remote_lock *lock = remote_locks;
 	XML_Parser parser = XML_ParserCreate(NULL);
 	enum XML_Status result;
 	struct curl_slist *dav_headers = NULL;
 	struct xml_ctx ctx;
 
-	url = xmalloc(strlen(remote->url) + strlen(file) + 1);
-	sprintf(url, "%s%s", remote->url, file);
+	url = xmalloc(strlen(remote->url) + strlen(path) + 1);
+	sprintf(url, "%s%s", remote->url, path);
+
+	/* Make sure the url is not already locked */
+	while (lock && strcmp(lock->url, url)) {
+		lock = lock->next;
+	}
+	if (lock) {
+		free(url);
+		if (refresh_lock(lock))
+			return lock;
+		else
+			return NULL;
+	}
 
 	/* Make sure leading directories exist for the remote ref */
 	ep = strchr(url + strlen(remote->url) + 11, '/');
@@ -921,11 +995,11 @@ static struct active_lock *lock_remote(char *file, long timeout)
 	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_LOCK);
 	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
 
-	new_lock = xcalloc(1, sizeof(*new_lock));
-	new_lock->owner = NULL;
-	new_lock->token = NULL;
-	new_lock->timeout = -1;
-	new_lock->refreshing = 0;
+	lock = xcalloc(1, sizeof(*lock));
+	lock->owner = NULL;
+	lock->token = NULL;
+	lock->timeout = -1;
+	lock->refreshing = 0;
 
 	if (start_active_slot(slot)) {
 		run_active_slot(slot);
@@ -934,7 +1008,7 @@ static struct active_lock *lock_remote(char *file, long timeout)
 			ctx.len = 0;
 			ctx.cdata = NULL;
 			ctx.userFunc = handle_new_lock_ctx;
-			ctx.userData = new_lock;
+			ctx.userData = lock;
 			XML_SetUserData(parser, &ctx);
 			XML_SetElementHandler(parser, xml_start_tag,
 					      xml_end_tag);
@@ -946,7 +1020,7 @@ static struct active_lock *lock_remote(char *file, long timeout)
 				fprintf(stderr, "XML error: %s\n",
 					XML_ErrorString(
 						XML_GetErrorCode(parser)));
-				new_lock->timeout = -1;
+				lock->timeout = -1;
 			}
 		}
 	} else {
@@ -957,23 +1031,26 @@ static struct active_lock *lock_remote(char *file, long timeout)
 	free(out_data);
 	free(in_data);
 
-	if (new_lock->token == NULL || new_lock->timeout <= 0) {
-		if (new_lock->token != NULL)
-			free(new_lock->token);
-		if (new_lock->owner != NULL)
-			free(new_lock->owner);
+	if (lock->token == NULL || lock->timeout <= 0) {
+		if (lock->token != NULL)
+			free(lock->token);
+		if (lock->owner != NULL)
+			free(lock->owner);
 		free(url);
-		free(new_lock);
-		new_lock = NULL;
+		free(lock);
+		lock = NULL;
 	} else {
-		new_lock->url = url;
-		new_lock->start_time = time(NULL);
+		lock->url = url;
+		lock->active = 1;
+		lock->start_time = time(NULL);
+		lock->next = remote_locks;
+		remote_locks = lock;
 	}
 
-	return new_lock;
+	return lock;
 }
 
-static int unlock_remote(struct active_lock *lock)
+static int unlock_remote(struct remote_lock *lock)
 {
 	struct active_request_slot *slot;
 	char *lock_token_header;
@@ -1005,15 +1082,171 @@ static int unlock_remote(struct active_lock *lock)
 	curl_slist_free_all(dav_headers);
 	free(lock_token_header);
 
-	if (lock->owner != NULL)
-		free(lock->owner);
-	free(lock->url);
-	free(lock->token);
-	free(lock);
+	lock->active = 0;
 
 	return rc;
 }
 
+static void crawl_remote_refs(char *path)
+{
+	char *url;
+	struct active_request_slot *slot;
+	struct buffer in_buffer;
+	struct buffer out_buffer;
+	char *in_data;
+	char *out_data;
+	XML_Parser parser = XML_ParserCreate(NULL);
+	enum XML_Status result;
+	struct curl_slist *dav_headers = NULL;
+	struct xml_ctx ctx;
+	struct remote_dentry dentry;
+
+	fprintf(stderr, "  %s\n", path);
+
+	dentry.base = path;
+	dentry.name = NULL;
+	dentry.is_dir = 0;
+
+	url = xmalloc(strlen(remote->url) + strlen(path) + 1);
+	sprintf(url, "%s%s", remote->url, path);
+
+	out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
+	out_data = xmalloc(out_buffer.size + 1);
+	snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
+	out_buffer.posn = 0;
+	out_buffer.buffer = out_data;
+
+	in_buffer.size = 4096;
+	in_data = xmalloc(in_buffer.size);
+	in_buffer.posn = 0;
+	in_buffer.buffer = in_data;
+
+	dav_headers = curl_slist_append(dav_headers, "Depth: 1");
+	dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
+
+	slot = get_active_slot();
+	curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
+	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+	curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
+	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
+	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+
+	if (start_active_slot(slot)) {
+		run_active_slot(slot);
+		if (slot->curl_result == CURLE_OK) {
+			ctx.name = xcalloc(10, 1);
+			ctx.len = 0;
+			ctx.cdata = NULL;
+			ctx.userFunc = handle_crawl_ref_ctx;
+			ctx.userData = &dentry;
+			XML_SetUserData(parser, &ctx);
+			XML_SetElementHandler(parser, xml_start_tag,
+					      xml_end_tag);
+			XML_SetCharacterDataHandler(parser, xml_cdata);
+			result = XML_Parse(parser, in_buffer.buffer,
+					   in_buffer.posn, 1);
+			free(ctx.name);
+
+			if (result != XML_STATUS_OK) {
+				fprintf(stderr, "XML error: %s\n",
+					XML_ErrorString(
+						XML_GetErrorCode(parser)));
+			}
+		}
+	} else {
+		fprintf(stderr, "Unable to start request\n");
+	}
+
+	free(url);
+	free(out_data);
+	free(in_buffer.buffer);
+	curl_slist_free_all(dav_headers);
+}
+
+static void get_remote_object_list(unsigned char parent)
+{
+	char *url;
+	struct active_request_slot *slot;
+	struct buffer in_buffer;
+	struct buffer out_buffer;
+	char *in_data;
+	char *out_data;
+	XML_Parser parser = XML_ParserCreate(NULL);
+	enum XML_Status result;
+	struct curl_slist *dav_headers = NULL;
+	struct xml_ctx ctx;
+	char path[] = "/objects/XX/";
+	static const char hex[] = "0123456789abcdef";
+	unsigned int val = parent;
+
+	path[9] = hex[val >> 4];
+	path[10] = hex[val & 0xf];
+	url = xmalloc(strlen(remote->url) + strlen(path) + 1);
+	sprintf(url, "%s%s", remote->url, path);
+
+	out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
+	out_data = xmalloc(out_buffer.size + 1);
+	snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
+	out_buffer.posn = 0;
+	out_buffer.buffer = out_data;
+
+	in_buffer.size = 4096;
+	in_data = xmalloc(in_buffer.size);
+	in_buffer.posn = 0;
+	in_buffer.buffer = in_data;
+
+	dav_headers = curl_slist_append(dav_headers, "Depth: 1");
+	dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
+
+	slot = get_active_slot();
+	curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
+	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
+	curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+	curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
+	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PROPFIND);
+	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+
+	if (start_active_slot(slot)) {
+		run_active_slot(slot);
+		if (slot->curl_result == CURLE_OK) {
+			remote_dir_exists[parent] = 1;
+			ctx.name = xcalloc(10, 1);
+			ctx.len = 0;
+			ctx.cdata = NULL;
+			ctx.userFunc = handle_remote_object_list_ctx;
+			XML_SetUserData(parser, &ctx);
+			XML_SetElementHandler(parser, xml_start_tag,
+					      xml_end_tag);
+			XML_SetCharacterDataHandler(parser, xml_cdata);
+			result = XML_Parse(parser, in_buffer.buffer,
+					   in_buffer.posn, 1);
+			free(ctx.name);
+
+			if (result != XML_STATUS_OK) {
+				fprintf(stderr, "XML error: %s\n",
+					XML_ErrorString(
+						XML_GetErrorCode(parser)));
+			}
+		} else {
+			remote_dir_exists[parent] = 0;
+		}
+	} else {
+		fprintf(stderr, "Unable to start request\n");
+	}
+
+	free(url);
+	free(out_data);
+	free(in_buffer.buffer);
+	curl_slist_free_all(dav_headers);
+}
+
 static int locking_available(void)
 {
 	struct active_request_slot *slot;
@@ -1027,9 +1260,12 @@ static int locking_available(void)
 	struct xml_ctx ctx;
 	int lock_flags = 0;
 
-	out_buffer.size = strlen(PROPFIND_REQUEST) + strlen(remote->url) - 2;
+	out_buffer.size =
+		strlen(PROPFIND_SUPPORTEDLOCK_REQUEST) +
+		strlen(remote->url) - 2;
 	out_data = xmalloc(out_buffer.size + 1);
-	snprintf(out_data, out_buffer.size + 1, PROPFIND_REQUEST, remote->url);
+	snprintf(out_data, out_buffer.size + 1,
+		 PROPFIND_SUPPORTEDLOCK_REQUEST, remote->url);
 	out_buffer.posn = 0;
 	out_buffer.buffer = out_data;
 
@@ -1085,85 +1321,99 @@ static int locking_available(void)
 	return lock_flags;
 }
 
-static int is_ancestor(unsigned char *sha1, struct commit *commit)
+static struct object_list **process_blob(struct blob *blob,
+					 struct object_list **p,
+					 struct name_path *path,
+					 const char *name)
 {
-	struct commit_list *parents;
+	struct object *obj = &blob->object;
 
-	if (parse_commit(commit))
-		return 0;
-	parents = commit->parents;
-	for (; parents; parents = parents->next) {
-		if (!memcmp(sha1, parents->item->object.sha1, 20)) {
-			return 1;
-		} else if (parents->item->object.type == commit_type) {
-			if (is_ancestor(
-				    sha1,
-				    (struct commit *)&parents->item->object
-				    ))
-				return 1;
-		}
+	obj->flags |= LOCAL;
+
+	if (obj->flags & (UNINTERESTING | SEEN))
+		return p;
+
+	obj->flags |= SEEN;
+	return add_object(obj, p, path, name);
+}
+
+static struct object_list **process_tree(struct tree *tree,
+					 struct object_list **p,
+					 struct name_path *path,
+					 const char *name)
+{
+	struct object *obj = &tree->object;
+	struct tree_entry_list *entry;
+	struct name_path me;
+
+	obj->flags |= LOCAL;
+
+	if (obj->flags & (UNINTERESTING | SEEN))
+		return p;
+	if (parse_tree(tree) < 0)
+		die("bad tree object %s", sha1_to_hex(obj->sha1));
+
+	obj->flags |= SEEN;
+	p = add_object(obj, p, NULL, name);
+	me.up = path;
+	me.elem = name;
+	me.elem_len = strlen(name);
+	entry = tree->entries;
+	tree->entries = NULL;
+	while (entry) {
+		struct tree_entry_list *next = entry->next;
+		if (entry->directory)
+			p = process_tree(entry->item.tree, p, &me, entry->name);
+		else
+			p = process_blob(entry->item.blob, p, &me, entry->name);
+		free(entry);
+		entry = next;
 	}
-	return 0;
+	return p;
 }
 
-static void get_delta(unsigned char *sha1, struct object *obj,
-		      struct active_lock *lock)
+static void get_delta(struct rev_info *revs, struct remote_lock *lock)
 {
 	struct commit *commit;
-	struct commit_list *parents;
-	struct tree *tree;
-	struct tree_entry_list *entry;
+	struct object_list **p = &objects, *pending;
 
-	if (sha1 && !memcmp(sha1, obj->sha1, 20))
-		return;
+	while ((commit = get_revision(revs)) != NULL) {
+		p = process_tree(commit->tree, p, NULL, "");
+		commit->object.flags |= LOCAL;
+		if (!(commit->object.flags & UNINTERESTING))
+			add_request(&commit->object, lock);
+	}
 
-	if (aborted)
-		return;
+	for (pending = revs->pending_objects; pending; pending = pending->next) {
+		struct object *obj = pending->item;
+		const char *name = pending->name;
 
-	if (obj->type == commit_type) {
-		if (push_verbosely)
-			fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
-		add_request(obj->sha1, lock);
-		commit = (struct commit *)obj;
-		if (parse_commit(commit)) {
-			fprintf(stderr, "Error parsing commit %s\n",
-				sha1_to_hex(obj->sha1));
-			aborted = 1;
-			return;
+		if (obj->flags & (UNINTERESTING | SEEN))
+			continue;
+		if (obj->type == tag_type) {
+			obj->flags |= SEEN;
+			p = add_object(obj, p, NULL, name);
+			continue;
 		}
-		parents = commit->parents;
-		for (; parents; parents = parents->next)
-			if (sha1 == NULL ||
-			    memcmp(sha1, parents->item->object.sha1, 20))
-				get_delta(sha1, &parents->item->object,
-					  lock);
-		get_delta(sha1, &commit->tree->object, lock);
-	} else if (obj->type == tree_type) {
-		if (push_verbosely)
-			fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
-		add_request(obj->sha1, lock);
-		tree = (struct tree *)obj;
-		if (parse_tree(tree)) {
-			fprintf(stderr, "Error parsing tree %s\n",
-				sha1_to_hex(obj->sha1));
-			aborted = 1;
-			return;
+		if (obj->type == tree_type) {
+			p = process_tree((struct tree *)obj, p, NULL, name);
+			continue;
 		}
-		entry = tree->entries;
-		tree->entries = NULL;
-		while (entry) {
-			struct tree_entry_list *next = entry->next;
-			get_delta(sha1, entry->item.any, lock);
-			free(entry->name);
-			free(entry);
-			entry = next;
+		if (obj->type == blob_type) {
+			p = process_blob((struct blob *)obj, p, NULL, name);
+			continue;
 		}
-	} else if (obj->type == blob_type || obj->type == tag_type) {
-		add_request(obj->sha1, lock);
+		die("unknown pending object %s (%s)", sha1_to_hex(obj->sha1), name);
+	}
+
+	while (objects) {
+		if (!(objects->item->flags & UNINTERESTING))
+			add_request(objects->item, lock);
+		objects = objects->next;
 	}
 }
 
-static int update_remote(unsigned char *sha1, struct active_lock *lock)
+static int update_remote(unsigned char *sha1, struct remote_lock *lock)
 {
 	struct active_request_slot *slot;
 	char *out_data;
@@ -1218,22 +1468,146 @@ static int update_remote(unsigned char *sha1, struct active_lock *lock)
 	return 1;
 }
 
+static struct ref *local_refs, **local_tail;
+static struct ref *remote_refs, **remote_tail;
+
+static int one_local_ref(const char *refname, const unsigned char *sha1)
+{
+	struct ref *ref;
+	int len = strlen(refname) + 1;
+	ref = xcalloc(1, sizeof(*ref) + len);
+	memcpy(ref->new_sha1, sha1, 20);
+	memcpy(ref->name, refname, len);
+	*local_tail = ref;
+	local_tail = &ref->next;
+	return 0;
+}
+
+static void one_remote_ref(char *refname)
+{
+	struct ref *ref;
+	unsigned char remote_sha1[20];
+
+	if (fetch_ref(refname, remote_sha1) != 0) {
+		fprintf(stderr,
+			"Unable to fetch ref %s from %s\n",
+			refname, remote->url);
+		return;
+	}
+
+	int len = strlen(refname) + 1;
+	ref = xcalloc(1, sizeof(*ref) + len);
+	memcpy(ref->old_sha1, remote_sha1, 20);
+	memcpy(ref->name, refname, len);
+	*remote_tail = ref;
+	remote_tail = &ref->next;
+}
+
+static void get_local_heads(void)
+{
+	local_tail = &local_refs;
+	for_each_ref(one_local_ref);
+}
+
+static void get_dav_remote_heads(void)
+{
+	remote_tail = &remote_refs;
+	crawl_remote_refs("refs/");
+}
+
+static int is_zero_sha1(const unsigned char *sha1)
+{
+	int i;
+
+	for (i = 0; i < 20; i++) {
+		if (*sha1++)
+			return 0;
+	}
+	return 1;
+}
+
+static void unmark_and_free(struct commit_list *list, unsigned int mark)
+{
+	while (list) {
+		struct commit_list *temp = list;
+		temp->item->object.flags &= ~mark;
+		list = temp->next;
+		free(temp);
+	}
+}
+
+static int ref_newer(const unsigned char *new_sha1,
+		     const unsigned char *old_sha1)
+{
+	struct object *o;
+	struct commit *old, *new;
+	struct commit_list *list, *used;
+	int found = 0;
+
+	/* Both new and old must be commit-ish and new is descendant of
+	 * old.  Otherwise we require --force.
+	 */
+	o = deref_tag(parse_object(old_sha1), NULL, 0);
+	if (!o || o->type != commit_type)
+		return 0;
+	old = (struct commit *) o;
+
+	o = deref_tag(parse_object(new_sha1), NULL, 0);
+	if (!o || o->type != commit_type)
+		return 0;
+	new = (struct commit *) o;
+
+	if (parse_commit(new) < 0)
+		return 0;
+
+	used = list = NULL;
+	commit_list_insert(new, &list);
+	while (list) {
+		new = pop_most_recent_commit(&list, TMP_MARK);
+		commit_list_insert(new, &used);
+		if (new == old) {
+			found = 1;
+			break;
+		}
+	}
+	unmark_and_free(list, TMP_MARK);
+	unmark_and_free(used, TMP_MARK);
+	return found;
+}
+
+static void mark_edge_parents_uninteresting(struct commit *commit)
+{
+	struct commit_list *parents;
+
+	for (parents = commit->parents; parents; parents = parents->next) {
+		struct commit *parent = parents->item;
+		if (!(parent->object.flags & UNINTERESTING))
+			continue;
+		mark_tree_uninteresting(parent->tree);
+	}
+}
+
+static void mark_edges_uninteresting(struct commit_list *list)
+{
+	for ( ; list; list = list->next) {
+		struct commit *commit = list->item;
+
+		if (commit->object.flags & UNINTERESTING) {
+			mark_tree_uninteresting(commit->tree);
+			continue;
+		}
+		mark_edge_parents_uninteresting(commit);
+	}
+}
+
 int main(int argc, char **argv)
 {
 	struct transfer_request *request;
 	struct transfer_request *next_request;
 	int nr_refspec = 0;
 	char **refspec = NULL;
-	int do_remote_update;
-	int new_branch;
-	int force_this;
-	char *local_ref;
-	unsigned char local_sha1[20];
-	struct object *local_object = NULL;
-	char *remote_ref = NULL;
-	unsigned char remote_sha1[20];
-	struct active_lock *remote_lock;
-	char *remote_path = NULL;
+	struct remote_lock *ref_lock;
+	struct rev_info revs;
 	int rc = 0;
 	int i;
 
@@ -1242,6 +1616,7 @@ int main(int argc, char **argv)
 
 	remote = xmalloc(sizeof(*remote));
 	remote->url = NULL;
+	remote->path_len = 0;
 	remote->packs = NULL;
 
 	argv++;
@@ -1249,7 +1624,7 @@ int main(int argc, char **argv)
 		char *arg = *argv;
 
 		if (*arg == '-') {
-			if (!strcmp(arg, "--complete")) {
+			if (!strcmp(arg, "--all")) {
 				push_all = 1;
 				continue;
 			}
@@ -1265,6 +1640,12 @@ int main(int argc, char **argv)
 		}
 		if (!remote->url) {
 			remote->url = arg;
+			char *path = strstr(arg, "//");
+			if (path) {
+				path = index(path+2, '/');
+				if (path)
+					remote->path_len = strlen(path);
+			}
 			continue;
 		}
 		refspec = argv;
@@ -1275,7 +1656,7 @@ int main(int argc, char **argv)
 	if (!remote->url)
 		usage(http_push_usage);
 
-	memset(remote_dir_exists, 0, 256);
+	memset(remote_dir_exists, -1, 256);
 
 	http_init();
 
@@ -1293,92 +1674,113 @@ int main(int argc, char **argv)
 		goto cleanup;
 	}
 
-	/* Process each refspec */
-	for (i = 0; i < nr_refspec; i++) {
-		char *ep;
-		force_this = 0;
-		do_remote_update = 0;
-		new_branch = 0;
-		local_ref = refspec[i];
-		if (*local_ref == '+') {
-			force_this = 1;
-			local_ref++;
+	/* Get a list of all local and remote heads to validate refspecs */
+	get_local_heads();
+	fprintf(stderr, "Fetching remote heads...\n");
+	get_dav_remote_heads();
+
+	/* match them up */
+	if (!remote_tail)
+		remote_tail = &remote_refs;
+	if (match_refs(local_refs, remote_refs, &remote_tail,
+		       nr_refspec, refspec, push_all))
+		return -1;
+	if (!remote_refs) {
+		fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
+		return 0;
+	}
+
+	int ret = 0;
+	int new_refs = 0;
+	struct ref *ref;
+	for (ref = remote_refs; ref; ref = ref->next) {
+		char old_hex[60], *new_hex;
+		if (!ref->peer_ref)
+			continue;
+		if (!memcmp(ref->old_sha1, ref->peer_ref->new_sha1, 20)) {
+			if (push_verbosely || 1)
+				fprintf(stderr, "'%s': up-to-date\n", ref->name);
+			continue;
+		}
+
+		if (!force_all &&
+		    !is_zero_sha1(ref->old_sha1) &&
+		    !ref->force) {
+			if (!has_sha1_file(ref->old_sha1) ||
+			    !ref_newer(ref->peer_ref->new_sha1,
+				       ref->old_sha1)) {
+				/* We do not have the remote ref, or
+				 * we know that the remote ref is not
+				 * an ancestor of what we are trying to
+				 * push.  Either way this can be losing
+				 * commits at the remote end and likely
+				 * we were not up to date to begin with.
+				 */
+				error("remote '%s' is not a strict "
+				      "subset of local ref '%s'. "
+				      "maybe you are not up-to-date and "
+				      "need to pull first?",
+				      ref->name,
+				      ref->peer_ref->name);
+				ret = -2;
+				continue;
+			}
 		}
-		ep = strchr(local_ref, ':');
-		if (ep) {
-			remote_ref = ep + 1;
-			*ep = 0;
+		memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
+		if (is_zero_sha1(ref->new_sha1)) {
+			error("cannot happen anymore");
+			ret = -3;
+			continue;
 		}
-		else
-			remote_ref = local_ref;
+		new_refs++;
+		strcpy(old_hex, sha1_to_hex(ref->old_sha1));
+		new_hex = sha1_to_hex(ref->new_sha1);
+
+		fprintf(stderr, "updating '%s'", ref->name);
+		if (strcmp(ref->name, ref->peer_ref->name))
+			fprintf(stderr, " using '%s'", ref->peer_ref->name);
+		fprintf(stderr, "\n  from %s\n  to   %s\n", old_hex, new_hex);
+
 
 		/* Lock remote branch ref */
-		if (remote_path)
-			free(remote_path);
-		remote_path = xmalloc(strlen(remote_ref) + 12);
-		sprintf(remote_path, "refs/heads/%s", remote_ref);
-		remote_lock = lock_remote(remote_path, LOCK_TIME);
-		if (remote_lock == NULL) {
+		ref_lock = lock_remote(ref->name, LOCK_TIME);
+		if (ref_lock == NULL) {
 			fprintf(stderr, "Unable to lock remote branch %s\n",
-				remote_ref);
+				ref->name);
 			rc = 1;
 			continue;
 		}
 
-		/* Resolve local and remote refs */
-		if (fetch_ref(remote_ref, remote_sha1) != 0) {
-			fprintf(stderr,
-				"Remote branch %s does not exist on %s\n",
-				remote_ref, remote->url);
-			new_branch = 1;
-		}
-		if (get_sha1(local_ref, local_sha1) != 0) {
-			fprintf(stderr, "Error resolving local branch %s\n",
-				local_ref);
-			rc = 1;
-			goto unlock;
+		/* Set up revision info for this refspec */
+		const char *commit_argv[3];
+		int commit_argc = 2;
+		char *new_sha1_hex = strdup(sha1_to_hex(ref->new_sha1));
+		char *old_sha1_hex = NULL;
+		commit_argv[1] = new_sha1_hex;
+		if (!push_all && !is_zero_sha1(ref->old_sha1)) {
+			old_sha1_hex = xmalloc(42);
+			sprintf(old_sha1_hex, "^%s",
+				sha1_to_hex(ref->old_sha1));
+			commit_argv[2] = old_sha1_hex;
+			commit_argc++;
 		}
-	
-		/* Find relationship between local and remote */
-		local_object = parse_object(local_sha1);
-		if (!local_object) {
-			fprintf(stderr, "Unable to parse local object %s\n",
-				sha1_to_hex(local_sha1));
-			rc = 1;
-			goto unlock;
-		} else if (new_branch) {
-			do_remote_update = 1;
-		} else {
-			if (!memcmp(local_sha1, remote_sha1, 20)) {
-				fprintf(stderr,
-					"* %s: same as branch '%s' of %s\n",
-					local_ref, remote_ref, remote->url);
-			} else if (is_ancestor(remote_sha1,
-					       (struct commit *)local_object)) {
-				fprintf(stderr,
-					"Remote %s will fast-forward to local %s\n",
-					remote_ref, local_ref);
-				do_remote_update = 1;
-			} else if (force_all || force_this) {
-				fprintf(stderr,
-					"* %s on %s does not fast forward to local branch '%s', overwriting\n",
-					remote_ref, remote->url, local_ref);
-				do_remote_update = 1;
-			} else {
-				fprintf(stderr,
-					"* %s on %s does not fast forward to local branch '%s'\n",
-					remote_ref, remote->url, local_ref);
-				rc = 1;
-				goto unlock;
-			}
+		revs.commits = NULL;
+		setup_revisions(commit_argc, commit_argv, &revs, NULL);
+		revs.tag_objects = 1;
+		revs.tree_objects = 1;
+		revs.blob_objects = 1;
+		free(new_sha1_hex);
+		if (old_sha1_hex) {
+			free(old_sha1_hex);
+			commit_argv[1] = NULL;
 		}
 
-		/* Generate and check list of required objects */
+		/* Generate a list of objects that need to be pushed */
 		pushing = 0;
-		if (do_remote_update || push_all)
-			fetch_indices();
-		get_delta(push_all ? NULL : remote_sha1,
-			  local_object, remote_lock);
+		prepare_revision_walk(&revs);
+		mark_edges_uninteresting(revs.commits);
+		fetch_indices();
+		get_delta(&revs, ref_lock);
 		finish_all_active_slots();
 
 		/* Push missing objects to remote, this would be a
@@ -1388,25 +1790,15 @@ int main(int argc, char **argv)
 		finish_all_active_slots();
 
 		/* Update the remote branch if all went well */
-		if (do_remote_update) {
-			if (!aborted && update_remote(local_sha1,
-						      remote_lock)) {
-				fprintf(stderr, "%s remote branch %s\n",
-					new_branch ? "Created" : "Updated",
-					remote_ref);
-			} else {
-				fprintf(stderr,
-					"Unable to %s remote branch %s\n",
-					new_branch ? "create" : "update",
-					remote_ref);
-				rc = 1;
-				goto unlock;
-			}
+		if (aborted || !update_remote(ref->new_sha1, ref_lock)) {
+			rc = 1;
+			goto unlock;
 		}
 
 	unlock:
-		unlock_remote(remote_lock);
-		free(remote_path);
+		if (!rc)
+			fprintf(stderr, "    done\n");
+		unlock_remote(ref_lock);
 	}
 
  cleanup:
diff --git a/repo-config.c b/repo-config.c
index 9cf65193f9..c5ebb7668a 100644
--- a/repo-config.c
+++ b/repo-config.c
@@ -14,6 +14,9 @@ static enum { T_RAW, T_INT, T_BOOL } type = T_RAW;
 
 static int show_config(const char* key_, const char* value_)
 {
+	if (value_ == NULL)
+		value_ = "";
+
 	if (!strcmp(key_, key) &&
 			(regexp == NULL ||
 			 (do_not_match ^
@@ -35,7 +38,7 @@ static int show_config(const char* key_, const char* value_)
 			sprintf(value, "%s", git_config_bool(key_, value_)
 					     ? "true" : "false");
 		} else {
-			value = strdup(value_ ? value_ : "");
+			value = strdup(value_);
 		}
 		seen++;
 	}
diff --git a/t/t1300-repo-config.sh b/t/t1300-repo-config.sh
index 207dd3de64..ab4dd5c4ce 100755
--- a/t/t1300-repo-config.sh
+++ b/t/t1300-repo-config.sh
@@ -247,5 +247,13 @@ EOF
 
 test_expect_success 'hierarchical section value' 'cmp .git/config expect'
 
+cat > .git/config << EOF
+[novalue]
+	variable
+EOF
+
+test_expect_success 'get variable with no value' \
+	'git-repo-config --get novalue.variable ^$'
+
 test_done