[thirdparty/git.git] / transport.c

#include "cache.h"
#include "transport.h"
#include "run-command.h"
#include "http.h"
#include "pkt-line.h"
#include "fetch-pack.h"
#include "walker.h"
#include "bundle.h"

/* Generic functions for using commit walkers */

static int fetch_objs_via_walker(struct transport *transport,
				 int nr_objs, struct ref **to_fetch)
{
	char *dest = xstrdup(transport->url);
	struct walker *walker = transport->data;
	char **objs = xmalloc(nr_objs * sizeof(*objs));
	int i;

	walker->get_all = 1;
	walker->get_tree = 1;
	walker->get_history = 1;
	walker->get_verbosely = transport->verbose;
	walker->get_recover = 0;

	for (i = 0; i < nr_objs; i++)
		objs[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));

	if (walker_fetch(walker, nr_objs, objs, NULL, NULL))
		die("Fetch failed.");

	for (i = 0; i < nr_objs; i++)
		free(objs[i]);
	free(objs);
	free(dest);
	return 0;
}

static int disconnect_walker(struct transport *transport)
{
	struct walker *walker = transport->data;
	if (walker)
		walker_free(walker);
	return 0;
}

static int curl_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) {
	const char **argv;
	int argc;
	int err;

	argv = xmalloc((refspec_nr + 11) * sizeof(char *));
	argv[0] = "http-push";
	argc = 1;
	if (flags & TRANSPORT_PUSH_ALL)
		argv[argc++] = "--all";
	if (flags & TRANSPORT_PUSH_FORCE)
		argv[argc++] = "--force";
	argv[argc++] = transport->url;
	while (refspec_nr--)
		argv[argc++] = *refspec++;
	argv[argc] = NULL;
	err = run_command_v_opt(argv, RUN_GIT_CMD);
	switch (err) {
	case -ERR_RUN_COMMAND_FORK:
		error("unable to fork for %s", argv[0]);
	case -ERR_RUN_COMMAND_EXEC:
		error("unable to exec %s", argv[0]);
		break;
	case -ERR_RUN_COMMAND_WAITPID:
	case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
	case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
	case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
		error("%s died with strange error", argv[0]);
	}
	return !!err;
}

#ifndef NO_CURL
static int missing__target(int code, int result)
{
	return	/* file:// URL -- do we ever use one??? */
		(result == CURLE_FILE_COULDNT_READ_FILE) ||
		/* http:// and https:// URL */
		(code == 404 && result == CURLE_HTTP_RETURNED_ERROR) ||
		/* ftp:// URL */
		(code == 550 && result == CURLE_FTP_COULDNT_RETR_FILE)
		;
}

#define missing_target(a) missing__target((a)->http_code, (a)->curl_result)

static struct ref *get_refs_via_curl(const struct transport *transport)
{
	struct buffer buffer;
	char *data, *start, *mid;
	char *ref_name;
	char *refs_url;
	int i = 0;

	struct active_request_slot *slot;
	struct slot_results results;

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

	data = xmalloc(4096);
	buffer.size = 4096;
	buffer.posn = 0;
	buffer.buffer = data;

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

	http_init();

	slot = get_active_slot();
	slot->results = &results;
	curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
	curl_easy_setopt(slot->curl, CURLOPT_URL, refs_url);
	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
	if (start_active_slot(slot)) {
		run_active_slot(slot);
		if (results.curl_result != CURLE_OK) {
			if (missing_target(&results)) {
				free(buffer.buffer);
				return NULL;
			} else {
				free(buffer.buffer);
				error("%s", curl_errorstr);
				return NULL;
			}
		}
	} else {
		free(buffer.buffer);
		error("Unable to start request");
		return NULL;
	}

	http_cleanup();

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

	free(buffer.buffer);

	return refs;
}

static int fetch_objs_via_curl(struct transport *transport,
				 int nr_objs, struct ref **to_fetch)
{
	if (!transport->data)
		transport->data = get_http_walker(transport->url);
	return fetch_objs_via_walker(transport, nr_objs, to_fetch);
}

#else

static struct ref *get_refs_via_curl(const struct transport *transport)
{
	die("Cannot fetch from '%s' without curl ...", transport->url);
	return NULL;
}

static int fetch_objs_via_curl(struct transport *transport,
				 int nr_objs, struct ref **to_fetch)
{
	die("Cannot fetch from '%s' without curl ...", transport->url);
	return -1;
}

#endif

struct bundle_transport_data {
	int fd;
	struct bundle_header header;
};

static struct ref *get_refs_from_bundle(const struct transport *transport)
{
	struct bundle_transport_data *data = transport->data;
	struct ref *result = NULL;
	int i;

	if (data->fd > 0)
		close(data->fd);
	data->fd = read_bundle_header(transport->url, &data->header);
	if (data->fd < 0)
		die ("Could not read bundle '%s'.", transport->url);
	for (i = 0; i < data->header.references.nr; i++) {
		struct ref_list_entry *e = data->header.references.list + i;
		struct ref *ref = alloc_ref(strlen(e->name) + 1);
		hashcpy(ref->old_sha1, e->sha1);
		strcpy(ref->name, e->name);
		ref->next = result;
		result = ref;
	}
	return result;
}

static int fetch_refs_from_bundle(struct transport *transport,
			       int nr_heads, struct ref **to_fetch)
{
	struct bundle_transport_data *data = transport->data;
	return unbundle(&data->header, data->fd);
}

static int close_bundle(struct transport *transport)
{
	struct bundle_transport_data *data = transport->data;
	if (data->fd > 0)
		close(data->fd);
	free(data);
	return 0;
}

struct git_transport_data {
	unsigned thin : 1;
	unsigned keep : 1;
	int depth;
	const char *uploadpack;
	const char *receivepack;
};

static int set_git_option(struct transport *connection,
			  const char *name, const char *value)
{
	struct git_transport_data *data = connection->data;
	if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
		data->uploadpack = value;
		return 0;
	} else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
		data->receivepack = value;
		return 0;
	} else if (!strcmp(name, TRANS_OPT_THIN)) {
		data->thin = !!value;
		return 0;
	} else if (!strcmp(name, TRANS_OPT_KEEP)) {
		data->keep = !!value;
		return 0;
	} else if (!strcmp(name, TRANS_OPT_DEPTH)) {
		if (!value)
			data->depth = 0;
		else
			data->depth = atoi(value);
		return 0;
	}
	return 1;
}

static struct ref *get_refs_via_connect(const struct transport *transport)
{
	struct git_transport_data *data = transport->data;
	struct ref *refs;
	int fd[2];
	pid_t pid;
	char *dest = xstrdup(transport->url);

	pid = git_connect(fd, dest, data->uploadpack, 0);

	if (pid < 0)
		die("Failed to connect to \"%s\"", transport->url);

	get_remote_heads(fd[0], &refs, 0, NULL, 0);
	packet_flush(fd[1]);

	finish_connect(pid);

	free(dest);

	return refs;
}

static int fetch_refs_via_pack(struct transport *transport,
			       int nr_heads, struct ref **to_fetch)
{
	struct git_transport_data *data = transport->data;
	char **heads = xmalloc(nr_heads * sizeof(*heads));
	char **origh = xmalloc(nr_heads * sizeof(*origh));
	struct ref *refs;
	char *dest = xstrdup(transport->url);
	struct fetch_pack_args args;
	int i;

	memset(&args, 0, sizeof(args));
	args.uploadpack = data->uploadpack;
	args.keep_pack = data->keep;
	args.lock_pack = 1;
	args.use_thin_pack = data->thin;
	args.verbose = transport->verbose;
	args.depth = data->depth;

	for (i = 0; i < nr_heads; i++)
		origh[i] = heads[i] = xstrdup(to_fetch[i]->name);
	refs = fetch_pack(&args, dest, nr_heads, heads, &transport->pack_lockfile);

	for (i = 0; i < nr_heads; i++)
		free(origh[i]);
	free(origh);
	free(heads);
	free_refs(refs);
	free(dest);
	return 0;
}

static int git_transport_push(struct transport *transport, int refspec_nr, const char **refspec, int flags) {
	struct git_transport_data *data = transport->data;
	const char **argv;
	char *rem;
	int argc;
	int err;

	argv = xmalloc((refspec_nr + 11) * sizeof(char *));
	argv[0] = "send-pack";
	argc = 1;
	if (flags & TRANSPORT_PUSH_ALL)
		argv[argc++] = "--all";
	if (flags & TRANSPORT_PUSH_FORCE)
		argv[argc++] = "--force";
	if (data->receivepack) {
		char *rp = xmalloc(strlen(data->receivepack) + 16);
		sprintf(rp, "--receive-pack=%s", data->receivepack);
		argv[argc++] = rp;
	}
	if (data->thin)
		argv[argc++] = "--thin";
	rem = xmalloc(strlen(transport->remote->name) + 10);
	sprintf(rem, "--remote=%s", transport->remote->name);
	argv[argc++] = rem;
	argv[argc++] = transport->url;
	while (refspec_nr--)
		argv[argc++] = *refspec++;
	argv[argc] = NULL;
	err = run_command_v_opt(argv, RUN_GIT_CMD);
	switch (err) {
	case -ERR_RUN_COMMAND_FORK:
		error("unable to fork for %s", argv[0]);
	case -ERR_RUN_COMMAND_EXEC:
		error("unable to exec %s", argv[0]);
		break;
	case -ERR_RUN_COMMAND_WAITPID:
	case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
	case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
	case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
		error("%s died with strange error", argv[0]);
	}
	return !!err;
}

static int disconnect_git(struct transport *transport)
{
	free(transport->data);
	return 0;
}

static int is_local(const char *url)
{
	const char *colon = strchr(url, ':');
	const char *slash = strchr(url, '/');
	return !colon || (slash && slash < colon);
}

static int is_file(const char *url)
{
	struct stat buf;
	if (stat(url, &buf))
		return 0;
	return S_ISREG(buf.st_mode);
}

struct transport *transport_get(struct remote *remote, const char *url)
{
	struct transport *ret = xcalloc(1, sizeof(*ret));

	ret->remote = remote;
	ret->url = url;

	if (!prefixcmp(url, "rsync://")) {
		/* not supported; don't populate any ops */

	} else if (!prefixcmp(url, "http://")
	        || !prefixcmp(url, "https://")
	        || !prefixcmp(url, "ftp://")) {
		ret->get_refs_list = get_refs_via_curl;
		ret->fetch = fetch_objs_via_curl;
		ret->push = curl_transport_push;
		ret->disconnect = disconnect_walker;

	} else if (is_local(url) && is_file(url)) {
		struct bundle_transport_data *data = xcalloc(1, sizeof(*data));
		ret->data = data;
		ret->get_refs_list = get_refs_from_bundle;
		ret->fetch = fetch_refs_from_bundle;
		ret->disconnect = close_bundle;

	} else {
		struct git_transport_data *data = xcalloc(1, sizeof(*data));
		ret->data = data;
		ret->set_option = set_git_option;
		ret->get_refs_list = get_refs_via_connect;
		ret->fetch = fetch_refs_via_pack;
		ret->push = git_transport_push;
		ret->disconnect = disconnect_git;

		data->thin = 1;
		data->uploadpack = "git-upload-pack";
		if (remote && remote->uploadpack)
			data->uploadpack = remote->uploadpack;
		data->receivepack = "git-receive-pack";
		if (remote && remote->receivepack)
			data->receivepack = remote->receivepack;
	}

	return ret;
}

int transport_set_option(struct transport *transport,
			 const char *name, const char *value)
{
	if (transport->set_option)
		return transport->set_option(transport, name, value);
	return 1;
}

int transport_push(struct transport *transport,
		   int refspec_nr, const char **refspec, int flags)
{
	if (!transport->push)
		return 1;
	return transport->push(transport, refspec_nr, refspec, flags);
}

struct ref *transport_get_remote_refs(struct transport *transport)
{
	if (!transport->remote_refs)
		transport->remote_refs = transport->get_refs_list(transport);
	return transport->remote_refs;
}

int transport_fetch_refs(struct transport *transport, struct ref *refs)
{
	int rc;
	int nr_heads = 0, nr_alloc = 0;
	struct ref **heads = NULL;
	struct ref *rm;

	for (rm = refs; rm; rm = rm->next) {
		if (rm->peer_ref &&
		    !hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
			continue;
		ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
		heads[nr_heads++] = rm;
	}

	rc = transport->fetch(transport, nr_heads, heads);
	free(heads);
	return rc;
}

void transport_unlock_pack(struct transport *transport)
{
	if (transport->pack_lockfile) {
		unlink(transport->pack_lockfile);
		free(transport->pack_lockfile);
		transport->pack_lockfile = NULL;
	}
}

int transport_disconnect(struct transport *transport)
{
	int ret = 0;
	if (transport->disconnect)
		ret = transport->disconnect(transport);
	free(transport);
	return ret;
}
Commit	Line	Data
9b288516 DB	1	#include "cache.h"
	2	#include "transport.h"
	3	#include "run-command.h"
c29727d5 DB	4	#include "http.h"
	5	#include "pkt-line.h"
	6	#include "fetch-pack.h"
	7	#include "walker.h"
c7a8a162	8	#include "bundle.h"
c29727d5 DB	9
	10	/* Generic functions for using commit walkers */
	11
1788c39c	12	static int fetch_objs_via_walker(struct transport *transport,
425b1393	13	int nr_objs, struct ref **to_fetch)
c29727d5 DB	14	{
	15	char *dest = xstrdup(transport->url);
	16	struct walker *walker = transport->data;
425b1393 SP	17	char *objs = xmalloc(nr_objs sizeof(*objs));
425b1393 SP	18	int i;
c29727d5 DB	19
	20	walker->get_all = 1;
	21	walker->get_tree = 1;
	22	walker->get_history = 1;
	23	walker->get_verbosely = transport->verbose;
	24	walker->get_recover = 0;
	25
425b1393 SP	26	for (i = 0; i < nr_objs; i++)
	27	objs[i] = xstrdup(sha1_to_hex(to_fetch[i]->old_sha1));
	28
b6abb48a	29	if (walker_fetch(walker, nr_objs, objs, NULL, NULL))
c29727d5 DB	30	die("Fetch failed.");
c29727d5 DB	31
425b1393 SP	32	for (i = 0; i < nr_objs; i++)
	33	free(objs[i]);
	34	free(objs);
c29727d5 DB	35	free(dest);
	36	return 0;
	37	}
	38
	39	static int disconnect_walker(struct transport *transport)
	40	{
	41	struct walker *walker = transport->data;
	42	if (walker)
	43	walker_free(walker);
	44	return 0;
	45	}
9b288516	46
9b288516 DB	47	static int curl_transport_push(struct transport transport, int refspec_nr, const char *refspec, int flags) {
	48	const char **argv;
	49	int argc;
	50	int err;
	51
	52	argv = xmalloc((refspec_nr + 11) * sizeof(char *));
	53	argv[0] = "http-push";
	54	argc = 1;
	55	if (flags & TRANSPORT_PUSH_ALL)
	56	argv[argc++] = "--all";
	57	if (flags & TRANSPORT_PUSH_FORCE)
	58	argv[argc++] = "--force";
	59	argv[argc++] = transport->url;
	60	while (refspec_nr--)
	61	argv[argc++] = *refspec++;
	62	argv[argc] = NULL;
	63	err = run_command_v_opt(argv, RUN_GIT_CMD);
	64	switch (err) {
	65	case -ERR_RUN_COMMAND_FORK:
	66	error("unable to fork for %s", argv[0]);
	67	case -ERR_RUN_COMMAND_EXEC:
	68	error("unable to exec %s", argv[0]);
	69	break;
	70	case -ERR_RUN_COMMAND_WAITPID:
	71	case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
	72	case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
	73	case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
	74	error("%s died with strange error", argv[0]);
	75	}
	76	return !!err;
	77	}
	78
c29727d5 DB	79	#ifndef NO_CURL
	80	static int missing__target(int code, int result)
	81	{
	82	return /* file:// URL -- do we ever use one??? */
	83	(result == CURLE_FILE_COULDNT_READ_FILE) \|\|
	84	/* http:// and https:// URL */
	85	(code == 404 && result == CURLE_HTTP_RETURNED_ERROR) \|\|
	86	/* ftp:// URL */
	87	(code == 550 && result == CURLE_FTP_COULDNT_RETR_FILE)
	88	;
	89	}
	90
	91	#define missing_target(a) missing__target((a)->http_code, (a)->curl_result)
	92
	93	static struct ref get_refs_via_curl(const struct transport transport)
	94	{
	95	struct buffer buffer;
	96	char data, start, *mid;
	97	char *ref_name;
	98	char *refs_url;
	99	int i = 0;
	100
	101	struct active_request_slot *slot;
	102	struct slot_results results;
	103
	104	struct ref *refs = NULL;
	105	struct ref *ref = NULL;
	106	struct ref *last_ref = NULL;
	107
	108	data = xmalloc(4096);
	109	buffer.size = 4096;
	110	buffer.posn = 0;
	111	buffer.buffer = data;
	112
	113	refs_url = xmalloc(strlen(transport->url) + 11);
	114	sprintf(refs_url, "%s/info/refs", transport->url);
	115
	116	http_init();
	117
	118	slot = get_active_slot();
	119	slot->results = &results;
	120	curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
	121	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
	122	curl_easy_setopt(slot->curl, CURLOPT_URL, refs_url);
	123	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
	124	if (start_active_slot(slot)) {
	125	run_active_slot(slot);
	126	if (results.curl_result != CURLE_OK) {
	127	if (missing_target(&results)) {
	128	free(buffer.buffer);
	129	return NULL;
	130	} else {
	131	free(buffer.buffer);
	132	error("%s", curl_errorstr);
	133	return NULL;
	134	}
	135	}
	136	} else {
	137	free(buffer.buffer);
	138	error("Unable to start request");
	139	return NULL;
	140	}
	141
	142	http_cleanup();
143
144	data = buffer.buffer;
145	start = NULL;
146	mid = data;
147	while (i < buffer.posn) {
148	if (!start)
149	start = &data[i];
150	if (data[i] == '\t')
151	mid = &data[i];
152	if (data[i] == '\n') {
153	data[i] = 0;
154	ref_name = mid + 1;
155	ref = xmalloc(sizeof(struct ref) +
156	strlen(ref_name) + 1);
157	memset(ref, 0, sizeof(struct ref));
158	strcpy(ref->name, ref_name);
159	get_sha1_hex(start, ref->old_sha1);
160	if (!refs)
161	refs = ref;
162	if (last_ref)
163	last_ref->next = ref;
164	last_ref = ref;
165	start = NULL;
166	}
167	i++;
168	}
169
170	free(buffer.buffer);
171
172	return refs;
173	}
174
e5f4e214 SP	175	static int fetch_objs_via_curl(struct transport *transport,
	176	int nr_objs, struct ref **to_fetch)
	177	{
	178	if (!transport->data)
	179	transport->data = get_http_walker(transport->url);
	180	return fetch_objs_via_walker(transport, nr_objs, to_fetch);
	181	}
	182
c29727d5 DB	183	#else
	184
	185	static struct ref get_refs_via_curl(const struct transport transport)
	186	{
	187	die("Cannot fetch from '%s' without curl ...", transport->url);
	188	return NULL;
	189	}
	190
e5f4e214 SP	191	static int fetch_objs_via_curl(struct transport *transport,
	192	int nr_objs, struct ref **to_fetch)
	193	{
	194	die("Cannot fetch from '%s' without curl ...", transport->url);
	195	return -1;
	196	}
	197
c29727d5 DB	198	#endif
c29727d5 DB	199
c7a8a162 JS	200	struct bundle_transport_data {
	201	int fd;
	202	struct bundle_header header;
	203	};
	204
	205	static struct ref get_refs_from_bundle(const struct transport transport)
	206	{
	207	struct bundle_transport_data *data = transport->data;
	208	struct ref *result = NULL;
	209	int i;
	210
	211	if (data->fd > 0)
	212	close(data->fd);
	213	data->fd = read_bundle_header(transport->url, &data->header);
	214	if (data->fd < 0)
	215	die ("Could not read bundle '%s'.", transport->url);
	216	for (i = 0; i < data->header.references.nr; i++) {
	217	struct ref_list_entry *e = data->header.references.list + i;
90446a00	218	struct ref *ref = alloc_ref(strlen(e->name) + 1);
c7a8a162 JS	219	hashcpy(ref->old_sha1, e->sha1);
	220	strcpy(ref->name, e->name);
	221	ref->next = result;
	222	result = ref;
	223	}
	224	return result;
	225	}
	226
1788c39c	227	static int fetch_refs_from_bundle(struct transport *transport,
425b1393	228	int nr_heads, struct ref **to_fetch)
c7a8a162 JS	229	{
	230	struct bundle_transport_data *data = transport->data;
	231	return unbundle(&data->header, data->fd);
	232	}
	233
	234	static int close_bundle(struct transport *transport)
	235	{
	236	struct bundle_transport_data *data = transport->data;
	237	if (data->fd > 0)
	238	close(data->fd);
f4e95765	239	free(data);
c7a8a162 JS	240	return 0;
	241	}
	242
9b288516 DB	243	struct git_transport_data {
9b288516 DB	244	unsigned thin : 1;
c29727d5	245	unsigned keep : 1;
c29727d5	246	int depth;
c29727d5	247	const char *uploadpack;
9b288516 DB	248	const char *receivepack;
	249	};
	250
	251	static int set_git_option(struct transport *connection,
	252	const char name, const char value)
	253	{
	254	struct git_transport_data *data = connection->data;
c29727d5 DB	255	if (!strcmp(name, TRANS_OPT_UPLOADPACK)) {
	256	data->uploadpack = value;
	257	return 0;
	258	} else if (!strcmp(name, TRANS_OPT_RECEIVEPACK)) {
9b288516 DB	259	data->receivepack = value;
	260	return 0;
	261	} else if (!strcmp(name, TRANS_OPT_THIN)) {
	262	data->thin = !!value;
	263	return 0;
c29727d5 DB	264	} else if (!strcmp(name, TRANS_OPT_KEEP)) {
	265	data->keep = !!value;
	266	return 0;
c29727d5 DB	267	} else if (!strcmp(name, TRANS_OPT_DEPTH)) {
	268	if (!value)
	269	data->depth = 0;
	270	else
	271	data->depth = atoi(value);
	272	return 0;
9b288516 DB	273	}
	274	return 1;
	275	}
	276
c29727d5 DB	277	static struct ref get_refs_via_connect(const struct transport transport)
	278	{
	279	struct git_transport_data *data = transport->data;
	280	struct ref *refs;
	281	int fd[2];
	282	pid_t pid;
	283	char *dest = xstrdup(transport->url);
	284
	285	pid = git_connect(fd, dest, data->uploadpack, 0);
	286
	287	if (pid < 0)
	288	die("Failed to connect to \"%s\"", transport->url);
	289
	290	get_remote_heads(fd[0], &refs, 0, NULL, 0);
	291	packet_flush(fd[1]);
	292
	293	finish_connect(pid);
	294
	295	free(dest);
	296
	297	return refs;
	298	}
	299
1788c39c	300	static int fetch_refs_via_pack(struct transport *transport,
425b1393	301	int nr_heads, struct ref **to_fetch)
c29727d5 DB	302	{
c29727d5 DB	303	struct git_transport_data *data = transport->data;
425b1393	304	char *heads = xmalloc(nr_heads sizeof(*heads));
e4cd6c7a	305	char *origh = xmalloc(nr_heads sizeof(*origh));
c29727d5 DB	306	struct ref *refs;
	307	char *dest = xstrdup(transport->url);
	308	struct fetch_pack_args args;
425b1393	309	int i;
c29727d5	310
fa740529	311	memset(&args, 0, sizeof(args));
c29727d5	312	args.uploadpack = data->uploadpack;
c29727d5	313	args.keep_pack = data->keep;
fa740529	314	args.lock_pack = 1;
c29727d5	315	args.use_thin_pack = data->thin;
c29727d5 DB	316	args.verbose = transport->verbose;
c29727d5 DB	317	args.depth = data->depth;
c29727d5	318
425b1393	319	for (i = 0; i < nr_heads; i++)
e4cd6c7a	320	origh[i] = heads[i] = xstrdup(to_fetch[i]->name);
fa740529	321	refs = fetch_pack(&args, dest, nr_heads, heads, &transport->pack_lockfile);
c29727d5	322
425b1393	323	for (i = 0; i < nr_heads; i++)
e4cd6c7a SP	324	free(origh[i]);
	325	free(origh);
	326	free(heads);
c29727d5	327	free_refs(refs);
c29727d5 DB	328	free(dest);
	329	return 0;
	330	}
	331
9b288516 DB	332	static int git_transport_push(struct transport transport, int refspec_nr, const char *refspec, int flags) {
	333	struct git_transport_data *data = transport->data;
	334	const char **argv;
	335	char *rem;
	336	int argc;
	337	int err;
	338
	339	argv = xmalloc((refspec_nr + 11) * sizeof(char *));
	340	argv[0] = "send-pack";
	341	argc = 1;
	342	if (flags & TRANSPORT_PUSH_ALL)
	343	argv[argc++] = "--all";
	344	if (flags & TRANSPORT_PUSH_FORCE)
	345	argv[argc++] = "--force";
	346	if (data->receivepack) {
	347	char *rp = xmalloc(strlen(data->receivepack) + 16);
	348	sprintf(rp, "--receive-pack=%s", data->receivepack);
	349	argv[argc++] = rp;
	350	}
	351	if (data->thin)
	352	argv[argc++] = "--thin";
	353	rem = xmalloc(strlen(transport->remote->name) + 10);
	354	sprintf(rem, "--remote=%s", transport->remote->name);
	355	argv[argc++] = rem;
	356	argv[argc++] = transport->url;
	357	while (refspec_nr--)
	358	argv[argc++] = *refspec++;
	359	argv[argc] = NULL;
	360	err = run_command_v_opt(argv, RUN_GIT_CMD);
	361	switch (err) {
	362	case -ERR_RUN_COMMAND_FORK:
	363	error("unable to fork for %s", argv[0]);
	364	case -ERR_RUN_COMMAND_EXEC:
	365	error("unable to exec %s", argv[0]);
	366	break;
	367	case -ERR_RUN_COMMAND_WAITPID:
	368	case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
	369	case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
	370	case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
	371	error("%s died with strange error", argv[0]);
	372	}
	373	return !!err;
	374	}
	375
f4e95765 SP	376	static int disconnect_git(struct transport *transport)
	377	{
	378	free(transport->data);
	379	return 0;
	380	}
	381
9b288516 DB	382	static int is_local(const char *url)
	383	{
	384	const char *colon = strchr(url, ':');
	385	const char *slash = strchr(url, '/');
	386	return !colon \|\| (slash && slash < colon);
	387	}
	388
	389	static int is_file(const char *url)
	390	{
	391	struct stat buf;
	392	if (stat(url, &buf))
	393	return 0;
	394	return S_ISREG(buf.st_mode);
	395	}
	396
e5f4e214	397	struct transport transport_get(struct remote remote, const char *url)
9b288516	398	{
8eb554ae SP	399	struct transport ret = xcalloc(1, sizeof(ret));
	400
	401	ret->remote = remote;
	402	ret->url = url;
8eb554ae	403
9b288516	404	if (!prefixcmp(url, "rsync://")) {
824d5776 SP	405	/* not supported; don't populate any ops */
824d5776 SP	406
8eb554ae SP	407	} else if (!prefixcmp(url, "http://")
	408	\|\| !prefixcmp(url, "https://")
	409	\|\| !prefixcmp(url, "ftp://")) {
824d5776 SP	410	ret->get_refs_list = get_refs_via_curl;
	411	ret->fetch = fetch_objs_via_curl;
	412	ret->push = curl_transport_push;
	413	ret->disconnect = disconnect_walker;
	414
9b288516	415	} else if (is_local(url) && is_file(url)) {
c7a8a162	416	struct bundle_transport_data data = xcalloc(1, sizeof(data));
c7a8a162	417	ret->data = data;
824d5776 SP	418	ret->get_refs_list = get_refs_from_bundle;
	419	ret->fetch = fetch_refs_from_bundle;
	420	ret->disconnect = close_bundle;
	421
9b288516 DB	422	} else {
9b288516 DB	423	struct git_transport_data data = xcalloc(1, sizeof(data));
9b288516	424	ret->data = data;
824d5776 SP	425	ret->set_option = set_git_option;
	426	ret->get_refs_list = get_refs_via_connect;
	427	ret->fetch = fetch_refs_via_pack;
	428	ret->push = git_transport_push;
f4e95765	429	ret->disconnect = disconnect_git;
824d5776	430
9b288516	431	data->thin = 1;
c29727d5 DB	432	data->uploadpack = "git-upload-pack";
	433	if (remote && remote->uploadpack)
	434	data->uploadpack = remote->uploadpack;
9b288516 DB	435	data->receivepack = "git-receive-pack";
	436	if (remote && remote->receivepack)
	437	data->receivepack = remote->receivepack;
9b288516	438	}
8eb554ae	439
9b288516 DB	440	return ret;
	441	}
	442
	443	int transport_set_option(struct transport *transport,
	444	const char name, const char value)
	445	{
824d5776 SP	446	if (transport->set_option)
824d5776 SP	447	return transport->set_option(transport, name, value);
ab865e6e	448	return 1;
9b288516 DB	449	}
	450
	451	int transport_push(struct transport *transport,
	452	int refspec_nr, const char **refspec, int flags)
	453	{
824d5776	454	if (!transport->push)
9b288516	455	return 1;
824d5776	456	return transport->push(transport, refspec_nr, refspec, flags);
9b288516 DB	457	}
9b288516 DB	458
c29727d5 DB	459	struct ref transport_get_remote_refs(struct transport transport)
	460	{
	461	if (!transport->remote_refs)
824d5776	462	transport->remote_refs = transport->get_refs_list(transport);
c29727d5 DB	463	return transport->remote_refs;
	464	}
	465
c29727d5 DB	466	int transport_fetch_refs(struct transport transport, struct ref refs)
c29727d5 DB	467	{
425b1393	468	int rc;
7a2bff45	469	int nr_heads = 0, nr_alloc = 0;
425b1393	470	struct ref **heads = NULL;
c29727d5	471	struct ref *rm;
c29727d5 DB	472
	473	for (rm = refs; rm; rm = rm->next) {
	474	if (rm->peer_ref &&
	475	!hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))
	476	continue;
7a2bff45	477	ALLOC_GROW(heads, nr_heads + 1, nr_alloc);
425b1393	478	heads[nr_heads++] = rm;
c29727d5 DB	479	}
c29727d5 DB	480
824d5776	481	rc = transport->fetch(transport, nr_heads, heads);
c29727d5	482	free(heads);
425b1393	483	return rc;
c29727d5 DB	484	}
c29727d5 DB	485
1788c39c SP	486	void transport_unlock_pack(struct transport *transport)
	487	{
	488	if (transport->pack_lockfile) {
	489	unlink(transport->pack_lockfile);
	490	free(transport->pack_lockfile);
	491	transport->pack_lockfile = NULL;
	492	}
	493	}
	494
9b288516 DB	495	int transport_disconnect(struct transport *transport)
	496	{
	497	int ret = 0;
824d5776 SP	498	if (transport->disconnect)
824d5776 SP	499	ret = transport->disconnect(transport);
9b288516 DB	500	free(transport);
	501	return ret;
	502	}