5
static struct remote **remotes;
6
static int allocated_remotes;
8
#define BUF_SIZE (2048)
9
static char buffer[BUF_SIZE];
11
static void add_push_refspec(struct remote *remote, const char *ref)
13
int nr = remote->push_refspec_nr + 1;
14
remote->push_refspec =
15
xrealloc(remote->push_refspec, nr * sizeof(char *));
16
remote->push_refspec[nr-1] = ref;
17
remote->push_refspec_nr = nr;
20
static void add_fetch_refspec(struct remote *remote, const char *ref)
22
int nr = remote->fetch_refspec_nr + 1;
23
remote->fetch_refspec =
24
xrealloc(remote->fetch_refspec, nr * sizeof(char *));
25
remote->fetch_refspec[nr-1] = ref;
26
remote->fetch_refspec_nr = nr;
29
static void add_uri(struct remote *remote, const char *uri)
31
int nr = remote->uri_nr + 1;
33
xrealloc(remote->uri, nr * sizeof(char *));
34
remote->uri[nr-1] = uri;
38
static struct remote *make_remote(const char *name, int len)
42
for (i = 0; i < allocated_remotes; i++) {
47
if (len ? (!strncmp(name, remotes[i]->name, len) &&
48
!remotes[i]->name[len]) :
49
!strcmp(name, remotes[i]->name))
55
empty = allocated_remotes;
56
allocated_remotes += allocated_remotes ? allocated_remotes : 1;
57
remotes = xrealloc(remotes,
58
sizeof(*remotes) * allocated_remotes);
59
memset(remotes + empty, 0,
60
(allocated_remotes - empty) * sizeof(*remotes));
62
remotes[empty] = xcalloc(1, sizeof(struct remote));
64
remotes[empty]->name = xstrndup(name, len);
66
remotes[empty]->name = xstrdup(name);
67
return remotes[empty];
70
static void read_remotes_file(struct remote *remote)
72
FILE *f = fopen(git_path("remotes/%s", remote->name), "r");
76
while (fgets(buffer, BUF_SIZE, f)) {
80
if (!prefixcmp(buffer, "URL:")) {
83
} else if (!prefixcmp(buffer, "Push:")) {
86
} else if (!prefixcmp(buffer, "Pull:")) {
98
while (isspace(p[-1]))
101
switch (value_list) {
103
add_uri(remote, xstrdup(s));
106
add_push_refspec(remote, xstrdup(s));
109
add_fetch_refspec(remote, xstrdup(s));
116
static void read_branches_file(struct remote *remote)
118
const char *slash = strchr(remote->name, '/');
119
int n = slash ? slash - remote->name : 1000;
120
FILE *f = fopen(git_path("branches/%.*s", n, remote->name), "r");
126
s = fgets(buffer, BUF_SIZE, f);
135
while (isspace(p[-1]))
139
len += strlen(slash);
140
p = xmalloc(len + 1);
147
static char *default_remote_name = NULL;
148
static const char *current_branch = NULL;
149
static int current_branch_len = 0;
151
static int handle_config(const char *key, const char *value)
155
struct remote *remote;
156
if (!prefixcmp(key, "branch.") && current_branch &&
157
!strncmp(key + 7, current_branch, current_branch_len) &&
158
!strcmp(key + 7 + current_branch_len, ".remote")) {
159
free(default_remote_name);
160
default_remote_name = xstrdup(value);
162
if (prefixcmp(key, "remote."))
165
subkey = strrchr(name, '.');
167
return error("Config with no key for remote %s", name);
168
if (*subkey == '/') {
169
warning("Config remote shorthand cannot begin with '/': %s", name);
172
remote = make_remote(name, subkey - name);
174
/* if we ever have a boolean variable, e.g. "remote.*.disabled"
177
* is a valid way to set it to true; we get NULL in value so
178
* we need to handle it here.
180
* if (!strcmp(subkey, ".disabled")) {
181
* val = git_config_bool(key, value);
186
return 0; /* ignore unknown booleans */
188
if (!strcmp(subkey, ".url")) {
189
add_uri(remote, xstrdup(value));
190
} else if (!strcmp(subkey, ".push")) {
191
add_push_refspec(remote, xstrdup(value));
192
} else if (!strcmp(subkey, ".fetch")) {
193
add_fetch_refspec(remote, xstrdup(value));
194
} else if (!strcmp(subkey, ".receivepack")) {
195
if (!remote->receivepack)
196
remote->receivepack = xstrdup(value);
198
error("more than one receivepack given, using the first");
203
static void read_config(void)
205
unsigned char sha1[20];
206
const char *head_ref;
208
if (default_remote_name) // did this already
210
default_remote_name = xstrdup("origin");
211
current_branch = NULL;
212
head_ref = resolve_ref("HEAD", sha1, 0, &flag);
213
if (head_ref && (flag & REF_ISSYMREF) &&
214
!prefixcmp(head_ref, "refs/heads/")) {
215
current_branch = head_ref + strlen("refs/heads/");
216
current_branch_len = strlen(current_branch);
218
git_config(handle_config);
221
static struct refspec *parse_ref_spec(int nr_refspec, const char **refspec)
224
struct refspec *rs = xcalloc(sizeof(*rs), nr_refspec);
225
for (i = 0; i < nr_refspec; i++) {
226
const char *sp, *ep, *gp;
232
gp = strchr(sp, '*');
233
ep = strchr(sp, ':');
234
if (gp && ep && gp > ep)
238
const char *glob = strchr(ep + 1, '*');
242
rs[i].dst = xstrndup(ep + 1,
245
rs[i].dst = xstrdup(ep + 1);
248
ep = sp + strlen(sp);
254
rs[i].src = xstrndup(sp, ep - sp);
259
struct remote *remote_get(const char *name)
265
name = default_remote_name;
266
ret = make_remote(name, 0);
267
if (name[0] != '/') {
269
read_remotes_file(ret);
271
read_branches_file(ret);
277
ret->fetch = parse_ref_spec(ret->fetch_refspec_nr, ret->fetch_refspec);
278
ret->push = parse_ref_spec(ret->push_refspec_nr, ret->push_refspec);
282
int for_each_remote(each_remote_fn fn, void *priv)
286
for (i = 0; i < allocated_remotes && !result; i++) {
287
struct remote *r = remotes[i];
291
r->fetch = parse_ref_spec(r->fetch_refspec_nr,
294
r->push = parse_ref_spec(r->push_refspec_nr,
296
result = fn(r, priv);
301
int remote_has_uri(struct remote *remote, const char *uri)
304
for (i = 0; i < remote->uri_nr; i++) {
305
if (!strcmp(remote->uri[i], uri))
311
int remote_find_tracking(struct remote *remote, struct refspec *refspec)
313
int find_src = refspec->src == NULL;
314
char *needle, **result;
318
if (refspec->dst == NULL)
319
return error("find_tracking: need either src or dst");
320
needle = refspec->dst;
321
result = &refspec->src;
323
needle = refspec->src;
324
result = &refspec->dst;
327
for (i = 0; i < remote->fetch_refspec_nr; i++) {
328
struct refspec *fetch = &remote->fetch[i];
329
const char *key = find_src ? fetch->dst : fetch->src;
330
const char *value = find_src ? fetch->src : fetch->dst;
333
if (fetch->pattern) {
334
if (!prefixcmp(needle, key)) {
335
*result = xmalloc(strlen(value) +
338
strcpy(*result, value);
339
strcpy(*result + strlen(value),
340
needle + strlen(key));
341
refspec->force = fetch->force;
344
} else if (!strcmp(needle, key)) {
345
*result = xstrdup(value);
346
refspec->force = fetch->force;
353
struct ref *alloc_ref(unsigned namelen)
355
struct ref *ret = xmalloc(sizeof(struct ref) + namelen);
356
memset(ret, 0, sizeof(struct ref) + namelen);
360
void free_refs(struct ref *ref)
372
static int count_refspec_match(const char *pattern,
374
struct ref **matched_ref)
376
int patlen = strlen(pattern);
377
struct ref *matched_weak = NULL;
378
struct ref *matched = NULL;
382
for (weak_match = match = 0; refs; refs = refs->next) {
383
char *name = refs->name;
384
int namelen = strlen(name);
386
if (namelen < patlen ||
387
memcmp(name + namelen - patlen, pattern, patlen))
389
if (namelen != patlen && name[namelen - patlen - 1] != '/')
392
/* A match is "weak" if it is with refs outside
393
* heads or tags, and did not specify the pattern
394
* in full (e.g. "refs/remotes/origin/master") or at
395
* least from the toplevel (e.g. "remotes/origin/master");
396
* otherwise "git push $URL master" would result in
397
* ambiguity between remotes/origin/master and heads/master
398
* at the remote site.
400
if (namelen != patlen &&
401
patlen != namelen - 5 &&
402
prefixcmp(name, "refs/heads/") &&
403
prefixcmp(name, "refs/tags/")) {
404
/* We want to catch the case where only weak
405
* matches are found and there are multiple
406
* matches, and where more than one strong
407
* matches are found, as ambiguous. One
408
* strong match with zero or more weak matches
409
* are acceptable as a unique match.
420
*matched_ref = matched_weak;
424
*matched_ref = matched;
429
static void tail_link_ref(struct ref *ref, struct ref ***tail)
437
static struct ref *try_explicit_object_name(const char *name)
439
unsigned char sha1[20];
445
strcpy(ref->name, "(delete)");
446
hashclr(ref->new_sha1);
449
if (get_sha1(name, sha1))
451
len = strlen(name) + 1;
452
ref = alloc_ref(len);
453
memcpy(ref->name, name, len);
454
hashcpy(ref->new_sha1, sha1);
458
static struct ref *make_linked_ref(const char *name, struct ref ***tail)
463
len = strlen(name) + 1;
464
ret = alloc_ref(len);
465
memcpy(ret->name, name, len);
466
tail_link_ref(ret, tail);
470
static int match_explicit(struct ref *src, struct ref *dst,
471
struct ref ***dst_tail,
475
struct ref *matched_src, *matched_dst;
477
const char *dst_value = rs->dst;
482
matched_src = matched_dst = NULL;
483
switch (count_refspec_match(rs->src, src, &matched_src)) {
487
/* The source could be in the get_sha1() format
488
* not a reference name. :refs/other is a
489
* way to delete 'other' ref at the remote end.
491
matched_src = try_explicit_object_name(rs->src);
494
error("src refspec %s does not match any.",
499
error("src refspec %s matches more than one.",
507
if (dst_value == NULL)
508
dst_value = matched_src->name;
510
switch (count_refspec_match(dst_value, dst, &matched_dst)) {
514
if (!memcmp(dst_value, "refs/", 5))
515
matched_dst = make_linked_ref(dst_value, dst_tail);
517
error("dst refspec %s does not match any "
518
"existing ref on the remote and does "
519
"not start with refs/.", dst_value);
523
error("dst refspec %s matches more than one.",
527
if (errs || matched_dst == NULL)
529
if (matched_dst->peer_ref) {
531
error("dst ref %s receives from more than one src.",
535
matched_dst->peer_ref = matched_src;
536
matched_dst->force = rs->force;
541
static int match_explicit_refs(struct ref *src, struct ref *dst,
542
struct ref ***dst_tail, struct refspec *rs,
546
for (i = errs = 0; i < rs_nr; i++)
547
errs |= match_explicit(src, dst, dst_tail, &rs[i], errs);
551
static struct ref *find_ref_by_name(struct ref *list, const char *name)
553
for ( ; list; list = list->next)
554
if (!strcmp(list->name, name))
559
static const struct refspec *check_pattern_match(const struct refspec *rs,
561
const struct ref *src)
564
for (i = 0; i < rs_nr; i++) {
565
if (rs[i].pattern && !prefixcmp(src->name, rs[i].src))
572
* Note. This is used only by "push"; refspec matching rules for
573
* push and fetch are subtly different, so do not try to reuse it
576
int match_refs(struct ref *src, struct ref *dst, struct ref ***dst_tail,
577
int nr_refspec, char **refspec, int all)
580
parse_ref_spec(nr_refspec, (const char **) refspec);
582
if (match_explicit_refs(src, dst, dst_tail, rs, nr_refspec))
585
/* pick the remainder */
586
for ( ; src; src = src->next) {
587
struct ref *dst_peer;
588
const struct refspec *pat = NULL;
593
pat = check_pattern_match(rs, nr_refspec, src);
597
else if (prefixcmp(src->name, "refs/heads/"))
599
* "matching refs"; traditionally we pushed everything
600
* including refs outside refs/heads/ hierarchy, but
601
* that does not make much sense these days.
606
const char *dst_side = pat->dst ? pat->dst : pat->src;
607
dst_name = xmalloc(strlen(dst_side) +
609
strlen(pat->src) + 2);
610
strcpy(dst_name, dst_side);
611
strcat(dst_name, src->name + strlen(pat->src));
613
dst_name = xstrdup(src->name);
614
dst_peer = find_ref_by_name(dst, dst_name);
615
if (dst_peer && dst_peer->peer_ref)
616
/* We're already sending something to this ref. */
618
if (!dst_peer && !nr_refspec && !all)
619
/* Remote doesn't have it, and we have no
620
* explicit pattern, and we don't have
624
/* Create a new one and link it */
625
dst_peer = make_linked_ref(dst_name, dst_tail);
626
hashcpy(dst_peer->new_sha1, src->new_sha1);
628
dst_peer->peer_ref = src;