[thirdparty/git.git] / fetch-pack.c

#include "cache.h"
#include "refs.h"
#include "pkt-line.h"
#include "commit.h"
#include "tag.h"

static int keep_pack;
static int quiet;
static int verbose;
static const char fetch_pack_usage[] =
"git-fetch-pack [-q] [-v] [-k] [--exec=upload-pack] [host:]directory <refs>...";
static const char *exec = "git-upload-pack";

#define COMPLETE	(1U << 0)
#define COMMON		(1U << 1)
#define COMMON_REF	(1U << 2)
#define SEEN		(1U << 3)
#define POPPED		(1U << 4)

static struct commit_list *rev_list = NULL;
static int non_common_revs = 0, multi_ack = 0;

static void rev_list_push(struct commit *commit, int mark)
{
	if (!(commit->object.flags & mark)) {
		commit->object.flags |= mark;

		if (!(commit->object.parsed))
			parse_commit(commit);

		insert_by_date(commit, &rev_list);

		if (!(commit->object.flags & COMMON))
			non_common_revs++;
	}
}

static int rev_list_insert_ref(const char *path, const unsigned char *sha1)
{
	struct object *o = deref_tag(parse_object(sha1), path, 0);

	if (o && o->type == commit_type)
		rev_list_push((struct commit *)o, SEEN);

	return 0;
}

/*
   This function marks a rev and its ancestors as common.
   In some cases, it is desirable to mark only the ancestors (for example
   when only the server does not yet know that they are common).
*/

static void mark_common(struct commit *commit,
		int ancestors_only, int dont_parse)
{
	if (commit != NULL && !(commit->object.flags & COMMON)) {
		struct object *o = (struct object *)commit;

		if (!ancestors_only)
			o->flags |= COMMON;

		if (!(o->flags & SEEN))
			rev_list_push(commit, SEEN);
		else {
			struct commit_list *parents;

			if (!ancestors_only && !(o->flags & POPPED))
				non_common_revs--;
			if (!o->parsed && !dont_parse)
				parse_commit(commit);

			for (parents = commit->parents;
					parents;
					parents = parents->next)
				mark_common(parents->item, 0, dont_parse);
		}
	}
}

/*
  Get the next rev to send, ignoring the common.
*/

static const unsigned char* get_rev()
{
	struct commit *commit = NULL;

	while (commit == NULL) {
		unsigned int mark;
		struct commit_list* parents;

		if (rev_list == NULL || non_common_revs == 0)
			return NULL;

		commit = rev_list->item;
		if (!(commit->object.parsed))
			parse_commit(commit);
		commit->object.flags |= POPPED;
		if (!(commit->object.flags & COMMON))
			non_common_revs--;
	
		parents = commit->parents;

		if (commit->object.flags & COMMON) {
			/* do not send "have", and ignore ancestors */
			commit = NULL;
			mark = COMMON | SEEN;
		} else if (commit->object.flags & COMMON_REF)
			/* send "have", and ignore ancestors */
			mark = COMMON | SEEN;
		else
			/* send "have", also for its ancestors */
			mark = SEEN;

		while (parents) {
			if (!(parents->item->object.flags & SEEN))
				rev_list_push(parents->item, mark);
			if (mark & COMMON)
				mark_common(parents->item, 1, 0);
			parents = parents->next;
		}

		rev_list = rev_list->next;
	}

	return commit->object.sha1;
}

static int find_common(int fd[2], unsigned char *result_sha1,
		       struct ref *refs)
{
	int fetching;
	int count = 0, flushes = 0, retval;
	const unsigned char *sha1;

	for_each_ref(rev_list_insert_ref);

	fetching = 0;
	for ( ; refs ; refs = refs->next) {
		unsigned char *remote = refs->old_sha1;
		struct object *o;

		/*
		 * If that object is complete (i.e. it is an ancestor of a
		 * local ref), we tell them we have it but do not have to
		 * tell them about its ancestors, which they already know
		 * about.
		 *
		 * We use lookup_object here because we are only
		 * interested in the case we *know* the object is
		 * reachable and we have already scanned it.
		 */
		if (((o = lookup_object(remote)) != NULL) &&
				(o->flags & COMPLETE)) {
			continue;
		}

		packet_write(fd[1], "want %s%s\n", sha1_to_hex(remote),
			multi_ack ? " multi_ack" : "");
		fetching++;
	}
	packet_flush(fd[1]);
	if (!fetching)
		return 1;

	flushes = 0;
	retval = -1;
	while ((sha1 = get_rev())) {
		packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
		if (verbose)
			fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
		if (!(31 & ++count)) {
			int ack;

			packet_flush(fd[1]);
			flushes++;

			/*
			 * We keep one window "ahead" of the other side, and
			 * will wait for an ACK only on the next one
			 */
			if (count == 32)
				continue;

			do {
				ack = get_ack(fd[0], result_sha1);
				if (verbose && ack)
					fprintf(stderr, "got ack %d %s\n", ack,
							sha1_to_hex(result_sha1));
				if (ack == 1) {
					flushes = 0;
					multi_ack = 0;
					retval = 0;
					goto done;
				} else if (ack == 2) {
					struct commit *commit =
						lookup_commit(result_sha1);
					mark_common(commit, 0, 1);
					retval = 0;
				}
			} while (ack);
			flushes--;
		}
	}
done:
	packet_write(fd[1], "done\n");
	if (verbose)
		fprintf(stderr, "done\n");
	if (retval != 0) {
		multi_ack = 0;
		flushes++;
	}
	while (flushes || multi_ack) {
		int ack = get_ack(fd[0], result_sha1);
		if (ack) {
			if (verbose)
				fprintf(stderr, "got ack (%d) %s\n", ack,
					sha1_to_hex(result_sha1));
			if (ack == 1)
				return 0;
			multi_ack = 1;
			continue;
		}
		flushes--;
	}
	return retval;
}

static struct commit_list *complete = NULL;

static int mark_complete(const char *path, const unsigned char *sha1)
{
	struct object *o = parse_object(sha1);

	while (o && o->type == tag_type) {
		struct tag *t = (struct tag *) o;
		if (!t->tagged)
			break; /* broken repository */
		o->flags |= COMPLETE;
		o = parse_object(t->tagged->sha1);
	}
	if (o && o->type == commit_type) {
		struct commit *commit = (struct commit *)o;
		commit->object.flags |= COMPLETE;
		insert_by_date(commit, &complete);
	}
	return 0;
}

static void mark_recent_complete_commits(unsigned long cutoff)
{
	while (complete && cutoff <= complete->item->date) {
		if (verbose)
			fprintf(stderr, "Marking %s as complete\n",
				sha1_to_hex(complete->item->object.sha1));
		pop_most_recent_commit(&complete, COMPLETE);
	}
}

static void filter_refs(struct ref **refs, int nr_match, char **match)
{
	struct ref *prev, *current, *next;

	if (!nr_match)
		return;

	for (prev = NULL, current = *refs; current; current = next) {
		next = current->next;
		if ((!memcmp(current->name, "refs/", 5) &&
					check_ref_format(current->name + 5)) ||
				!path_match(current->name, nr_match, match)) {
			if (prev == NULL)
				*refs = next;
			else
				prev->next = next;
			free(current);
		} else
			prev = current;
	}
}

static int everything_local(struct ref **refs, int nr_match, char **match)
{
	struct ref *ref;
	int retval;
	unsigned long cutoff = 0;

	track_object_refs = 0;
	save_commit_buffer = 0;

	for (ref = *refs; ref; ref = ref->next) {
		struct object *o;

		o = parse_object(ref->old_sha1);
		if (!o)
			continue;

		/* We already have it -- which may mean that we were
		 * in sync with the other side at some time after
		 * that (it is OK if we guess wrong here).
		 */
		if (o->type == commit_type) {
			struct commit *commit = (struct commit *)o;
			if (!cutoff || cutoff < commit->date)
				cutoff = commit->date;
		}
	}

	for_each_ref(mark_complete);
	if (cutoff)
		mark_recent_complete_commits(cutoff);

	/*
	 * Mark all complete remote refs as common refs.
	 * Don't mark them common yet; the server has to be told so first.
	 */
	for (ref = *refs; ref; ref = ref->next) {
		struct object *o = deref_tag(lookup_object(ref->old_sha1),
					     NULL, 0);

		if (!o || o->type != commit_type || !(o->flags & COMPLETE))
			continue;

		if (!(o->flags & SEEN)) {
			rev_list_push((struct commit *)o, COMMON_REF | SEEN);

			mark_common((struct commit *)o, 1, 1);
		}
	}

	filter_refs(refs, nr_match, match);

	for (retval = 1, ref = *refs; ref ; ref = ref->next) {
		const unsigned char *remote = ref->old_sha1;
		unsigned char local[20];
		struct object *o;

		o = lookup_object(remote);
		if (!o || !(o->flags & COMPLETE)) {
			retval = 0;
			if (!verbose)
				continue;
			fprintf(stderr,
				"want %s (%s)\n", sha1_to_hex(remote),
				ref->name);
			continue;
		}

		memcpy(ref->new_sha1, local, 20);
		if (!verbose)
			continue;
		fprintf(stderr,
			"already have %s (%s)\n", sha1_to_hex(remote),
			ref->name);
	}
	return retval;
}

static int fetch_pack(int fd[2], int nr_match, char **match)
{
	struct ref *ref;
	unsigned char sha1[20];
	int status;

	get_remote_heads(fd[0], &ref, 0, NULL, 0);
	if (server_supports("multi_ack")) {
		if (verbose)
			fprintf(stderr, "Server supports multi_ack\n");
		multi_ack = 1;
	}
	if (!ref) {
		packet_flush(fd[1]);
		die("no matching remote head");
	}
	if (everything_local(&ref, nr_match, match)) {
		packet_flush(fd[1]);
		goto all_done;
	}
	if (find_common(fd, sha1, ref) < 0)
		fprintf(stderr, "warning: no common commits\n");

	if (keep_pack)
		status = receive_keep_pack(fd, "git-fetch-pack");
	else
		status = receive_unpack_pack(fd, "git-fetch-pack", quiet);

	if (status)
		die("git-fetch-pack: fetch failed.");

 all_done:
	while (ref) {
		printf("%s %s\n",
		       sha1_to_hex(ref->old_sha1), ref->name);
		ref = ref->next;
	}
	return 0;
}

int main(int argc, char **argv)
{
	int i, ret, nr_heads;
	char *dest = NULL, **heads;
	int fd[2];
	pid_t pid;

	setup_git_directory();

	nr_heads = 0;
	heads = NULL;
	for (i = 1; i < argc; i++) {
		char *arg = argv[i];

		if (*arg == '-') {
			if (!strncmp("--exec=", arg, 7)) {
				exec = arg + 7;
				continue;
			}
			if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
				quiet = 1;
				continue;
			}
			if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
				keep_pack = 1;
				continue;
			}
			if (!strcmp("-v", arg)) {
				verbose = 1;
				continue;
			}
			usage(fetch_pack_usage);
		}
		dest = arg;
		heads = argv + i + 1;
		nr_heads = argc - i - 1;
		break;
	}
	if (!dest)
		usage(fetch_pack_usage);
	pid = git_connect(fd, dest, exec);
	if (pid < 0)
		return 1;
	ret = fetch_pack(fd, nr_heads, heads);
	close(fd[0]);
	close(fd[1]);
	finish_connect(pid);

	if (!ret && nr_heads) {
		/* If the heads to pull were given, we should have
		 * consumed all of them by matching the remote.
		 * Otherwise, 'git-fetch remote no-such-ref' would
		 * silently succeed without issuing an error.
		 */
		for (i = 0; i < nr_heads; i++)
			if (heads[i] && heads[i][0]) {
				error("no such remote ref %s", heads[i]);
				ret = 1;
			}
	}

	return ret;
}
Commit	Line	Data
def88e9a	1	#include "cache.h"
fb9040cc	2	#include "refs.h"
def88e9a	3	#include "pkt-line.h"
49bb805e JH	4	#include "commit.h"
49bb805e JH	5	#include "tag.h"
def88e9a	6
ad897215	7	static int keep_pack;
8b3d9dc0	8	static int quiet;
33b83034 JH	9	static int verbose;
33b83034 JH	10	static const char fetch_pack_usage[] =
ad897215	11	"git-fetch-pack [-q] [-v] [-k] [--exec=upload-pack] [host:]directory <refs>...";
def88e9a LT	12	static const char *exec = "git-upload-pack";
def88e9a LT	13
0a8944dd	14	#define COMPLETE (1U << 0)
23d61f83 JS	15	#define COMMON (1U << 1)
	16	#define COMMON_REF (1U << 2)
	17	#define SEEN (1U << 3)
	18	#define POPPED (1U << 4)
	19
	20	static struct commit_list *rev_list = NULL;
c4c86f07	21	static int non_common_revs = 0, multi_ack = 0;
23d61f83 JS	22
	23	static void rev_list_push(struct commit *commit, int mark)
	24	{
	25	if (!(commit->object.flags & mark)) {
	26	commit->object.flags \|= mark;
	27
	28	if (!(commit->object.parsed))
	29	parse_commit(commit);
	30
	31	insert_by_date(commit, &rev_list);
	32
	33	if (!(commit->object.flags & COMMON))
	34	non_common_revs++;
	35	}
	36	}
	37
	38	static int rev_list_insert_ref(const char path, const unsigned char sha1)
	39	{
9534f40b	40	struct object *o = deref_tag(parse_object(sha1), path, 0);
23d61f83	41
9534f40b	42	if (o && o->type == commit_type)
23d61f83 JS	43	rev_list_push((struct commit *)o, SEEN);
	44
	45	return 0;
	46	}
	47
	48	/*
	49	This function marks a rev and its ancestors as common.
	50	In some cases, it is desirable to mark only the ancestors (for example
	51	when only the server does not yet know that they are common).
	52	*/
	53
	54	static void mark_common(struct commit *commit,
	55	int ancestors_only, int dont_parse)
	56	{
	57	if (commit != NULL && !(commit->object.flags & COMMON)) {
	58	struct object o = (struct object )commit;
	59
	60	if (!ancestors_only)
	61	o->flags \|= COMMON;
	62
	63	if (!(o->flags & SEEN))
	64	rev_list_push(commit, SEEN);
	65	else {
	66	struct commit_list *parents;
	67
	68	if (!ancestors_only && !(o->flags & POPPED))
	69	non_common_revs--;
	70	if (!o->parsed && !dont_parse)
	71	parse_commit(commit);
	72
	73	for (parents = commit->parents;
	74	parents;
	75	parents = parents->next)
	76	mark_common(parents->item, 0, dont_parse);
	77	}
	78	}
	79	}
	80
	81	/*
	82	Get the next rev to send, ignoring the common.
	83	*/
	84
	85	static const unsigned char* get_rev()
	86	{
	87	struct commit *commit = NULL;
	88
	89	while (commit == NULL) {
	90	unsigned int mark;
	91	struct commit_list* parents;
	92
	93	if (rev_list == NULL \|\| non_common_revs == 0)
	94	return NULL;
	95
	96	commit = rev_list->item;
	97	if (!(commit->object.parsed))
	98	parse_commit(commit);
	99	commit->object.flags \|= POPPED;
	100	if (!(commit->object.flags & COMMON))
	101	non_common_revs--;
	102
	103	parents = commit->parents;
	104
	105	if (commit->object.flags & COMMON) {
	106	/* do not send "have", and ignore ancestors */
107	commit = NULL;
108	mark = COMMON \| SEEN;
109	} else if (commit->object.flags & COMMON_REF)
110	/* send "have", and ignore ancestors */
111	mark = COMMON \| SEEN;
112	else
113	/* send "have", also for its ancestors */
114	mark = SEEN;
115
116	while (parents) {
117	if (!(parents->item->object.flags & SEEN))
118	rev_list_push(parents->item, mark);
119	if (mark & COMMON)
120	mark_common(parents->item, 1, 0);
121	parents = parents->next;
122	}
123
124	rev_list = rev_list->next;
125	}
126
127	return commit->object.sha1;
128	}
0a8944dd	129
33b83034 JH	130	static int find_common(int fd[2], unsigned char *result_sha1,
33b83034 JH	131	struct ref *refs)
def88e9a	132	{
2759cbc7	133	int fetching;
23d61f83 JS	134	int count = 0, flushes = 0, retval;
	135	const unsigned char *sha1;
	136
	137	for_each_ref(rev_list_insert_ref);
def88e9a	138
2759cbc7 LT	139	fetching = 0;
2759cbc7 LT	140	for ( ; refs ; refs = refs->next) {
33b83034	141	unsigned char *remote = refs->old_sha1;
4dab94d5	142	struct object *o;
2759cbc7	143
0a8944dd	144	/*
4dab94d5 JH	145	* If that object is complete (i.e. it is an ancestor of a
	146	* local ref), we tell them we have it but do not have to
	147	* tell them about its ancestors, which they already know
	148	* about.
f1f0a2be JH	149	*
	150	* We use lookup_object here because we are only
	151	* interested in the case we know the object is
	152	* reachable and we have already scanned it.
4dab94d5	153	*/
f1f0a2be	154	if (((o = lookup_object(remote)) != NULL) &&
1baaae5e	155	(o->flags & COMPLETE)) {
2759cbc7	156	continue;
0a8944dd	157	}
23d61f83	158
c4c86f07 JS	159	packet_write(fd[1], "want %s%s\n", sha1_to_hex(remote),
c4c86f07 JS	160	multi_ack ? " multi_ack" : "");
2759cbc7	161	fetching++;
33b83034	162	}
fb9040cc	163	packet_flush(fd[1]);
2759cbc7 LT	164	if (!fetching)
2759cbc7 LT	165	return 1;
0a8944dd	166
23d61f83	167	flushes = 0;
75bfc6c2	168	retval = -1;
23d61f83	169	while ((sha1 = get_rev())) {
def88e9a	170	packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
33b83034 JH	171	if (verbose)
33b83034 JH	172	fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
def88e9a	173	if (!(31 & ++count)) {
c4c86f07 JS	174	int ack;
c4c86f07 JS	175
def88e9a LT	176	packet_flush(fd[1]);
	177	flushes++;
	178
	179	/*
	180	* We keep one window "ahead" of the other side, and
	181	* will wait for an ACK only on the next one
	182	*/
	183	if (count == 32)
	184	continue;
c4c86f07 JS	185
	186	do {
	187	ack = get_ack(fd[0], result_sha1);
	188	if (verbose && ack)
	189	fprintf(stderr, "got ack %d %s\n", ack,
	190	sha1_to_hex(result_sha1));
	191	if (ack == 1) {
	192	flushes = 0;
	193	multi_ack = 0;
	194	retval = 0;
	195	goto done;
	196	} else if (ack == 2) {
	197	struct commit *commit =
	198	lookup_commit(result_sha1);
	199	mark_common(commit, 0, 1);
	200	retval = 0;
	201	}
	202	} while (ack);
def88e9a LT	203	flushes--;
	204	}
	205	}
c4c86f07	206	done:
75bfc6c2	207	packet_write(fd[1], "done\n");
33b83034 JH	208	if (verbose)
33b83034 JH	209	fprintf(stderr, "done\n");
c4c86f07 JS	210	if (retval != 0) {
c4c86f07 JS	211	multi_ack = 0;
23d61f83	212	flushes++;
c4c86f07 JS	213	}
	214	while (flushes \|\| multi_ack) {
	215	int ack = get_ack(fd[0], result_sha1);
	216	if (ack) {
33b83034	217	if (verbose)
c4c86f07 JS	218	fprintf(stderr, "got ack (%d) %s\n", ack,
	219	sha1_to_hex(result_sha1));
	220	if (ack == 1)
	221	return 0;
	222	multi_ack = 1;
	223	continue;
33b83034	224	}
c4c86f07	225	flushes--;
def88e9a	226	}
75bfc6c2	227	return retval;
def88e9a LT	228	}
def88e9a LT	229
49bb805e JH	230	static struct commit_list *complete = NULL;
	231
	232	static int mark_complete(const char path, const unsigned char sha1)
	233	{
	234	struct object *o = parse_object(sha1);
	235
	236	while (o && o->type == tag_type) {
f1f0a2be JH	237	struct tag t = (struct tag ) o;
	238	if (!t->tagged)
	239	break; /* broken repository */
49bb805e	240	o->flags \|= COMPLETE;
f1f0a2be	241	o = parse_object(t->tagged->sha1);
49bb805e	242	}
f1f0a2be	243	if (o && o->type == commit_type) {
49bb805e JH	244	struct commit commit = (struct commit )o;
	245	commit->object.flags \|= COMPLETE;
	246	insert_by_date(commit, &complete);
	247	}
	248	return 0;
	249	}
	250
	251	static void mark_recent_complete_commits(unsigned long cutoff)
	252	{
	253	while (complete && cutoff <= complete->item->date) {
	254	if (verbose)
	255	fprintf(stderr, "Marking %s as complete\n",
	256	sha1_to_hex(complete->item->object.sha1));
	257	pop_most_recent_commit(&complete, COMPLETE);
	258	}
	259	}
	260
1baaae5e JS	261	static void filter_refs(struct ref refs, int nr_match, char match)
	262	{
	263	struct ref prev, current, *next;
	264
	265	if (!nr_match)
	266	return;
	267
	268	for (prev = NULL, current = *refs; current; current = next) {
	269	next = current->next;
	270	if ((!memcmp(current->name, "refs/", 5) &&
	271	check_ref_format(current->name + 5)) \|\|
	272	!path_match(current->name, nr_match, match)) {
	273	if (prev == NULL)
	274	*refs = next;
	275	else
	276	prev->next = next;
	277	free(current);
	278	} else
	279	prev = current;
	280	}
	281	}
	282
	283	static int everything_local(struct ref refs, int nr_match, char match)
2759cbc7	284	{
49bb805e	285	struct ref *ref;
2759cbc7	286	int retval;
49bb805e JH	287	unsigned long cutoff = 0;
	288
	289	track_object_refs = 0;
	290	save_commit_buffer = 0;
	291
1baaae5e	292	for (ref = *refs; ref; ref = ref->next) {
49bb805e JH	293	struct object *o;
	294
	295	o = parse_object(ref->old_sha1);
	296	if (!o)
	297	continue;
	298
	299	/* We already have it -- which may mean that we were
	300	* in sync with the other side at some time after
	301	* that (it is OK if we guess wrong here).
	302	*/
	303	if (o->type == commit_type) {
	304	struct commit commit = (struct commit )o;
	305	if (!cutoff \|\| cutoff < commit->date)
	306	cutoff = commit->date;
	307	}
	308	}
	309
	310	for_each_ref(mark_complete);
	311	if (cutoff)
	312	mark_recent_complete_commits(cutoff);
2759cbc7	313
1baaae5e JS	314	/*
	315	* Mark all complete remote refs as common refs.
	316	* Don't mark them common yet; the server has to be told so first.
	317	*/
	318	for (ref = *refs; ref; ref = ref->next) {
9534f40b JH	319	struct object *o = deref_tag(lookup_object(ref->old_sha1),
9534f40b JH	320	NULL, 0);
1baaae5e JS	321
	322	if (!o \|\| o->type != commit_type \|\| !(o->flags & COMPLETE))
	323	continue;
	324
	325	if (!(o->flags & SEEN)) {
	326	rev_list_push((struct commit *)o, COMMON_REF \| SEEN);
	327
	328	mark_common((struct commit *)o, 1, 1);
	329	}
	330	}
	331
	332	filter_refs(refs, nr_match, match);
	333
	334	for (retval = 1, ref = *refs; ref ; ref = ref->next) {
	335	const unsigned char *remote = ref->old_sha1;
2759cbc7	336	unsigned char local[20];
49bb805e	337	struct object *o;
2759cbc7	338
1baaae5e	339	o = lookup_object(remote);
49bb805e	340	if (!o \|\| !(o->flags & COMPLETE)) {
2759cbc7 LT	341	retval = 0;
	342	if (!verbose)
	343	continue;
	344	fprintf(stderr,
	345	"want %s (%s)\n", sha1_to_hex(remote),
1baaae5e	346	ref->name);
2759cbc7 LT	347	continue;
	348	}
	349
1baaae5e	350	memcpy(ref->new_sha1, local, 20);
2759cbc7 LT	351	if (!verbose)
	352	continue;
	353	fprintf(stderr,
	354	"already have %s (%s)\n", sha1_to_hex(remote),
1baaae5e	355	ref->name);
2759cbc7 LT	356	}
	357	return retval;
	358	}
	359
def88e9a LT	360	static int fetch_pack(int fd[2], int nr_match, char **match)
def88e9a LT	361	{
d1c133f5 LT	362	struct ref *ref;
	363	unsigned char sha1[20];
	364	int status;
def88e9a	365
1baaae5e	366	get_remote_heads(fd[0], &ref, 0, NULL, 0);
c4c86f07 JS	367	if (server_supports("multi_ack")) {
	368	if (verbose)
	369	fprintf(stderr, "Server supports multi_ack\n");
	370	multi_ack = 1;
	371	}
d1c133f5 LT	372	if (!ref) {
	373	packet_flush(fd[1]);
	374	die("no matching remote head");
	375	}
1baaae5e	376	if (everything_local(&ref, nr_match, match)) {
2759cbc7 LT	377	packet_flush(fd[1]);
	378	goto all_done;
	379	}
33b83034 JH	380	if (find_common(fd, sha1, ref) < 0)
33b83034 JH	381	fprintf(stderr, "warning: no common commits\n");
ad897215 JH	382
	383	if (keep_pack)
	384	status = receive_keep_pack(fd, "git-fetch-pack");
	385	else
	386	status = receive_unpack_pack(fd, "git-fetch-pack", quiet);
	387
	388	if (status)
	389	die("git-fetch-pack: fetch failed.");
	390
	391	all_done:
	392	while (ref) {
	393	printf("%s %s\n",
	394	sha1_to_hex(ref->old_sha1), ref->name);
	395	ref = ref->next;
75bfc6c2	396	}
ad897215	397	return 0;
def88e9a LT	398	}
	399
	400	int main(int argc, char **argv)
	401	{
	402	int i, ret, nr_heads;
	403	char dest = NULL, *heads;
	404	int fd[2];
	405	pid_t pid;
	406
5a327713 JH	407	setup_git_directory();
5a327713 JH	408
def88e9a LT	409	nr_heads = 0;
	410	heads = NULL;
	411	for (i = 1; i < argc; i++) {
	412	char *arg = argv[i];
	413
	414	if (*arg == '-') {
8b3d9dc0 JH	415	if (!strncmp("--exec=", arg, 7)) {
	416	exec = arg + 7;
	417	continue;
	418	}
2247efb4	419	if (!strcmp("--quiet", arg) \|\| !strcmp("-q", arg)) {
33b83034 JH	420	quiet = 1;
	421	continue;
	422	}
2247efb4	423	if (!strcmp("--keep", arg) \|\| !strcmp("-k", arg)) {
ad897215 JH	424	keep_pack = 1;
	425	continue;
	426	}
33b83034 JH	427	if (!strcmp("-v", arg)) {
	428	verbose = 1;
	429	continue;
	430	}
def88e9a LT	431	usage(fetch_pack_usage);
	432	}
	433	dest = arg;
	434	heads = argv + i + 1;
	435	nr_heads = argc - i - 1;
	436	break;
	437	}
	438	if (!dest)
	439	usage(fetch_pack_usage);
	440	pid = git_connect(fd, dest, exec);
	441	if (pid < 0)
	442	return 1;
	443	ret = fetch_pack(fd, nr_heads, heads);
	444	close(fd[0]);
	445	close(fd[1]);
	446	finish_connect(pid);
9e5d2b40 JH	447
	448	if (!ret && nr_heads) {
	449	/* If the heads to pull were given, we should have
	450	* consumed all of them by matching the remote.
	451	* Otherwise, 'git-fetch remote no-such-ref' would
	452	* silently succeed without issuing an error.
	453	*/
	454	for (i = 0; i < nr_heads; i++)
	455	if (heads[i] && heads[i][0]) {
	456	error("no such remote ref %s", heads[i]);
	457	ret = 1;
	458	}
	459	}
	460
def88e9a LT	461	return ret;
def88e9a LT	462	}