[git/git.git] / remote-curl.c

#include "cache.h"
#include "remote.h"
#include "strbuf.h"
#include "walker.h"
#include "http.h"
#include "exec_cmd.h"
#include "run-command.h"
#include "pkt-line.h"
#include "sideband.h"

static struct remote *remote;
static const char *url;
static struct walker *walker;

struct options {
	int verbosity;
	unsigned long depth;
	unsigned progress : 1,
		followtags : 1,
		dry_run : 1,
		thin : 1;
};
static struct options options;

static void init_walker(void)
{
	if (!walker)
		walker = get_http_walker(url, remote);
}

static int set_option(const char *name, const char *value)
{
	if (!strcmp(name, "verbosity")) {
		char *end;
		int v = strtol(value, &end, 10);
		if (value == end || *end)
			return -1;
		options.verbosity = v;
		return 0;
	}
	else if (!strcmp(name, "progress")) {
		if (!strcmp(value, "true"))
			options.progress = 1;
		else if (!strcmp(value, "false"))
			options.progress = 0;
		else
			return -1;
		return 0;
	}
	else if (!strcmp(name, "depth")) {
		char *end;
		unsigned long v = strtoul(value, &end, 10);
		if (value == end || *end)
			return -1;
		options.depth = v;
		return 0;
	}
	else if (!strcmp(name, "followtags")) {
		if (!strcmp(value, "true"))
			options.followtags = 1;
		else if (!strcmp(value, "false"))
			options.followtags = 0;
		else
			return -1;
		return 0;
	}
	else if (!strcmp(name, "dry-run")) {
		if (!strcmp(value, "true"))
			options.dry_run = 1;
		else if (!strcmp(value, "false"))
			options.dry_run = 0;
		else
			return -1;
		return 0;
	}
	else {
		return 1 /* unsupported */;
	}
}

struct discovery {
	const char *service;
	char *buf_alloc;
	char *buf;
	size_t len;
	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;

	if (last && !strcmp(service, last->service))
		return last;
	free_discovery(last);

	strbuf_addf(&buffer, "%s/info/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);

	init_walker();
	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);
	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 && 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 fd, void *data)
{
	struct discovery *heads = data;
	int err = 0;
	if (write_in_full(fd, heads->buf, heads->len) != heads->len)
		err = 1;
	close(fd);
	return err;
}

static struct ref *parse_git_refs(struct discovery *heads)
{
	struct ref *list = NULL;
	struct async async;

	memset(&async, 0, sizeof(async));
	async.proc = write_discovery;
	async.data = heads;

	if (start_async(&async))
		die("cannot start thread to parse advertised refs");
	get_remote_heads(async.out, &list, 0, NULL, 0, NULL);
	close(async.out);
	if (finish_async(&async))
		die("ref parsing thread failed");
	return list;
}

static struct ref *parse_info_refs(struct discovery *heads)
{
	char *data, *start, *mid;
	char *ref_name;
	int i = 0;

	struct ref *refs = NULL;
	struct ref *ref = NULL;
	struct ref *last_ref = NULL;

	data = heads->buf;
	start = NULL;
	mid = data;
	while (i < heads->len) {
		if (!start) {
			start = &data[i];
		}
		if (data[i] == '\t')
			mid = &data[i];
		if (data[i] == '\n') {
			data[i] = 0;
			ref_name = mid + 1;
			ref = xmalloc(sizeof(struct ref) +
				      strlen(ref_name) + 1);
			memset(ref, 0, sizeof(struct ref));
			strcpy(ref->name, ref_name);
			get_sha1_hex(start, ref->old_sha1);
			if (!refs)
				refs = ref;
			if (last_ref)
				last_ref->next = ref;
			last_ref = ref;
			start = NULL;
		}
		i++;
	}

	init_walker();
	ref = alloc_ref("HEAD");
	if (!walker->fetch_ref(walker, ref) &&
	    !resolve_remote_symref(ref, refs)) {
		ref->next = refs;
		refs = ref;
	} else {
		free(ref);
	}

	return refs;
}

static struct ref *get_refs(int for_push)
{
	struct discovery *heads;

	if (for_push)
		heads = discover_refs("git-receive-pack");
	else
		heads = discover_refs("git-upload-pack");

	if (heads->proto_git)
		return parse_git_refs(heads);
	return parse_info_refs(heads);
}

static void output_refs(struct ref *refs)
{
	struct ref *posn;
	for (posn = refs; posn; posn = posn->next) {
		if (posn->symref)
			printf("@%s %s\n", posn->symref, posn->name);
		else
			printf("%s %s\n", sha1_to_hex(posn->old_sha1), posn->name);
	}
	printf("\n");
	fflush(stdout);
	free_refs(refs);
}

struct rpc_state {
	const char *service_name;
	const char **argv;
	char *service_url;
	char *hdr_content_type;
	char *hdr_accept;
	char *buf;
	size_t alloc;
	size_t len;
	size_t pos;
	int in;
	int out;
	struct strbuf result;
};

static size_t rpc_out(void *ptr, size_t eltsize,
		size_t nmemb, void *buffer_)
{
	size_t max = eltsize * nmemb;
	struct rpc_state *rpc = buffer_;
	size_t avail = rpc->len - rpc->pos;

	if (!avail) {
		avail = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
		if (!avail)
			return 0;
		rpc->pos = 0;
		rpc->len = avail;
	}

	if (max < avail);
		avail = max;
	memcpy(ptr, rpc->buf + rpc->pos, avail);
	rpc->pos += avail;
	return avail;
}

static size_t rpc_in(const void *ptr, size_t eltsize,
		size_t nmemb, void *buffer_)
{
	size_t size = eltsize * nmemb;
	struct rpc_state *rpc = buffer_;
	write_or_die(rpc->in, ptr, size);
	return size;
}

static int post_rpc(struct rpc_state *rpc)
{
	struct active_request_slot *slot;
	struct slot_results results;
	struct curl_slist *headers = NULL;
	int err = 0, large_request = 0;

	/* Try to load the entire request, if we can fit it into the
	 * allocated buffer space we can use HTTP/1.0 and avoid the
	 * chunked encoding mess.
	 */
	while (1) {
		size_t left = rpc->alloc - rpc->len;
		char *buf = rpc->buf + rpc->len;
		int n;

		if (left < LARGE_PACKET_MAX) {
			large_request = 1;
			break;
		}

		n = packet_read_line(rpc->out, buf, left);
		if (!n)
			break;
		rpc->len += n;
	}

	slot = get_active_slot();
	slot->results = &results;

	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);

	headers = curl_slist_append(headers, rpc->hdr_content_type);
	headers = curl_slist_append(headers, rpc->hdr_accept);

	if (large_request) {
		/* The request body is large and the size cannot be predicted.
		 * We must use chunked encoding to send it.
		 */
		headers = curl_slist_append(headers, "Expect: 100-continue");
		headers = curl_slist_append(headers, "Transfer-Encoding: chunked");
		curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
		curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc);
		if (options.verbosity > 1) {
			fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
			fflush(stderr);
		}

	} else {
		/* We know the complete request size in advance, use the
		 * more normal Content-Length approach.
		 */
		curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, rpc->buf);
		curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, rpc->len);
		if (options.verbosity > 1) {
			fprintf(stderr, "POST %s (%lu bytes)\n",
				rpc->service_name, (unsigned long)rpc->len);
			fflush(stderr);
		}
	}

	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, rpc_in);
	curl_easy_setopt(slot->curl, CURLOPT_FILE, rpc);

	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);
	}

	curl_slist_free_all(headers);
	return err;
}

static int rpc_service(struct rpc_state *rpc, struct discovery *heads)
{
	const char *svc = rpc->service_name;
	struct strbuf buf = STRBUF_INIT;
	struct child_process client;
	int err = 0;

	init_walker();
	memset(&client, 0, sizeof(client));
	client.in = -1;
	client.out = -1;
	client.git_cmd = 1;
	client.argv = rpc->argv;
	if (start_command(&client))
		exit(1);
	if (heads)
		write_or_die(client.in, heads->buf, heads->len);

	rpc->alloc = http_post_buffer;
	rpc->buf = xmalloc(rpc->alloc);
	rpc->in = client.in;
	rpc->out = client.out;
	strbuf_init(&rpc->result, 0);

	strbuf_addf(&buf, "%s/%s", url, svc);
	rpc->service_url = strbuf_detach(&buf, NULL);

	strbuf_addf(&buf, "Content-Type: application/x-%s-request", svc);
	rpc->hdr_content_type = strbuf_detach(&buf, NULL);

	strbuf_addf(&buf, "Accept: application/x-%s-response", svc);
	rpc->hdr_accept = strbuf_detach(&buf, NULL);

	while (!err) {
		int n = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
		if (!n)
			break;
		rpc->pos = 0;
		rpc->len = n;
		err |= post_rpc(rpc);
	}
	strbuf_read(&rpc->result, client.out, 0);

	close(client.in);
	close(client.out);
	client.in = -1;
	client.out = -1;

	err |= finish_command(&client);
	free(rpc->service_url);
	free(rpc->hdr_content_type);
	free(rpc->hdr_accept);
	free(rpc->buf);
	strbuf_release(&buf);
	return err;
}

static int fetch_dumb(int nr_heads, struct ref **to_fetch)
{
	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));

	init_walker();
	walker->get_all = 1;
	walker->get_tree = 1;
	walker->get_history = 1;
	walker->get_verbosely = options.verbosity >= 3;
	walker->get_recover = 0;
	ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);

	for (i = 0; i < nr_heads; i++)
		free(targets[i]);
	free(targets);

	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;

	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;
	struct ref *list_head = NULL;
	struct ref **list = &list_head;
	int alloc_heads = 0, nr_heads = 0;

	do {
		if (!prefixcmp(buf->buf, "fetch ")) {
			char *p = buf->buf + strlen("fetch ");
			char *name;
			struct ref *ref;
			unsigned char old_sha1[20];

			if (strlen(p) < 40 || get_sha1_hex(p, old_sha1))
				die("protocol error: expected sha/ref, got %s'", p);
			if (p[40] == ' ')
				name = p + 41;
			else if (!p[40])
				name = "";
			else
				die("protocol error: expected sha/ref, got %s'", p);

			ref = alloc_ref(name);
			hashcpy(ref->old_sha1, old_sha1);

			*list = ref;
			list = &ref->next;

			ALLOC_GROW(to_fetch, nr_heads + 1, alloc_heads);
			to_fetch[nr_heads++] = ref;
		}
		else
			die("http transport does not support %s", buf->buf);

		strbuf_reset(buf);
		if (strbuf_getline(buf, stdin, '\n') == EOF)
			return;
		if (!*buf->buf)
			break;
	} while (1);

	if (fetch(nr_heads, to_fetch))
		exit(128); /* error already reported */
	free_refs(list_head);
	free(to_fetch);

	printf("\n");
	fflush(stdout);
	strbuf_reset(buf);
}

static int push_dav(int nr_spec, char **specs)
{
	const char **argv = xmalloc((10 + nr_spec) * sizeof(char*));
	int argc = 0, i;

	argv[argc++] = "http-push";
	argv[argc++] = "--helper-status";
	if (options.dry_run)
		argv[argc++] = "--dry-run";
	if (options.verbosity > 1)
		argv[argc++] = "--verbose";
	argv[argc++] = url;
	for (i = 0; i < nr_spec; i++)
		argv[argc++] = specs[i];
	argv[argc++] = NULL;

	if (run_command_v_opt(argv, RUN_GIT_CMD))
		die("git-%s failed", argv[0]);
	free(argv);
	return 0;
}

static int push_git(struct discovery *heads, int nr_spec, char **specs)
{
	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";
	if (options.thin)
		argv[argc++] = "--thin";
	if (options.dry_run)
		argv[argc++] = "--dry-run";
	if (options.verbosity > 1)
		argv[argc++] = "--verbose";
	argv[argc++] = url;
	for (i = 0; i < nr_spec; i++)
		argv[argc++] = specs[i];
	argv[argc++] = NULL;

	memset(&rpc, 0, sizeof(rpc));
	rpc.service_name = "git-receive-pack",
	rpc.argv = argv;

	err = rpc_service(&rpc, heads);
	if (rpc.result.len)
		safe_write(1, rpc.result.buf, rpc.result.len);
	strbuf_release(&rpc.result);
	free(argv);
	return err;
}

static int push(int nr_spec, char **specs)
{
	struct discovery *heads = discover_refs("git-receive-pack");
	int ret;

	if (heads->proto_git)
		ret = push_git(heads, nr_spec, specs);
	else
		ret = push_dav(nr_spec, specs);
	free_discovery(heads);
	return ret;
}

static void parse_push(struct strbuf *buf)
{
	char **specs = NULL;
	int alloc_spec = 0, nr_spec = 0, i;

	do {
		if (!prefixcmp(buf->buf, "push ")) {
			ALLOC_GROW(specs, nr_spec + 1, alloc_spec);
			specs[nr_spec++] = xstrdup(buf->buf + 5);
		}
		else
			die("http transport does not support %s", buf->buf);

		strbuf_reset(buf);
		if (strbuf_getline(buf, stdin, '\n') == EOF)
			return;
		if (!*buf->buf)
			break;
	} while (1);

	if (push(nr_spec, specs))
		exit(128); /* error already reported */
	for (i = 0; i < nr_spec; i++)
		free(specs[i]);
	free(specs);

	printf("\n");
	fflush(stdout);
}

int main(int argc, const char **argv)
{
	struct strbuf buf = STRBUF_INIT;

	git_extract_argv0_path(argv[0]);
	setup_git_directory();
	if (argc < 2) {
		fprintf(stderr, "Remote needed\n");
		return 1;
	}

	options.verbosity = 1;
	options.progress = !!isatty(2);
	options.thin = 1;

	remote = remote_get(argv[1]);

	if (argc > 2) {
		url = argv[2];
	} else {
		url = remote->url[0];
	}

	do {
		if (strbuf_getline(&buf, stdin, '\n') == EOF)
			break;
		if (!prefixcmp(buf.buf, "fetch ")) {
			parse_fetch(&buf);

		} else if (!strcmp(buf.buf, "list") || !prefixcmp(buf.buf, "list ")) {
			int for_push = !!strstr(buf.buf + 4, "for-push");
			output_refs(get_refs(for_push));

		} else if (!prefixcmp(buf.buf, "push ")) {
			parse_push(&buf);

		} else if (!prefixcmp(buf.buf, "option ")) {
			char *name = buf.buf + strlen("option ");
			char *value = strchr(name, ' ');
			int result;

			if (value)
				*value++ = '\0';
			else
				value = "true";

			result = set_option(name, value);
			if (!result)
				printf("ok\n");
			else if (result < 0)
				printf("error invalid value\n");
			else
				printf("unsupported\n");
			fflush(stdout);

		} else if (!strcmp(buf.buf, "capabilities")) {
			printf("fetch\n");
			printf("option\n");
			printf("push\n");
			printf("\n");
			fflush(stdout);
		} else {
			return 1;
		}
		strbuf_reset(&buf);
	} while (1);
	return 0;
}
Commit	Line	Data
a2d725b7 DB	1	#include "cache.h"
	2	#include "remote.h"
	3	#include "strbuf.h"
	4	#include "walker.h"
	5	#include "http.h"
d01a8e32	6	#include "exec_cmd.h"
ae4efe19	7	#include "run-command.h"
97cc7bc4	8	#include "pkt-line.h"
de1a2fdd	9	#include "sideband.h"
a2d725b7	10
37a8768f SP	11	static struct remote *remote;
	12	static const char *url;
	13	static struct walker *walker;
	14
ef08ef9e SP	15	struct options {
	16	int verbosity;
	17	unsigned long depth;
	18	unsigned progress : 1,
ae4efe19	19	followtags : 1,
de1a2fdd SP	20	dry_run : 1,
de1a2fdd SP	21	thin : 1;
ef08ef9e SP	22	};
	23	static struct options options;
	24
37a8768f SP	25	static void init_walker(void)
	26	{
	27	if (!walker)
	28	walker = get_http_walker(url, remote);
	29	}
	30
ef08ef9e SP	31	static int set_option(const char name, const char value)
	32	{
	33	if (!strcmp(name, "verbosity")) {
	34	char *end;
	35	int v = strtol(value, &end, 10);
	36	if (value == end \|\| *end)
	37	return -1;
	38	options.verbosity = v;
	39	return 0;
	40	}
	41	else if (!strcmp(name, "progress")) {
	42	if (!strcmp(value, "true"))
	43	options.progress = 1;
	44	else if (!strcmp(value, "false"))
	45	options.progress = 0;
	46	else
	47	return -1;
249b2004	48	return 0;
ef08ef9e SP	49	}
	50	else if (!strcmp(name, "depth")) {
	51	char *end;
	52	unsigned long v = strtoul(value, &end, 10);
	53	if (value == end \|\| *end)
	54	return -1;
	55	options.depth = v;
249b2004	56	return 0;
ef08ef9e SP	57	}
	58	else if (!strcmp(name, "followtags")) {
	59	if (!strcmp(value, "true"))
	60	options.followtags = 1;
	61	else if (!strcmp(value, "false"))
	62	options.followtags = 0;
	63	else
	64	return -1;
249b2004	65	return 0;
ef08ef9e	66	}
ae4efe19 SP	67	else if (!strcmp(name, "dry-run")) {
	68	if (!strcmp(value, "true"))
	69	options.dry_run = 1;
	70	else if (!strcmp(value, "false"))
	71	options.dry_run = 0;
	72	else
	73	return -1;
	74	return 0;
	75	}
ef08ef9e SP	76	else {
	77	return 1 /* unsupported */;
	78	}
	79	}
	80
97cc7bc4 SP	81	struct discovery {
	82	const char *service;
	83	char *buf_alloc;
	84	char *buf;
	85	size_t len;
	86	unsigned proto_git : 1;
	87	};
	88	static struct discovery *last_discovery;
	89
	90	static void free_discovery(struct discovery *d)
	91	{
	92	if (d) {
	93	if (d == last_discovery)
	94	last_discovery = NULL;
	95	free(d->buf_alloc);
	96	free(d);
	97	}
	98	}
	99
	100	static struct discovery* discover_refs(const char *service)
a2d725b7 DB	101	{
a2d725b7 DB	102	struct strbuf buffer = STRBUF_INIT;
97cc7bc4	103	struct discovery *last = last_discovery;
a2d725b7	104	char *refs_url;
97cc7bc4	105	int http_ret, is_http = 0;
a2d725b7	106
97cc7bc4 SP	107	if (last && !strcmp(service, last->service))
	108	return last;
	109	free_discovery(last);
a2d725b7	110
97cc7bc4 SP	111	strbuf_addf(&buffer, "%s/info/refs", url);
	112	if (!prefixcmp(url, "http://") \|\| !prefixcmp(url, "https://")) {
	113	is_http = 1;
	114	if (!strchr(url, '?'))
	115	strbuf_addch(&buffer, '?');
	116	else
	117	strbuf_addch(&buffer, '&');
	118	strbuf_addf(&buffer, "service=%s", service);
	119	}
	120	refs_url = strbuf_detach(&buffer, NULL);
a2d725b7	121
37a8768f	122	init_walker();
a2d725b7 DB	123	http_ret = http_get_strbuf(refs_url, &buffer, HTTP_NO_CACHE);
	124	switch (http_ret) {
	125	case HTTP_OK:
	126	break;
	127	case HTTP_MISSING_TARGET:
	128	die("%s not found: did you run git update-server-info on the"
	129	" server?", refs_url);
	130	default:
	131	http_error(refs_url, http_ret);
	132	die("HTTP request failed");
	133	}
	134
97cc7bc4 SP	135	last= xcalloc(1, sizeof(*last_discovery));
	136	last->service = service;
	137	last->buf_alloc = strbuf_detach(&buffer, &last->len);
	138	last->buf = last->buf_alloc;
	139
	140	if (is_http && 5 <= last->len && last->buf[4] == '#') {
	141	/* smart HTTP response; validate that the service
	142	* pkt-line matches our request.
	143	*/
	144	struct strbuf exp = STRBUF_INIT;
	145
	146	if (packet_get_line(&buffer, &last->buf, &last->len) <= 0)
	147	die("%s has invalid packet header", refs_url);
	148	if (buffer.len && buffer.buf[buffer.len - 1] == '\n')
	149	strbuf_setlen(&buffer, buffer.len - 1);
	150
	151	strbuf_addf(&exp, "# service=%s", service);
	152	if (strbuf_cmp(&exp, &buffer))
	153	die("invalid server response; got '%s'", buffer.buf);
	154	strbuf_release(&exp);
	155
	156	/* The header can include additional metadata lines, up
	157	* until a packet flush marker. Ignore these now, but
	158	* in the future we might start to scan them.
	159	*/
	160	strbuf_reset(&buffer);
	161	while (packet_get_line(&buffer, &last->buf, &last->len) > 0)
	162	strbuf_reset(&buffer);
	163
	164	last->proto_git = 1;
	165	}
	166
	167	free(refs_url);
	168	strbuf_release(&buffer);
	169	last_discovery = last;
	170	return last;
	171	}
	172
	173	static int write_discovery(int fd, void *data)
	174	{
	175	struct discovery *heads = data;
	176	int err = 0;
	177	if (write_in_full(fd, heads->buf, heads->len) != heads->len)
	178	err = 1;
	179	close(fd);
	180	return err;
	181	}
	182
	183	static struct ref parse_git_refs(struct discovery heads)
	184	{
	185	struct ref *list = NULL;
	186	struct async async;
	187
	188	memset(&async, 0, sizeof(async));
	189	async.proc = write_discovery;
	190	async.data = heads;
	191
	192	if (start_async(&async))
	193	die("cannot start thread to parse advertised refs");
	194	get_remote_heads(async.out, &list, 0, NULL, 0, NULL);
	195	close(async.out);
	196	if (finish_async(&async))
	197	die("ref parsing thread failed");
	198	return list;
199	}
200
201	static struct ref parse_info_refs(struct discovery heads)
202	{
203	char data, start, *mid;
204	char *ref_name;
205	int i = 0;
206
207	struct ref *refs = NULL;
208	struct ref *ref = NULL;
209	struct ref *last_ref = NULL;
210
211	data = heads->buf;
a2d725b7 DB	212	start = NULL;
a2d725b7 DB	213	mid = data;
97cc7bc4	214	while (i < heads->len) {
a2d725b7 DB	215	if (!start) {
	216	start = &data[i];
	217	}
	218	if (data[i] == '\t')
	219	mid = &data[i];
	220	if (data[i] == '\n') {
	221	data[i] = 0;
	222	ref_name = mid + 1;
	223	ref = xmalloc(sizeof(struct ref) +
	224	strlen(ref_name) + 1);
	225	memset(ref, 0, sizeof(struct ref));
	226	strcpy(ref->name, ref_name);
	227	get_sha1_hex(start, ref->old_sha1);
	228	if (!refs)
	229	refs = ref;
	230	if (last_ref)
	231	last_ref->next = ref;
	232	last_ref = ref;
	233	start = NULL;
	234	}
	235	i++;
	236	}
	237
97cc7bc4	238	init_walker();
a2d725b7 DB	239	ref = alloc_ref("HEAD");
	240	if (!walker->fetch_ref(walker, ref) &&
	241	!resolve_remote_symref(ref, refs)) {
	242	ref->next = refs;
	243	refs = ref;
	244	} else {
	245	free(ref);
	246	}
	247
a2d725b7 DB	248	return refs;
	249	}
	250
97cc7bc4 SP	251	static struct ref *get_refs(int for_push)
	252	{
	253	struct discovery *heads;
	254
	255	if (for_push)
	256	heads = discover_refs("git-receive-pack");
	257	else
	258	heads = discover_refs("git-upload-pack");
	259
	260	if (heads->proto_git)
	261	return parse_git_refs(heads);
	262	return parse_info_refs(heads);
	263	}
	264
ae4efe19 SP	265	static void output_refs(struct ref *refs)
	266	{
	267	struct ref *posn;
	268	for (posn = refs; posn; posn = posn->next) {
	269	if (posn->symref)
	270	printf("@%s %s\n", posn->symref, posn->name);
	271	else
	272	printf("%s %s\n", sha1_to_hex(posn->old_sha1), posn->name);
	273	}
	274	printf("\n");
	275	fflush(stdout);
	276	free_refs(refs);
	277	}
	278
de1a2fdd SP	279	struct rpc_state {
	280	const char *service_name;
	281	const char **argv;
	282	char *service_url;
	283	char *hdr_content_type;
	284	char *hdr_accept;
	285	char *buf;
	286	size_t alloc;
	287	size_t len;
	288	size_t pos;
	289	int in;
	290	int out;
	291	struct strbuf result;
	292	};
	293
	294	static size_t rpc_out(void *ptr, size_t eltsize,
	295	size_t nmemb, void *buffer_)
	296	{
	297	size_t max = eltsize * nmemb;
	298	struct rpc_state *rpc = buffer_;
	299	size_t avail = rpc->len - rpc->pos;
	300
	301	if (!avail) {
	302	avail = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
	303	if (!avail)
	304	return 0;
	305	rpc->pos = 0;
	306	rpc->len = avail;
	307	}
	308
	309	if (max < avail);
	310	avail = max;
	311	memcpy(ptr, rpc->buf + rpc->pos, avail);
	312	rpc->pos += avail;
	313	return avail;
	314	}
	315
	316	static size_t rpc_in(const void *ptr, size_t eltsize,
	317	size_t nmemb, void *buffer_)
	318	{
	319	size_t size = eltsize * nmemb;
	320	struct rpc_state *rpc = buffer_;
	321	write_or_die(rpc->in, ptr, size);
	322	return size;
	323	}
	324
	325	static int post_rpc(struct rpc_state *rpc)
	326	{
	327	struct active_request_slot *slot;
	328	struct slot_results results;
	329	struct curl_slist *headers = NULL;
	330	int err = 0, large_request = 0;
	331
	332	/* Try to load the entire request, if we can fit it into the
	333	* allocated buffer space we can use HTTP/1.0 and avoid the
	334	* chunked encoding mess.
	335	*/
	336	while (1) {
	337	size_t left = rpc->alloc - rpc->len;
	338	char *buf = rpc->buf + rpc->len;
	339	int n;
	340
	341	if (left < LARGE_PACKET_MAX) {
	342	large_request = 1;
343	break;
344	}
345
346	n = packet_read_line(rpc->out, buf, left);
347	if (!n)
348	break;
349	rpc->len += n;
350	}
351
352	slot = get_active_slot();
353	slot->results = &results;
354
355	curl_easy_setopt(slot->curl, CURLOPT_POST, 1);
356	curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 0);
357	curl_easy_setopt(slot->curl, CURLOPT_URL, rpc->service_url);
358
359	headers = curl_slist_append(headers, rpc->hdr_content_type);
360	headers = curl_slist_append(headers, rpc->hdr_accept);
361
362	if (large_request) {
363	/* The request body is large and the size cannot be predicted.
364	* We must use chunked encoding to send it.
365	*/
366	headers = curl_slist_append(headers, "Expect: 100-continue");
367	headers = curl_slist_append(headers, "Transfer-Encoding: chunked");
368	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, rpc_out);
369	curl_easy_setopt(slot->curl, CURLOPT_INFILE, rpc);
370	if (options.verbosity > 1) {
371	fprintf(stderr, "POST %s (chunked)\n", rpc->service_name);
372	fflush(stderr);
373	}
374
375	} else {
376	/* We know the complete request size in advance, use the
377	* more normal Content-Length approach.
378	*/
379	curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDS, rpc->buf);
380	curl_easy_setopt(slot->curl, CURLOPT_POSTFIELDSIZE, rpc->len);
381	if (options.verbosity > 1) {
382	fprintf(stderr, "POST %s (%lu bytes)\n",
383	rpc->service_name, (unsigned long)rpc->len);
384	fflush(stderr);
385	}
386	}
387
388	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, headers);
389	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, rpc_in);
390	curl_easy_setopt(slot->curl, CURLOPT_FILE, rpc);
391
392	slot->curl_result = curl_easy_perform(slot->curl);
393	finish_active_slot(slot);
394
395	if (results.curl_result != CURLE_OK) {
396	err \|= error("RPC failed; result=%d, HTTP code = %ld",
397	results.curl_result, results.http_code);
398	}
399
400	curl_slist_free_all(headers);
401	return err;
402	}
403
404	static int rpc_service(struct rpc_state rpc, struct discovery heads)
405	{
406	const char *svc = rpc->service_name;
407	struct strbuf buf = STRBUF_INIT;
408	struct child_process client;
409	int err = 0;
410
411	init_walker();
412	memset(&client, 0, sizeof(client));
413	client.in = -1;
414	client.out = -1;
415	client.git_cmd = 1;
416	client.argv = rpc->argv;
417	if (start_command(&client))
418	exit(1);
419	if (heads)
420	write_or_die(client.in, heads->buf, heads->len);
421
422	rpc->alloc = http_post_buffer;
423	rpc->buf = xmalloc(rpc->alloc);
424	rpc->in = client.in;
425	rpc->out = client.out;
426	strbuf_init(&rpc->result, 0);
427
428	strbuf_addf(&buf, "%s/%s", url, svc);
429	rpc->service_url = strbuf_detach(&buf, NULL);
430
431	strbuf_addf(&buf, "Content-Type: application/x-%s-request", svc);
432	rpc->hdr_content_type = strbuf_detach(&buf, NULL);
433
434	strbuf_addf(&buf, "Accept: application/x-%s-response", svc);
435	rpc->hdr_accept = strbuf_detach(&buf, NULL);
436
437	while (!err) {
438	int n = packet_read_line(rpc->out, rpc->buf, rpc->alloc);
439	if (!n)
440	break;
441	rpc->pos = 0;
442	rpc->len = n;
443	err \|= post_rpc(rpc);
444	}
445	strbuf_read(&rpc->result, client.out, 0);
446
447	close(client.in);
448	close(client.out);
449	client.in = -1;
450	client.out = -1;
451
452	err \|= finish_command(&client);
453	free(rpc->service_url);
454	free(rpc->hdr_content_type);
455	free(rpc->hdr_accept);
456	free(rpc->buf);
457	strbuf_release(&buf);
458	return err;
459	}
460
292ce46b SP	461	static int fetch_dumb(int nr_heads, struct ref **to_fetch)
	462	{
	463	char *targets = xmalloc(nr_heads sizeof(char*));
	464	int ret, i;
	465
249b2004 SP	466	if (options.depth)
249b2004 SP	467	die("dumb http transport does not support --depth");
292ce46b SP	468	for (i = 0; i < nr_heads; i++)
	469	targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
	470
	471	init_walker();
	472	walker->get_all = 1;
	473	walker->get_tree = 1;
	474	walker->get_history = 1;
ef08ef9e	475	walker->get_verbosely = options.verbosity >= 3;
292ce46b SP	476	walker->get_recover = 0;
	477	ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);
	478
	479	for (i = 0; i < nr_heads; i++)
	480	free(targets[i]);
	481	free(targets);
	482
	483	return ret ? error("Fetch failed.") : 0;
	484	}
	485
249b2004 SP	486	static int fetch_git(struct discovery *heads,
	487	int nr_heads, struct ref **to_fetch)
	488	{
	489	struct rpc_state rpc;
	490	char *depth_arg = NULL;
	491	const char **argv;
	492	int argc = 0, i, err;
	493
	494	argv = xmalloc((15 + nr_heads) * sizeof(char*));
	495	argv[argc++] = "fetch-pack";
	496	argv[argc++] = "--stateless-rpc";
	497	argv[argc++] = "--lock-pack";
	498	if (options.followtags)
	499	argv[argc++] = "--include-tag";
	500	if (options.thin)
	501	argv[argc++] = "--thin";
	502	if (options.verbosity >= 3) {
	503	argv[argc++] = "-v";
	504	argv[argc++] = "-v";
	505	}
	506	if (!options.progress)
	507	argv[argc++] = "--no-progress";
	508	if (options.depth) {
	509	struct strbuf buf = STRBUF_INIT;
	510	strbuf_addf(&buf, "--depth=%lu", options.depth);
	511	depth_arg = strbuf_detach(&buf, NULL);
	512	argv[argc++] = depth_arg;
	513	}
	514	argv[argc++] = url;
	515	for (i = 0; i < nr_heads; i++) {
	516	struct ref *ref = to_fetch[i];
	517	if (!ref->name \|\| !*ref->name)
	518	die("cannot fetch by sha1 over smart http");
	519	argv[argc++] = ref->name;
	520	}
	521	argv[argc++] = NULL;
	522
	523	memset(&rpc, 0, sizeof(rpc));
	524	rpc.service_name = "git-upload-pack",
	525	rpc.argv = argv;
	526
	527	err = rpc_service(&rpc, heads);
	528	if (rpc.result.len)
	529	safe_write(1, rpc.result.buf, rpc.result.len);
	530	strbuf_release(&rpc.result);
	531	free(argv);
	532	free(depth_arg);
	533	return err;
	534	}
	535
	536	static int fetch(int nr_heads, struct ref **to_fetch)
	537	{
	538	struct discovery *d = discover_refs("git-upload-pack");
	539	if (d->proto_git)
	540	return fetch_git(d, nr_heads, to_fetch);
	541	else
	542	return fetch_dumb(nr_heads, to_fetch);
	543	}
	544
292ce46b SP	545	static void parse_fetch(struct strbuf *buf)
	546	{
	547	struct ref **to_fetch = NULL;
	548	struct ref *list_head = NULL;
	549	struct ref **list = &list_head;
	550	int alloc_heads = 0, nr_heads = 0;
	551
	552	do {
	553	if (!prefixcmp(buf->buf, "fetch ")) {
	554	char *p = buf->buf + strlen("fetch ");
	555	char *name;
	556	struct ref *ref;
	557	unsigned char old_sha1[20];
	558
	559	if (strlen(p) < 40 \|\| get_sha1_hex(p, old_sha1))
	560	die("protocol error: expected sha/ref, got %s'", p);
	561	if (p[40] == ' ')
	562	name = p + 41;
	563	else if (!p[40])
	564	name = "";
	565	else
	566	die("protocol error: expected sha/ref, got %s'", p);
	567
	568	ref = alloc_ref(name);
	569	hashcpy(ref->old_sha1, old_sha1);
	570
	571	*list = ref;
	572	list = &ref->next;
	573
	574	ALLOC_GROW(to_fetch, nr_heads + 1, alloc_heads);
	575	to_fetch[nr_heads++] = ref;
	576	}
	577	else
	578	die("http transport does not support %s", buf->buf);
	579
	580	strbuf_reset(buf);
	581	if (strbuf_getline(buf, stdin, '\n') == EOF)
	582	return;
	583	if (!*buf->buf)
	584	break;
	585	} while (1);
	586
249b2004	587	if (fetch(nr_heads, to_fetch))
292ce46b SP	588	exit(128); /* error already reported */
	589	free_refs(list_head);
	590	free(to_fetch);
	591
	592	printf("\n");
	593	fflush(stdout);
	594	strbuf_reset(buf);
	595	}
	596
ae4efe19 SP	597	static int push_dav(int nr_spec, char **specs)
	598	{
	599	const char *argv = xmalloc((10 + nr_spec) sizeof(char*));
	600	int argc = 0, i;
	601
	602	argv[argc++] = "http-push";
	603	argv[argc++] = "--helper-status";
	604	if (options.dry_run)
	605	argv[argc++] = "--dry-run";
	606	if (options.verbosity > 1)
	607	argv[argc++] = "--verbose";
	608	argv[argc++] = url;
	609	for (i = 0; i < nr_spec; i++)
	610	argv[argc++] = specs[i];
	611	argv[argc++] = NULL;
	612
	613	if (run_command_v_opt(argv, RUN_GIT_CMD))
	614	die("git-%s failed", argv[0]);
	615	free(argv);
	616	return 0;
	617	}
	618
de1a2fdd SP	619	static int push_git(struct discovery heads, int nr_spec, char *specs)
	620	{
	621	struct rpc_state rpc;
	622	const char **argv;
	623	int argc = 0, i, err;
	624
	625	argv = xmalloc((10 + nr_spec) * sizeof(char*));
	626	argv[argc++] = "send-pack";
	627	argv[argc++] = "--stateless-rpc";
	628	argv[argc++] = "--helper-status";
	629	if (options.thin)
	630	argv[argc++] = "--thin";
	631	if (options.dry_run)
	632	argv[argc++] = "--dry-run";
	633	if (options.verbosity > 1)
	634	argv[argc++] = "--verbose";
	635	argv[argc++] = url;
	636	for (i = 0; i < nr_spec; i++)
	637	argv[argc++] = specs[i];
	638	argv[argc++] = NULL;
	639
	640	memset(&rpc, 0, sizeof(rpc));
	641	rpc.service_name = "git-receive-pack",
	642	rpc.argv = argv;
	643
	644	err = rpc_service(&rpc, heads);
	645	if (rpc.result.len)
	646	safe_write(1, rpc.result.buf, rpc.result.len);
	647	strbuf_release(&rpc.result);
	648	free(argv);
	649	return err;
	650	}
	651
	652	static int push(int nr_spec, char **specs)
	653	{
	654	struct discovery *heads = discover_refs("git-receive-pack");
	655	int ret;
	656
	657	if (heads->proto_git)
	658	ret = push_git(heads, nr_spec, specs);
	659	else
	660	ret = push_dav(nr_spec, specs);
	661	free_discovery(heads);
	662	return ret;
	663	}
	664
ae4efe19 SP	665	static void parse_push(struct strbuf *buf)
	666	{
	667	char **specs = NULL;
	668	int alloc_spec = 0, nr_spec = 0, i;
	669
	670	do {
	671	if (!prefixcmp(buf->buf, "push ")) {
	672	ALLOC_GROW(specs, nr_spec + 1, alloc_spec);
	673	specs[nr_spec++] = xstrdup(buf->buf + 5);
	674	}
	675	else
	676	die("http transport does not support %s", buf->buf);
	677
	678	strbuf_reset(buf);
	679	if (strbuf_getline(buf, stdin, '\n') == EOF)
	680	return;
	681	if (!*buf->buf)
	682	break;
	683	} while (1);
	684
de1a2fdd	685	if (push(nr_spec, specs))
ae4efe19 SP	686	exit(128); /* error already reported */
	687	for (i = 0; i < nr_spec; i++)
	688	free(specs[i]);
	689	free(specs);
	690
	691	printf("\n");
	692	fflush(stdout);
	693	}
	694
a2d725b7 DB	695	int main(int argc, const char **argv)
a2d725b7 DB	696	{
a2d725b7	697	struct strbuf buf = STRBUF_INIT;
a2d725b7	698
c6dfb399	699	git_extract_argv0_path(argv[0]);
a2d725b7 DB	700	setup_git_directory();
	701	if (argc < 2) {
	702	fprintf(stderr, "Remote needed\n");
	703	return 1;
	704	}
	705
ef08ef9e SP	706	options.verbosity = 1;
ef08ef9e SP	707	options.progress = !!isatty(2);
de1a2fdd	708	options.thin = 1;
ef08ef9e	709
a2d725b7 DB	710	remote = remote_get(argv[1]);
	711
	712	if (argc > 2) {
	713	url = argv[2];
	714	} else {
	715	url = remote->url[0];
	716	}
	717
	718	do {
	719	if (strbuf_getline(&buf, stdin, '\n') == EOF)
	720	break;
	721	if (!prefixcmp(buf.buf, "fetch ")) {
292ce46b SP	722	parse_fetch(&buf);
292ce46b SP	723
ae4efe19	724	} else if (!strcmp(buf.buf, "list") \|\| !prefixcmp(buf.buf, "list ")) {
97cc7bc4 SP	725	int for_push = !!strstr(buf.buf + 4, "for-push");
97cc7bc4 SP	726	output_refs(get_refs(for_push));
ae4efe19 SP	727
	728	} else if (!prefixcmp(buf.buf, "push ")) {
	729	parse_push(&buf);
	730
ef08ef9e SP	731	} else if (!prefixcmp(buf.buf, "option ")) {
	732	char *name = buf.buf + strlen("option ");
	733	char *value = strchr(name, ' ');
	734	int result;
	735
	736	if (value)
	737	*value++ = '\0';
	738	else
	739	value = "true";
	740
	741	result = set_option(name, value);
	742	if (!result)
	743	printf("ok\n");
	744	else if (result < 0)
	745	printf("error invalid value\n");
	746	else
	747	printf("unsupported\n");
	748	fflush(stdout);
	749
a2d725b7 DB	750	} else if (!strcmp(buf.buf, "capabilities")) {
a2d725b7 DB	751	printf("fetch\n");
ef08ef9e	752	printf("option\n");
ae4efe19	753	printf("push\n");
a2d725b7 DB	754	printf("\n");
	755	fflush(stdout);
	756	} else {
	757	return 1;
	758	}
	759	strbuf_reset(&buf);
	760	} while (1);
	761	return 0;
	762	}