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

/*
 * "git fetch"
 */
#include "cache.h"
#include "refs.h"
#include "commit.h"
#include "builtin.h"
#include "path-list.h"
#include "remote.h"
#include "transport.h"

static const char fetch_usage[] = "git-fetch [-a | --append] [--upload-pack <upload-pack>] [-f | --force] [--no-tags] [-t | --tags] [-k | --keep] [-u | --update-head-ok] [--depth <depth>] [-v | --verbose] [<repository> <refspec>...]";

static int append, force, tags, no_tags, update_head_ok, verbose, quiet;
static char *default_rla = NULL;
static struct transport *transport;

static void unlock_pack(void)
{
	if (transport)
		transport_unlock_pack(transport);
}

static void unlock_pack_on_signal(int signo)
{
	unlock_pack();
	signal(SIGINT, SIG_DFL);
	raise(signo);
}

static void add_merge_config(struct ref **head,
		           struct ref *remote_refs,
		           struct branch *branch,
		           struct ref ***tail)
{
	int i;

	for (i = 0; i < branch->merge_nr; i++) {
		struct ref *rm, **old_tail = *tail;
		struct refspec refspec;

		for (rm = *head; rm; rm = rm->next) {
			if (branch_merge_matches(branch, i, rm->name)) {
				rm->merge = 1;
				break;
			}
		}
		if (rm)
			continue;

		/* Not fetched to a tracking branch?  We need to fetch
		 * it anyway to allow this branch's "branch.$name.merge"
		 * to be honored by git-pull.
		 */
		refspec.src = branch->merge[i]->src;
		refspec.dst = NULL;
		refspec.pattern = 0;
		refspec.force = 0;
		get_fetch_map(remote_refs, &refspec, tail);
		for (rm = *old_tail; rm; rm = rm->next)
			rm->merge = 1;
	}
}

static struct ref *get_ref_map(struct transport *transport,
			       struct refspec *refs, int ref_count, int tags,
			       int *autotags)
{
	int i;
	struct ref *rm;
	struct ref *ref_map = NULL;
	struct ref **tail = &ref_map;

	struct ref *remote_refs = transport_get_remote_refs(transport);

	if (ref_count || tags) {
		for (i = 0; i < ref_count; i++) {
			get_fetch_map(remote_refs, &refs[i], &tail);
			if (refs[i].dst && refs[i].dst[0])
				*autotags = 1;
		}
		/* Merge everything on the command line, but not --tags */
		for (rm = ref_map; rm; rm = rm->next)
			rm->merge = 1;
		if (tags) {
			struct refspec refspec;
			refspec.src = "refs/tags/";
			refspec.dst = "refs/tags/";
			refspec.pattern = 1;
			refspec.force = 0;
			get_fetch_map(remote_refs, &refspec, &tail);
		}
	} else {
		/* Use the defaults */
		struct remote *remote = transport->remote;
		struct branch *branch = branch_get(NULL);
		int has_merge = branch_has_merge_config(branch);
		if (remote && (remote->fetch_refspec_nr || has_merge)) {
			for (i = 0; i < remote->fetch_refspec_nr; i++) {
				get_fetch_map(remote_refs, &remote->fetch[i], &tail);
				if (remote->fetch[i].dst &&
				    remote->fetch[i].dst[0])
					*autotags = 1;
				if (!i && !has_merge && ref_map &&
				    !strcmp(remote->fetch[0].src, ref_map->name))
					ref_map->merge = 1;
			}
			if (has_merge)
				add_merge_config(&ref_map, remote_refs, branch, &tail);
		} else {
			ref_map = get_remote_ref(remote_refs, "HEAD");
			ref_map->merge = 1;
		}
	}

	return ref_map;
}

static void show_new(enum object_type type, unsigned char *sha1_new)
{
	fprintf(stderr, "  %s: %s\n", typename(type),
		find_unique_abbrev(sha1_new, DEFAULT_ABBREV));
}

static int s_update_ref(const char *action,
			struct ref *ref,
			int check_old)
{
	char msg[1024];
	char *rla = getenv("GIT_REFLOG_ACTION");
	static struct ref_lock *lock;

	if (!rla)
		rla = default_rla;
	snprintf(msg, sizeof(msg), "%s: %s", rla, action);
	lock = lock_any_ref_for_update(ref->name,
				       check_old ? ref->old_sha1 : NULL, 0);
	if (!lock)
		return 1;
	if (write_ref_sha1(lock, ref->new_sha1, msg) < 0)
		return 1;
	return 0;
}

static int update_local_ref(struct ref *ref,
			    const char *note,
			    int verbose)
{
	char oldh[41], newh[41];
	struct commit *current = NULL, *updated;
	enum object_type type;
	struct branch *current_branch = branch_get(NULL);

	type = sha1_object_info(ref->new_sha1, NULL);
	if (type < 0)
		die("object %s not found", sha1_to_hex(ref->new_sha1));

	if (!*ref->name) {
		/* Not storing */
		if (verbose) {
			fprintf(stderr, "* fetched %s\n", note);
			show_new(type, ref->new_sha1);
		}
		return 0;
	}

	if (!hashcmp(ref->old_sha1, ref->new_sha1)) {
		if (verbose) {
			fprintf(stderr, "* %s: same as %s\n",
				ref->name, note);
			show_new(type, ref->new_sha1);
		}
		return 0;
	}

	if (current_branch &&
	    !strcmp(ref->name, current_branch->name) &&
	    !(update_head_ok || is_bare_repository()) &&
	    !is_null_sha1(ref->old_sha1)) {
		/*
		 * If this is the head, and it's not okay to update
		 * the head, and the old value of the head isn't empty...
		 */
		fprintf(stderr,
			" * %s: Cannot fetch into the current branch.\n",
			ref->name);
		return 1;
	}

	if (!is_null_sha1(ref->old_sha1) &&
	    !prefixcmp(ref->name, "refs/tags/")) {
		fprintf(stderr, "* %s: updating with %s\n",
			ref->name, note);
		show_new(type, ref->new_sha1);
		return s_update_ref("updating tag", ref, 0);
	}

	current = lookup_commit_reference(ref->old_sha1);
	updated = lookup_commit_reference(ref->new_sha1);
	if (!current || !updated) {
		char *msg;
		if (!strncmp(ref->name, "refs/tags/", 10))
			msg = "storing tag";
		else
			msg = "storing head";
		fprintf(stderr, "* %s: storing %s\n",
			ref->name, note);
		show_new(type, ref->new_sha1);
		return s_update_ref(msg, ref, 0);
	}

	strcpy(oldh, find_unique_abbrev(current->object.sha1, DEFAULT_ABBREV));
	strcpy(newh, find_unique_abbrev(ref->new_sha1, DEFAULT_ABBREV));

	if (in_merge_bases(current, &updated, 1)) {
		fprintf(stderr, "* %s: fast forward to %s\n",
			ref->name, note);
		fprintf(stderr, "  old..new: %s..%s\n", oldh, newh);
		return s_update_ref("fast forward", ref, 1);
	}
	if (!force && !ref->force) {
		fprintf(stderr,
			"* %s: not updating to non-fast forward %s\n",
			ref->name, note);
		fprintf(stderr,
			"  old...new: %s...%s\n", oldh, newh);
		return 1;
	}
	fprintf(stderr,
		"* %s: forcing update to non-fast forward %s\n",
		ref->name, note);
	fprintf(stderr, "  old...new: %s...%s\n", oldh, newh);
	return s_update_ref("forced-update", ref, 1);
}

static void store_updated_refs(const char *url, struct ref *ref_map)
{
	FILE *fp;
	struct commit *commit;
	int url_len, i, note_len;
	char note[1024];
	const char *what, *kind;
	struct ref *rm;

	fp = fopen(git_path("FETCH_HEAD"), "a");
	for (rm = ref_map; rm; rm = rm->next) {
		struct ref *ref = NULL;

		if (rm->peer_ref) {
			ref = xcalloc(1, sizeof(*ref) + strlen(rm->peer_ref->name) + 1);
			strcpy(ref->name, rm->peer_ref->name);
			hashcpy(ref->old_sha1, rm->peer_ref->old_sha1);
			hashcpy(ref->new_sha1, rm->old_sha1);
			ref->force = rm->peer_ref->force;
		}

		commit = lookup_commit_reference(rm->old_sha1);
		if (!commit)
			rm->merge = 0;

		if (!strcmp(rm->name, "HEAD")) {
			kind = "";
			what = "";
		}
		else if (!prefixcmp(rm->name, "refs/heads/")) {
			kind = "branch";
			what = rm->name + 11;
		}
		else if (!prefixcmp(rm->name, "refs/tags/")) {
			kind = "tag";
			what = rm->name + 10;
		}
		else if (!prefixcmp(rm->name, "refs/remotes/")) {
			kind = "remote branch";
			what = rm->name + 13;
		}
		else {
			kind = "";
			what = rm->name;
		}

		url_len = strlen(url);
		for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
			;
		url_len = i + 1;
		if (4 < i && !strncmp(".git", url + i - 3, 4))
			url_len = i - 3;

		note_len = 0;
		if (*what) {
			if (*kind)
				note_len += sprintf(note + note_len, "%s ",
						    kind);
			note_len += sprintf(note + note_len, "'%s' of ", what);
		}
		note_len += sprintf(note + note_len, "%.*s", url_len, url);
		fprintf(fp, "%s\t%s\t%s\n",
			sha1_to_hex(commit ? commit->object.sha1 :
				    rm->old_sha1),
			rm->merge ? "" : "not-for-merge",
			note);

		if (ref)
			update_local_ref(ref, note, verbose);
	}
	fclose(fp);
}

static int fetch_refs(struct transport *transport, struct ref *ref_map)
{
	int ret = transport_fetch_refs(transport, ref_map);
	if (!ret)
		store_updated_refs(transport->url, ref_map);
	transport_unlock_pack(transport);
	return ret;
}

static int add_existing(const char *refname, const unsigned char *sha1,
			int flag, void *cbdata)
{
	struct path_list *list = (struct path_list *)cbdata;
	path_list_insert(refname, list);
	return 0;
}

static struct ref *find_non_local_tags(struct transport *transport,
				       struct ref *fetch_map)
{
	static struct path_list existing_refs = { NULL, 0, 0, 0 };
	struct path_list new_refs = { NULL, 0, 0, 1 };
	char *ref_name;
	int ref_name_len;
	unsigned char *ref_sha1;
	struct ref *tag_ref;
	struct ref *rm = NULL;
	struct ref *ref_map = NULL;
	struct ref **tail = &ref_map;
	struct ref *ref;

	for_each_ref(add_existing, &existing_refs);
	for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
		if (prefixcmp(ref->name, "refs/tags"))
			continue;

		ref_name = xstrdup(ref->name);
		ref_name_len = strlen(ref_name);
		ref_sha1 = ref->old_sha1;

		if (!strcmp(ref_name + ref_name_len - 3, "^{}")) {
			ref_name[ref_name_len - 3] = 0;
			tag_ref = transport_get_remote_refs(transport);
			while (tag_ref) {
				if (!strcmp(tag_ref->name, ref_name)) {
					ref_sha1 = tag_ref->old_sha1;
					break;
				}
				tag_ref = tag_ref->next;
			}
		}

		if (!path_list_has_path(&existing_refs, ref_name) &&
		    !path_list_has_path(&new_refs, ref_name) &&
		    lookup_object(ref->old_sha1)) {
			fprintf(stderr, "Auto-following %s\n",
				ref_name);

			path_list_insert(ref_name, &new_refs);

			rm = alloc_ref(strlen(ref_name) + 1);
			strcpy(rm->name, ref_name);
			rm->peer_ref = alloc_ref(strlen(ref_name) + 1);
			strcpy(rm->peer_ref->name, ref_name);
			hashcpy(rm->old_sha1, ref_sha1);

			*tail = rm;
			tail = &rm->next;
		}
		free(ref_name);
	}

	return ref_map;
}

static int do_fetch(struct transport *transport,
		    struct refspec *refs, int ref_count)
{
	struct ref *ref_map, *fetch_map;
	struct ref *rm;
	int autotags = (transport->remote->fetch_tags == 1);
	if (transport->remote->fetch_tags == 2 && !no_tags)
		tags = 1;
	if (transport->remote->fetch_tags == -1)
		no_tags = 1;

	if (!transport->get_refs_list || !transport->fetch)
		die("Don't know how to fetch from %s", transport->url);

	/* if not appending, truncate FETCH_HEAD */
	if (!append)
		fclose(fopen(git_path("FETCH_HEAD"), "w"));

	ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);

	for (rm = ref_map; rm; rm = rm->next) {
		if (rm->peer_ref)
			read_ref(rm->peer_ref->name, rm->peer_ref->old_sha1);
	}

	if (fetch_refs(transport, ref_map)) {
		free_refs(ref_map);
		return 1;
	}

	fetch_map = ref_map;

	/* if neither --no-tags nor --tags was specified, do automated tag
	 * following ... */
	if (!(tags || no_tags) && autotags) {
		ref_map = find_non_local_tags(transport, fetch_map);
		if (ref_map) {
			transport_set_option(transport, TRANS_OPT_DEPTH, "0");
			fetch_refs(transport, ref_map);
		}
		free_refs(ref_map);
	}

	free_refs(fetch_map);

	return 0;
}

static void set_option(const char *name, const char *value)
{
	int r = transport_set_option(transport, name, value);
	if (r < 0)
		die("Option \"%s\" value \"%s\" is not valid for %s\n",
			name, value, transport->url);
	if (r > 0)
		warning("Option \"%s\" is ignored for %s\n",
			name, transport->url);
}

int cmd_fetch(int argc, const char **argv, const char *prefix)
{
	struct remote *remote;
	int i, j, rla_offset;
	static const char **refs = NULL;
	int ref_nr = 0;
	int cmd_len = 0;
	const char *depth = NULL, *upload_pack = NULL;
	int keep = 0;

	for (i = 1; i < argc; i++) {
		const char *arg = argv[i];
		cmd_len += strlen(arg);

		if (arg[0] != '-')
			break;
		if (!strcmp(arg, "--append") || !strcmp(arg, "-a")) {
			append = 1;
			continue;
		}
		if (!prefixcmp(arg, "--upload-pack=")) {
			upload_pack = arg + 14;
			continue;
		}
		if (!strcmp(arg, "--upload-pack")) {
			i++;
			if (i == argc)
				usage(fetch_usage);
			upload_pack = argv[i];
			continue;
		}
		if (!strcmp(arg, "--force") || !strcmp(arg, "-f")) {
			force = 1;
			continue;
		}
		if (!strcmp(arg, "--no-tags")) {
			no_tags = 1;
			continue;
		}
		if (!strcmp(arg, "--tags") || !strcmp(arg, "-t")) {
			tags = 1;
			continue;
		}
		if (!strcmp(arg, "--keep") || !strcmp(arg, "-k")) {
			keep = 1;
			continue;
		}
		if (!strcmp(arg, "--update-head-ok") || !strcmp(arg, "-u")) {
			update_head_ok = 1;
			continue;
		}
		if (!prefixcmp(arg, "--depth=")) {
			depth = arg + 8;
			continue;
		}
		if (!strcmp(arg, "--depth")) {
			i++;
			if (i == argc)
				usage(fetch_usage);
			depth = argv[i];
			continue;
		}
		if (!strcmp(arg, "--quiet")) {
			quiet = 1;
			continue;
		}
		if (!strcmp(arg, "--verbose") || !strcmp(arg, "-v")) {
			verbose++;
			continue;
		}
		usage(fetch_usage);
	}

	for (j = i; j < argc; j++)
		cmd_len += strlen(argv[j]);

	default_rla = xmalloc(cmd_len + 5 + argc + 1);
	sprintf(default_rla, "fetch");
	rla_offset = strlen(default_rla);
	for (j = 1; j < argc; j++) {
		sprintf(default_rla + rla_offset, " %s", argv[j]);
		rla_offset += strlen(argv[j]) + 1;
	}

	if (i == argc)
		remote = remote_get(NULL);
	else
		remote = remote_get(argv[i++]);

	transport = transport_get(remote, remote->url[0]);
	if (verbose >= 2)
		transport->verbose = 1;
	if (quiet)
		transport->verbose = 0;
	if (upload_pack)
		set_option(TRANS_OPT_UPLOADPACK, upload_pack);
	if (keep)
		set_option(TRANS_OPT_KEEP, "yes");
	if (depth)
		set_option(TRANS_OPT_DEPTH, depth);

	if (!transport->url)
		die("Where do you want to fetch from today?");

	if (i < argc) {
		int j = 0;
		refs = xcalloc(argc - i + 1, sizeof(const char *));
		while (i < argc) {
			if (!strcmp(argv[i], "tag")) {
				char *ref;
				i++;
				ref = xmalloc(strlen(argv[i]) * 2 + 22);
				strcpy(ref, "refs/tags/");
				strcat(ref, argv[i]);
				strcat(ref, ":refs/tags/");
				strcat(ref, argv[i]);
				refs[j++] = ref;
			} else
				refs[j++] = argv[i];
			i++;
		}
		refs[j] = NULL;
		ref_nr = j;
	}

	signal(SIGINT, unlock_pack_on_signal);
	atexit(unlock_pack);
	return do_fetch(transport, parse_ref_spec(ref_nr, refs), ref_nr);
}
Commit	Line	Data
b888d61c DB	1	/*
	2	* "git fetch"
	3	*/
	4	#include "cache.h"
	5	#include "refs.h"
	6	#include "commit.h"
	7	#include "builtin.h"
	8	#include "path-list.h"
	9	#include "remote.h"
	10	#include "transport.h"
	11
	12	static const char fetch_usage[] = "git-fetch [-a \| --append] [--upload-pack <upload-pack>] [-f \| --force] [--no-tags] [-t \| --tags] [-k \| --keep] [-u \| --update-head-ok] [--depth <depth>] [-v \| --verbose] [<repository> <refspec>...]";
	13
	14	static int append, force, tags, no_tags, update_head_ok, verbose, quiet;
b888d61c	15	static char *default_rla = NULL;
e4022ed2 SP	16	static struct transport *transport;
	17
	18	static void unlock_pack(void)
	19	{
	20	if (transport)
	21	transport_unlock_pack(transport);
	22	}
	23
	24	static void unlock_pack_on_signal(int signo)
	25	{
	26	unlock_pack();
	27	signal(SIGINT, SIG_DFL);
	28	raise(signo);
	29	}
b888d61c	30
85682c19 SP	31	static void add_merge_config(struct ref **head,
	32	struct ref *remote_refs,
	33	struct branch *branch,
	34	struct ref ***tail)
b888d61c	35	{
85682c19	36	int i;
b888d61c	37
85682c19 SP	38	for (i = 0; i < branch->merge_nr; i++) {
	39	struct ref rm, old_tail = tail;
	40	struct refspec refspec;
	41
	42	for (rm = *head; rm; rm = rm->next) {
	43	if (branch_merge_matches(branch, i, rm->name)) {
b888d61c	44	rm->merge = 1;
85682c19 SP	45	break;
85682c19 SP	46	}
b888d61c	47	}
85682c19 SP	48	if (rm)
	49	continue;
	50
	51	/* Not fetched to a tracking branch? We need to fetch
	52	* it anyway to allow this branch's "branch.$name.merge"
	53	* to be honored by git-pull.
	54	*/
	55	refspec.src = branch->merge[i]->src;
	56	refspec.dst = NULL;
	57	refspec.pattern = 0;
	58	refspec.force = 0;
	59	get_fetch_map(remote_refs, &refspec, tail);
	60	for (rm = *old_tail; rm; rm = rm->next)
	61	rm->merge = 1;
b888d61c DB	62	}
	63	}
	64
	65	static struct ref get_ref_map(struct transport transport,
	66	struct refspec *refs, int ref_count, int tags,
	67	int *autotags)
	68	{
	69	int i;
	70	struct ref *rm;
	71	struct ref *ref_map = NULL;
	72	struct ref **tail = &ref_map;
	73
	74	struct ref *remote_refs = transport_get_remote_refs(transport);
	75
	76	if (ref_count \|\| tags) {
	77	for (i = 0; i < ref_count; i++) {
	78	get_fetch_map(remote_refs, &refs[i], &tail);
	79	if (refs[i].dst && refs[i].dst[0])
	80	*autotags = 1;
	81	}
	82	/* Merge everything on the command line, but not --tags */
	83	for (rm = ref_map; rm; rm = rm->next)
	84	rm->merge = 1;
	85	if (tags) {
	86	struct refspec refspec;
	87	refspec.src = "refs/tags/";
	88	refspec.dst = "refs/tags/";
	89	refspec.pattern = 1;
	90	refspec.force = 0;
	91	get_fetch_map(remote_refs, &refspec, &tail);
	92	}
	93	} else {
	94	/* Use the defaults */
	95	struct remote *remote = transport->remote;
85682c19 SP	96	struct branch *branch = branch_get(NULL);
	97	int has_merge = branch_has_merge_config(branch);
	98	if (remote && (remote->fetch_refspec_nr \|\| has_merge)) {
b888d61c DB	99	for (i = 0; i < remote->fetch_refspec_nr; i++) {
	100	get_fetch_map(remote_refs, &remote->fetch[i], &tail);
	101	if (remote->fetch[i].dst &&
	102	remote->fetch[i].dst[0])
	103	*autotags = 1;
85682c19 SP	104	if (!i && !has_merge && ref_map &&
	105	!strcmp(remote->fetch[0].src, ref_map->name))
	106	ref_map->merge = 1;
b888d61c	107	}
85682c19 SP	108	if (has_merge)
85682c19 SP	109	add_merge_config(&ref_map, remote_refs, branch, &tail);
b888d61c DB	110	} else {
b888d61c DB	111	ref_map = get_remote_ref(remote_refs, "HEAD");
b888d61c DB	112	ref_map->merge = 1;
	113	}
	114	}
	115
	116	return ref_map;
	117	}
	118
	119	static void show_new(enum object_type type, unsigned char *sha1_new)
	120	{
	121	fprintf(stderr, " %s: %s\n", typename(type),
	122	find_unique_abbrev(sha1_new, DEFAULT_ABBREV));
	123	}
	124
	125	static int s_update_ref(const char *action,
	126	struct ref *ref,
	127	int check_old)
	128	{
	129	char msg[1024];
	130	char *rla = getenv("GIT_REFLOG_ACTION");
	131	static struct ref_lock *lock;
	132
	133	if (!rla)
	134	rla = default_rla;
	135	snprintf(msg, sizeof(msg), "%s: %s", rla, action);
	136	lock = lock_any_ref_for_update(ref->name,
	137	check_old ? ref->old_sha1 : NULL, 0);
	138	if (!lock)
	139	return 1;
	140	if (write_ref_sha1(lock, ref->new_sha1, msg) < 0)
	141	return 1;
	142	return 0;
	143	}
	144
	145	static int update_local_ref(struct ref *ref,
	146	const char *note,
	147	int verbose)
	148	{
	149	char oldh[41], newh[41];
	150	struct commit current = NULL, updated;
	151	enum object_type type;
	152	struct branch *current_branch = branch_get(NULL);
	153
	154	type = sha1_object_info(ref->new_sha1, NULL);
	155	if (type < 0)
	156	die("object %s not found", sha1_to_hex(ref->new_sha1));
	157
	158	if (!*ref->name) {
	159	/* Not storing */
	160	if (verbose) {
	161	fprintf(stderr, "* fetched %s\n", note);
	162	show_new(type, ref->new_sha1);
	163	}
	164	return 0;
	165	}
	166
	167	if (!hashcmp(ref->old_sha1, ref->new_sha1)) {
	168	if (verbose) {
	169	fprintf(stderr, "* %s: same as %s\n",
	170	ref->name, note);
	171	show_new(type, ref->new_sha1);
	172	}
	173	return 0;
	174	}
	175
b3abdd9d SP	176	if (current_branch &&
b3abdd9d SP	177	!strcmp(ref->name, current_branch->name) &&
b888d61c DB	178	!(update_head_ok \|\| is_bare_repository()) &&
	179	!is_null_sha1(ref->old_sha1)) {
	180	/*
	181	* If this is the head, and it's not okay to update
	182	* the head, and the old value of the head isn't empty...
	183	*/
	184	fprintf(stderr,
	185	" * %s: Cannot fetch into the current branch.\n",
	186	ref->name);
	187	return 1;
	188	}
	189
	190	if (!is_null_sha1(ref->old_sha1) &&
	191	!prefixcmp(ref->name, "refs/tags/")) {
	192	fprintf(stderr, "* %s: updating with %s\n",
	193	ref->name, note);
	194	show_new(type, ref->new_sha1);
	195	return s_update_ref("updating tag", ref, 0);
	196	}
	197
	198	current = lookup_commit_reference(ref->old_sha1);
	199	updated = lookup_commit_reference(ref->new_sha1);
	200	if (!current \|\| !updated) {
	201	char *msg;
	202	if (!strncmp(ref->name, "refs/tags/", 10))
	203	msg = "storing tag";
	204	else
	205	msg = "storing head";
	206	fprintf(stderr, "* %s: storing %s\n",
	207	ref->name, note);
	208	show_new(type, ref->new_sha1);
	209	return s_update_ref(msg, ref, 0);
	210	}
	211
	212	strcpy(oldh, find_unique_abbrev(current->object.sha1, DEFAULT_ABBREV));
	213	strcpy(newh, find_unique_abbrev(ref->new_sha1, DEFAULT_ABBREV));
	214
	215	if (in_merge_bases(current, &updated, 1)) {
	216	fprintf(stderr, "* %s: fast forward to %s\n",
	217	ref->name, note);
	218	fprintf(stderr, " old..new: %s..%s\n", oldh, newh);
	219	return s_update_ref("fast forward", ref, 1);
	220	}
	221	if (!force && !ref->force) {
	222	fprintf(stderr,
	223	"* %s: not updating to non-fast forward %s\n",
	224	ref->name, note);
	225	fprintf(stderr,
	226	" old...new: %s...%s\n", oldh, newh);
	227	return 1;
	228	}
	229	fprintf(stderr,
	230	"* %s: forcing update to non-fast forward %s\n",
	231	ref->name, note);
	232	fprintf(stderr, " old...new: %s...%s\n", oldh, newh);
	233	return s_update_ref("forced-update", ref, 1);
	234	}
	235
	236	static void store_updated_refs(const char url, struct ref ref_map)
	237	{
	238	FILE *fp;
	239	struct commit *commit;
	240	int url_len, i, note_len;
	241	char note[1024];
242	const char what, kind;
243	struct ref *rm;
244
245	fp = fopen(git_path("FETCH_HEAD"), "a");
246	for (rm = ref_map; rm; rm = rm->next) {
247	struct ref *ref = NULL;
248
249	if (rm->peer_ref) {
250	ref = xcalloc(1, sizeof(*ref) + strlen(rm->peer_ref->name) + 1);
251	strcpy(ref->name, rm->peer_ref->name);
252	hashcpy(ref->old_sha1, rm->peer_ref->old_sha1);
253	hashcpy(ref->new_sha1, rm->old_sha1);
1aad91f5	254	ref->force = rm->peer_ref->force;
b888d61c DB	255	}
	256
	257	commit = lookup_commit_reference(rm->old_sha1);
	258	if (!commit)
	259	rm->merge = 0;
	260
	261	if (!strcmp(rm->name, "HEAD")) {
	262	kind = "";
	263	what = "";
	264	}
	265	else if (!prefixcmp(rm->name, "refs/heads/")) {
	266	kind = "branch";
	267	what = rm->name + 11;
	268	}
	269	else if (!prefixcmp(rm->name, "refs/tags/")) {
	270	kind = "tag";
	271	what = rm->name + 10;
	272	}
	273	else if (!prefixcmp(rm->name, "refs/remotes/")) {
	274	kind = "remote branch";
	275	what = rm->name + 13;
	276	}
	277	else {
	278	kind = "";
	279	what = rm->name;
	280	}
	281
	282	url_len = strlen(url);
	283	for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
	284	;
	285	url_len = i + 1;
	286	if (4 < i && !strncmp(".git", url + i - 3, 4))
	287	url_len = i - 3;
	288
	289	note_len = 0;
	290	if (*what) {
	291	if (*kind)
	292	note_len += sprintf(note + note_len, "%s ",
	293	kind);
	294	note_len += sprintf(note + note_len, "'%s' of ", what);
	295	}
	296	note_len += sprintf(note + note_len, "%.*s", url_len, url);
	297	fprintf(fp, "%s\t%s\t%s\n",
	298	sha1_to_hex(commit ? commit->object.sha1 :
	299	rm->old_sha1),
	300	rm->merge ? "" : "not-for-merge",
	301	note);
	302
	303	if (ref)
	304	update_local_ref(ref, note, verbose);
	305	}
	306	fclose(fp);
	307	}
	308
	309	static int fetch_refs(struct transport transport, struct ref ref_map)
	310	{
	311	int ret = transport_fetch_refs(transport, ref_map);
	312	if (!ret)
	313	store_updated_refs(transport->url, ref_map);
1788c39c	314	transport_unlock_pack(transport);
b888d61c DB	315	return ret;
	316	}
	317
	318	static int add_existing(const char refname, const unsigned char sha1,
	319	int flag, void *cbdata)
	320	{
	321	struct path_list list = (struct path_list )cbdata;
	322	path_list_insert(refname, list);
	323	return 0;
	324	}
	325
	326	static struct ref find_non_local_tags(struct transport transport,
	327	struct ref *fetch_map)
	328	{
	329	static struct path_list existing_refs = { NULL, 0, 0, 0 };
	330	struct path_list new_refs = { NULL, 0, 0, 1 };
	331	char *ref_name;
	332	int ref_name_len;
	333	unsigned char *ref_sha1;
	334	struct ref *tag_ref;
	335	struct ref *rm = NULL;
	336	struct ref *ref_map = NULL;
	337	struct ref **tail = &ref_map;
	338	struct ref *ref;
	339
	340	for_each_ref(add_existing, &existing_refs);
	341	for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
	342	if (prefixcmp(ref->name, "refs/tags"))
	343	continue;
	344
	345	ref_name = xstrdup(ref->name);
	346	ref_name_len = strlen(ref_name);
	347	ref_sha1 = ref->old_sha1;
	348
	349	if (!strcmp(ref_name + ref_name_len - 3, "^{}")) {
	350	ref_name[ref_name_len - 3] = 0;
	351	tag_ref = transport_get_remote_refs(transport);
	352	while (tag_ref) {
	353	if (!strcmp(tag_ref->name, ref_name)) {
	354	ref_sha1 = tag_ref->old_sha1;
	355	break;
	356	}
	357	tag_ref = tag_ref->next;
	358	}
	359	}
	360
	361	if (!path_list_has_path(&existing_refs, ref_name) &&
	362	!path_list_has_path(&new_refs, ref_name) &&
	363	lookup_object(ref->old_sha1)) {
	364	fprintf(stderr, "Auto-following %s\n",
	365	ref_name);
	366
	367	path_list_insert(ref_name, &new_refs);
	368
	369	rm = alloc_ref(strlen(ref_name) + 1);
	370	strcpy(rm->name, ref_name);
	371	rm->peer_ref = alloc_ref(strlen(ref_name) + 1);
	372	strcpy(rm->peer_ref->name, ref_name);
	373	hashcpy(rm->old_sha1, ref_sha1);
	374
	375	*tail = rm;
	376	tail = &rm->next;
	377	}
	378	free(ref_name);
379	}
380
381	return ref_map;
382	}
383
384	static int do_fetch(struct transport *transport,
385	struct refspec *refs, int ref_count)
386	{
387	struct ref ref_map, fetch_map;
388	struct ref *rm;
389	int autotags = (transport->remote->fetch_tags == 1);
390	if (transport->remote->fetch_tags == 2 && !no_tags)
391	tags = 1;
392	if (transport->remote->fetch_tags == -1)
393	no_tags = 1;
394
824d5776	395	if (!transport->get_refs_list \|\| !transport->fetch)
b888d61c DB	396	die("Don't know how to fetch from %s", transport->url);
	397
	398	/* if not appending, truncate FETCH_HEAD */
	399	if (!append)
	400	fclose(fopen(git_path("FETCH_HEAD"), "w"));
	401
	402	ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);
	403
	404	for (rm = ref_map; rm; rm = rm->next) {
	405	if (rm->peer_ref)
	406	read_ref(rm->peer_ref->name, rm->peer_ref->old_sha1);
b888d61c DB	407	}
	408
	409	if (fetch_refs(transport, ref_map)) {
	410	free_refs(ref_map);
	411	return 1;
	412	}
	413
	414	fetch_map = ref_map;
	415
	416	/* if neither --no-tags nor --tags was specified, do automated tag
	417	* following ... */
	418	if (!(tags \|\| no_tags) && autotags) {
	419	ref_map = find_non_local_tags(transport, fetch_map);
	420	if (ref_map) {
	421	transport_set_option(transport, TRANS_OPT_DEPTH, "0");
	422	fetch_refs(transport, ref_map);
	423	}
	424	free_refs(ref_map);
	425	}
	426
	427	free_refs(fetch_map);
	428
	429	return 0;
	430	}
	431
ab865e6e SP	432	static void set_option(const char name, const char value)
	433	{
	434	int r = transport_set_option(transport, name, value);
	435	if (r < 0)
	436	die("Option \"%s\" value \"%s\" is not valid for %s\n",
	437	name, value, transport->url);
	438	if (r > 0)
	439	warning("Option \"%s\" is ignored for %s\n",
	440	name, transport->url);
	441	}
	442
b888d61c DB	443	int cmd_fetch(int argc, const char *argv, const char prefix)
	444	{
	445	struct remote *remote;
b888d61c DB	446	int i, j, rla_offset;
	447	static const char **refs = NULL;
	448	int ref_nr = 0;
	449	int cmd_len = 0;
	450	const char depth = NULL, upload_pack = NULL;
	451	int keep = 0;
	452
b888d61c DB	453	for (i = 1; i < argc; i++) {
	454	const char *arg = argv[i];
	455	cmd_len += strlen(arg);
	456
	457	if (arg[0] != '-')
	458	break;
	459	if (!strcmp(arg, "--append") \|\| !strcmp(arg, "-a")) {
	460	append = 1;
	461	continue;
	462	}
	463	if (!prefixcmp(arg, "--upload-pack=")) {
	464	upload_pack = arg + 14;
	465	continue;
	466	}
	467	if (!strcmp(arg, "--upload-pack")) {
	468	i++;
	469	if (i == argc)
	470	usage(fetch_usage);
	471	upload_pack = argv[i];
	472	continue;
	473	}
	474	if (!strcmp(arg, "--force") \|\| !strcmp(arg, "-f")) {
	475	force = 1;
	476	continue;
	477	}
	478	if (!strcmp(arg, "--no-tags")) {
	479	no_tags = 1;
	480	continue;
	481	}
	482	if (!strcmp(arg, "--tags") \|\| !strcmp(arg, "-t")) {
	483	tags = 1;
	484	continue;
	485	}
	486	if (!strcmp(arg, "--keep") \|\| !strcmp(arg, "-k")) {
	487	keep = 1;
	488	continue;
	489	}
	490	if (!strcmp(arg, "--update-head-ok") \|\| !strcmp(arg, "-u")) {
	491	update_head_ok = 1;
	492	continue;
	493	}
	494	if (!prefixcmp(arg, "--depth=")) {
	495	depth = arg + 8;
	496	continue;
	497	}
	498	if (!strcmp(arg, "--depth")) {
	499	i++;
	500	if (i == argc)
	501	usage(fetch_usage);
	502	depth = argv[i];
	503	continue;
	504	}
	505	if (!strcmp(arg, "--quiet")) {
	506	quiet = 1;
	507	continue;
	508	}
	509	if (!strcmp(arg, "--verbose") \|\| !strcmp(arg, "-v")) {
	510	verbose++;
	511	continue;
	512	}
	513	usage(fetch_usage);
	514	}
	515
	516	for (j = i; j < argc; j++)
517	cmd_len += strlen(argv[j]);
518
519	default_rla = xmalloc(cmd_len + 5 + argc + 1);
520	sprintf(default_rla, "fetch");
521	rla_offset = strlen(default_rla);
522	for (j = 1; j < argc; j++) {
523	sprintf(default_rla + rla_offset, " %s", argv[j]);
4ad1eada	524	rla_offset += strlen(argv[j]) + 1;
b888d61c DB	525	}
	526
	527	if (i == argc)
	528	remote = remote_get(NULL);
	529	else
	530	remote = remote_get(argv[i++]);
	531
28b91f8a	532	transport = transport_get(remote, remote->url[0]);
b888d61c DB	533	if (verbose >= 2)
	534	transport->verbose = 1;
	535	if (quiet)
	536	transport->verbose = 0;
	537	if (upload_pack)
ab865e6e	538	set_option(TRANS_OPT_UPLOADPACK, upload_pack);
b888d61c	539	if (keep)
ab865e6e SP	540	set_option(TRANS_OPT_KEEP, "yes");
	541	if (depth)
	542	set_option(TRANS_OPT_DEPTH, depth);
b888d61c DB	543
	544	if (!transport->url)
	545	die("Where do you want to fetch from today?");
	546
	547	if (i < argc) {
	548	int j = 0;
	549	refs = xcalloc(argc - i + 1, sizeof(const char *));
	550	while (i < argc) {
	551	if (!strcmp(argv[i], "tag")) {
	552	char *ref;
	553	i++;
	554	ref = xmalloc(strlen(argv[i]) * 2 + 22);
	555	strcpy(ref, "refs/tags/");
	556	strcat(ref, argv[i]);
	557	strcat(ref, ":refs/tags/");
	558	strcat(ref, argv[i]);
	559	refs[j++] = ref;
	560	} else
	561	refs[j++] = argv[i];
	562	i++;
	563	}
	564	refs[j] = NULL;
	565	ref_nr = j;
b888d61c DB	566	}
b888d61c DB	567
e4022ed2 SP	568	signal(SIGINT, unlock_pack_on_signal);
e4022ed2 SP	569	atexit(unlock_pack);
b888d61c DB	570	return do_fetch(transport, parse_ref_spec(ref_nr, refs), ref_nr);
b888d61c DB	571	}