5 static struct remote
**remotes
;
6 static int allocated_remotes
;
8 static struct branch
**branches
;
9 static int allocated_branches
;
11 static struct branch
*current_branch
;
12 static const char *default_remote_name
;
14 #define BUF_SIZE (2048)
15 static char buffer
[BUF_SIZE
];
17 static void add_push_refspec(struct remote
*remote
, const char *ref
)
19 int nr
= remote
->push_refspec_nr
+ 1;
20 remote
->push_refspec
=
21 xrealloc(remote
->push_refspec
, nr
* sizeof(char *));
22 remote
->push_refspec
[nr
-1] = ref
;
23 remote
->push_refspec_nr
= nr
;
26 static void add_fetch_refspec(struct remote
*remote
, const char *ref
)
28 int nr
= remote
->fetch_refspec_nr
+ 1;
29 remote
->fetch_refspec
=
30 xrealloc(remote
->fetch_refspec
, nr
* sizeof(char *));
31 remote
->fetch_refspec
[nr
-1] = ref
;
32 remote
->fetch_refspec_nr
= nr
;
35 static void add_uri(struct remote
*remote
, const char *uri
)
37 int nr
= remote
->uri_nr
+ 1;
39 xrealloc(remote
->uri
, nr
* sizeof(char *));
40 remote
->uri
[nr
-1] = uri
;
44 static struct remote
*make_remote(const char *name
, int len
)
48 for (i
= 0; i
< allocated_remotes
; i
++) {
53 if (len
? (!strncmp(name
, remotes
[i
]->name
, len
) &&
54 !remotes
[i
]->name
[len
]) :
55 !strcmp(name
, remotes
[i
]->name
))
61 empty
= allocated_remotes
;
62 allocated_remotes
+= allocated_remotes
? allocated_remotes
: 1;
63 remotes
= xrealloc(remotes
,
64 sizeof(*remotes
) * allocated_remotes
);
65 memset(remotes
+ empty
, 0,
66 (allocated_remotes
- empty
) * sizeof(*remotes
));
68 remotes
[empty
] = xcalloc(1, sizeof(struct remote
));
70 remotes
[empty
]->name
= xstrndup(name
, len
);
72 remotes
[empty
]->name
= xstrdup(name
);
73 return remotes
[empty
];
76 static void add_merge(struct branch
*branch
, const char *name
)
78 int nr
= branch
->merge_nr
+ 1;
80 xrealloc(branch
->merge_name
, nr
* sizeof(char *));
81 branch
->merge_name
[nr
-1] = name
;
82 branch
->merge_nr
= nr
;
85 static struct branch
*make_branch(const char *name
, int len
)
90 for (i
= 0; i
< allocated_branches
; i
++) {
95 if (len
? (!strncmp(name
, branches
[i
]->name
, len
) &&
96 !branches
[i
]->name
[len
]) :
97 !strcmp(name
, branches
[i
]->name
))
103 empty
= allocated_branches
;
104 allocated_branches
+= allocated_branches
? allocated_branches
: 1;
105 branches
= xrealloc(branches
,
106 sizeof(*branches
) * allocated_branches
);
107 memset(branches
+ empty
, 0,
108 (allocated_branches
- empty
) * sizeof(*branches
));
110 branches
[empty
] = xcalloc(1, sizeof(struct branch
));
112 branches
[empty
]->name
= xstrndup(name
, len
);
114 branches
[empty
]->name
= xstrdup(name
);
115 refname
= malloc(strlen(name
) + strlen("refs/heads/") + 1);
116 strcpy(refname
, "refs/heads/");
117 strcpy(refname
+ strlen("refs/heads/"),
118 branches
[empty
]->name
);
119 branches
[empty
]->refname
= refname
;
121 return branches
[empty
];
124 static void read_remotes_file(struct remote
*remote
)
126 FILE *f
= fopen(git_path("remotes/%s", remote
->name
), "r");
130 while (fgets(buffer
, BUF_SIZE
, f
)) {
134 if (!prefixcmp(buffer
, "URL:")) {
137 } else if (!prefixcmp(buffer
, "Push:")) {
140 } else if (!prefixcmp(buffer
, "Pull:")) {
152 while (isspace(p
[-1]))
155 switch (value_list
) {
157 add_uri(remote
, xstrdup(s
));
160 add_push_refspec(remote
, xstrdup(s
));
163 add_fetch_refspec(remote
, xstrdup(s
));
170 static void read_branches_file(struct remote
*remote
)
172 const char *slash
= strchr(remote
->name
, '/');
175 int n
= slash
? slash
- remote
->name
: 1000;
176 FILE *f
= fopen(git_path("branches/%.*s", n
, remote
->name
), "r");
182 s
= fgets(buffer
, BUF_SIZE
, f
);
191 while (isspace(p
[-1]))
195 len
+= strlen(slash
);
196 p
= xmalloc(len
+ 1);
200 frag
= strchr(p
, '#');
203 branch
= xmalloc(strlen(frag
) + 12);
204 strcpy(branch
, "refs/heads/");
205 strcat(branch
, frag
);
207 branch
= "refs/heads/master";
210 add_fetch_refspec(remote
, branch
);
213 static int handle_config(const char *key
, const char *value
)
217 struct remote
*remote
;
218 struct branch
*branch
;
219 if (!prefixcmp(key
, "branch.")) {
221 subkey
= strrchr(name
, '.');
222 branch
= make_branch(name
, subkey
- name
);
227 if (!strcmp(subkey
, ".remote")) {
228 branch
->remote_name
= xstrdup(value
);
229 if (branch
== current_branch
)
230 default_remote_name
= branch
->remote_name
;
231 } else if (!strcmp(subkey
, ".merge"))
232 add_merge(branch
, xstrdup(value
));
235 if (prefixcmp(key
, "remote."))
238 subkey
= strrchr(name
, '.');
240 return error("Config with no key for remote %s", name
);
241 if (*subkey
== '/') {
242 warning("Config remote shorthand cannot begin with '/': %s", name
);
245 remote
= make_remote(name
, subkey
- name
);
247 /* if we ever have a boolean variable, e.g. "remote.*.disabled"
250 * is a valid way to set it to true; we get NULL in value so
251 * we need to handle it here.
253 * if (!strcmp(subkey, ".disabled")) {
254 * val = git_config_bool(key, value);
259 return 0; /* ignore unknown booleans */
261 if (!strcmp(subkey
, ".url")) {
262 add_uri(remote
, xstrdup(value
));
263 } else if (!strcmp(subkey
, ".push")) {
264 add_push_refspec(remote
, xstrdup(value
));
265 } else if (!strcmp(subkey
, ".fetch")) {
266 add_fetch_refspec(remote
, xstrdup(value
));
267 } else if (!strcmp(subkey
, ".receivepack")) {
268 if (!remote
->receivepack
)
269 remote
->receivepack
= xstrdup(value
);
271 error("more than one receivepack given, using the first");
272 } else if (!strcmp(subkey
, ".uploadpack")) {
273 if (!remote
->uploadpack
)
274 remote
->uploadpack
= xstrdup(value
);
276 error("more than one uploadpack given, using the first");
281 static void read_config(void)
283 unsigned char sha1
[20];
284 const char *head_ref
;
286 if (default_remote_name
) // did this already
288 default_remote_name
= xstrdup("origin");
289 current_branch
= NULL
;
290 head_ref
= resolve_ref("HEAD", sha1
, 0, &flag
);
291 if (head_ref
&& (flag
& REF_ISSYMREF
) &&
292 !prefixcmp(head_ref
, "refs/heads/")) {
294 make_branch(head_ref
+ strlen("refs/heads/"), 0);
296 git_config(handle_config
);
299 static struct refspec
*parse_ref_spec(int nr_refspec
, const char **refspec
)
302 struct refspec
*rs
= xcalloc(sizeof(*rs
), nr_refspec
);
303 for (i
= 0; i
< nr_refspec
; i
++) {
304 const char *sp
, *ep
, *gp
;
310 gp
= strchr(sp
, '*');
311 ep
= strchr(sp
, ':');
312 if (gp
&& ep
&& gp
> ep
)
316 const char *glob
= strchr(ep
+ 1, '*');
320 rs
[i
].dst
= xstrndup(ep
+ 1,
323 rs
[i
].dst
= xstrdup(ep
+ 1);
326 ep
= sp
+ strlen(sp
);
332 rs
[i
].src
= xstrndup(sp
, ep
- sp
);
337 struct remote
*remote_get(const char *name
)
343 name
= default_remote_name
;
344 ret
= make_remote(name
, 0);
345 if (name
[0] != '/') {
347 read_remotes_file(ret
);
349 read_branches_file(ret
);
355 ret
->fetch
= parse_ref_spec(ret
->fetch_refspec_nr
, ret
->fetch_refspec
);
356 ret
->push
= parse_ref_spec(ret
->push_refspec_nr
, ret
->push_refspec
);
360 int for_each_remote(each_remote_fn fn
, void *priv
)
364 for (i
= 0; i
< allocated_remotes
&& !result
; i
++) {
365 struct remote
*r
= remotes
[i
];
369 r
->fetch
= parse_ref_spec(r
->fetch_refspec_nr
,
372 r
->push
= parse_ref_spec(r
->push_refspec_nr
,
374 result
= fn(r
, priv
);
379 int remote_has_uri(struct remote
*remote
, const char *uri
)
382 for (i
= 0; i
< remote
->uri_nr
; i
++) {
383 if (!strcmp(remote
->uri
[i
], uri
))
390 * Returns true if, under the matching rules for fetching, name is the
391 * same as the given full name.
393 static int ref_matches_abbrev(const char *name
, const char *full
)
395 if (!prefixcmp(name
, "refs/") || !strcmp(name
, "HEAD"))
396 return !strcmp(name
, full
);
397 if (prefixcmp(full
, "refs/"))
399 if (!prefixcmp(name
, "heads/") ||
400 !prefixcmp(name
, "tags/") ||
401 !prefixcmp(name
, "remotes/"))
402 return !strcmp(name
, full
+ 5);
403 if (prefixcmp(full
+ 5, "heads/"))
405 return !strcmp(full
+ 11, name
);
408 int remote_find_tracking(struct remote
*remote
, struct refspec
*refspec
)
410 int find_src
= refspec
->src
== NULL
;
411 char *needle
, **result
;
415 if (refspec
->dst
== NULL
)
416 return error("find_tracking: need either src or dst");
417 needle
= refspec
->dst
;
418 result
= &refspec
->src
;
420 needle
= refspec
->src
;
421 result
= &refspec
->dst
;
424 for (i
= 0; i
< remote
->fetch_refspec_nr
; i
++) {
425 struct refspec
*fetch
= &remote
->fetch
[i
];
426 const char *key
= find_src
? fetch
->dst
: fetch
->src
;
427 const char *value
= find_src
? fetch
->src
: fetch
->dst
;
430 if (fetch
->pattern
) {
431 if (!prefixcmp(needle
, key
)) {
432 *result
= xmalloc(strlen(value
) +
435 strcpy(*result
, value
);
436 strcpy(*result
+ strlen(value
),
437 needle
+ strlen(key
));
438 refspec
->force
= fetch
->force
;
441 } else if (!strcmp(needle
, key
)) {
442 *result
= xstrdup(value
);
443 refspec
->force
= fetch
->force
;
450 struct ref
*alloc_ref(unsigned namelen
)
452 struct ref
*ret
= xmalloc(sizeof(struct ref
) + namelen
);
453 memset(ret
, 0, sizeof(struct ref
) + namelen
);
457 void free_refs(struct ref
*ref
)
469 static int count_refspec_match(const char *pattern
,
471 struct ref
**matched_ref
)
473 int patlen
= strlen(pattern
);
474 struct ref
*matched_weak
= NULL
;
475 struct ref
*matched
= NULL
;
479 for (weak_match
= match
= 0; refs
; refs
= refs
->next
) {
480 char *name
= refs
->name
;
481 int namelen
= strlen(name
);
483 if (namelen
< patlen
||
484 memcmp(name
+ namelen
- patlen
, pattern
, patlen
))
486 if (namelen
!= patlen
&& name
[namelen
- patlen
- 1] != '/')
489 /* A match is "weak" if it is with refs outside
490 * heads or tags, and did not specify the pattern
491 * in full (e.g. "refs/remotes/origin/master") or at
492 * least from the toplevel (e.g. "remotes/origin/master");
493 * otherwise "git push $URL master" would result in
494 * ambiguity between remotes/origin/master and heads/master
495 * at the remote site.
497 if (namelen
!= patlen
&&
498 patlen
!= namelen
- 5 &&
499 prefixcmp(name
, "refs/heads/") &&
500 prefixcmp(name
, "refs/tags/")) {
501 /* We want to catch the case where only weak
502 * matches are found and there are multiple
503 * matches, and where more than one strong
504 * matches are found, as ambiguous. One
505 * strong match with zero or more weak matches
506 * are acceptable as a unique match.
517 *matched_ref
= matched_weak
;
521 *matched_ref
= matched
;
526 static void tail_link_ref(struct ref
*ref
, struct ref
***tail
)
534 static struct ref
*try_explicit_object_name(const char *name
)
536 unsigned char sha1
[20];
542 strcpy(ref
->name
, "(delete)");
543 hashclr(ref
->new_sha1
);
546 if (get_sha1(name
, sha1
))
548 len
= strlen(name
) + 1;
549 ref
= alloc_ref(len
);
550 memcpy(ref
->name
, name
, len
);
551 hashcpy(ref
->new_sha1
, sha1
);
555 static struct ref
*make_linked_ref(const char *name
, struct ref
***tail
)
560 len
= strlen(name
) + 1;
561 ret
= alloc_ref(len
);
562 memcpy(ret
->name
, name
, len
);
563 tail_link_ref(ret
, tail
);
567 static int match_explicit(struct ref
*src
, struct ref
*dst
,
568 struct ref
***dst_tail
,
572 struct ref
*matched_src
, *matched_dst
;
574 const char *dst_value
= rs
->dst
;
579 matched_src
= matched_dst
= NULL
;
580 switch (count_refspec_match(rs
->src
, src
, &matched_src
)) {
584 /* The source could be in the get_sha1() format
585 * not a reference name. :refs/other is a
586 * way to delete 'other' ref at the remote end.
588 matched_src
= try_explicit_object_name(rs
->src
);
591 error("src refspec %s does not match any.",
596 error("src refspec %s matches more than one.",
604 if (dst_value
== NULL
)
605 dst_value
= matched_src
->name
;
607 switch (count_refspec_match(dst_value
, dst
, &matched_dst
)) {
611 if (!memcmp(dst_value
, "refs/", 5))
612 matched_dst
= make_linked_ref(dst_value
, dst_tail
);
614 error("dst refspec %s does not match any "
615 "existing ref on the remote and does "
616 "not start with refs/.", dst_value
);
620 error("dst refspec %s matches more than one.",
624 if (errs
|| matched_dst
== NULL
)
626 if (matched_dst
->peer_ref
) {
628 error("dst ref %s receives from more than one src.",
632 matched_dst
->peer_ref
= matched_src
;
633 matched_dst
->force
= rs
->force
;
638 static int match_explicit_refs(struct ref
*src
, struct ref
*dst
,
639 struct ref
***dst_tail
, struct refspec
*rs
,
643 for (i
= errs
= 0; i
< rs_nr
; i
++)
644 errs
|= match_explicit(src
, dst
, dst_tail
, &rs
[i
], errs
);
648 static struct ref
*find_ref_by_name(struct ref
*list
, const char *name
)
650 for ( ; list
; list
= list
->next
)
651 if (!strcmp(list
->name
, name
))
656 static const struct refspec
*check_pattern_match(const struct refspec
*rs
,
658 const struct ref
*src
)
661 for (i
= 0; i
< rs_nr
; i
++) {
662 if (rs
[i
].pattern
&& !prefixcmp(src
->name
, rs
[i
].src
))
669 * Note. This is used only by "push"; refspec matching rules for
670 * push and fetch are subtly different, so do not try to reuse it
673 int match_refs(struct ref
*src
, struct ref
*dst
, struct ref
***dst_tail
,
674 int nr_refspec
, char **refspec
, int all
)
677 parse_ref_spec(nr_refspec
, (const char **) refspec
);
679 if (match_explicit_refs(src
, dst
, dst_tail
, rs
, nr_refspec
))
682 /* pick the remainder */
683 for ( ; src
; src
= src
->next
) {
684 struct ref
*dst_peer
;
685 const struct refspec
*pat
= NULL
;
690 pat
= check_pattern_match(rs
, nr_refspec
, src
);
694 else if (prefixcmp(src
->name
, "refs/heads/"))
696 * "matching refs"; traditionally we pushed everything
697 * including refs outside refs/heads/ hierarchy, but
698 * that does not make much sense these days.
703 const char *dst_side
= pat
->dst
? pat
->dst
: pat
->src
;
704 dst_name
= xmalloc(strlen(dst_side
) +
706 strlen(pat
->src
) + 2);
707 strcpy(dst_name
, dst_side
);
708 strcat(dst_name
, src
->name
+ strlen(pat
->src
));
710 dst_name
= xstrdup(src
->name
);
711 dst_peer
= find_ref_by_name(dst
, dst_name
);
712 if (dst_peer
&& dst_peer
->peer_ref
)
713 /* We're already sending something to this ref. */
715 if (!dst_peer
&& !nr_refspec
&& !all
)
716 /* Remote doesn't have it, and we have no
717 * explicit pattern, and we don't have
721 /* Create a new one and link it */
722 dst_peer
= make_linked_ref(dst_name
, dst_tail
);
723 hashcpy(dst_peer
->new_sha1
, src
->new_sha1
);
725 dst_peer
->peer_ref
= src
;
732 struct branch
*branch_get(const char *name
)
737 if (!name
|| !*name
|| !strcmp(name
, "HEAD"))
738 ret
= current_branch
;
740 ret
= make_branch(name
, 0);
741 if (ret
&& ret
->remote_name
) {
742 ret
->remote
= remote_get(ret
->remote_name
);
745 ret
->merge
= xcalloc(sizeof(*ret
->merge
),
747 for (i
= 0; i
< ret
->merge_nr
; i
++) {
748 ret
->merge
[i
] = xcalloc(1, sizeof(**ret
->merge
));
749 ret
->merge
[i
]->src
= xstrdup(ret
->merge_name
[i
]);
750 remote_find_tracking(ret
->remote
,
758 int branch_has_merge_config(struct branch
*branch
)
760 return branch
&& !!branch
->merge
;
763 int branch_merges(struct branch
*branch
, const char *refname
)
768 for (i
= 0; i
< branch
->merge_nr
; i
++) {
769 if (ref_matches_abbrev(branch
->merge
[i
]->src
, refname
))