Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 1 | #ifndef REMOTE_H |
| 2 | #define REMOTE_H |
| 3 | |
Elijah Newren | b9a7ac2 | 2023-05-16 06:34:07 +0000 | [diff] [blame] | 4 | #include "hash-ll.h" |
Patrick Reynolds | d0da003 | 2014-07-29 14:43:39 +0000 | [diff] [blame] | 5 | #include "hashmap.h" |
Brandon Williams | 6bdb304 | 2018-05-16 15:58:00 -0700 | [diff] [blame] | 6 | #include "refspec.h" |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 7 | |
SZEDER Gábor | c4d9c79 | 2023-03-19 17:27:12 +0100 | [diff] [blame] | 8 | struct option; |
Jonathan Tan | 3983540 | 2021-02-05 12:48:48 -0800 | [diff] [blame] | 9 | struct transport_ls_refs_options; |
| 10 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 11 | /** |
| 12 | * The API gives access to the configuration related to remotes. It handles |
| 13 | * all three configuration mechanisms historically and currently used by Git, |
| 14 | * and presents the information in a uniform fashion. Note that the code also |
| 15 | * handles plain URLs without any configuration, giving them just the default |
| 16 | * information. |
| 17 | */ |
| 18 | |
Miklos Vajna | 89cf4c7 | 2008-11-10 21:43:00 +0100 | [diff] [blame] | 19 | enum { |
Thomas Gummerer | 674468b | 2016-02-16 10:47:50 +0100 | [diff] [blame] | 20 | REMOTE_UNCONFIGURED = 0, |
Miklos Vajna | 89cf4c7 | 2008-11-10 21:43:00 +0100 | [diff] [blame] | 21 | REMOTE_CONFIG, |
| 22 | REMOTE_REMOTES, |
| 23 | REMOTE_BRANCHES |
| 24 | }; |
| 25 | |
Glen Choo | fd3cb05 | 2021-11-17 16:53:22 -0800 | [diff] [blame] | 26 | struct rewrite { |
| 27 | const char *base; |
| 28 | size_t baselen; |
| 29 | struct counted_string *instead_of; |
| 30 | int instead_of_nr; |
| 31 | int instead_of_alloc; |
| 32 | }; |
| 33 | |
| 34 | struct rewrites { |
| 35 | struct rewrite **rewrite; |
| 36 | int rewrite_alloc; |
| 37 | int rewrite_nr; |
| 38 | }; |
| 39 | |
| 40 | struct remote_state { |
| 41 | struct remote **remotes; |
| 42 | int remotes_alloc; |
| 43 | int remotes_nr; |
| 44 | struct hashmap remotes_hash; |
| 45 | |
Glen Choo | 4a2dcb1 | 2021-11-17 16:53:25 -0800 | [diff] [blame] | 46 | struct hashmap branches_hash; |
Glen Choo | fd3cb05 | 2021-11-17 16:53:22 -0800 | [diff] [blame] | 47 | |
| 48 | struct branch *current_branch; |
| 49 | const char *pushremote_name; |
| 50 | |
| 51 | struct rewrites rewrites; |
| 52 | struct rewrites rewrites_push; |
Glen Choo | 085b98f | 2021-11-17 16:53:23 -0800 | [diff] [blame] | 53 | |
| 54 | int initialized; |
Glen Choo | fd3cb05 | 2021-11-17 16:53:22 -0800 | [diff] [blame] | 55 | }; |
| 56 | |
| 57 | void remote_state_clear(struct remote_state *remote_state); |
| 58 | struct remote_state *remote_state_new(void); |
| 59 | |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 60 | struct remote { |
Eric Wong | e2b5038 | 2019-10-06 23:30:43 +0000 | [diff] [blame] | 61 | struct hashmap_entry ent; |
Patrick Reynolds | d0da003 | 2014-07-29 14:43:39 +0000 | [diff] [blame] | 62 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 63 | /* The user's nickname for the remote */ |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 64 | const char *name; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 65 | |
Johannes Schindelin | e459b07 | 2017-01-19 22:20:02 +0100 | [diff] [blame] | 66 | int origin, configured_in_repo; |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 67 | |
Daniel Barkalow | c578f51 | 2009-11-18 02:42:25 +0100 | [diff] [blame] | 68 | const char *foreign_vcs; |
| 69 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 70 | /* An array of all of the url_nr URLs configured for the remote */ |
Shawn O. Pearce | 28b91f8 | 2007-09-19 00:49:27 -0400 | [diff] [blame] | 71 | const char **url; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 72 | |
Shawn O. Pearce | 28b91f8 | 2007-09-19 00:49:27 -0400 | [diff] [blame] | 73 | int url_nr; |
Daniel Barkalow | 2d31347 | 2008-02-18 23:41:41 -0500 | [diff] [blame] | 74 | int url_alloc; |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 75 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 76 | /* An array of all of the pushurl_nr push URLs configured for the remote */ |
Michael J Gruber | 2034623 | 2009-06-09 18:01:34 +0200 | [diff] [blame] | 77 | const char **pushurl; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 78 | |
Michael J Gruber | 2034623 | 2009-06-09 18:01:34 +0200 | [diff] [blame] | 79 | int pushurl_nr; |
| 80 | int pushurl_alloc; |
| 81 | |
Brandon Williams | 6bdb304 | 2018-05-16 15:58:00 -0700 | [diff] [blame] | 82 | struct refspec push; |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 83 | |
Brandon Williams | e5349ab | 2018-05-16 15:58:01 -0700 | [diff] [blame] | 84 | struct refspec fetch; |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 85 | |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 86 | /* |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 87 | * The setting for whether to fetch tags (as a separate rule from the |
| 88 | * configured refspecs); |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 89 | * -1 to never fetch tags |
| 90 | * 0 to auto-follow tags on heuristic (default) |
| 91 | * 1 to always auto-follow tags |
| 92 | * 2 to always fetch tags |
| 93 | */ |
| 94 | int fetch_tags; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 95 | |
Johannes Schindelin | 211c896 | 2008-02-29 01:45:45 +0000 | [diff] [blame] | 96 | int skip_default_update; |
Paolo Bonzini | 84bb2df | 2008-04-17 13:17:20 +0200 | [diff] [blame] | 97 | int mirror; |
Michael Schubert | 737c5a9 | 2013-07-13 11:36:24 +0200 | [diff] [blame] | 98 | int prune; |
Ævar Arnfjörð Bjarmason | 97716d2 | 2018-02-09 20:32:15 +0000 | [diff] [blame] | 99 | int prune_tags; |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 100 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 101 | /** |
| 102 | * The configured helper programs to run on the remote side, for |
| 103 | * Git-native protocols. |
| 104 | */ |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 105 | const char *receivepack; |
Daniel Barkalow | 0012ba2 | 2007-09-10 23:02:51 -0400 | [diff] [blame] | 106 | const char *uploadpack; |
Sam Vilain | 14c9821 | 2007-12-04 10:48:54 +1300 | [diff] [blame] | 107 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 108 | /* The proxy to use for curl (http, https, ftp, etc.) URLs. */ |
Sam Vilain | 14c9821 | 2007-12-04 10:48:54 +1300 | [diff] [blame] | 109 | char *http_proxy; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 110 | |
| 111 | /* The method used for authenticating against `http_proxy`. */ |
Knut Franke | ef97639 | 2016-01-26 13:02:47 +0000 | [diff] [blame] | 112 | char *http_proxy_authmethod; |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 113 | }; |
| 114 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 115 | /** |
| 116 | * struct remotes can be found by name with remote_get(). |
| 117 | * remote_get(NULL) will return the default remote, given the current branch |
| 118 | * and configuration. |
| 119 | */ |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 120 | struct remote *remote_get(const char *name); |
Patrick Steinhardt | 3c8f60c | 2023-12-12 08:01:03 +0100 | [diff] [blame] | 121 | struct remote *remote_get_early(const char *name); |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 122 | |
Ramkumar Ramachandra | f24f715 | 2013-04-02 13:10:32 +0530 | [diff] [blame] | 123 | struct remote *pushremote_get(const char *name); |
Johannes Schindelin | e459b07 | 2017-01-19 22:20:02 +0100 | [diff] [blame] | 124 | int remote_is_configured(struct remote *remote, int in_repo); |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 125 | |
Johannes Schindelin | b42f692 | 2007-07-10 18:48:40 +0100 | [diff] [blame] | 126 | typedef int each_remote_fn(struct remote *remote, void *priv); |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 127 | |
| 128 | /* iterate through struct remotes */ |
Johannes Schindelin | b42f692 | 2007-07-10 18:48:40 +0100 | [diff] [blame] | 129 | int for_each_remote(each_remote_fn fn, void *priv); |
| 130 | |
Shawn O. Pearce | 28b91f8 | 2007-09-19 00:49:27 -0400 | [diff] [blame] | 131 | int remote_has_url(struct remote *remote, const char *url); |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 132 | |
Jiang Xin | 15d3af5 | 2020-08-27 11:45:44 -0400 | [diff] [blame] | 133 | struct ref_push_report { |
| 134 | const char *ref_name; |
| 135 | struct object_id *old_oid; |
| 136 | struct object_id *new_oid; |
| 137 | unsigned int forced_update:1; |
| 138 | struct ref_push_report *next; |
| 139 | }; |
| 140 | |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 141 | struct ref { |
| 142 | struct ref *next; |
brian m. carlson | f4e54d0 | 2015-11-10 02:22:20 +0000 | [diff] [blame] | 143 | struct object_id old_oid; |
| 144 | struct object_id new_oid; |
| 145 | struct object_id old_oid_expect; /* used by expect-old */ |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 146 | char *symref; |
Srinidhi Kaushik | 99a1f9a | 2020-10-03 17:40:44 +0530 | [diff] [blame] | 147 | char *tracking_ref; |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 148 | unsigned int |
| 149 | force:1, |
| 150 | forced_update:1, |
Junio C Hamano | 91048a9 | 2013-07-09 11:01:06 -0700 | [diff] [blame] | 151 | expect_old_sha1:1, |
Brandon Williams | 7330205 | 2018-06-27 15:30:23 -0700 | [diff] [blame] | 152 | exact_oid:1, |
Srinidhi Kaushik | 99a1f9a | 2020-10-03 17:40:44 +0530 | [diff] [blame] | 153 | deletion:1, |
| 154 | /* Need to check if local reflog reaches the remote tip. */ |
| 155 | check_reachable:1, |
| 156 | /* |
| 157 | * Store the result of the check enabled by "check_reachable"; |
| 158 | * implies the local reflog does not reach the remote tip. |
| 159 | */ |
| 160 | unreachable:1; |
Matt McCutchen | d56583d | 2017-02-22 11:05:57 -0500 | [diff] [blame] | 161 | |
| 162 | enum { |
| 163 | REF_NOT_MATCHED = 0, /* initial value */ |
| 164 | REF_MATCHED, |
| 165 | REF_UNADVERTISED_NOT_ALLOWED |
| 166 | } match_status; |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 167 | |
| 168 | /* |
| 169 | * Order is important here, as we write to FETCH_HEAD |
| 170 | * in numeric order. And the default NOT_FOR_MERGE |
| 171 | * should be 0, so that xcalloc'd structures get it |
| 172 | * by default. |
| 173 | */ |
Patrick Steinhardt | 58a646a | 2021-01-12 13:27:35 +0100 | [diff] [blame] | 174 | enum fetch_head_status { |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 175 | FETCH_HEAD_MERGE = -1, |
| 176 | FETCH_HEAD_NOT_FOR_MERGE = 0, |
| 177 | FETCH_HEAD_IGNORE = 1 |
| 178 | } fetch_head_status; |
| 179 | |
| 180 | enum { |
| 181 | REF_STATUS_NONE = 0, |
| 182 | REF_STATUS_OK, |
| 183 | REF_STATUS_REJECT_NONFASTFORWARD, |
| 184 | REF_STATUS_REJECT_ALREADY_EXISTS, |
| 185 | REF_STATUS_REJECT_NODELETE, |
| 186 | REF_STATUS_REJECT_FETCH_FIRST, |
| 187 | REF_STATUS_REJECT_NEEDS_FORCE, |
Junio C Hamano | 631b5ef | 2013-07-08 14:42:40 -0700 | [diff] [blame] | 188 | REF_STATUS_REJECT_STALE, |
Nguyễn Thái Ngọc Duy | 4820a33 | 2013-12-05 20:02:40 +0700 | [diff] [blame] | 189 | REF_STATUS_REJECT_SHALLOW, |
Srinidhi Kaushik | 99a1f9a | 2020-10-03 17:40:44 +0530 | [diff] [blame] | 190 | REF_STATUS_REJECT_REMOTE_UPDATED, |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 191 | REF_STATUS_UPTODATE, |
| 192 | REF_STATUS_REMOTE_REJECT, |
Ronnie Sahlberg | 4ff17f1 | 2015-01-07 19:23:22 -0800 | [diff] [blame] | 193 | REF_STATUS_EXPECTING_REPORT, |
| 194 | REF_STATUS_ATOMIC_PUSH_FAILED |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 195 | } status; |
| 196 | char *remote_status; |
Jiang Xin | 63518a5 | 2020-08-27 11:45:46 -0400 | [diff] [blame] | 197 | struct ref_push_report *report; |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 198 | struct ref *peer_ref; /* when renaming */ |
| 199 | char name[FLEX_ARRAY]; /* more */ |
| 200 | }; |
| 201 | |
| 202 | #define REF_NORMAL (1u << 0) |
| 203 | #define REF_HEADS (1u << 1) |
| 204 | #define REF_TAGS (1u << 2) |
| 205 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 206 | struct ref *find_ref_by_name(const struct ref *list, const char *name); |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 207 | |
René Scharfe | 59c69c0 | 2008-10-18 10:44:18 +0200 | [diff] [blame] | 208 | struct ref *alloc_ref(const char *name); |
Jeff King | 59a5775 | 2011-06-07 19:03:03 -0400 | [diff] [blame] | 209 | struct ref *copy_ref(const struct ref *ref); |
Daniel Barkalow | 4577370 | 2007-10-29 21:05:40 -0400 | [diff] [blame] | 210 | struct ref *copy_ref_list(const struct ref *ref); |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 211 | int count_refspec_match(const char *, struct ref *refs, struct ref **matched_ref); |
Daniel Barkalow | 4577370 | 2007-10-29 21:05:40 -0400 | [diff] [blame] | 212 | |
| 213 | int check_ref_type(const struct ref *ref, int flags); |
| 214 | |
Daniel Barkalow | dfd255d | 2007-07-10 00:47:23 -0400 | [diff] [blame] | 215 | /* |
Jeff King | 1027186 | 2019-04-13 01:54:31 -0400 | [diff] [blame] | 216 | * Free a single ref and its peer, or an entire list of refs and their peers, |
| 217 | * respectively. |
Daniel Barkalow | dfd255d | 2007-07-10 00:47:23 -0400 | [diff] [blame] | 218 | */ |
Jeff King | 1027186 | 2019-04-13 01:54:31 -0400 | [diff] [blame] | 219 | void free_one_ref(struct ref *ref); |
Daniel Barkalow | dfd255d | 2007-07-10 00:47:23 -0400 | [diff] [blame] | 220 | void free_refs(struct ref *ref); |
| 221 | |
brian m. carlson | 910650d | 2017-03-31 01:40:00 +0000 | [diff] [blame] | 222 | struct oid_array; |
Brandon Williams | ad6ac12 | 2018-03-14 11:31:45 -0700 | [diff] [blame] | 223 | struct packet_reader; |
Jeff King | 873cd28 | 2020-07-28 16:23:25 -0400 | [diff] [blame] | 224 | struct strvec; |
Brandon Williams | ff47322 | 2018-04-23 15:46:23 -0700 | [diff] [blame] | 225 | struct string_list; |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 226 | struct ref **get_remote_heads(struct packet_reader *reader, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 227 | struct ref **list, unsigned int flags, |
| 228 | struct oid_array *extra_have, |
| 229 | struct oid_array *shallow_points); |
Junio C Hamano | 47a5918 | 2013-07-08 13:56:53 -0700 | [diff] [blame] | 230 | |
Brandon Williams | e52449b | 2018-03-15 10:31:21 -0700 | [diff] [blame] | 231 | /* Used for protocol v2 in order to retrieve refs from a remote */ |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 232 | struct ref **get_remote_refs(int fd_out, struct packet_reader *reader, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 233 | struct ref **list, int for_push, |
Jonathan Tan | 3983540 | 2021-02-05 12:48:48 -0800 | [diff] [blame] | 234 | struct transport_ls_refs_options *transport_options, |
Denton Liu | b0df0c1 | 2020-05-19 06:54:00 -0400 | [diff] [blame] | 235 | const struct string_list *server_options, |
| 236 | int stateless_rpc); |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 237 | |
Ævar Arnfjörð Bjarmason | 0cfde74 | 2022-12-22 15:14:09 +0000 | [diff] [blame] | 238 | /* Used for protocol v2 in order to retrieve refs from a remote */ |
| 239 | struct bundle_list; |
| 240 | int get_remote_bundle_uri(int fd_out, struct packet_reader *reader, |
| 241 | struct bundle_list *bundles, int stateless_rpc); |
| 242 | |
Daniel Barkalow | be885d9 | 2008-04-26 15:53:12 -0400 | [diff] [blame] | 243 | int resolve_remote_symref(struct ref *ref, struct ref *list); |
| 244 | |
Daniel Barkalow | 2467a4f | 2007-10-08 00:25:07 -0400 | [diff] [blame] | 245 | /* |
Michael Haggerty | b9afe66 | 2013-10-30 06:33:09 +0100 | [diff] [blame] | 246 | * Remove and free all but the first of any entries in the input list |
| 247 | * that map the same remote reference to the same local reference. If |
| 248 | * there are two entries that map different remote references to the |
| 249 | * same local reference, emit an error message and die. Return a |
| 250 | * pointer to the head of the resulting list. |
Daniel Barkalow | 2467a4f | 2007-10-08 00:25:07 -0400 | [diff] [blame] | 251 | */ |
Michael Haggerty | b9afe66 | 2013-10-30 06:33:09 +0100 | [diff] [blame] | 252 | struct ref *ref_remove_duplicates(struct ref *ref_map); |
Daniel Barkalow | 2467a4f | 2007-10-08 00:25:07 -0400 | [diff] [blame] | 253 | |
Jacob Keller | c0192df | 2020-09-30 14:25:29 -0700 | [diff] [blame] | 254 | /* |
Jacob Keller | 2c80a82 | 2022-06-16 17:20:31 -0700 | [diff] [blame] | 255 | * Check whether a name matches any negative refspec in rs. Returns 1 if the |
| 256 | * name matches at least one negative refspec, and 0 otherwise. |
| 257 | */ |
| 258 | int omit_name_by_refspec(const char *name, struct refspec *rs); |
| 259 | |
| 260 | /* |
Jacob Keller | c0192df | 2020-09-30 14:25:29 -0700 | [diff] [blame] | 261 | * Remove all entries in the input list which match any negative refspec in |
| 262 | * the refspec list. |
| 263 | */ |
| 264 | struct ref *apply_negative_refspecs(struct ref *ref_map, struct refspec *rs); |
| 265 | |
Brandon Williams | 86baf82 | 2018-05-16 15:58:12 -0700 | [diff] [blame] | 266 | int query_refspecs(struct refspec *rs, struct refspec_item *query); |
Brandon Williams | d000414 | 2018-05-16 15:58:11 -0700 | [diff] [blame] | 267 | char *apply_refspecs(struct refspec *rs, const char *name); |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 268 | |
Brandon Williams | afb1aed | 2018-05-16 15:58:22 -0700 | [diff] [blame] | 269 | int check_push_refs(struct ref *src, struct refspec *rs); |
Junio C Hamano | 29753cd | 2011-09-09 11:54:58 -0700 | [diff] [blame] | 270 | int match_push_refs(struct ref *src, struct ref **dst, |
Brandon Williams | 5c7ec84 | 2018-05-16 15:58:21 -0700 | [diff] [blame] | 271 | struct refspec *rs, int flags); |
Tay Ray Chuan | 20e8b46 | 2010-01-08 10:12:42 +0800 | [diff] [blame] | 272 | void set_ref_status_for_push(struct ref *remote_refs, int send_mirror, |
| 273 | int force_update); |
Daniel Barkalow | 6b62816 | 2007-05-12 11:45:59 -0400 | [diff] [blame] | 274 | |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 275 | /* |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 276 | * Given a list of the remote refs and the specification of things to |
| 277 | * fetch, makes a (separate) list of the refs to fetch and the local |
Jacob Keller | c0192df | 2020-09-30 14:25:29 -0700 | [diff] [blame] | 278 | * refs to store into. Note that negative refspecs are ignored here, and |
| 279 | * should be handled separately. |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 280 | * |
| 281 | * *tail is the pointer to the tail pointer of the list of results |
| 282 | * beforehand, and will be set to the tail pointer of the list of |
| 283 | * results afterward. |
Junio C Hamano | 9ad7c5a | 2007-10-26 23:09:48 -0700 | [diff] [blame] | 284 | * |
| 285 | * missing_ok is usually false, but when we are adding branch.$name.merge |
| 286 | * it is Ok if the branch is not at the remote anymore. |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 287 | */ |
Brandon Williams | 0ad4a5f | 2018-05-16 15:57:49 -0700 | [diff] [blame] | 288 | int get_fetch_map(const struct ref *remote_refs, const struct refspec_item *refspec, |
Junio C Hamano | 9ad7c5a | 2007-10-26 23:09:48 -0700 | [diff] [blame] | 289 | struct ref ***tail, int missing_ok); |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 290 | |
Daniel Barkalow | 4577370 | 2007-10-29 21:05:40 -0400 | [diff] [blame] | 291 | struct ref *get_remote_ref(const struct ref *remote_refs, const char *name); |
Daniel Barkalow | d71ab17 | 2007-09-10 23:03:08 -0400 | [diff] [blame] | 292 | |
| 293 | /* |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 294 | * For the given remote, reads the refspec's src and sets the other fields. |
| 295 | */ |
Brandon Williams | 0ad4a5f | 2018-05-16 15:57:49 -0700 | [diff] [blame] | 296 | int remote_find_tracking(struct remote *remote, struct refspec_item *refspec); |
Daniel Barkalow | 5d46c9d | 2007-05-12 11:46:03 -0400 | [diff] [blame] | 297 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 298 | /** |
| 299 | * struct branch holds the configuration for a branch. It can be looked up with |
| 300 | * branch_get(name) for "refs/heads/{name}", or with branch_get(NULL) for HEAD. |
| 301 | */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 302 | struct branch { |
Glen Choo | 4a2dcb1 | 2021-11-17 16:53:25 -0800 | [diff] [blame] | 303 | struct hashmap_entry ent; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 304 | |
| 305 | /* The short name of the branch. */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 306 | const char *name; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 307 | |
| 308 | /* The full path for the branch ref. */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 309 | const char *refname; |
| 310 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 311 | /* The name of the remote listed in the configuration. */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 312 | const char *remote_name; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 313 | |
Jeff King | da66b27 | 2015-05-21 00:45:20 -0400 | [diff] [blame] | 314 | const char *pushremote_name; |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 315 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 316 | /* An array of the "merge" lines in the configuration. */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 317 | const char **merge_name; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 318 | |
| 319 | /** |
| 320 | * An array of the struct refspecs used for the merge lines. That is, |
| 321 | * merge[i]->dst is a local tracking ref which should be merged into this |
| 322 | * branch by default. |
| 323 | */ |
Brandon Williams | 0ad4a5f | 2018-05-16 15:57:49 -0700 | [diff] [blame] | 324 | struct refspec_item **merge; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 325 | |
| 326 | /* The number of merge configurations */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 327 | int merge_nr; |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 328 | |
Daniel Barkalow | 2d31347 | 2008-02-18 23:41:41 -0500 | [diff] [blame] | 329 | int merge_alloc; |
Jeff King | e291c75 | 2015-05-21 00:45:36 -0400 | [diff] [blame] | 330 | |
| 331 | const char *push_tracking_ref; |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 332 | }; |
| 333 | |
| 334 | struct branch *branch_get(const char *name); |
Jeff King | f052154 | 2015-05-21 00:45:16 -0400 | [diff] [blame] | 335 | const char *remote_for_branch(struct branch *branch, int *explicit); |
Jeff King | da66b27 | 2015-05-21 00:45:20 -0400 | [diff] [blame] | 336 | const char *pushremote_for_branch(struct branch *branch, int *explicit); |
Jeff King | af8ccd8 | 2020-03-03 17:12:22 +0100 | [diff] [blame] | 337 | const char *remote_ref_for_branch(struct branch *branch, int for_push); |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 338 | |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 339 | /* returns true if the given branch has merge configuration given. */ |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 340 | int branch_has_merge_config(struct branch *branch); |
Heba Waly | d27eb35 | 2019-11-17 21:04:45 +0000 | [diff] [blame] | 341 | |
Shawn O. Pearce | 85682c1 | 2007-09-18 04:54:53 -0400 | [diff] [blame] | 342 | int branch_merge_matches(struct branch *, int n, const char *); |
Daniel Barkalow | cf81834 | 2007-09-10 23:02:56 -0400 | [diff] [blame] | 343 | |
Jeff King | a9f9f8c | 2015-05-21 00:45:28 -0400 | [diff] [blame] | 344 | /** |
| 345 | * Return the fully-qualified refname of the tracking branch for `branch`. |
| 346 | * I.e., what "branch@{upstream}" would give you. Returns NULL if no |
| 347 | * upstream is defined. |
Jeff King | 3a429d0 | 2015-05-21 00:45:32 -0400 | [diff] [blame] | 348 | * |
| 349 | * If `err` is not NULL and no upstream is defined, a more specific error |
| 350 | * message is recorded there (if the function does not return NULL, then |
| 351 | * `err` is not touched). |
Jeff King | a9f9f8c | 2015-05-21 00:45:28 -0400 | [diff] [blame] | 352 | */ |
Jeff King | 3a429d0 | 2015-05-21 00:45:32 -0400 | [diff] [blame] | 353 | const char *branch_get_upstream(struct branch *branch, struct strbuf *err); |
Jeff King | a9f9f8c | 2015-05-21 00:45:28 -0400 | [diff] [blame] | 354 | |
Jeff King | e291c75 | 2015-05-21 00:45:36 -0400 | [diff] [blame] | 355 | /** |
| 356 | * Return the tracking branch that corresponds to the ref we would push to |
| 357 | * given a bare `git push` while `branch` is checked out. |
| 358 | * |
| 359 | * The return value and `err` conventions match those of `branch_get_upstream`. |
| 360 | */ |
| 361 | const char *branch_get_push(struct branch *branch, struct strbuf *err); |
| 362 | |
Andy Whitcroft | 28b9d6e | 2007-11-09 23:32:10 +0000 | [diff] [blame] | 363 | /* Flags to match_refs. */ |
| 364 | enum match_refs_flags { |
| 365 | MATCH_REFS_NONE = 0, |
| 366 | MATCH_REFS_ALL = (1 << 0), |
Felipe Contreras | 6ddba5e | 2012-02-23 00:43:41 +0200 | [diff] [blame] | 367 | MATCH_REFS_MIRROR = (1 << 1), |
Junio C Hamano | c2aba15 | 2013-03-04 12:09:50 -0800 | [diff] [blame] | 368 | MATCH_REFS_PRUNE = (1 << 2), |
| 369 | MATCH_REFS_FOLLOW_TAGS = (1 << 3) |
Andy Whitcroft | 28b9d6e | 2007-11-09 23:32:10 +0000 | [diff] [blame] | 370 | }; |
| 371 | |
Jeff Hostetler | d7d1b49 | 2018-01-09 18:50:15 +0000 | [diff] [blame] | 372 | /* Flags for --ahead-behind option. */ |
| 373 | enum ahead_behind_flags { |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 374 | AHEAD_BEHIND_UNSPECIFIED = -1, |
| 375 | AHEAD_BEHIND_QUICK = 0, /* just eq/neq reporting */ |
| 376 | AHEAD_BEHIND_FULL = 1, /* traditional a/b reporting */ |
Jeff Hostetler | d7d1b49 | 2018-01-09 18:50:15 +0000 | [diff] [blame] | 377 | }; |
| 378 | |
Junio C Hamano | 6d21bf9 | 2008-07-02 00:51:18 -0700 | [diff] [blame] | 379 | /* Reporting of tracking info */ |
Jeff King | 979cb24 | 2015-05-21 20:49:11 -0400 | [diff] [blame] | 380 | int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs, |
Damien Robert | c646d09 | 2019-04-16 14:16:46 +0200 | [diff] [blame] | 381 | const char **upstream_name, int for_push, |
| 382 | enum ahead_behind_flags abf); |
Jeff Hostetler | f39a757 | 2018-01-09 18:50:18 +0000 | [diff] [blame] | 383 | int format_tracking_info(struct branch *branch, struct strbuf *sb, |
Alex Henrie | b6f3da5 | 2023-07-12 22:41:13 -0600 | [diff] [blame] | 384 | enum ahead_behind_flags abf, |
| 385 | int show_divergence_advice); |
Junio C Hamano | 6d21bf9 | 2008-07-02 00:51:18 -0700 | [diff] [blame] | 386 | |
Jay Soffian | 454e202 | 2009-02-25 03:32:11 -0500 | [diff] [blame] | 387 | struct ref *get_local_heads(void); |
Jay Soffian | 6cb4e6c | 2009-02-25 03:32:14 -0500 | [diff] [blame] | 388 | /* |
Jay Soffian | 4229f1f | 2009-02-27 14:10:05 -0500 | [diff] [blame] | 389 | * Find refs from a list which are likely to be pointed to by the given HEAD |
| 390 | * ref. If 'all' is false, returns the most likely ref; otherwise, returns a |
| 391 | * list of all candidate refs. If no match is found (or 'head' is NULL), |
| 392 | * returns NULL. All returns are newly allocated and should be freed. |
Jay Soffian | 6cb4e6c | 2009-02-25 03:32:14 -0500 | [diff] [blame] | 393 | */ |
Jay Soffian | 4229f1f | 2009-02-27 14:10:05 -0500 | [diff] [blame] | 394 | struct ref *guess_remote_head(const struct ref *head, |
| 395 | const struct ref *refs, |
| 396 | int all); |
| 397 | |
Jay Soffian | f2ef607 | 2009-11-10 00:03:31 -0500 | [diff] [blame] | 398 | /* Return refs which no longer exist on remote */ |
Brandon Williams | a2ac50c | 2018-05-16 15:58:10 -0700 | [diff] [blame] | 399 | struct ref *get_stale_heads(struct refspec *rs, struct ref *fetch_map); |
Jay Soffian | f2ef607 | 2009-11-10 00:03:31 -0500 | [diff] [blame] | 400 | |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 401 | /* |
| 402 | * Compare-and-swap |
| 403 | */ |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 404 | struct push_cas_option { |
| 405 | unsigned use_tracking_for_rest:1; |
Srinidhi Kaushik | 99a1f9a | 2020-10-03 17:40:44 +0530 | [diff] [blame] | 406 | unsigned use_force_if_includes:1; |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 407 | struct push_cas { |
brian m. carlson | b8566f8 | 2017-07-13 23:49:21 +0000 | [diff] [blame] | 408 | struct object_id expect; |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 409 | unsigned use_tracking:1; |
| 410 | char *refname; |
| 411 | } *entry; |
| 412 | int nr; |
| 413 | int alloc; |
| 414 | }; |
| 415 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 416 | int parseopt_push_cas_option(const struct option *, const char *arg, int unset); |
Junio C Hamano | 28f5d17 | 2013-07-08 15:34:36 -0700 | [diff] [blame] | 417 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 418 | int is_empty_cas(const struct push_cas_option *); |
Junio C Hamano | 91048a9 | 2013-07-09 11:01:06 -0700 | [diff] [blame] | 419 | void apply_push_cas(struct push_cas_option *, struct remote *, struct ref *); |
| 420 | |
Derrick Stolee | 1d04e71 | 2022-05-16 20:11:03 +0000 | [diff] [blame] | 421 | /* |
| 422 | * The `url` argument is the URL that navigates to the submodule origin |
| 423 | * repo. When relative, this URL is relative to the superproject origin |
| 424 | * URL repo. The `up_path` argument, if specified, is the relative |
| 425 | * path that navigates from the submodule working tree to the superproject |
| 426 | * working tree. Returns the origin URL of the submodule. |
| 427 | * |
| 428 | * Return either an absolute URL or filesystem path (if the superproject |
| 429 | * origin URL is an absolute URL or filesystem path, respectively) or a |
| 430 | * relative file system path (if the superproject origin URL is a relative |
| 431 | * file system path). |
| 432 | * |
| 433 | * When the output is a relative file system path, the path is either |
| 434 | * relative to the submodule working tree, if up_path is specified, or to |
| 435 | * the superproject working tree otherwise. |
| 436 | * |
| 437 | * NEEDSWORK: This works incorrectly on the domain and protocol part. |
| 438 | * remote_url url outcome expectation |
| 439 | * http://a.com/b ../c http://a.com/c as is |
| 440 | * http://a.com/b/ ../c http://a.com/c same as previous line, but |
| 441 | * ignore trailing slash in url |
| 442 | * http://a.com/b ../../c http://c error out |
| 443 | * http://a.com/b ../../../c http:/c error out |
| 444 | * http://a.com/b ../../../../c http:c error out |
| 445 | * http://a.com/b ../../../../../c .:c error out |
Derrick Stolee | 834e352 | 2022-05-16 20:11:04 +0000 | [diff] [blame] | 446 | * http://a.com/b http://d.org/e http://d.org/e as is |
Derrick Stolee | 1d04e71 | 2022-05-16 20:11:03 +0000 | [diff] [blame] | 447 | * NEEDSWORK: Given how chop_last_dir() works, this function is broken |
| 448 | * when a local part has a colon in its path component, too. |
| 449 | */ |
| 450 | char *relative_url(const char *remote_url, const char *url, |
| 451 | const char *up_path); |
| 452 | |
Daniel Barkalow | 5751f49 | 2007-05-12 11:45:53 -0400 | [diff] [blame] | 453 | #endif |