2007-05-12 23:45:53 +08:00
|
|
|
#include "cache.h"
|
|
|
|
#include "remote.h"
|
|
|
|
#include "refs.h"
|
2008-07-02 15:51:18 +08:00
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
2009-01-10 20:07:50 +08:00
|
|
|
#include "dir.h"
|
2009-02-25 16:32:12 +08:00
|
|
|
#include "tag.h"
|
2009-10-26 05:28:11 +08:00
|
|
|
#include "string-list.h"
|
2012-05-22 06:19:28 +08:00
|
|
|
#include "mergesort.h"
|
2007-05-12 23:45:53 +08:00
|
|
|
|
2012-02-23 06:43:41 +08:00
|
|
|
enum map_direction { FROM_SRC, FROM_DST };
|
|
|
|
|
2008-04-18 07:32:35 +08:00
|
|
|
static struct refspec s_tag_refspec = {
|
|
|
|
0,
|
|
|
|
1,
|
2008-05-26 04:38:44 +08:00
|
|
|
0,
|
2009-03-07 14:11:36 +08:00
|
|
|
"refs/tags/*",
|
|
|
|
"refs/tags/*"
|
2008-04-18 07:32:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
const struct refspec *tag_refspec = &s_tag_refspec;
|
|
|
|
|
2008-02-25 14:25:04 +08:00
|
|
|
struct counted_string {
|
|
|
|
size_t len;
|
|
|
|
const char *s;
|
|
|
|
};
|
2008-02-21 02:43:53 +08:00
|
|
|
struct rewrite {
|
|
|
|
const char *base;
|
2008-02-25 14:25:04 +08:00
|
|
|
size_t baselen;
|
|
|
|
struct counted_string *instead_of;
|
2008-02-21 02:43:53 +08:00
|
|
|
int instead_of_nr;
|
|
|
|
int instead_of_alloc;
|
|
|
|
};
|
2009-09-07 16:56:00 +08:00
|
|
|
struct rewrites {
|
|
|
|
struct rewrite **rewrite;
|
|
|
|
int rewrite_alloc;
|
|
|
|
int rewrite_nr;
|
|
|
|
};
|
2008-02-21 02:43:53 +08:00
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
static struct remote **remotes;
|
2008-02-19 12:41:41 +08:00
|
|
|
static int remotes_alloc;
|
|
|
|
static int remotes_nr;
|
2007-05-12 23:45:53 +08:00
|
|
|
|
2007-09-11 11:02:56 +08:00
|
|
|
static struct branch **branches;
|
2008-02-19 12:41:41 +08:00
|
|
|
static int branches_alloc;
|
|
|
|
static int branches_nr;
|
2007-09-11 11:02:56 +08:00
|
|
|
|
|
|
|
static struct branch *current_branch;
|
|
|
|
static const char *default_remote_name;
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
static int explicit_default_remote_name;
|
2007-09-11 11:02:56 +08:00
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
static struct rewrites rewrites;
|
2009-09-07 16:56:33 +08:00
|
|
|
static struct rewrites rewrites_push;
|
2008-02-21 02:43:53 +08:00
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
#define BUF_SIZE (2048)
|
|
|
|
static char buffer[BUF_SIZE];
|
|
|
|
|
2009-11-18 09:42:23 +08:00
|
|
|
static int valid_remote(const struct remote *remote)
|
|
|
|
{
|
2009-11-18 09:42:25 +08:00
|
|
|
return (!!remote->url) || (!!remote->foreign_vcs);
|
2009-11-18 09:42:23 +08:00
|
|
|
}
|
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
static const char *alias_url(const char *url, struct rewrites *r)
|
2008-02-21 02:43:53 +08:00
|
|
|
{
|
|
|
|
int i, j;
|
2008-02-25 14:25:04 +08:00
|
|
|
char *ret;
|
|
|
|
struct counted_string *longest;
|
|
|
|
int longest_i;
|
|
|
|
|
|
|
|
longest = NULL;
|
|
|
|
longest_i = -1;
|
2009-09-07 16:56:00 +08:00
|
|
|
for (i = 0; i < r->rewrite_nr; i++) {
|
|
|
|
if (!r->rewrite[i])
|
2008-02-21 02:43:53 +08:00
|
|
|
continue;
|
2009-09-07 16:56:00 +08:00
|
|
|
for (j = 0; j < r->rewrite[i]->instead_of_nr; j++) {
|
|
|
|
if (!prefixcmp(url, r->rewrite[i]->instead_of[j].s) &&
|
2008-02-25 14:25:04 +08:00
|
|
|
(!longest ||
|
2009-09-07 16:56:00 +08:00
|
|
|
longest->len < r->rewrite[i]->instead_of[j].len)) {
|
|
|
|
longest = &(r->rewrite[i]->instead_of[j]);
|
2008-02-25 14:25:04 +08:00
|
|
|
longest_i = i;
|
2008-02-21 02:43:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-02-25 14:25:04 +08:00
|
|
|
if (!longest)
|
|
|
|
return url;
|
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
ret = xmalloc(r->rewrite[longest_i]->baselen +
|
2008-02-25 14:25:04 +08:00
|
|
|
(strlen(url) - longest->len) + 1);
|
2009-09-07 16:56:00 +08:00
|
|
|
strcpy(ret, r->rewrite[longest_i]->base);
|
|
|
|
strcpy(ret + r->rewrite[longest_i]->baselen, url + longest->len);
|
2008-02-25 14:25:04 +08:00
|
|
|
return ret;
|
2008-02-21 02:43:53 +08:00
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
static void add_push_refspec(struct remote *remote, const char *ref)
|
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
ALLOC_GROW(remote->push_refspec,
|
|
|
|
remote->push_refspec_nr + 1,
|
|
|
|
remote->push_refspec_alloc);
|
|
|
|
remote->push_refspec[remote->push_refspec_nr++] = ref;
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2007-05-12 23:46:03 +08:00
|
|
|
static void add_fetch_refspec(struct remote *remote, const char *ref)
|
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
ALLOC_GROW(remote->fetch_refspec,
|
|
|
|
remote->fetch_refspec_nr + 1,
|
|
|
|
remote->fetch_refspec_alloc);
|
|
|
|
remote->fetch_refspec[remote->fetch_refspec_nr++] = ref;
|
2007-05-12 23:46:03 +08:00
|
|
|
}
|
|
|
|
|
2007-09-19 12:49:27 +08:00
|
|
|
static void add_url(struct remote *remote, const char *url)
|
2007-05-12 23:45:53 +08:00
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
ALLOC_GROW(remote->url, remote->url_nr + 1, remote->url_alloc);
|
|
|
|
remote->url[remote->url_nr++] = url;
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2009-06-10 00:01:34 +08:00
|
|
|
static void add_pushurl(struct remote *remote, const char *pushurl)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(remote->pushurl, remote->pushurl_nr + 1, remote->pushurl_alloc);
|
|
|
|
remote->pushurl[remote->pushurl_nr++] = pushurl;
|
|
|
|
}
|
|
|
|
|
2009-09-07 16:56:33 +08:00
|
|
|
static void add_pushurl_alias(struct remote *remote, const char *url)
|
|
|
|
{
|
|
|
|
const char *pushurl = alias_url(url, &rewrites_push);
|
|
|
|
if (pushurl != url)
|
|
|
|
add_pushurl(remote, pushurl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_url_alias(struct remote *remote, const char *url)
|
|
|
|
{
|
|
|
|
add_url(remote, alias_url(url, &rewrites));
|
|
|
|
add_pushurl_alias(remote, url);
|
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
static struct remote *make_remote(const char *name, int len)
|
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
struct remote *ret;
|
|
|
|
int i;
|
2007-05-12 23:45:53 +08:00
|
|
|
|
2008-02-19 12:41:41 +08:00
|
|
|
for (i = 0; i < remotes_nr; i++) {
|
|
|
|
if (len ? (!strncmp(name, remotes[i]->name, len) &&
|
|
|
|
!remotes[i]->name[len]) :
|
|
|
|
!strcmp(name, remotes[i]->name))
|
|
|
|
return remotes[i];
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2008-02-19 12:41:41 +08:00
|
|
|
ret = xcalloc(1, sizeof(struct remote));
|
|
|
|
ALLOC_GROW(remotes, remotes_nr + 1, remotes_alloc);
|
|
|
|
remotes[remotes_nr++] = ret;
|
2007-05-12 23:45:53 +08:00
|
|
|
if (len)
|
2008-02-19 12:41:41 +08:00
|
|
|
ret->name = xstrndup(name, len);
|
2007-05-12 23:45:53 +08:00
|
|
|
else
|
2008-02-19 12:41:41 +08:00
|
|
|
ret->name = xstrdup(name);
|
|
|
|
return ret;
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2007-09-11 11:02:56 +08:00
|
|
|
static void add_merge(struct branch *branch, const char *name)
|
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
ALLOC_GROW(branch->merge_name, branch->merge_nr + 1,
|
|
|
|
branch->merge_alloc);
|
|
|
|
branch->merge_name[branch->merge_nr++] = name;
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct branch *make_branch(const char *name, int len)
|
|
|
|
{
|
2008-02-19 12:41:41 +08:00
|
|
|
struct branch *ret;
|
|
|
|
int i;
|
2007-09-11 11:02:56 +08:00
|
|
|
char *refname;
|
|
|
|
|
2008-02-19 12:41:41 +08:00
|
|
|
for (i = 0; i < branches_nr; i++) {
|
|
|
|
if (len ? (!strncmp(name, branches[i]->name, len) &&
|
|
|
|
!branches[i]->name[len]) :
|
|
|
|
!strcmp(name, branches[i]->name))
|
|
|
|
return branches[i];
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
|
|
|
|
2008-02-19 12:41:41 +08:00
|
|
|
ALLOC_GROW(branches, branches_nr + 1, branches_alloc);
|
|
|
|
ret = xcalloc(1, sizeof(struct branch));
|
|
|
|
branches[branches_nr++] = ret;
|
2007-09-11 11:02:56 +08:00
|
|
|
if (len)
|
2008-02-19 12:41:41 +08:00
|
|
|
ret->name = xstrndup(name, len);
|
2007-09-11 11:02:56 +08:00
|
|
|
else
|
2008-02-19 12:41:41 +08:00
|
|
|
ret->name = xstrdup(name);
|
2008-09-10 02:57:10 +08:00
|
|
|
refname = xmalloc(strlen(name) + strlen("refs/heads/") + 1);
|
2007-09-11 11:02:56 +08:00
|
|
|
strcpy(refname, "refs/heads/");
|
2008-02-19 12:41:41 +08:00
|
|
|
strcpy(refname + strlen("refs/heads/"), ret->name);
|
|
|
|
ret->refname = refname;
|
2007-09-11 11:02:56 +08:00
|
|
|
|
2008-02-19 12:41:41 +08:00
|
|
|
return ret;
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
static struct rewrite *make_rewrite(struct rewrites *r, const char *base, int len)
|
2008-02-21 02:43:53 +08:00
|
|
|
{
|
|
|
|
struct rewrite *ret;
|
|
|
|
int i;
|
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
for (i = 0; i < r->rewrite_nr; i++) {
|
2008-02-25 14:25:04 +08:00
|
|
|
if (len
|
2009-09-07 16:56:00 +08:00
|
|
|
? (len == r->rewrite[i]->baselen &&
|
|
|
|
!strncmp(base, r->rewrite[i]->base, len))
|
|
|
|
: !strcmp(base, r->rewrite[i]->base))
|
|
|
|
return r->rewrite[i];
|
2008-02-21 02:43:53 +08:00
|
|
|
}
|
|
|
|
|
2009-09-07 16:56:00 +08:00
|
|
|
ALLOC_GROW(r->rewrite, r->rewrite_nr + 1, r->rewrite_alloc);
|
2008-02-21 02:43:53 +08:00
|
|
|
ret = xcalloc(1, sizeof(struct rewrite));
|
2009-09-07 16:56:00 +08:00
|
|
|
r->rewrite[r->rewrite_nr++] = ret;
|
2008-02-25 14:25:04 +08:00
|
|
|
if (len) {
|
2008-02-21 02:43:53 +08:00
|
|
|
ret->base = xstrndup(base, len);
|
2008-02-25 14:25:04 +08:00
|
|
|
ret->baselen = len;
|
|
|
|
}
|
|
|
|
else {
|
2008-02-21 02:43:53 +08:00
|
|
|
ret->base = xstrdup(base);
|
2008-02-25 14:25:04 +08:00
|
|
|
ret->baselen = strlen(base);
|
|
|
|
}
|
2008-02-21 02:43:53 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_instead_of(struct rewrite *rewrite, const char *instead_of)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(rewrite->instead_of, rewrite->instead_of_nr + 1, rewrite->instead_of_alloc);
|
2008-02-25 14:25:04 +08:00
|
|
|
rewrite->instead_of[rewrite->instead_of_nr].s = instead_of;
|
|
|
|
rewrite->instead_of[rewrite->instead_of_nr].len = strlen(instead_of);
|
|
|
|
rewrite->instead_of_nr++;
|
2008-02-21 02:43:53 +08:00
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
static void read_remotes_file(struct remote *remote)
|
|
|
|
{
|
|
|
|
FILE *f = fopen(git_path("remotes/%s", remote->name), "r");
|
|
|
|
|
|
|
|
if (!f)
|
|
|
|
return;
|
2008-11-11 04:43:00 +08:00
|
|
|
remote->origin = REMOTE_REMOTES;
|
2007-05-12 23:45:53 +08:00
|
|
|
while (fgets(buffer, BUF_SIZE, f)) {
|
|
|
|
int value_list;
|
|
|
|
char *s, *p;
|
|
|
|
|
|
|
|
if (!prefixcmp(buffer, "URL:")) {
|
|
|
|
value_list = 0;
|
|
|
|
s = buffer + 4;
|
|
|
|
} else if (!prefixcmp(buffer, "Push:")) {
|
|
|
|
value_list = 1;
|
|
|
|
s = buffer + 5;
|
2007-05-12 23:46:03 +08:00
|
|
|
} else if (!prefixcmp(buffer, "Pull:")) {
|
|
|
|
value_list = 2;
|
|
|
|
s = buffer + 5;
|
2007-05-12 23:45:53 +08:00
|
|
|
} else
|
|
|
|
continue;
|
|
|
|
|
|
|
|
while (isspace(*s))
|
|
|
|
s++;
|
|
|
|
if (!*s)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
p = s + strlen(s);
|
|
|
|
while (isspace(p[-1]))
|
|
|
|
*--p = 0;
|
|
|
|
|
|
|
|
switch (value_list) {
|
|
|
|
case 0:
|
2008-02-21 02:43:53 +08:00
|
|
|
add_url_alias(remote, xstrdup(s));
|
2007-05-12 23:45:53 +08:00
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
add_push_refspec(remote, xstrdup(s));
|
|
|
|
break;
|
2007-05-12 23:46:03 +08:00
|
|
|
case 2:
|
|
|
|
add_fetch_refspec(remote, xstrdup(s));
|
|
|
|
break;
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_branches_file(struct remote *remote)
|
|
|
|
{
|
|
|
|
const char *slash = strchr(remote->name, '/');
|
2007-09-11 11:02:56 +08:00
|
|
|
char *frag;
|
2008-10-10 03:12:12 +08:00
|
|
|
struct strbuf branch = STRBUF_INIT;
|
2007-05-12 23:45:53 +08:00
|
|
|
int n = slash ? slash - remote->name : 1000;
|
|
|
|
FILE *f = fopen(git_path("branches/%.*s", n, remote->name), "r");
|
|
|
|
char *s, *p;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!f)
|
|
|
|
return;
|
|
|
|
s = fgets(buffer, BUF_SIZE, f);
|
|
|
|
fclose(f);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
while (isspace(*s))
|
|
|
|
s++;
|
|
|
|
if (!*s)
|
|
|
|
return;
|
2008-11-11 04:43:00 +08:00
|
|
|
remote->origin = REMOTE_BRANCHES;
|
2007-05-12 23:45:53 +08:00
|
|
|
p = s + strlen(s);
|
|
|
|
while (isspace(p[-1]))
|
|
|
|
*--p = 0;
|
|
|
|
len = p - s;
|
|
|
|
if (slash)
|
|
|
|
len += strlen(slash);
|
|
|
|
p = xmalloc(len + 1);
|
|
|
|
strcpy(p, s);
|
|
|
|
if (slash)
|
|
|
|
strcat(p, slash);
|
2008-03-26 07:35:28 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* With "slash", e.g. "git fetch jgarzik/netdev-2.6" when
|
|
|
|
* reading from $GIT_DIR/branches/jgarzik fetches "HEAD" from
|
|
|
|
* the partial URL obtained from the branches file plus
|
|
|
|
* "/netdev-2.6" and does not store it in any tracking ref.
|
|
|
|
* #branch specifier in the file is ignored.
|
|
|
|
*
|
|
|
|
* Otherwise, the branches file would have URL and optionally
|
|
|
|
* #branch specified. The "master" (or specified) branch is
|
|
|
|
* fetched and stored in the local branch of the same name.
|
|
|
|
*/
|
2007-09-11 11:02:56 +08:00
|
|
|
frag = strchr(p, '#');
|
|
|
|
if (frag) {
|
|
|
|
*(frag++) = '\0';
|
2008-03-26 07:35:28 +08:00
|
|
|
strbuf_addf(&branch, "refs/heads/%s", frag);
|
|
|
|
} else
|
|
|
|
strbuf_addstr(&branch, "refs/heads/master");
|
|
|
|
if (!slash) {
|
|
|
|
strbuf_addf(&branch, ":refs/heads/%s", remote->name);
|
2007-09-11 11:02:56 +08:00
|
|
|
} else {
|
2008-03-26 07:35:28 +08:00
|
|
|
strbuf_reset(&branch);
|
|
|
|
strbuf_addstr(&branch, "HEAD:");
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
2008-02-21 02:43:53 +08:00
|
|
|
add_url_alias(remote, p);
|
2009-06-19 01:28:43 +08:00
|
|
|
add_fetch_refspec(remote, strbuf_detach(&branch, NULL));
|
2008-11-11 05:47:11 +08:00
|
|
|
/*
|
|
|
|
* Cogito compatible push: push current HEAD to remote #branch
|
|
|
|
* (master if missing)
|
|
|
|
*/
|
|
|
|
strbuf_init(&branch, 0);
|
|
|
|
strbuf_addstr(&branch, "HEAD");
|
|
|
|
if (frag)
|
|
|
|
strbuf_addf(&branch, ":refs/heads/%s", frag);
|
|
|
|
else
|
|
|
|
strbuf_addstr(&branch, ":refs/heads/master");
|
2009-06-19 01:28:43 +08:00
|
|
|
add_push_refspec(remote, strbuf_detach(&branch, NULL));
|
2007-09-11 11:03:08 +08:00
|
|
|
remote->fetch_tags = 1; /* always auto-follow */
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2008-05-15 01:46:53 +08:00
|
|
|
static int handle_config(const char *key, const char *value, void *cb)
|
2007-05-12 23:45:53 +08:00
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
const char *subkey;
|
|
|
|
struct remote *remote;
|
2007-09-11 11:02:56 +08:00
|
|
|
struct branch *branch;
|
|
|
|
if (!prefixcmp(key, "branch.")) {
|
|
|
|
name = key + 7;
|
|
|
|
subkey = strrchr(name, '.');
|
|
|
|
if (!subkey)
|
|
|
|
return 0;
|
2007-12-15 12:34:56 +08:00
|
|
|
branch = make_branch(name, subkey - name);
|
2007-09-11 11:02:56 +08:00
|
|
|
if (!strcmp(subkey, ".remote")) {
|
2008-02-12 03:00:10 +08:00
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(key);
|
2007-09-11 11:02:56 +08:00
|
|
|
branch->remote_name = xstrdup(value);
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
if (branch == current_branch) {
|
2007-09-11 11:02:56 +08:00
|
|
|
default_remote_name = branch->remote_name;
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
explicit_default_remote_name = 1;
|
|
|
|
}
|
2008-02-12 03:00:10 +08:00
|
|
|
} else if (!strcmp(subkey, ".merge")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(key);
|
2007-09-11 11:02:56 +08:00
|
|
|
add_merge(branch, xstrdup(value));
|
2008-02-12 03:00:10 +08:00
|
|
|
}
|
2007-09-11 11:02:56 +08:00
|
|
|
return 0;
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
2008-02-21 02:43:53 +08:00
|
|
|
if (!prefixcmp(key, "url.")) {
|
|
|
|
struct rewrite *rewrite;
|
2008-04-13 03:32:00 +08:00
|
|
|
name = key + 4;
|
2008-02-21 02:43:53 +08:00
|
|
|
subkey = strrchr(name, '.');
|
|
|
|
if (!subkey)
|
|
|
|
return 0;
|
|
|
|
if (!strcmp(subkey, ".insteadof")) {
|
2009-09-07 16:56:33 +08:00
|
|
|
rewrite = make_rewrite(&rewrites, name, subkey - name);
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(key);
|
|
|
|
add_instead_of(rewrite, xstrdup(value));
|
|
|
|
} else if (!strcmp(subkey, ".pushinsteadof")) {
|
|
|
|
rewrite = make_rewrite(&rewrites_push, name, subkey - name);
|
2008-02-21 02:43:53 +08:00
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(key);
|
|
|
|
add_instead_of(rewrite, xstrdup(value));
|
|
|
|
}
|
|
|
|
}
|
2007-05-12 23:45:53 +08:00
|
|
|
if (prefixcmp(key, "remote."))
|
|
|
|
return 0;
|
|
|
|
name = key + 7;
|
2008-10-15 04:30:21 +08:00
|
|
|
if (*name == '/') {
|
|
|
|
warning("Config remote shorthand cannot begin with '/': %s",
|
|
|
|
name);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-05-12 23:45:53 +08:00
|
|
|
subkey = strrchr(name, '.');
|
|
|
|
if (!subkey)
|
2009-04-23 21:49:05 +08:00
|
|
|
return 0;
|
2007-05-12 23:45:53 +08:00
|
|
|
remote = make_remote(name, subkey - name);
|
2008-11-11 04:43:00 +08:00
|
|
|
remote->origin = REMOTE_CONFIG;
|
2008-04-17 19:17:20 +08:00
|
|
|
if (!strcmp(subkey, ".mirror"))
|
|
|
|
remote->mirror = git_config_bool(key, value);
|
|
|
|
else if (!strcmp(subkey, ".skipdefaultupdate"))
|
|
|
|
remote->skip_default_update = git_config_bool(key, value);
|
2009-11-10 04:11:06 +08:00
|
|
|
else if (!strcmp(subkey, ".skipfetchall"))
|
|
|
|
remote->skip_default_update = git_config_bool(key, value);
|
2008-04-17 19:17:20 +08:00
|
|
|
else if (!strcmp(subkey, ".url")) {
|
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
|
|
|
add_url(remote, v);
|
2009-06-10 00:01:34 +08:00
|
|
|
} else if (!strcmp(subkey, ".pushurl")) {
|
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
|
|
|
add_pushurl(remote, v);
|
2007-05-12 23:45:53 +08:00
|
|
|
} else if (!strcmp(subkey, ".push")) {
|
2008-04-17 19:17:20 +08:00
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
|
|
|
add_push_refspec(remote, v);
|
2007-05-12 23:46:03 +08:00
|
|
|
} else if (!strcmp(subkey, ".fetch")) {
|
2008-04-17 19:17:20 +08:00
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
|
|
|
add_fetch_refspec(remote, v);
|
2007-05-12 23:45:53 +08:00
|
|
|
} else if (!strcmp(subkey, ".receivepack")) {
|
2008-04-17 19:17:20 +08:00
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
2007-05-12 23:45:53 +08:00
|
|
|
if (!remote->receivepack)
|
2008-04-17 19:17:20 +08:00
|
|
|
remote->receivepack = v;
|
2007-05-12 23:45:53 +08:00
|
|
|
else
|
|
|
|
error("more than one receivepack given, using the first");
|
2007-09-11 11:02:51 +08:00
|
|
|
} else if (!strcmp(subkey, ".uploadpack")) {
|
2008-04-17 19:17:20 +08:00
|
|
|
const char *v;
|
|
|
|
if (git_config_string(&v, key, value))
|
|
|
|
return -1;
|
2007-09-11 11:02:51 +08:00
|
|
|
if (!remote->uploadpack)
|
2008-04-17 19:17:20 +08:00
|
|
|
remote->uploadpack = v;
|
2007-09-11 11:02:51 +08:00
|
|
|
else
|
|
|
|
error("more than one uploadpack given, using the first");
|
2007-09-11 11:03:08 +08:00
|
|
|
} else if (!strcmp(subkey, ".tagopt")) {
|
|
|
|
if (!strcmp(value, "--no-tags"))
|
|
|
|
remote->fetch_tags = -1;
|
2010-04-20 07:31:25 +08:00
|
|
|
else if (!strcmp(value, "--tags"))
|
|
|
|
remote->fetch_tags = 2;
|
2007-12-04 05:48:54 +08:00
|
|
|
} else if (!strcmp(subkey, ".proxy")) {
|
2008-04-17 19:17:20 +08:00
|
|
|
return git_config_string((const char **)&remote->http_proxy,
|
|
|
|
key, value);
|
2009-11-18 09:42:25 +08:00
|
|
|
} else if (!strcmp(subkey, ".vcs")) {
|
|
|
|
return git_config_string(&remote->foreign_vcs, key, value);
|
2008-04-17 19:17:20 +08:00
|
|
|
}
|
2007-05-12 23:45:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-21 02:43:53 +08:00
|
|
|
static void alias_all_urls(void)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i = 0; i < remotes_nr; i++) {
|
2009-09-07 16:56:33 +08:00
|
|
|
int add_pushurl_aliases;
|
2008-02-21 02:43:53 +08:00
|
|
|
if (!remotes[i])
|
|
|
|
continue;
|
2009-06-10 00:01:34 +08:00
|
|
|
for (j = 0; j < remotes[i]->pushurl_nr; j++) {
|
2009-09-07 16:56:00 +08:00
|
|
|
remotes[i]->pushurl[j] = alias_url(remotes[i]->pushurl[j], &rewrites);
|
2009-06-10 00:01:34 +08:00
|
|
|
}
|
2009-09-07 16:56:33 +08:00
|
|
|
add_pushurl_aliases = remotes[i]->pushurl_nr == 0;
|
|
|
|
for (j = 0; j < remotes[i]->url_nr; j++) {
|
|
|
|
if (add_pushurl_aliases)
|
|
|
|
add_pushurl_alias(remotes[i], remotes[i]->url[j]);
|
|
|
|
remotes[i]->url[j] = alias_url(remotes[i]->url[j], &rewrites);
|
|
|
|
}
|
2008-02-21 02:43:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
static void read_config(void)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
const char *head_ref;
|
|
|
|
int flag;
|
2010-06-04 17:32:11 +08:00
|
|
|
if (default_remote_name) /* did this already */
|
2007-05-12 23:45:53 +08:00
|
|
|
return;
|
|
|
|
default_remote_name = xstrdup("origin");
|
|
|
|
current_branch = NULL;
|
2011-12-12 19:20:32 +08:00
|
|
|
head_ref = resolve_ref_unsafe("HEAD", sha1, 0, &flag);
|
2007-05-12 23:45:53 +08:00
|
|
|
if (head_ref && (flag & REF_ISSYMREF) &&
|
|
|
|
!prefixcmp(head_ref, "refs/heads/")) {
|
2007-09-11 11:02:56 +08:00
|
|
|
current_branch =
|
|
|
|
make_branch(head_ref + strlen("refs/heads/"), 0);
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
2008-05-15 01:46:53 +08:00
|
|
|
git_config(handle_config, NULL);
|
2008-02-21 02:43:53 +08:00
|
|
|
alias_all_urls();
|
2007-05-12 23:45:53 +08:00
|
|
|
}
|
|
|
|
|
2008-08-22 08:16:30 +08:00
|
|
|
/*
|
|
|
|
* This function frees a refspec array.
|
|
|
|
* Warning: code paths should be checked to ensure that the src
|
|
|
|
* and dst pointers are always freeable pointers as well
|
|
|
|
* as the refspec pointer itself.
|
|
|
|
*/
|
2008-09-25 17:41:00 +08:00
|
|
|
static void free_refspecs(struct refspec *refspec, int nr_refspec)
|
2008-08-22 08:16:30 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!refspec)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_refspec; i++) {
|
|
|
|
free(refspec[i].src);
|
|
|
|
free(refspec[i].dst);
|
|
|
|
}
|
|
|
|
free(refspec);
|
|
|
|
}
|
|
|
|
|
2008-04-13 17:56:54 +08:00
|
|
|
static struct refspec *parse_refspec_internal(int nr_refspec, const char **refspec, int fetch, int verify)
|
2007-05-12 23:45:59 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct refspec *rs = xcalloc(sizeof(*rs), nr_refspec);
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
2007-05-12 23:45:59 +08:00
|
|
|
for (i = 0; i < nr_refspec; i++) {
|
2008-07-27 14:15:51 +08:00
|
|
|
size_t llen;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
int is_glob;
|
|
|
|
const char *lhs, *rhs;
|
2011-09-16 05:10:25 +08:00
|
|
|
int flags;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
2009-03-13 20:51:33 +08:00
|
|
|
is_glob = 0;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
|
|
|
lhs = refspec[i];
|
|
|
|
if (*lhs == '+') {
|
2007-05-12 23:45:59 +08:00
|
|
|
rs[i].force = 1;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
lhs++;
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
|
|
|
rhs = strrchr(lhs, ':');
|
2008-04-28 23:32:12 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Before going on, special case ":" (or "+:") as a refspec
|
|
|
|
* for matching refs.
|
|
|
|
*/
|
|
|
|
if (!fetch && rhs == lhs && rhs[1] == '\0') {
|
|
|
|
rs[i].matching = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
if (rhs) {
|
2008-07-27 14:15:51 +08:00
|
|
|
size_t rlen = strlen(++rhs);
|
2009-03-07 14:11:39 +08:00
|
|
|
is_glob = (1 <= rlen && strchr(rhs, '*'));
|
2009-03-07 14:11:36 +08:00
|
|
|
rs[i].dst = xstrndup(rhs, rlen);
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
2008-03-18 10:05:23 +08:00
|
|
|
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
llen = (rhs ? (rhs - lhs - 1) : strlen(lhs));
|
2009-03-07 14:11:39 +08:00
|
|
|
if (1 <= llen && memchr(lhs, '*', llen)) {
|
2008-03-26 12:15:52 +08:00
|
|
|
if ((rhs && !is_glob) || (!rhs && fetch))
|
|
|
|
goto invalid;
|
|
|
|
is_glob = 1;
|
|
|
|
} else if (rhs && is_glob) {
|
|
|
|
goto invalid;
|
2008-03-18 10:05:23 +08:00
|
|
|
}
|
2008-03-26 12:15:52 +08:00
|
|
|
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
rs[i].pattern = is_glob;
|
|
|
|
rs[i].src = xstrndup(lhs, llen);
|
2011-09-16 05:10:25 +08:00
|
|
|
flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0);
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
|
|
|
if (fetch) {
|
|
|
|
/*
|
|
|
|
* LHS
|
|
|
|
* - empty is allowed; it means HEAD.
|
|
|
|
* - otherwise it must be a valid looking ref.
|
|
|
|
*/
|
|
|
|
if (!*rs[i].src)
|
|
|
|
; /* empty is ok */
|
2011-09-16 05:10:25 +08:00
|
|
|
else if (check_refname_format(rs[i].src, flags))
|
|
|
|
goto invalid;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
/*
|
|
|
|
* RHS
|
2008-03-26 12:15:52 +08:00
|
|
|
* - missing is ok, and is same as empty.
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
* - empty is ok; it means not to store.
|
|
|
|
* - otherwise it must be a valid looking ref.
|
|
|
|
*/
|
2011-09-16 05:10:25 +08:00
|
|
|
if (!rs[i].dst)
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
; /* ok */
|
2011-09-16 05:10:25 +08:00
|
|
|
else if (!*rs[i].dst)
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
; /* ok */
|
2011-09-16 05:10:25 +08:00
|
|
|
else if (check_refname_format(rs[i].dst, flags))
|
|
|
|
goto invalid;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* LHS
|
|
|
|
* - empty is allowed; it means delete.
|
|
|
|
* - when wildcarded, it must be a valid looking ref.
|
|
|
|
* - otherwise, it must be an extended SHA-1, but
|
|
|
|
* there is no existing way to validate this.
|
|
|
|
*/
|
|
|
|
if (!*rs[i].src)
|
|
|
|
; /* empty is ok */
|
|
|
|
else if (is_glob) {
|
2011-09-16 05:10:25 +08:00
|
|
|
if (check_refname_format(rs[i].src, flags))
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
goto invalid;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
; /* anything goes, for now */
|
|
|
|
/*
|
|
|
|
* RHS
|
|
|
|
* - missing is allowed, but LHS then must be a
|
|
|
|
* valid looking ref.
|
|
|
|
* - empty is not allowed.
|
|
|
|
* - otherwise it must be a valid looking ref.
|
|
|
|
*/
|
|
|
|
if (!rs[i].dst) {
|
2011-09-16 05:10:25 +08:00
|
|
|
if (check_refname_format(rs[i].src, flags))
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
goto invalid;
|
|
|
|
} else if (!*rs[i].dst) {
|
|
|
|
goto invalid;
|
|
|
|
} else {
|
2011-09-16 05:10:25 +08:00
|
|
|
if (check_refname_format(rs[i].dst, flags))
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
goto invalid;
|
|
|
|
}
|
2008-03-18 10:05:23 +08:00
|
|
|
}
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
|
|
|
return rs;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
|
|
|
|
invalid:
|
2008-04-13 17:56:54 +08:00
|
|
|
if (verify) {
|
2008-08-22 08:16:30 +08:00
|
|
|
/*
|
|
|
|
* nr_refspec must be greater than zero and i must be valid
|
|
|
|
* since it is only possible to reach this point from within
|
|
|
|
* the for loop above.
|
|
|
|
*/
|
|
|
|
free_refspecs(rs, i+1);
|
2008-04-13 17:56:54 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
die("Invalid refspec '%s'", refspec[i]);
|
|
|
|
}
|
|
|
|
|
2008-04-13 17:56:54 +08:00
|
|
|
int valid_fetch_refspec(const char *fetch_refspec_str)
|
|
|
|
{
|
|
|
|
struct refspec *refspec;
|
|
|
|
|
2010-05-14 17:31:33 +08:00
|
|
|
refspec = parse_refspec_internal(1, &fetch_refspec_str, 1, 1);
|
2008-08-22 08:16:30 +08:00
|
|
|
free_refspecs(refspec, 1);
|
2008-04-13 17:56:54 +08:00
|
|
|
return !!refspec;
|
|
|
|
}
|
|
|
|
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
struct refspec *parse_fetch_refspec(int nr_refspec, const char **refspec)
|
|
|
|
{
|
2008-04-13 17:56:54 +08:00
|
|
|
return parse_refspec_internal(nr_refspec, refspec, 1, 0);
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
}
|
|
|
|
|
2008-09-25 17:41:00 +08:00
|
|
|
static struct refspec *parse_push_refspec(int nr_refspec, const char **refspec)
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
{
|
2008-04-13 17:56:54 +08:00
|
|
|
return parse_refspec_internal(nr_refspec, refspec, 0, 0);
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
|
|
|
|
2009-11-18 09:42:28 +08:00
|
|
|
void free_refspec(int nr_refspec, struct refspec *refspec)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < nr_refspec; i++) {
|
|
|
|
free(refspec[i].src);
|
|
|
|
free(refspec[i].dst);
|
|
|
|
}
|
|
|
|
free(refspec);
|
|
|
|
}
|
|
|
|
|
2008-02-16 03:14:18 +08:00
|
|
|
static int valid_remote_nick(const char *name)
|
|
|
|
{
|
2009-01-10 20:07:50 +08:00
|
|
|
if (!name[0] || is_dot_or_dotdot(name))
|
2008-02-16 03:14:18 +08:00
|
|
|
return 0;
|
|
|
|
return !strchr(name, '/'); /* no slash */
|
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
struct remote *remote_get(const char *name)
|
|
|
|
{
|
|
|
|
struct remote *ret;
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
int name_given = 0;
|
2007-05-12 23:45:53 +08:00
|
|
|
|
|
|
|
read_config();
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
if (name)
|
|
|
|
name_given = 1;
|
|
|
|
else {
|
2007-05-12 23:45:53 +08:00
|
|
|
name = default_remote_name;
|
Give error when no remote is configured
When there's no explicitly-named remote, we use the remote specified
for the current branch, which in turn defaults to "origin". But it
this case should require the remote to actually be configured, and not
fall back to the path "origin".
Possibly, the config file's "remote = something" should require the
something to be a configured remote instead of a bare repository URL,
but we actually test with a bare repository URL.
In fetch, we were giving the sensible error message when coming up
with a URL failed, but this wasn't actually reachable, so move that
error up and use it when appropriate.
In push, we need a new error message, because the old one (formerly
unreachable without a lot of help) used the repo name, which was NULL.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-11 13:47:20 +08:00
|
|
|
name_given = explicit_default_remote_name;
|
|
|
|
}
|
2009-03-16 15:35:09 +08:00
|
|
|
|
2007-05-12 23:45:53 +08:00
|
|
|
ret = make_remote(name, 0);
|
2008-02-16 03:14:18 +08:00
|
|
|
if (valid_remote_nick(name)) {
|
2009-11-18 09:42:23 +08:00
|
|
|
if (!valid_remote(ret))
|
2007-05-12 23:45:53 +08:00
|
|
|
read_remotes_file(ret);
|
2009-11-18 09:42:23 +08:00
|
|
|
if (!valid_remote(ret))
|
2007-05-12 23:45:53 +08:00
|
|
|
read_branches_file(ret);
|
|
|
|
}
|
2009-11-18 09:42:23 +08:00
|
|
|
if (name_given && !valid_remote(ret))
|
2008-02-21 02:43:53 +08:00
|
|
|
add_url_alias(ret, name);
|
2009-11-18 09:42:23 +08:00
|
|
|
if (!valid_remote(ret))
|
2007-05-12 23:45:53 +08:00
|
|
|
return NULL;
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
ret->fetch = parse_fetch_refspec(ret->fetch_refspec_nr, ret->fetch_refspec);
|
|
|
|
ret->push = parse_push_refspec(ret->push_refspec_nr, ret->push_refspec);
|
2007-05-12 23:45:53 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2007-05-12 23:45:59 +08:00
|
|
|
|
2009-04-06 21:41:01 +08:00
|
|
|
int remote_is_configured(const char *name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
read_config();
|
|
|
|
|
|
|
|
for (i = 0; i < remotes_nr; i++)
|
|
|
|
if (!strcmp(name, remotes[i]->name))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-11 01:48:40 +08:00
|
|
|
int for_each_remote(each_remote_fn fn, void *priv)
|
|
|
|
{
|
|
|
|
int i, result = 0;
|
|
|
|
read_config();
|
2008-02-19 12:41:41 +08:00
|
|
|
for (i = 0; i < remotes_nr && !result; i++) {
|
2007-07-11 01:48:40 +08:00
|
|
|
struct remote *r = remotes[i];
|
|
|
|
if (!r)
|
|
|
|
continue;
|
|
|
|
if (!r->fetch)
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
r->fetch = parse_fetch_refspec(r->fetch_refspec_nr,
|
|
|
|
r->fetch_refspec);
|
2007-07-11 01:48:40 +08:00
|
|
|
if (!r->push)
|
remote.c: Fix overtight refspec validation
We tightened the refspec validation code in an earlier commit ef00d15
(Tighten refspec processing, 2008-03-17) per my suggestion, but the
suggestion was misguided to begin with and it broke this usage:
$ git push origin HEAD~12:master
The syntax of push refspecs and fetch refspecs are similar in that they
are both colon separated LHS and RHS (possibly prefixed with a + to
force), but the similarity ends there. For example, LHS in a push refspec
can be anything that evaluates to a valid object name at runtime (except
when colon and RHS is missing, or it is a glob), while it must be a
valid-looking refname in a fetch refspec. To validate them correctly, the
caller needs to be able to say which kind of refspecs they are. It is
unreasonable to keep a single interface that cannot tell which kind it is
dealing with, and ask it to behave sensibly.
This commit separates the parsing of the two into different functions, and
clarifies the code to implement the parsing proper (i.e. splitting into
two parts, making sure both sides are wildcard or neither side is).
This happens to also allow pushing a commit named with the esoteric "look
for that string" syntax:
$ git push ../test.git ':/remote.c: Fix overtight refspec:master'
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-03-21 14:34:37 +08:00
|
|
|
r->push = parse_push_refspec(r->push_refspec_nr,
|
|
|
|
r->push_refspec);
|
2007-07-11 01:48:40 +08:00
|
|
|
result = fn(r, priv);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-10-08 12:25:07 +08:00
|
|
|
void ref_remove_duplicates(struct ref *ref_map)
|
|
|
|
{
|
2010-07-05 03:46:19 +08:00
|
|
|
struct string_list refs = STRING_LIST_INIT_NODUP;
|
2009-10-26 05:28:11 +08:00
|
|
|
struct string_list_item *item = NULL;
|
|
|
|
struct ref *prev = NULL, *next = NULL;
|
|
|
|
for (; ref_map; prev = ref_map, ref_map = next) {
|
|
|
|
next = ref_map->next;
|
2007-10-08 12:25:07 +08:00
|
|
|
if (!ref_map->peer_ref)
|
|
|
|
continue;
|
2009-10-26 05:28:11 +08:00
|
|
|
|
2010-06-26 07:41:37 +08:00
|
|
|
item = string_list_lookup(&refs, ref_map->peer_ref->name);
|
2009-10-26 05:28:11 +08:00
|
|
|
if (item) {
|
|
|
|
if (strcmp(((struct ref *)item->util)->name,
|
|
|
|
ref_map->name))
|
|
|
|
die("%s tracks both %s and %s",
|
|
|
|
ref_map->peer_ref->name,
|
|
|
|
((struct ref *)item->util)->name,
|
|
|
|
ref_map->name);
|
|
|
|
prev->next = ref_map->next;
|
|
|
|
free(ref_map->peer_ref);
|
|
|
|
free(ref_map);
|
2009-11-14 05:25:56 +08:00
|
|
|
ref_map = prev; /* skip this; we freed it */
|
|
|
|
continue;
|
2007-10-08 12:25:07 +08:00
|
|
|
}
|
2009-10-26 05:28:11 +08:00
|
|
|
|
2010-06-26 07:41:35 +08:00
|
|
|
item = string_list_insert(&refs, ref_map->peer_ref->name);
|
2009-10-26 05:28:11 +08:00
|
|
|
item->util = ref_map;
|
2007-10-08 12:25:07 +08:00
|
|
|
}
|
2009-10-26 05:28:11 +08:00
|
|
|
string_list_clear(&refs, 0);
|
2007-10-08 12:25:07 +08:00
|
|
|
}
|
|
|
|
|
2007-09-19 12:49:27 +08:00
|
|
|
int remote_has_url(struct remote *remote, const char *url)
|
2007-05-12 23:46:03 +08:00
|
|
|
{
|
|
|
|
int i;
|
2007-09-19 12:49:27 +08:00
|
|
|
for (i = 0; i < remote->url_nr; i++) {
|
|
|
|
if (!strcmp(remote->url[i], url))
|
2007-05-12 23:46:03 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-07 14:11:34 +08:00
|
|
|
static int match_name_with_pattern(const char *key, const char *name,
|
|
|
|
const char *value, char **result)
|
2009-03-07 14:11:29 +08:00
|
|
|
{
|
2009-03-07 14:11:36 +08:00
|
|
|
const char *kstar = strchr(key, '*');
|
|
|
|
size_t klen;
|
2009-03-07 14:11:39 +08:00
|
|
|
size_t ksuffixlen;
|
|
|
|
size_t namelen;
|
2009-03-07 14:11:36 +08:00
|
|
|
int ret;
|
|
|
|
if (!kstar)
|
|
|
|
die("Key '%s' of pattern had no '*'", key);
|
|
|
|
klen = kstar - key;
|
2009-03-07 14:11:39 +08:00
|
|
|
ksuffixlen = strlen(kstar + 1);
|
|
|
|
namelen = strlen(name);
|
|
|
|
ret = !strncmp(name, key, klen) && namelen >= klen + ksuffixlen &&
|
|
|
|
!memcmp(name + namelen - ksuffixlen, kstar + 1, ksuffixlen);
|
2009-03-07 14:11:34 +08:00
|
|
|
if (ret && value) {
|
2009-03-07 14:11:36 +08:00
|
|
|
const char *vstar = strchr(value, '*');
|
|
|
|
size_t vlen;
|
2009-03-07 14:11:39 +08:00
|
|
|
size_t vsuffixlen;
|
2009-03-07 14:11:36 +08:00
|
|
|
if (!vstar)
|
|
|
|
die("Value '%s' of pattern has no '*'", value);
|
|
|
|
vlen = vstar - value;
|
2009-03-07 14:11:39 +08:00
|
|
|
vsuffixlen = strlen(vstar + 1);
|
|
|
|
*result = xmalloc(vlen + vsuffixlen +
|
2009-03-07 14:11:34 +08:00
|
|
|
strlen(name) -
|
2009-03-07 14:11:39 +08:00
|
|
|
klen - ksuffixlen + 1);
|
|
|
|
strncpy(*result, value, vlen);
|
|
|
|
strncpy(*result + vlen,
|
|
|
|
name + klen, namelen - klen - ksuffixlen);
|
|
|
|
strcpy(*result + vlen + namelen - klen - ksuffixlen,
|
|
|
|
vstar + 1);
|
2009-03-07 14:11:34 +08:00
|
|
|
}
|
2009-03-07 14:11:29 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-15 13:04:24 +08:00
|
|
|
static int query_refspecs(struct refspec *refs, int ref_count, struct refspec *query)
|
2009-11-18 09:42:28 +08:00
|
|
|
{
|
|
|
|
int i;
|
2011-10-15 13:04:24 +08:00
|
|
|
int find_src = !query->src;
|
2009-11-18 09:42:28 +08:00
|
|
|
|
2011-10-15 13:04:24 +08:00
|
|
|
if (find_src && !query->dst)
|
|
|
|
return error("query_refspecs: need either src or dst");
|
2007-07-11 01:48:40 +08:00
|
|
|
|
2011-10-15 13:04:24 +08:00
|
|
|
for (i = 0; i < ref_count; i++) {
|
|
|
|
struct refspec *refspec = &refs[i];
|
|
|
|
const char *key = find_src ? refspec->dst : refspec->src;
|
|
|
|
const char *value = find_src ? refspec->src : refspec->dst;
|
|
|
|
const char *needle = find_src ? query->dst : query->src;
|
|
|
|
char **result = find_src ? &query->src : &query->dst;
|
2007-07-11 01:48:40 +08:00
|
|
|
|
2011-10-15 13:04:24 +08:00
|
|
|
if (!refspec->dst)
|
2007-05-12 23:46:03 +08:00
|
|
|
continue;
|
2011-10-15 13:04:24 +08:00
|
|
|
if (refspec->pattern) {
|
2009-03-07 14:11:34 +08:00
|
|
|
if (match_name_with_pattern(key, needle, value, result)) {
|
2011-10-15 13:04:24 +08:00
|
|
|
query->force = refspec->force;
|
2007-05-12 23:46:03 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-07-11 01:48:40 +08:00
|
|
|
} else if (!strcmp(needle, key)) {
|
|
|
|
*result = xstrdup(value);
|
2011-10-15 13:04:24 +08:00
|
|
|
query->force = refspec->force;
|
2007-07-11 01:48:40 +08:00
|
|
|
return 0;
|
2007-05-12 23:46:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-10-15 13:04:24 +08:00
|
|
|
char *apply_refspecs(struct refspec *refspecs, int nr_refspec,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct refspec query;
|
|
|
|
|
|
|
|
memset(&query, 0, sizeof(struct refspec));
|
|
|
|
query.src = (char *)name;
|
|
|
|
|
|
|
|
if (query_refspecs(refspecs, nr_refspec, &query))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return query.dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
int remote_find_tracking(struct remote *remote, struct refspec *refspec)
|
|
|
|
{
|
|
|
|
return query_refspecs(remote->fetch, remote->fetch_refspec_nr, refspec);
|
|
|
|
}
|
|
|
|
|
2008-10-18 16:37:40 +08:00
|
|
|
static struct ref *alloc_ref_with_prefix(const char *prefix, size_t prefixlen,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
size_t len = strlen(name);
|
|
|
|
struct ref *ref = xcalloc(1, sizeof(struct ref) + prefixlen + len + 1);
|
|
|
|
memcpy(ref->name, prefix, prefixlen);
|
|
|
|
memcpy(ref->name + prefixlen, name, len);
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2008-10-18 16:44:18 +08:00
|
|
|
struct ref *alloc_ref(const char *name)
|
2007-07-10 12:47:23 +08:00
|
|
|
{
|
2008-10-18 16:44:18 +08:00
|
|
|
return alloc_ref_with_prefix("", 0, name);
|
2008-05-11 07:26:58 +08:00
|
|
|
}
|
|
|
|
|
2011-06-08 07:03:03 +08:00
|
|
|
struct ref *copy_ref(const struct ref *ref)
|
2007-09-11 11:03:08 +08:00
|
|
|
{
|
2009-02-28 03:10:04 +08:00
|
|
|
struct ref *cpy;
|
|
|
|
size_t len;
|
|
|
|
if (!ref)
|
|
|
|
return NULL;
|
|
|
|
len = strlen(ref->name);
|
|
|
|
cpy = xmalloc(sizeof(struct ref) + len + 1);
|
|
|
|
memcpy(cpy, ref, sizeof(struct ref) + len + 1);
|
|
|
|
cpy->next = NULL;
|
|
|
|
cpy->symref = ref->symref ? xstrdup(ref->symref) : NULL;
|
|
|
|
cpy->remote_status = ref->remote_status ? xstrdup(ref->remote_status) : NULL;
|
|
|
|
cpy->peer_ref = copy_ref(ref->peer_ref);
|
|
|
|
return cpy;
|
2007-09-11 11:03:08 +08:00
|
|
|
}
|
|
|
|
|
2007-10-30 09:05:40 +08:00
|
|
|
struct ref *copy_ref_list(const struct ref *ref)
|
|
|
|
{
|
|
|
|
struct ref *ret = NULL;
|
|
|
|
struct ref **tail = &ret;
|
|
|
|
while (ref) {
|
|
|
|
*tail = copy_ref(ref);
|
|
|
|
ref = ref->next;
|
|
|
|
tail = &((*tail)->next);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-25 17:41:00 +08:00
|
|
|
static void free_ref(struct ref *ref)
|
2008-04-27 03:53:12 +08:00
|
|
|
{
|
|
|
|
if (!ref)
|
|
|
|
return;
|
2009-02-28 03:10:04 +08:00
|
|
|
free_ref(ref->peer_ref);
|
2008-04-27 03:53:12 +08:00
|
|
|
free(ref->remote_status);
|
|
|
|
free(ref->symref);
|
|
|
|
free(ref);
|
|
|
|
}
|
|
|
|
|
2007-07-10 12:47:23 +08:00
|
|
|
void free_refs(struct ref *ref)
|
|
|
|
{
|
|
|
|
struct ref *next;
|
|
|
|
while (ref) {
|
|
|
|
next = ref->next;
|
2008-04-27 03:53:12 +08:00
|
|
|
free_ref(ref);
|
2007-07-10 12:47:23 +08:00
|
|
|
ref = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-22 06:19:28 +08:00
|
|
|
int ref_compare_name(const void *va, const void *vb)
|
|
|
|
{
|
|
|
|
const struct ref *a = va, *b = vb;
|
|
|
|
return strcmp(a->name, b->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ref_list_get_next(const void *a)
|
|
|
|
{
|
|
|
|
return ((const struct ref *)a)->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ref_list_set_next(void *a, void *next)
|
|
|
|
{
|
|
|
|
((struct ref *)a)->next = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
void sort_ref_list(struct ref **l, int (*cmp)(const void *, const void *))
|
|
|
|
{
|
|
|
|
*l = llist_mergesort(*l, ref_list_get_next, ref_list_set_next, cmp);
|
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:59 +08:00
|
|
|
static int count_refspec_match(const char *pattern,
|
|
|
|
struct ref *refs,
|
|
|
|
struct ref **matched_ref)
|
|
|
|
{
|
|
|
|
int patlen = strlen(pattern);
|
|
|
|
struct ref *matched_weak = NULL;
|
|
|
|
struct ref *matched = NULL;
|
|
|
|
int weak_match = 0;
|
|
|
|
int match = 0;
|
|
|
|
|
|
|
|
for (weak_match = match = 0; refs; refs = refs->next) {
|
|
|
|
char *name = refs->name;
|
|
|
|
int namelen = strlen(name);
|
|
|
|
|
2007-11-11 22:01:47 +08:00
|
|
|
if (!refname_match(pattern, name, ref_rev_parse_rules))
|
2007-05-12 23:45:59 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* A match is "weak" if it is with refs outside
|
|
|
|
* heads or tags, and did not specify the pattern
|
|
|
|
* in full (e.g. "refs/remotes/origin/master") or at
|
|
|
|
* least from the toplevel (e.g. "remotes/origin/master");
|
|
|
|
* otherwise "git push $URL master" would result in
|
|
|
|
* ambiguity between remotes/origin/master and heads/master
|
|
|
|
* at the remote site.
|
|
|
|
*/
|
|
|
|
if (namelen != patlen &&
|
|
|
|
patlen != namelen - 5 &&
|
|
|
|
prefixcmp(name, "refs/heads/") &&
|
|
|
|
prefixcmp(name, "refs/tags/")) {
|
|
|
|
/* We want to catch the case where only weak
|
|
|
|
* matches are found and there are multiple
|
|
|
|
* matches, and where more than one strong
|
|
|
|
* matches are found, as ambiguous. One
|
|
|
|
* strong match with zero or more weak matches
|
|
|
|
* are acceptable as a unique match.
|
|
|
|
*/
|
|
|
|
matched_weak = refs;
|
|
|
|
weak_match++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
matched = refs;
|
|
|
|
match++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!matched) {
|
|
|
|
*matched_ref = matched_weak;
|
|
|
|
return weak_match;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*matched_ref = matched;
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-10 12:47:26 +08:00
|
|
|
static void tail_link_ref(struct ref *ref, struct ref ***tail)
|
2007-05-12 23:45:59 +08:00
|
|
|
{
|
|
|
|
**tail = ref;
|
2007-07-10 12:47:26 +08:00
|
|
|
while (ref->next)
|
|
|
|
ref = ref->next;
|
2007-05-12 23:45:59 +08:00
|
|
|
*tail = &ref->next;
|
|
|
|
}
|
|
|
|
|
2012-02-23 06:43:40 +08:00
|
|
|
static struct ref *alloc_delete_ref(void)
|
|
|
|
{
|
|
|
|
struct ref *ref = alloc_ref("(delete)");
|
|
|
|
hashclr(ref->new_sha1);
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2007-05-12 23:45:59 +08:00
|
|
|
static struct ref *try_explicit_object_name(const char *name)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct ref *ref;
|
|
|
|
|
2012-02-23 06:43:40 +08:00
|
|
|
if (!*name)
|
|
|
|
return alloc_delete_ref();
|
2007-05-12 23:45:59 +08:00
|
|
|
if (get_sha1(name, sha1))
|
|
|
|
return NULL;
|
2008-10-18 16:44:18 +08:00
|
|
|
ref = alloc_ref(name);
|
2007-05-12 23:45:59 +08:00
|
|
|
hashcpy(ref->new_sha1, sha1);
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2007-07-10 12:47:26 +08:00
|
|
|
static struct ref *make_linked_ref(const char *name, struct ref ***tail)
|
2007-05-12 23:45:59 +08:00
|
|
|
{
|
2008-10-18 16:44:18 +08:00
|
|
|
struct ref *ret = alloc_ref(name);
|
2007-07-10 12:47:26 +08:00
|
|
|
tail_link_ref(ret, tail);
|
|
|
|
return ret;
|
2007-06-09 15:07:34 +08:00
|
|
|
}
|
2007-05-25 13:20:56 +08:00
|
|
|
|
push: allow unqualified dest refspecs to DWIM
Previously, a push like:
git push remote src:dst
would go through the following steps:
1. check for an unambiguous 'dst' on the remote; if it
exists, then push to that ref
2. otherwise, check if 'dst' begins with 'refs/'; if it
does, create a new ref
3. otherwise, complain because we don't know where in the
refs hierarchy to put 'dst'
However, in some cases, we can guess about the ref type of
'dst' based on the ref type of 'src'. Specifically, before
complaining we now check:
2.5. if 'src' resolves to a ref starting with refs/heads
or refs/tags, then prepend that to 'dst'
So now this creates a new branch on the remote, whereas it
previously failed with an error message:
git push master:newbranch
Note that, by design, we limit this DWIM behavior only to
source refs which resolve exactly (including symrefs which
resolve to existing refs). We still complain on a partial
destination refspec if the source is a raw sha1, or a ref
expression such as 'master~10'.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-23 17:16:06 +08:00
|
|
|
static char *guess_ref(const char *name, struct ref *peer)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2011-12-12 19:20:32 +08:00
|
|
|
const char *r = resolve_ref_unsafe(peer->name, sha1, 1, NULL);
|
push: allow unqualified dest refspecs to DWIM
Previously, a push like:
git push remote src:dst
would go through the following steps:
1. check for an unambiguous 'dst' on the remote; if it
exists, then push to that ref
2. otherwise, check if 'dst' begins with 'refs/'; if it
does, create a new ref
3. otherwise, complain because we don't know where in the
refs hierarchy to put 'dst'
However, in some cases, we can guess about the ref type of
'dst' based on the ref type of 'src'. Specifically, before
complaining we now check:
2.5. if 'src' resolves to a ref starting with refs/heads
or refs/tags, then prepend that to 'dst'
So now this creates a new branch on the remote, whereas it
previously failed with an error message:
git push master:newbranch
Note that, by design, we limit this DWIM behavior only to
source refs which resolve exactly (including symrefs which
resolve to existing refs). We still complain on a partial
destination refspec if the source is a raw sha1, or a ref
expression such as 'master~10'.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-23 17:16:06 +08:00
|
|
|
if (!r)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!prefixcmp(r, "refs/heads/"))
|
|
|
|
strbuf_addstr(&buf, "refs/heads/");
|
|
|
|
else if (!prefixcmp(r, "refs/tags/"))
|
|
|
|
strbuf_addstr(&buf, "refs/tags/");
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
strbuf_addstr(&buf, name);
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
2007-06-09 14:22:58 +08:00
|
|
|
static int match_explicit(struct ref *src, struct ref *dst,
|
|
|
|
struct ref ***dst_tail,
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
struct refspec *rs)
|
2007-05-12 23:45:59 +08:00
|
|
|
{
|
2007-06-09 14:22:58 +08:00
|
|
|
struct ref *matched_src, *matched_dst;
|
2009-02-25 16:32:16 +08:00
|
|
|
int copy_src;
|
2007-05-25 13:20:56 +08:00
|
|
|
|
2007-06-09 14:22:58 +08:00
|
|
|
const char *dst_value = rs->dst;
|
push: allow unqualified dest refspecs to DWIM
Previously, a push like:
git push remote src:dst
would go through the following steps:
1. check for an unambiguous 'dst' on the remote; if it
exists, then push to that ref
2. otherwise, check if 'dst' begins with 'refs/'; if it
does, create a new ref
3. otherwise, complain because we don't know where in the
refs hierarchy to put 'dst'
However, in some cases, we can guess about the ref type of
'dst' based on the ref type of 'src'. Specifically, before
complaining we now check:
2.5. if 'src' resolves to a ref starting with refs/heads
or refs/tags, then prepend that to 'dst'
So now this creates a new branch on the remote, whereas it
previously failed with an error message:
git push master:newbranch
Note that, by design, we limit this DWIM behavior only to
source refs which resolve exactly (including symrefs which
resolve to existing refs). We still complain on a partial
destination refspec if the source is a raw sha1, or a ref
expression such as 'master~10'.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-23 17:16:06 +08:00
|
|
|
char *dst_guess;
|
2007-05-12 23:45:59 +08:00
|
|
|
|
2008-04-28 23:32:12 +08:00
|
|
|
if (rs->pattern || rs->matching)
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
return 0;
|
2007-05-25 13:20:56 +08:00
|
|
|
|
2007-06-09 14:22:58 +08:00
|
|
|
matched_src = matched_dst = NULL;
|
|
|
|
switch (count_refspec_match(rs->src, src, &matched_src)) {
|
|
|
|
case 1:
|
2009-02-25 16:32:16 +08:00
|
|
|
copy_src = 1;
|
2007-06-09 14:22:58 +08:00
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
/* The source could be in the get_sha1() format
|
|
|
|
* not a reference name. :refs/other is a
|
|
|
|
* way to delete 'other' ref at the remote end.
|
|
|
|
*/
|
|
|
|
matched_src = try_explicit_object_name(rs->src);
|
2007-09-25 12:13:19 +08:00
|
|
|
if (!matched_src)
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
return error("src refspec %s does not match any.", rs->src);
|
2009-02-25 16:32:16 +08:00
|
|
|
copy_src = 0;
|
2007-06-09 14:22:58 +08:00
|
|
|
break;
|
|
|
|
default:
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
return error("src refspec %s matches more than one.", rs->src);
|
2007-06-09 14:22:58 +08:00
|
|
|
}
|
2007-06-09 15:14:04 +08:00
|
|
|
|
2007-09-25 12:13:25 +08:00
|
|
|
if (!dst_value) {
|
2008-02-21 01:54:05 +08:00
|
|
|
unsigned char sha1[20];
|
|
|
|
int flag;
|
|
|
|
|
2011-12-12 19:20:32 +08:00
|
|
|
dst_value = resolve_ref_unsafe(matched_src->name, sha1, 1, &flag);
|
2008-02-21 01:54:05 +08:00
|
|
|
if (!dst_value ||
|
|
|
|
((flag & REF_ISSYMREF) &&
|
|
|
|
prefixcmp(dst_value, "refs/heads/")))
|
|
|
|
die("%s cannot be resolved to branch.",
|
|
|
|
matched_src->name);
|
2007-09-25 12:13:25 +08:00
|
|
|
}
|
2007-06-09 15:14:04 +08:00
|
|
|
|
2007-06-09 14:22:58 +08:00
|
|
|
switch (count_refspec_match(dst_value, dst, &matched_dst)) {
|
|
|
|
case 1:
|
|
|
|
break;
|
|
|
|
case 0:
|
2007-06-09 15:07:34 +08:00
|
|
|
if (!memcmp(dst_value, "refs/", 5))
|
2007-07-10 12:47:26 +08:00
|
|
|
matched_dst = make_linked_ref(dst_value, dst_tail);
|
push: don't guess at qualifying remote refs on deletion
When we try to push a ref and the right-hand side of the
refspec does not find a match, we try to create it. If it is
not fully qualified, we try to guess where it would go in
the refs hierarchy based on the left-hand source side. If
the source side is not a ref, then we give up and give a
long explanatory message.
For deletions, however, this doesn't make any sense. We
would never want to create on the remote side, and if an
unqualified ref can't be matched, it is simply an error. The
current code handles this already because the left-hand side
is empty, and therefore does not give us a hint as to where
the right-hand side should go, and we properly error out.
Unfortunately, the error message is the long "we tried to
qualify this, but the source side didn't let us guess"
message, which is quite confusing.
Instead, we can just be more succinct and say "we can't
delete this because we couldn't find it". So before:
$ git push origin :bogus
error: unable to push to unqualified destination: bogus
The destination refspec neither matches an existing ref on the remote nor
begins with refs/, and we are unable to guess a prefix based on the source ref.
error: failed to push some refs to '$URL'
and now:
$ git push origin :bogus
error: unable to delete 'bogus': remote ref does not exist
error: failed to push some refs to '$URL'
It is tempting to also catch a fully-qualified ref like
"refs/heads/bogus" and generate the same error message.
However, that currently does not error out at all, and
instead gets sent to the remote side, which typically
generates a warning:
$ git push origin:refs/heads/bogus
remote: warning: Deleting a non-existent ref.
To $URL
- [deleted] bogus
While it would be nice to catch this error early, a
client-side error would mean aborting the push entirely and
changing push's exit code. For example, right now you can
do:
$ git push origin refs/heads/foo refs/heads/bar
and end up in a state where "foo" and "bar" are deleted,
whether both of them currently exist or not (and see an
error only if we actually failed to contact the server).
Generating an error would cause a regression for this use
case.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-07-04 02:04:39 +08:00
|
|
|
else if (is_null_sha1(matched_src->new_sha1))
|
|
|
|
error("unable to delete '%s': remote ref does not exist",
|
|
|
|
dst_value);
|
2009-09-01 13:35:10 +08:00
|
|
|
else if ((dst_guess = guess_ref(dst_value, matched_src)))
|
push: allow unqualified dest refspecs to DWIM
Previously, a push like:
git push remote src:dst
would go through the following steps:
1. check for an unambiguous 'dst' on the remote; if it
exists, then push to that ref
2. otherwise, check if 'dst' begins with 'refs/'; if it
does, create a new ref
3. otherwise, complain because we don't know where in the
refs hierarchy to put 'dst'
However, in some cases, we can guess about the ref type of
'dst' based on the ref type of 'src'. Specifically, before
complaining we now check:
2.5. if 'src' resolves to a ref starting with refs/heads
or refs/tags, then prepend that to 'dst'
So now this creates a new branch on the remote, whereas it
previously failed with an error message:
git push master:newbranch
Note that, by design, we limit this DWIM behavior only to
source refs which resolve exactly (including symrefs which
resolve to existing refs). We still complain on a partial
destination refspec if the source is a raw sha1, or a ref
expression such as 'master~10'.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-23 17:16:06 +08:00
|
|
|
matched_dst = make_linked_ref(dst_guess, dst_tail);
|
2007-06-09 15:14:04 +08:00
|
|
|
else
|
push: allow unqualified dest refspecs to DWIM
Previously, a push like:
git push remote src:dst
would go through the following steps:
1. check for an unambiguous 'dst' on the remote; if it
exists, then push to that ref
2. otherwise, check if 'dst' begins with 'refs/'; if it
does, create a new ref
3. otherwise, complain because we don't know where in the
refs hierarchy to put 'dst'
However, in some cases, we can guess about the ref type of
'dst' based on the ref type of 'src'. Specifically, before
complaining we now check:
2.5. if 'src' resolves to a ref starting with refs/heads
or refs/tags, then prepend that to 'dst'
So now this creates a new branch on the remote, whereas it
previously failed with an error message:
git push master:newbranch
Note that, by design, we limit this DWIM behavior only to
source refs which resolve exactly (including symrefs which
resolve to existing refs). We still complain on a partial
destination refspec if the source is a raw sha1, or a ref
expression such as 'master~10'.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-04-23 17:16:06 +08:00
|
|
|
error("unable to push to unqualified destination: %s\n"
|
|
|
|
"The destination refspec neither matches an "
|
|
|
|
"existing ref on the remote nor\n"
|
|
|
|
"begins with refs/, and we are unable to "
|
|
|
|
"guess a prefix based on the source ref.",
|
|
|
|
dst_value);
|
2007-06-09 14:22:58 +08:00
|
|
|
break;
|
|
|
|
default:
|
2007-06-09 15:14:04 +08:00
|
|
|
matched_dst = NULL;
|
2007-06-09 14:22:58 +08:00
|
|
|
error("dst refspec %s matches more than one.",
|
|
|
|
dst_value);
|
|
|
|
break;
|
|
|
|
}
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
if (!matched_dst)
|
|
|
|
return -1;
|
|
|
|
if (matched_dst->peer_ref)
|
|
|
|
return error("dst ref %s receives from more than one src.",
|
2007-06-09 14:22:58 +08:00
|
|
|
matched_dst->name);
|
|
|
|
else {
|
2009-02-25 16:32:16 +08:00
|
|
|
matched_dst->peer_ref = copy_src ? copy_ref(matched_src) : matched_src;
|
2007-06-09 14:22:58 +08:00
|
|
|
matched_dst->force = rs->force;
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
return 0;
|
2007-06-09 14:22:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int match_explicit_refs(struct ref *src, struct ref *dst,
|
|
|
|
struct ref ***dst_tail, struct refspec *rs,
|
|
|
|
int rs_nr)
|
|
|
|
{
|
|
|
|
int i, errs;
|
|
|
|
for (i = errs = 0; i < rs_nr; i++)
|
clean up error conventions of remote.c:match_explicit
match_explicit is called for each push refspec to try to
fully resolve the source and destination sides of the
refspec. Currently, we look at each refspec and report
errors on both the source and the dest side before aborting.
It makes sense to report errors for each refspec, since an
error in one is independent of an error in the other.
However, reporting errors on the 'dst' side of a refspec if
there has been an error on the 'src' side does not
necessarily make sense, since the interpretation of the
'dst' side depends on the 'src' side (for example, when
creating a new unqualified remote ref, we use the same type
as the src ref).
This patch lets match_explicit return early when the src
side of the refspec is bogus. We still look at all of the
refspecs before aborting the push, though.
At the same time, we clean up the call signature, which
previously took an extra "errs" flag. This was pointless, as
we didn't act on that flag, but rather just passed it back
to the caller. Instead, we now use the more traditional
"return -1" to signal an error, and the caller aggregates
the error count.
This change fixes two bugs, as well:
- the early return avoids a segfault when passing a NULL
matched_src to guess_ref()
- the check for multiple sources pointing to a single dest
aborted if the "err" flag was set. Presumably the intent
was not to bother with the check if we had no
matched_src. However, since the err flag was passed in
from the caller, we might abort the check just because a
previous refspec had a problem, which doesn't make
sense.
In practice, this didn't matter, since due to the error
flag we end up aborting the push anyway.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-17 00:15:02 +08:00
|
|
|
errs += match_explicit(src, dst, dst_tail, &rs[i]);
|
|
|
|
return errs;
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
|
|
|
|
2012-02-23 06:43:39 +08:00
|
|
|
static char *get_ref_match(const struct refspec *rs, int rs_nr, const struct ref *ref,
|
2012-02-23 06:43:41 +08:00
|
|
|
int send_mirror, int direction, const struct refspec **ret_pat)
|
2007-05-25 13:20:56 +08:00
|
|
|
{
|
2012-02-23 06:43:39 +08:00
|
|
|
const struct refspec *pat;
|
|
|
|
char *name;
|
2007-05-25 13:20:56 +08:00
|
|
|
int i;
|
2008-04-28 23:32:12 +08:00
|
|
|
int matching_refs = -1;
|
2007-05-25 13:20:56 +08:00
|
|
|
for (i = 0; i < rs_nr; i++) {
|
2008-04-28 23:32:12 +08:00
|
|
|
if (rs[i].matching &&
|
|
|
|
(matching_refs == -1 || rs[i].force)) {
|
|
|
|
matching_refs = i;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-02-23 06:43:39 +08:00
|
|
|
if (rs[i].pattern) {
|
|
|
|
const char *dst_side = rs[i].dst ? rs[i].dst : rs[i].src;
|
2012-02-23 06:43:41 +08:00
|
|
|
int match;
|
|
|
|
if (direction == FROM_SRC)
|
|
|
|
match = match_name_with_pattern(rs[i].src, ref->name, dst_side, &name);
|
|
|
|
else
|
|
|
|
match = match_name_with_pattern(dst_side, ref->name, rs[i].src, &name);
|
|
|
|
if (match) {
|
2012-02-23 06:43:39 +08:00
|
|
|
matching_refs = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-05-25 13:20:56 +08:00
|
|
|
}
|
2012-02-23 06:43:39 +08:00
|
|
|
if (matching_refs == -1)
|
2008-04-28 23:32:12 +08:00
|
|
|
return NULL;
|
2012-02-23 06:43:39 +08:00
|
|
|
|
|
|
|
pat = rs + matching_refs;
|
|
|
|
if (pat->matching) {
|
|
|
|
/*
|
|
|
|
* "matching refs"; traditionally we pushed everything
|
|
|
|
* including refs outside refs/heads/ hierarchy, but
|
|
|
|
* that does not make much sense these days.
|
|
|
|
*/
|
|
|
|
if (!send_mirror && prefixcmp(ref->name, "refs/heads/"))
|
|
|
|
return NULL;
|
|
|
|
name = xstrdup(ref->name);
|
|
|
|
}
|
|
|
|
if (ret_pat)
|
|
|
|
*ret_pat = pat;
|
|
|
|
return name;
|
2007-05-25 13:20:56 +08:00
|
|
|
}
|
|
|
|
|
2009-05-31 22:26:48 +08:00
|
|
|
static struct ref **tail_ref(struct ref **head)
|
|
|
|
{
|
|
|
|
struct ref **tail = head;
|
|
|
|
while (*tail)
|
|
|
|
tail = &((*tail)->next);
|
|
|
|
return tail;
|
|
|
|
}
|
|
|
|
|
2007-06-09 14:22:58 +08:00
|
|
|
/*
|
2011-09-10 02:54:58 +08:00
|
|
|
* Given the set of refs the local repository has, the set of refs the
|
|
|
|
* remote repository has, and the refspec used for push, determine
|
|
|
|
* what remote refs we will update and with what value by setting
|
|
|
|
* peer_ref (which object is being pushed) and force (if the push is
|
|
|
|
* forced) in elements of "dst". The function may add new elements to
|
|
|
|
* dst (e.g. pushing to a new branch, done in match_explicit_refs).
|
2007-06-09 14:22:58 +08:00
|
|
|
*/
|
2011-09-10 02:54:58 +08:00
|
|
|
int match_push_refs(struct ref *src, struct ref **dst,
|
|
|
|
int nr_refspec, const char **refspec, int flags)
|
2007-05-12 23:45:59 +08:00
|
|
|
{
|
2008-04-28 23:32:12 +08:00
|
|
|
struct refspec *rs;
|
2007-11-10 07:32:10 +08:00
|
|
|
int send_all = flags & MATCH_REFS_ALL;
|
|
|
|
int send_mirror = flags & MATCH_REFS_MIRROR;
|
2012-02-23 06:43:41 +08:00
|
|
|
int send_prune = flags & MATCH_REFS_PRUNE;
|
2009-02-25 16:32:17 +08:00
|
|
|
int errs;
|
2009-06-19 01:28:43 +08:00
|
|
|
static const char *default_refspec[] = { ":", NULL };
|
2012-02-23 06:43:38 +08:00
|
|
|
struct ref *ref, **dst_tail = tail_ref(dst);
|
2007-05-12 23:45:59 +08:00
|
|
|
|
2008-04-28 23:32:12 +08:00
|
|
|
if (!nr_refspec) {
|
|
|
|
nr_refspec = 1;
|
|
|
|
refspec = default_refspec;
|
|
|
|
}
|
|
|
|
rs = parse_push_refspec(nr_refspec, (const char **) refspec);
|
2009-05-31 22:26:48 +08:00
|
|
|
errs = match_explicit_refs(src, *dst, &dst_tail, rs, nr_refspec);
|
2007-05-12 23:45:59 +08:00
|
|
|
|
|
|
|
/* pick the remainder */
|
2012-02-23 06:43:38 +08:00
|
|
|
for (ref = src; ref; ref = ref->next) {
|
2007-05-12 23:45:59 +08:00
|
|
|
struct ref *dst_peer;
|
2007-06-08 07:43:05 +08:00
|
|
|
const struct refspec *pat = NULL;
|
|
|
|
char *dst_name;
|
2012-02-23 06:43:39 +08:00
|
|
|
|
2012-02-23 06:43:38 +08:00
|
|
|
if (ref->peer_ref)
|
2007-05-12 23:45:59 +08:00
|
|
|
continue;
|
2008-04-28 23:32:12 +08:00
|
|
|
|
2012-02-23 06:43:41 +08:00
|
|
|
dst_name = get_ref_match(rs, nr_refspec, ref, send_mirror, FROM_SRC, &pat);
|
2012-02-23 06:43:39 +08:00
|
|
|
if (!dst_name)
|
2008-04-28 23:32:12 +08:00
|
|
|
continue;
|
|
|
|
|
2009-05-31 22:26:48 +08:00
|
|
|
dst_peer = find_ref_by_name(*dst, dst_name);
|
2008-04-28 23:32:12 +08:00
|
|
|
if (dst_peer) {
|
|
|
|
if (dst_peer->peer_ref)
|
|
|
|
/* We're already sending something to this ref. */
|
|
|
|
goto free_name;
|
|
|
|
} else {
|
|
|
|
if (pat->matching && !(send_all || send_mirror))
|
|
|
|
/*
|
|
|
|
* Remote doesn't have it, and we have no
|
|
|
|
* explicit pattern, and we don't have
|
|
|
|
* --all nor --mirror.
|
|
|
|
*/
|
|
|
|
goto free_name;
|
2007-11-10 07:32:10 +08:00
|
|
|
|
2007-05-12 23:45:59 +08:00
|
|
|
/* Create a new one and link it */
|
2009-05-31 22:26:48 +08:00
|
|
|
dst_peer = make_linked_ref(dst_name, &dst_tail);
|
2012-02-23 06:43:38 +08:00
|
|
|
hashcpy(dst_peer->new_sha1, ref->new_sha1);
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
2012-02-23 06:43:38 +08:00
|
|
|
dst_peer->peer_ref = copy_ref(ref);
|
2008-04-28 23:32:12 +08:00
|
|
|
dst_peer->force = pat->force;
|
2007-06-08 07:43:05 +08:00
|
|
|
free_name:
|
|
|
|
free(dst_name);
|
2007-05-12 23:45:59 +08:00
|
|
|
}
|
2012-02-23 06:43:41 +08:00
|
|
|
if (send_prune) {
|
|
|
|
/* check for missing refs on the remote */
|
|
|
|
for (ref = *dst; ref; ref = ref->next) {
|
|
|
|
char *src_name;
|
|
|
|
|
|
|
|
if (ref->peer_ref)
|
|
|
|
/* We're already sending something to this ref. */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
src_name = get_ref_match(rs, nr_refspec, ref, send_mirror, FROM_DST, NULL);
|
|
|
|
if (src_name) {
|
|
|
|
if (!find_ref_by_name(src, src_name))
|
|
|
|
ref->peer_ref = alloc_delete_ref();
|
|
|
|
free(src_name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-02-25 16:32:17 +08:00
|
|
|
if (errs)
|
|
|
|
return -1;
|
2007-05-12 23:45:59 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-09-11 11:02:56 +08:00
|
|
|
|
2010-01-08 10:12:42 +08:00
|
|
|
void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
|
|
|
|
int force_update)
|
|
|
|
{
|
|
|
|
struct ref *ref;
|
|
|
|
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
2012-11-30 09:41:36 +08:00
|
|
|
int force_ref_update = ref->force || force_update;
|
|
|
|
|
2010-01-08 10:12:42 +08:00
|
|
|
if (ref->peer_ref)
|
|
|
|
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
|
|
|
|
else if (!send_mirror)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ref->deletion = is_null_sha1(ref->new_sha1);
|
|
|
|
if (!ref->deletion &&
|
|
|
|
!hashcmp(ref->old_sha1, ref->new_sha1)) {
|
|
|
|
ref->status = REF_STATUS_UPTODATE;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-11-30 09:41:40 +08:00
|
|
|
/*
|
push: fix "refs/tags/ hierarchy cannot be updated without --force"
When pushing to update a branch with a commit that is not a
descendant of the commit at the tip, a wrong message "already
exists" was given, instead of the correct "non-fast-forward", if we
do not have the object sitting in the destination repository at the
tip of the ref we are updating.
The primary cause of the bug is that the check in a new helper
function is_forwardable() assumed both old and new objects are
available and can be checked, which is not always the case.
The way the caller uses the result of this function is also wrong.
If the helper says "we do not want to let this push go through", the
caller unconditionally translates it into "we blocked it because the
destination already exists", which is not true at all in this case.
Fix this by doing these three things:
* Remove unnecessary not_forwardable from "struct ref"; it is only
used inside set_ref_status_for_push();
* Make "refs/tags/" the only hierarchy that cannot be replaced
without --force;
* Remove the misguided attempt to force that everything that
updates an existing ref has to be a commit outside "refs/tags/"
hierarchy.
The policy last one tried to implement may later be resurrected and
extended to ensure fast-forwardness (defined as "not losing
objects", extending from the traditional "not losing commits from
the resulting history") when objects that are not commit are
involved (e.g. an annotated tag in hierarchies outside refs/tags),
but such a logic belongs to "is this a fast-forward?" check that is
done by ref_newer(); is_forwardable(), which is now removed, was not
the right place to do so.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-17 05:02:27 +08:00
|
|
|
* Decide whether an individual refspec A:B can be
|
|
|
|
* pushed. The push will succeed if any of the
|
|
|
|
* following are true:
|
2010-01-08 10:12:42 +08:00
|
|
|
*
|
2012-11-30 09:41:40 +08:00
|
|
|
* (1) the remote reference B does not exist
|
2010-01-08 10:12:42 +08:00
|
|
|
*
|
2012-11-30 09:41:40 +08:00
|
|
|
* (2) the remote reference B is being removed (i.e.,
|
|
|
|
* pushing :B where no source is specified)
|
2010-01-08 10:12:42 +08:00
|
|
|
*
|
push: fix "refs/tags/ hierarchy cannot be updated without --force"
When pushing to update a branch with a commit that is not a
descendant of the commit at the tip, a wrong message "already
exists" was given, instead of the correct "non-fast-forward", if we
do not have the object sitting in the destination repository at the
tip of the ref we are updating.
The primary cause of the bug is that the check in a new helper
function is_forwardable() assumed both old and new objects are
available and can be checked, which is not always the case.
The way the caller uses the result of this function is also wrong.
If the helper says "we do not want to let this push go through", the
caller unconditionally translates it into "we blocked it because the
destination already exists", which is not true at all in this case.
Fix this by doing these three things:
* Remove unnecessary not_forwardable from "struct ref"; it is only
used inside set_ref_status_for_push();
* Make "refs/tags/" the only hierarchy that cannot be replaced
without --force;
* Remove the misguided attempt to force that everything that
updates an existing ref has to be a commit outside "refs/tags/"
hierarchy.
The policy last one tried to implement may later be resurrected and
extended to ensure fast-forwardness (defined as "not losing
objects", extending from the traditional "not losing commits from
the resulting history") when objects that are not commit are
involved (e.g. an annotated tag in hierarchies outside refs/tags),
but such a logic belongs to "is this a fast-forward?" check that is
done by ref_newer(); is_forwardable(), which is now removed, was not
the right place to do so.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-17 05:02:27 +08:00
|
|
|
* (3) the destination is not under refs/tags/, and
|
|
|
|
* if the old and new value is a commit, the new
|
|
|
|
* is a descendant of the old.
|
2010-01-08 10:12:42 +08:00
|
|
|
*
|
2012-11-30 09:41:40 +08:00
|
|
|
* (4) it is forced using the +A:B notation, or by
|
|
|
|
* passing the --force argument
|
2010-01-08 10:12:42 +08:00
|
|
|
*/
|
|
|
|
|
2013-01-22 12:24:07 +08:00
|
|
|
if (!ref->deletion && !is_null_sha1(ref->old_sha1)) {
|
2013-01-24 05:14:48 +08:00
|
|
|
int why = 0; /* why would this push require --force? */
|
|
|
|
|
|
|
|
if (!prefixcmp(ref->name, "refs/tags/"))
|
|
|
|
why = REF_STATUS_REJECT_ALREADY_EXISTS;
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-24 05:55:30 +08:00
|
|
|
else if (!has_sha1_file(ref->old_sha1))
|
|
|
|
why = 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;
|
|
|
|
else if (!ref_newer(ref->new_sha1, ref->old_sha1))
|
2013-01-24 05:14:48 +08:00
|
|
|
why = REF_STATUS_REJECT_NONFASTFORWARD;
|
|
|
|
|
|
|
|
if (!force_ref_update)
|
|
|
|
ref->status = why;
|
|
|
|
else if (why)
|
2013-01-22 12:24:07 +08:00
|
|
|
ref->forced_update = 1;
|
2010-01-08 10:12:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-11 11:02:56 +08:00
|
|
|
struct branch *branch_get(const char *name)
|
|
|
|
{
|
|
|
|
struct branch *ret;
|
|
|
|
|
|
|
|
read_config();
|
|
|
|
if (!name || !*name || !strcmp(name, "HEAD"))
|
|
|
|
ret = current_branch;
|
|
|
|
else
|
|
|
|
ret = make_branch(name, 0);
|
|
|
|
if (ret && ret->remote_name) {
|
|
|
|
ret->remote = remote_get(ret->remote_name);
|
|
|
|
if (ret->merge_nr) {
|
|
|
|
int i;
|
|
|
|
ret->merge = xcalloc(sizeof(*ret->merge),
|
|
|
|
ret->merge_nr);
|
|
|
|
for (i = 0; i < ret->merge_nr; i++) {
|
|
|
|
ret->merge[i] = xcalloc(1, sizeof(**ret->merge));
|
|
|
|
ret->merge[i]->src = xstrdup(ret->merge_name[i]);
|
2009-04-02 05:42:49 +08:00
|
|
|
if (remote_find_tracking(ret->remote, ret->merge[i])
|
|
|
|
&& !strcmp(ret->remote_name, "."))
|
|
|
|
ret->merge[i]->dst = xstrdup(ret->merge_name[i]);
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int branch_has_merge_config(struct branch *branch)
|
|
|
|
{
|
|
|
|
return branch && !!branch->merge;
|
|
|
|
}
|
|
|
|
|
2007-09-18 16:54:53 +08:00
|
|
|
int branch_merge_matches(struct branch *branch,
|
|
|
|
int i,
|
|
|
|
const char *refname)
|
2007-09-11 11:02:56 +08:00
|
|
|
{
|
2007-09-18 16:54:53 +08:00
|
|
|
if (!branch || i < 0 || i >= branch->merge_nr)
|
2007-09-11 11:02:56 +08:00
|
|
|
return 0;
|
2007-11-11 22:01:48 +08:00
|
|
|
return refname_match(branch->merge[i]->src, refname, ref_fetch_rules);
|
2007-09-11 11:02:56 +08:00
|
|
|
}
|
2007-09-11 11:03:08 +08:00
|
|
|
|
fetch: ignore wildcarded refspecs that update local symbolic refs
In a repository cloned from somewhere else, you typically have a
symbolic ref refs/remotes/origin/HEAD pointing at the 'master'
remote-tracking ref that is next to it. When fetching into such a
repository with "git fetch --mirror" from another repository that
was similarly cloned, the implied wildcard refspec refs/*:refs/*
will end up asking to update refs/remotes/origin/HEAD with the
object at refs/remotes/origin/HEAD at the remote side, while asking
to update refs/remotes/origin/master the same way. Depending on the
order the two updates happen, the latter one would find that the
value of the ref before it is updated has changed from what the code
expects.
When the user asks to update the underlying ref via the symbolic ref
explicitly without using a wildcard refspec, e.g. "git fetch $there
refs/heads/master:refs/remotes/origin/HEAD", we should still let him
do so, but when expanding wildcard refs, it will result in a more
intuitive outcome if we simply ignore local symbolic refs.
As the purpose of the symbolic ref refs/remotes/origin/HEAD is to
follow the ref it points at (e.g. refs/remotes/origin/master), its
value would change when the underlying ref is updated.
Earlier commit da3efdb (receive-pack: detect aliased updates which
can occur with symrefs, 2010-04-19) fixed a similar issue for "git
push".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-12-12 05:00:52 +08:00
|
|
|
static int ignore_symref_update(const char *refname)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
if (!resolve_ref_unsafe(refname, sha1, 0, &flag))
|
|
|
|
return 0; /* non-existing refs are OK */
|
|
|
|
return (flag & REF_ISSYMREF);
|
|
|
|
}
|
|
|
|
|
2007-10-30 09:05:40 +08:00
|
|
|
static struct ref *get_expanded_map(const struct ref *remote_refs,
|
2007-09-11 11:03:08 +08:00
|
|
|
const struct refspec *refspec)
|
|
|
|
{
|
2007-10-30 09:05:40 +08:00
|
|
|
const struct ref *ref;
|
2007-09-11 11:03:08 +08:00
|
|
|
struct ref *ret = NULL;
|
|
|
|
struct ref **tail = &ret;
|
|
|
|
|
2009-03-07 14:11:34 +08:00
|
|
|
char *expn_name;
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
for (ref = remote_refs; ref; ref = ref->next) {
|
|
|
|
if (strchr(ref->name, '^'))
|
|
|
|
continue; /* a dereference item */
|
2009-03-07 14:11:34 +08:00
|
|
|
if (match_name_with_pattern(refspec->src, ref->name,
|
fetch: ignore wildcarded refspecs that update local symbolic refs
In a repository cloned from somewhere else, you typically have a
symbolic ref refs/remotes/origin/HEAD pointing at the 'master'
remote-tracking ref that is next to it. When fetching into such a
repository with "git fetch --mirror" from another repository that
was similarly cloned, the implied wildcard refspec refs/*:refs/*
will end up asking to update refs/remotes/origin/HEAD with the
object at refs/remotes/origin/HEAD at the remote side, while asking
to update refs/remotes/origin/master the same way. Depending on the
order the two updates happen, the latter one would find that the
value of the ref before it is updated has changed from what the code
expects.
When the user asks to update the underlying ref via the symbolic ref
explicitly without using a wildcard refspec, e.g. "git fetch $there
refs/heads/master:refs/remotes/origin/HEAD", we should still let him
do so, but when expanding wildcard refs, it will result in a more
intuitive outcome if we simply ignore local symbolic refs.
As the purpose of the symbolic ref refs/remotes/origin/HEAD is to
follow the ref it points at (e.g. refs/remotes/origin/master), its
value would change when the underlying ref is updated.
Earlier commit da3efdb (receive-pack: detect aliased updates which
can occur with symrefs, 2010-04-19) fixed a similar issue for "git
push".
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-12-12 05:00:52 +08:00
|
|
|
refspec->dst, &expn_name) &&
|
|
|
|
!ignore_symref_update(expn_name)) {
|
2007-09-11 11:03:08 +08:00
|
|
|
struct ref *cpy = copy_ref(ref);
|
|
|
|
|
2009-03-07 14:11:34 +08:00
|
|
|
cpy->peer_ref = alloc_ref(expn_name);
|
|
|
|
free(expn_name);
|
2007-09-11 11:03:08 +08:00
|
|
|
if (refspec->force)
|
|
|
|
cpy->peer_ref->force = 1;
|
|
|
|
*tail = cpy;
|
|
|
|
tail = &cpy->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-10-30 09:05:40 +08:00
|
|
|
static const struct ref *find_ref_by_name_abbrev(const struct ref *refs, const char *name)
|
2007-09-11 11:03:08 +08:00
|
|
|
{
|
2007-10-30 09:05:40 +08:00
|
|
|
const struct ref *ref;
|
2007-09-11 11:03:08 +08:00
|
|
|
for (ref = refs; ref; ref = ref->next) {
|
2007-11-11 22:01:48 +08:00
|
|
|
if (refname_match(name, ref->name, ref_fetch_rules))
|
2007-09-11 11:03:08 +08:00
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-30 09:05:40 +08:00
|
|
|
struct ref *get_remote_ref(const struct ref *remote_refs, const char *name)
|
2007-09-11 11:03:08 +08:00
|
|
|
{
|
2007-10-30 09:05:40 +08:00
|
|
|
const struct ref *ref = find_ref_by_name_abbrev(remote_refs, name);
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
if (!ref)
|
2007-10-27 14:09:48 +08:00
|
|
|
return NULL;
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
return copy_ref(ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref *get_local_ref(const char *name)
|
|
|
|
{
|
2009-06-17 21:38:36 +08:00
|
|
|
if (!name || name[0] == '\0')
|
2007-09-11 11:03:08 +08:00
|
|
|
return NULL;
|
|
|
|
|
2008-10-18 16:44:18 +08:00
|
|
|
if (!prefixcmp(name, "refs/"))
|
|
|
|
return alloc_ref(name);
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
if (!prefixcmp(name, "heads/") ||
|
|
|
|
!prefixcmp(name, "tags/") ||
|
2008-10-18 16:37:40 +08:00
|
|
|
!prefixcmp(name, "remotes/"))
|
|
|
|
return alloc_ref_with_prefix("refs/", 5, name);
|
2007-09-11 11:03:08 +08:00
|
|
|
|
2008-10-18 16:37:40 +08:00
|
|
|
return alloc_ref_with_prefix("refs/heads/", 11, name);
|
2007-09-11 11:03:08 +08:00
|
|
|
}
|
|
|
|
|
2007-10-30 09:05:40 +08:00
|
|
|
int get_fetch_map(const struct ref *remote_refs,
|
2007-09-11 11:03:08 +08:00
|
|
|
const struct refspec *refspec,
|
2007-10-27 14:09:48 +08:00
|
|
|
struct ref ***tail,
|
|
|
|
int missing_ok)
|
2007-09-11 11:03:08 +08:00
|
|
|
{
|
2008-03-18 10:05:23 +08:00
|
|
|
struct ref *ref_map, **rmp;
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
if (refspec->pattern) {
|
|
|
|
ref_map = get_expanded_map(remote_refs, refspec);
|
|
|
|
} else {
|
2007-10-27 14:09:48 +08:00
|
|
|
const char *name = refspec->src[0] ? refspec->src : "HEAD";
|
|
|
|
|
|
|
|
ref_map = get_remote_ref(remote_refs, name);
|
|
|
|
if (!missing_ok && !ref_map)
|
|
|
|
die("Couldn't find remote ref %s", name);
|
|
|
|
if (ref_map) {
|
|
|
|
ref_map->peer_ref = get_local_ref(refspec->dst);
|
|
|
|
if (ref_map->peer_ref && refspec->force)
|
|
|
|
ref_map->peer_ref->force = 1;
|
|
|
|
}
|
2007-09-11 11:03:08 +08:00
|
|
|
}
|
|
|
|
|
2008-03-18 10:05:23 +08:00
|
|
|
for (rmp = &ref_map; *rmp; ) {
|
|
|
|
if ((*rmp)->peer_ref) {
|
2012-05-05 06:35:18 +08:00
|
|
|
if (prefixcmp((*rmp)->peer_ref->name, "refs/") ||
|
|
|
|
check_refname_format((*rmp)->peer_ref->name, 0)) {
|
2008-03-18 10:05:23 +08:00
|
|
|
struct ref *ignore = *rmp;
|
|
|
|
error("* Ignoring funny ref '%s' locally",
|
|
|
|
(*rmp)->peer_ref->name);
|
|
|
|
*rmp = (*rmp)->next;
|
|
|
|
free(ignore->peer_ref);
|
|
|
|
free(ignore);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rmp = &((*rmp)->next);
|
2007-09-11 11:03:08 +08:00
|
|
|
}
|
|
|
|
|
2007-10-13 04:40:04 +08:00
|
|
|
if (ref_map)
|
|
|
|
tail_link_ref(ref_map, tail);
|
2007-09-11 11:03:08 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-04-27 03:53:12 +08:00
|
|
|
|
|
|
|
int resolve_remote_symref(struct ref *ref, struct ref *list)
|
|
|
|
{
|
|
|
|
if (!ref->symref)
|
|
|
|
return 0;
|
|
|
|
for (; list; list = list->next)
|
|
|
|
if (!strcmp(ref->symref, list->name)) {
|
|
|
|
hashcpy(ref->old_sha1, list->old_sha1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2008-07-02 15:51:18 +08:00
|
|
|
|
2009-02-25 16:32:12 +08:00
|
|
|
static void unmark_and_free(struct commit_list *list, unsigned int mark)
|
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct commit_list *temp = list;
|
|
|
|
temp->item->object.flags &= ~mark;
|
|
|
|
list = temp->next;
|
|
|
|
free(temp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int ref_newer(const unsigned char *new_sha1, const unsigned char *old_sha1)
|
|
|
|
{
|
|
|
|
struct object *o;
|
|
|
|
struct commit *old, *new;
|
|
|
|
struct commit_list *list, *used;
|
|
|
|
int found = 0;
|
|
|
|
|
push: introduce REJECT_FETCH_FIRST and REJECT_NEEDS_FORCE
When we push to update an existing ref, if:
* the object at the tip of the remote is not a commit; or
* the object we are pushing is not a commit,
it won't be correct to suggest to fetch, integrate and push again,
as the old and new objects will not "merge". We should explain that
the push must be forced when there is a non-committish object is
involved in such a case.
If we do not have the current object at the tip of the remote, we do
not even know that object, when fetched, is something that can be
merged. In such a case, suggesting to pull first just like
non-fast-forward case may not be technically correct, but in
practice, most such failures are seen when you try to push your work
to a branch without knowing that somebody else already pushed to
update the same branch since you forked, so "pull first" would work
as a suggestion most of the time. And if the object at the tip is
not a commit, "pull first" will fail, without making any permanent
damage. As a side effect, it also makes the error message the user
will get during the next "push" attempt easier to understand, now
the user is aware that a non-commit object is involved.
In these cases, the current code already rejects such a push on the
client end, but we used the same error and advice messages as the
ones used when rejecting a non-fast-forward push, i.e. pull from
there and integrate before pushing again.
Introduce new rejection reasons and reword the messages
appropriately.
[jc: with help by Peff on message details]
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-24 05:55:30 +08:00
|
|
|
/*
|
|
|
|
* Both new and old must be commit-ish and new is descendant of
|
2009-02-25 16:32:12 +08:00
|
|
|
* old. Otherwise we require --force.
|
|
|
|
*/
|
|
|
|
o = deref_tag(parse_object(old_sha1), NULL, 0);
|
|
|
|
if (!o || o->type != OBJ_COMMIT)
|
|
|
|
return 0;
|
|
|
|
old = (struct commit *) o;
|
|
|
|
|
|
|
|
o = deref_tag(parse_object(new_sha1), NULL, 0);
|
|
|
|
if (!o || o->type != OBJ_COMMIT)
|
|
|
|
return 0;
|
|
|
|
new = (struct commit *) o;
|
|
|
|
|
|
|
|
if (parse_commit(new) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
used = list = NULL;
|
|
|
|
commit_list_insert(new, &list);
|
|
|
|
while (list) {
|
|
|
|
new = pop_most_recent_commit(&list, TMP_MARK);
|
|
|
|
commit_list_insert(new, &used);
|
|
|
|
if (new == old) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
unmark_and_free(list, TMP_MARK);
|
|
|
|
unmark_and_free(used, TMP_MARK);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2008-07-02 15:51:18 +08:00
|
|
|
/*
|
|
|
|
* Return true if there is anything to report, otherwise false.
|
|
|
|
*/
|
|
|
|
int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct commit *ours, *theirs;
|
|
|
|
char symmetric[84];
|
|
|
|
struct rev_info revs;
|
|
|
|
const char *rev_argv[10], *base;
|
|
|
|
int rev_argc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nothing to report 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.
|
|
|
|
*/
|
|
|
|
base = branch->merge[0]->dst;
|
2011-11-13 18:22:14 +08:00
|
|
|
if (read_ref(base, sha1))
|
2008-07-02 15:51:18 +08:00
|
|
|
return 0;
|
2009-05-11 22:42:54 +08:00
|
|
|
theirs = lookup_commit_reference(sha1);
|
2008-07-02 15:51:18 +08:00
|
|
|
if (!theirs)
|
|
|
|
return 0;
|
|
|
|
|
2011-11-13 18:22:14 +08:00
|
|
|
if (read_ref(branch->refname, sha1))
|
2008-07-02 15:51:18 +08:00
|
|
|
return 0;
|
2009-05-11 22:42:54 +08:00
|
|
|
ours = lookup_commit_reference(sha1);
|
2008-07-02 15:51:18 +08:00
|
|
|
if (!ours)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* are we the same? */
|
|
|
|
if (theirs == ours)
|
|
|
|
return 0;
|
|
|
|
|
2009-04-22 07:32:18 +08:00
|
|
|
/* Run "rev-list --left-right ours...theirs" internally... */
|
2008-07-02 15:51:18 +08:00
|
|
|
rev_argc = 0;
|
|
|
|
rev_argv[rev_argc++] = NULL;
|
|
|
|
rev_argv[rev_argc++] = "--left-right";
|
|
|
|
rev_argv[rev_argc++] = symmetric;
|
|
|
|
rev_argv[rev_argc++] = "--";
|
|
|
|
rev_argv[rev_argc] = NULL;
|
|
|
|
|
|
|
|
strcpy(symmetric, sha1_to_hex(ours->object.sha1));
|
|
|
|
strcpy(symmetric + 40, "...");
|
|
|
|
strcpy(symmetric + 43, sha1_to_hex(theirs->object.sha1));
|
|
|
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
setup_revisions(rev_argc, rev_argv, &revs, NULL);
|
|
|
|
prepare_revision_walk(&revs);
|
|
|
|
|
|
|
|
/* ... and count the commits on each side. */
|
|
|
|
*num_ours = 0;
|
|
|
|
*num_theirs = 0;
|
|
|
|
while (1) {
|
|
|
|
struct commit *c = get_revision(&revs);
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
if (c->object.flags & SYMMETRIC_LEFT)
|
|
|
|
(*num_ours)++;
|
|
|
|
else
|
|
|
|
(*num_theirs)++;
|
|
|
|
}
|
2008-07-04 03:09:48 +08:00
|
|
|
|
|
|
|
/* clear object flags smudged by the above traversal */
|
|
|
|
clear_commit_marks(ours, ALL_REV_FLAGS);
|
|
|
|
clear_commit_marks(theirs, ALL_REV_FLAGS);
|
2008-07-02 15:51:18 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return true when there is anything to report, otherwise false.
|
|
|
|
*/
|
|
|
|
int format_tracking_info(struct branch *branch, struct strbuf *sb)
|
|
|
|
{
|
|
|
|
int num_ours, num_theirs;
|
2008-07-17 03:19:27 +08:00
|
|
|
const char *base;
|
2008-07-02 15:51:18 +08:00
|
|
|
|
|
|
|
if (!stat_tracking_info(branch, &num_ours, &num_theirs))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
base = branch->merge[0]->dst;
|
2009-04-16 16:20:44 +08:00
|
|
|
base = shorten_unambiguous_ref(base, 0);
|
2012-11-15 18:45:00 +08:00
|
|
|
if (!num_theirs) {
|
2012-02-02 10:02:23 +08:00
|
|
|
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);
|
2012-12-03 14:16:57 +08:00
|
|
|
if (advice_status_hints)
|
|
|
|
strbuf_addf(sb,
|
|
|
|
_(" (use \"git push\" to publish your local commits)\n"));
|
2012-11-15 18:45:00 +08:00
|
|
|
} else if (!num_ours) {
|
2012-02-02 10:02:23 +08:00
|
|
|
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);
|
2012-12-03 14:16:57 +08:00
|
|
|
if (advice_status_hints)
|
|
|
|
strbuf_addf(sb,
|
|
|
|
_(" (use \"git pull\" to update your local branch)\n"));
|
2012-11-15 18:45:00 +08:00
|
|
|
} else {
|
2012-02-02 10:02:23 +08:00
|
|
|
strbuf_addf(sb,
|
|
|
|
Q_("Your branch and '%s' have diverged,\n"
|
|
|
|
"and have %d and %d different commit each, "
|
|
|
|
"respectively.\n",
|
|
|
|
"Your branch and '%s' have diverged,\n"
|
|
|
|
"and have %d and %d different commits each, "
|
|
|
|
"respectively.\n",
|
|
|
|
num_theirs),
|
|
|
|
base, num_ours, num_theirs);
|
2012-12-03 14:16:57 +08:00
|
|
|
if (advice_status_hints)
|
|
|
|
strbuf_addf(sb,
|
|
|
|
_(" (use \"git pull\" to merge the remote branch into yours)\n"));
|
2012-11-15 18:45:00 +08:00
|
|
|
}
|
2008-07-02 15:51:18 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2009-02-25 16:32:11 +08:00
|
|
|
|
|
|
|
static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
|
|
|
{
|
|
|
|
struct ref ***local_tail = cb_data;
|
|
|
|
struct ref *ref;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* we already know it starts with refs/ to get here */
|
2011-09-16 05:10:25 +08:00
|
|
|
if (check_refname_format(refname + 5, 0))
|
2009-02-25 16:32:11 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = strlen(refname) + 1;
|
|
|
|
ref = xcalloc(1, sizeof(*ref) + len);
|
|
|
|
hashcpy(ref->new_sha1, sha1);
|
|
|
|
memcpy(ref->name, refname, len);
|
|
|
|
**local_tail = ref;
|
|
|
|
*local_tail = &ref->next;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ref *get_local_heads(void)
|
|
|
|
{
|
2009-04-17 06:16:23 +08:00
|
|
|
struct ref *local_refs = NULL, **local_tail = &local_refs;
|
2009-02-25 16:32:11 +08:00
|
|
|
for_each_ref(one_local_ref, &local_tail);
|
|
|
|
return local_refs;
|
|
|
|
}
|
2009-02-25 16:32:13 +08:00
|
|
|
|
2009-02-28 03:10:05 +08:00
|
|
|
struct ref *guess_remote_head(const struct ref *head,
|
|
|
|
const struct ref *refs,
|
|
|
|
int all)
|
2009-02-25 16:32:13 +08:00
|
|
|
{
|
|
|
|
const struct ref *r;
|
2009-02-28 03:10:05 +08:00
|
|
|
struct ref *list = NULL;
|
|
|
|
struct ref **tail = &list;
|
2009-02-25 16:32:13 +08:00
|
|
|
|
2009-02-25 16:32:14 +08:00
|
|
|
if (!head)
|
2009-02-25 16:32:13 +08:00
|
|
|
return NULL;
|
|
|
|
|
2009-02-28 03:10:06 +08:00
|
|
|
/*
|
|
|
|
* Some transports support directly peeking at
|
|
|
|
* where HEAD points; if that is the case, then
|
|
|
|
* we don't have to guess.
|
|
|
|
*/
|
|
|
|
if (head->symref)
|
|
|
|
return copy_ref(find_ref_by_name(refs, head->symref));
|
|
|
|
|
2009-02-25 16:32:13 +08:00
|
|
|
/* If refs/heads/master could be right, it is. */
|
2009-02-28 03:10:05 +08:00
|
|
|
if (!all) {
|
|
|
|
r = find_ref_by_name(refs, "refs/heads/master");
|
|
|
|
if (r && !hashcmp(r->old_sha1, head->old_sha1))
|
|
|
|
return copy_ref(r);
|
|
|
|
}
|
2009-02-25 16:32:13 +08:00
|
|
|
|
|
|
|
/* Look for another ref that points there */
|
2009-02-28 03:10:05 +08:00
|
|
|
for (r = refs; r; r = r->next) {
|
2011-06-03 13:11:13 +08:00
|
|
|
if (r != head &&
|
|
|
|
!prefixcmp(r->name, "refs/heads/") &&
|
|
|
|
!hashcmp(r->old_sha1, head->old_sha1)) {
|
2009-02-28 03:10:05 +08:00
|
|
|
*tail = copy_ref(r);
|
|
|
|
tail = &((*tail)->next);
|
|
|
|
if (!all)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-02-25 16:32:13 +08:00
|
|
|
|
2009-02-28 03:10:05 +08:00
|
|
|
return list;
|
2009-02-25 16:32:13 +08:00
|
|
|
}
|
2009-11-10 13:03:31 +08:00
|
|
|
|
|
|
|
struct stale_heads_info {
|
|
|
|
struct string_list *ref_names;
|
|
|
|
struct ref **stale_refs_tail;
|
2011-10-15 13:04:25 +08:00
|
|
|
struct refspec *refs;
|
|
|
|
int ref_count;
|
2009-11-10 13:03:31 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int get_stale_heads_cb(const char *refname,
|
|
|
|
const unsigned char *sha1, int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct stale_heads_info *info = cb_data;
|
2011-10-15 13:04:25 +08:00
|
|
|
struct refspec query;
|
|
|
|
memset(&query, 0, sizeof(struct refspec));
|
|
|
|
query.dst = (char *)refname;
|
|
|
|
|
|
|
|
if (query_refspecs(info->refs, info->ref_count, &query))
|
|
|
|
return 0; /* No matches */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we did find a suitable refspec and it's not a symref and
|
|
|
|
* it's not in the list of refs that currently exist in that
|
|
|
|
* remote we consider it to be stale.
|
|
|
|
*/
|
|
|
|
if (!((flags & REF_ISSYMREF) ||
|
|
|
|
string_list_has_string(info->ref_names, query.src))) {
|
|
|
|
struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
|
|
|
|
hashcpy(ref->new_sha1, sha1);
|
2009-11-10 13:03:31 +08:00
|
|
|
}
|
2011-10-15 13:04:25 +08:00
|
|
|
|
|
|
|
free(query.src);
|
2009-11-10 13:03:31 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-15 13:04:25 +08:00
|
|
|
struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fetch_map)
|
2009-11-10 13:03:31 +08:00
|
|
|
{
|
|
|
|
struct ref *ref, *stale_refs = NULL;
|
2010-07-05 03:46:19 +08:00
|
|
|
struct string_list ref_names = STRING_LIST_INIT_NODUP;
|
2009-11-10 13:03:31 +08:00
|
|
|
struct stale_heads_info info;
|
|
|
|
info.ref_names = &ref_names;
|
|
|
|
info.stale_refs_tail = &stale_refs;
|
2011-10-15 13:04:25 +08:00
|
|
|
info.refs = refs;
|
|
|
|
info.ref_count = ref_count;
|
2009-11-10 13:03:31 +08:00
|
|
|
for (ref = fetch_map; ref; ref = ref->next)
|
2010-06-26 07:41:38 +08:00
|
|
|
string_list_append(&ref_names, ref->name);
|
2009-11-10 13:03:31 +08:00
|
|
|
sort_string_list(&ref_names);
|
|
|
|
for_each_ref(get_stale_heads_cb, &info);
|
|
|
|
string_list_clear(&ref_names, 0);
|
|
|
|
return stale_refs;
|
|
|
|
}
|