[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"

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;
};
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 1 /* TODO implement later */;
	}
	else if (!strcmp(name, "depth")) {
		char *end;
		unsigned long v = strtoul(value, &end, 10);
		if (value == end || *end)
			return -1;
		options.depth = v;
		return 1 /* TODO implement later */;
	}
	else if (!strcmp(name, "followtags")) {
		if (!strcmp(value, "true"))
			options.followtags = 1;
		else if (!strcmp(value, "false"))
			options.followtags = 0;
		else
			return -1;
		return 1 /* TODO implement later */;
	}
	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 */;
	}
}

static struct ref *get_refs(void)
{
	struct strbuf buffer = STRBUF_INIT;
	char *data, *start, *mid;
	char *ref_name;
	char *refs_url;
	int i = 0;
	int http_ret;

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

	refs_url = xmalloc(strlen(url) + 11);
	sprintf(refs_url, "%s/info/refs", url);

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

	data = buffer.buf;
	start = NULL;
	mid = data;
	while (i < buffer.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++;
	}

	strbuf_release(&buffer);

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

	strbuf_release(&buffer);
	free(refs_url);
	return refs;
}

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

static int fetch_dumb(int nr_heads, struct ref **to_fetch)
{
	char **targets = xmalloc(nr_heads * sizeof(char*));
	int ret, i;

	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 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_dumb(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 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_dav(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);

	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 ")) {
			output_refs(get_refs());

		} 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"
a2d725b7	8
37a8768f SP	9	static struct remote *remote;
	10	static const char *url;
	11	static struct walker *walker;
	12
ef08ef9e SP	13	struct options {
	14	int verbosity;
	15	unsigned long depth;
	16	unsigned progress : 1,
ae4efe19 SP	17	followtags : 1,
ae4efe19 SP	18	dry_run : 1;
ef08ef9e SP	19	};
	20	static struct options options;
	21
37a8768f SP	22	static void init_walker(void)
	23	{
	24	if (!walker)
	25	walker = get_http_walker(url, remote);
	26	}
	27
ef08ef9e SP	28	static int set_option(const char name, const char value)
	29	{
	30	if (!strcmp(name, "verbosity")) {
	31	char *end;
	32	int v = strtol(value, &end, 10);
	33	if (value == end \|\| *end)
	34	return -1;
	35	options.verbosity = v;
	36	return 0;
	37	}
	38	else if (!strcmp(name, "progress")) {
	39	if (!strcmp(value, "true"))
	40	options.progress = 1;
	41	else if (!strcmp(value, "false"))
	42	options.progress = 0;
	43	else
	44	return -1;
	45	return 1 /* TODO implement later */;
	46	}
	47	else if (!strcmp(name, "depth")) {
	48	char *end;
	49	unsigned long v = strtoul(value, &end, 10);
	50	if (value == end \|\| *end)
	51	return -1;
	52	options.depth = v;
	53	return 1 /* TODO implement later */;
	54	}
	55	else if (!strcmp(name, "followtags")) {
	56	if (!strcmp(value, "true"))
	57	options.followtags = 1;
	58	else if (!strcmp(value, "false"))
	59	options.followtags = 0;
	60	else
	61	return -1;
	62	return 1 /* TODO implement later */;
	63	}
ae4efe19 SP	64	else if (!strcmp(name, "dry-run")) {
	65	if (!strcmp(value, "true"))
	66	options.dry_run = 1;
	67	else if (!strcmp(value, "false"))
	68	options.dry_run = 0;
	69	else
	70	return -1;
	71	return 0;
	72	}
ef08ef9e SP	73	else {
	74	return 1 /* unsupported */;
	75	}
	76	}
	77
37a8768f	78	static struct ref *get_refs(void)
a2d725b7 DB	79	{
	80	struct strbuf buffer = STRBUF_INIT;
	81	char data, start, *mid;
	82	char *ref_name;
	83	char *refs_url;
	84	int i = 0;
	85	int http_ret;
	86
	87	struct ref *refs = NULL;
	88	struct ref *ref = NULL;
	89	struct ref *last_ref = NULL;
	90
	91	refs_url = xmalloc(strlen(url) + 11);
	92	sprintf(refs_url, "%s/info/refs", url);
	93
37a8768f	94	init_walker();
a2d725b7 DB	95	http_ret = http_get_strbuf(refs_url, &buffer, HTTP_NO_CACHE);
	96	switch (http_ret) {
	97	case HTTP_OK:
	98	break;
	99	case HTTP_MISSING_TARGET:
	100	die("%s not found: did you run git update-server-info on the"
	101	" server?", refs_url);
	102	default:
	103	http_error(refs_url, http_ret);
	104	die("HTTP request failed");
	105	}
	106
	107	data = buffer.buf;
	108	start = NULL;
	109	mid = data;
	110	while (i < buffer.len) {
	111	if (!start) {
	112	start = &data[i];
	113	}
	114	if (data[i] == '\t')
	115	mid = &data[i];
	116	if (data[i] == '\n') {
	117	data[i] = 0;
	118	ref_name = mid + 1;
	119	ref = xmalloc(sizeof(struct ref) +
	120	strlen(ref_name) + 1);
	121	memset(ref, 0, sizeof(struct ref));
	122	strcpy(ref->name, ref_name);
	123	get_sha1_hex(start, ref->old_sha1);
	124	if (!refs)
	125	refs = ref;
	126	if (last_ref)
	127	last_ref->next = ref;
	128	last_ref = ref;
	129	start = NULL;
	130	}
	131	i++;
	132	}
	133
	134	strbuf_release(&buffer);
	135
	136	ref = alloc_ref("HEAD");
	137	if (!walker->fetch_ref(walker, ref) &&
	138	!resolve_remote_symref(ref, refs)) {
	139	ref->next = refs;
	140	refs = ref;
	141	} else {
	142	free(ref);
	143	}
	144
	145	strbuf_release(&buffer);
	146	free(refs_url);
	147	return refs;
	148	}
	149
ae4efe19 SP	150	static void output_refs(struct ref *refs)
	151	{
	152	struct ref *posn;
	153	for (posn = refs; posn; posn = posn->next) {
	154	if (posn->symref)
	155	printf("@%s %s\n", posn->symref, posn->name);
	156	else
	157	printf("%s %s\n", sha1_to_hex(posn->old_sha1), posn->name);
	158	}
	159	printf("\n");
	160	fflush(stdout);
	161	free_refs(refs);
	162	}
	163
292ce46b SP	164	static int fetch_dumb(int nr_heads, struct ref **to_fetch)
	165	{
	166	char *targets = xmalloc(nr_heads sizeof(char*));
	167	int ret, i;
	168
	169	for (i = 0; i < nr_heads; i++)
	170	targets[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
	171
	172	init_walker();
	173	walker->get_all = 1;
	174	walker->get_tree = 1;
	175	walker->get_history = 1;
ef08ef9e	176	walker->get_verbosely = options.verbosity >= 3;
292ce46b SP	177	walker->get_recover = 0;
	178	ret = walker_fetch(walker, nr_heads, targets, NULL, NULL);
	179
	180	for (i = 0; i < nr_heads; i++)
	181	free(targets[i]);
	182	free(targets);
	183
	184	return ret ? error("Fetch failed.") : 0;
	185	}
	186
	187	static void parse_fetch(struct strbuf *buf)
	188	{
	189	struct ref **to_fetch = NULL;
	190	struct ref *list_head = NULL;
	191	struct ref **list = &list_head;
	192	int alloc_heads = 0, nr_heads = 0;
	193
	194	do {
	195	if (!prefixcmp(buf->buf, "fetch ")) {
	196	char *p = buf->buf + strlen("fetch ");
	197	char *name;
	198	struct ref *ref;
	199	unsigned char old_sha1[20];
	200
	201	if (strlen(p) < 40 \|\| get_sha1_hex(p, old_sha1))
	202	die("protocol error: expected sha/ref, got %s'", p);
	203	if (p[40] == ' ')
	204	name = p + 41;
	205	else if (!p[40])
	206	name = "";
	207	else
	208	die("protocol error: expected sha/ref, got %s'", p);
	209
	210	ref = alloc_ref(name);
	211	hashcpy(ref->old_sha1, old_sha1);
	212
	213	*list = ref;
	214	list = &ref->next;
	215
	216	ALLOC_GROW(to_fetch, nr_heads + 1, alloc_heads);
	217	to_fetch[nr_heads++] = ref;
	218	}
	219	else
	220	die("http transport does not support %s", buf->buf);
	221
	222	strbuf_reset(buf);
	223	if (strbuf_getline(buf, stdin, '\n') == EOF)
	224	return;
	225	if (!*buf->buf)
	226	break;
	227	} while (1);
	228
	229	if (fetch_dumb(nr_heads, to_fetch))
	230	exit(128); /* error already reported */
	231	free_refs(list_head);
	232	free(to_fetch);
	233
	234	printf("\n");
	235	fflush(stdout);
	236	strbuf_reset(buf);
	237	}
	238
ae4efe19 SP	239	static int push_dav(int nr_spec, char **specs)
	240	{
	241	const char *argv = xmalloc((10 + nr_spec) sizeof(char*));
	242	int argc = 0, i;
	243
	244	argv[argc++] = "http-push";
	245	argv[argc++] = "--helper-status";
	246	if (options.dry_run)
	247	argv[argc++] = "--dry-run";
	248	if (options.verbosity > 1)
	249	argv[argc++] = "--verbose";
	250	argv[argc++] = url;
	251	for (i = 0; i < nr_spec; i++)
	252	argv[argc++] = specs[i];
	253	argv[argc++] = NULL;
	254
	255	if (run_command_v_opt(argv, RUN_GIT_CMD))
	256	die("git-%s failed", argv[0]);
	257	free(argv);
	258	return 0;
	259	}
	260
	261	static void parse_push(struct strbuf *buf)
	262	{
	263	char **specs = NULL;
	264	int alloc_spec = 0, nr_spec = 0, i;
	265
	266	do {
	267	if (!prefixcmp(buf->buf, "push ")) {
	268	ALLOC_GROW(specs, nr_spec + 1, alloc_spec);
	269	specs[nr_spec++] = xstrdup(buf->buf + 5);
	270	}
	271	else
	272	die("http transport does not support %s", buf->buf);
	273
	274	strbuf_reset(buf);
	275	if (strbuf_getline(buf, stdin, '\n') == EOF)
	276	return;
	277	if (!*buf->buf)
	278	break;
	279	} while (1);
	280
	281	if (push_dav(nr_spec, specs))
	282	exit(128); /* error already reported */
	283	for (i = 0; i < nr_spec; i++)
	284	free(specs[i]);
	285	free(specs);
	286
	287	printf("\n");
	288	fflush(stdout);
	289	}
	290
a2d725b7 DB	291	int main(int argc, const char **argv)
a2d725b7 DB	292	{
a2d725b7	293	struct strbuf buf = STRBUF_INIT;
a2d725b7	294
c6dfb399	295	git_extract_argv0_path(argv[0]);
a2d725b7 DB	296	setup_git_directory();
	297	if (argc < 2) {
	298	fprintf(stderr, "Remote needed\n");
	299	return 1;
	300	}
	301
ef08ef9e SP	302	options.verbosity = 1;
	303	options.progress = !!isatty(2);
	304
a2d725b7 DB	305	remote = remote_get(argv[1]);
	306
	307	if (argc > 2) {
	308	url = argv[2];
	309	} else {
	310	url = remote->url[0];
	311	}
	312
	313	do {
	314	if (strbuf_getline(&buf, stdin, '\n') == EOF)
	315	break;
	316	if (!prefixcmp(buf.buf, "fetch ")) {
292ce46b SP	317	parse_fetch(&buf);
292ce46b SP	318
ae4efe19 SP	319	} else if (!strcmp(buf.buf, "list") \|\| !prefixcmp(buf.buf, "list ")) {
	320	output_refs(get_refs());
	321
	322	} else if (!prefixcmp(buf.buf, "push ")) {
	323	parse_push(&buf);
	324
ef08ef9e SP	325	} else if (!prefixcmp(buf.buf, "option ")) {
	326	char *name = buf.buf + strlen("option ");
	327	char *value = strchr(name, ' ');
	328	int result;
	329
	330	if (value)
	331	*value++ = '\0';
	332	else
	333	value = "true";
	334
	335	result = set_option(name, value);
	336	if (!result)
	337	printf("ok\n");
	338	else if (result < 0)
	339	printf("error invalid value\n");
	340	else
	341	printf("unsupported\n");
	342	fflush(stdout);
	343
a2d725b7 DB	344	} else if (!strcmp(buf.buf, "capabilities")) {
a2d725b7 DB	345	printf("fetch\n");
ef08ef9e	346	printf("option\n");
ae4efe19	347	printf("push\n");
a2d725b7 DB	348	printf("\n");
	349	fflush(stdout);
	350	} else {
	351	return 1;
	352	}
	353	strbuf_reset(&buf);
	354	} while (1);
	355	return 0;
	356	}