[thirdparty/git.git] / transport-helper.c

#include "cache.h"
#include "transport.h"
#include "quote.h"
#include "run-command.h"
#include "commit.h"
#include "diff.h"
#include "revision.h"
#include "quote.h"
#include "remote.h"

struct helper_data
{
	const char *name;
	struct child_process *helper;
	FILE *out;
	unsigned fetch : 1,
		import : 1,
		option : 1,
		push : 1;
	/* These go from remote name (as in "list") to private name */
	struct refspec *refspecs;
	int refspec_nr;
};

static struct child_process *get_helper(struct transport *transport)
{
	struct helper_data *data = transport->data;
	struct strbuf buf = STRBUF_INIT;
	struct child_process *helper;
	const char **refspecs = NULL;
	int refspec_nr = 0;
	int refspec_alloc = 0;

	if (data->helper)
		return data->helper;

	helper = xcalloc(1, sizeof(*helper));
	helper->in = -1;
	helper->out = -1;
	helper->err = 0;
	helper->argv = xcalloc(4, sizeof(*helper->argv));
	strbuf_addf(&buf, "remote-%s", data->name);
	helper->argv[0] = strbuf_detach(&buf, NULL);
	helper->argv[1] = transport->remote->name;
	helper->argv[2] = transport->url;
	helper->git_cmd = 1;
	if (start_command(helper))
		die("Unable to run helper: git %s", helper->argv[0]);
	data->helper = helper;

	write_str_in_full(helper->in, "capabilities\n");

	data->out = xfdopen(helper->out, "r");
	while (1) {
		if (strbuf_getline(&buf, data->out, '\n') == EOF)
			exit(128); /* child died, message supplied already */

		if (!*buf.buf)
			break;
		if (!strcmp(buf.buf, "fetch"))
			data->fetch = 1;
		if (!strcmp(buf.buf, "option"))
			data->option = 1;
		if (!strcmp(buf.buf, "push"))
			data->push = 1;
		if (!strcmp(buf.buf, "import"))
			data->import = 1;
		if (!data->refspecs && !prefixcmp(buf.buf, "refspec ")) {
			ALLOC_GROW(refspecs,
				   refspec_nr + 1,
				   refspec_alloc);
			refspecs[refspec_nr++] = strdup(buf.buf + strlen("refspec "));
		}
	}
	if (refspecs) {
		int i;
		data->refspec_nr = refspec_nr;
		data->refspecs = parse_fetch_refspec(refspec_nr, refspecs);
		for (i = 0; i < refspec_nr; i++) {
			free((char *)refspecs[i]);
		}
		free(refspecs);
	}
	strbuf_release(&buf);
	return data->helper;
}

static int disconnect_helper(struct transport *transport)
{
	struct helper_data *data = transport->data;
	if (data->helper) {
		write_str_in_full(data->helper->in, "\n");
		close(data->helper->in);
		fclose(data->out);
		finish_command(data->helper);
		free((char *)data->helper->argv[0]);
		free(data->helper->argv);
		free(data->helper);
		data->helper = NULL;
	}
	return 0;
}

static const char *unsupported_options[] = {
	TRANS_OPT_UPLOADPACK,
	TRANS_OPT_RECEIVEPACK,
	TRANS_OPT_THIN,
	TRANS_OPT_KEEP
	};
static const char *boolean_options[] = {
	TRANS_OPT_THIN,
	TRANS_OPT_KEEP,
	TRANS_OPT_FOLLOWTAGS
	};

static int set_helper_option(struct transport *transport,
			  const char *name, const char *value)
{
	struct helper_data *data = transport->data;
	struct child_process *helper = get_helper(transport);
	struct strbuf buf = STRBUF_INIT;
	int i, ret, is_bool = 0;

	if (!data->option)
		return 1;

	for (i = 0; i < ARRAY_SIZE(unsupported_options); i++) {
		if (!strcmp(name, unsupported_options[i]))
			return 1;
	}

	for (i = 0; i < ARRAY_SIZE(boolean_options); i++) {
		if (!strcmp(name, boolean_options[i])) {
			is_bool = 1;
			break;
		}
	}

	strbuf_addf(&buf, "option %s ", name);
	if (is_bool)
		strbuf_addstr(&buf, value ? "true" : "false");
	else
		quote_c_style(value, &buf, NULL, 0);
	strbuf_addch(&buf, '\n');

	if (write_in_full(helper->in, buf.buf, buf.len) != buf.len)
		die_errno("cannot send option to %s", data->name);

	strbuf_reset(&buf);
	if (strbuf_getline(&buf, data->out, '\n') == EOF)
		exit(128); /* child died, message supplied already */

	if (!strcmp(buf.buf, "ok"))
		ret = 0;
	else if (!prefixcmp(buf.buf, "error")) {
		ret = -1;
	} else if (!strcmp(buf.buf, "unsupported"))
		ret = 1;
	else {
		warning("%s unexpectedly said: '%s'", data->name, buf.buf);
		ret = 1;
	}
	strbuf_release(&buf);
	return ret;
}

static void standard_options(struct transport *t)
{
	char buf[16];
	int n;
	int v = t->verbose;
	int no_progress = v < 0 || (!t->progress && !isatty(1));

	set_helper_option(t, "progress", !no_progress ? "true" : "false");

	n = snprintf(buf, sizeof(buf), "%d", v + 1);
	if (n >= sizeof(buf))
		die("impossibly large verbosity value");
	set_helper_option(t, "verbosity", buf);
}

static int release_helper(struct transport *transport)
{
	struct helper_data *data = transport->data;
	free_refspec(data->refspec_nr, data->refspecs);
	data->refspecs = NULL;
	disconnect_helper(transport);
	free(transport->data);
	return 0;
}

static int fetch_with_fetch(struct transport *transport,
			    int nr_heads, struct ref **to_fetch)
{
	struct helper_data *data = transport->data;
	int i;
	struct strbuf buf = STRBUF_INIT;

	standard_options(transport);

	for (i = 0; i < nr_heads; i++) {
		const struct ref *posn = to_fetch[i];
		if (posn->status & REF_STATUS_UPTODATE)
			continue;

		strbuf_addf(&buf, "fetch %s %s\n",
			    sha1_to_hex(posn->old_sha1), posn->name);
	}

	strbuf_addch(&buf, '\n');
	if (write_in_full(data->helper->in, buf.buf, buf.len) != buf.len)
		die_errno("cannot send fetch to %s", data->name);

	while (1) {
		strbuf_reset(&buf);
		if (strbuf_getline(&buf, data->out, '\n') == EOF)
			exit(128); /* child died, message supplied already */

		if (!prefixcmp(buf.buf, "lock ")) {
			const char *name = buf.buf + 5;
			if (transport->pack_lockfile)
				warning("%s also locked %s", data->name, name);
			else
				transport->pack_lockfile = xstrdup(name);
		}
		else if (!buf.len)
			break;
		else
			warning("%s unexpectedly said: '%s'", data->name, buf.buf);
	}
	strbuf_release(&buf);
	return 0;
}

static int get_importer(struct transport *transport, struct child_process *fastimport)
{
	struct child_process *helper = get_helper(transport);
	memset(fastimport, 0, sizeof(*fastimport));
	fastimport->in = helper->out;
	fastimport->argv = xcalloc(5, sizeof(*fastimport->argv));
	fastimport->argv[0] = "fast-import";
	fastimport->argv[1] = "--quiet";

	fastimport->git_cmd = 1;
	return start_command(fastimport);
}

static int fetch_with_import(struct transport *transport,
			     int nr_heads, struct ref **to_fetch)
{
	struct child_process fastimport;
	struct child_process *helper = get_helper(transport);
	struct helper_data *data = transport->data;
	int i;
	struct ref *posn;
	struct strbuf buf = STRBUF_INIT;

	if (get_importer(transport, &fastimport))
		die("Couldn't run fast-import");

	for (i = 0; i < nr_heads; i++) {
		posn = to_fetch[i];
		if (posn->status & REF_STATUS_UPTODATE)
			continue;

		strbuf_addf(&buf, "import %s\n", posn->name);
		write_in_full(helper->in, buf.buf, buf.len);
		strbuf_reset(&buf);
	}
	disconnect_helper(transport);
	finish_command(&fastimport);
	free(fastimport.argv);
	fastimport.argv = NULL;

	for (i = 0; i < nr_heads; i++) {
		char *private;
		posn = to_fetch[i];
		if (posn->status & REF_STATUS_UPTODATE)
			continue;
		if (data->refspecs)
			private = apply_refspecs(data->refspecs, data->refspec_nr, posn->name);
		else
			private = strdup(posn->name);
		read_ref(private, posn->old_sha1);
		free(private);
	}
	strbuf_release(&buf);
	return 0;
}

static int fetch(struct transport *transport,
		 int nr_heads, struct ref **to_fetch)
{
	struct helper_data *data = transport->data;
	int i, count;

	count = 0;
	for (i = 0; i < nr_heads; i++)
		if (!(to_fetch[i]->status & REF_STATUS_UPTODATE))
			count++;

	if (!count)
		return 0;

	if (data->fetch)
		return fetch_with_fetch(transport, nr_heads, to_fetch);

	if (data->import)
		return fetch_with_import(transport, nr_heads, to_fetch);

	return -1;
}

static int push_refs(struct transport *transport,
		struct ref *remote_refs, int flags)
{
	int force_all = flags & TRANSPORT_PUSH_FORCE;
	int mirror = flags & TRANSPORT_PUSH_MIRROR;
	struct helper_data *data = transport->data;
	struct strbuf buf = STRBUF_INIT;
	struct child_process *helper;
	struct ref *ref;

	if (!remote_refs)
		return 0;

	helper = get_helper(transport);
	if (!data->push)
		return 1;

	for (ref = remote_refs; ref; ref = ref->next) {
		if (ref->peer_ref)
			hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
		else if (!mirror)
			continue;

		ref->deletion = is_null_sha1(ref->new_sha1);
		if (!ref->deletion &&
			!hashcmp(ref->old_sha1, ref->new_sha1)) {
			ref->status = REF_STATUS_UPTODATE;
			continue;
		}

		if (force_all)
			ref->force = 1;

		strbuf_addstr(&buf, "push ");
		if (!ref->deletion) {
			if (ref->force)
				strbuf_addch(&buf, '+');
			if (ref->peer_ref)
				strbuf_addstr(&buf, ref->peer_ref->name);
			else
				strbuf_addstr(&buf, sha1_to_hex(ref->new_sha1));
		}
		strbuf_addch(&buf, ':');
		strbuf_addstr(&buf, ref->name);
		strbuf_addch(&buf, '\n');
	}
	if (buf.len == 0)
		return 0;

	transport->verbose = flags & TRANSPORT_PUSH_VERBOSE ? 1 : 0;
	standard_options(transport);

	if (flags & TRANSPORT_PUSH_DRY_RUN) {
		if (set_helper_option(transport, "dry-run", "true") != 0)
			die("helper %s does not support dry-run", data->name);
	}

	strbuf_addch(&buf, '\n');
	if (write_in_full(helper->in, buf.buf, buf.len) != buf.len)
		exit(128);

	ref = remote_refs;
	while (1) {
		char *refname, *msg;
		int status;

		strbuf_reset(&buf);
		if (strbuf_getline(&buf, data->out, '\n') == EOF)
			exit(128); /* child died, message supplied already */
		if (!buf.len)
			break;

		if (!prefixcmp(buf.buf, "ok ")) {
			status = REF_STATUS_OK;
			refname = buf.buf + 3;
		} else if (!prefixcmp(buf.buf, "error ")) {
			status = REF_STATUS_REMOTE_REJECT;
			refname = buf.buf + 6;
		} else
			die("expected ok/error, helper said '%s'\n", buf.buf);

		msg = strchr(refname, ' ');
		if (msg) {
			struct strbuf msg_buf = STRBUF_INIT;
			const char *end;

			*msg++ = '\0';
			if (!unquote_c_style(&msg_buf, msg, &end))
				msg = strbuf_detach(&msg_buf, NULL);
			else
				msg = xstrdup(msg);
			strbuf_release(&msg_buf);

			if (!strcmp(msg, "no match")) {
				status = REF_STATUS_NONE;
				free(msg);
				msg = NULL;
			}
			else if (!strcmp(msg, "up to date")) {
				status = REF_STATUS_UPTODATE;
				free(msg);
				msg = NULL;
			}
			else if (!strcmp(msg, "non-fast forward")) {
				status = REF_STATUS_REJECT_NONFASTFORWARD;
				free(msg);
				msg = NULL;
			}
		}

		if (ref)
			ref = find_ref_by_name(ref, refname);
		if (!ref)
			ref = find_ref_by_name(remote_refs, refname);
		if (!ref) {
			warning("helper reported unexpected status of %s", refname);
			continue;
		}

		ref->status = status;
		ref->remote_status = msg;
	}
	strbuf_release(&buf);
	return 0;
}

static int has_attribute(const char *attrs, const char *attr) {
	int len;
	if (!attrs)
		return 0;

	len = strlen(attr);
	for (;;) {
		const char *space = strchrnul(attrs, ' ');
		if (len == space - attrs && !strncmp(attrs, attr, len))
			return 1;
		if (!*space)
			return 0;
		attrs = space + 1;
	}
}

static struct ref *get_refs_list(struct transport *transport, int for_push)
{
	struct helper_data *data = transport->data;
	struct child_process *helper;
	struct ref *ret = NULL;
	struct ref **tail = &ret;
	struct ref *posn;
	struct strbuf buf = STRBUF_INIT;

	helper = get_helper(transport);

	if (data->push && for_push)
		write_str_in_full(helper->in, "list for-push\n");
	else
		write_str_in_full(helper->in, "list\n");

	while (1) {
		char *eov, *eon;
		if (strbuf_getline(&buf, data->out, '\n') == EOF)
			exit(128); /* child died, message supplied already */

		if (!*buf.buf)
			break;

		eov = strchr(buf.buf, ' ');
		if (!eov)
			die("Malformed response in ref list: %s", buf.buf);
		eon = strchr(eov + 1, ' ');
		*eov = '\0';
		if (eon)
			*eon = '\0';
		*tail = alloc_ref(eov + 1);
		if (buf.buf[0] == '@')
			(*tail)->symref = xstrdup(buf.buf + 1);
		else if (buf.buf[0] != '?')
			get_sha1_hex(buf.buf, (*tail)->old_sha1);
		if (eon) {
			if (has_attribute(eon + 1, "unchanged")) {
				(*tail)->status |= REF_STATUS_UPTODATE;
				read_ref((*tail)->name, (*tail)->old_sha1);
			}
		}
		tail = &((*tail)->next);
	}
	strbuf_release(&buf);

	for (posn = ret; posn; posn = posn->next)
		resolve_remote_symref(posn, ret);

	return ret;
}

int transport_helper_init(struct transport *transport, const char *name)
{
	struct helper_data *data = xcalloc(sizeof(*data), 1);
	data->name = name;

	transport->data = data;
	transport->set_option = set_helper_option;
	transport->get_refs_list = get_refs_list;
	transport->fetch = fetch;
	transport->push_refs = push_refs;
	transport->disconnect = release_helper;
	return 0;
}
Commit	Line	Data
6eb996b5 DB	1	#include "cache.h"
6eb996b5 DB	2	#include "transport.h"
ae4efe19	3	#include "quote.h"
6eb996b5 DB	4	#include "run-command.h"
	5	#include "commit.h"
	6	#include "diff.h"
	7	#include "revision.h"
ef08ef9e	8	#include "quote.h"
72ff8943	9	#include "remote.h"
6eb996b5 DB	10
	11	struct helper_data
	12	{
	13	const char *name;
	14	struct child_process *helper;
292ce46b	15	FILE *out;
ef08ef9e	16	unsigned fetch : 1,
a24a32dd	17	import : 1,
ae4efe19 SP	18	option : 1,
ae4efe19 SP	19	push : 1;
72ff8943 DB	20	/* These go from remote name (as in "list") to private name */
	21	struct refspec *refspecs;
	22	int refspec_nr;
6eb996b5 DB	23	};
	24
	25	static struct child_process get_helper(struct transport transport)
	26	{
	27	struct helper_data *data = transport->data;
	28	struct strbuf buf = STRBUF_INIT;
	29	struct child_process *helper;
72ff8943 DB	30	const char **refspecs = NULL;
	31	int refspec_nr = 0;
	32	int refspec_alloc = 0;
6eb996b5 DB	33
	34	if (data->helper)
	35	return data->helper;
	36
	37	helper = xcalloc(1, sizeof(*helper));
	38	helper->in = -1;
	39	helper->out = -1;
	40	helper->err = 0;
	41	helper->argv = xcalloc(4, sizeof(*helper->argv));
	42	strbuf_addf(&buf, "remote-%s", data->name);
	43	helper->argv[0] = strbuf_detach(&buf, NULL);
	44	helper->argv[1] = transport->remote->name;
	45	helper->argv[2] = transport->url;
	46	helper->git_cmd = 1;
	47	if (start_command(helper))
	48	die("Unable to run helper: git %s", helper->argv[0]);
	49	data->helper = helper;
	50
3d913526	51	write_str_in_full(helper->in, "capabilities\n");
2d14d65c	52
292ce46b	53	data->out = xfdopen(helper->out, "r");
6eb996b5	54	while (1) {
292ce46b	55	if (strbuf_getline(&buf, data->out, '\n') == EOF)
6eb996b5 DB	56	exit(128); /* child died, message supplied already */
	57
	58	if (!*buf.buf)
	59	break;
	60	if (!strcmp(buf.buf, "fetch"))
	61	data->fetch = 1;
ef08ef9e SP	62	if (!strcmp(buf.buf, "option"))
ef08ef9e SP	63	data->option = 1;
ae4efe19 SP	64	if (!strcmp(buf.buf, "push"))
ae4efe19 SP	65	data->push = 1;
e65e91ed DB	66	if (!strcmp(buf.buf, "import"))
e65e91ed DB	67	data->import = 1;
72ff8943 DB	68	if (!data->refspecs && !prefixcmp(buf.buf, "refspec ")) {
	69	ALLOC_GROW(refspecs,
	70	refspec_nr + 1,
	71	refspec_alloc);
	72	refspecs[refspec_nr++] = strdup(buf.buf + strlen("refspec "));
	73	}
	74	}
	75	if (refspecs) {
	76	int i;
	77	data->refspec_nr = refspec_nr;
	78	data->refspecs = parse_fetch_refspec(refspec_nr, refspecs);
	79	for (i = 0; i < refspec_nr; i++) {
	80	free((char *)refspecs[i]);
	81	}
	82	free(refspecs);
6eb996b5	83	}
b962dbdc	84	strbuf_release(&buf);
6eb996b5 DB	85	return data->helper;
	86	}
	87
	88	static int disconnect_helper(struct transport *transport)
	89	{
	90	struct helper_data *data = transport->data;
	91	if (data->helper) {
3d913526	92	write_str_in_full(data->helper->in, "\n");
6eb996b5	93	close(data->helper->in);
292ce46b	94	fclose(data->out);
6eb996b5 DB	95	finish_command(data->helper);
	96	free((char *)data->helper->argv[0]);
	97	free(data->helper->argv);
	98	free(data->helper);
	99	data->helper = NULL;
	100	}
	101	return 0;
	102	}
	103
ef08ef9e SP	104	static const char *unsupported_options[] = {
	105	TRANS_OPT_UPLOADPACK,
	106	TRANS_OPT_RECEIVEPACK,
	107	TRANS_OPT_THIN,
	108	TRANS_OPT_KEEP
	109	};
	110	static const char *boolean_options[] = {
	111	TRANS_OPT_THIN,
	112	TRANS_OPT_KEEP,
	113	TRANS_OPT_FOLLOWTAGS
	114	};
	115
	116	static int set_helper_option(struct transport *transport,
	117	const char name, const char value)
	118	{
	119	struct helper_data *data = transport->data;
	120	struct child_process *helper = get_helper(transport);
	121	struct strbuf buf = STRBUF_INIT;
	122	int i, ret, is_bool = 0;
	123
	124	if (!data->option)
	125	return 1;
	126
	127	for (i = 0; i < ARRAY_SIZE(unsupported_options); i++) {
	128	if (!strcmp(name, unsupported_options[i]))
	129	return 1;
	130	}
	131
	132	for (i = 0; i < ARRAY_SIZE(boolean_options); i++) {
	133	if (!strcmp(name, boolean_options[i])) {
	134	is_bool = 1;
	135	break;
	136	}
	137	}
	138
	139	strbuf_addf(&buf, "option %s ", name);
	140	if (is_bool)
	141	strbuf_addstr(&buf, value ? "true" : "false");
	142	else
	143	quote_c_style(value, &buf, NULL, 0);
	144	strbuf_addch(&buf, '\n');
	145
	146	if (write_in_full(helper->in, buf.buf, buf.len) != buf.len)
	147	die_errno("cannot send option to %s", data->name);
	148
	149	strbuf_reset(&buf);
	150	if (strbuf_getline(&buf, data->out, '\n') == EOF)
	151	exit(128); /* child died, message supplied already */
	152
	153	if (!strcmp(buf.buf, "ok"))
	154	ret = 0;
	155	else if (!prefixcmp(buf.buf, "error")) {
	156	ret = -1;
	157	} else if (!strcmp(buf.buf, "unsupported"))
	158	ret = 1;
	159	else {
	160	warning("%s unexpectedly said: '%s'", data->name, buf.buf);
	161	ret = 1;
	162	}
	163	strbuf_release(&buf);
	164	return ret;
	165	}
	166
	167	static void standard_options(struct transport *t)
168	{
169	char buf[16];
170	int n;
171	int v = t->verbose;
172	int no_progress = v < 0 \|\| (!t->progress && !isatty(1));
173
174	set_helper_option(t, "progress", !no_progress ? "true" : "false");
175
176	n = snprintf(buf, sizeof(buf), "%d", v + 1);
177	if (n >= sizeof(buf))
178	die("impossibly large verbosity value");
179	set_helper_option(t, "verbosity", buf);
180	}
181
f2a37151 DB	182	static int release_helper(struct transport *transport)
f2a37151 DB	183	{
72ff8943 DB	184	struct helper_data *data = transport->data;
	185	free_refspec(data->refspec_nr, data->refspecs);
	186	data->refspecs = NULL;
f2a37151 DB	187	disconnect_helper(transport);
	188	free(transport->data);
	189	return 0;
	190	}
	191
6eb996b5	192	static int fetch_with_fetch(struct transport *transport,
37148311	193	int nr_heads, struct ref **to_fetch)
6eb996b5	194	{
292ce46b	195	struct helper_data *data = transport->data;
6eb996b5 DB	196	int i;
	197	struct strbuf buf = STRBUF_INIT;
	198
ef08ef9e SP	199	standard_options(transport);
ef08ef9e SP	200
6eb996b5	201	for (i = 0; i < nr_heads; i++) {
1088261f	202	const struct ref *posn = to_fetch[i];
6eb996b5 DB	203	if (posn->status & REF_STATUS_UPTODATE)
6eb996b5 DB	204	continue;
2d14d65c DB	205
	206	strbuf_addf(&buf, "fetch %s %s\n",
	207	sha1_to_hex(posn->old_sha1), posn->name);
292ce46b	208	}
2d14d65c	209
292ce46b SP	210	strbuf_addch(&buf, '\n');
	211	if (write_in_full(data->helper->in, buf.buf, buf.len) != buf.len)
	212	die_errno("cannot send fetch to %s", data->name);
	213
	214	while (1) {
	215	strbuf_reset(&buf);
	216	if (strbuf_getline(&buf, data->out, '\n') == EOF)
6eb996b5	217	exit(128); /* child died, message supplied already */
292ce46b SP	218
	219	if (!prefixcmp(buf.buf, "lock ")) {
	220	const char *name = buf.buf + 5;
	221	if (transport->pack_lockfile)
	222	warning("%s also locked %s", data->name, name);
	223	else
	224	transport->pack_lockfile = xstrdup(name);
	225	}
	226	else if (!buf.len)
	227	break;
	228	else
	229	warning("%s unexpectedly said: '%s'", data->name, buf.buf);
6eb996b5	230	}
292ce46b	231	strbuf_release(&buf);
6eb996b5 DB	232	return 0;
	233	}
	234
e65e91ed DB	235	static int get_importer(struct transport transport, struct child_process fastimport)
	236	{
	237	struct child_process *helper = get_helper(transport);
	238	memset(fastimport, 0, sizeof(*fastimport));
	239	fastimport->in = helper->out;
	240	fastimport->argv = xcalloc(5, sizeof(*fastimport->argv));
	241	fastimport->argv[0] = "fast-import";
	242	fastimport->argv[1] = "--quiet";
	243
	244	fastimport->git_cmd = 1;
	245	return start_command(fastimport);
	246	}
	247
	248	static int fetch_with_import(struct transport *transport,
	249	int nr_heads, struct ref **to_fetch)
	250	{
	251	struct child_process fastimport;
	252	struct child_process *helper = get_helper(transport);
72ff8943	253	struct helper_data *data = transport->data;
e65e91ed DB	254	int i;
	255	struct ref *posn;
	256	struct strbuf buf = STRBUF_INIT;
	257
	258	if (get_importer(transport, &fastimport))
	259	die("Couldn't run fast-import");
	260
	261	for (i = 0; i < nr_heads; i++) {
	262	posn = to_fetch[i];
	263	if (posn->status & REF_STATUS_UPTODATE)
	264	continue;
	265
	266	strbuf_addf(&buf, "import %s\n", posn->name);
	267	write_in_full(helper->in, buf.buf, buf.len);
	268	strbuf_reset(&buf);
	269	}
	270	disconnect_helper(transport);
	271	finish_command(&fastimport);
b962dbdc SR	272	free(fastimport.argv);
b962dbdc SR	273	fastimport.argv = NULL;
e65e91ed DB	274
e65e91ed DB	275	for (i = 0; i < nr_heads; i++) {
72ff8943	276	char *private;
e65e91ed DB	277	posn = to_fetch[i];
	278	if (posn->status & REF_STATUS_UPTODATE)
	279	continue;
72ff8943 DB	280	if (data->refspecs)
	281	private = apply_refspecs(data->refspecs, data->refspec_nr, posn->name);
	282	else
	283	private = strdup(posn->name);
	284	read_ref(private, posn->old_sha1);
	285	free(private);
e65e91ed	286	}
b962dbdc	287	strbuf_release(&buf);
e65e91ed DB	288	return 0;
	289	}
	290
6eb996b5	291	static int fetch(struct transport *transport,
37148311	292	int nr_heads, struct ref **to_fetch)
6eb996b5 DB	293	{
	294	struct helper_data *data = transport->data;
	295	int i, count;
	296
	297	count = 0;
	298	for (i = 0; i < nr_heads; i++)
	299	if (!(to_fetch[i]->status & REF_STATUS_UPTODATE))
	300	count++;
	301
	302	if (!count)
	303	return 0;
	304
	305	if (data->fetch)
	306	return fetch_with_fetch(transport, nr_heads, to_fetch);
	307
e65e91ed DB	308	if (data->import)
	309	return fetch_with_import(transport, nr_heads, to_fetch);
	310
6eb996b5 DB	311	return -1;
	312	}
	313
ae4efe19 SP	314	static int push_refs(struct transport *transport,
	315	struct ref *remote_refs, int flags)
	316	{
	317	int force_all = flags & TRANSPORT_PUSH_FORCE;
	318	int mirror = flags & TRANSPORT_PUSH_MIRROR;
	319	struct helper_data *data = transport->data;
	320	struct strbuf buf = STRBUF_INIT;
	321	struct child_process *helper;
	322	struct ref *ref;
	323
	324	if (!remote_refs)
	325	return 0;
	326
	327	helper = get_helper(transport);
	328	if (!data->push)
	329	return 1;
	330
	331	for (ref = remote_refs; ref; ref = ref->next) {
	332	if (ref->peer_ref)
	333	hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
	334	else if (!mirror)
	335	continue;
	336
	337	ref->deletion = is_null_sha1(ref->new_sha1);
	338	if (!ref->deletion &&
	339	!hashcmp(ref->old_sha1, ref->new_sha1)) {
	340	ref->status = REF_STATUS_UPTODATE;
	341	continue;
	342	}
	343
	344	if (force_all)
	345	ref->force = 1;
	346
	347	strbuf_addstr(&buf, "push ");
	348	if (!ref->deletion) {
	349	if (ref->force)
	350	strbuf_addch(&buf, '+');
	351	if (ref->peer_ref)
	352	strbuf_addstr(&buf, ref->peer_ref->name);
	353	else
	354	strbuf_addstr(&buf, sha1_to_hex(ref->new_sha1));
	355	}
	356	strbuf_addch(&buf, ':');
	357	strbuf_addstr(&buf, ref->name);
	358	strbuf_addch(&buf, '\n');
	359	}
d8f67d20 CB	360	if (buf.len == 0)
d8f67d20 CB	361	return 0;
ae4efe19 SP	362
	363	transport->verbose = flags & TRANSPORT_PUSH_VERBOSE ? 1 : 0;
	364	standard_options(transport);
	365
	366	if (flags & TRANSPORT_PUSH_DRY_RUN) {
	367	if (set_helper_option(transport, "dry-run", "true") != 0)
	368	die("helper %s does not support dry-run", data->name);
	369	}
	370
	371	strbuf_addch(&buf, '\n');
	372	if (write_in_full(helper->in, buf.buf, buf.len) != buf.len)
	373	exit(128);
	374
	375	ref = remote_refs;
	376	while (1) {
	377	char refname, msg;
	378	int status;
	379
	380	strbuf_reset(&buf);
	381	if (strbuf_getline(&buf, data->out, '\n') == EOF)
	382	exit(128); /* child died, message supplied already */
	383	if (!buf.len)
	384	break;
	385
	386	if (!prefixcmp(buf.buf, "ok ")) {
	387	status = REF_STATUS_OK;
	388	refname = buf.buf + 3;
	389	} else if (!prefixcmp(buf.buf, "error ")) {
	390	status = REF_STATUS_REMOTE_REJECT;
	391	refname = buf.buf + 6;
	392	} else
	393	die("expected ok/error, helper said '%s'\n", buf.buf);
	394
	395	msg = strchr(refname, ' ');
	396	if (msg) {
	397	struct strbuf msg_buf = STRBUF_INIT;
	398	const char *end;
	399
	400	*msg++ = '\0';
	401	if (!unquote_c_style(&msg_buf, msg, &end))
	402	msg = strbuf_detach(&msg_buf, NULL);
	403	else
	404	msg = xstrdup(msg);
	405	strbuf_release(&msg_buf);
	406
	407	if (!strcmp(msg, "no match")) {
	408	status = REF_STATUS_NONE;
	409	free(msg);
	410	msg = NULL;
	411	}
	412	else if (!strcmp(msg, "up to date")) {
	413	status = REF_STATUS_UPTODATE;
	414	free(msg);
	415	msg = NULL;
	416	}
	417	else if (!strcmp(msg, "non-fast forward")) {
	418	status = REF_STATUS_REJECT_NONFASTFORWARD;
	419	free(msg);
	420	msg = NULL;
	421	}
	422	}
	423
	424	if (ref)
	425	ref = find_ref_by_name(ref, refname);
426	if (!ref)
427	ref = find_ref_by_name(remote_refs, refname);
428	if (!ref) {
429	warning("helper reported unexpected status of %s", refname);
430	continue;
431	}
432
433	ref->status = status;
434	ref->remote_status = msg;
435	}
436	strbuf_release(&buf);
437	return 0;
438	}
439
f8ec9167 DB	440	static int has_attribute(const char attrs, const char attr) {
	441	int len;
	442	if (!attrs)
	443	return 0;
	444
	445	len = strlen(attr);
	446	for (;;) {
	447	const char *space = strchrnul(attrs, ' ');
	448	if (len == space - attrs && !strncmp(attrs, attr, len))
	449	return 1;
	450	if (!*space)
	451	return 0;
	452	attrs = space + 1;
	453	}
	454	}
	455
6eb996b5 DB	456	static struct ref get_refs_list(struct transport transport, int for_push)
6eb996b5 DB	457	{
292ce46b	458	struct helper_data *data = transport->data;
6eb996b5 DB	459	struct child_process *helper;
	460	struct ref *ret = NULL;
	461	struct ref **tail = &ret;
	462	struct ref *posn;
	463	struct strbuf buf = STRBUF_INIT;
6eb996b5 DB	464
6eb996b5 DB	465	helper = get_helper(transport);
2d14d65c	466
ae4efe19 SP	467	if (data->push && for_push)
	468	write_str_in_full(helper->in, "list for-push\n");
	469	else
	470	write_str_in_full(helper->in, "list\n");
6eb996b5	471
6eb996b5 DB	472	while (1) {
6eb996b5 DB	473	char eov, eon;
292ce46b	474	if (strbuf_getline(&buf, data->out, '\n') == EOF)
6eb996b5 DB	475	exit(128); /* child died, message supplied already */
	476
	477	if (!*buf.buf)
	478	break;
	479
	480	eov = strchr(buf.buf, ' ');
	481	if (!eov)
	482	die("Malformed response in ref list: %s", buf.buf);
	483	eon = strchr(eov + 1, ' ');
	484	*eov = '\0';
	485	if (eon)
	486	*eon = '\0';
	487	*tail = alloc_ref(eov + 1);
	488	if (buf.buf[0] == '@')
	489	(*tail)->symref = xstrdup(buf.buf + 1);
	490	else if (buf.buf[0] != '?')
	491	get_sha1_hex(buf.buf, (*tail)->old_sha1);
f8ec9167 DB	492	if (eon) {
	493	if (has_attribute(eon + 1, "unchanged")) {
	494	(*tail)->status \|= REF_STATUS_UPTODATE;
	495	read_ref((tail)->name, (tail)->old_sha1);
	496	}
	497	}
6eb996b5 DB	498	tail = &((*tail)->next);
	499	}
	500	strbuf_release(&buf);
	501
	502	for (posn = ret; posn; posn = posn->next)
	503	resolve_remote_symref(posn, ret);
	504
	505	return ret;
	506	}
	507
c9e388bb	508	int transport_helper_init(struct transport transport, const char name)
6eb996b5 DB	509	{
6eb996b5 DB	510	struct helper_data data = xcalloc(sizeof(data), 1);
c9e388bb	511	data->name = name;
6eb996b5 DB	512
6eb996b5 DB	513	transport->data = data;
ef08ef9e	514	transport->set_option = set_helper_option;
6eb996b5 DB	515	transport->get_refs_list = get_refs_list;
6eb996b5 DB	516	transport->fetch = fetch;
ae4efe19	517	transport->push_refs = push_refs;
f2a37151	518	transport->disconnect = release_helper;
6eb996b5 DB	519	return 0;
6eb996b5 DB	520	}