options.progress = 0;
else
return -1;
- return 1 /* TODO implement later */;
+ return 0;
}
else if (!strcmp(name, "depth")) {
char *end;
if (value == end || *end)
return -1;
options.depth = v;
- return 1 /* TODO implement later */;
+ return 0;
}
else if (!strcmp(name, "followtags")) {
if (!strcmp(value, "true"))
options.followtags = 0;
else
return -1;
- return 1 /* TODO implement later */;
+ return 0;
}
else if (!strcmp(name, "dry-run")) {
if (!strcmp(value, "true"))
int in;
int out;
struct strbuf result;
+ unsigned gzip_request : 1;
};
static size_t rpc_out(void *ptr, size_t eltsize,
struct active_request_slot *slot;
struct slot_results results;
struct curl_slist *headers = NULL;
+ int use_gzip = rpc->gzip_request;
+ char *gzip_body = NULL;
int err = 0, large_request = 0;
/* Try to load the entire request, if we can fit it into the
if (left < LARGE_PACKET_MAX) {
large_request = 1;
+ use_gzip = 0;
break;
}
curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
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);
fflush(stderr);
}
+ } else if (use_gzip && 1024 < rpc->len) {
+ /* The client backend isn't giving us compressed data so
+ * we can try to deflate it ourselves, this may save on.
+ * the transfer time.
+ */
+ size_t size;
+ z_stream stream;
+ int ret;
+
+ memset(&stream, 0, sizeof(stream));
+ ret = deflateInit2(&stream, Z_BEST_COMPRESSION,
+ Z_DEFLATED, (15 + 16),
+ 8, Z_DEFAULT_STRATEGY);
+ if (ret != Z_OK)
+ die("cannot deflate request; zlib init error %d", ret);
+ size = deflateBound(&stream, rpc->len);
+ gzip_body = xmalloc(size);
+
+ stream.next_in = (unsigned char *)rpc->buf;
+ stream.avail_in = rpc->len;
+ stream.next_out = (unsigned char *)gzip_body;
+ stream.avail_out = size;
+
+ ret = deflate(&stream, Z_FINISH);
+ if (ret != Z_STREAM_END)
+ die("cannot deflate request; zlib deflate error %d", ret);
+
+ ret = deflateEnd(&stream);
+ if (ret != Z_OK)
+ die("cannot deflate request; zlib end error %d", ret);
+
+ 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);
+
+ if (options.verbosity > 1) {
+ fprintf(stderr, "POST %s (gzip %lu to %lu bytes)\n",
+ rpc->service_name,
+ (unsigned long)rpc->len, (unsigned long)size);
+ fflush(stderr);
+ }
} else {
/* We know the complete request size in advance, use the
* more normal Content-Length approach.
}
curl_slist_free_all(headers);
+ free(gzip_body);
return err;
}
char **targets = xmalloc(nr_heads * sizeof(char*));
int ret, i;
+ if (options.depth)
+ die("dumb http transport does not support --depth");
for (i = 0; i < nr_heads; i++)
targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
return ret ? error("Fetch failed.") : 0;
}
+static int fetch_git(struct discovery *heads,
+ int nr_heads, struct ref **to_fetch)
+{
+ struct rpc_state rpc;
+ char *depth_arg = NULL;
+ const char **argv;
+ int argc = 0, i, err;
+
+ argv = xmalloc((15 + nr_heads) * sizeof(char*));
+ argv[argc++] = "fetch-pack";
+ argv[argc++] = "--stateless-rpc";
+ argv[argc++] = "--lock-pack";
+ if (options.followtags)
+ argv[argc++] = "--include-tag";
+ if (options.thin)
+ argv[argc++] = "--thin";
+ if (options.verbosity >= 3) {
+ argv[argc++] = "-v";
+ argv[argc++] = "-v";
+ }
+ if (!options.progress)
+ argv[argc++] = "--no-progress";
+ if (options.depth) {
+ struct strbuf buf = STRBUF_INIT;
+ strbuf_addf(&buf, "--depth=%lu", options.depth);
+ depth_arg = strbuf_detach(&buf, NULL);
+ argv[argc++] = depth_arg;
+ }
+ argv[argc++] = url;
+ 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;
+
+ memset(&rpc, 0, sizeof(rpc));
+ rpc.service_name = "git-upload-pack",
+ rpc.argv = argv;
+ rpc.gzip_request = 1;
+
+ err = rpc_service(&rpc, heads);
+ if (rpc.result.len)
+ safe_write(1, rpc.result.buf, rpc.result.len);
+ strbuf_release(&rpc.result);
+ free(argv);
+ free(depth_arg);
+ return err;
+}
+
+static int fetch(int nr_heads, struct ref **to_fetch)
+{
+ struct discovery *d = discover_refs("git-upload-pack");
+ if (d->proto_git)
+ return fetch_git(d, nr_heads, to_fetch);
+ else
+ return fetch_dumb(nr_heads, to_fetch);
+}
+
static void parse_fetch(struct strbuf *buf)
{
struct ref **to_fetch = NULL;
break;
} while (1);
- if (fetch_dumb(nr_heads, to_fetch))
+ if (fetch(nr_heads, to_fetch))
exit(128); /* error already reported */
free_refs(list_head);
free(to_fetch);
int main(int argc, const char **argv)
{
struct strbuf buf = STRBUF_INIT;
+ int nongit;
git_extract_argv0_path(argv[0]);
- setup_git_directory();
+ setup_git_directory_gently(&nongit);
if (argc < 2) {
fprintf(stderr, "Remote needed\n");
return 1;
if (strbuf_getline(&buf, stdin, '\n') == EOF)
break;
if (!prefixcmp(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 ")) {