Add support for pushing to a remote repository using HTTP/DAV

Add support for pushing to a remote repository using HTTP/DAV

Signed-off-by: Nick Hengeveld <nickh@reactrix.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/Documentation/git-http-push.txt b/Documentation/git-http-push.txt
new file mode 100644 (file)
index 0000000..c7066d6
--- /dev/null
+++ b/Documentation/git-http-push.txt
@@ -0,0 +1,89 @@
+git-http-push(1)
+================
+
+NAME
+----
+git-http-push - Push missing objects using HTTP/DAV.
+
+
+SYNOPSIS
+--------
+'git-http-push' [--complete] [--force] [--verbose] <url> <ref> [<ref>...]
+
+DESCRIPTION
+-----------
+Sends missing objects to remote repository, and updates the
+remote branch.
+
+
+OPTIONS
+-------
+--complete::
+       Do not assume that the remote repository is complete in its
+       current state, and verify all objects in the entire local
+       ref's history exist in the remote repository.
+
+--force::
+       Usually, the command refuses to update a remote ref that
+       is not an ancestor of the local ref used to overwrite it.
+       This flag disables the check.  What this means is that
+       the remote repository can lose commits; use it with
+       care.
+
+--verbose::
+       Report the list of objects being walked locally and the
+       list of objects successfully sent to the remote repository.
+
+<ref>...:
+       The remote refs to update.
+
+
+Specifying the Refs
+-------------------
+
+A '<ref>' specification can be either a single pattern, or a pair
+of such patterns separated by a colon ":" (this means that a ref name
+cannot have a colon in it).  A single pattern '<name>' is just a 
+shorthand for '<name>:<name>'.
+
+Each pattern pair consists of the source side (before the colon)
+and the destination side (after the colon).  The ref to be
+pushed is determined by finding a match that matches the source
+side, and where it is pushed is determined by using the
+destination side.
+
+ - It is an error if <src> does not match exactly one of the
+   local refs.
+
+ - If <dst> does not match any remote ref, either
+
+   * it has to start with "refs/"; <dst> is used as the
+     destination literally in this case.
+
+   * <src> == <dst> and the ref that matched the <src> must not
+     exist in the set of remote refs; the ref matched <src>
+     locally is used as the name of the destination.
+
+Without '--force', the <src> ref is stored at the remote only if
+<dst> does not exist, or <dst> is a proper subset (i.e. an
+ancestor) of <src>.  This check, known as "fast forward check",
+is performed in order to avoid accidentally overwriting the
+remote ref and lose other peoples' commits from there.
+
+With '--force', the fast forward check is disabled for all refs.
+
+Optionally, a <ref> parameter can be prefixed with a plus '+' sign
+to disable the fast-forward check only on that ref.
+
+
+Author
+------
+Written by Nick Hengeveld <nickh@reactrix.com>
+
+Documentation
+--------------
+Documentation by Nick Hengeveld
+
+GIT
+---
+Part of the gitlink:git[7] suite

diff --git a/Makefile b/Makefile
index 6c01dc29537a7926f1e57c4fe115334c4cdc036c..f4fe31e8acfeb1bc460d1cef8a8f247745897b96 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -6,12 +6,16 @@
 # Define NO_OPENSSL environment variable if you do not have OpenSSL. You will
 # miss out git-rev-list --merge-order. This also implies MOZILLA_SHA1.
 #
-# Define NO_CURL if you do not have curl installed.  git-http-pull is not
-# built, and you cannot use http:// and https:// transports.
+# Define NO_CURL if you do not have curl installed.  git-http-pull and
+# git-http-push are not built, and you cannot use http:// and https://
+# transports.
 #
 # Define CURLDIR=/foo/bar if your curl header and library files are in
 # /foo/bar/include and /foo/bar/lib directories.
 #
+# Define NO_EXPAT if you do not have expat installed.  git-http-push is
+# not built, and you cannot push using http:// and https:// transports.
+#
 # Define NO_STRCASESTR if you don't have strcasestr.
 #
 # Define PPC_SHA1 environment variable when running make to make use of
@@ -223,6 +227,10 @@ ifndef NO_CURL
                CURL_LIBCURL = -lcurl
        endif
        PROGRAMS += git-http-fetch$X
+       ifndef NO_EXPAT
+               EXPAT_LIBEXPAT = -lexpat
+               PROGRAMS += git-http-push$X
+       endif
 endif
 
 ifndef SHELL_PATH
@@ -375,6 +383,7 @@ git-ssh-pull$X: rsh.o fetch.o
 git-ssh-push$X: rsh.o
 
 git-http-fetch$X: LIBS += $(CURL_LIBCURL)
+git-http-push$X: LIBS += $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
 git-rev-list$X: LIBS += $(OPENSSL_LIBSSL)
 
 init-db.o: init-db.c

diff --git a/http-push.c b/http-push.c
new file mode 100644 (file)
index 0000000..e85f1c1
--- /dev/null
+++ b/http-push.c
@@ -0,0 +1,1625 @@
+#include "cache.h"
+#include "commit.h"
+#include "pack.h"
+#include "fetch.h"
+#include "tag.h"
+#include "blob.h"
+
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include "expat.h"
+
+static const char http_push_usage[] =
+"git-http-push [--complete] [--force] [--verbose] <url> <ref> [<ref>...]\n";
+
+#if LIBCURL_VERSION_NUM >= 0x070908
+#define USE_CURL_MULTI
+#define DEFAULT_MAX_REQUESTS 5
+#endif
+
+#if LIBCURL_VERSION_NUM < 0x070704
+#define curl_global_cleanup() do { /* nothing */ } while(0)
+#endif
+#if LIBCURL_VERSION_NUM < 0x070800
+#define curl_global_init(a) do { /* nothing */ } while(0)
+#endif
+
+#if LIBCURL_VERSION_NUM < 0x070c04
+#define NO_CURL_EASY_DUPHANDLE
+#endif
+
+#define RANGE_HEADER_SIZE 30
+
+/* DAV method names and request body templates */
+#define DAV_LOCK "LOCK"
+#define DAV_MKCOL "MKCOL"
+#define DAV_MOVE "MOVE"
+#define DAV_PROPFIND "PROPFIND"
+#define DAV_PUT "PUT"
+#define DAV_UNLOCK "UNLOCK"
+#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 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>"
+
+static int active_requests = 0;
+static int data_received;
+static int pushing = 0;
+static int aborted = 0;
+
+#ifdef USE_CURL_MULTI
+static int max_requests = -1;
+static CURLM *curlm;
+#endif
+#ifndef NO_CURL_EASY_DUPHANDLE
+static CURL *curl_default;
+#endif
+static struct curl_slist *no_pragma_header;
+static struct curl_slist *default_headers;
+static char curl_errorstr[CURL_ERROR_SIZE];
+static char *lock_token = NULL;
+
+static int push_verbosely = 0;
+static int push_all = 0;
+static int force_all = 0;
+
+struct buffer
+{
+        size_t posn;
+        size_t size;
+        void *buffer;
+};
+
+struct repo
+{
+       char *url;
+       struct packed_git *packs;
+};
+
+static struct repo *remote = NULL;
+
+enum transfer_state {
+       NEED_CHECK,
+       RUN_HEAD,
+       NEED_PUSH,
+       RUN_MKCOL,
+       RUN_PUT,
+       RUN_MOVE,
+       ABORTED,
+       COMPLETE,
+};
+
+struct transfer_request
+{
+       unsigned char sha1[20];
+       char *url;
+       char *dest;
+       char *lock_token;
+       struct curl_slist *headers;
+       struct buffer buffer;
+       char filename[PATH_MAX];
+       char tmpfile[PATH_MAX];
+       enum transfer_state state;
+       CURLcode curl_result;
+       char errorstr[CURL_ERROR_SIZE];
+       long http_code;
+       unsigned char real_sha1[20];
+       SHA_CTX c;
+       z_stream stream;
+       int zret;
+       int rename;
+       struct active_request_slot *slot;
+       struct transfer_request *next;
+};
+
+struct active_request_slot
+{
+       CURL *curl;
+       FILE *local;
+       int in_use;
+       int done;
+       CURLcode curl_result;
+       long http_code;
+       struct active_request_slot *next;
+};
+
+static struct transfer_request *request_queue_head = NULL;
+static struct active_request_slot *active_queue_head = NULL;
+
+static int curl_ssl_verify = -1;
+static char *ssl_cert = NULL;
+#if LIBCURL_VERSION_NUM >= 0x070902
+static char *ssl_key = NULL;
+#endif
+#if LIBCURL_VERSION_NUM >= 0x070908
+static char *ssl_capath = NULL;
+#endif
+static char *ssl_cainfo = NULL;
+static long curl_low_speed_limit = -1;
+static long curl_low_speed_time = -1;
+
+struct lockprop
+{
+       int supported_lock;
+       int lock_entry;
+       int lock_scope;
+       int lock_type;
+       int lock_exclusive;
+       int lock_exclusive_write;
+};
+
+static int http_options(const char *var, const char *value)
+{
+       if (!strcmp("http.sslverify", var)) {
+               if (curl_ssl_verify == -1) {
+                       curl_ssl_verify = git_config_bool(var, value);
+               }
+               return 0;
+       }
+
+       if (!strcmp("http.sslcert", var)) {
+               if (ssl_cert == NULL) {
+                       ssl_cert = xmalloc(strlen(value)+1);
+                       strcpy(ssl_cert, value);
+               }
+               return 0;
+       }
+#if LIBCURL_VERSION_NUM >= 0x070902
+       if (!strcmp("http.sslkey", var)) {
+               if (ssl_key == NULL) {
+                       ssl_key = xmalloc(strlen(value)+1);
+                       strcpy(ssl_key, value);
+               }
+               return 0;
+       }
+#endif
+#if LIBCURL_VERSION_NUM >= 0x070908
+       if (!strcmp("http.sslcapath", var)) {
+               if (ssl_capath == NULL) {
+                       ssl_capath = xmalloc(strlen(value)+1);
+                       strcpy(ssl_capath, value);
+               }
+               return 0;
+       }
+#endif
+       if (!strcmp("http.sslcainfo", var)) {
+               if (ssl_cainfo == NULL) {
+                       ssl_cainfo = xmalloc(strlen(value)+1);
+                       strcpy(ssl_cainfo, value);
+               }
+               return 0;
+       }
+
+#ifdef USE_CURL_MULTI  
+       if (!strcmp("http.maxrequests", var)) {
+               if (max_requests == -1)
+                       max_requests = git_config_int(var, value);
+               return 0;
+       }
+#endif
+
+       if (!strcmp("http.lowspeedlimit", var)) {
+               if (curl_low_speed_limit == -1)
+                       curl_low_speed_limit = (long)git_config_int(var, value);
+               return 0;
+       }
+       if (!strcmp("http.lowspeedtime", var)) {
+               if (curl_low_speed_time == -1)
+                       curl_low_speed_time = (long)git_config_int(var, value);
+               return 0;
+       }
+
+       /* Fall back on the default ones */
+       return git_default_config(var, value);
+}
+
+static size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
+                          struct buffer *buffer)
+{
+       size_t size = eltsize * nmemb;
+       if (size > buffer->size - buffer->posn)
+               size = buffer->size - buffer->posn;
+       memcpy(ptr, buffer->buffer + buffer->posn, size);
+       buffer->posn += size;
+       return size;
+}
+
+static size_t fwrite_buffer_dynamic(const void *ptr, size_t eltsize,
+                                   size_t nmemb, struct buffer *buffer)
+{
+       size_t size = eltsize * nmemb;
+       if (size > buffer->size - buffer->posn) {
+               buffer->size = buffer->size * 3 / 2;
+               if (buffer->size < buffer->posn + size)
+                       buffer->size = buffer->posn + size;
+               buffer->buffer = xrealloc(buffer->buffer, buffer->size);
+       }
+       memcpy(buffer->buffer + buffer->posn, ptr, size);
+       buffer->posn += size;
+       data_received++;
+       return size;
+}
+
+static size_t fwrite_null(const void *ptr, size_t eltsize,
+                         size_t nmemb, struct buffer *buffer)
+{
+       data_received++;
+       return eltsize * nmemb;
+}
+
+#ifdef USE_CURL_MULTI
+static void process_curl_messages(void);
+static void process_request_queue(void);
+#endif
+
+static CURL* get_curl_handle(void)
+{
+       CURL* result = curl_easy_init();
+
+       curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, curl_ssl_verify);
+#if LIBCURL_VERSION_NUM >= 0x070907
+       curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
+#endif
+
+       if (ssl_cert != NULL)
+               curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
+#if LIBCURL_VERSION_NUM >= 0x070902
+       if (ssl_key != NULL)
+               curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
+#endif
+#if LIBCURL_VERSION_NUM >= 0x070908
+       if (ssl_capath != NULL)
+               curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
+#endif
+       if (ssl_cainfo != NULL)
+               curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
+       curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);
+
+       if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
+               curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
+                                curl_low_speed_limit);
+               curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
+                                curl_low_speed_time);
+       }
+
+       return result;
+}
+
+static struct active_request_slot *get_active_slot(void)
+{
+       struct active_request_slot *slot = active_queue_head;
+       struct active_request_slot *newslot;
+
+#ifdef USE_CURL_MULTI
+       int num_transfers;
+
+       /* Wait for a slot to open up if the queue is full */
+       while (active_requests >= max_requests) {
+               curl_multi_perform(curlm, &num_transfers);
+               if (num_transfers < active_requests) {
+                       process_curl_messages();
+               }
+       }
+#endif
+
+       while (slot != NULL && slot->in_use) {
+               slot = slot->next;
+       }
+       if (slot == NULL) {
+               newslot = xmalloc(sizeof(*newslot));
+               newslot->curl = NULL;
+               newslot->in_use = 0;
+               newslot->next = NULL;
+
+               slot = active_queue_head;
+               if (slot == NULL) {
+                       active_queue_head = newslot;
+               } else {
+                       while (slot->next != NULL) {
+                               slot = slot->next;
+                       }
+                       slot->next = newslot;
+               }
+               slot = newslot;
+       }
+
+       if (slot->curl == NULL) {
+#ifdef NO_CURL_EASY_DUPHANDLE
+               slot->curl = get_curl_handle();
+#else
+               slot->curl = curl_easy_duphandle(curl_default);
+#endif
+       }
+
+       active_requests++;
+       slot->in_use = 1;
+       slot->done = 0;
+       slot->local = NULL;
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, default_headers);
+       curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
+
+       return slot;
+}
+
+static int start_active_slot(struct active_request_slot *slot)
+{
+#ifdef USE_CURL_MULTI
+       CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
+
+       if (curlm_result != CURLM_OK &&
+           curlm_result != CURLM_CALL_MULTI_PERFORM) {
+               active_requests--;
+               slot->in_use = 0;
+               return 0;
+       }
+#endif
+       return 1;
+}
+
+static void run_active_slot(struct active_request_slot *slot)
+{
+#ifdef USE_CURL_MULTI
+       int num_transfers;
+       long last_pos = 0;
+       long current_pos;
+       fd_set readfds;
+       fd_set writefds;
+       fd_set excfds;
+       int max_fd;
+       struct timeval select_timeout;
+       CURLMcode curlm_result;
+
+       while (!slot->done) {
+               data_received = 0;
+               do {
+                       curlm_result = curl_multi_perform(curlm,
+                                                         &num_transfers);
+               } while (curlm_result == CURLM_CALL_MULTI_PERFORM);
+               if (num_transfers < active_requests) {
+                       process_curl_messages();
+                       process_request_queue();
+               }
+
+               if (!data_received && slot->local != NULL) {
+                       current_pos = ftell(slot->local);
+                       if (current_pos > last_pos)
+                               data_received++;
+                       last_pos = current_pos;
+               }
+
+               if (!slot->done && !data_received) {
+                       max_fd = 0;
+                       FD_ZERO(&readfds);
+                       FD_ZERO(&writefds);
+                       FD_ZERO(&excfds);
+                       select_timeout.tv_sec = 0;
+                       select_timeout.tv_usec = 50000;
+                       select(max_fd, &readfds, &writefds,
+                              &excfds, &select_timeout);
+               }
+       }
+#else
+       slot->curl_result = curl_easy_perform(slot->curl);
+       active_requests--;
+#endif
+}
+
+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();
+       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);
+       }
+}
+
+static void start_mkcol(struct transfer_request *request)
+{
+       char *hex = sha1_to_hex(request->sha1);
+       struct active_request_slot *slot;
+       char *posn;
+
+       request->url = xmalloc(strlen(remote->url) + 13);
+       strcpy(request->url, remote->url);
+       posn = request->url + strlen(remote->url);
+       strcpy(posn, "objects/");
+       posn += 8;
+       memcpy(posn, hex, 2);
+       posn += 2;
+       strcpy(posn, "/");
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
+       curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
+       curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, request->errorstr);
+       curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MKCOL);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
+
+       if (start_active_slot(slot)) {
+               request->slot = slot;
+               request->state = RUN_MKCOL;
+       } else {
+               request->state = ABORTED;
+               free(request->url);
+       }
+}
+
+static void start_put(struct transfer_request *request)
+{
+       char *hex = sha1_to_hex(request->sha1);
+       struct active_request_slot *slot;
+       char *posn;
+       char type[20];
+       char hdr[50];
+       void *unpacked;
+       unsigned long len;
+       int hdrlen;
+       ssize_t size;
+       z_stream stream;
+
+       unpacked = read_sha1_file(request->sha1, type, &len);
+       hdrlen = sprintf(hdr, "%s %lu", type, len) + 1;
+
+       /* Set it up */
+       memset(&stream, 0, sizeof(stream));
+       deflateInit(&stream, Z_BEST_COMPRESSION);
+       size = deflateBound(&stream, len + hdrlen);
+       request->buffer.buffer = xmalloc(size);
+
+       /* Compress it */
+       stream.next_out = request->buffer.buffer;
+       stream.avail_out = size;
+
+       /* First header.. */
+       stream.next_in = (void *)hdr;
+       stream.avail_in = hdrlen;
+       while (deflate(&stream, 0) == Z_OK)
+               /* nothing */;
+
+       /* Then the data itself.. */
+       stream.next_in = unpacked;
+       stream.avail_in = len;
+       while (deflate(&stream, Z_FINISH) == Z_OK)
+               /* nothing */;
+       deflateEnd(&stream);
+       free(unpacked);
+
+       request->buffer.size = stream.total_out;
+       request->buffer.posn = 0;
+
+       if (request->url != NULL)
+               free(request->url);
+       request->url = xmalloc(strlen(remote->url) + 
+                              strlen(request->lock_token) + 51);
+       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);
+       request->dest = xmalloc(strlen(request->url) + 14);
+       sprintf(request->dest, "Destination: %s", request->url);
+       posn += 38;
+       *(posn++) = '.';
+       strcpy(posn, request->lock_token);
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
+       curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
+       curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
+       curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
+       curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
+       curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
+       curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
+
+       if (start_active_slot(slot)) {
+               request->slot = slot;
+               request->state = RUN_PUT;
+       } else {
+               request->state = ABORTED;
+               free(request->url);
+       }
+}
+
+static void start_move(struct transfer_request *request)
+{
+       struct active_request_slot *slot;
+       struct curl_slist *dav_headers = NULL;
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1); /* undo PUT setup */
+       curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_MOVE);
+       dav_headers = curl_slist_append(dav_headers, request->dest);
+       dav_headers = curl_slist_append(dav_headers, "Overwrite: T");
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, request->url);
+
+       if (start_active_slot(slot)) {
+               request->slot = slot;
+               request->state = RUN_MOVE;
+       } else {
+               request->state = ABORTED;
+               free(request->url);
+       }
+}
+
+static void finish_request(struct transfer_request *request)
+{
+       request->curl_result =  request->slot->curl_result;
+       request->http_code = request->slot->http_code;
+       request->slot = NULL;
+       if (request->headers != NULL)
+               curl_slist_free_all(request->headers);
+       if (request->state == RUN_HEAD) {
+               if (request->http_code == 404) {
+                       request->state = NEED_PUSH;
+               } else if (request->curl_result == CURLE_OK) {
+                       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->curl_result == CURLE_OK ||
+                   request->http_code == 405) {
+                       start_put(request);
+               } else {
+                       fprintf(stderr, "MKCOL %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_PUT) {
+               if (request->curl_result == CURLE_OK) {
+                       start_move(request);
+               } else {
+                       fprintf(stderr, "PUT %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_MOVE) {
+               if (request->curl_result == CURLE_OK) {
+                       if (push_verbosely)
+                               fprintf(stderr,
+                                       "sent %s\n",
+                                       sha1_to_hex(request->sha1));
+                       request->state = COMPLETE;
+               } else {
+                       fprintf(stderr, "MOVE %s failed, aborting (%d/%ld)\n",
+                               sha1_to_hex(request->sha1),
+                               request->curl_result, request->http_code);
+                       request->state = ABORTED;
+                       aborted = 1;
+               }
+       }
+}
+
+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;
+       }
+
+       free(request->url);
+       free(request);
+}
+
+#ifdef USE_CURL_MULTI
+void process_curl_messages(void)
+{
+       int num_messages;
+       struct active_request_slot *slot;
+       struct transfer_request *request = NULL;
+       CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
+
+       while (curl_message != NULL) {
+               if (curl_message->msg == CURLMSG_DONE) {
+                       slot = active_queue_head;
+                       while (slot != NULL &&
+                              slot->curl != curl_message->easy_handle)
+                               slot = slot->next;
+                       if (slot != NULL) {
+                               curl_multi_remove_handle(curlm, slot->curl);
+                               active_requests--;
+                               slot->done = 1;
+                               slot->in_use = 0;
+                               slot->curl_result = curl_message->data.result;
+                               curl_easy_getinfo(slot->curl,
+                                                 CURLINFO_HTTP_CODE,
+                                                 &slot->http_code);
+                               request = request_queue_head;
+                               while (request != NULL &&
+                                      request->slot != slot)
+                                       request = request->next;
+                               if (request != NULL)
+                                       finish_request(request);
+                       } else {
+                               fprintf(stderr, "Received DONE message for unknown request!\n");
+                       }
+               } else {
+                       fprintf(stderr, "Unknown CURL message received: %d\n",
+                               (int)curl_message->msg);
+               }
+               curl_message = curl_multi_info_read(curlm, &num_messages);
+       }
+}
+
+void process_request_queue(void)
+{
+       struct transfer_request *request = request_queue_head;
+       struct active_request_slot *slot = active_queue_head;
+       int num_transfers;
+
+       if (aborted)
+               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) {
+                       start_mkcol(request);
+                       curl_multi_perform(curlm, &num_transfers);
+               }
+               request = request->next;
+       }
+
+       while (slot != NULL) {
+               if (!slot->in_use && slot->curl != NULL) {
+                       curl_easy_cleanup(slot->curl);
+                       slot->curl = NULL;
+               }
+               slot = slot->next;
+       }                               
+}
+#endif
+
+void process_waiting_requests(void)
+{
+       struct active_request_slot *slot = active_queue_head;
+
+       while (slot != NULL)
+               if (slot->in_use) {
+                       run_active_slot(slot);
+                       slot = active_queue_head;
+               } else {
+                       slot = slot->next;
+               }
+}
+
+void add_request(unsigned char *sha1, char *lock_token)
+{
+       struct transfer_request *request = request_queue_head;
+       struct transfer_request *tail;
+       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)
+               return;
+
+       request = xmalloc(sizeof(*request));
+       memcpy(request->sha1, sha1, 20);
+       request->url = NULL;
+       request->lock_token = lock_token;
+       request->headers = NULL;
+       request->state = NEED_CHECK;
+       request->next = NULL;
+
+       if (request_queue_head == NULL) {
+               request_queue_head = request;
+       } else {
+               tail = request_queue_head;
+               while (tail->next != NULL) {
+                       tail = tail->next;
+               }
+               tail->next = request;
+       }
+#ifdef USE_CURL_MULTI
+       process_request_queue();
+       process_curl_messages();
+#endif
+}
+
+static int fetch_index(unsigned char *sha1)
+{
+       char *hex = sha1_to_hex(sha1);
+       char *filename;
+       char *url;
+       char tmpfile[PATH_MAX];
+       long prev_posn = 0;
+       char range[RANGE_HEADER_SIZE];
+       struct curl_slist *range_header = NULL;
+
+       FILE *indexfile;
+       struct active_request_slot *slot;
+
+       if (has_pack_index(sha1))
+               return 0;
+
+       if (push_verbosely)
+               fprintf(stderr, "Getting index for pack %s\n", hex);
+       
+       url = xmalloc(strlen(remote->url) + 64);
+       sprintf(url, "%s/objects/pack/pack-%s.idx", remote->url, hex);
+       
+       filename = sha1_pack_index_name(sha1);
+       snprintf(tmpfile, sizeof(tmpfile), "%s.temp", filename);
+       indexfile = fopen(tmpfile, "a");
+       if (!indexfile)
+               return error("Unable to open local file %s for pack index",
+                            filename);
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_FILE, indexfile);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, no_pragma_header);
+       slot->local = indexfile;
+
+       /* If there is data present from a previous transfer attempt,
+          resume where it left off */
+       prev_posn = ftell(indexfile);
+       if (prev_posn>0) {
+               if (push_verbosely)
+                       fprintf(stderr,
+                               "Resuming fetch of index for pack %s at byte %ld\n",
+                               hex, prev_posn);
+               sprintf(range, "Range: bytes=%ld-", prev_posn);
+               range_header = curl_slist_append(range_header, range);
+               curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, range_header);
+       }
+
+       if (start_active_slot(slot)) {
+               run_active_slot(slot);
+               if (slot->curl_result != CURLE_OK) {
+                       free(url);
+                       fclose(indexfile);
+                       return error("Unable to get pack index %s\n%s", url,
+                                    curl_errorstr);
+               }
+       } else {
+               free(url);
+               return error("Unable to start request");
+       }
+
+       free(url);
+       fclose(indexfile);
+
+       return move_temp_to_file(tmpfile, filename);
+}
+
+static int setup_index(unsigned char *sha1)
+{
+       struct packed_git *new_pack;
+       if (has_pack_file(sha1))
+               return 0; // don't list this as something we can get
+
+       if (fetch_index(sha1))
+               return -1;
+
+       new_pack = parse_pack_index(sha1);
+       new_pack->next = remote->packs;
+       remote->packs = new_pack;
+       return 0;
+}
+
+static int fetch_indices()
+{
+       unsigned char sha1[20];
+       char *url;
+       struct buffer buffer;
+       char *data;
+       int i = 0;
+
+       struct active_request_slot *slot;
+
+       data = xmalloc(4096);
+       memset(data, 0, 4096);
+       buffer.size = 4096;
+       buffer.posn = 0;
+       buffer.buffer = data;
+
+       if (push_verbosely)
+               fprintf(stderr, "Getting pack list\n");
+       
+       url = xmalloc(strlen(remote->url) + 21);
+       sprintf(url, "%s/objects/info/packs", remote->url);
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
+                        fwrite_buffer_dynamic);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
+       if (start_active_slot(slot)) {
+               run_active_slot(slot);
+               if (slot->curl_result != CURLE_OK) {
+                       free(buffer.buffer);
+                       free(url);
+                       if (slot->http_code == 404)
+                               return 0;
+                       else
+                               return error("%s", curl_errorstr);
+               }
+       } else {
+               free(buffer.buffer);
+               free(url);
+               return error("Unable to start request");
+       }
+       free(url);
+
+       data = buffer.buffer;
+       while (i < buffer.posn) {
+               switch (data[i]) {
+               case 'P':
+                       i++;
+                       if (i + 52 < buffer.posn &&
+                           !strncmp(data + i, " pack-", 6) &&
+                           !strncmp(data + i + 46, ".pack\n", 6)) {
+                               get_sha1_hex(data + i + 6, sha1);
+                               setup_index(sha1);
+                               i += 51;
+                               break;
+                       }
+               default:
+                       while (data[i] != '\n')
+                               i++;
+               }
+               i++;
+       }
+
+       free(buffer.buffer);
+       return 0;
+}
+
+static inline int needs_quote(int ch)
+{
+       switch (ch) {
+       case '/': case '-': case '.':
+       case 'A'...'Z': case 'a'...'z': case '0'...'9':
+               return 0;
+       default:
+               return 1;
+       }
+}
+
+static inline int hex(int v)
+{
+       if (v < 10) return '0' + v;
+       else return 'A' + v - 10;
+}
+
+static char *quote_ref_url(const char *base, const char *ref)
+{
+       const char *cp;
+       char *dp, *qref;
+       int len, baselen, ch;
+
+       baselen = strlen(base);
+       len = baselen + 12; /* "refs/heads/" + NUL */
+       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++) {
+               if (needs_quote(ch)) {
+                       *dp++ = '%';
+                       *dp++ = hex((ch >> 4) & 0xF);
+                       *dp++ = hex(ch & 0xF);
+               }
+               else
+                       *dp++ = ch;
+       }
+       *dp = 0;
+
+       return qref;
+}
+
+int fetch_ref(char *ref, unsigned char *sha1)
+{
+        char *url;
+        char hex[42];
+        struct buffer buffer;
+       char *base = remote->url;
+       struct active_request_slot *slot;
+        buffer.size = 41;
+        buffer.posn = 0;
+        buffer.buffer = hex;
+        hex[41] = '\0';
+        
+       url = quote_ref_url(base, ref);
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION,
+                        fwrite_buffer_dynamic);
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+       if (start_active_slot(slot)) {
+               run_active_slot(slot);
+               if (slot->curl_result != CURLE_OK)
+                       return error("Couldn't get %s for %s\n%s",
+                                    url, ref, curl_errorstr);
+       } else {
+               return error("Unable to start request");
+       }
+
+        hex[40] = '\0';
+        get_sha1_hex(hex, sha1);
+        return 0;
+}
+
+static void
+start_lockprop_element(void *userData, const char *name, const char **atts)
+{
+       struct lockprop *prop = (struct lockprop *)userData;
+
+       if (prop->lock_type && !strcmp(name, "D:write")) {
+               if (prop->lock_exclusive) {
+                       prop->lock_exclusive_write = 1;
+               }
+       } else if (prop->lock_scope && !strcmp(name, "D:exclusive")) {
+               prop->lock_exclusive = 1;
+       } else if (prop->lock_entry) {
+               if (!strcmp(name, "D:lockscope")) {
+                       prop->lock_scope = 1;
+               } else if (!strcmp(name, "D:locktype")) {
+                       prop->lock_type = 1;
+               }
+       } else if (prop->supported_lock) {
+               if (!strcmp(name, "D:lockentry")) {
+                       prop->lock_entry = 1;
+               }
+       } else if (!strcmp(name, "D:supportedlock")) {
+               prop->supported_lock = 1;
+       }
+}
+
+static void
+end_lockprop_element(void *userData, const char *name)
+{
+       struct lockprop *prop = (struct lockprop *)userData;
+
+       if (!strcmp(name, "D:lockentry")) {
+               prop->lock_entry = 0;
+               prop->lock_scope = 0;
+               prop->lock_type = 0;
+               prop->lock_exclusive = 0;
+       } else if (!strcmp(name, "D:supportedlock")) {
+               prop->supported_lock = 0;
+       }
+}
+
+size_t process_lock_header( void *ptr, size_t size, size_t nmemb, void *stream)
+{
+       size_t header_size = size*nmemb;
+       char *start;
+       char *end;
+
+       if (!strncmp(ptr, "Lock-Token: <opaquelocktoken:", 29)) {
+               start = ptr + 29;
+               for (end = ptr + header_size;
+                    *(end - 1) == '\r' || *(end - 1) == '\n' || *(end - 1) == '>';
+                    end--) {}
+               if (end > start) {
+                       lock_token = xmalloc(end - start + 1);
+                       memcpy(lock_token, start, end - start);
+                       lock_token[end - start] = 0;
+               }
+       }
+
+       return header_size;
+}
+
+char *lock_remote(char *file, int timeout)
+{
+       struct active_request_slot *slot;
+       struct buffer out_buffer;
+       char *out_data;
+       char *url;
+       char timeout_header[25];
+       struct curl_slist *dav_headers = NULL;
+
+       if (lock_token != NULL)
+               free(lock_token);
+
+       out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
+       out_data = xmalloc(out_buffer.size + 1);
+       snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
+       out_buffer.posn = 0;
+       out_buffer.buffer = out_data;
+
+       sprintf(timeout_header, "Timeout: Second-%d", timeout);
+       url = xmalloc(strlen(remote->url) + strlen(file) + 1);
+       sprintf(url, "%s%s", remote->url, file);
+       dav_headers = curl_slist_append(dav_headers, timeout_header);
+       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_WRITEFUNCTION, fwrite_null);
+       curl_easy_setopt(slot->curl, CURLOPT_HEADERFUNCTION,
+               process_lock_header);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+       curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
+       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);
+               free(out_data);
+               if (slot->curl_result != CURLE_OK) {
+                       fprintf(stderr, "Got HTTP error %ld\n", slot->http_code);
+                       return NULL;
+               }
+       } else {
+               free(out_data);
+               fprintf(stderr, "Unable to start request\n");
+       }
+
+       return strdup(lock_token);
+}
+
+int unlock_remote(char *file, char *lock_token)
+{
+       struct active_request_slot *slot;
+       char *url;
+       char *lock_token_header;
+       struct curl_slist *dav_headers = NULL;
+       int rc = 0;
+
+       if (lock_token == NULL) {
+               fprintf(stderr, "Unable to unlock, no lock token");
+               return 0;
+       }
+
+       lock_token_header = xmalloc(strlen(lock_token) + 31);
+       sprintf(lock_token_header, "Lock-Token: <opaquelocktoken:%s>",
+               lock_token);
+       url = xmalloc(strlen(remote->url) + strlen(file) + 1);
+       sprintf(url, "%s%s", remote->url, file);
+       dav_headers = curl_slist_append(dav_headers, lock_token_header);
+
+       slot = get_active_slot();
+       curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+       curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_UNLOCK);
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+
+       if (start_active_slot(slot)) {
+               run_active_slot(slot);
+               if (slot->curl_result == CURLE_OK)
+                       rc = 1;
+               else
+                       fprintf(stderr, "Got HTTP error %ld\n",
+                               slot->http_code);
+       } else {
+               fprintf(stderr, "Unable to start request\n");
+       }
+
+       curl_slist_free_all(dav_headers);
+       free(lock_token_header);
+       free(url);
+
+       return rc;
+}
+
+int check_locking()
+{
+       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 lockprop supported_lock;
+       struct curl_slist *dav_headers = NULL;
+
+       out_buffer.size = strlen(PROPFIND_REQUEST) + strlen(remote->url) - 2;
+       out_data = xmalloc(out_buffer.size + 1);
+       snprintf(out_data, out_buffer.size + 1, PROPFIND_REQUEST, remote->url);
+       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: 0");
+       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_dynamic);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, remote->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);
+               free(out_data);
+               if (slot->curl_result != CURLE_OK) {
+                       free(in_buffer.buffer);
+                       return -1;
+               }
+
+               XML_SetUserData(parser, &supported_lock);
+               XML_SetElementHandler(parser, start_lockprop_element,
+                                     end_lockprop_element);
+               result = XML_Parse(parser, in_buffer.buffer, in_buffer.posn, 1);
+               free(in_buffer.buffer);
+               if (result != XML_STATUS_OK)
+                       return error("%s", XML_ErrorString(
+                                            XML_GetErrorCode(parser)));
+       } else {
+               free(out_data);
+               free(in_buffer.buffer);
+               return error("Unable to start request");
+       }
+
+       if (supported_lock.lock_exclusive_write)
+               return 0;
+       else
+               return 1;
+}
+
+int is_ancestor(unsigned char *sha1, struct commit *commit)
+{
+       struct commit_list *parents;
+
+       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;
+               }
+       }
+       return 0;
+}
+
+void get_delta(unsigned char *sha1, struct object *obj, char *lock_token)
+{
+       struct commit *commit;
+       struct commit_list *parents;
+       struct tree *tree;
+       struct tree_entry_list *entry;
+
+       if (sha1 && !memcmp(sha1, obj->sha1, 20))
+               return;
+
+       if (aborted)
+               return;
+
+       if (obj->type == commit_type) {
+               if (push_verbosely)
+                       fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
+               add_request(obj->sha1, lock_token);
+               commit = (struct commit *)obj;
+               if (parse_commit(commit)) {
+                       fprintf(stderr, "Error parsing commit %s\n",
+                               sha1_to_hex(obj->sha1));
+                       aborted = 1;
+                       return;
+               }
+               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_token);
+               get_delta(sha1, &commit->tree->object, lock_token);
+       } else if (obj->type == tree_type) {
+               if (push_verbosely)
+                       fprintf(stderr, "walk %s\n", sha1_to_hex(obj->sha1));
+               add_request(obj->sha1, lock_token);
+               tree = (struct tree *)obj;
+               if (parse_tree(tree)) {
+                       fprintf(stderr, "Error parsing tree %s\n",
+                               sha1_to_hex(obj->sha1));
+                       aborted = 1;
+                       return;
+               }
+               entry = tree->entries;
+               tree->entries = NULL;
+               while (entry) {
+                       struct tree_entry_list *next = entry->next;
+                       get_delta(sha1, entry->item.any, lock_token);
+                       free(entry->name);
+                       free(entry);
+                       entry = next;
+               }
+       } else if (obj->type == blob_type || obj->type == tag_type) {
+               add_request(obj->sha1, lock_token);
+       }
+}
+
+int update_remote(char *remote_path, unsigned char *sha1, char *lock_token)
+{
+       struct active_request_slot *slot;
+       char *url;
+       char *out_data;
+       char *if_header;
+       struct buffer out_buffer;
+       struct curl_slist *dav_headers = NULL;
+       int i;
+
+       url = xmalloc(strlen(remote->url) + strlen(remote_path) + 1);
+       sprintf(url, "%s%s", remote->url, remote_path);
+
+       if_header = xmalloc(strlen(lock_token) + 25);
+       sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock_token);
+       dav_headers = curl_slist_append(dav_headers, if_header);
+
+       out_buffer.size = 41;
+       out_data = xmalloc(out_buffer.size + 1);
+       i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
+       if (i != out_buffer.size) {
+               fprintf(stderr, "Unable to initialize PUT request body\n");
+               return 0;
+       }
+       out_buffer.posn = 0;
+       out_buffer.buffer = out_data;
+
+       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_WRITEFUNCTION, fwrite_null);
+       curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
+       curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
+       curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 1);
+       curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
+       curl_easy_setopt(slot->curl, CURLOPT_URL, url);
+
+       if (start_active_slot(slot)) {
+               run_active_slot(slot);
+               free(out_data);
+               free(if_header);
+               free(url);
+               if (slot->curl_result != CURLE_OK) {
+                       fprintf(stderr,
+                               "PUT error: curl result=%d, HTTP code=%ld\n",
+                               slot->curl_result, slot->http_code);
+                       /* We should attempt recovery? */
+                       return 0;
+               }
+       } else {
+               free(out_data);
+               free(if_header);
+               free(url);
+               fprintf(stderr, "Unable to start PUT request\n");
+               return 0;
+       }
+
+       return 1;
+}
+
+int main(int argc, char **argv)
+{
+       struct active_request_slot *slot;
+       struct active_request_slot *next_slot;
+       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];
+       char *remote_lock = NULL;
+       char *remote_path = NULL;
+       char *low_speed_limit;
+       char *low_speed_time;
+       int rc = 0;
+       int i;
+
+       setup_ident();
+
+       remote = xmalloc(sizeof(*remote));
+       remote->url = NULL;
+       remote->packs = NULL;
+
+       argv++;
+       for (i = 1; i < argc; i++, argv++) {
+               char *arg = *argv;
+
+               if (*arg == '-') {
+                       if (!strcmp(arg, "--complete")) {
+                               push_all = 1;
+                               continue;
+                       }
+                       if (!strcmp(arg, "--force")) {
+                               force_all = 1;
+                               continue;
+                       }
+                       if (!strcmp(arg, "--verbose")) {
+                               push_verbosely = 1;
+                               continue;
+                       }
+                       usage(http_push_usage);
+               }
+               if (!remote->url) {
+                       remote->url = arg;
+                       continue;
+               }
+               refspec = argv;
+               nr_refspec = argc - i;
+               break;
+       }
+
+       curl_global_init(CURL_GLOBAL_ALL);
+
+#ifdef USE_CURL_MULTI
+       {
+               char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
+               if (http_max_requests != NULL)
+                       max_requests = atoi(http_max_requests);
+       }
+
+       curlm = curl_multi_init();
+       if (curlm == NULL) {
+               fprintf(stderr, "Error creating curl multi handle.\n");
+               return 1;
+       }
+#endif
+
+       if (getenv("GIT_SSL_NO_VERIFY"))
+               curl_ssl_verify = 0;
+
+       ssl_cert = getenv("GIT_SSL_CERT");
+#if LIBCURL_VERSION_NUM >= 0x070902
+       ssl_key = getenv("GIT_SSL_KEY");
+#endif
+#if LIBCURL_VERSION_NUM >= 0x070908
+       ssl_capath = getenv("GIT_SSL_CAPATH");
+#endif
+       ssl_cainfo = getenv("GIT_SSL_CAINFO");
+
+       low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
+       if (low_speed_limit != NULL)
+               curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
+       low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
+       if (low_speed_time != NULL)
+               curl_low_speed_time = strtol(low_speed_time, NULL, 10);
+
+       git_config(http_options);
+
+       if (curl_ssl_verify == -1)
+               curl_ssl_verify = 1;
+
+#ifdef USE_CURL_MULTI
+       if (max_requests < 1)
+               max_requests = DEFAULT_MAX_REQUESTS;
+#endif
+
+       no_pragma_header = curl_slist_append(no_pragma_header, "Pragma:");
+       default_headers = curl_slist_append(default_headers, "Range:");
+       default_headers = curl_slist_append(default_headers, "Destination:");
+       default_headers = curl_slist_append(default_headers, "If:");
+       default_headers = curl_slist_append(default_headers,
+                                           "Pragma: no-cache");
+
+#ifndef NO_CURL_EASY_DUPHANDLE
+       curl_default = get_curl_handle();
+#endif
+
+       /* Verify DAV compliance/lock support */
+       if (check_locking() != 0) {
+               fprintf(stderr, "Error: no DAV locking support on remote repo %s\n", remote->url);
+               rc = 1;
+               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++;
+               }
+               ep = strchr(local_ref, ':');
+               if (ep) {
+                       remote_ref = ep + 1;
+                       *ep = 0;
+               }
+               else
+                       remote_ref = local_ref;
+
+               /* 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, 3600);
+               if (remote_lock == NULL) {
+                       fprintf(stderr, "Unable to lock remote branch %s\n",
+                               remote_ref);
+                       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;
+               }
+       
+               /* 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;
+                       }
+               }
+
+               /* Generate and check list of required objects */
+               pushing = 0;
+               if (do_remote_update || push_all)
+                       fetch_indices();
+               get_delta(push_all ? NULL : remote_sha1,
+                         local_object, remote_lock);
+               process_waiting_requests();
+
+               /* Push missing objects to remote, this would be a
+                  convenient time to pack them first if appropriate. */
+               pushing = 1;
+               process_request_queue();
+               process_waiting_requests();
+
+               /* Update the remote branch if all went well */
+               if (do_remote_update) {
+                       if (!aborted && update_remote(remote_path,
+                                                     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;
+                       }
+               }
+
+       unlock:
+               unlock_remote(remote_path, remote_lock);
+               free(remote_path);
+               free(remote_lock);
+       }
+
+ cleanup:
+       free(remote);
+
+       curl_slist_free_all(no_pragma_header);
+       curl_slist_free_all(default_headers);
+
+       slot = active_queue_head;
+       while (slot != NULL) {
+               next_slot = slot->next;
+               if (slot->curl != NULL)
+                       curl_easy_cleanup(slot->curl);
+               free(slot);
+               slot = next_slot;
+       }
+
+       request = request_queue_head;
+       while (request != NULL) {
+               next_request = request->next;
+               release_request(request);
+               free(request);
+               request = next_request;
+       }
+
+#ifndef NO_CURL_EASY_DUPHANDLE
+       curl_easy_cleanup(curl_default);
+#endif
+#ifdef USE_CURL_MULTI
+       curl_multi_cleanup(curlm);
+#endif
+       curl_global_cleanup();
+       return rc;
+}