Changeset 782 for git/branches/dmik/remote-curl.c

Timestamp:

Jun 23, 2014, 9:45:51 PM (11 years ago)

Author:

dmik

Message:

git: Merge version 2.0.0 from vendor to dmik branch.

Location:

git/branches/dmik

Files:

• . (modified) (1 prop)
• remote-curl.c (modified) (42 diffs)

git/branches/dmik/remote-curl.c ¶

@@ -7 +7 @@
 #include "run-command.h"
 #include "pkt-line.h"
+#include "string-list.h"
 #include "sideband.h"
+#include "argv-array.h"
+#include "credential.h"
+#include "sha1-array.h"
 
 static struct remote *remote;
-static const char *url; /* always ends with a trailing slash */
+/* always ends with a trailing slash */
+static struct strbuf url = STRBUF_INIT;
 
 struct options {
@@ -16 +21 @@
         unsigned long depth;
         unsigned progress : 1,
+                check_self_contained_and_connected : 1,
+                cloning : 1,
+                update_shallow : 1,
                 followtags : 1,
                 dry_run : 1,
@@ -21 +29 @@
 };
 static struct options options;
+static struct string_list cas_options = STRING_LIST_INIT_DUP;
 
 static int set_option(const char *name, const char *value)
@@ -67 +76 @@
                 return 0;
         }
-        else {
+        else if (!strcmp(name, "check-connectivity")) {
+                if (!strcmp(value, "true"))
+                        options.check_self_contained_and_connected = 1;
+                else if (!strcmp(value, "false"))
+                        options.check_self_contained_and_connected = 0;
+                else
+                        return -1;
+                return 0;
+        }
+        else if (!strcmp(name, "cas")) {
+                struct strbuf val = STRBUF_INIT;
+                strbuf_addf(&val, "--" CAS_OPT_NAME "=%s", value);
+                string_list_append(&cas_options, val.buf);
+                strbuf_release(&val);
+                return 0;
+        } else if (!strcmp(name, "cloning")) {
+                if (!strcmp(value, "true"))
+                        options.cloning = 1;
+                else if (!strcmp(value, "false"))
+                        options.cloning = 0;
+                else
+                        return -1;
+                return 0;
+        } else if (!strcmp(name, "update-shallow")) {
+                if (!strcmp(value, "true"))
+                        options.update_shallow = 1;
+                else if (!strcmp(value, "false"))
+                        options.update_shallow = 0;
+                else
+                        return -1;
+                return 0;
+        } else {
                 return 1 /* unsupported */;
         }
@@ -77 +117 @@
         char *buf;
         size_t len;
+        struct ref *refs;
+        struct sha1_array shallow;
         unsigned proto_git : 1;
 };
 static struct discovery *last_discovery;
 
-static void free_discovery(struct discovery *d)
-{
-        if (d) {
-                if (d == last_discovery)
-                        last_discovery = NULL;
-                free(d->buf_alloc);
-                free(d);
-        }
-}
-
-static struct discovery* discover_refs(const char *service)
-{
-        struct strbuf buffer = STRBUF_INIT;
-        struct discovery *last = last_discovery;
-        char *refs_url;
-        int http_ret, is_http = 0, proto_git_candidate = 1;
-
-        if (last && !strcmp(service, last->service))
-                return last;
-        free_discovery(last);
-
-        strbuf_addf(&buffer, "%sinfo/refs", url);
-        if (!prefixcmp(url, "http://") || !prefixcmp(url, "https://")) {
-                is_http = 1;
-                if (!strchr(url, '?'))
-                        strbuf_addch(&buffer, '?');
-                else
-                        strbuf_addch(&buffer, '&');
-                strbuf_addf(&buffer, "service=%s", service);
-        }
-        refs_url = strbuf_detach(&buffer, NULL);
-
-        http_ret = http_get_strbuf(refs_url, &buffer, HTTP_NO_CACHE);
-
-        /* try again with "plain" url (no ? or & appended) */
-        if (http_ret != HTTP_OK && http_ret != HTTP_NOAUTH) {
-                free(refs_url);
-                strbuf_reset(&buffer);
-
-                proto_git_candidate = 0;
-                strbuf_addf(&buffer, "%sinfo/refs", url);
-                refs_url = strbuf_detach(&buffer, NULL);
-
-                http_ret = http_get_strbuf(refs_url, &buffer, HTTP_NO_CACHE);
-        }
-
-        switch (http_ret) {
-        case HTTP_OK:
-                break;
-        case HTTP_MISSING_TARGET:
-                die("%s not found: did you run git update-server-info on the"
-                    " server?", refs_url);
-        case HTTP_NOAUTH:
-                die("Authentication failed");
-        default:
-                http_error(refs_url, http_ret);
-                die("HTTP request failed");
-        }
-
-        last= xcalloc(1, sizeof(*last_discovery));
-        last->service = service;
-        last->buf_alloc = strbuf_detach(&buffer, &last->len);
-        last->buf = last->buf_alloc;
-
-        if (is_http && proto_git_candidate
-                && 5 <= last->len && last->buf[4] == '#') {
-                /* smart HTTP response; validate that the service
-                 * pkt-line matches our request.
-                 */
-                struct strbuf exp = STRBUF_INIT;
-
-                if (packet_get_line(&buffer, &last->buf, &last->len) <= 0)
-                        die("%s has invalid packet header", refs_url);
-                if (buffer.len && buffer.buf[buffer.len - 1] == '\n')
-                        strbuf_setlen(&buffer, buffer.len - 1);
-
-                strbuf_addf(&exp, "# service=%s", service);
-                if (strbuf_cmp(&exp, &buffer))
-                        die("invalid server response; got '%s'", buffer.buf);
-                strbuf_release(&exp);
-
-                /* The header can include additional metadata lines, up
-                 * until a packet flush marker.  Ignore these now, but
-                 * in the future we might start to scan them.
-                 */
-                strbuf_reset(&buffer);
-                while (packet_get_line(&buffer, &last->buf, &last->len) > 0)
-                        strbuf_reset(&buffer);
-
-                last->proto_git = 1;
-        }
-
-        free(refs_url);
-        strbuf_release(&buffer);
-        last_discovery = last;
-        return last;
-}
-
-static int write_discovery(int in, int out, void *data)
-{
-        struct discovery *heads = data;
-        int err = 0;
-        if (write_in_full(out, heads->buf, heads->len) != heads->len)
-                err = 1;
-        close(out);
-        return err;
-}
-
 static struct ref *parse_git_refs(struct discovery *heads, int for_push)
 {
         struct ref *list = NULL;
-        struct async async;
-
-        memset(&async, 0, sizeof(async));
-        async.proc = write_discovery;
-        async.data = heads;
-        async.out = -1;
-
-        if (start_async(&async))
-                die("cannot start thread to parse advertised refs");
-        get_remote_heads(async.out, &list,
-                        for_push ? REF_NORMAL : 0, NULL);
-        close(async.out);
-        if (finish_async(&async))
-                die("ref parsing thread failed");
+        get_remote_heads(-1, heads->buf, heads->len, &list,
+                         for_push ? REF_NORMAL : 0, NULL, &heads->shallow);
         return list;
 }
@@ -230 +152 @@
                 if (data[i] == '\n') {
                         if (mid - start != 40)
-                                die("%sinfo/refs not valid: is this a git repository?", url);
+                                die("%sinfo/refs not valid: is this a git repository?",
+                                    url.buf);
                         data[i] = 0;
                         ref_name = mid + 1;
@@ -249 +172 @@
 
         ref = alloc_ref("HEAD");
-        if (!http_fetch_ref(url, ref) &&
+        if (!http_fetch_ref(url.buf, ref) &&
             !resolve_remote_symref(ref, refs)) {
                 ref->next = refs;
@@ -260 +183 @@
 }
 
+static void free_discovery(struct discovery *d)
+{
+        if (d) {
+                if (d == last_discovery)
+                        last_discovery = NULL;
+                free(d->shallow.sha1);
+                free(d->buf_alloc);
+                free_refs(d->refs);
+                free(d);
+        }
+}
+
+static int show_http_message(struct strbuf *type, struct strbuf *msg)
+{
+        const char *p, *eol;
+
+        /*
+         * We only show text/plain parts, as other types are likely
+         * to be ugly to look at on the user's terminal.
+         *
+         * TODO should handle "; charset=XXX", and re-encode into
+         * logoutputencoding
+         */
+        if (strcasecmp(type->buf, "text/plain"))
+                return -1;
+
+        strbuf_trim(msg);
+        if (!msg->len)
+                return -1;
+
+        p = msg->buf;
+        do {
+                eol = strchrnul(p, '\n');
+                fprintf(stderr, "remote: %.*s\n", (int)(eol - p), p);
+                p = eol + 1;
+        } while(*eol);
+        return 0;
+}
+
+static struct discovery* discover_refs(const char *service, int for_push)
+{
+        struct strbuf exp = STRBUF_INIT;
+        struct strbuf type = STRBUF_INIT;
+        struct strbuf buffer = STRBUF_INIT;
+        struct strbuf refs_url = STRBUF_INIT;
+        struct strbuf effective_url = STRBUF_INIT;
+        struct discovery *last = last_discovery;
+        int http_ret, maybe_smart = 0;
+        struct http_get_options options;
+
+        if (last && !strcmp(service, last->service))
+                return last;
+        free_discovery(last);
+
+        strbuf_addf(&refs_url, "%sinfo/refs", url.buf);
+        if ((starts_with(url.buf, "http://") || starts_with(url.buf, "https://")) &&
+             git_env_bool("GIT_SMART_HTTP", 1)) {
+                maybe_smart = 1;
+                if (!strchr(url.buf, '?'))
+                        strbuf_addch(&refs_url, '?');
+                else
+                        strbuf_addch(&refs_url, '&');
+                strbuf_addf(&refs_url, "service=%s", service);
+        }
+
+        memset(&options, 0, sizeof(options));
+        options.content_type = &type;
+        options.effective_url = &effective_url;
+        options.base_url = &url;
+        options.no_cache = 1;
+        options.keep_error = 1;
+
+        http_ret = http_get_strbuf(refs_url.buf, &buffer, &options);
+        switch (http_ret) {
+        case HTTP_OK:
+                break;
+        case HTTP_MISSING_TARGET:
+                show_http_message(&type, &buffer);
+                die("repository '%s' not found", url.buf);
+        case HTTP_NOAUTH:
+                show_http_message(&type, &buffer);
+                die("Authentication failed for '%s'", url.buf);
+        default:
+                show_http_message(&type, &buffer);
+                die("unable to access '%s': %s", url.buf, curl_errorstr);
+        }
+
+        last= xcalloc(1, sizeof(*last_discovery));
+        last->service = service;
+        last->buf_alloc = strbuf_detach(&buffer, &last->len);
+        last->buf = last->buf_alloc;
+
+        strbuf_addf(&exp, "application/x-%s-advertisement", service);
+        if (maybe_smart &&
+            (5 <= last->len && last->buf[4] == '#') &&
+            !strbuf_cmp(&exp, &type)) {
+                char *line;
+
+                /*
+                 * smart HTTP response; validate that the service
+                 * pkt-line matches our request.
+                 */
+                line = packet_read_line_buf(&last->buf, &last->len, NULL);
+
+                strbuf_reset(&exp);
+                strbuf_addf(&exp, "# service=%s", service);
+                if (strcmp(line, exp.buf))
+                        die("invalid server response; got '%s'", line);
+                strbuf_release(&exp);
+
+                /* The header can include additional metadata lines, up
+                 * until a packet flush marker.  Ignore these now, but
+                 * in the future we might start to scan them.
+                 */
+                while (packet_read_line_buf(&last->buf, &last->len, NULL))
+                        ;
+
+                last->proto_git = 1;
+        }
+
+        if (last->proto_git)
+                last->refs = parse_git_refs(last, for_push);
+        else
+                last->refs = parse_info_refs(last);
+
+        strbuf_release(&refs_url);
+        strbuf_release(&exp);
+        strbuf_release(&type);
+        strbuf_release(&effective_url);
+        strbuf_release(&buffer);
+        last_discovery = last;
+        return last;
+}
+
 static struct ref *get_refs(int for_push)
 {
@@ -265 +322 @@
 
         if (for_push)
-                heads = discover_refs("git-receive-pack");
+                heads = discover_refs("git-receive-pack", for_push);
         else
-                heads = discover_refs("git-upload-pack");
-
-        if (heads->proto_git)
-                return parse_git_refs(heads, for_push);
-        return parse_info_refs(heads);
+                heads = discover_refs("git-upload-pack", for_push);
+
+        return heads->refs;
 }
 
@@ -285 +340 @@
         printf("\n");
         fflush(stdout);
-        free_refs(refs);
 }
 
@@ -291 +345 @@
         const char *service_name;
         const char **argv;
+        struct strbuf *stdin_preamble;
         char *service_url;
         char *hdr_content_type;
@@ -314 +369 @@
         if (!avail) {
                 rpc->initial_buffer = 0;
-                avail = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
+                avail = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
                 if (!avail)
                         return 0;
@@ -360 +415 @@
 }
 
-static int run_slot(struct active_request_slot *slot)
-{
-        int err = 0;
-        struct slot_results results;
-
-        slot->results = &results;
-        slot->curl_result = curl_easy_perform(slot->curl);
-        finish_active_slot(slot);
-
-        if (results.curl_result != CURLE_OK) {
-                err |= error("RPC failed; result=%d, HTTP code = %ld",
-                        results.curl_result, results.http_code);
+static int run_slot(struct active_request_slot *slot,
+                    struct slot_results *results)
+{
+        int err;
+        struct slot_results results_buf;
+
+        if (!results)
+                results = &results_buf;
+
+        err = run_one_slot(slot, results);
+
+        if (err != HTTP_OK && err != HTTP_REAUTH) {
+                error("RPC failed; result=%d, HTTP code = %ld",
+                      results->curl_result, results->http_code);
         }
 
@@ -377 +434 @@
 }
 
-static int probe_rpc(struct rpc_state *rpc)
+static int probe_rpc(struct rpc_state *rpc, struct slot_results *results)
 {
         struct active_request_slot *slot;
@@ -392 +449 @@
         curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
         curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
-        curl_easy_setopt(slot->curl, CURLOPT_ENCODING, "");
+        curl_easy_setopt(slot->curl, CURLOPT_ENCODING, NULL);
         curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, "0000");
         curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, 4);
@@ -399 +456 @@
         curl_easy_setopt(slot->curl, CURLOPT_FILE, &buf);
 
-        err = run_slot(slot);
+        err = run_slot(slot, results);
 
         curl_slist_free_all(headers);
@@ -412 +469 @@
         int use_gzip = rpc->gzip_request;
         char *gzip_body = NULL;
+        size_t gzip_size = 0;
         int err, large_request = 0;
+        int needs_100_continue = 0;
 
         /* Try to load the entire request, if we can fit it into the
@@ -429 +488 @@
                 }
 
-                n = packet_read_line(rpc->out, buf, left);
+                n = packet_read(rpc->out, NULL, NULL, buf, left, 0);
                 if (!n)
                         break;
@@ -436 +495 @@
 
         if (large_request) {
-                err = probe_rpc(rpc);
-                if (err)
-                        return err;
-        }
-
+                struct slot_results results;
+
+                do {
+                        err = probe_rpc(rpc, &results);
+                        if (err == HTTP_REAUTH)
+                                credential_fill(&http_auth);
+                } while (err == HTTP_REAUTH);
+                if (err != HTTP_OK)
+                        return -1;
+
+                if (results.auth_avail & CURLAUTH_GSSNEGOTIATE)
+                        needs_100_continue = 1;
+        }
+
+        headers = curl_slist_append(headers, rpc->hdr_content_type);
+        headers = curl_slist_append(headers, rpc->hdr_accept);
+        headers = curl_slist_append(headers, needs_100_continue ?
+                "Expect: 100-continue" : "Expect:");
+
+retry:
         slot = get_active_slot();
 
@@ -446 +520 @@
         curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
         curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
-        curl_easy_setopt(slot->curl, CURLOPT_ENCODING, "");
-
-        headers = curl_slist_append(headers, rpc->hdr_content_type);
-        headers = curl_slist_append(headers, rpc->hdr_accept);
-        headers = curl_slist_append(headers, "Expect:");
+        curl_easy_setopt(slot->curl, CURLOPT_ENCODING, "gzip");
 
         if (large_request) {
@@ -469 +539 @@
                 }
 
+        } else if (gzip_body) {
+                /*
+                 * If we are looping to retry authentication, then the previous
+                 * run will have set up the headers and gzip buffer already,
+                 * and we just need to send it.
+                 */
+                curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
+                curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
+
         } else if (use_gzip && 1024 < rpc->len) {
                 /* The client backend isn't giving us compressed data so
@@ -474 +553 @@
                  * the transfer time.
                  */
-                size_t size;
                 git_zstream stream;
                 int ret;
@@ -480 +558 @@
                 memset(&stream, 0, sizeof(stream));
                 git_deflate_init_gzip(&stream, Z_BEST_COMPRESSION);
-                size = git_deflate_bound(&stream, rpc->len);
-                gzip_body = xmalloc(size);
+                gzip_size = git_deflate_bound(&stream, rpc->len);
+                gzip_body = xmalloc(gzip_size);
 
                 stream.next_in = (unsigned char *)rpc->buf;
                 stream.avail_in = rpc->len;
                 stream.next_out = (unsigned char *)gzip_body;
-                stream.avail_out = size;
+                stream.avail_out = gzip_size;
 
                 ret = git_deflate(&stream, Z_FINISH);
@@ -496 +574 @@
                         die("cannot deflate request; zlib end error %d", ret);
 
-                size = stream.total_out;
+                gzip_size = stream.total_out;
 
                 headers = curl_slist_append(headers, "Content-Encoding: gzip");
                 curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, gzip_body);
-                curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, size);
+                curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, gzip_size);
 
                 if (options.verbosity > 1) {
                         fprintf(stderr, "POST %s (gzip %lu to %lu bytes)\n",
                                 rpc->service_name,
-                                (unsigned long)rpc->len, (unsigned long)size);
+                                (unsigned long)rpc->len, (unsigned long)gzip_size);
                         fflush(stderr);
                 }
@@ -525 +603 @@
         curl_easy_setopt(slot->curl, CURLOPT_FILE, rpc);
 
-        err = run_slot(slot);
+        err = run_slot(slot, NULL);
+        if (err == HTTP_REAUTH && !large_request) {
+                credential_fill(&http_auth);
+                goto retry;
+        }
+        if (err != HTTP_OK)
+                err = -1;
 
         curl_slist_free_all(headers);
@@ -536 +620 @@
         const char *svc = rpc->service_name;
         struct strbuf buf = STRBUF_INIT;
+        struct strbuf *preamble = rpc->stdin_preamble;
         struct child_process client;
         int err = 0;
@@ -546 +631 @@
         if (start_command(&client))
                 exit(1);
+        if (preamble)
+                write_or_die(client.in, preamble->buf, preamble->len);
         if (heads)
                 write_or_die(client.in, heads->buf, heads->len);
@@ -555 +642 @@
         strbuf_init(&rpc->result, 0);
 
-        strbuf_addf(&buf, "%s%s", url, svc);
+        strbuf_addf(&buf, "%s%s", url.buf, svc);
         rpc->service_url = strbuf_detach(&buf, NULL);
 
@@ -565 +652 @@
 
         while (!err) {
-                int n = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
+                int n = packet_read(rpc->out, NULL, NULL, rpc->buf, rpc->alloc, 0);
                 if (!n)
                         break;
@@ -607 +694 @@
                 targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
 
-        walker = get_http_walker(url);
+        walker = get_http_walker(url.buf);
         walker->get_all = 1;
         walker->get_tree = 1;
@@ -627 +714 @@
 {
         struct rpc_state rpc;
+        struct strbuf preamble = STRBUF_INIT;
         char *depth_arg = NULL;
-        const char **argv;
         int argc = 0, i, err;
-
-        argv = xmalloc((15 + nr_heads) * sizeof(char*));
+        const char *argv[17];
+
         argv[argc++] = "fetch-pack";
         argv[argc++] = "--stateless-rpc";
+        argv[argc++] = "--stdin";
         argv[argc++] = "--lock-pack";
         if (options.followtags)
@@ -643 +731 @@
                 argv[argc++] = "-v";
         }
+        if (options.check_self_contained_and_connected)
+                argv[argc++] = "--check-self-contained-and-connected";
+        if (options.cloning)
+                argv[argc++] = "--cloning";
+        if (options.update_shallow)
+                argv[argc++] = "--update-shallow";
         if (!options.progress)
                 argv[argc++] = "--no-progress";
@@ -651 +745 @@
                 argv[argc++] = depth_arg;
         }
-        argv[argc++] = url;
+        argv[argc++] = url.buf;
+        argv[argc++] = NULL;
+
         for (i = 0; i < nr_heads; i++) {
                 struct ref *ref = to_fetch[i];
                 if (!ref->name || !*ref->name)
                         die("cannot fetch by sha1 over smart http");
-                argv[argc++] = ref->name;
-        }
-        argv[argc++] = NULL;
+                packet_buf_write(&preamble, "%s %s\n",
+                                 sha1_to_hex(ref->old_sha1), ref->name);
+        }
+        packet_buf_flush(&preamble);
 
         memset(&rpc, 0, sizeof(rpc));
         rpc.service_name = "git-upload-pack",
         rpc.argv = argv;
+        rpc.stdin_preamble = &preamble;
         rpc.gzip_request = 1;
 
         err = rpc_service(&rpc, heads);
         if (rpc.result.len)
-                safe_write(1, rpc.result.buf, rpc.result.len);
+                write_or_die(1, rpc.result.buf, rpc.result.len);
         strbuf_release(&rpc.result);
-        free(argv);
+        strbuf_release(&preamble);
         free(depth_arg);
         return err;
@@ -676 +774 @@
 static int fetch(int nr_heads, struct ref **to_fetch)
 {
-        struct discovery *d = discover_refs("git-upload-pack");
+        struct discovery *d = discover_refs("git-upload-pack", 0);
         if (d->proto_git)
                 return fetch_git(d, nr_heads, to_fetch);
@@ -691 +789 @@
 
         do {
-                if (!prefixcmp(buf->buf, "fetch ")) {
+                if (starts_with(buf->buf, "fetch ")) {
                         char *p = buf->buf + strlen("fetch ");
                         char *name;
@@ -746 +844 @@
         if (options.verbosity > 1)
                 argv[argc++] = "--verbose";
-        argv[argc++] = url;
+        argv[argc++] = url.buf;
         for (i = 0; i < nr_spec; i++)
                 argv[argc++] = specs[i];
@@ -760 +858 @@
 {
         struct rpc_state rpc;
-        const char **argv;
-        int argc = 0, i, err;
-
-        argv = xmalloc((10 + nr_spec) * sizeof(char*));
-        argv[argc++] = "send-pack";
-        argv[argc++] = "--stateless-rpc";
-        argv[argc++] = "--helper-status";
+        int i, err;
+        struct argv_array args;
+        struct string_list_item *cas_option;
+
+        argv_array_init(&args);
+        argv_array_pushl(&args, "send-pack", "--stateless-rpc", "--helper-status",
+                         NULL);
+
         if (options.thin)
-                argv[argc++] = "--thin";
+                argv_array_push(&args, "--thin");
         if (options.dry_run)
-                argv[argc++] = "--dry-run";
+                argv_array_push(&args, "--dry-run");
         if (options.verbosity == 0)
-                argv[argc++] = "--quiet";
+                argv_array_push(&args, "--quiet");
         else if (options.verbosity > 1)
-                argv[argc++] = "--verbose";
-        argv[argc++] = url;
+                argv_array_push(&args, "--verbose");
+        argv_array_push(&args, options.progress ? "--progress" : "--no-progress");
+        for_each_string_list_item(cas_option, &cas_options)
+                argv_array_push(&args, cas_option->string);
+        argv_array_push(&args, url.buf);
         for (i = 0; i < nr_spec; i++)
-                argv[argc++] = specs[i];
-        argv[argc++] = NULL;
+                argv_array_push(&args, specs[i]);
 
         memset(&rpc, 0, sizeof(rpc));
         rpc.service_name = "git-receive-pack",
-        rpc.argv = argv;
+        rpc.argv = args.argv;
 
         err = rpc_service(&rpc, heads);
         if (rpc.result.len)
-                safe_write(1, rpc.result.buf, rpc.result.len);
+                write_or_die(1, rpc.result.buf, rpc.result.len);
         strbuf_release(&rpc.result);
-        free(argv);
+        argv_array_clear(&args);
         return err;
 }
@@ -794 +895 @@
 static int push(int nr_spec, char **specs)
 {
-        struct discovery *heads = discover_refs("git-receive-pack");
+        struct discovery *heads = discover_refs("git-receive-pack", 1);
         int ret;
 
@@ -811 +912 @@
 
         do {
-                if (!prefixcmp(buf->buf, "push ")) {
+                if (starts_with(buf->buf, "push ")) {
                         ALLOC_GROW(specs, nr_spec + 1, alloc_spec);
                         specs[nr_spec++] = xstrdup(buf->buf + 5);
@@ -857 +958 @@
 
         if (argc > 2) {
-                end_url_with_slash(&buf, argv[2]);
+                end_url_with_slash(&url, argv[2]);
         } else {
-                end_url_with_slash(&buf, remote->url[0]);
-        }
-
-        url = strbuf_detach(&buf, NULL);
-
-        http_init(remote, url, 0);
+                end_url_with_slash(&url, remote->url[0]);
+        }
+
+        http_init(remote, url.buf, 0);
 
         do {
@@ -876 +975 @@
                 if (buf.len == 0)
                         break;
-                if (!prefixcmp(buf.buf, "fetch ")) {
+                if (starts_with(buf.buf, "fetch ")) {
                         if (nongit)
                                 die("Fetch attempted without a local repo");
                         parse_fetch(&buf);
 
-                } else if (!strcmp(buf.buf, "list") || !prefixcmp(buf.buf, "list ")) {
+                } else if (!strcmp(buf.buf, "list") || starts_with(buf.buf, "list ")) {
                         int for_push = !!strstr(buf.buf + 4, "for-push");
                         output_refs(get_refs(for_push));
 
-                } else if (!prefixcmp(buf.buf, "push ")) {
+                } else if (starts_with(buf.buf, "push ")) {
                         parse_push(&buf);
 
-                } else if (!prefixcmp(buf.buf, "option ")) {
+                } else if (starts_with(buf.buf, "option ")) {
                         char *name = buf.buf + strlen("option ");
                         char *value = strchr(name, ' ');
@@ -911 +1010 @@
                         printf("option\n");
                         printf("push\n");
+                        printf("check-connectivity\n");
                         printf("\n");
                         fflush(stdout);