1 #include "git-compat-util.h"
4 #include "environment.h"
11 #include "object-name.h"
12 #include "object-store-ll.h"
20 #include "string-list.h"
22 #include "commit-reach.h"
25 #include "parse-options.h"
27 enum map_direction
{ FROM_SRC
, FROM_DST
};
29 struct counted_string
{
34 static int valid_remote(const struct remote
*remote
)
36 return (!!remote
->url
) || (!!remote
->foreign_vcs
);
39 static const char *alias_url(const char *url
, struct rewrites
*r
)
42 struct counted_string
*longest
;
47 for (i
= 0; i
< r
->rewrite_nr
; i
++) {
50 for (j
= 0; j
< r
->rewrite
[i
]->instead_of_nr
; j
++) {
51 if (starts_with(url
, r
->rewrite
[i
]->instead_of
[j
].s
) &&
53 longest
->len
< r
->rewrite
[i
]->instead_of
[j
].len
)) {
54 longest
= &(r
->rewrite
[i
]->instead_of
[j
]);
62 return xstrfmt("%s%s", r
->rewrite
[longest_i
]->base
, url
+ longest
->len
);
65 static void add_url(struct remote
*remote
, const char *url
)
67 ALLOC_GROW(remote
->url
, remote
->url_nr
+ 1, remote
->url_alloc
);
68 remote
->url
[remote
->url_nr
++] = url
;
71 static void add_pushurl(struct remote
*remote
, const char *pushurl
)
73 ALLOC_GROW(remote
->pushurl
, remote
->pushurl_nr
+ 1, remote
->pushurl_alloc
);
74 remote
->pushurl
[remote
->pushurl_nr
++] = pushurl
;
77 static void add_pushurl_alias(struct remote_state
*remote_state
,
78 struct remote
*remote
, const char *url
)
80 const char *pushurl
= alias_url(url
, &remote_state
->rewrites_push
);
82 add_pushurl(remote
, pushurl
);
85 static void add_url_alias(struct remote_state
*remote_state
,
86 struct remote
*remote
, const char *url
)
88 add_url(remote
, alias_url(url
, &remote_state
->rewrites
));
89 add_pushurl_alias(remote_state
, remote
, url
);
92 struct remotes_hash_key
{
97 static int remotes_hash_cmp(const void *cmp_data UNUSED
,
98 const struct hashmap_entry
*eptr
,
99 const struct hashmap_entry
*entry_or_key
,
102 const struct remote
*a
, *b
;
103 const struct remotes_hash_key
*key
= keydata
;
105 a
= container_of(eptr
, const struct remote
, ent
);
106 b
= container_of(entry_or_key
, const struct remote
, ent
);
109 return strncmp(a
->name
, key
->str
, key
->len
) || a
->name
[key
->len
];
111 return strcmp(a
->name
, b
->name
);
114 static struct remote
*make_remote(struct remote_state
*remote_state
,
115 const char *name
, int len
)
118 struct remotes_hash_key lookup
;
119 struct hashmap_entry lookup_entry
, *e
;
126 hashmap_entry_init(&lookup_entry
, memhash(name
, len
));
128 e
= hashmap_get(&remote_state
->remotes_hash
, &lookup_entry
, &lookup
);
130 return container_of(e
, struct remote
, ent
);
132 CALLOC_ARRAY(ret
, 1);
133 ret
->prune
= -1; /* unspecified */
134 ret
->prune_tags
= -1; /* unspecified */
135 ret
->name
= xstrndup(name
, len
);
136 refspec_init(&ret
->push
, REFSPEC_PUSH
);
137 refspec_init(&ret
->fetch
, REFSPEC_FETCH
);
139 ALLOC_GROW(remote_state
->remotes
, remote_state
->remotes_nr
+ 1,
140 remote_state
->remotes_alloc
);
141 remote_state
->remotes
[remote_state
->remotes_nr
++] = ret
;
143 hashmap_entry_init(&ret
->ent
, lookup_entry
.hash
);
144 if (hashmap_put_entry(&remote_state
->remotes_hash
, ret
, ent
))
145 BUG("hashmap_put overwrote entry after hashmap_get returned NULL");
149 static void remote_clear(struct remote
*remote
)
153 free((char *)remote
->name
);
154 free((char *)remote
->foreign_vcs
);
156 for (i
= 0; i
< remote
->url_nr
; i
++)
157 free((char *)remote
->url
[i
]);
158 FREE_AND_NULL(remote
->url
);
160 for (i
= 0; i
< remote
->pushurl_nr
; i
++)
161 free((char *)remote
->pushurl
[i
]);
162 FREE_AND_NULL(remote
->pushurl
);
163 free((char *)remote
->receivepack
);
164 free((char *)remote
->uploadpack
);
165 FREE_AND_NULL(remote
->http_proxy
);
166 FREE_AND_NULL(remote
->http_proxy_authmethod
);
169 static void add_merge(struct branch
*branch
, const char *name
)
171 ALLOC_GROW(branch
->merge_name
, branch
->merge_nr
+ 1,
172 branch
->merge_alloc
);
173 branch
->merge_name
[branch
->merge_nr
++] = name
;
176 struct branches_hash_key
{
181 static int branches_hash_cmp(const void *cmp_data UNUSED
,
182 const struct hashmap_entry
*eptr
,
183 const struct hashmap_entry
*entry_or_key
,
186 const struct branch
*a
, *b
;
187 const struct branches_hash_key
*key
= keydata
;
189 a
= container_of(eptr
, const struct branch
, ent
);
190 b
= container_of(entry_or_key
, const struct branch
, ent
);
193 return strncmp(a
->name
, key
->str
, key
->len
) ||
196 return strcmp(a
->name
, b
->name
);
199 static struct branch
*find_branch(struct remote_state
*remote_state
,
200 const char *name
, size_t len
)
202 struct branches_hash_key lookup
;
203 struct hashmap_entry lookup_entry
, *e
;
207 hashmap_entry_init(&lookup_entry
, memhash(name
, len
));
209 e
= hashmap_get(&remote_state
->branches_hash
, &lookup_entry
, &lookup
);
211 return container_of(e
, struct branch
, ent
);
216 static void die_on_missing_branch(struct repository
*repo
,
217 struct branch
*branch
)
219 /* branch == NULL is always valid because it represents detached HEAD. */
221 branch
!= find_branch(repo
->remote_state
, branch
->name
,
222 strlen(branch
->name
)))
223 die("branch %s was not found in the repository", branch
->name
);
226 static struct branch
*make_branch(struct remote_state
*remote_state
,
227 const char *name
, size_t len
)
231 ret
= find_branch(remote_state
, name
, len
);
235 CALLOC_ARRAY(ret
, 1);
236 ret
->name
= xstrndup(name
, len
);
237 ret
->refname
= xstrfmt("refs/heads/%s", ret
->name
);
239 hashmap_entry_init(&ret
->ent
, memhash(name
, len
));
240 if (hashmap_put_entry(&remote_state
->branches_hash
, ret
, ent
))
241 BUG("hashmap_put overwrote entry after hashmap_get returned NULL");
245 static struct rewrite
*make_rewrite(struct rewrites
*r
,
246 const char *base
, size_t len
)
251 for (i
= 0; i
< r
->rewrite_nr
; i
++) {
252 if (len
== r
->rewrite
[i
]->baselen
&&
253 !strncmp(base
, r
->rewrite
[i
]->base
, len
))
254 return r
->rewrite
[i
];
257 ALLOC_GROW(r
->rewrite
, r
->rewrite_nr
+ 1, r
->rewrite_alloc
);
258 CALLOC_ARRAY(ret
, 1);
259 r
->rewrite
[r
->rewrite_nr
++] = ret
;
260 ret
->base
= xstrndup(base
, len
);
265 static void add_instead_of(struct rewrite
*rewrite
, const char *instead_of
)
267 ALLOC_GROW(rewrite
->instead_of
, rewrite
->instead_of_nr
+ 1, rewrite
->instead_of_alloc
);
268 rewrite
->instead_of
[rewrite
->instead_of_nr
].s
= instead_of
;
269 rewrite
->instead_of
[rewrite
->instead_of_nr
].len
= strlen(instead_of
);
270 rewrite
->instead_of_nr
++;
273 static const char *skip_spaces(const char *s
)
280 static void read_remotes_file(struct remote_state
*remote_state
,
281 struct remote
*remote
)
283 struct strbuf buf
= STRBUF_INIT
;
284 FILE *f
= fopen_or_warn(git_path("remotes/%s", remote
->name
), "r");
288 remote
->configured_in_repo
= 1;
289 remote
->origin
= REMOTE_REMOTES
;
290 while (strbuf_getline(&buf
, f
) != EOF
) {
295 if (skip_prefix(buf
.buf
, "URL:", &v
))
296 add_url_alias(remote_state
, remote
,
297 xstrdup(skip_spaces(v
)));
298 else if (skip_prefix(buf
.buf
, "Push:", &v
))
299 refspec_append(&remote
->push
, skip_spaces(v
));
300 else if (skip_prefix(buf
.buf
, "Pull:", &v
))
301 refspec_append(&remote
->fetch
, skip_spaces(v
));
303 strbuf_release(&buf
);
307 static void read_branches_file(struct remote_state
*remote_state
,
308 struct remote
*remote
)
311 struct strbuf buf
= STRBUF_INIT
;
312 FILE *f
= fopen_or_warn(git_path("branches/%s", remote
->name
), "r");
317 strbuf_getline_lf(&buf
, f
);
321 strbuf_release(&buf
);
325 remote
->configured_in_repo
= 1;
326 remote
->origin
= REMOTE_BRANCHES
;
329 * The branches file would have URL and optionally
330 * #branch specified. The default (or specified) branch is
331 * fetched and stored in the local branch matching the
334 frag
= strchr(buf
.buf
, '#');
338 frag
= (char *)git_default_branch_name(0);
340 add_url_alias(remote_state
, remote
, strbuf_detach(&buf
, NULL
));
341 refspec_appendf(&remote
->fetch
, "refs/heads/%s:refs/heads/%s",
345 * Cogito compatible push: push current HEAD to remote #branch
346 * (master if missing)
348 refspec_appendf(&remote
->push
, "HEAD:refs/heads/%s", frag
);
349 remote
->fetch_tags
= 1; /* always auto-follow */
352 static int handle_config(const char *key
, const char *value
,
353 const struct config_context
*ctx
, void *cb
)
358 struct remote
*remote
;
359 struct branch
*branch
;
360 struct remote_state
*remote_state
= cb
;
361 const struct key_value_info
*kvi
= ctx
->kvi
;
363 if (parse_config_key(key
, "branch", &name
, &namelen
, &subkey
) >= 0) {
364 /* There is no subsection. */
367 /* There is a subsection, but it is empty. */
370 branch
= make_branch(remote_state
, name
, namelen
);
371 if (!strcmp(subkey
, "remote")) {
372 return git_config_string(&branch
->remote_name
, key
, value
);
373 } else if (!strcmp(subkey
, "pushremote")) {
374 return git_config_string(&branch
->pushremote_name
, key
, value
);
375 } else if (!strcmp(subkey
, "merge")) {
377 return config_error_nonbool(key
);
378 add_merge(branch
, xstrdup(value
));
382 if (parse_config_key(key
, "url", &name
, &namelen
, &subkey
) >= 0) {
383 struct rewrite
*rewrite
;
386 if (!strcmp(subkey
, "insteadof")) {
388 return config_error_nonbool(key
);
389 rewrite
= make_rewrite(&remote_state
->rewrites
, name
,
391 add_instead_of(rewrite
, xstrdup(value
));
392 } else if (!strcmp(subkey
, "pushinsteadof")) {
394 return config_error_nonbool(key
);
395 rewrite
= make_rewrite(&remote_state
->rewrites_push
,
397 add_instead_of(rewrite
, xstrdup(value
));
401 if (parse_config_key(key
, "remote", &name
, &namelen
, &subkey
) < 0)
404 /* Handle remote.* variables */
405 if (!name
&& !strcmp(subkey
, "pushdefault"))
406 return git_config_string(&remote_state
->pushremote_name
, key
,
411 /* Handle remote.<name>.* variables */
413 warning(_("config remote shorthand cannot begin with '/': %s"),
417 remote
= make_remote(remote_state
, name
, namelen
);
418 remote
->origin
= REMOTE_CONFIG
;
419 if (kvi
->scope
== CONFIG_SCOPE_LOCAL
||
420 kvi
->scope
== CONFIG_SCOPE_WORKTREE
)
421 remote
->configured_in_repo
= 1;
422 if (!strcmp(subkey
, "mirror"))
423 remote
->mirror
= git_config_bool(key
, value
);
424 else if (!strcmp(subkey
, "skipdefaultupdate"))
425 remote
->skip_default_update
= git_config_bool(key
, value
);
426 else if (!strcmp(subkey
, "skipfetchall"))
427 remote
->skip_default_update
= git_config_bool(key
, value
);
428 else if (!strcmp(subkey
, "prune"))
429 remote
->prune
= git_config_bool(key
, value
);
430 else if (!strcmp(subkey
, "prunetags"))
431 remote
->prune_tags
= git_config_bool(key
, value
);
432 else if (!strcmp(subkey
, "url")) {
434 if (git_config_string(&v
, key
, value
))
437 } else if (!strcmp(subkey
, "pushurl")) {
439 if (git_config_string(&v
, key
, value
))
441 add_pushurl(remote
, v
);
442 } else if (!strcmp(subkey
, "push")) {
444 if (git_config_string(&v
, key
, value
))
446 refspec_append(&remote
->push
, v
);
448 } else if (!strcmp(subkey
, "fetch")) {
450 if (git_config_string(&v
, key
, value
))
452 refspec_append(&remote
->fetch
, v
);
454 } else if (!strcmp(subkey
, "receivepack")) {
456 if (git_config_string(&v
, key
, value
))
458 if (!remote
->receivepack
)
459 remote
->receivepack
= v
;
461 error(_("more than one receivepack given, using the first"));
462 } else if (!strcmp(subkey
, "uploadpack")) {
464 if (git_config_string(&v
, key
, value
))
466 if (!remote
->uploadpack
)
467 remote
->uploadpack
= v
;
469 error(_("more than one uploadpack given, using the first"));
470 } else if (!strcmp(subkey
, "tagopt")) {
471 if (!strcmp(value
, "--no-tags"))
472 remote
->fetch_tags
= -1;
473 else if (!strcmp(value
, "--tags"))
474 remote
->fetch_tags
= 2;
475 } else if (!strcmp(subkey
, "proxy")) {
476 return git_config_string((const char **)&remote
->http_proxy
,
478 } else if (!strcmp(subkey
, "proxyauthmethod")) {
479 return git_config_string((const char **)&remote
->http_proxy_authmethod
,
481 } else if (!strcmp(subkey
, "vcs")) {
482 return git_config_string(&remote
->foreign_vcs
, key
, value
);
487 static void alias_all_urls(struct remote_state
*remote_state
)
490 for (i
= 0; i
< remote_state
->remotes_nr
; i
++) {
491 int add_pushurl_aliases
;
492 if (!remote_state
->remotes
[i
])
494 for (j
= 0; j
< remote_state
->remotes
[i
]->pushurl_nr
; j
++) {
495 remote_state
->remotes
[i
]->pushurl
[j
] =
496 alias_url(remote_state
->remotes
[i
]->pushurl
[j
],
497 &remote_state
->rewrites
);
499 add_pushurl_aliases
= remote_state
->remotes
[i
]->pushurl_nr
== 0;
500 for (j
= 0; j
< remote_state
->remotes
[i
]->url_nr
; j
++) {
501 if (add_pushurl_aliases
)
503 remote_state
, remote_state
->remotes
[i
],
504 remote_state
->remotes
[i
]->url
[j
]);
505 remote_state
->remotes
[i
]->url
[j
] =
506 alias_url(remote_state
->remotes
[i
]->url
[j
],
507 &remote_state
->rewrites
);
512 static void read_config(struct repository
*repo
, int early
)
516 if (repo
->remote_state
->initialized
)
518 repo
->remote_state
->initialized
= 1;
520 repo
->remote_state
->current_branch
= NULL
;
521 if (startup_info
->have_repository
&& !early
) {
522 const char *head_ref
= refs_resolve_ref_unsafe(
523 get_main_ref_store(repo
), "HEAD", 0, NULL
, &flag
);
524 if (head_ref
&& (flag
& REF_ISSYMREF
) &&
525 skip_prefix(head_ref
, "refs/heads/", &head_ref
)) {
526 repo
->remote_state
->current_branch
= make_branch(
527 repo
->remote_state
, head_ref
, strlen(head_ref
));
530 repo_config(repo
, handle_config
, repo
->remote_state
);
531 alias_all_urls(repo
->remote_state
);
534 static int valid_remote_nick(const char *name
)
536 if (!name
[0] || is_dot_or_dotdot(name
))
539 /* remote nicknames cannot contain slashes */
541 if (is_dir_sep(*name
++))
546 static const char *remotes_remote_for_branch(struct remote_state
*remote_state
,
547 struct branch
*branch
,
550 if (branch
&& branch
->remote_name
) {
553 return branch
->remote_name
;
557 if (remote_state
->remotes_nr
== 1)
558 return remote_state
->remotes
[0]->name
;
562 const char *remote_for_branch(struct branch
*branch
, int *explicit)
564 read_config(the_repository
, 0);
565 die_on_missing_branch(the_repository
, branch
);
567 return remotes_remote_for_branch(the_repository
->remote_state
, branch
,
572 remotes_pushremote_for_branch(struct remote_state
*remote_state
,
573 struct branch
*branch
, int *explicit)
575 if (branch
&& branch
->pushremote_name
) {
578 return branch
->pushremote_name
;
580 if (remote_state
->pushremote_name
) {
583 return remote_state
->pushremote_name
;
585 return remotes_remote_for_branch(remote_state
, branch
, explicit);
588 const char *pushremote_for_branch(struct branch
*branch
, int *explicit)
590 read_config(the_repository
, 0);
591 die_on_missing_branch(the_repository
, branch
);
593 return remotes_pushremote_for_branch(the_repository
->remote_state
,
597 static struct remote
*remotes_remote_get(struct remote_state
*remote_state
,
600 const char *remote_ref_for_branch(struct branch
*branch
, int for_push
)
602 read_config(the_repository
, 0);
603 die_on_missing_branch(the_repository
, branch
);
607 if (branch
->merge_nr
) {
608 return branch
->merge_name
[0];
612 *remote_name
= remotes_pushremote_for_branch(
613 the_repository
->remote_state
, branch
,
615 struct remote
*remote
= remotes_remote_get(
616 the_repository
->remote_state
, remote_name
);
618 if (remote
&& remote
->push
.nr
&&
619 (dst
= apply_refspecs(&remote
->push
,
628 static void validate_remote_url(struct remote
*remote
)
632 struct strbuf redacted
= STRBUF_INIT
;
635 if (git_config_get_string_tmp("transfer.credentialsinurl", &value
))
638 if (!strcmp("warn", value
))
640 else if (!strcmp("die", value
))
642 else if (!strcmp("allow", value
))
645 die(_("unrecognized value transfer.credentialsInUrl: '%s'"), value
);
647 for (i
= 0; i
< remote
->url_nr
; i
++) {
648 struct url_info url_info
= { 0 };
650 if (!url_normalize(remote
->url
[i
], &url_info
) ||
651 !url_info
.passwd_off
)
654 strbuf_reset(&redacted
);
655 strbuf_add(&redacted
, url_info
.url
, url_info
.passwd_off
);
656 strbuf_addstr(&redacted
, "<redacted>");
657 strbuf_addstr(&redacted
,
658 url_info
.url
+ url_info
.passwd_off
+ url_info
.passwd_len
);
661 warning(_("URL '%s' uses plaintext credentials"), redacted
.buf
);
663 die(_("URL '%s' uses plaintext credentials"), redacted
.buf
);
669 strbuf_release(&redacted
);
672 static struct remote
*
673 remotes_remote_get_1(struct remote_state
*remote_state
, const char *name
,
674 const char *(*get_default
)(struct remote_state
*,
675 struct branch
*, int *))
683 name
= get_default(remote_state
, remote_state
->current_branch
,
686 ret
= make_remote(remote_state
, name
, 0);
687 if (valid_remote_nick(name
) && have_git_dir()) {
688 if (!valid_remote(ret
))
689 read_remotes_file(remote_state
, ret
);
690 if (!valid_remote(ret
))
691 read_branches_file(remote_state
, ret
);
693 if (name_given
&& !valid_remote(ret
))
694 add_url_alias(remote_state
, ret
, name
);
695 if (!valid_remote(ret
))
698 validate_remote_url(ret
);
703 static inline struct remote
*
704 remotes_remote_get(struct remote_state
*remote_state
, const char *name
)
706 return remotes_remote_get_1(remote_state
, name
,
707 remotes_remote_for_branch
);
710 struct remote
*remote_get(const char *name
)
712 read_config(the_repository
, 0);
713 return remotes_remote_get(the_repository
->remote_state
, name
);
716 struct remote
*remote_get_early(const char *name
)
718 read_config(the_repository
, 1);
719 return remotes_remote_get(the_repository
->remote_state
, name
);
722 static inline struct remote
*
723 remotes_pushremote_get(struct remote_state
*remote_state
, const char *name
)
725 return remotes_remote_get_1(remote_state
, name
,
726 remotes_pushremote_for_branch
);
729 struct remote
*pushremote_get(const char *name
)
731 read_config(the_repository
, 0);
732 return remotes_pushremote_get(the_repository
->remote_state
, name
);
735 int remote_is_configured(struct remote
*remote
, int in_repo
)
740 return remote
->configured_in_repo
;
741 return !!remote
->origin
;
744 int for_each_remote(each_remote_fn fn
, void *priv
)
747 read_config(the_repository
, 0);
748 for (i
= 0; i
< the_repository
->remote_state
->remotes_nr
&& !result
;
750 struct remote
*remote
=
751 the_repository
->remote_state
->remotes
[i
];
754 result
= fn(remote
, priv
);
759 static void handle_duplicate(struct ref
*ref1
, struct ref
*ref2
)
761 if (strcmp(ref1
->name
, ref2
->name
)) {
762 if (ref1
->fetch_head_status
!= FETCH_HEAD_IGNORE
&&
763 ref2
->fetch_head_status
!= FETCH_HEAD_IGNORE
) {
764 die(_("Cannot fetch both %s and %s to %s"),
765 ref1
->name
, ref2
->name
, ref2
->peer_ref
->name
);
766 } else if (ref1
->fetch_head_status
!= FETCH_HEAD_IGNORE
&&
767 ref2
->fetch_head_status
== FETCH_HEAD_IGNORE
) {
768 warning(_("%s usually tracks %s, not %s"),
769 ref2
->peer_ref
->name
, ref2
->name
, ref1
->name
);
770 } else if (ref1
->fetch_head_status
== FETCH_HEAD_IGNORE
&&
771 ref2
->fetch_head_status
== FETCH_HEAD_IGNORE
) {
772 die(_("%s tracks both %s and %s"),
773 ref2
->peer_ref
->name
, ref1
->name
, ref2
->name
);
776 * This last possibility doesn't occur because
777 * FETCH_HEAD_IGNORE entries always appear at
778 * the end of the list.
780 BUG("Internal error");
783 free(ref2
->peer_ref
);
787 struct ref
*ref_remove_duplicates(struct ref
*ref_map
)
789 struct string_list refs
= STRING_LIST_INIT_NODUP
;
790 struct ref
*retval
= NULL
;
791 struct ref
**p
= &retval
;
794 struct ref
*ref
= ref_map
;
796 ref_map
= ref_map
->next
;
799 if (!ref
->peer_ref
) {
803 struct string_list_item
*item
=
804 string_list_insert(&refs
, ref
->peer_ref
->name
);
807 /* Entry already existed */
808 handle_duplicate((struct ref
*)item
->util
, ref
);
817 string_list_clear(&refs
, 0);
821 int remote_has_url(struct remote
*remote
, const char *url
)
824 for (i
= 0; i
< remote
->url_nr
; i
++) {
825 if (!strcmp(remote
->url
[i
], url
))
831 static int match_name_with_pattern(const char *key
, const char *name
,
832 const char *value
, char **result
)
834 const char *kstar
= strchr(key
, '*');
840 die(_("key '%s' of pattern had no '*'"), key
);
842 ksuffixlen
= strlen(kstar
+ 1);
843 namelen
= strlen(name
);
844 ret
= !strncmp(name
, key
, klen
) && namelen
>= klen
+ ksuffixlen
&&
845 !memcmp(name
+ namelen
- ksuffixlen
, kstar
+ 1, ksuffixlen
);
847 struct strbuf sb
= STRBUF_INIT
;
848 const char *vstar
= strchr(value
, '*');
850 die(_("value '%s' of pattern has no '*'"), value
);
851 strbuf_add(&sb
, value
, vstar
- value
);
852 strbuf_add(&sb
, name
+ klen
, namelen
- klen
- ksuffixlen
);
853 strbuf_addstr(&sb
, vstar
+ 1);
854 *result
= strbuf_detach(&sb
, NULL
);
859 static int refspec_match(const struct refspec_item
*refspec
,
862 if (refspec
->pattern
)
863 return match_name_with_pattern(refspec
->src
, name
, NULL
, NULL
);
865 return !strcmp(refspec
->src
, name
);
868 int omit_name_by_refspec(const char *name
, struct refspec
*rs
)
872 for (i
= 0; i
< rs
->nr
; i
++) {
873 if (rs
->items
[i
].negative
&& refspec_match(&rs
->items
[i
], name
))
879 struct ref
*apply_negative_refspecs(struct ref
*ref_map
, struct refspec
*rs
)
883 for (tail
= &ref_map
; *tail
; ) {
884 struct ref
*ref
= *tail
;
886 if (omit_name_by_refspec(ref
->name
, rs
)) {
897 static int query_matches_negative_refspec(struct refspec
*rs
, struct refspec_item
*query
)
899 int i
, matched_negative
= 0;
900 int find_src
= !query
->src
;
901 struct string_list reversed
= STRING_LIST_INIT_DUP
;
902 const char *needle
= find_src
? query
->dst
: query
->src
;
905 * Check whether the queried ref matches any negative refpsec. If so,
906 * then we should ultimately treat this as not matching the query at
909 * Note that negative refspecs always match the source, but the query
910 * item uses the destination. To handle this, we apply pattern
911 * refspecs in reverse to figure out if the query source matches any
912 * of the negative refspecs.
914 * The first loop finds and expands all positive refspecs
915 * matched by the queried ref.
917 * The second loop checks if any of the results of the first loop
918 * match any negative refspec.
920 for (i
= 0; i
< rs
->nr
; i
++) {
921 struct refspec_item
*refspec
= &rs
->items
[i
];
924 if (refspec
->negative
)
927 /* Note the reversal of src and dst */
928 if (refspec
->pattern
) {
929 const char *key
= refspec
->dst
? refspec
->dst
: refspec
->src
;
930 const char *value
= refspec
->src
;
932 if (match_name_with_pattern(key
, needle
, value
, &expn_name
))
933 string_list_append_nodup(&reversed
, expn_name
);
934 } else if (refspec
->matching
) {
935 /* For the special matching refspec, any query should match */
936 string_list_append(&reversed
, needle
);
937 } else if (!refspec
->src
) {
938 BUG("refspec->src should not be null here");
939 } else if (!strcmp(needle
, refspec
->src
)) {
940 string_list_append(&reversed
, refspec
->src
);
944 for (i
= 0; !matched_negative
&& i
< reversed
.nr
; i
++) {
945 if (omit_name_by_refspec(reversed
.items
[i
].string
, rs
))
946 matched_negative
= 1;
949 string_list_clear(&reversed
, 0);
951 return matched_negative
;
954 static void query_refspecs_multiple(struct refspec
*rs
,
955 struct refspec_item
*query
,
956 struct string_list
*results
)
959 int find_src
= !query
->src
;
961 if (find_src
&& !query
->dst
)
962 BUG("query_refspecs_multiple: need either src or dst");
964 if (query_matches_negative_refspec(rs
, query
))
967 for (i
= 0; i
< rs
->nr
; i
++) {
968 struct refspec_item
*refspec
= &rs
->items
[i
];
969 const char *key
= find_src
? refspec
->dst
: refspec
->src
;
970 const char *value
= find_src
? refspec
->src
: refspec
->dst
;
971 const char *needle
= find_src
? query
->dst
: query
->src
;
972 char **result
= find_src
? &query
->src
: &query
->dst
;
974 if (!refspec
->dst
|| refspec
->negative
)
976 if (refspec
->pattern
) {
977 if (match_name_with_pattern(key
, needle
, value
, result
))
978 string_list_append_nodup(results
, *result
);
979 } else if (!strcmp(needle
, key
)) {
980 string_list_append(results
, value
);
985 int query_refspecs(struct refspec
*rs
, struct refspec_item
*query
)
988 int find_src
= !query
->src
;
989 const char *needle
= find_src
? query
->dst
: query
->src
;
990 char **result
= find_src
? &query
->src
: &query
->dst
;
992 if (find_src
&& !query
->dst
)
993 BUG("query_refspecs: need either src or dst");
995 if (query_matches_negative_refspec(rs
, query
))
998 for (i
= 0; i
< rs
->nr
; i
++) {
999 struct refspec_item
*refspec
= &rs
->items
[i
];
1000 const char *key
= find_src
? refspec
->dst
: refspec
->src
;
1001 const char *value
= find_src
? refspec
->src
: refspec
->dst
;
1003 if (!refspec
->dst
|| refspec
->negative
)
1005 if (refspec
->pattern
) {
1006 if (match_name_with_pattern(key
, needle
, value
, result
)) {
1007 query
->force
= refspec
->force
;
1010 } else if (!strcmp(needle
, key
)) {
1011 *result
= xstrdup(value
);
1012 query
->force
= refspec
->force
;
1019 char *apply_refspecs(struct refspec
*rs
, const char *name
)
1021 struct refspec_item query
;
1023 memset(&query
, 0, sizeof(struct refspec_item
));
1024 query
.src
= (char *)name
;
1026 if (query_refspecs(rs
, &query
))
1032 int remote_find_tracking(struct remote
*remote
, struct refspec_item
*refspec
)
1034 return query_refspecs(&remote
->fetch
, refspec
);
1037 static struct ref
*alloc_ref_with_prefix(const char *prefix
, size_t prefixlen
,
1040 size_t len
= strlen(name
);
1041 struct ref
*ref
= xcalloc(1, st_add4(sizeof(*ref
), prefixlen
, len
, 1));
1042 memcpy(ref
->name
, prefix
, prefixlen
);
1043 memcpy(ref
->name
+ prefixlen
, name
, len
);
1047 struct ref
*alloc_ref(const char *name
)
1049 return alloc_ref_with_prefix("", 0, name
);
1052 struct ref
*copy_ref(const struct ref
*ref
)
1058 len
= st_add3(sizeof(struct ref
), strlen(ref
->name
), 1);
1060 memcpy(cpy
, ref
, len
);
1062 cpy
->symref
= xstrdup_or_null(ref
->symref
);
1063 cpy
->remote_status
= xstrdup_or_null(ref
->remote_status
);
1064 cpy
->peer_ref
= copy_ref(ref
->peer_ref
);
1068 struct ref
*copy_ref_list(const struct ref
*ref
)
1070 struct ref
*ret
= NULL
;
1071 struct ref
**tail
= &ret
;
1073 *tail
= copy_ref(ref
);
1075 tail
= &((*tail
)->next
);
1080 void free_one_ref(struct ref
*ref
)
1084 free_one_ref(ref
->peer_ref
);
1085 free(ref
->remote_status
);
1090 void free_refs(struct ref
*ref
)
1100 int count_refspec_match(const char *pattern
,
1102 struct ref
**matched_ref
)
1104 int patlen
= strlen(pattern
);
1105 struct ref
*matched_weak
= NULL
;
1106 struct ref
*matched
= NULL
;
1110 for (weak_match
= match
= 0; refs
; refs
= refs
->next
) {
1111 char *name
= refs
->name
;
1112 int namelen
= strlen(name
);
1114 if (!refname_match(pattern
, name
))
1117 /* A match is "weak" if it is with refs outside
1118 * heads or tags, and did not specify the pattern
1119 * in full (e.g. "refs/remotes/origin/master") or at
1120 * least from the toplevel (e.g. "remotes/origin/master");
1121 * otherwise "git push $URL master" would result in
1122 * ambiguity between remotes/origin/master and heads/master
1123 * at the remote site.
1125 if (namelen
!= patlen
&&
1126 patlen
!= namelen
- 5 &&
1127 !starts_with(name
, "refs/heads/") &&
1128 !starts_with(name
, "refs/tags/")) {
1129 /* We want to catch the case where only weak
1130 * matches are found and there are multiple
1131 * matches, and where more than one strong
1132 * matches are found, as ambiguous. One
1133 * strong match with zero or more weak matches
1134 * are acceptable as a unique match.
1136 matched_weak
= refs
;
1146 *matched_ref
= matched_weak
;
1151 *matched_ref
= matched
;
1156 static void tail_link_ref(struct ref
*ref
, struct ref
***tail
)
1164 static struct ref
*alloc_delete_ref(void)
1166 struct ref
*ref
= alloc_ref("(delete)");
1167 oidclr(&ref
->new_oid
);
1171 static int try_explicit_object_name(const char *name
,
1174 struct object_id oid
;
1178 *match
= alloc_delete_ref();
1182 if (repo_get_oid(the_repository
, name
, &oid
))
1186 *match
= alloc_ref(name
);
1187 oidcpy(&(*match
)->new_oid
, &oid
);
1192 static struct ref
*make_linked_ref(const char *name
, struct ref
***tail
)
1194 struct ref
*ret
= alloc_ref(name
);
1195 tail_link_ref(ret
, tail
);
1199 static char *guess_ref(const char *name
, struct ref
*peer
)
1201 struct strbuf buf
= STRBUF_INIT
;
1203 const char *r
= resolve_ref_unsafe(peer
->name
, RESOLVE_REF_READING
,
1208 if (starts_with(r
, "refs/heads/")) {
1209 strbuf_addstr(&buf
, "refs/heads/");
1210 } else if (starts_with(r
, "refs/tags/")) {
1211 strbuf_addstr(&buf
, "refs/tags/");
1216 strbuf_addstr(&buf
, name
);
1217 return strbuf_detach(&buf
, NULL
);
1220 static int match_explicit_lhs(struct ref
*src
,
1221 struct refspec_item
*rs
,
1223 int *allocated_match
)
1225 switch (count_refspec_match(rs
->src
, src
, match
)) {
1227 if (allocated_match
)
1228 *allocated_match
= 0;
1231 /* The source could be in the get_sha1() format
1232 * not a reference name. :refs/other is a
1233 * way to delete 'other' ref at the remote end.
1235 if (try_explicit_object_name(rs
->src
, match
) < 0)
1236 return error(_("src refspec %s does not match any"), rs
->src
);
1237 if (allocated_match
)
1238 *allocated_match
= 1;
1241 return error(_("src refspec %s matches more than one"), rs
->src
);
1245 static void show_push_unqualified_ref_name_error(const char *dst_value
,
1246 const char *matched_src_name
)
1248 struct object_id oid
;
1249 enum object_type type
;
1252 * TRANSLATORS: "matches '%s'%" is the <dst> part of "git push
1253 * <remote> <src>:<dst>" push, and "being pushed ('%s')" is
1256 error(_("The destination you provided is not a full refname (i.e.,\n"
1257 "starting with \"refs/\"). We tried to guess what you meant by:\n"
1259 "- Looking for a ref that matches '%s' on the remote side.\n"
1260 "- Checking if the <src> being pushed ('%s')\n"
1261 " is a ref in \"refs/{heads,tags}/\". If so we add a corresponding\n"
1262 " refs/{heads,tags}/ prefix on the remote side.\n"
1264 "Neither worked, so we gave up. You must fully qualify the ref."),
1265 dst_value
, matched_src_name
);
1267 if (!advice_enabled(ADVICE_PUSH_UNQUALIFIED_REF_NAME
))
1270 if (repo_get_oid(the_repository
, matched_src_name
, &oid
))
1271 BUG("'%s' is not a valid object, "
1272 "match_explicit_lhs() should catch this!",
1274 type
= oid_object_info(the_repository
, &oid
, NULL
);
1275 if (type
== OBJ_COMMIT
) {
1276 advise(_("The <src> part of the refspec is a commit object.\n"
1277 "Did you mean to create a new branch by pushing to\n"
1278 "'%s:refs/heads/%s'?"),
1279 matched_src_name
, dst_value
);
1280 } else if (type
== OBJ_TAG
) {
1281 advise(_("The <src> part of the refspec is a tag object.\n"
1282 "Did you mean to create a new tag by pushing to\n"
1283 "'%s:refs/tags/%s'?"),
1284 matched_src_name
, dst_value
);
1285 } else if (type
== OBJ_TREE
) {
1286 advise(_("The <src> part of the refspec is a tree object.\n"
1287 "Did you mean to tag a new tree by pushing to\n"
1288 "'%s:refs/tags/%s'?"),
1289 matched_src_name
, dst_value
);
1290 } else if (type
== OBJ_BLOB
) {
1291 advise(_("The <src> part of the refspec is a blob object.\n"
1292 "Did you mean to tag a new blob by pushing to\n"
1293 "'%s:refs/tags/%s'?"),
1294 matched_src_name
, dst_value
);
1296 BUG("'%s' should be commit/tag/tree/blob, is '%d'",
1297 matched_src_name
, type
);
1301 static int match_explicit(struct ref
*src
, struct ref
*dst
,
1302 struct ref
***dst_tail
,
1303 struct refspec_item
*rs
)
1305 struct ref
*matched_src
, *matched_dst
;
1308 const char *dst_value
= rs
->dst
;
1311 if (rs
->pattern
|| rs
->matching
|| rs
->negative
)
1314 matched_src
= matched_dst
= NULL
;
1315 if (match_explicit_lhs(src
, rs
, &matched_src
, &allocated_src
) < 0)
1321 dst_value
= resolve_ref_unsafe(matched_src
->name
,
1322 RESOLVE_REF_READING
,
1325 ((flag
& REF_ISSYMREF
) &&
1326 !starts_with(dst_value
, "refs/heads/")))
1327 die(_("%s cannot be resolved to branch"),
1331 switch (count_refspec_match(dst_value
, dst
, &matched_dst
)) {
1335 if (starts_with(dst_value
, "refs/")) {
1336 matched_dst
= make_linked_ref(dst_value
, dst_tail
);
1337 } else if (is_null_oid(&matched_src
->new_oid
)) {
1338 error(_("unable to delete '%s': remote ref does not exist"),
1340 } else if ((dst_guess
= guess_ref(dst_value
, matched_src
))) {
1341 matched_dst
= make_linked_ref(dst_guess
, dst_tail
);
1344 show_push_unqualified_ref_name_error(dst_value
,
1350 error(_("dst refspec %s matches more than one"),
1356 if (matched_dst
->peer_ref
)
1357 return error(_("dst ref %s receives from more than one src"),
1360 matched_dst
->peer_ref
= allocated_src
?
1362 copy_ref(matched_src
);
1363 matched_dst
->force
= rs
->force
;
1368 static int match_explicit_refs(struct ref
*src
, struct ref
*dst
,
1369 struct ref
***dst_tail
, struct refspec
*rs
)
1372 for (i
= errs
= 0; i
< rs
->nr
; i
++)
1373 errs
+= match_explicit(src
, dst
, dst_tail
, &rs
->items
[i
]);
1377 static char *get_ref_match(const struct refspec
*rs
, const struct ref
*ref
,
1378 int send_mirror
, int direction
,
1379 const struct refspec_item
**ret_pat
)
1381 const struct refspec_item
*pat
;
1384 int matching_refs
= -1;
1385 for (i
= 0; i
< rs
->nr
; i
++) {
1386 const struct refspec_item
*item
= &rs
->items
[i
];
1391 if (item
->matching
&&
1392 (matching_refs
== -1 || item
->force
)) {
1397 if (item
->pattern
) {
1398 const char *dst_side
= item
->dst
? item
->dst
: item
->src
;
1400 if (direction
== FROM_SRC
)
1401 match
= match_name_with_pattern(item
->src
, ref
->name
, dst_side
, &name
);
1403 match
= match_name_with_pattern(dst_side
, ref
->name
, item
->src
, &name
);
1410 if (matching_refs
== -1)
1413 pat
= &rs
->items
[matching_refs
];
1414 if (pat
->matching
) {
1416 * "matching refs"; traditionally we pushed everything
1417 * including refs outside refs/heads/ hierarchy, but
1418 * that does not make much sense these days.
1420 if (!send_mirror
&& !starts_with(ref
->name
, "refs/heads/"))
1422 name
= xstrdup(ref
->name
);
1429 static struct ref
**tail_ref(struct ref
**head
)
1431 struct ref
**tail
= head
;
1433 tail
= &((*tail
)->next
);
1438 struct commit
**tip
;
1442 static void add_to_tips(struct tips
*tips
, const struct object_id
*oid
)
1444 struct commit
*commit
;
1446 if (is_null_oid(oid
))
1448 commit
= lookup_commit_reference_gently(the_repository
, oid
, 1);
1449 if (!commit
|| (commit
->object
.flags
& TMP_MARK
))
1451 commit
->object
.flags
|= TMP_MARK
;
1452 ALLOC_GROW(tips
->tip
, tips
->nr
+ 1, tips
->alloc
);
1453 tips
->tip
[tips
->nr
++] = commit
;
1456 static void add_missing_tags(struct ref
*src
, struct ref
**dst
, struct ref
***dst_tail
)
1458 struct string_list dst_tag
= STRING_LIST_INIT_NODUP
;
1459 struct string_list src_tag
= STRING_LIST_INIT_NODUP
;
1460 struct string_list_item
*item
;
1462 struct tips sent_tips
;
1465 * Collect everything we know they would have at the end of
1466 * this push, and collect all tags they have.
1468 memset(&sent_tips
, 0, sizeof(sent_tips
));
1469 for (ref
= *dst
; ref
; ref
= ref
->next
) {
1470 if (ref
->peer_ref
&&
1471 !is_null_oid(&ref
->peer_ref
->new_oid
))
1472 add_to_tips(&sent_tips
, &ref
->peer_ref
->new_oid
);
1474 add_to_tips(&sent_tips
, &ref
->old_oid
);
1475 if (starts_with(ref
->name
, "refs/tags/"))
1476 string_list_append(&dst_tag
, ref
->name
);
1478 clear_commit_marks_many(sent_tips
.nr
, sent_tips
.tip
, TMP_MARK
);
1480 string_list_sort(&dst_tag
);
1482 /* Collect tags they do not have. */
1483 for (ref
= src
; ref
; ref
= ref
->next
) {
1484 if (!starts_with(ref
->name
, "refs/tags/"))
1485 continue; /* not a tag */
1486 if (string_list_has_string(&dst_tag
, ref
->name
))
1487 continue; /* they already have it */
1488 if (oid_object_info(the_repository
, &ref
->new_oid
, NULL
) != OBJ_TAG
)
1489 continue; /* be conservative */
1490 item
= string_list_append(&src_tag
, ref
->name
);
1493 string_list_clear(&dst_tag
, 0);
1496 * At this point, src_tag lists tags that are missing from
1497 * dst, and sent_tips lists the tips we are pushing or those
1498 * that we know they already have. An element in the src_tag
1499 * that is an ancestor of any of the sent_tips needs to be
1500 * sent to the other side.
1503 const int reachable_flag
= 1;
1504 struct commit_list
*found_commits
;
1505 struct commit
**src_commits
;
1506 int nr_src_commits
= 0, alloc_src_commits
= 16;
1507 ALLOC_ARRAY(src_commits
, alloc_src_commits
);
1509 for_each_string_list_item(item
, &src_tag
) {
1510 struct ref
*ref
= item
->util
;
1511 struct commit
*commit
;
1513 if (is_null_oid(&ref
->new_oid
))
1515 commit
= lookup_commit_reference_gently(the_repository
,
1519 /* not pushing a commit, which is not an error */
1522 ALLOC_GROW(src_commits
, nr_src_commits
+ 1, alloc_src_commits
);
1523 src_commits
[nr_src_commits
++] = commit
;
1526 found_commits
= get_reachable_subset(sent_tips
.tip
, sent_tips
.nr
,
1527 src_commits
, nr_src_commits
,
1530 for_each_string_list_item(item
, &src_tag
) {
1531 struct ref
*dst_ref
;
1532 struct ref
*ref
= item
->util
;
1533 struct commit
*commit
;
1535 if (is_null_oid(&ref
->new_oid
))
1537 commit
= lookup_commit_reference_gently(the_repository
,
1541 /* not pushing a commit, which is not an error */
1545 * Is this tag, which they do not have, reachable from
1546 * any of the commits we are sending?
1548 if (!(commit
->object
.flags
& reachable_flag
))
1552 dst_ref
= make_linked_ref(ref
->name
, dst_tail
);
1553 oidcpy(&dst_ref
->new_oid
, &ref
->new_oid
);
1554 dst_ref
->peer_ref
= copy_ref(ref
);
1557 clear_commit_marks_many(nr_src_commits
, src_commits
, reachable_flag
);
1559 free_commit_list(found_commits
);
1562 string_list_clear(&src_tag
, 0);
1563 free(sent_tips
.tip
);
1566 struct ref
*find_ref_by_name(const struct ref
*list
, const char *name
)
1568 for ( ; list
; list
= list
->next
)
1569 if (!strcmp(list
->name
, name
))
1570 return (struct ref
*)list
;
1574 static void prepare_ref_index(struct string_list
*ref_index
, struct ref
*ref
)
1576 for ( ; ref
; ref
= ref
->next
)
1577 string_list_append_nodup(ref_index
, ref
->name
)->util
= ref
;
1579 string_list_sort(ref_index
);
1583 * Given only the set of local refs, sanity-check the set of push
1584 * refspecs. We can't catch all errors that match_push_refs would,
1585 * but we can catch some errors early before even talking to the
1588 int check_push_refs(struct ref
*src
, struct refspec
*rs
)
1593 for (i
= 0; i
< rs
->nr
; i
++) {
1594 struct refspec_item
*item
= &rs
->items
[i
];
1596 if (item
->pattern
|| item
->matching
|| item
->negative
)
1599 ret
|= match_explicit_lhs(src
, item
, NULL
, NULL
);
1606 * Given the set of refs the local repository has, the set of refs the
1607 * remote repository has, and the refspec used for push, determine
1608 * what remote refs we will update and with what value by setting
1609 * peer_ref (which object is being pushed) and force (if the push is
1610 * forced) in elements of "dst". The function may add new elements to
1611 * dst (e.g. pushing to a new branch, done in match_explicit_refs).
1613 int match_push_refs(struct ref
*src
, struct ref
**dst
,
1614 struct refspec
*rs
, int flags
)
1616 int send_all
= flags
& MATCH_REFS_ALL
;
1617 int send_mirror
= flags
& MATCH_REFS_MIRROR
;
1618 int send_prune
= flags
& MATCH_REFS_PRUNE
;
1620 struct ref
*ref
, **dst_tail
= tail_ref(dst
);
1621 struct string_list dst_ref_index
= STRING_LIST_INIT_NODUP
;
1623 /* If no refspec is provided, use the default ":" */
1625 refspec_append(rs
, ":");
1627 errs
= match_explicit_refs(src
, *dst
, &dst_tail
, rs
);
1629 /* pick the remainder */
1630 for (ref
= src
; ref
; ref
= ref
->next
) {
1631 struct string_list_item
*dst_item
;
1632 struct ref
*dst_peer
;
1633 const struct refspec_item
*pat
= NULL
;
1636 dst_name
= get_ref_match(rs
, ref
, send_mirror
, FROM_SRC
, &pat
);
1640 if (!dst_ref_index
.nr
)
1641 prepare_ref_index(&dst_ref_index
, *dst
);
1643 dst_item
= string_list_lookup(&dst_ref_index
, dst_name
);
1644 dst_peer
= dst_item
? dst_item
->util
: NULL
;
1646 if (dst_peer
->peer_ref
)
1647 /* We're already sending something to this ref. */
1650 if (pat
->matching
&& !(send_all
|| send_mirror
))
1652 * Remote doesn't have it, and we have no
1653 * explicit pattern, and we don't have
1654 * --all or --mirror.
1658 /* Create a new one and link it */
1659 dst_peer
= make_linked_ref(dst_name
, &dst_tail
);
1660 oidcpy(&dst_peer
->new_oid
, &ref
->new_oid
);
1661 string_list_insert(&dst_ref_index
,
1662 dst_peer
->name
)->util
= dst_peer
;
1664 dst_peer
->peer_ref
= copy_ref(ref
);
1665 dst_peer
->force
= pat
->force
;
1670 string_list_clear(&dst_ref_index
, 0);
1672 if (flags
& MATCH_REFS_FOLLOW_TAGS
)
1673 add_missing_tags(src
, dst
, &dst_tail
);
1676 struct string_list src_ref_index
= STRING_LIST_INIT_NODUP
;
1677 /* check for missing refs on the remote */
1678 for (ref
= *dst
; ref
; ref
= ref
->next
) {
1682 /* We're already sending something to this ref. */
1685 src_name
= get_ref_match(rs
, ref
, send_mirror
, FROM_DST
, NULL
);
1687 if (!src_ref_index
.nr
)
1688 prepare_ref_index(&src_ref_index
, src
);
1689 if (!string_list_has_string(&src_ref_index
,
1691 ref
->peer_ref
= alloc_delete_ref();
1695 string_list_clear(&src_ref_index
, 0);
1698 *dst
= apply_negative_refspecs(*dst
, rs
);
1705 void set_ref_status_for_push(struct ref
*remote_refs
, int send_mirror
,
1710 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
1711 int force_ref_update
= ref
->force
|| force_update
;
1712 int reject_reason
= 0;
1715 oidcpy(&ref
->new_oid
, &ref
->peer_ref
->new_oid
);
1716 else if (!send_mirror
)
1719 ref
->deletion
= is_null_oid(&ref
->new_oid
);
1720 if (!ref
->deletion
&&
1721 oideq(&ref
->old_oid
, &ref
->new_oid
)) {
1722 ref
->status
= REF_STATUS_UPTODATE
;
1727 * If the remote ref has moved and is now different
1728 * from what we expect, reject any push.
1730 * It also is an error if the user told us to check
1731 * with the remote-tracking branch to find the value
1732 * to expect, but we did not have such a tracking
1735 * If the tip of the remote-tracking ref is unreachable
1736 * from any reflog entry of its local ref indicating a
1737 * possible update since checkout; reject the push.
1739 if (ref
->expect_old_sha1
) {
1740 if (!oideq(&ref
->old_oid
, &ref
->old_oid_expect
))
1741 reject_reason
= REF_STATUS_REJECT_STALE
;
1742 else if (ref
->check_reachable
&& ref
->unreachable
)
1744 REF_STATUS_REJECT_REMOTE_UPDATED
;
1747 * If the ref isn't stale, and is reachable
1748 * from one of the reflog entries of
1749 * the local branch, force the update.
1751 force_ref_update
= 1;
1755 * If the update isn't already rejected then check
1756 * the usual "must fast-forward" rules.
1758 * Decide whether an individual refspec A:B can be
1759 * pushed. The push will succeed if any of the
1760 * following are true:
1762 * (1) the remote reference B does not exist
1764 * (2) the remote reference B is being removed (i.e.,
1765 * pushing :B where no source is specified)
1767 * (3) the destination is not under refs/tags/, and
1768 * if the old and new value is a commit, the new
1769 * is a descendant of the old.
1771 * (4) it is forced using the +A:B notation, or by
1772 * passing the --force argument
1775 if (!reject_reason
&& !ref
->deletion
&& !is_null_oid(&ref
->old_oid
)) {
1776 if (starts_with(ref
->name
, "refs/tags/"))
1777 reject_reason
= REF_STATUS_REJECT_ALREADY_EXISTS
;
1778 else if (!repo_has_object_file(the_repository
, &ref
->old_oid
))
1779 reject_reason
= REF_STATUS_REJECT_FETCH_FIRST
;
1780 else if (!lookup_commit_reference_gently(the_repository
, &ref
->old_oid
, 1) ||
1781 !lookup_commit_reference_gently(the_repository
, &ref
->new_oid
, 1))
1782 reject_reason
= REF_STATUS_REJECT_NEEDS_FORCE
;
1783 else if (!ref_newer(&ref
->new_oid
, &ref
->old_oid
))
1784 reject_reason
= REF_STATUS_REJECT_NONFASTFORWARD
;
1788 * "--force" will defeat any rejection implemented
1789 * by the rules above.
1791 if (!force_ref_update
)
1792 ref
->status
= reject_reason
;
1793 else if (reject_reason
)
1794 ref
->forced_update
= 1;
1798 static void set_merge(struct remote_state
*remote_state
, struct branch
*ret
)
1800 struct remote
*remote
;
1802 struct object_id oid
;
1806 return; /* no branch */
1808 return; /* already run */
1809 if (!ret
->remote_name
|| !ret
->merge_nr
) {
1811 * no merge config; let's make sure we don't confuse callers
1812 * with a non-zero merge_nr but a NULL merge
1818 remote
= remotes_remote_get(remote_state
, ret
->remote_name
);
1820 CALLOC_ARRAY(ret
->merge
, ret
->merge_nr
);
1821 for (i
= 0; i
< ret
->merge_nr
; i
++) {
1822 ret
->merge
[i
] = xcalloc(1, sizeof(**ret
->merge
));
1823 ret
->merge
[i
]->src
= xstrdup(ret
->merge_name
[i
]);
1824 if (!remote_find_tracking(remote
, ret
->merge
[i
]) ||
1825 strcmp(ret
->remote_name
, "."))
1827 if (repo_dwim_ref(the_repository
, ret
->merge_name
[i
],
1828 strlen(ret
->merge_name
[i
]), &oid
, &ref
,
1830 ret
->merge
[i
]->dst
= ref
;
1832 ret
->merge
[i
]->dst
= xstrdup(ret
->merge_name
[i
]);
1836 struct branch
*branch_get(const char *name
)
1840 read_config(the_repository
, 0);
1841 if (!name
|| !*name
|| !strcmp(name
, "HEAD"))
1842 ret
= the_repository
->remote_state
->current_branch
;
1844 ret
= make_branch(the_repository
->remote_state
, name
,
1846 set_merge(the_repository
->remote_state
, ret
);
1850 int branch_has_merge_config(struct branch
*branch
)
1852 return branch
&& !!branch
->merge
;
1855 int branch_merge_matches(struct branch
*branch
,
1857 const char *refname
)
1859 if (!branch
|| i
< 0 || i
>= branch
->merge_nr
)
1861 return refname_match(branch
->merge
[i
]->src
, refname
);
1864 __attribute__((format (printf
,2,3)))
1865 static const char *error_buf(struct strbuf
*err
, const char *fmt
, ...)
1870 strbuf_vaddf(err
, fmt
, ap
);
1876 const char *branch_get_upstream(struct branch
*branch
, struct strbuf
*err
)
1879 return error_buf(err
, _("HEAD does not point to a branch"));
1881 if (!branch
->merge
|| !branch
->merge
[0]) {
1883 * no merge config; is it because the user didn't define any,
1884 * or because it is not a real branch, and get_branch
1887 if (!ref_exists(branch
->refname
))
1888 return error_buf(err
, _("no such branch: '%s'"),
1890 return error_buf(err
,
1891 _("no upstream configured for branch '%s'"),
1895 if (!branch
->merge
[0]->dst
)
1896 return error_buf(err
,
1897 _("upstream branch '%s' not stored as a remote-tracking branch"),
1898 branch
->merge
[0]->src
);
1900 return branch
->merge
[0]->dst
;
1903 static const char *tracking_for_push_dest(struct remote
*remote
,
1904 const char *refname
,
1909 ret
= apply_refspecs(&remote
->fetch
, refname
);
1911 return error_buf(err
,
1912 _("push destination '%s' on remote '%s' has no local tracking branch"),
1913 refname
, remote
->name
);
1917 static const char *branch_get_push_1(struct remote_state
*remote_state
,
1918 struct branch
*branch
, struct strbuf
*err
)
1920 struct remote
*remote
;
1922 remote
= remotes_remote_get(
1924 remotes_pushremote_for_branch(remote_state
, branch
, NULL
));
1926 return error_buf(err
,
1927 _("branch '%s' has no remote for pushing"),
1930 if (remote
->push
.nr
) {
1934 dst
= apply_refspecs(&remote
->push
, branch
->refname
);
1936 return error_buf(err
,
1937 _("push refspecs for '%s' do not include '%s'"),
1938 remote
->name
, branch
->name
);
1940 ret
= tracking_for_push_dest(remote
, dst
, err
);
1946 return tracking_for_push_dest(remote
, branch
->refname
, err
);
1948 switch (push_default
) {
1949 case PUSH_DEFAULT_NOTHING
:
1950 return error_buf(err
, _("push has no destination (push.default is 'nothing')"));
1952 case PUSH_DEFAULT_MATCHING
:
1953 case PUSH_DEFAULT_CURRENT
:
1954 return tracking_for_push_dest(remote
, branch
->refname
, err
);
1956 case PUSH_DEFAULT_UPSTREAM
:
1957 return branch_get_upstream(branch
, err
);
1959 case PUSH_DEFAULT_UNSPECIFIED
:
1960 case PUSH_DEFAULT_SIMPLE
:
1962 const char *up
, *cur
;
1964 up
= branch_get_upstream(branch
, err
);
1967 cur
= tracking_for_push_dest(remote
, branch
->refname
, err
);
1970 if (strcmp(cur
, up
))
1971 return error_buf(err
,
1972 _("cannot resolve 'simple' push to a single destination"));
1977 BUG("unhandled push situation");
1980 const char *branch_get_push(struct branch
*branch
, struct strbuf
*err
)
1982 read_config(the_repository
, 0);
1983 die_on_missing_branch(the_repository
, branch
);
1986 return error_buf(err
, _("HEAD does not point to a branch"));
1988 if (!branch
->push_tracking_ref
)
1989 branch
->push_tracking_ref
= branch_get_push_1(
1990 the_repository
->remote_state
, branch
, err
);
1991 return branch
->push_tracking_ref
;
1994 static int ignore_symref_update(const char *refname
, struct strbuf
*scratch
)
1996 return !refs_read_symbolic_ref(get_main_ref_store(the_repository
), refname
, scratch
);
2000 * Create and return a list of (struct ref) consisting of copies of
2001 * each remote_ref that matches refspec. refspec must be a pattern.
2002 * Fill in the copies' peer_ref to describe the local tracking refs to
2003 * which they map. Omit any references that would map to an existing
2004 * local symbolic ref.
2006 static struct ref
*get_expanded_map(const struct ref
*remote_refs
,
2007 const struct refspec_item
*refspec
)
2009 struct strbuf scratch
= STRBUF_INIT
;
2010 const struct ref
*ref
;
2011 struct ref
*ret
= NULL
;
2012 struct ref
**tail
= &ret
;
2014 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
2015 char *expn_name
= NULL
;
2017 strbuf_reset(&scratch
);
2019 if (strchr(ref
->name
, '^'))
2020 continue; /* a dereference item */
2021 if (match_name_with_pattern(refspec
->src
, ref
->name
,
2022 refspec
->dst
, &expn_name
) &&
2023 !ignore_symref_update(expn_name
, &scratch
)) {
2024 struct ref
*cpy
= copy_ref(ref
);
2026 cpy
->peer_ref
= alloc_ref(expn_name
);
2028 cpy
->peer_ref
->force
= 1;
2035 strbuf_release(&scratch
);
2039 static const struct ref
*find_ref_by_name_abbrev(const struct ref
*refs
, const char *name
)
2041 const struct ref
*ref
;
2042 const struct ref
*best_match
= NULL
;
2045 for (ref
= refs
; ref
; ref
= ref
->next
) {
2046 int score
= refname_match(name
, ref
->name
);
2048 if (best_score
< score
) {
2056 struct ref
*get_remote_ref(const struct ref
*remote_refs
, const char *name
)
2058 const struct ref
*ref
= find_ref_by_name_abbrev(remote_refs
, name
);
2063 return copy_ref(ref
);
2066 static struct ref
*get_local_ref(const char *name
)
2068 if (!name
|| name
[0] == '\0')
2071 if (starts_with(name
, "refs/"))
2072 return alloc_ref(name
);
2074 if (starts_with(name
, "heads/") ||
2075 starts_with(name
, "tags/") ||
2076 starts_with(name
, "remotes/"))
2077 return alloc_ref_with_prefix("refs/", 5, name
);
2079 return alloc_ref_with_prefix("refs/heads/", 11, name
);
2082 int get_fetch_map(const struct ref
*remote_refs
,
2083 const struct refspec_item
*refspec
,
2087 struct ref
*ref_map
, **rmp
;
2089 if (refspec
->negative
)
2092 if (refspec
->pattern
) {
2093 ref_map
= get_expanded_map(remote_refs
, refspec
);
2095 const char *name
= refspec
->src
[0] ? refspec
->src
: "HEAD";
2097 if (refspec
->exact_sha1
) {
2098 ref_map
= alloc_ref(name
);
2099 get_oid_hex(name
, &ref_map
->old_oid
);
2100 ref_map
->exact_oid
= 1;
2102 ref_map
= get_remote_ref(remote_refs
, name
);
2104 if (!missing_ok
&& !ref_map
)
2105 die(_("couldn't find remote ref %s"), name
);
2107 ref_map
->peer_ref
= get_local_ref(refspec
->dst
);
2108 if (ref_map
->peer_ref
&& refspec
->force
)
2109 ref_map
->peer_ref
->force
= 1;
2113 for (rmp
= &ref_map
; *rmp
; ) {
2114 if ((*rmp
)->peer_ref
) {
2115 if (!starts_with((*rmp
)->peer_ref
->name
, "refs/") ||
2116 check_refname_format((*rmp
)->peer_ref
->name
, 0)) {
2117 struct ref
*ignore
= *rmp
;
2118 error(_("* Ignoring funny ref '%s' locally"),
2119 (*rmp
)->peer_ref
->name
);
2120 *rmp
= (*rmp
)->next
;
2121 free(ignore
->peer_ref
);
2126 rmp
= &((*rmp
)->next
);
2130 tail_link_ref(ref_map
, tail
);
2135 int resolve_remote_symref(struct ref
*ref
, struct ref
*list
)
2139 for (; list
; list
= list
->next
)
2140 if (!strcmp(ref
->symref
, list
->name
)) {
2141 oidcpy(&ref
->old_oid
, &list
->old_oid
);
2148 * Compute the commit ahead/behind values for the pair branch_name, base.
2150 * If abf is AHEAD_BEHIND_FULL, compute the full ahead/behind and return the
2151 * counts in *num_ours and *num_theirs. If abf is AHEAD_BEHIND_QUICK, skip
2152 * the (potentially expensive) a/b computation (*num_ours and *num_theirs are
2155 * Returns -1 if num_ours and num_theirs could not be filled in (e.g., ref
2156 * does not exist). Returns 0 if the commits are identical. Returns 1 if
2157 * commits are different.
2160 static int stat_branch_pair(const char *branch_name
, const char *base
,
2161 int *num_ours
, int *num_theirs
,
2162 enum ahead_behind_flags abf
)
2164 struct object_id oid
;
2165 struct commit
*ours
, *theirs
;
2166 struct rev_info revs
;
2167 struct setup_revision_opt opt
= {
2168 .free_removed_argv_elements
= 1,
2170 struct strvec argv
= STRVEC_INIT
;
2172 /* Cannot stat if what we used to build on no longer exists */
2173 if (read_ref(base
, &oid
))
2175 theirs
= lookup_commit_reference(the_repository
, &oid
);
2179 if (read_ref(branch_name
, &oid
))
2181 ours
= lookup_commit_reference(the_repository
, &oid
);
2185 *num_theirs
= *num_ours
= 0;
2187 /* are we the same? */
2190 if (abf
== AHEAD_BEHIND_QUICK
)
2192 if (abf
!= AHEAD_BEHIND_FULL
)
2193 BUG("stat_branch_pair: invalid abf '%d'", abf
);
2195 /* Run "rev-list --left-right ours...theirs" internally... */
2196 strvec_push(&argv
, ""); /* ignored */
2197 strvec_push(&argv
, "--left-right");
2198 strvec_pushf(&argv
, "%s...%s",
2199 oid_to_hex(&ours
->object
.oid
),
2200 oid_to_hex(&theirs
->object
.oid
));
2201 strvec_push(&argv
, "--");
2203 repo_init_revisions(the_repository
, &revs
, NULL
);
2204 setup_revisions(argv
.nr
, argv
.v
, &revs
, &opt
);
2205 if (prepare_revision_walk(&revs
))
2206 die(_("revision walk setup failed"));
2208 /* ... and count the commits on each side. */
2210 struct commit
*c
= get_revision(&revs
);
2213 if (c
->object
.flags
& SYMMETRIC_LEFT
)
2219 /* clear object flags smudged by the above traversal */
2220 clear_commit_marks(ours
, ALL_REV_FLAGS
);
2221 clear_commit_marks(theirs
, ALL_REV_FLAGS
);
2223 strvec_clear(&argv
);
2224 release_revisions(&revs
);
2229 * Lookup the tracking branch for the given branch and if present, optionally
2230 * compute the commit ahead/behind values for the pair.
2232 * If for_push is true, the tracking branch refers to the push branch,
2233 * otherwise it refers to the upstream branch.
2235 * The name of the tracking branch (or NULL if it is not defined) is
2236 * returned via *tracking_name, if it is not itself NULL.
2238 * If abf is AHEAD_BEHIND_FULL, compute the full ahead/behind and return the
2239 * counts in *num_ours and *num_theirs. If abf is AHEAD_BEHIND_QUICK, skip
2240 * the (potentially expensive) a/b computation (*num_ours and *num_theirs are
2243 * Returns -1 if num_ours and num_theirs could not be filled in (e.g., no
2244 * upstream defined, or ref does not exist). Returns 0 if the commits are
2245 * identical. Returns 1 if commits are different.
2247 int stat_tracking_info(struct branch
*branch
, int *num_ours
, int *num_theirs
,
2248 const char **tracking_name
, int for_push
,
2249 enum ahead_behind_flags abf
)
2253 /* Cannot stat unless we are marked to build on top of somebody else. */
2254 base
= for_push
? branch_get_push(branch
, NULL
) :
2255 branch_get_upstream(branch
, NULL
);
2257 *tracking_name
= base
;
2261 return stat_branch_pair(branch
->refname
, base
, num_ours
, num_theirs
, abf
);
2265 * Return true when there is anything to report, otherwise false.
2267 int format_tracking_info(struct branch
*branch
, struct strbuf
*sb
,
2268 enum ahead_behind_flags abf
,
2269 int show_divergence_advice
)
2271 int ours
, theirs
, sti
;
2272 const char *full_base
;
2274 int upstream_is_gone
= 0;
2276 sti
= stat_tracking_info(branch
, &ours
, &theirs
, &full_base
, 0, abf
);
2280 upstream_is_gone
= 1;
2283 base
= shorten_unambiguous_ref(full_base
, 0);
2284 if (upstream_is_gone
) {
2286 _("Your branch is based on '%s', but the upstream is gone.\n"),
2288 if (advice_enabled(ADVICE_STATUS_HINTS
))
2290 _(" (use \"git branch --unset-upstream\" to fixup)\n"));
2293 _("Your branch is up to date with '%s'.\n"),
2295 } else if (abf
== AHEAD_BEHIND_QUICK
) {
2297 _("Your branch and '%s' refer to different commits.\n"),
2299 if (advice_enabled(ADVICE_STATUS_HINTS
))
2300 strbuf_addf(sb
, _(" (use \"%s\" for details)\n"),
2301 "git status --ahead-behind");
2302 } else if (!theirs
) {
2304 Q_("Your branch is ahead of '%s' by %d commit.\n",
2305 "Your branch is ahead of '%s' by %d commits.\n",
2308 if (advice_enabled(ADVICE_STATUS_HINTS
))
2310 _(" (use \"git push\" to publish your local commits)\n"));
2313 Q_("Your branch is behind '%s' by %d commit, "
2314 "and can be fast-forwarded.\n",
2315 "Your branch is behind '%s' by %d commits, "
2316 "and can be fast-forwarded.\n",
2319 if (advice_enabled(ADVICE_STATUS_HINTS
))
2321 _(" (use \"git pull\" to update your local branch)\n"));
2324 Q_("Your branch and '%s' have diverged,\n"
2325 "and have %d and %d different commit each, "
2327 "Your branch and '%s' have diverged,\n"
2328 "and have %d and %d different commits each, "
2331 base
, ours
, theirs
);
2332 if (show_divergence_advice
&&
2333 advice_enabled(ADVICE_STATUS_HINTS
))
2335 _(" (use \"git pull\" if you want to integrate the remote branch with yours)\n"));
2341 static int one_local_ref(const char *refname
, const struct object_id
*oid
,
2345 struct ref
***local_tail
= cb_data
;
2348 /* we already know it starts with refs/ to get here */
2349 if (check_refname_format(refname
+ 5, 0))
2352 ref
= alloc_ref(refname
);
2353 oidcpy(&ref
->new_oid
, oid
);
2355 *local_tail
= &ref
->next
;
2359 struct ref
*get_local_heads(void)
2361 struct ref
*local_refs
= NULL
, **local_tail
= &local_refs
;
2363 for_each_ref(one_local_ref
, &local_tail
);
2367 struct ref
*guess_remote_head(const struct ref
*head
,
2368 const struct ref
*refs
,
2371 const struct ref
*r
;
2372 struct ref
*list
= NULL
;
2373 struct ref
**tail
= &list
;
2379 * Some transports support directly peeking at
2380 * where HEAD points; if that is the case, then
2381 * we don't have to guess.
2384 return copy_ref(find_ref_by_name(refs
, head
->symref
));
2386 /* If a remote branch exists with the default branch name, let's use it. */
2388 char *ref
= xstrfmt("refs/heads/%s",
2389 git_default_branch_name(0));
2391 r
= find_ref_by_name(refs
, ref
);
2393 if (r
&& oideq(&r
->old_oid
, &head
->old_oid
))
2396 /* Fall back to the hard-coded historical default */
2397 r
= find_ref_by_name(refs
, "refs/heads/master");
2398 if (r
&& oideq(&r
->old_oid
, &head
->old_oid
))
2402 /* Look for another ref that points there */
2403 for (r
= refs
; r
; r
= r
->next
) {
2405 starts_with(r
->name
, "refs/heads/") &&
2406 oideq(&r
->old_oid
, &head
->old_oid
)) {
2407 *tail
= copy_ref(r
);
2408 tail
= &((*tail
)->next
);
2417 struct stale_heads_info
{
2418 struct string_list
*ref_names
;
2419 struct ref
**stale_refs_tail
;
2423 static int get_stale_heads_cb(const char *refname
, const struct object_id
*oid
,
2424 int flags
, void *cb_data
)
2426 struct stale_heads_info
*info
= cb_data
;
2427 struct string_list matches
= STRING_LIST_INIT_DUP
;
2428 struct refspec_item query
;
2430 memset(&query
, 0, sizeof(struct refspec_item
));
2431 query
.dst
= (char *)refname
;
2433 query_refspecs_multiple(info
->rs
, &query
, &matches
);
2434 if (matches
.nr
== 0)
2435 goto clean_exit
; /* No matches */
2438 * If we did find a suitable refspec and it's not a symref and
2439 * it's not in the list of refs that currently exist in that
2440 * remote, we consider it to be stale. In order to deal with
2441 * overlapping refspecs, we need to go over all of the
2444 if (flags
& REF_ISSYMREF
)
2447 for (i
= 0; stale
&& i
< matches
.nr
; i
++)
2448 if (string_list_has_string(info
->ref_names
, matches
.items
[i
].string
))
2452 struct ref
*ref
= make_linked_ref(refname
, &info
->stale_refs_tail
);
2453 oidcpy(&ref
->new_oid
, oid
);
2457 string_list_clear(&matches
, 0);
2461 struct ref
*get_stale_heads(struct refspec
*rs
, struct ref
*fetch_map
)
2463 struct ref
*ref
, *stale_refs
= NULL
;
2464 struct string_list ref_names
= STRING_LIST_INIT_NODUP
;
2465 struct stale_heads_info info
;
2467 info
.ref_names
= &ref_names
;
2468 info
.stale_refs_tail
= &stale_refs
;
2470 for (ref
= fetch_map
; ref
; ref
= ref
->next
)
2471 string_list_append(&ref_names
, ref
->name
);
2472 string_list_sort(&ref_names
);
2473 for_each_ref(get_stale_heads_cb
, &info
);
2474 string_list_clear(&ref_names
, 0);
2481 static void clear_cas_option(struct push_cas_option
*cas
)
2485 for (i
= 0; i
< cas
->nr
; i
++)
2486 free(cas
->entry
[i
].refname
);
2488 memset(cas
, 0, sizeof(*cas
));
2491 static struct push_cas
*add_cas_entry(struct push_cas_option
*cas
,
2492 const char *refname
,
2495 struct push_cas
*entry
;
2496 ALLOC_GROW(cas
->entry
, cas
->nr
+ 1, cas
->alloc
);
2497 entry
= &cas
->entry
[cas
->nr
++];
2498 memset(entry
, 0, sizeof(*entry
));
2499 entry
->refname
= xmemdupz(refname
, refnamelen
);
2503 static int parse_push_cas_option(struct push_cas_option
*cas
, const char *arg
, int unset
)
2506 struct push_cas
*entry
;
2509 /* "--no-<option>" */
2510 clear_cas_option(cas
);
2515 /* just "--<option>" */
2516 cas
->use_tracking_for_rest
= 1;
2520 /* "--<option>=refname" or "--<option>=refname:value" */
2521 colon
= strchrnul(arg
, ':');
2522 entry
= add_cas_entry(cas
, arg
, colon
- arg
);
2524 entry
->use_tracking
= 1;
2526 oidclr(&entry
->expect
);
2527 else if (repo_get_oid(the_repository
, colon
+ 1, &entry
->expect
))
2528 return error(_("cannot parse expected object name '%s'"),
2533 int parseopt_push_cas_option(const struct option
*opt
, const char *arg
, int unset
)
2535 return parse_push_cas_option(opt
->value
, arg
, unset
);
2538 int is_empty_cas(const struct push_cas_option
*cas
)
2540 return !cas
->use_tracking_for_rest
&& !cas
->nr
;
2544 * Look at remote.fetch refspec and see if we have a remote
2545 * tracking branch for the refname there. Fill the name of
2546 * the remote-tracking branch in *dst_refname, and the name
2547 * of the commit object at its tip in oid[].
2548 * If we cannot do so, return negative to signal an error.
2550 static int remote_tracking(struct remote
*remote
, const char *refname
,
2551 struct object_id
*oid
, char **dst_refname
)
2555 dst
= apply_refspecs(&remote
->fetch
, refname
);
2557 return -1; /* no tracking ref for refname at remote */
2558 if (read_ref(dst
, oid
))
2559 return -1; /* we know what the tracking ref is but we cannot read it */
2566 * The struct "reflog_commit_array" and related helper functions
2567 * are used for collecting commits into an array during reflog
2568 * traversals in "check_and_collect_until()".
2570 struct reflog_commit_array
{
2571 struct commit
**item
;
2575 #define REFLOG_COMMIT_ARRAY_INIT { 0 }
2577 /* Append a commit to the array. */
2578 static void append_commit(struct reflog_commit_array
*arr
,
2579 struct commit
*commit
)
2581 ALLOC_GROW(arr
->item
, arr
->nr
+ 1, arr
->alloc
);
2582 arr
->item
[arr
->nr
++] = commit
;
2585 /* Free and reset the array. */
2586 static void free_commit_array(struct reflog_commit_array
*arr
)
2588 FREE_AND_NULL(arr
->item
);
2589 arr
->nr
= arr
->alloc
= 0;
2592 struct check_and_collect_until_cb_data
{
2593 struct commit
*remote_commit
;
2594 struct reflog_commit_array
*local_commits
;
2595 timestamp_t remote_reflog_timestamp
;
2598 /* Get the timestamp of the latest entry. */
2599 static int peek_reflog(struct object_id
*o_oid UNUSED
,
2600 struct object_id
*n_oid UNUSED
,
2601 const char *ident UNUSED
,
2602 timestamp_t timestamp
, int tz UNUSED
,
2603 const char *message UNUSED
, void *cb_data
)
2605 timestamp_t
*ts
= cb_data
;
2610 static int check_and_collect_until(struct object_id
*o_oid UNUSED
,
2611 struct object_id
*n_oid
,
2612 const char *ident UNUSED
,
2613 timestamp_t timestamp
, int tz UNUSED
,
2614 const char *message UNUSED
, void *cb_data
)
2616 struct commit
*commit
;
2617 struct check_and_collect_until_cb_data
*cb
= cb_data
;
2619 /* An entry was found. */
2620 if (oideq(n_oid
, &cb
->remote_commit
->object
.oid
))
2623 if ((commit
= lookup_commit_reference(the_repository
, n_oid
)))
2624 append_commit(cb
->local_commits
, commit
);
2627 * If the reflog entry timestamp is older than the remote ref's
2628 * latest reflog entry, there is no need to check or collect
2629 * entries older than this one.
2631 if (timestamp
< cb
->remote_reflog_timestamp
)
2637 #define MERGE_BASES_BATCH_SIZE 8
2640 * Iterate through the reflog of the local ref to check if there is an entry
2641 * for the given remote-tracking ref; runs until the timestamp of an entry is
2642 * older than latest timestamp of remote-tracking ref's reflog. Any commits
2643 * are that seen along the way are collected into an array to check if the
2644 * remote-tracking ref is reachable from any of them.
2646 static int is_reachable_in_reflog(const char *local
, const struct ref
*remote
)
2649 struct commit
*commit
;
2650 struct commit
**chunk
;
2651 struct check_and_collect_until_cb_data cb
;
2652 struct reflog_commit_array arr
= REFLOG_COMMIT_ARRAY_INIT
;
2656 commit
= lookup_commit_reference(the_repository
, &remote
->old_oid
);
2658 goto cleanup_return
;
2661 * Get the timestamp from the latest entry
2662 * of the remote-tracking ref's reflog.
2664 for_each_reflog_ent_reverse(remote
->tracking_ref
, peek_reflog
, &date
);
2666 cb
.remote_commit
= commit
;
2667 cb
.local_commits
= &arr
;
2668 cb
.remote_reflog_timestamp
= date
;
2669 ret
= for_each_reflog_ent_reverse(local
, check_and_collect_until
, &cb
);
2671 /* We found an entry in the reflog. */
2673 goto cleanup_return
;
2676 * Check if the remote commit is reachable from any
2677 * of the commits in the collected array, in batches.
2679 for (chunk
= arr
.item
; chunk
< arr
.item
+ arr
.nr
; chunk
+= size
) {
2680 size
= arr
.item
+ arr
.nr
- chunk
;
2681 if (MERGE_BASES_BATCH_SIZE
< size
)
2682 size
= MERGE_BASES_BATCH_SIZE
;
2684 if ((ret
= repo_in_merge_bases_many(the_repository
, commit
, size
, chunk
)))
2689 free_commit_array(&arr
);
2694 * Check for reachability of a remote-tracking
2695 * ref in the reflog entries of its local ref.
2697 static void check_if_includes_upstream(struct ref
*remote
)
2699 struct ref
*local
= get_local_ref(remote
->name
);
2703 if (is_reachable_in_reflog(local
->name
, remote
) <= 0)
2704 remote
->unreachable
= 1;
2707 static void apply_cas(struct push_cas_option
*cas
,
2708 struct remote
*remote
,
2713 /* Find an explicit --<option>=<name>[:<value>] entry */
2714 for (i
= 0; i
< cas
->nr
; i
++) {
2715 struct push_cas
*entry
= &cas
->entry
[i
];
2716 if (!refname_match(entry
->refname
, ref
->name
))
2718 ref
->expect_old_sha1
= 1;
2719 if (!entry
->use_tracking
)
2720 oidcpy(&ref
->old_oid_expect
, &entry
->expect
);
2721 else if (remote_tracking(remote
, ref
->name
,
2722 &ref
->old_oid_expect
,
2723 &ref
->tracking_ref
))
2724 oidclr(&ref
->old_oid_expect
);
2726 ref
->check_reachable
= cas
->use_force_if_includes
;
2730 /* Are we using "--<option>" to cover all? */
2731 if (!cas
->use_tracking_for_rest
)
2734 ref
->expect_old_sha1
= 1;
2735 if (remote_tracking(remote
, ref
->name
,
2736 &ref
->old_oid_expect
,
2737 &ref
->tracking_ref
))
2738 oidclr(&ref
->old_oid_expect
);
2740 ref
->check_reachable
= cas
->use_force_if_includes
;
2743 void apply_push_cas(struct push_cas_option
*cas
,
2744 struct remote
*remote
,
2745 struct ref
*remote_refs
)
2748 for (ref
= remote_refs
; ref
; ref
= ref
->next
) {
2749 apply_cas(cas
, remote
, ref
);
2752 * If "compare-and-swap" is in "use_tracking[_for_rest]"
2753 * mode, and if "--force-if-includes" was specified, run
2756 if (ref
->check_reachable
)
2757 check_if_includes_upstream(ref
);
2761 struct remote_state
*remote_state_new(void)
2763 struct remote_state
*r
= xmalloc(sizeof(*r
));
2765 memset(r
, 0, sizeof(*r
));
2767 hashmap_init(&r
->remotes_hash
, remotes_hash_cmp
, NULL
, 0);
2768 hashmap_init(&r
->branches_hash
, branches_hash_cmp
, NULL
, 0);
2772 void remote_state_clear(struct remote_state
*remote_state
)
2776 for (i
= 0; i
< remote_state
->remotes_nr
; i
++)
2777 remote_clear(remote_state
->remotes
[i
]);
2778 FREE_AND_NULL(remote_state
->remotes
);
2779 remote_state
->remotes_alloc
= 0;
2780 remote_state
->remotes_nr
= 0;
2782 hashmap_clear_and_free(&remote_state
->remotes_hash
, struct remote
, ent
);
2783 hashmap_clear_and_free(&remote_state
->branches_hash
, struct remote
, ent
);
2787 * Returns 1 if it was the last chop before ':'.
2789 static int chop_last_dir(char **remoteurl
, int is_relative
)
2791 char *rfind
= find_last_dir_sep(*remoteurl
);
2797 rfind
= strrchr(*remoteurl
, ':');
2803 if (is_relative
|| !strcmp(".", *remoteurl
))
2804 die(_("cannot strip one component off url '%s'"),
2808 *remoteurl
= xstrdup(".");
2812 char *relative_url(const char *remote_url
, const char *url
,
2813 const char *up_path
)
2815 int is_relative
= 0;
2819 struct strbuf sb
= STRBUF_INIT
;
2822 if (!url_is_local_not_ssh(url
) || is_absolute_path(url
))
2823 return xstrdup(url
);
2825 len
= strlen(remote_url
);
2827 BUG("invalid empty remote_url");
2829 remoteurl
= xstrdup(remote_url
);
2830 if (is_dir_sep(remoteurl
[len
-1]))
2831 remoteurl
[len
-1] = '\0';
2833 if (!url_is_local_not_ssh(remoteurl
) || is_absolute_path(remoteurl
))
2838 * Prepend a './' to ensure all relative
2839 * remoteurls start with './' or '../'
2841 if (!starts_with_dot_slash_native(remoteurl
) &&
2842 !starts_with_dot_dot_slash_native(remoteurl
)) {
2844 strbuf_addf(&sb
, "./%s", remoteurl
);
2846 remoteurl
= strbuf_detach(&sb
, NULL
);
2850 * When the url starts with '../', remove that and the
2851 * last directory in remoteurl.
2854 if (starts_with_dot_dot_slash_native(url
)) {
2856 colonsep
|= chop_last_dir(&remoteurl
, is_relative
);
2857 } else if (starts_with_dot_slash_native(url
))
2863 strbuf_addf(&sb
, "%s%s%s", remoteurl
, colonsep
? ":" : "/", url
);
2864 if (ends_with(url
, "/"))
2865 strbuf_setlen(&sb
, sb
.len
- 1);
2868 if (starts_with_dot_slash_native(sb
.buf
))
2869 out
= xstrdup(sb
.buf
+ 2);
2871 out
= xstrdup(sb
.buf
);
2873 if (!up_path
|| !is_relative
) {
2874 strbuf_release(&sb
);
2879 strbuf_addf(&sb
, "%s%s", up_path
, out
);
2881 return strbuf_detach(&sb
, NULL
);