From: Junio C Hamano <gitster@pobox.com>
Date: Mon, 28 Oct 2013 17:43:28 +0000 (-0700)
Subject: Merge branch 'jk/remote-literal-string-leakfix'
X-Git-Tag: v1.8.5-rc0~22
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/93542d90c005ee614ce6ad4dde16b89764cdea67?hp=-c

Merge branch 'jk/remote-literal-string-leakfix'

* jk/remote-literal-string-leakfix:
remote: do not copy "origin" string literal
---

93542d90c005ee614ce6ad4dde16b89764cdea67
diff --combined remote.c
index e9fedfa918,ffd1a6523e..9f1a8aa2c4
--- a/remote.c
+++ b/remote.c
@@@ -148,7 -148,6 +148,7 @@@ static struct remote *make_remote(cons
  	}
  
  	ret = xcalloc(1, sizeof(struct remote));
 +	ret->prune = -1;  /* unspecified */
  	ALLOC_GROW(remotes, remotes_nr + 1, remotes_alloc);
  	remotes[remotes_nr++] = ret;
  	if (len)
@@@ -405,8 -404,6 +405,8 @@@ static int handle_config(const char *ke
  		remote->skip_default_update = git_config_bool(key, value);
  	else if (!strcmp(subkey, ".skipfetchall"))
  		remote->skip_default_update = git_config_bool(key, value);
 +	else if (!strcmp(subkey, ".prune"))
 +		remote->prune = git_config_bool(key, value);
  	else if (!strcmp(subkey, ".url")) {
  		const char *v;
  		if (git_config_string(&v, key, value))
@@@ -483,7 -480,7 +483,7 @@@ static void read_config(void
  	int flag;
  	if (default_remote_name) /* did this already */
  		return;
- 	default_remote_name = xstrdup("origin");
+ 	default_remote_name = "origin";
  	current_branch = NULL;
  	head_ref = resolve_ref_unsafe("HEAD", sha1, 0, &flag);
  	if (head_ref && (flag & REF_ISSYMREF) &&
@@@ -1305,14 -1302,6 +1305,14 @@@ static void add_missing_tags(struct re
  	free(sent_tips.tip);
  }
  
 +struct ref *find_ref_by_name(const struct ref *list, const char *name)
 +{
 +	for ( ; list; list = list->next)
 +		if (!strcmp(list->name, name))
 +			return (struct ref *)list;
 +	return NULL;
 +}
 +
  static void prepare_ref_index(struct string_list *ref_index, struct ref *ref)
  {
  	for ( ; ref; ref = ref->next)
@@@ -1422,13 -1411,12 +1422,13 @@@ int match_push_refs(struct ref *src, st
  }
  
  void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
 -	int force_update)
 +			     int force_update)
  {
  	struct ref *ref;
  
  	for (ref = remote_refs; ref; ref = ref->next) {
  		int force_ref_update = ref->force || force_update;
 +		int reject_reason = 0;
  
  		if (ref->peer_ref)
  			hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
@@@ -1443,26 -1431,6 +1443,26 @@@
  		}
  
  		/*
 +		 * Bypass the usual "must fast-forward" check but
 +		 * replace it with a weaker "the old value must be
 +		 * this value we observed".  If the remote ref has
 +		 * moved and is now different from what we expect,
 +		 * reject any push.
 +		 *
 +		 * It also is an error if the user told us to check
 +		 * with the remote-tracking branch to find the value
 +		 * to expect, but we did not have such a tracking
 +		 * branch.
 +		 */
 +		if (ref->expect_old_sha1) {
 +			if (ref->expect_old_no_trackback ||
 +			    hashcmp(ref->old_sha1, ref->old_sha1_expect))
 +				reject_reason = REF_STATUS_REJECT_STALE;
 +		}
 +
 +		/*
 +		 * The usual "must fast-forward" rules.
 +		 *
  		 * Decide whether an individual refspec A:B can be
  		 * pushed.  The push will succeed if any of the
  		 * following are true:
@@@ -1480,26 -1448,24 +1480,26 @@@
  		 *     passing the --force argument
  		 */
  
 -		if (!ref->deletion && !is_null_sha1(ref->old_sha1)) {
 -			int why = 0; /* why would this push require --force? */
 -
 +		else if (!ref->deletion && !is_null_sha1(ref->old_sha1)) {
  			if (!prefixcmp(ref->name, "refs/tags/"))
 -				why = REF_STATUS_REJECT_ALREADY_EXISTS;
 +				reject_reason = REF_STATUS_REJECT_ALREADY_EXISTS;
  			else if (!has_sha1_file(ref->old_sha1))
 -				why = REF_STATUS_REJECT_FETCH_FIRST;
 +				reject_reason = REF_STATUS_REJECT_FETCH_FIRST;
  			else if (!lookup_commit_reference_gently(ref->old_sha1, 1) ||
  				 !lookup_commit_reference_gently(ref->new_sha1, 1))
 -				why = REF_STATUS_REJECT_NEEDS_FORCE;
 +				reject_reason = REF_STATUS_REJECT_NEEDS_FORCE;
  			else if (!ref_newer(ref->new_sha1, ref->old_sha1))
 -				why = REF_STATUS_REJECT_NONFASTFORWARD;
 -
 -			if (!force_ref_update)
 -				ref->status = why;
 -			else if (why)
 -				ref->forced_update = 1;
 +				reject_reason = REF_STATUS_REJECT_NONFASTFORWARD;
  		}
 +
 +		/*
 +		 * "--force" will defeat any rejection implemented
 +		 * by the rules above.
 +		 */
 +		if (!force_ref_update)
 +			ref->status = reject_reason;
 +		else if (reject_reason)
 +			ref->forced_update = 1;
  	}
  }
  
@@@ -1729,11 -1695,7 +1729,11 @@@ int ref_newer(const unsigned char *new_
  }
  
  /*
 - * Return true if there is anything to report, otherwise false.
 + * Compare a branch with its upstream, and save their differences (number
 + * of commits) in *num_ours and *num_theirs.
 + *
 + * Return 0 if branch has no upstream (no base), -1 if upstream is missing
 + * (with "gone" base), otherwise 1 (with base).
   */
  int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs)
  {
@@@ -1744,30 -1706,34 +1744,30 @@@
  	const char *rev_argv[10], *base;
  	int rev_argc;
  
 -	/*
 -	 * Nothing to report unless we are marked to build on top of
 -	 * somebody else.
 -	 */
 +	/* Cannot stat unless we are marked to build on top of somebody else. */
  	if (!branch ||
  	    !branch->merge || !branch->merge[0] || !branch->merge[0]->dst)
  		return 0;
  
 -	/*
 -	 * If what we used to build on no longer exists, there is
 -	 * nothing to report.
 -	 */
 +	/* Cannot stat if what we used to build on no longer exists */
  	base = branch->merge[0]->dst;
  	if (read_ref(base, sha1))
 -		return 0;
 +		return -1;
  	theirs = lookup_commit_reference(sha1);
  	if (!theirs)
 -		return 0;
 +		return -1;
  
  	if (read_ref(branch->refname, sha1))
 -		return 0;
 +		return -1;
  	ours = lookup_commit_reference(sha1);
  	if (!ours)
 -		return 0;
 +		return -1;
  
  	/* are we the same? */
 -	if (theirs == ours)
 -		return 0;
 +	if (theirs == ours) {
 +		*num_theirs = *num_ours = 0;
 +		return 1;
 +	}
  
  	/* Run "rev-list --left-right ours...theirs" internally... */
  	rev_argc = 0;
@@@ -1809,53 -1775,31 +1809,53 @@@
   */
  int format_tracking_info(struct branch *branch, struct strbuf *sb)
  {
 -	int num_ours, num_theirs;
 +	int ours, theirs;
  	const char *base;
 +	int upstream_is_gone = 0;
  
 -	if (!stat_tracking_info(branch, &num_ours, &num_theirs))
 +	switch (stat_tracking_info(branch, &ours, &theirs)) {
 +	case 0:
 +		/* no base */
  		return 0;
 +	case -1:
 +		/* with "gone" base */
 +		upstream_is_gone = 1;
 +		break;
 +	default:
 +		/* with base */
 +		break;
 +	}
  
  	base = branch->merge[0]->dst;
  	base = shorten_unambiguous_ref(base, 0);
 -	if (!num_theirs) {
 +	if (upstream_is_gone) {
 +		strbuf_addf(sb,
 +			_("Your branch is based on '%s', but the upstream is gone.\n"),
 +			base);
 +		if (advice_status_hints)
 +			strbuf_addf(sb,
 +				_("  (use \"git branch --unset-upstream\" to fixup)\n"));
 +	} else if (!ours && !theirs) {
 +		strbuf_addf(sb,
 +			_("Your branch is up-to-date with '%s'.\n"),
 +			base);
 +	} else if (!theirs) {
  		strbuf_addf(sb,
  			Q_("Your branch is ahead of '%s' by %d commit.\n",
  			   "Your branch is ahead of '%s' by %d commits.\n",
 -			   num_ours),
 -			base, num_ours);
 +			   ours),
 +			base, ours);
  		if (advice_status_hints)
  			strbuf_addf(sb,
  				_("  (use \"git push\" to publish your local commits)\n"));
 -	} else if (!num_ours) {
 +	} else if (!ours) {
  		strbuf_addf(sb,
  			Q_("Your branch is behind '%s' by %d commit, "
  			       "and can be fast-forwarded.\n",
  			   "Your branch is behind '%s' by %d commits, "
  			       "and can be fast-forwarded.\n",
 -			   num_theirs),
 -			base, num_theirs);
 +			   theirs),
 +			base, theirs);
  		if (advice_status_hints)
  			strbuf_addf(sb,
  				_("  (use \"git pull\" to update your local branch)\n"));
@@@ -1867,8 -1811,8 +1867,8 @@@
  			   "Your branch and '%s' have diverged,\n"
  			       "and have %d and %d different commits each, "
  			       "respectively.\n",
 -			   num_theirs),
 -			base, num_ours, num_theirs);
 +			   theirs),
 +			base, ours, theirs);
  		if (advice_status_hints)
  			strbuf_addf(sb,
  				_("  (use \"git pull\" to merge the remote branch into yours)\n"));
@@@ -1992,121 -1936,3 +1992,121 @@@ struct ref *get_stale_heads(struct refs
  	string_list_clear(&ref_names, 0);
  	return stale_refs;
  }
 +
 +/*
 + * Compare-and-swap
 + */
 +void clear_cas_option(struct push_cas_option *cas)
 +{
 +	int i;
 +
 +	for (i = 0; i < cas->nr; i++)
 +		free(cas->entry[i].refname);
 +	free(cas->entry);
 +	memset(cas, 0, sizeof(*cas));
 +}
 +
 +static struct push_cas *add_cas_entry(struct push_cas_option *cas,
 +				      const char *refname,
 +				      size_t refnamelen)
 +{
 +	struct push_cas *entry;
 +	ALLOC_GROW(cas->entry, cas->nr + 1, cas->alloc);
 +	entry = &cas->entry[cas->nr++];
 +	memset(entry, 0, sizeof(*entry));
 +	entry->refname = xmemdupz(refname, refnamelen);
 +	return entry;
 +}
 +
 +int parse_push_cas_option(struct push_cas_option *cas, const char *arg, int unset)
 +{
 +	const char *colon;
 +	struct push_cas *entry;
 +
 +	if (unset) {
 +		/* "--no-<option>" */
 +		clear_cas_option(cas);
 +		return 0;
 +	}
 +
 +	if (!arg) {
 +		/* just "--<option>" */
 +		cas->use_tracking_for_rest = 1;
 +		return 0;
 +	}
 +
 +	/* "--<option>=refname" or "--<option>=refname:value" */
 +	colon = strchrnul(arg, ':');
 +	entry = add_cas_entry(cas, arg, colon - arg);
 +	if (!*colon)
 +		entry->use_tracking = 1;
 +	else if (get_sha1(colon + 1, entry->expect))
 +		return error("cannot parse expected object name '%s'", colon + 1);
 +	return 0;
 +}
 +
 +int parseopt_push_cas_option(const struct option *opt, const char *arg, int unset)
 +{
 +	return parse_push_cas_option(opt->value, arg, unset);
 +}
 +
 +int is_empty_cas(const struct push_cas_option *cas)
 +{
 +	return !cas->use_tracking_for_rest && !cas->nr;
 +}
 +
 +/*
 + * Look at remote.fetch refspec and see if we have a remote
 + * tracking branch for the refname there.  Fill its current
 + * value in sha1[].
 + * If we cannot do so, return negative to signal an error.
 + */
 +static int remote_tracking(struct remote *remote, const char *refname,
 +			   unsigned char sha1[20])
 +{
 +	char *dst;
 +
 +	dst = apply_refspecs(remote->fetch, remote->fetch_refspec_nr, refname);
 +	if (!dst)
 +		return -1; /* no tracking ref for refname at remote */
 +	if (read_ref(dst, sha1))
 +		return -1; /* we know what the tracking ref is but we cannot read it */
 +	return 0;
 +}
 +
 +static void apply_cas(struct push_cas_option *cas,
 +		      struct remote *remote,
 +		      struct ref *ref)
 +{
 +	int i;
 +
 +	/* Find an explicit --<option>=<name>[:<value>] entry */
 +	for (i = 0; i < cas->nr; i++) {
 +		struct push_cas *entry = &cas->entry[i];
 +		if (!refname_match(entry->refname, ref->name, ref_rev_parse_rules))
 +			continue;
 +		ref->expect_old_sha1 = 1;
 +		if (!entry->use_tracking)
 +			hashcpy(ref->old_sha1_expect, cas->entry[i].expect);
 +		else if (remote_tracking(remote, ref->name, ref->old_sha1_expect))
 +			ref->expect_old_no_trackback = 1;
 +		return;
 +	}
 +
 +	/* Are we using "--<option>" to cover all? */
 +	if (!cas->use_tracking_for_rest)
 +		return;
 +
 +	ref->expect_old_sha1 = 1;
 +	if (remote_tracking(remote, ref->name, ref->old_sha1_expect))
 +		ref->expect_old_no_trackback = 1;
 +}
 +
 +void apply_push_cas(struct push_cas_option *cas,
 +		    struct remote *remote,
 +		    struct ref *remote_refs)
 +{
 +	struct ref *ref;
 +	for (ref = remote_refs; ref; ref = ref->next)
 +		apply_cas(cas, remote, ref);
 +}