5 #include "object-store.h"
11 #include "string-list.h"
12 #include "mergesort.h"
13 #include "argv-array.h"
15 enum map_direction
{ FROM_SRC
, FROM_DST
};
17 static struct refspec s_tag_refspec
= {
26 /* See TAG_REFSPEC for the string version */
27 const struct refspec
*tag_refspec
= &s_tag_refspec
;
29 struct counted_string
{
36 struct counted_string
*instead_of
;
41 struct rewrite
**rewrite
;
46 static struct remote
**remotes
;
47 static int remotes_alloc
;
48 static int remotes_nr
;
49 static struct hashmap remotes_hash
;
51 static struct branch
**branches
;
52 static int branches_alloc
;
53 static int branches_nr
;
55 static struct branch
*current_branch
;
56 static const char *pushremote_name
;
58 static struct rewrites rewrites
;
59 static struct rewrites rewrites_push
;
61 static int valid_remote(const struct remote
*remote
)
63 return (!!remote
->url
) || (!!remote
->foreign_vcs
);
66 static const char *alias_url(const char *url
, struct rewrites
*r
)
69 struct counted_string
*longest
;
74 for (i
= 0; i
< r
->rewrite_nr
; i
++) {
77 for (j
= 0; j
< r
->rewrite
[i
]->instead_of_nr
; j
++) {
78 if (starts_with(url
, r
->rewrite
[i
]->instead_of
[j
].s
) &&
80 longest
->len
< r
->rewrite
[i
]->instead_of
[j
].len
)) {
81 longest
= &(r
->rewrite
[i
]->instead_of
[j
]);
89 return xstrfmt("%s%s", r
->rewrite
[longest_i
]->base
, url
+ longest
->len
);
92 static void add_push_refspec(struct remote
*remote
, const char *ref
)
94 ALLOC_GROW(remote
->push_refspec
,
95 remote
->push_refspec_nr
+ 1,
96 remote
->push_refspec_alloc
);
97 remote
->push_refspec
[remote
->push_refspec_nr
++] = ref
;
100 static void add_fetch_refspec(struct remote
*remote
, const char *ref
)
102 ALLOC_GROW(remote
->fetch_refspec
,
103 remote
->fetch_refspec_nr
+ 1,
104 remote
->fetch_refspec_alloc
);
105 remote
->fetch_refspec
[remote
->fetch_refspec_nr
++] = ref
;
108 void add_prune_tags_to_fetch_refspec(struct remote
*remote
)
110 int nr
= remote
->fetch_refspec_nr
;
111 int bufsize
= nr
+ 1;
112 int size
= sizeof(struct refspec
);
114 remote
->fetch
= xrealloc(remote
->fetch
, size
* bufsize
);
115 memcpy(&remote
->fetch
[nr
], tag_refspec
, size
);
116 add_fetch_refspec(remote
, xstrdup(TAG_REFSPEC
));
119 static void add_url(struct remote
*remote
, const char *url
)
121 ALLOC_GROW(remote
->url
, remote
->url_nr
+ 1, remote
->url_alloc
);
122 remote
->url
[remote
->url_nr
++] = url
;
125 static void add_pushurl(struct remote
*remote
, const char *pushurl
)
127 ALLOC_GROW(remote
->pushurl
, remote
->pushurl_nr
+ 1, remote
->pushurl_alloc
);
128 remote
->pushurl
[remote
->pushurl_nr
++] = pushurl
;
131 static void add_pushurl_alias(struct remote
*remote
, const char *url
)
133 const char *pushurl
= alias_url(url
, &rewrites_push
);
135 add_pushurl(remote
, pushurl
);
138 static void add_url_alias(struct remote
*remote
, const char *url
)
140 add_url(remote
, alias_url(url
, &rewrites
));
141 add_pushurl_alias(remote
, url
);
144 struct remotes_hash_key
{
149 static int remotes_hash_cmp(const void *unused_cmp_data
,
151 const void *entry_or_key
,
154 const struct remote
*a
= entry
;
155 const struct remote
*b
= entry_or_key
;
156 const struct remotes_hash_key
*key
= keydata
;
159 return strncmp(a
->name
, key
->str
, key
->len
) || a
->name
[key
->len
];
161 return strcmp(a
->name
, b
->name
);
164 static inline void init_remotes_hash(void)
166 if (!remotes_hash
.cmpfn
)
167 hashmap_init(&remotes_hash
, remotes_hash_cmp
, NULL
, 0);
170 static struct remote
*make_remote(const char *name
, int len
)
172 struct remote
*ret
, *replaced
;
173 struct remotes_hash_key lookup
;
174 struct hashmap_entry lookup_entry
;
182 hashmap_entry_init(&lookup_entry
, memhash(name
, len
));
184 if ((ret
= hashmap_get(&remotes_hash
, &lookup_entry
, &lookup
)) != NULL
)
187 ret
= xcalloc(1, sizeof(struct remote
));
188 ret
->prune
= -1; /* unspecified */
189 ret
->prune_tags
= -1; /* unspecified */
190 ALLOC_GROW(remotes
, remotes_nr
+ 1, remotes_alloc
);
191 remotes
[remotes_nr
++] = ret
;
192 ret
->name
= xstrndup(name
, len
);
194 hashmap_entry_init(ret
, lookup_entry
.hash
);
195 replaced
= hashmap_put(&remotes_hash
, ret
);
196 assert(replaced
== NULL
); /* no previous entry overwritten */
200 static void add_merge(struct branch
*branch
, const char *name
)
202 ALLOC_GROW(branch
->merge_name
, branch
->merge_nr
+ 1,
203 branch
->merge_alloc
);
204 branch
->merge_name
[branch
->merge_nr
++] = name
;
207 static struct branch
*make_branch(const char *name
, int len
)
212 for (i
= 0; i
< branches_nr
; i
++) {
213 if (len
? (!strncmp(name
, branches
[i
]->name
, len
) &&
214 !branches
[i
]->name
[len
]) :
215 !strcmp(name
, branches
[i
]->name
))
219 ALLOC_GROW(branches
, branches_nr
+ 1, branches_alloc
);
220 ret
= xcalloc(1, sizeof(struct branch
));
221 branches
[branches_nr
++] = ret
;
223 ret
->name
= xstrndup(name
, len
);
225 ret
->name
= xstrdup(name
);
226 ret
->refname
= xstrfmt("refs/heads/%s", ret
->name
);
231 static struct rewrite
*make_rewrite(struct rewrites
*r
, const char *base
, int len
)
236 for (i
= 0; i
< r
->rewrite_nr
; i
++) {
238 ? (len
== r
->rewrite
[i
]->baselen
&&
239 !strncmp(base
, r
->rewrite
[i
]->base
, len
))
240 : !strcmp(base
, r
->rewrite
[i
]->base
))
241 return r
->rewrite
[i
];
244 ALLOC_GROW(r
->rewrite
, r
->rewrite_nr
+ 1, r
->rewrite_alloc
);
245 ret
= xcalloc(1, sizeof(struct rewrite
));
246 r
->rewrite
[r
->rewrite_nr
++] = ret
;
248 ret
->base
= xstrndup(base
, len
);
252 ret
->base
= xstrdup(base
);
253 ret
->baselen
= strlen(base
);
258 static void add_instead_of(struct rewrite
*rewrite
, const char *instead_of
)
260 ALLOC_GROW(rewrite
->instead_of
, rewrite
->instead_of_nr
+ 1, rewrite
->instead_of_alloc
);
261 rewrite
->instead_of
[rewrite
->instead_of_nr
].s
= instead_of
;
262 rewrite
->instead_of
[rewrite
->instead_of_nr
].len
= strlen(instead_of
);
263 rewrite
->instead_of_nr
++;
266 static const char *skip_spaces(const char *s
)
273 static void read_remotes_file(struct remote
*remote
)
275 struct strbuf buf
= STRBUF_INIT
;
276 FILE *f
= fopen_or_warn(git_path("remotes/%s", remote
->name
), "r");
280 remote
->configured_in_repo
= 1;
281 remote
->origin
= REMOTE_REMOTES
;
282 while (strbuf_getline(&buf
, f
) != EOF
) {
287 if (skip_prefix(buf
.buf
, "URL:", &v
))
288 add_url_alias(remote
, xstrdup(skip_spaces(v
)));
289 else if (skip_prefix(buf
.buf
, "Push:", &v
))
290 add_push_refspec(remote
, xstrdup(skip_spaces(v
)));
291 else if (skip_prefix(buf
.buf
, "Pull:", &v
))
292 add_fetch_refspec(remote
, xstrdup(skip_spaces(v
)));
294 strbuf_release(&buf
);
298 static void read_branches_file(struct remote
*remote
)
301 struct strbuf buf
= STRBUF_INIT
;
302 FILE *f
= fopen_or_warn(git_path("branches/%s", remote
->name
), "r");
307 strbuf_getline_lf(&buf
, f
);
311 strbuf_release(&buf
);
315 remote
->configured_in_repo
= 1;
316 remote
->origin
= REMOTE_BRANCHES
;
319 * The branches file would have URL and optionally
320 * #branch specified. The "master" (or specified) branch is
321 * fetched and stored in the local branch matching the
324 frag
= strchr(buf
.buf
, '#');
330 add_url_alias(remote
, strbuf_detach(&buf
, NULL
));
331 add_fetch_refspec(remote
, xstrfmt("refs/heads/%s:refs/heads/%s",
332 frag
, remote
->name
));
335 * Cogito compatible push: push current HEAD to remote #branch
336 * (master if missing)
338 add_push_refspec(remote
, xstrfmt("HEAD:refs/heads/%s", frag
));
339 remote
->fetch_tags
= 1; /* always auto-follow */
342 static int handle_config(const char *key
, const char *value
, void *cb
)
347 struct remote
*remote
;
348 struct branch
*branch
;
349 if (parse_config_key(key
, "branch", &name
, &namelen
, &subkey
) >= 0) {
352 branch
= make_branch(name
, namelen
);
353 if (!strcmp(subkey
, "remote")) {
354 return git_config_string(&branch
->remote_name
, key
, value
);
355 } else if (!strcmp(subkey
, "pushremote")) {
356 return git_config_string(&branch
->pushremote_name
, key
, value
);
357 } else if (!strcmp(subkey
, "merge")) {
359 return config_error_nonbool(key
);
360 add_merge(branch
, xstrdup(value
));
364 if (parse_config_key(key
, "url", &name
, &namelen
, &subkey
) >= 0) {
365 struct rewrite
*rewrite
;
368 if (!strcmp(subkey
, "insteadof")) {
369 rewrite
= make_rewrite(&rewrites
, name
, namelen
);
371 return config_error_nonbool(key
);
372 add_instead_of(rewrite
, xstrdup(value
));
373 } else if (!strcmp(subkey
, "pushinsteadof")) {
374 rewrite
= make_rewrite(&rewrites_push
, name
, namelen
);
376 return config_error_nonbool(key
);
377 add_instead_of(rewrite
, xstrdup(value
));
381 if (parse_config_key(key
, "remote", &name
, &namelen
, &subkey
) < 0)
384 /* Handle remote.* variables */
385 if (!name
&& !strcmp(subkey
, "pushdefault"))
386 return git_config_string(&pushremote_name
, key
, value
);
390 /* Handle remote.<name>.* variables */
392 warning("Config remote shorthand cannot begin with '/': %s",
396 remote
= make_remote(name
, namelen
);
397 remote
->origin
= REMOTE_CONFIG
;
398 if (current_config_scope() == CONFIG_SCOPE_REPO
)
399 remote
->configured_in_repo
= 1;
400 if (!strcmp(subkey
, "mirror"))
401 remote
->mirror
= git_config_bool(key
, value
);
402 else if (!strcmp(subkey
, "skipdefaultupdate"))
403 remote
->skip_default_update
= git_config_bool(key
, value
);
404 else if (!strcmp(subkey
, "skipfetchall"))
405 remote
->skip_default_update
= git_config_bool(key
, value
);
406 else if (!strcmp(subkey
, "prune"))
407 remote
->prune
= git_config_bool(key
, value
);
408 else if (!strcmp(subkey
, "prunetags"))
409 remote
->prune_tags
= git_config_bool(key
, value
);
410 else if (!strcmp(subkey
, "url")) {
412 if (git_config_string(&v
, key
, value
))
415 } else if (!strcmp(subkey
, "pushurl")) {
417 if (git_config_string(&v
, key
, value
))
419 add_pushurl(remote
, v
);
420 } else if (!strcmp(subkey
, "push")) {
422 if (git_config_string(&v
, key
, value
))
424 add_push_refspec(remote
, v
);
425 } else if (!strcmp(subkey
, "fetch")) {
427 if (git_config_string(&v
, key
, value
))
429 add_fetch_refspec(remote
, v
);
430 } else if (!strcmp(subkey
, "receivepack")) {
432 if (git_config_string(&v
, key
, value
))
434 if (!remote
->receivepack
)
435 remote
->receivepack
= v
;
437 error("more than one receivepack given, using the first");
438 } else if (!strcmp(subkey
, "uploadpack")) {
440 if (git_config_string(&v
, key
, value
))
442 if (!remote
->uploadpack
)
443 remote
->uploadpack
= v
;
445 error("more than one uploadpack given, using the first");
446 } else if (!strcmp(subkey
, "tagopt")) {
447 if (!strcmp(value
, "--no-tags"))
448 remote
->fetch_tags
= -1;
449 else if (!strcmp(value
, "--tags"))
450 remote
->fetch_tags
= 2;
451 } else if (!strcmp(subkey
, "proxy")) {
452 return git_config_string((const char **)&remote
->http_proxy
,
454 } else if (!strcmp(subkey
, "proxyauthmethod")) {
455 return git_config_string((const char **)&remote
->http_proxy_authmethod
,
457 } else if (!strcmp(subkey
, "vcs")) {
458 return git_config_string(&remote
->foreign_vcs
, key
, value
);
463 static void alias_all_urls(void)
466 for (i
= 0; i
< remotes_nr
; i
++) {
467 int add_pushurl_aliases
;
470 for (j
= 0; j
< remotes
[i
]->pushurl_nr
; j
++) {
471 remotes
[i
]->pushurl
[j
] = alias_url(remotes
[i
]->pushurl
[j
], &rewrites
);
473 add_pushurl_aliases
= remotes
[i
]->pushurl_nr
== 0;
474 for (j
= 0; j
< remotes
[i
]->url_nr
; j
++) {
475 if (add_pushurl_aliases
)
476 add_pushurl_alias(remotes
[i
], remotes
[i
]->url
[j
]);
477 remotes
[i
]->url
[j
] = alias_url(remotes
[i
]->url
[j
], &rewrites
);
482 static void read_config(void)
491 current_branch
= NULL
;
492 if (startup_info
->have_repository
) {
493 const char *head_ref
= resolve_ref_unsafe("HEAD", 0, NULL
, &flag
);
494 if (head_ref
&& (flag
& REF_ISSYMREF
) &&
495 skip_prefix(head_ref
, "refs/heads/", &head_ref
)) {
496 current_branch
= make_branch(head_ref
, 0);
499 git_config(handle_config
, NULL
);
503 static struct refspec
*parse_refspec_internal(int nr_refspec
, const char **refspec
, int fetch
, int verify
)
506 struct refspec
*rs
= xcalloc(nr_refspec
, sizeof(*rs
));
508 for (i
= 0; i
< nr_refspec
; i
++) {
511 const char *lhs
, *rhs
;
522 rhs
= strrchr(lhs
, ':');
525 * Before going on, special case ":" (or "+:") as a refspec
526 * for pushing matching refs.
528 if (!fetch
&& rhs
== lhs
&& rhs
[1] == '\0') {
534 size_t rlen
= strlen(++rhs
);
535 is_glob
= (1 <= rlen
&& strchr(rhs
, '*'));
536 rs
[i
].dst
= xstrndup(rhs
, rlen
);
539 llen
= (rhs
? (rhs
- lhs
- 1) : strlen(lhs
));
540 if (1 <= llen
&& memchr(lhs
, '*', llen
)) {
541 if ((rhs
&& !is_glob
) || (!rhs
&& fetch
))
544 } else if (rhs
&& is_glob
) {
548 rs
[i
].pattern
= is_glob
;
549 rs
[i
].src
= xstrndup(lhs
, llen
);
550 flags
= REFNAME_ALLOW_ONELEVEL
| (is_glob
? REFNAME_REFSPEC_PATTERN
: 0);
553 struct object_id unused
;
557 ; /* empty is ok; it means "HEAD" */
558 else if (llen
== GIT_SHA1_HEXSZ
&& !get_oid_hex(rs
[i
].src
, &unused
))
559 rs
[i
].exact_sha1
= 1; /* ok */
560 else if (!check_refname_format(rs
[i
].src
, flags
))
561 ; /* valid looking ref is ok */
566 ; /* missing is ok; it is the same as empty */
567 else if (!*rs
[i
].dst
)
568 ; /* empty is ok; it means "do not store" */
569 else if (!check_refname_format(rs
[i
].dst
, flags
))
570 ; /* valid looking ref is ok */
576 * - empty is allowed; it means delete.
577 * - when wildcarded, it must be a valid looking ref.
578 * - otherwise, it must be an extended SHA-1, but
579 * there is no existing way to validate this.
584 if (check_refname_format(rs
[i
].src
, flags
))
588 ; /* anything goes, for now */
591 * - missing is allowed, but LHS then must be a
593 * - empty is not allowed.
594 * - otherwise it must be a valid looking ref.
597 if (check_refname_format(rs
[i
].src
, flags
))
599 } else if (!*rs
[i
].dst
) {
602 if (check_refname_format(rs
[i
].dst
, flags
))
612 * nr_refspec must be greater than zero and i must be valid
613 * since it is only possible to reach this point from within
614 * the for loop above.
616 free_refspec(i
+1, rs
);
619 die("Invalid refspec '%s'", refspec
[i
]);
622 int valid_fetch_refspec(const char *fetch_refspec_str
)
624 struct refspec
*refspec
;
626 refspec
= parse_refspec_internal(1, &fetch_refspec_str
, 1, 1);
627 free_refspec(1, refspec
);
631 struct refspec
*parse_fetch_refspec(int nr_refspec
, const char **refspec
)
633 return parse_refspec_internal(nr_refspec
, refspec
, 1, 0);
636 struct refspec
*parse_push_refspec(int nr_refspec
, const char **refspec
)
638 return parse_refspec_internal(nr_refspec
, refspec
, 0, 0);
641 void free_refspec(int nr_refspec
, struct refspec
*refspec
)
648 for (i
= 0; i
< nr_refspec
; i
++) {
649 free(refspec
[i
].src
);
650 free(refspec
[i
].dst
);
655 static int valid_remote_nick(const char *name
)
657 if (!name
[0] || is_dot_or_dotdot(name
))
660 /* remote nicknames cannot contain slashes */
662 if (is_dir_sep(*name
++))
667 const char *remote_for_branch(struct branch
*branch
, int *explicit)
669 if (branch
&& branch
->remote_name
) {
672 return branch
->remote_name
;
679 const char *pushremote_for_branch(struct branch
*branch
, int *explicit)
681 if (branch
&& branch
->pushremote_name
) {
684 return branch
->pushremote_name
;
686 if (pushremote_name
) {
689 return pushremote_name
;
691 return remote_for_branch(branch
, explicit);
694 const char *remote_ref_for_branch(struct branch
*branch
, int for_push
,
699 if (branch
->merge_nr
) {
702 return branch
->merge_name
[0];
705 const char *dst
, *remote_name
=
706 pushremote_for_branch(branch
, NULL
);
707 struct remote
*remote
= remote_get(remote_name
);
709 if (remote
&& remote
->push_refspec_nr
&&
710 (dst
= apply_refspecs(remote
->push
,
711 remote
->push_refspec_nr
,
724 static struct remote
*remote_get_1(const char *name
,
725 const char *(*get_default
)(struct branch
*, int *))
735 name
= get_default(current_branch
, &name_given
);
737 ret
= make_remote(name
, 0);
738 if (valid_remote_nick(name
) && have_git_dir()) {
739 if (!valid_remote(ret
))
740 read_remotes_file(ret
);
741 if (!valid_remote(ret
))
742 read_branches_file(ret
);
744 if (name_given
&& !valid_remote(ret
))
745 add_url_alias(ret
, name
);
746 if (!valid_remote(ret
))
748 ret
->fetch
= parse_fetch_refspec(ret
->fetch_refspec_nr
, ret
->fetch_refspec
);
749 ret
->push
= parse_push_refspec(ret
->push_refspec_nr
, ret
->push_refspec
);
753 struct remote
*remote_get(const char *name
)
755 return remote_get_1(name
, remote_for_branch
);
758 struct remote
*pushremote_get(const char *name
)
760 return remote_get_1(name
, pushremote_for_branch
);
763 int remote_is_configured(struct remote
*remote
, int in_repo
)
768 return remote
->configured_in_repo
;
769 return !!remote
->origin
;
772 int for_each_remote(each_remote_fn fn
, void *priv
)
776 for (i
= 0; i
< remotes_nr
&& !result
; i
++) {
777 struct remote
*r
= remotes
[i
];
781 r
->fetch
= parse_fetch_refspec(r
->fetch_refspec_nr
,
784 r
->push
= parse_push_refspec(r
->push_refspec_nr
,
786 result
= fn(r
, priv
);
791 static void handle_duplicate(struct ref
*ref1
, struct ref
*ref2
)
793 if (strcmp(ref1
->name
, ref2
->name
)) {
794 if (ref1
->fetch_head_status
!= FETCH_HEAD_IGNORE
&&
795 ref2
->fetch_head_status
!= FETCH_HEAD_IGNORE
) {
796 die(_("Cannot fetch both %s and %s to %s"),
797 ref1
->name
, ref2
->name
, ref2
->peer_ref
->name
);
798 } else if (ref1
->fetch_head_status
!= FETCH_HEAD_IGNORE
&&
799 ref2
->fetch_head_status
== FETCH_HEAD_IGNORE
) {
800 warning(_("%s usually tracks %s, not %s"),
801 ref2
->peer_ref
->name
, ref2
->name
, ref1
->name
);
802 } else if (ref1
->fetch_head_status
== FETCH_HEAD_IGNORE
&&
803 ref2
->fetch_head_status
== FETCH_HEAD_IGNORE
) {
804 die(_("%s tracks both %s and %s"),
805 ref2
->peer_ref
->name
, ref1
->name
, ref2
->name
);
808 * This last possibility doesn't occur because
809 * FETCH_HEAD_IGNORE entries always appear at
810 * the end of the list.
812 die(_("Internal error"));
815 free(ref2
->peer_ref
);
819 struct ref
*ref_remove_duplicates(struct ref
*ref_map
)
821 struct string_list refs
= STRING_LIST_INIT_NODUP
;
822 struct ref
*retval
= NULL
;
823 struct ref
**p
= &retval
;
826 struct ref
*ref
= ref_map
;
828 ref_map
= ref_map
->next
;
831 if (!ref
->peer_ref
) {
835 struct string_list_item
*item
=
836 string_list_insert(&refs
, ref
->peer_ref
->name
);
839 /* Entry already existed */
840 handle_duplicate((struct ref
*)item
->util
, ref
);
849 string_list_clear(&refs
, 0);
853 int remote_has_url(struct remote
*remote
, const char *url
)
856 for (i
= 0; i
< remote
->url_nr
; i
++) {
857 if (!strcmp(remote
->url
[i
], url
))
863 static int match_name_with_pattern(const char *key
, const char *name
,
864 const char *value
, char **result
)
866 const char *kstar
= strchr(key
, '*');
872 die("Key '%s' of pattern had no '*'", key
);
874 ksuffixlen
= strlen(kstar
+ 1);
875 namelen
= strlen(name
);
876 ret
= !strncmp(name
, key
, klen
) && namelen
>= klen
+ ksuffixlen
&&
877 !memcmp(name
+ namelen
- ksuffixlen
, kstar
+ 1, ksuffixlen
);
879 struct strbuf sb
= STRBUF_INIT
;
880 const char *vstar
= strchr(value
, '*');
882 die("Value '%s' of pattern has no '*'", value
);
883 strbuf_add(&sb
, value
, vstar
- value
);
884 strbuf_add(&sb
, name
+ klen
, namelen
- klen
- ksuffixlen
);
885 strbuf_addstr(&sb
, vstar
+ 1);
886 *result
= strbuf_detach(&sb
, NULL
);
891 static void query_refspecs_multiple(struct refspec
*refs
, int ref_count
, struct refspec
*query
, struct string_list
*results
)
894 int find_src
= !query
->src
;
896 if (find_src
&& !query
->dst
)
897 error("query_refspecs_multiple: need either src or dst");
899 for (i
= 0; i
< ref_count
; i
++) {
900 struct refspec
*refspec
= &refs
[i
];
901 const char *key
= find_src
? refspec
->dst
: refspec
->src
;
902 const char *value
= find_src
? refspec
->src
: refspec
->dst
;
903 const char *needle
= find_src
? query
->dst
: query
->src
;
904 char **result
= find_src
? &query
->src
: &query
->dst
;
908 if (refspec
->pattern
) {
909 if (match_name_with_pattern(key
, needle
, value
, result
))
910 string_list_append_nodup(results
, *result
);
911 } else if (!strcmp(needle
, key
)) {
912 string_list_append(results
, value
);
917 int query_refspecs(struct refspec
*refs
, int ref_count
, struct refspec
*query
)
920 int find_src
= !query
->src
;
921 const char *needle
= find_src
? query
->dst
: query
->src
;
922 char **result
= find_src
? &query
->src
: &query
->dst
;
924 if (find_src
&& !query
->dst
)
925 return error("query_refspecs: need either src or dst");
927 for (i
= 0; i
< ref_count
; i
++) {
928 struct refspec
*refspec
= &refs
[i
];
929 const char *key
= find_src
? refspec
->dst
: refspec
->src
;
930 const char *value
= find_src
? refspec
->src
: refspec
->dst
;
934 if (refspec
->pattern
) {
935 if (match_name_with_pattern(key
, needle
, value
, result
)) {
936 query
->force
= refspec
->force
;
939 } else if (!strcmp(needle
, key
)) {
940 *result
= xstrdup(value
);
941 query
->force
= refspec
->force
;
948 char *apply_refspecs(struct refspec
*refspecs
, int nr_refspec
,
951 struct refspec query
;
953 memset(&query
, 0, sizeof(struct refspec
));
954 query
.src
= (char *)name
;
956 if (query_refspecs(refspecs
, nr_refspec
, &query
))
962 int remote_find_tracking(struct remote
*remote
, struct refspec
*refspec
)
964 return query_refspecs(remote
->fetch
, remote
->fetch_refspec_nr
, refspec
);
967 static struct ref
*alloc_ref_with_prefix(const char *prefix
, size_t prefixlen
,
970 size_t len
= strlen(name
);
971 struct ref
*ref
= xcalloc(1, st_add4(sizeof(*ref
), prefixlen
, len
, 1));
972 memcpy(ref
->name
, prefix
, prefixlen
);
973 memcpy(ref
->name
+ prefixlen
, name
, len
);
977 struct ref
*alloc_ref(const char *name
)
979 return alloc_ref_with_prefix("", 0, name
);
982 struct ref
*copy_ref(const struct ref
*ref
)
988 len
= st_add3(sizeof(struct ref
), strlen(ref
->name
), 1);
990 memcpy(cpy
, ref
, len
);
992 cpy
->symref
= xstrdup_or_null(ref
->symref
);
993 cpy
->remote_status
= xstrdup_or_null(ref
->remote_status
);
994 cpy
->peer_ref
= copy_ref(ref
->peer_ref
);
998 struct ref
*copy_ref_list(const struct ref
*ref
)
1000 struct ref
*ret
= NULL
;
1001 struct ref
**tail
= &ret
;
1003 *tail
= copy_ref(ref
);
1005 tail
= &((*tail
)->next
);
1010 static void free_ref(struct ref
*ref
)
1014 free_ref(ref
->peer_ref
);
1015 free(ref
->remote_status
);
1020 void free_refs(struct ref
*ref
)
1030 int ref_compare_name(const void *va
, const void *vb
)
1032 const struct ref
*a
= va
, *b
= vb
;
1033 return strcmp(a
->name
, b
->name
);
1036 static void *ref_list_get_next(const void *a
)
1038 return ((const struct ref
*)a
)->next
;
1041 static void ref_list_set_next(void *a
, void *next
)
1043 ((struct ref
*)a
)->next
= next
;
1046 void sort_ref_list(struct ref
**l
, int (*cmp
)(const void *, const void *))
1048 *l
= llist_mergesort(*l
, ref_list_get_next
, ref_list_set_next
, cmp
);
1051 int count_refspec_match(const char *pattern
,
1053 struct ref
**matched_ref
)
1055 int patlen
= strlen(pattern
);
1056 struct ref
*matched_weak
= NULL
;
1057 struct ref
*matched
= NULL
;
1061 for (weak_match
= match
= 0; refs
; refs
= refs
->next
) {
1062 char *name
= refs
->name
;
1063 int namelen
= strlen(name
);
1065 if (!refname_match(pattern
, name
))
1068 /* A match is "weak" if it is with refs outside
1069 * heads or tags, and did not specify the pattern
1070 * in full (e.g. "refs/remotes/origin/master") or at
1071 * least from the toplevel (e.g. "remotes/origin/master");
1072 * otherwise "git push $URL master" would result in
1073 * ambiguity between remotes/origin/master and heads/master
1074 * at the remote site.
1076 if (namelen
!= patlen
&&
1077 patlen
!= namelen
- 5 &&
1078 !starts_with(name
, "refs/heads/") &&
1079 !starts_with(name
, "refs/tags/")) {
1080 /* We want to catch the case where only weak
1081 * matches are found and there are multiple
1082 * matches, and where more than one strong
1083 * matches are found, as ambiguous. One
1084 * strong match with zero or more weak matches
1085 * are acceptable as a unique match.
1087 matched_weak
= refs
;
1097 *matched_ref
= matched_weak
;
1102 *matched_ref
= matched
;
1107 static void tail_link_ref(struct ref
*ref
, struct ref
***tail
)
1115 static struct ref
*alloc_delete_ref(void)
1117 struct ref
*ref
= alloc_ref("(delete)");
1118 oidclr(&ref
->new_oid
);
1122 static int try_explicit_object_name(const char *name
,
1125 struct object_id oid
;
1129 *match
= alloc_delete_ref();
1133 if (get_oid(name
, &oid
))
1137 *match
= alloc_ref(name
);
1138 oidcpy(&(*match
)->new_oid
, &oid
);
1143 static struct ref
*make_linked_ref(const char *name
, struct ref
***tail
)
1145 struct ref
*ret
= alloc_ref(name
);
1146 tail_link_ref(ret
, tail
);
1150 static char *guess_ref(const char *name
, struct ref
*peer
)
1152 struct strbuf buf
= STRBUF_INIT
;
1154 const char *r
= resolve_ref_unsafe(peer
->name
, RESOLVE_REF_READING
,
1159 if (starts_with(r
, "refs/heads/"))
1160 strbuf_addstr(&buf
, "refs/heads/");
1161 else if (starts_with(r
, "refs/tags/"))
1162 strbuf_addstr(&buf
, "refs/tags/");
1166 strbuf_addstr(&buf
, name
);
1167 return strbuf_detach(&buf
, NULL
);
1170 static int match_explicit_lhs(struct ref
*src
,
1173 int *allocated_match
)
1175 switch (count_refspec_match(rs
->src
, src
, match
)) {
1177 if (allocated_match
)
1178 *allocated_match
= 0;
1181 /* The source could be in the get_sha1() format
1182 * not a reference name. :refs/other is a
1183 * way to delete 'other' ref at the remote end.
1185 if (try_explicit_object_name(rs
->src
, match
) < 0)
1186 return error("src refspec %s does not match any.", rs
->src
);
1187 if (allocated_match
)
1188 *allocated_match
= 1;
1191 return error("src refspec %s matches more than one.", rs
->src
);
1195 static int match_explicit(struct ref
*src
, struct ref
*dst
,
1196 struct ref
***dst_tail
,
1199 struct ref
*matched_src
, *matched_dst
;
1202 const char *dst_value
= rs
->dst
;
1205 if (rs
->pattern
|| rs
->matching
)
1208 matched_src
= matched_dst
= NULL
;
1209 if (match_explicit_lhs(src
, rs
, &matched_src
, &allocated_src
) < 0)
1215 dst_value
= resolve_ref_unsafe(matched_src
->name
,
1216 RESOLVE_REF_READING
,
1219 ((flag
& REF_ISSYMREF
) &&
1220 !starts_with(dst_value
, "refs/heads/")))
1221 die("%s cannot be resolved to branch.",
1225 switch (count_refspec_match(dst_value
, dst
, &matched_dst
)) {
1229 if (starts_with(dst_value
, "refs/"))
1230 matched_dst
= make_linked_ref(dst_value
, dst_tail
);
1231 else if (is_null_oid(&matched_src
->new_oid
))
1232 error("unable to delete '%s': remote ref does not exist",
1234 else if ((dst_guess
= guess_ref(dst_value
, matched_src
))) {
1235 matched_dst
= make_linked_ref(dst_guess
, dst_tail
);
1238 error("unable to push to unqualified destination: %s\n"
1239 "The destination refspec neither matches an "
1240 "existing ref on the remote nor\n"
1241 "begins with refs/, and we are unable to "
1242 "guess a prefix based on the source ref.",
1247 error("dst refspec %s matches more than one.",
1253 if (matched_dst
->peer_ref
)
1254 return error("dst ref %s receives from more than one src.",
1257 matched_dst
->peer_ref
= allocated_src
?
1259 copy_ref(matched_src
);
1260 matched_dst
->force
= rs
->force
;
1265 static int match_explicit_refs(struct ref
*src
, struct ref
*dst
,
1266 struct ref
***dst_tail
, struct refspec
*rs
,
1270 for (i
= errs
= 0; i
< rs_nr
; i
++)
1271 errs
+= match_explicit(src
, dst
, dst_tail
, &rs
[i
]);
1275 static char *get_ref_match(const struct refspec
*rs
, int rs_nr
, const struct ref
*ref
,
1276 int send_mirror
, int direction
, const struct refspec
**ret_pat
)
1278 const struct refspec
*pat
;
1281 int matching_refs
= -1;
1282 for (i
= 0; i
< rs_nr
; i
++) {
1283 if (rs
[i
].matching
&&
1284 (matching_refs
== -1 || rs
[i
].force
)) {
1289 if (rs
[i
].pattern
) {
1290 const char *dst_side
= rs
[i
].dst
? rs
[i
].dst
: rs
[i
].src
;
1292 if (direction
== FROM_SRC
)
1293 match
= match_name_with_pattern(rs
[i
].src
, ref
->name
, dst_side
, &name
);
1295 match
= match_name_with_pattern(dst_side
, ref
->name
, rs
[i
].src
, &name
);
1302 if (matching_refs
== -1)
1305 pat
= rs
+ matching_refs
;
1306 if (pat
->matching
) {
1308 * "matching refs"; traditionally we pushed everything
1309 * including refs outside refs/heads/ hierarchy, but
1310 * that does not make much sense these days.
1312 if (!send_mirror
&& !starts_with(ref
->name
, "refs/heads/"))
1314 name
= xstrdup(ref
->name
);
1321 static struct ref
**tail_ref(struct ref
**head
)
1323 struct ref
**tail
= head
;
1325 tail
= &((*tail
)->next
);
1330 struct commit
**tip
;
1334 static void add_to_tips(struct tips
*tips
, const struct object_id
*oid
)
1336 struct commit
*commit
;
1338 if (is_null_oid(oid
))
1340 commit
= lookup_commit_reference_gently(oid
, 1);
1341 if (!commit
|| (commit
->object
.flags
& TMP_MARK
))
1343 commit
->object
.flags
|= TMP_MARK
;
1344 ALLOC_GROW(tips
->tip
, tips
->nr
+ 1, tips
->alloc
);
1345 tips
->tip
[tips
->nr
++] = commit
;
1348 static void add_missing_tags(struct ref
*src
, struct ref
**dst
, struct ref
***dst_tail
)
1350 struct string_list dst_tag
= STRING_LIST_INIT_NODUP
;
1351 struct string_list src_tag
= STRING_LIST_INIT_NODUP
;
1352 struct string_list_item
*item
;
1354 struct tips sent_tips
;
1357 * Collect everything we know they would have at the end of
1358 * this push, and collect all tags they have.
1360 memset(&sent_tips
, 0, sizeof(sent_tips
));
1361 for (ref
= *dst
; ref
; ref
= ref
->next
) {
1362 if (ref
->peer_ref
&&
1363 !is_null_oid(&ref
->peer_ref
->new_oid
))
1364 add_to_tips(&sent_tips
, &ref
->peer_ref
->new_oid
);
1366 add_to_tips(&sent_tips
, &ref
->old_oid
);
1367 if (starts_with(ref
->name
, "refs/tags/"))
1368 string_list_append(&dst_tag
, ref
->name
);
1370 clear_commit_marks_many(sent_tips
.nr
, sent_tips
.tip
, TMP_MARK
);
1372 string_list_sort(&dst_tag
);
1374 /* Collect tags they do not have. */
1375 for (ref
= src
; ref
; ref
= ref
->next
) {
1376 if (!starts_with(ref
->name
, "refs/tags/"))
1377 continue; /* not a tag */
1378 if (string_list_has_string(&dst_tag
, ref
->name
))
1379 continue; /* they already have it */
1380 if (oid_object_info(the_repository
, &ref
->new_oid
, NULL
) != OBJ_TAG
)
1381 continue; /* be conservative */
1382 item
= string_list_append(&src_tag
, ref
->name
);
1385 string_list_clear(&dst_tag
, 0);
1388 * At this point, src_tag lists tags that are missing from
1389 * dst, and sent_tips lists the tips we are pushing or those
1390 * that we know they already have. An element in the src_tag
1391 * that is an ancestor of any of the sent_tips needs to be
1392 * sent to the other side.
1395 for_each_string_list_item(item
, &src_tag
) {
1396 struct ref
*ref
= item
->util
;
1397 struct ref
*dst_ref
;
1398 struct commit
*commit
;
1400 if (is_null_oid(&ref
->new_oid
))
1402 commit
= lookup_commit_reference_gently(&ref
->new_oid
,
1405 /* not pushing a commit, which is not an error */
1409 * Is this tag, which they do not have, reachable from
1410 * any of the commits we are sending?
1412 if (!in_merge_bases_many(commit
, sent_tips
.nr
, sent_tips
.tip
))
1416 dst_ref
= make_linked_ref(ref
->name
, dst_tail
);
1417 oidcpy(&dst_ref
->new_oid
, &ref
->new_oid
);
1418 dst_ref
->peer_ref
= copy_ref(ref
);
1421 string_list_clear(&src_tag
, 0);
1422 free(sent_tips
.tip
);
1425 struct ref
*find_ref_by_name(const struct ref
*list
, const char *name
)
1427 for ( ; list
; list
= list
->next
)
1428 if (!strcmp(list
->name
, name
))
1429 return (struct ref
*)list
;
1433 static void prepare_ref_index(struct string_list
*ref_index
, struct ref
*ref
)
1435 for ( ; ref
; ref
= ref
->next
)
1436 string_list_append_nodup(ref_index
, ref
->name
)->util
= ref
;
1438 string_list_sort(ref_index
);
1442 * Given only the set of local refs, sanity-check the set of push
1443 * refspecs. We can't catch all errors that match_push_refs would,
1444 * but we can catch some errors early before even talking to the
1447 int check_push_refs(struct ref
*src
, int nr_refspec
, const char **refspec_names
)
1449 struct refspec
*refspec
= parse_push_refspec(nr_refspec
, refspec_names
);
1453 for (i
= 0; i
< nr_refspec
; i
++) {
1454 struct refspec
*rs
= refspec
+ i
;
1456 if (rs
->pattern
|| rs
->matching
)
1459 ret
|= match_explicit_lhs(src
, rs
, NULL
, NULL
);
1462 free_refspec(nr_refspec
, refspec
);
1467 * Given the set of refs the local repository has, the set of refs the
1468 * remote repository has, and the refspec used for push, determine
1469 * what remote refs we will update and with what value by setting
1470 * peer_ref (which object is being pushed) and force (if the push is
1471 * forced) in elements of "dst". The function may add new elements to
1472 * dst (e.g. pushing to a new branch, done in match_explicit_refs).
1474 int match_push_refs(struct ref
*src
, struct ref
**dst
,
1475 int nr_refspec
, const char **refspec
, int flags
)
1478 int send_all
= flags
& MATCH_REFS_ALL
;
1479 int send_mirror
= flags
& MATCH_REFS_MIRROR
;
1480 int send_prune
= flags
& MATCH_REFS_PRUNE
;
1482 static const char *default_refspec
[] = { ":", NULL
};
1483 struct ref
*ref
, **dst_tail
= tail_ref(dst
);
1484 struct string_list dst_ref_index
= STRING_LIST_INIT_NODUP
;
1488 refspec
= default_refspec
;
1490 rs
= parse_push_refspec(nr_refspec
, (const char **) refspec
);
1491 errs
= match_explicit_refs(src
, *dst
, &dst_tail
, rs
, nr_refspec
);
1493 /* pick the remainder */
1494 for (ref
= src
; ref
; ref
= ref
->next
) {
1495 struct string_list_item
*dst_item
;
1496 struct ref
*dst_peer
;
1497 const struct refspec
*pat
= NULL
;
1500 dst_name
= get_ref_match(rs
, nr_refspec
, ref
, send_mirror
, FROM_SRC
, &pat
);
1504 if (!dst_ref_index
.nr
)
1505 prepare_ref_index(&dst_ref_index
, *dst
);
1507 dst_item
= string_list_lookup(&dst_ref_index
, dst_name
);
1508 dst_peer
= dst_item
? dst_item
->util
: NULL
;
1510 if (dst_peer
->peer_ref
)
1511 /* We're already sending something to this ref. */
1514 if (pat
->matching
&& !(send_all
|| send_mirror
))
1516 * Remote doesn't have it, and we have no
1517 * explicit pattern, and we don't have
1518 * --all or --mirror.
1522 /* Create a new one and link it */
1523 dst_peer
= make_linked_ref(dst_name
, &dst_tail
);
1524 oidcpy(&dst_peer
->new_oid
, &ref
->new_oid
);
1525 string_list_insert(&dst_ref_index
,
1526 dst_peer
->name
)->util
= dst_peer
;
1528 dst_peer
->peer_ref
= copy_ref(ref
);
1529 dst_peer
->force
= pat
->force
;
1534 string_list_clear(&dst_ref_index
, 0);
1536 if (flags
& MATCH_REFS_FOLLOW_TAGS
)
1537 add_missing_tags(src
, dst
, &dst_tail
);
1540 struct string_list src_ref_index
= STRING_LIST_INIT_NODUP
;
1541 /* check for missing refs on the remote */
1542 for (ref
= *dst
; ref
; ref
= ref
->next
) {
1546 /* We're already sending something to this ref. */
1549 src_name
= get_ref_match(rs
, nr_refspec
, ref
, send_mirror
, FROM_DST
, NULL
);
1551 if (!src_ref_index
.nr
)
1552 prepare_ref_index(&src_ref_index
, src
);
1553 if (!string_list_has_string(&src_ref_index
,
1555 ref
->peer_ref
= alloc_delete_ref();
1559 string_list_clear(&src_ref_index
, 0);
1566 void set_ref_status_for_push(struct ref
*remote_refs
, int send_mirror
,
1571 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
1572 int force_ref_update
= ref
->force
|| force_update
;
1573 int reject_reason
= 0;
1576 oidcpy(&ref
->new_oid
, &ref
->peer_ref
->new_oid
);
1577 else if (!send_mirror
)
1580 ref
->deletion
= is_null_oid(&ref
->new_oid
);
1581 if (!ref
->deletion
&&
1582 !oidcmp(&ref
->old_oid
, &ref
->new_oid
)) {
1583 ref
->status
= REF_STATUS_UPTODATE
;
1588 * If the remote ref has moved and is now different
1589 * from what we expect, reject any push.
1591 * It also is an error if the user told us to check
1592 * with the remote-tracking branch to find the value
1593 * to expect, but we did not have such a tracking
1596 if (ref
->expect_old_sha1
) {
1597 if (oidcmp(&ref
->old_oid
, &ref
->old_oid_expect
))
1598 reject_reason
= REF_STATUS_REJECT_STALE
;
1600 /* If the ref isn't stale then force the update. */
1601 force_ref_update
= 1;
1605 * If the update isn't already rejected then check
1606 * the usual "must fast-forward" rules.
1608 * Decide whether an individual refspec A:B can be
1609 * pushed. The push will succeed if any of the
1610 * following are true:
1612 * (1) the remote reference B does not exist
1614 * (2) the remote reference B is being removed (i.e.,
1615 * pushing :B where no source is specified)
1617 * (3) the destination is not under refs/tags/, and
1618 * if the old and new value is a commit, the new
1619 * is a descendant of the old.
1621 * (4) it is forced using the +A:B notation, or by
1622 * passing the --force argument
1625 if (!reject_reason
&& !ref
->deletion
&& !is_null_oid(&ref
->old_oid
)) {
1626 if (starts_with(ref
->name
, "refs/tags/"))
1627 reject_reason
= REF_STATUS_REJECT_ALREADY_EXISTS
;
1628 else if (!has_object_file(&ref
->old_oid
))
1629 reject_reason
= REF_STATUS_REJECT_FETCH_FIRST
;
1630 else if (!lookup_commit_reference_gently(&ref
->old_oid
, 1) ||
1631 !lookup_commit_reference_gently(&ref
->new_oid
, 1))
1632 reject_reason
= REF_STATUS_REJECT_NEEDS_FORCE
;
1633 else if (!ref_newer(&ref
->new_oid
, &ref
->old_oid
))
1634 reject_reason
= REF_STATUS_REJECT_NONFASTFORWARD
;
1638 * "--force" will defeat any rejection implemented
1639 * by the rules above.
1641 if (!force_ref_update
)
1642 ref
->status
= reject_reason
;
1643 else if (reject_reason
)
1644 ref
->forced_update
= 1;
1648 static void set_merge(struct branch
*ret
)
1650 struct remote
*remote
;
1652 struct object_id oid
;
1656 return; /* no branch */
1658 return; /* already run */
1659 if (!ret
->remote_name
|| !ret
->merge_nr
) {
1661 * no merge config; let's make sure we don't confuse callers
1662 * with a non-zero merge_nr but a NULL merge
1668 remote
= remote_get(ret
->remote_name
);
1670 ret
->merge
= xcalloc(ret
->merge_nr
, sizeof(*ret
->merge
));
1671 for (i
= 0; i
< ret
->merge_nr
; i
++) {
1672 ret
->merge
[i
] = xcalloc(1, sizeof(**ret
->merge
));
1673 ret
->merge
[i
]->src
= xstrdup(ret
->merge_name
[i
]);
1674 if (!remote_find_tracking(remote
, ret
->merge
[i
]) ||
1675 strcmp(ret
->remote_name
, "."))
1677 if (dwim_ref(ret
->merge_name
[i
], strlen(ret
->merge_name
[i
]),
1679 ret
->merge
[i
]->dst
= ref
;
1681 ret
->merge
[i
]->dst
= xstrdup(ret
->merge_name
[i
]);
1685 struct branch
*branch_get(const char *name
)
1690 if (!name
|| !*name
|| !strcmp(name
, "HEAD"))
1691 ret
= current_branch
;
1693 ret
= make_branch(name
, 0);
1698 int branch_has_merge_config(struct branch
*branch
)
1700 return branch
&& !!branch
->merge
;
1703 int branch_merge_matches(struct branch
*branch
,
1705 const char *refname
)
1707 if (!branch
|| i
< 0 || i
>= branch
->merge_nr
)
1709 return refname_match(branch
->merge
[i
]->src
, refname
);
1712 __attribute__((format (printf
,2,3)))
1713 static const char *error_buf(struct strbuf
*err
, const char *fmt
, ...)
1718 strbuf_vaddf(err
, fmt
, ap
);
1724 const char *branch_get_upstream(struct branch
*branch
, struct strbuf
*err
)
1727 return error_buf(err
, _("HEAD does not point to a branch"));
1729 if (!branch
->merge
|| !branch
->merge
[0]) {
1731 * no merge config; is it because the user didn't define any,
1732 * or because it is not a real branch, and get_branch
1735 if (!ref_exists(branch
->refname
))
1736 return error_buf(err
, _("no such branch: '%s'"),
1738 return error_buf(err
,
1739 _("no upstream configured for branch '%s'"),
1743 if (!branch
->merge
[0]->dst
)
1744 return error_buf(err
,
1745 _("upstream branch '%s' not stored as a remote-tracking branch"),
1746 branch
->merge
[0]->src
);
1748 return branch
->merge
[0]->dst
;
1751 static const char *tracking_for_push_dest(struct remote
*remote
,
1752 const char *refname
,
1757 ret
= apply_refspecs(remote
->fetch
, remote
->fetch_refspec_nr
, refname
);
1759 return error_buf(err
,
1760 _("push destination '%s' on remote '%s' has no local tracking branch"),
1761 refname
, remote
->name
);
1765 static const char *branch_get_push_1(struct branch
*branch
, struct strbuf
*err
)
1767 struct remote
*remote
;
1769 remote
= remote_get(pushremote_for_branch(branch
, NULL
));
1771 return error_buf(err
,
1772 _("branch '%s' has no remote for pushing"),
1775 if (remote
->push_refspec_nr
) {
1779 dst
= apply_refspecs(remote
->push
, remote
->push_refspec_nr
,
1782 return error_buf(err
,
1783 _("push refspecs for '%s' do not include '%s'"),
1784 remote
->name
, branch
->name
);
1786 ret
= tracking_for_push_dest(remote
, dst
, err
);
1792 return tracking_for_push_dest(remote
, branch
->refname
, err
);
1794 switch (push_default
) {
1795 case PUSH_DEFAULT_NOTHING
:
1796 return error_buf(err
, _("push has no destination (push.default is 'nothing')"));
1798 case PUSH_DEFAULT_MATCHING
:
1799 case PUSH_DEFAULT_CURRENT
:
1800 return tracking_for_push_dest(remote
, branch
->refname
, err
);
1802 case PUSH_DEFAULT_UPSTREAM
:
1803 return branch_get_upstream(branch
, err
);
1805 case PUSH_DEFAULT_UNSPECIFIED
:
1806 case PUSH_DEFAULT_SIMPLE
:
1808 const char *up
, *cur
;
1810 up
= branch_get_upstream(branch
, err
);
1813 cur
= tracking_for_push_dest(remote
, branch
->refname
, err
);
1816 if (strcmp(cur
, up
))
1817 return error_buf(err
,
1818 _("cannot resolve 'simple' push to a single destination"));
1823 die("BUG: unhandled push situation");
1826 const char *branch_get_push(struct branch
*branch
, struct strbuf
*err
)
1829 return error_buf(err
, _("HEAD does not point to a branch"));
1831 if (!branch
->push_tracking_ref
)
1832 branch
->push_tracking_ref
= branch_get_push_1(branch
, err
);
1833 return branch
->push_tracking_ref
;
1836 static int ignore_symref_update(const char *refname
)
1840 if (!resolve_ref_unsafe(refname
, 0, NULL
, &flag
))
1841 return 0; /* non-existing refs are OK */
1842 return (flag
& REF_ISSYMREF
);
1846 * Create and return a list of (struct ref) consisting of copies of
1847 * each remote_ref that matches refspec. refspec must be a pattern.
1848 * Fill in the copies' peer_ref to describe the local tracking refs to
1849 * which they map. Omit any references that would map to an existing
1850 * local symbolic ref.
1852 static struct ref
*get_expanded_map(const struct ref
*remote_refs
,
1853 const struct refspec
*refspec
)
1855 const struct ref
*ref
;
1856 struct ref
*ret
= NULL
;
1857 struct ref
**tail
= &ret
;
1859 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
1860 char *expn_name
= NULL
;
1862 if (strchr(ref
->name
, '^'))
1863 continue; /* a dereference item */
1864 if (match_name_with_pattern(refspec
->src
, ref
->name
,
1865 refspec
->dst
, &expn_name
) &&
1866 !ignore_symref_update(expn_name
)) {
1867 struct ref
*cpy
= copy_ref(ref
);
1869 cpy
->peer_ref
= alloc_ref(expn_name
);
1871 cpy
->peer_ref
->force
= 1;
1881 static const struct ref
*find_ref_by_name_abbrev(const struct ref
*refs
, const char *name
)
1883 const struct ref
*ref
;
1884 for (ref
= refs
; ref
; ref
= ref
->next
) {
1885 if (refname_match(name
, ref
->name
))
1891 struct ref
*get_remote_ref(const struct ref
*remote_refs
, const char *name
)
1893 const struct ref
*ref
= find_ref_by_name_abbrev(remote_refs
, name
);
1898 return copy_ref(ref
);
1901 static struct ref
*get_local_ref(const char *name
)
1903 if (!name
|| name
[0] == '\0')
1906 if (starts_with(name
, "refs/"))
1907 return alloc_ref(name
);
1909 if (starts_with(name
, "heads/") ||
1910 starts_with(name
, "tags/") ||
1911 starts_with(name
, "remotes/"))
1912 return alloc_ref_with_prefix("refs/", 5, name
);
1914 return alloc_ref_with_prefix("refs/heads/", 11, name
);
1917 int get_fetch_map(const struct ref
*remote_refs
,
1918 const struct refspec
*refspec
,
1922 struct ref
*ref_map
, **rmp
;
1924 if (refspec
->pattern
) {
1925 ref_map
= get_expanded_map(remote_refs
, refspec
);
1927 const char *name
= refspec
->src
[0] ? refspec
->src
: "HEAD";
1929 if (refspec
->exact_sha1
) {
1930 ref_map
= alloc_ref(name
);
1931 get_oid_hex(name
, &ref_map
->old_oid
);
1933 ref_map
= get_remote_ref(remote_refs
, name
);
1935 if (!missing_ok
&& !ref_map
)
1936 die("Couldn't find remote ref %s", name
);
1938 ref_map
->peer_ref
= get_local_ref(refspec
->dst
);
1939 if (ref_map
->peer_ref
&& refspec
->force
)
1940 ref_map
->peer_ref
->force
= 1;
1944 for (rmp
= &ref_map
; *rmp
; ) {
1945 if ((*rmp
)->peer_ref
) {
1946 if (!starts_with((*rmp
)->peer_ref
->name
, "refs/") ||
1947 check_refname_format((*rmp
)->peer_ref
->name
, 0)) {
1948 struct ref
*ignore
= *rmp
;
1949 error("* Ignoring funny ref '%s' locally",
1950 (*rmp
)->peer_ref
->name
);
1951 *rmp
= (*rmp
)->next
;
1952 free(ignore
->peer_ref
);
1957 rmp
= &((*rmp
)->next
);
1961 tail_link_ref(ref_map
, tail
);
1966 int resolve_remote_symref(struct ref
*ref
, struct ref
*list
)
1970 for (; list
; list
= list
->next
)
1971 if (!strcmp(ref
->symref
, list
->name
)) {
1972 oidcpy(&ref
->old_oid
, &list
->old_oid
);
1978 static void unmark_and_free(struct commit_list
*list
, unsigned int mark
)
1981 struct commit
*commit
= pop_commit(&list
);
1982 commit
->object
.flags
&= ~mark
;
1986 int ref_newer(const struct object_id
*new_oid
, const struct object_id
*old_oid
)
1989 struct commit
*old_commit
, *new_commit
;
1990 struct commit_list
*list
, *used
;
1994 * Both new_commit and old_commit must be commit-ish and new_commit is descendant of
1995 * old_commit. Otherwise we require --force.
1997 o
= deref_tag(parse_object(old_oid
), NULL
, 0);
1998 if (!o
|| o
->type
!= OBJ_COMMIT
)
2000 old_commit
= (struct commit
*) o
;
2002 o
= deref_tag(parse_object(new_oid
), NULL
, 0);
2003 if (!o
|| o
->type
!= OBJ_COMMIT
)
2005 new_commit
= (struct commit
*) o
;
2007 if (parse_commit(new_commit
) < 0)
2011 commit_list_insert(new_commit
, &list
);
2013 new_commit
= pop_most_recent_commit(&list
, TMP_MARK
);
2014 commit_list_insert(new_commit
, &used
);
2015 if (new_commit
== old_commit
) {
2020 unmark_and_free(list
, TMP_MARK
);
2021 unmark_and_free(used
, TMP_MARK
);
2026 * Lookup the upstream branch for the given branch and if present, optionally
2027 * compute the commit ahead/behind values for the pair.
2029 * If abf is AHEAD_BEHIND_FULL, compute the full ahead/behind and return the
2030 * counts in *num_ours and *num_theirs. If abf is AHEAD_BEHIND_QUICK, skip
2031 * the (potentially expensive) a/b computation (*num_ours and *num_theirs are
2034 * The name of the upstream branch (or NULL if no upstream is defined) is
2035 * returned via *upstream_name, if it is not itself NULL.
2037 * Returns -1 if num_ours and num_theirs could not be filled in (e.g., no
2038 * upstream defined, or ref does not exist). Returns 0 if the commits are
2039 * identical. Returns 1 if commits are different.
2041 int stat_tracking_info(struct branch
*branch
, int *num_ours
, int *num_theirs
,
2042 const char **upstream_name
, enum ahead_behind_flags abf
)
2044 struct object_id oid
;
2045 struct commit
*ours
, *theirs
;
2046 struct rev_info revs
;
2048 struct argv_array argv
= ARGV_ARRAY_INIT
;
2050 /* Cannot stat unless we are marked to build on top of somebody else. */
2051 base
= branch_get_upstream(branch
, NULL
);
2053 *upstream_name
= base
;
2057 /* Cannot stat if what we used to build on no longer exists */
2058 if (read_ref(base
, &oid
))
2060 theirs
= lookup_commit_reference(&oid
);
2064 if (read_ref(branch
->refname
, &oid
))
2066 ours
= lookup_commit_reference(&oid
);
2070 *num_theirs
= *num_ours
= 0;
2072 /* are we the same? */
2075 if (abf
== AHEAD_BEHIND_QUICK
)
2077 if (abf
!= AHEAD_BEHIND_FULL
)
2078 BUG("stat_tracking_info: invalid abf '%d'", abf
);
2080 /* Run "rev-list --left-right ours...theirs" internally... */
2081 argv_array_push(&argv
, ""); /* ignored */
2082 argv_array_push(&argv
, "--left-right");
2083 argv_array_pushf(&argv
, "%s...%s",
2084 oid_to_hex(&ours
->object
.oid
),
2085 oid_to_hex(&theirs
->object
.oid
));
2086 argv_array_push(&argv
, "--");
2088 init_revisions(&revs
, NULL
);
2089 setup_revisions(argv
.argc
, argv
.argv
, &revs
, NULL
);
2090 if (prepare_revision_walk(&revs
))
2091 die("revision walk setup failed");
2093 /* ... and count the commits on each side. */
2095 struct commit
*c
= get_revision(&revs
);
2098 if (c
->object
.flags
& SYMMETRIC_LEFT
)
2104 /* clear object flags smudged by the above traversal */
2105 clear_commit_marks(ours
, ALL_REV_FLAGS
);
2106 clear_commit_marks(theirs
, ALL_REV_FLAGS
);
2108 argv_array_clear(&argv
);
2113 * Return true when there is anything to report, otherwise false.
2115 int format_tracking_info(struct branch
*branch
, struct strbuf
*sb
,
2116 enum ahead_behind_flags abf
)
2118 int ours
, theirs
, sti
;
2119 const char *full_base
;
2121 int upstream_is_gone
= 0;
2123 sti
= stat_tracking_info(branch
, &ours
, &theirs
, &full_base
, abf
);
2127 upstream_is_gone
= 1;
2130 base
= shorten_unambiguous_ref(full_base
, 0);
2131 if (upstream_is_gone
) {
2133 _("Your branch is based on '%s', but the upstream is gone.\n"),
2135 if (advice_status_hints
)
2137 _(" (use \"git branch --unset-upstream\" to fixup)\n"));
2140 _("Your branch is up to date with '%s'.\n"),
2142 } else if (abf
== AHEAD_BEHIND_QUICK
) {
2144 _("Your branch and '%s' refer to different commits.\n"),
2146 if (advice_status_hints
)
2147 strbuf_addf(sb
, _(" (use \"%s\" for details)\n"),
2148 "git status --ahead-behind");
2149 } else if (!theirs
) {
2151 Q_("Your branch is ahead of '%s' by %d commit.\n",
2152 "Your branch is ahead of '%s' by %d commits.\n",
2155 if (advice_status_hints
)
2157 _(" (use \"git push\" to publish your local commits)\n"));
2160 Q_("Your branch is behind '%s' by %d commit, "
2161 "and can be fast-forwarded.\n",
2162 "Your branch is behind '%s' by %d commits, "
2163 "and can be fast-forwarded.\n",
2166 if (advice_status_hints
)
2168 _(" (use \"git pull\" to update your local branch)\n"));
2171 Q_("Your branch and '%s' have diverged,\n"
2172 "and have %d and %d different commit each, "
2174 "Your branch and '%s' have diverged,\n"
2175 "and have %d and %d different commits each, "
2178 base
, ours
, theirs
);
2179 if (advice_status_hints
)
2181 _(" (use \"git pull\" to merge the remote branch into yours)\n"));
2187 static int one_local_ref(const char *refname
, const struct object_id
*oid
,
2188 int flag
, void *cb_data
)
2190 struct ref
***local_tail
= cb_data
;
2193 /* we already know it starts with refs/ to get here */
2194 if (check_refname_format(refname
+ 5, 0))
2197 ref
= alloc_ref(refname
);
2198 oidcpy(&ref
->new_oid
, oid
);
2200 *local_tail
= &ref
->next
;
2204 struct ref
*get_local_heads(void)
2206 struct ref
*local_refs
= NULL
, **local_tail
= &local_refs
;
2208 for_each_ref(one_local_ref
, &local_tail
);
2212 struct ref
*guess_remote_head(const struct ref
*head
,
2213 const struct ref
*refs
,
2216 const struct ref
*r
;
2217 struct ref
*list
= NULL
;
2218 struct ref
**tail
= &list
;
2224 * Some transports support directly peeking at
2225 * where HEAD points; if that is the case, then
2226 * we don't have to guess.
2229 return copy_ref(find_ref_by_name(refs
, head
->symref
));
2231 /* If refs/heads/master could be right, it is. */
2233 r
= find_ref_by_name(refs
, "refs/heads/master");
2234 if (r
&& !oidcmp(&r
->old_oid
, &head
->old_oid
))
2238 /* Look for another ref that points there */
2239 for (r
= refs
; r
; r
= r
->next
) {
2241 starts_with(r
->name
, "refs/heads/") &&
2242 !oidcmp(&r
->old_oid
, &head
->old_oid
)) {
2243 *tail
= copy_ref(r
);
2244 tail
= &((*tail
)->next
);
2253 struct stale_heads_info
{
2254 struct string_list
*ref_names
;
2255 struct ref
**stale_refs_tail
;
2256 struct refspec
*refs
;
2260 static int get_stale_heads_cb(const char *refname
, const struct object_id
*oid
,
2261 int flags
, void *cb_data
)
2263 struct stale_heads_info
*info
= cb_data
;
2264 struct string_list matches
= STRING_LIST_INIT_DUP
;
2265 struct refspec query
;
2267 memset(&query
, 0, sizeof(struct refspec
));
2268 query
.dst
= (char *)refname
;
2270 query_refspecs_multiple(info
->refs
, info
->ref_count
, &query
, &matches
);
2271 if (matches
.nr
== 0)
2272 goto clean_exit
; /* No matches */
2275 * If we did find a suitable refspec and it's not a symref and
2276 * it's not in the list of refs that currently exist in that
2277 * remote, we consider it to be stale. In order to deal with
2278 * overlapping refspecs, we need to go over all of the
2281 if (flags
& REF_ISSYMREF
)
2284 for (i
= 0; stale
&& i
< matches
.nr
; i
++)
2285 if (string_list_has_string(info
->ref_names
, matches
.items
[i
].string
))
2289 struct ref
*ref
= make_linked_ref(refname
, &info
->stale_refs_tail
);
2290 oidcpy(&ref
->new_oid
, oid
);
2294 string_list_clear(&matches
, 0);
2298 struct ref
*get_stale_heads(struct refspec
*refs
, int ref_count
, struct ref
*fetch_map
)
2300 struct ref
*ref
, *stale_refs
= NULL
;
2301 struct string_list ref_names
= STRING_LIST_INIT_NODUP
;
2302 struct stale_heads_info info
;
2304 info
.ref_names
= &ref_names
;
2305 info
.stale_refs_tail
= &stale_refs
;
2307 info
.ref_count
= ref_count
;
2308 for (ref
= fetch_map
; ref
; ref
= ref
->next
)
2309 string_list_append(&ref_names
, ref
->name
);
2310 string_list_sort(&ref_names
);
2311 for_each_ref(get_stale_heads_cb
, &info
);
2312 string_list_clear(&ref_names
, 0);
2319 static void clear_cas_option(struct push_cas_option
*cas
)
2323 for (i
= 0; i
< cas
->nr
; i
++)
2324 free(cas
->entry
[i
].refname
);
2326 memset(cas
, 0, sizeof(*cas
));
2329 static struct push_cas
*add_cas_entry(struct push_cas_option
*cas
,
2330 const char *refname
,
2333 struct push_cas
*entry
;
2334 ALLOC_GROW(cas
->entry
, cas
->nr
+ 1, cas
->alloc
);
2335 entry
= &cas
->entry
[cas
->nr
++];
2336 memset(entry
, 0, sizeof(*entry
));
2337 entry
->refname
= xmemdupz(refname
, refnamelen
);
2341 static int parse_push_cas_option(struct push_cas_option
*cas
, const char *arg
, int unset
)
2344 struct push_cas
*entry
;
2347 /* "--no-<option>" */
2348 clear_cas_option(cas
);
2353 /* just "--<option>" */
2354 cas
->use_tracking_for_rest
= 1;
2358 /* "--<option>=refname" or "--<option>=refname:value" */
2359 colon
= strchrnul(arg
, ':');
2360 entry
= add_cas_entry(cas
, arg
, colon
- arg
);
2362 entry
->use_tracking
= 1;
2364 oidclr(&entry
->expect
);
2365 else if (get_oid(colon
+ 1, &entry
->expect
))
2366 return error("cannot parse expected object name '%s'", colon
+ 1);
2370 int parseopt_push_cas_option(const struct option
*opt
, const char *arg
, int unset
)
2372 return parse_push_cas_option(opt
->value
, arg
, unset
);
2375 int is_empty_cas(const struct push_cas_option
*cas
)
2377 return !cas
->use_tracking_for_rest
&& !cas
->nr
;
2381 * Look at remote.fetch refspec and see if we have a remote
2382 * tracking branch for the refname there. Fill its current
2384 * If we cannot do so, return negative to signal an error.
2386 static int remote_tracking(struct remote
*remote
, const char *refname
,
2387 struct object_id
*oid
)
2391 dst
= apply_refspecs(remote
->fetch
, remote
->fetch_refspec_nr
, refname
);
2393 return -1; /* no tracking ref for refname at remote */
2394 if (read_ref(dst
, oid
))
2395 return -1; /* we know what the tracking ref is but we cannot read it */
2399 static void apply_cas(struct push_cas_option
*cas
,
2400 struct remote
*remote
,
2405 /* Find an explicit --<option>=<name>[:<value>] entry */
2406 for (i
= 0; i
< cas
->nr
; i
++) {
2407 struct push_cas
*entry
= &cas
->entry
[i
];
2408 if (!refname_match(entry
->refname
, ref
->name
))
2410 ref
->expect_old_sha1
= 1;
2411 if (!entry
->use_tracking
)
2412 oidcpy(&ref
->old_oid_expect
, &entry
->expect
);
2413 else if (remote_tracking(remote
, ref
->name
, &ref
->old_oid_expect
))
2414 oidclr(&ref
->old_oid_expect
);
2418 /* Are we using "--<option>" to cover all? */
2419 if (!cas
->use_tracking_for_rest
)
2422 ref
->expect_old_sha1
= 1;
2423 if (remote_tracking(remote
, ref
->name
, &ref
->old_oid_expect
))
2424 oidclr(&ref
->old_oid_expect
);
2427 void apply_push_cas(struct push_cas_option
*cas
,
2428 struct remote
*remote
,
2429 struct ref
*remote_refs
)
2432 for (ref
= remote_refs
; ref
; ref
= ref
->next
)
2433 apply_cas(cas
, remote
, ref
);