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

#include "cache.h"
#include "refs.h"
#include "pkt-line.h"
#include "commit.h"
#include "tag.h"
#include <time.h>
#include <sys/wait.h>

static int quiet;
static int verbose;
static const char fetch_pack_usage[] =
"git-fetch-pack [-q] [-v] [--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;
	pid_t pid;

	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");
	pid = fork();
	if (pid < 0)
		die("git-fetch-pack: unable to fork off git-unpack-objects");
	if (!pid) {
		dup2(fd[0], 0);
		close(fd[0]);
		close(fd[1]);
		execlp("git-unpack-objects", "git-unpack-objects",
		       quiet ? "-q" : NULL, NULL);
		die("git-unpack-objects exec failed");
	}
	close(fd[0]);
	close(fd[1]);
	while (waitpid(pid, &status, 0) < 0) {
		if (errno != EINTR)
			die("waiting for git-unpack-objects: %s", strerror(errno));
	}
	if (WIFEXITED(status)) {
		int code = WEXITSTATUS(status);
		if (code)
			die("git-unpack-objects died with error code %d", code);
all_done:
		while (ref) {
			printf("%s %s\n",
			       sha1_to_hex(ref->old_sha1), ref->name);
			ref = ref->next;
		}
		return 0;
	}
	if (WIFSIGNALED(status)) {
		int sig = WTERMSIG(status);
		die("git-unpack-objects died of signal %d", sig);
	}
	die("Sherlock Holmes! git-unpack-objects died of unnatural causes %d!", status);
}

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

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