]>
Commit | Line | Data |
---|---|---|
1 | #include "cache.h" | |
2 | #include "strvec.h" | |
3 | #include "refs.h" | |
4 | #include "refspec.h" | |
5 | ||
6 | static struct refspec_item s_tag_refspec = { | |
7 | 0, | |
8 | 1, | |
9 | 0, | |
10 | 0, | |
11 | 0, | |
12 | "refs/tags/*", | |
13 | "refs/tags/*" | |
14 | }; | |
15 | ||
16 | /* See TAG_REFSPEC for the string version */ | |
17 | const struct refspec_item *tag_refspec = &s_tag_refspec; | |
18 | ||
19 | /* | |
20 | * Parses the provided refspec 'refspec' and populates the refspec_item 'item'. | |
21 | * Returns 1 if successful and 0 if the refspec is invalid. | |
22 | */ | |
23 | static int parse_refspec(struct refspec_item *item, const char *refspec, int fetch) | |
24 | { | |
25 | size_t llen; | |
26 | int is_glob; | |
27 | const char *lhs, *rhs; | |
28 | int flags; | |
29 | ||
30 | is_glob = 0; | |
31 | ||
32 | lhs = refspec; | |
33 | if (*lhs == '+') { | |
34 | item->force = 1; | |
35 | lhs++; | |
36 | } else if (*lhs == '^') { | |
37 | item->negative = 1; | |
38 | lhs++; | |
39 | } | |
40 | ||
41 | rhs = strrchr(lhs, ':'); | |
42 | ||
43 | /* negative refspecs only have one side */ | |
44 | if (item->negative && rhs) | |
45 | return 0; | |
46 | ||
47 | /* | |
48 | * Before going on, special case ":" (or "+:") as a refspec | |
49 | * for pushing matching refs. | |
50 | */ | |
51 | if (!fetch && rhs == lhs && rhs[1] == '\0') { | |
52 | item->matching = 1; | |
53 | return 1; | |
54 | } | |
55 | ||
56 | if (rhs) { | |
57 | size_t rlen = strlen(++rhs); | |
58 | is_glob = (1 <= rlen && strchr(rhs, '*')); | |
59 | item->dst = xstrndup(rhs, rlen); | |
60 | } else { | |
61 | item->dst = NULL; | |
62 | } | |
63 | ||
64 | llen = (rhs ? (rhs - lhs - 1) : strlen(lhs)); | |
65 | if (1 <= llen && memchr(lhs, '*', llen)) { | |
66 | if ((rhs && !is_glob) || (!rhs && !item->negative && fetch)) | |
67 | return 0; | |
68 | is_glob = 1; | |
69 | } else if (rhs && is_glob) { | |
70 | return 0; | |
71 | } | |
72 | ||
73 | item->pattern = is_glob; | |
74 | item->src = xstrndup(lhs, llen); | |
75 | flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0); | |
76 | ||
77 | if (item->negative) { | |
78 | struct object_id unused; | |
79 | ||
80 | /* | |
81 | * Negative refspecs only have a LHS, which indicates a ref | |
82 | * (or pattern of refs) to exclude from other matches. This | |
83 | * can either be a simple ref, or a glob pattern. Exact sha1 | |
84 | * match is not currently supported. | |
85 | */ | |
86 | if (!*item->src) | |
87 | return 0; /* negative refspecs must not be empty */ | |
88 | else if (llen == the_hash_algo->hexsz && !get_oid_hex(item->src, &unused)) | |
89 | return 0; /* negative refpsecs cannot be exact sha1 */ | |
90 | else if (!check_refname_format(item->src, flags)) | |
91 | ; /* valid looking ref is ok */ | |
92 | else | |
93 | return 0; | |
94 | ||
95 | /* the other rules below do not apply to negative refspecs */ | |
96 | return 1; | |
97 | } | |
98 | ||
99 | if (fetch) { | |
100 | struct object_id unused; | |
101 | ||
102 | /* LHS */ | |
103 | if (!*item->src) | |
104 | ; /* empty is ok; it means "HEAD" */ | |
105 | else if (llen == the_hash_algo->hexsz && !get_oid_hex(item->src, &unused)) | |
106 | item->exact_sha1 = 1; /* ok */ | |
107 | else if (!check_refname_format(item->src, flags)) | |
108 | ; /* valid looking ref is ok */ | |
109 | else | |
110 | return 0; | |
111 | /* RHS */ | |
112 | if (!item->dst) | |
113 | ; /* missing is ok; it is the same as empty */ | |
114 | else if (!*item->dst) | |
115 | ; /* empty is ok; it means "do not store" */ | |
116 | else if (!check_refname_format(item->dst, flags)) | |
117 | ; /* valid looking ref is ok */ | |
118 | else | |
119 | return 0; | |
120 | } else { | |
121 | /* | |
122 | * LHS | |
123 | * - empty is allowed; it means delete. | |
124 | * - when wildcarded, it must be a valid looking ref. | |
125 | * - otherwise, it must be an extended SHA-1, but | |
126 | * there is no existing way to validate this. | |
127 | */ | |
128 | if (!*item->src) | |
129 | ; /* empty is ok */ | |
130 | else if (is_glob) { | |
131 | if (check_refname_format(item->src, flags)) | |
132 | return 0; | |
133 | } | |
134 | else | |
135 | ; /* anything goes, for now */ | |
136 | /* | |
137 | * RHS | |
138 | * - missing is allowed, but LHS then must be a | |
139 | * valid looking ref. | |
140 | * - empty is not allowed. | |
141 | * - otherwise it must be a valid looking ref. | |
142 | */ | |
143 | if (!item->dst) { | |
144 | if (check_refname_format(item->src, flags)) | |
145 | return 0; | |
146 | } else if (!*item->dst) { | |
147 | return 0; | |
148 | } else { | |
149 | if (check_refname_format(item->dst, flags)) | |
150 | return 0; | |
151 | } | |
152 | } | |
153 | ||
154 | return 1; | |
155 | } | |
156 | ||
157 | int refspec_item_init(struct refspec_item *item, const char *refspec, int fetch) | |
158 | { | |
159 | memset(item, 0, sizeof(*item)); | |
160 | return parse_refspec(item, refspec, fetch); | |
161 | } | |
162 | ||
163 | void refspec_item_init_or_die(struct refspec_item *item, const char *refspec, | |
164 | int fetch) | |
165 | { | |
166 | if (!refspec_item_init(item, refspec, fetch)) | |
167 | die(_("invalid refspec '%s'"), refspec); | |
168 | } | |
169 | ||
170 | void refspec_item_clear(struct refspec_item *item) | |
171 | { | |
172 | FREE_AND_NULL(item->src); | |
173 | FREE_AND_NULL(item->dst); | |
174 | item->force = 0; | |
175 | item->pattern = 0; | |
176 | item->matching = 0; | |
177 | item->exact_sha1 = 0; | |
178 | } | |
179 | ||
180 | void refspec_init(struct refspec *rs, int fetch) | |
181 | { | |
182 | memset(rs, 0, sizeof(*rs)); | |
183 | rs->fetch = fetch; | |
184 | } | |
185 | ||
186 | static void refspec_append_nodup(struct refspec *rs, char *refspec) | |
187 | { | |
188 | struct refspec_item item; | |
189 | ||
190 | refspec_item_init_or_die(&item, refspec, rs->fetch); | |
191 | ||
192 | ALLOC_GROW(rs->items, rs->nr + 1, rs->alloc); | |
193 | rs->items[rs->nr++] = item; | |
194 | ||
195 | ALLOC_GROW(rs->raw, rs->raw_nr + 1, rs->raw_alloc); | |
196 | rs->raw[rs->raw_nr++] = refspec; | |
197 | } | |
198 | ||
199 | void refspec_append(struct refspec *rs, const char *refspec) | |
200 | { | |
201 | refspec_append_nodup(rs, xstrdup(refspec)); | |
202 | } | |
203 | ||
204 | void refspec_appendf(struct refspec *rs, const char *fmt, ...) | |
205 | { | |
206 | va_list ap; | |
207 | ||
208 | va_start(ap, fmt); | |
209 | refspec_append_nodup(rs, xstrvfmt(fmt, ap)); | |
210 | va_end(ap); | |
211 | } | |
212 | ||
213 | void refspec_appendn(struct refspec *rs, const char **refspecs, int nr) | |
214 | { | |
215 | int i; | |
216 | for (i = 0; i < nr; i++) | |
217 | refspec_append(rs, refspecs[i]); | |
218 | } | |
219 | ||
220 | void refspec_clear(struct refspec *rs) | |
221 | { | |
222 | int i; | |
223 | ||
224 | for (i = 0; i < rs->nr; i++) | |
225 | refspec_item_clear(&rs->items[i]); | |
226 | ||
227 | FREE_AND_NULL(rs->items); | |
228 | rs->alloc = 0; | |
229 | rs->nr = 0; | |
230 | ||
231 | for (i = 0; i < rs->raw_nr; i++) | |
232 | free((char *)rs->raw[i]); | |
233 | FREE_AND_NULL(rs->raw); | |
234 | rs->raw_alloc = 0; | |
235 | rs->raw_nr = 0; | |
236 | ||
237 | rs->fetch = 0; | |
238 | } | |
239 | ||
240 | int valid_fetch_refspec(const char *fetch_refspec_str) | |
241 | { | |
242 | struct refspec_item refspec; | |
243 | int ret = refspec_item_init(&refspec, fetch_refspec_str, REFSPEC_FETCH); | |
244 | refspec_item_clear(&refspec); | |
245 | return ret; | |
246 | } | |
247 | ||
248 | int valid_remote_name(const char *name) | |
249 | { | |
250 | int result; | |
251 | struct strbuf refspec = STRBUF_INIT; | |
252 | strbuf_addf(&refspec, "refs/heads/test:refs/remotes/%s/test", name); | |
253 | result = valid_fetch_refspec(refspec.buf); | |
254 | strbuf_release(&refspec); | |
255 | return result; | |
256 | } | |
257 | ||
258 | void refspec_ref_prefixes(const struct refspec *rs, | |
259 | struct strvec *ref_prefixes) | |
260 | { | |
261 | int i; | |
262 | for (i = 0; i < rs->nr; i++) { | |
263 | const struct refspec_item *item = &rs->items[i]; | |
264 | const char *prefix = NULL; | |
265 | ||
266 | if (item->exact_sha1 || item->negative) | |
267 | continue; | |
268 | if (rs->fetch == REFSPEC_FETCH) | |
269 | prefix = item->src; | |
270 | else if (item->dst) | |
271 | prefix = item->dst; | |
272 | else if (item->src && !item->exact_sha1) | |
273 | prefix = item->src; | |
274 | ||
275 | if (prefix) { | |
276 | if (item->pattern) { | |
277 | const char *glob = strchr(prefix, '*'); | |
278 | strvec_pushf(ref_prefixes, "%.*s", | |
279 | (int)(glob - prefix), | |
280 | prefix); | |
281 | } else { | |
282 | expand_ref_prefix(ref_prefixes, prefix); | |
283 | } | |
284 | } | |
285 | } | |
286 | } |