refname_is_safe(): insist that the refname already be normalized
[git/git.git] / refs.c
CommitLineData
7bd9bcf3
MH
1/*
2 * The backend-independent part of the reference module.
3 */
4
95fc7512 5#include "cache.h"
697cc8ef 6#include "lockfile.h"
85023577 7#include "refs.h"
4cb77009 8#include "refs/refs-internal.h"
cf0adba7
JH
9#include "object.h"
10#include "tag.h"
3581d793 11
bc5fd6d3 12/*
dde8a902
DT
13 * How to handle various characters in refnames:
14 * 0: An acceptable character for refs
5e650228
JH
15 * 1: End-of-component
16 * 2: ., look for a preceding . to reject .. in refs
17 * 3: {, look for a preceding @ to reject @{ in refs
53a8555e 18 * 4: A bad character: ASCII control characters, and
cd377f45
JK
19 * ":", "?", "[", "\", "^", "~", SP, or TAB
20 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
dde8a902
DT
21 */
22static unsigned char refname_disposition[256] = {
5e650228
JH
23 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
24 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
cd377f45 25 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
5e650228 26 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
dde8a902 27 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5e650228
JH
28 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
29 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
30 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
dde8a902
DT
31};
32
33/*
34 * Try to read one refname component from the front of refname.
35 * Return the length of the component found, or -1 if the component is
36 * not legal. It is legal if it is something reasonable to have under
37 * ".git/refs/"; We do not like it if:
bc5fd6d3
MH
38 *
39 * - any path component of it begins with ".", or
40 * - it has double dots "..", or
53a8555e 41 * - it has ASCII control characters, or
cd377f45
JK
42 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
43 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
53a8555e
JK
44 * - it ends with a "/", or
45 * - it ends with ".lock", or
46 * - it contains a "@{" portion
bc5fd6d3 47 */
cd377f45 48static int check_refname_component(const char *refname, int *flags)
bc5fd6d3
MH
49{
50 const char *cp;
51 char last = '\0';
52
53 for (cp = refname; ; cp++) {
dde8a902
DT
54 int ch = *cp & 255;
55 unsigned char disp = refname_disposition[ch];
56 switch (disp) {
5e650228 57 case 1:
dde8a902 58 goto out;
5e650228 59 case 2:
dde8a902
DT
60 if (last == '.')
61 return -1; /* Refname contains "..". */
62 break;
5e650228 63 case 3:
dde8a902
DT
64 if (last == '@')
65 return -1; /* Refname contains "@{". */
bc5fd6d3 66 break;
5e650228 67 case 4:
dde8a902 68 return -1;
cd377f45
JK
69 case 5:
70 if (!(*flags & REFNAME_REFSPEC_PATTERN))
71 return -1; /* refspec can't be a pattern */
72
73 /*
74 * Unset the pattern flag so that we only accept
75 * a single asterisk for one side of refspec.
76 */
77 *flags &= ~ REFNAME_REFSPEC_PATTERN;
78 break;
dde8a902 79 }
bc5fd6d3
MH
80 last = ch;
81 }
dde8a902 82out:
bc5fd6d3 83 if (cp == refname)
dac529e4 84 return 0; /* Component has zero length. */
f3cc52d8
JN
85 if (refname[0] == '.')
86 return -1; /* Component starts with '.'. */
7108ad23
MH
87 if (cp - refname >= LOCK_SUFFIX_LEN &&
88 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN))
bc5fd6d3
MH
89 return -1; /* Refname ends with ".lock". */
90 return cp - refname;
91}
92
5e650228 93int check_refname_format(const char *refname, int flags)
bc5fd6d3
MH
94{
95 int component_len, component_count = 0;
96
9ba89f48
FC
97 if (!strcmp(refname, "@"))
98 /* Refname is a single character '@'. */
99 return -1;
100
bc5fd6d3
MH
101 while (1) {
102 /* We are at the start of a path component. */
cd377f45
JK
103 component_len = check_refname_component(refname, &flags);
104 if (component_len <= 0)
105 return -1;
106
bc5fd6d3
MH
107 component_count++;
108 if (refname[component_len] == '\0')
109 break;
110 /* Skip to next component. */
111 refname += component_len + 1;
112 }
113
114 if (refname[component_len - 1] == '.')
115 return -1; /* Refname ends with '.'. */
116 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
117 return -1; /* Refname has only one component. */
118 return 0;
119}
120
4cb77009 121int refname_is_safe(const char *refname)
d0f810f0 122{
39950fef
MH
123 const char *rest;
124
125 if (skip_prefix(refname, "refs/", &rest)) {
d0f810f0
RS
126 char *buf;
127 int result;
e40f3557
MH
128 size_t restlen = strlen(rest);
129
130 /* rest must not be empty, or start or end with "/" */
131 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
132 return 0;
d0f810f0 133
d0f810f0
RS
134 /*
135 * Does the refname try to escape refs/?
136 * For example: refs/foo/../bar is safe but refs/foo/../../bar
137 * is not.
138 */
e40f3557
MH
139 buf = xmallocz(restlen);
140 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
d0f810f0
RS
141 free(buf);
142 return result;
143 }
35db25c6
MH
144
145 do {
d0f810f0
RS
146 if (!isupper(*refname) && *refname != '_')
147 return 0;
148 refname++;
35db25c6 149 } while (*refname);
d0f810f0
RS
150 return 1;
151}
152
7bd9bcf3
MH
153char *resolve_refdup(const char *refname, int resolve_flags,
154 unsigned char *sha1, int *flags)
e1e22e37 155{
7bd9bcf3
MH
156 return xstrdup_or_null(resolve_ref_unsafe(refname, resolve_flags,
157 sha1, flags));
cddc4258
MH
158}
159
7bd9bcf3
MH
160/* The argument to filter_refs */
161struct ref_filter {
162 const char *pattern;
163 each_ref_fn *fn;
164 void *cb_data;
165};
432ad41e 166
7bd9bcf3 167int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
732134ed 168{
7bd9bcf3
MH
169 if (resolve_ref_unsafe(refname, resolve_flags, sha1, flags))
170 return 0;
171 return -1;
732134ed
MH
172}
173
7bd9bcf3 174int read_ref(const char *refname, unsigned char *sha1)
cddc4258 175{
7bd9bcf3 176 return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
c774aab9
JP
177}
178
7bd9bcf3 179int ref_exists(const char *refname)
bc5fd6d3 180{
7bd9bcf3
MH
181 unsigned char sha1[20];
182 return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
bc5fd6d3
MH
183}
184
7bd9bcf3
MH
185static int filter_refs(const char *refname, const struct object_id *oid,
186 int flags, void *data)
432ad41e 187{
7bd9bcf3
MH
188 struct ref_filter *filter = (struct ref_filter *)data;
189
190 if (wildmatch(filter->pattern, refname, 0, NULL))
191 return 0;
192 return filter->fn(refname, oid, flags, filter->cb_data);
432ad41e
MH
193}
194
7bd9bcf3 195enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
c774aab9 196{
7bd9bcf3 197 struct object *o = lookup_unknown_object(name);
c774aab9 198
7bd9bcf3
MH
199 if (o->type == OBJ_NONE) {
200 int type = sha1_object_info(name, NULL);
201 if (type < 0 || !object_as_type(o, type, 0))
202 return PEEL_INVALID;
203 }
bc5fd6d3 204
7bd9bcf3
MH
205 if (o->type != OBJ_TAG)
206 return PEEL_NON_TAG;
e1980c9d 207
7bd9bcf3
MH
208 o = deref_tag_noverify(o);
209 if (!o)
210 return PEEL_INVALID;
211
844a9ce4 212 hashcpy(sha1, o->oid.hash);
7bd9bcf3 213 return PEEL_PEELED;
e1980c9d
JH
214}
215
7bd9bcf3
MH
216struct warn_if_dangling_data {
217 FILE *fp;
218 const char *refname;
219 const struct string_list *refnames;
220 const char *msg_fmt;
221};
bc5fd6d3 222
7bd9bcf3
MH
223static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
224 int flags, void *cb_data)
225{
226 struct warn_if_dangling_data *d = cb_data;
227 const char *resolves_to;
228 struct object_id junk;
bc5fd6d3 229
7bd9bcf3
MH
230 if (!(flags & REF_ISSYMREF))
231 return 0;
bc5fd6d3 232
7bd9bcf3
MH
233 resolves_to = resolve_ref_unsafe(refname, 0, junk.hash, NULL);
234 if (!resolves_to
235 || (d->refname
236 ? strcmp(resolves_to, d->refname)
237 : !string_list_has_string(d->refnames, resolves_to))) {
238 return 0;
239 }
bc5fd6d3 240
7bd9bcf3
MH
241 fprintf(d->fp, d->msg_fmt, refname);
242 fputc('\n', d->fp);
243 return 0;
bc5fd6d3
MH
244}
245
7bd9bcf3 246void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
f348ac92 247{
7bd9bcf3
MH
248 struct warn_if_dangling_data data;
249
250 data.fp = fp;
251 data.refname = refname;
252 data.refnames = NULL;
253 data.msg_fmt = msg_fmt;
254 for_each_rawref(warn_if_dangling_symref, &data);
f348ac92
MH
255}
256
7bd9bcf3 257void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
432ad41e 258{
7bd9bcf3 259 struct warn_if_dangling_data data;
432ad41e 260
7bd9bcf3
MH
261 data.fp = fp;
262 data.refname = NULL;
263 data.refnames = refnames;
264 data.msg_fmt = msg_fmt;
265 for_each_rawref(warn_if_dangling_symref, &data);
432ad41e
MH
266}
267
7bd9bcf3 268int for_each_tag_ref(each_ref_fn fn, void *cb_data)
432ad41e 269{
7bd9bcf3 270 return for_each_ref_in("refs/tags/", fn, cb_data);
432ad41e
MH
271}
272
7bd9bcf3 273int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
506a760d 274{
7bd9bcf3 275 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
432ad41e
MH
276}
277
7bd9bcf3 278int for_each_branch_ref(each_ref_fn fn, void *cb_data)
432ad41e 279{
7bd9bcf3 280 return for_each_ref_in("refs/heads/", fn, cb_data);
432ad41e
MH
281}
282
7bd9bcf3 283int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
202a56a9 284{
7bd9bcf3 285 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
202a56a9 286}
432ad41e 287
7bd9bcf3 288int for_each_remote_ref(each_ref_fn fn, void *cb_data)
e9c4c111 289{
7bd9bcf3 290 return for_each_ref_in("refs/remotes/", fn, cb_data);
202a56a9
MH
291}
292
7bd9bcf3 293int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
e9c4c111 294{
7bd9bcf3 295 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
662428f4 296}
c774aab9 297
7bd9bcf3
MH
298int head_ref_namespaced(each_ref_fn fn, void *cb_data)
299{
300 struct strbuf buf = STRBUF_INIT;
301 int ret = 0;
302 struct object_id oid;
303 int flag;
c774aab9 304
7bd9bcf3
MH
305 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
306 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, oid.hash, &flag))
307 ret = fn(buf.buf, &oid, flag, cb_data);
308 strbuf_release(&buf);
c774aab9 309
7bd9bcf3 310 return ret;
e9c4c111 311}
c774aab9 312
7bd9bcf3
MH
313int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
314 const char *prefix, void *cb_data)
662428f4 315{
7bd9bcf3
MH
316 struct strbuf real_pattern = STRBUF_INIT;
317 struct ref_filter filter;
318 int ret;
d08bae7e 319
59556548 320 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 321 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
322 else if (prefix)
323 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
324 strbuf_addstr(&real_pattern, pattern);
325
894a9d33 326 if (!has_glob_specials(pattern)) {
9517e6b8 327 /* Append implied '/' '*' if not present. */
00b6c178 328 strbuf_complete(&real_pattern, '/');
d08bae7e
IL
329 /* No need to check for '*', there is none. */
330 strbuf_addch(&real_pattern, '*');
331 }
332
333 filter.pattern = real_pattern.buf;
334 filter.fn = fn;
335 filter.cb_data = cb_data;
336 ret = for_each_ref(filter_refs, &filter);
337
338 strbuf_release(&real_pattern);
339 return ret;
340}
341
b09fe971
IL
342int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
343{
344 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
345}
346
4577e483 347const char *prettify_refname(const char *name)
a9c37a72 348{
a9c37a72 349 return name + (
59556548
CC
350 starts_with(name, "refs/heads/") ? 11 :
351 starts_with(name, "refs/tags/") ? 10 :
352 starts_with(name, "refs/remotes/") ? 13 :
a9c37a72
DB
353 0);
354}
355
54457fe5 356static const char *ref_rev_parse_rules[] = {
79803322
SP
357 "%.*s",
358 "refs/%.*s",
359 "refs/tags/%.*s",
360 "refs/heads/%.*s",
361 "refs/remotes/%.*s",
362 "refs/remotes/%.*s/HEAD",
363 NULL
364};
365
54457fe5 366int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
367{
368 const char **p;
369 const int abbrev_name_len = strlen(abbrev_name);
370
54457fe5 371 for (p = ref_rev_parse_rules; *p; p++) {
79803322
SP
372 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
373 return 1;
374 }
375 }
376
377 return 0;
378}
379
ff74f7f1
JH
380/*
381 * *string and *len will only be substituted, and *string returned (for
382 * later free()ing) if the string passed in is a magic short-hand form
383 * to name a branch.
384 */
385static char *substitute_branch_name(const char **string, int *len)
386{
387 struct strbuf buf = STRBUF_INIT;
cf99a761 388 int ret = interpret_branch_name(*string, *len, &buf);
ff74f7f1
JH
389
390 if (ret == *len) {
391 size_t size;
392 *string = strbuf_detach(&buf, &size);
393 *len = size;
394 return (char *)*string;
395 }
396
397 return NULL;
398}
399
400int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
401{
402 char *last_branch = substitute_branch_name(&str, &len);
403 const char **p, *r;
404 int refs_found = 0;
405
406 *ref = NULL;
407 for (p = ref_rev_parse_rules; *p; p++) {
408 char fullref[PATH_MAX];
409 unsigned char sha1_from_ref[20];
410 unsigned char *this_result;
411 int flag;
412
413 this_result = refs_found ? sha1_from_ref : sha1;
414 mksnpath(fullref, sizeof(fullref), *p, len, str);
7695d118
RS
415 r = resolve_ref_unsafe(fullref, RESOLVE_REF_READING,
416 this_result, &flag);
ff74f7f1
JH
417 if (r) {
418 if (!refs_found++)
419 *ref = xstrdup(r);
420 if (!warn_ambiguous_refs)
421 break;
55956350 422 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
ff74f7f1 423 warning("ignoring dangling symref %s.", fullref);
55956350
JH
424 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
425 warning("ignoring broken ref %s.", fullref);
426 }
ff74f7f1
JH
427 }
428 free(last_branch);
429 return refs_found;
430}
431
432int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
433{
434 char *last_branch = substitute_branch_name(&str, &len);
435 const char **p;
436 int logs_found = 0;
437
438 *log = NULL;
439 for (p = ref_rev_parse_rules; *p; p++) {
ff74f7f1
JH
440 unsigned char hash[20];
441 char path[PATH_MAX];
442 const char *ref, *it;
443
444 mksnpath(path, sizeof(path), *p, len, str);
7695d118
RS
445 ref = resolve_ref_unsafe(path, RESOLVE_REF_READING,
446 hash, NULL);
ff74f7f1
JH
447 if (!ref)
448 continue;
4da58835 449 if (reflog_exists(path))
ff74f7f1 450 it = path;
4da58835 451 else if (strcmp(ref, path) && reflog_exists(ref))
ff74f7f1
JH
452 it = ref;
453 else
454 continue;
455 if (!logs_found++) {
456 *log = xstrdup(it);
457 hashcpy(sha1, hash);
458 }
7bd9bcf3
MH
459 if (!warn_ambiguous_refs)
460 break;
c0277d15 461 }
7bd9bcf3
MH
462 free(last_branch);
463 return logs_found;
2ddb5d17
BK
464}
465
266b1827
DT
466static int is_per_worktree_ref(const char *refname)
467{
ce414b33
DT
468 return !strcmp(refname, "HEAD") ||
469 starts_with(refname, "refs/bisect/");
266b1827
DT
470}
471
472static int is_pseudoref_syntax(const char *refname)
473{
474 const char *c;
475
476 for (c = refname; *c; c++) {
477 if (!isupper(*c) && *c != '-' && *c != '_')
478 return 0;
479 }
480
481 return 1;
482}
483
484enum ref_type ref_type(const char *refname)
485{
486 if (is_per_worktree_ref(refname))
487 return REF_TYPE_PER_WORKTREE;
488 if (is_pseudoref_syntax(refname))
489 return REF_TYPE_PSEUDOREF;
490 return REF_TYPE_NORMAL;
491}
492
74ec19d4
DT
493static int write_pseudoref(const char *pseudoref, const unsigned char *sha1,
494 const unsigned char *old_sha1, struct strbuf *err)
495{
496 const char *filename;
497 int fd;
498 static struct lock_file lock;
499 struct strbuf buf = STRBUF_INIT;
500 int ret = -1;
501
502 strbuf_addf(&buf, "%s\n", sha1_to_hex(sha1));
503
504 filename = git_path("%s", pseudoref);
505 fd = hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);
506 if (fd < 0) {
507 strbuf_addf(err, "Could not open '%s' for writing: %s",
508 filename, strerror(errno));
509 return -1;
510 }
511
512 if (old_sha1) {
513 unsigned char actual_old_sha1[20];
2c3aed13
DT
514
515 if (read_ref(pseudoref, actual_old_sha1))
516 die("could not read ref '%s'", pseudoref);
74ec19d4
DT
517 if (hashcmp(actual_old_sha1, old_sha1)) {
518 strbuf_addf(err, "Unexpected sha1 when writing %s", pseudoref);
519 rollback_lock_file(&lock);
520 goto done;
521 }
522 }
523
524 if (write_in_full(fd, buf.buf, buf.len) != buf.len) {
525 strbuf_addf(err, "Could not write to '%s'", filename);
526 rollback_lock_file(&lock);
527 goto done;
528 }
529
530 commit_lock_file(&lock);
531 ret = 0;
532done:
533 strbuf_release(&buf);
534 return ret;
535}
536
537static int delete_pseudoref(const char *pseudoref, const unsigned char *old_sha1)
538{
539 static struct lock_file lock;
540 const char *filename;
541
542 filename = git_path("%s", pseudoref);
543
544 if (old_sha1 && !is_null_sha1(old_sha1)) {
545 int fd;
546 unsigned char actual_old_sha1[20];
547
548 fd = hold_lock_file_for_update(&lock, filename,
549 LOCK_DIE_ON_ERROR);
550 if (fd < 0)
551 die_errno(_("Could not open '%s' for writing"), filename);
2c3aed13
DT
552 if (read_ref(pseudoref, actual_old_sha1))
553 die("could not read ref '%s'", pseudoref);
74ec19d4
DT
554 if (hashcmp(actual_old_sha1, old_sha1)) {
555 warning("Unexpected sha1 when deleting %s", pseudoref);
556 rollback_lock_file(&lock);
557 return -1;
a4c653df 558 }
74ec19d4
DT
559
560 unlink(filename);
561 rollback_lock_file(&lock);
562 } else {
563 unlink(filename);
4bd18c43 564 }
a4c653df 565
4bd18c43 566 return 0;
95fc7512 567}
d556fae2 568
fc1c2168
MH
569int delete_ref(const char *refname, const unsigned char *old_sha1,
570 unsigned int flags)
41b625b0 571{
7521cc46 572 struct ref_transaction *transaction;
a4c653df 573 struct strbuf err = STRBUF_INIT;
8b5157e4 574
74ec19d4 575 if (ref_type(refname) == REF_TYPE_PSEUDOREF)
080cc646 576 return delete_pseudoref(refname, old_sha1);
d48744d1 577
7521cc46
RS
578 transaction = ref_transaction_begin(&err);
579 if (!transaction ||
fc67a082 580 ref_transaction_delete(transaction, refname, old_sha1,
fb5a6bb6 581 flags, NULL, &err) ||
db7516ab 582 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
583 error("%s", err.buf);
584 ref_transaction_free(transaction);
585 strbuf_release(&err);
c0277d15 586 return 1;
41b625b0 587 }
7bd9bcf3
MH
588 ref_transaction_free(transaction);
589 strbuf_release(&err);
b531394d
BC
590 return 0;
591}
41b625b0 592
4cb77009 593int copy_reflog_msg(char *buf, const char *msg)
0ec29a47
JH
594{
595 char *cp = buf;
596 char c;
597 int wasspace = 1;
8b5157e4 598
0ec29a47
JH
599 *cp++ = '\t';
600 while ((c = *msg++)) {
601 if (wasspace && isspace(c))
602 continue;
603 wasspace = isspace(c);
604 if (wasspace)
605 c = ' ';
606 *cp++ = c;
a4c653df 607 }
0ec29a47
JH
608 while (buf < cp && isspace(cp[-1]))
609 cp--;
610 *cp++ = '\n';
611 return cp - buf;
612}
8b5157e4 613
4cb77009 614int should_autocreate_reflog(const char *refname)
4e2bef57
DT
615{
616 if (!log_all_ref_updates)
617 return 0;
618 return starts_with(refname, "refs/heads/") ||
619 starts_with(refname, "refs/remotes/") ||
620 starts_with(refname, "refs/notes/") ||
621 !strcmp(refname, "HEAD");
622}
623
e7e0f26e 624int is_branch(const char *refname)
c3b0dec5 625{
59556548 626 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
41b625b0
NP
627}
628
4207ed28
RS
629struct read_ref_at_cb {
630 const char *refname;
631 unsigned long at_time;
632 int cnt;
633 int reccnt;
634 unsigned char *sha1;
635 int found_it;
636
637 unsigned char osha1[20];
638 unsigned char nsha1[20];
639 int tz;
640 unsigned long date;
641 char **msg;
642 unsigned long *cutoff_time;
643 int *cutoff_tz;
644 int *cutoff_cnt;
645};
646
647static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,
648 const char *email, unsigned long timestamp, int tz,
649 const char *message, void *cb_data)
650{
651 struct read_ref_at_cb *cb = cb_data;
652
653 cb->reccnt++;
654 cb->tz = tz;
655 cb->date = timestamp;
656
657 if (timestamp <= cb->at_time || cb->cnt == 0) {
658 if (cb->msg)
659 *cb->msg = xstrdup(message);
660 if (cb->cutoff_time)
661 *cb->cutoff_time = timestamp;
662 if (cb->cutoff_tz)
663 *cb->cutoff_tz = tz;
664 if (cb->cutoff_cnt)
665 *cb->cutoff_cnt = cb->reccnt - 1;
666 /*
667 * we have not yet updated cb->[n|o]sha1 so they still
668 * hold the values for the previous record.
669 */
670 if (!is_null_sha1(cb->osha1)) {
671 hashcpy(cb->sha1, nsha1);
672 if (hashcmp(cb->osha1, nsha1))
673 warning("Log for ref %s has gap after %s.",
a5481a6c 674 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
4207ed28
RS
675 }
676 else if (cb->date == cb->at_time)
677 hashcpy(cb->sha1, nsha1);
678 else if (hashcmp(nsha1, cb->sha1))
679 warning("Log for ref %s unexpectedly ended on %s.",
680 cb->refname, show_date(cb->date, cb->tz,
a5481a6c 681 DATE_MODE(RFC2822)));
4207ed28
RS
682 hashcpy(cb->osha1, osha1);
683 hashcpy(cb->nsha1, nsha1);
684 cb->found_it = 1;
685 return 1;
686 }
687 hashcpy(cb->osha1, osha1);
688 hashcpy(cb->nsha1, nsha1);
689 if (cb->cnt > 0)
690 cb->cnt--;
691 return 0;
692}
693
694static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,
695 const char *email, unsigned long timestamp,
696 int tz, const char *message, void *cb_data)
697{
698 struct read_ref_at_cb *cb = cb_data;
699
700 if (cb->msg)
701 *cb->msg = xstrdup(message);
702 if (cb->cutoff_time)
703 *cb->cutoff_time = timestamp;
704 if (cb->cutoff_tz)
705 *cb->cutoff_tz = tz;
706 if (cb->cutoff_cnt)
707 *cb->cutoff_cnt = cb->reccnt;
708 hashcpy(cb->sha1, osha1);
709 if (is_null_sha1(cb->sha1))
710 hashcpy(cb->sha1, nsha1);
711 /* We just want the first entry */
712 return 1;
16d7cc90
JH
713}
714
c41a87dd 715int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,
dfefa935
MH
716 unsigned char *sha1, char **msg,
717 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 718{
4207ed28 719 struct read_ref_at_cb cb;
d556fae2 720
4207ed28
RS
721 memset(&cb, 0, sizeof(cb));
722 cb.refname = refname;
723 cb.at_time = at_time;
724 cb.cnt = cnt;
725 cb.msg = msg;
726 cb.cutoff_time = cutoff_time;
727 cb.cutoff_tz = cutoff_tz;
728 cb.cutoff_cnt = cutoff_cnt;
729 cb.sha1 = sha1;
730
731 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
732
c41a87dd
DA
733 if (!cb.reccnt) {
734 if (flags & GET_SHA1_QUIETLY)
735 exit(128);
736 else
737 die("Log for %s is empty.", refname);
738 }
4207ed28
RS
739 if (cb.found_it)
740 return 0;
741
742 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
d556fae2 743
16d7cc90 744 return 1;
d556fae2 745}
2ff81662 746
93a644ea 747struct ref_transaction *ref_transaction_begin(struct strbuf *err)
caa4046c 748{
5a603b04
JN
749 assert(err);
750
caa4046c
MH
751 return xcalloc(1, sizeof(struct ref_transaction));
752}
753
026bd1d3 754void ref_transaction_free(struct ref_transaction *transaction)
caa4046c
MH
755{
756 int i;
757
1b07255c
RS
758 if (!transaction)
759 return;
760
db7516ab
RS
761 for (i = 0; i < transaction->nr; i++) {
762 free(transaction->updates[i]->msg);
88615910 763 free(transaction->updates[i]);
db7516ab 764 }
caa4046c
MH
765 free(transaction->updates);
766 free(transaction);
767}
768
caa4046c
MH
769static struct ref_update *add_update(struct ref_transaction *transaction,
770 const char *refname)
771{
96ffc06f
JK
772 struct ref_update *update;
773 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
774 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
775 transaction->updates[transaction->nr++] = update;
776 return update;
777}
778
8e34800e
RS
779int ref_transaction_update(struct ref_transaction *transaction,
780 const char *refname,
781 const unsigned char *new_sha1,
782 const unsigned char *old_sha1,
1d147bdf 783 unsigned int flags, const char *msg,
8e34800e 784 struct strbuf *err)
caa4046c 785{
8e34800e 786 struct ref_update *update;
caa4046c 787
5a603b04
JN
788 assert(err);
789
2bdc785f
RS
790 if (transaction->state != REF_TRANSACTION_OPEN)
791 die("BUG: update called for transaction that is not open");
792
16180334 793 if (new_sha1 && !is_null_sha1(new_sha1) &&
d0f810f0
RS
794 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
795 strbuf_addf(err, "refusing to update ref with bad name %s",
796 refname);
797 return -1;
798 }
799
8e34800e 800 update = add_update(transaction, refname);
16180334
MH
801 if (new_sha1) {
802 hashcpy(update->new_sha1, new_sha1);
803 flags |= REF_HAVE_NEW;
804 }
1d147bdf 805 if (old_sha1) {
caa4046c 806 hashcpy(update->old_sha1, old_sha1);
8df4e511
MH
807 flags |= REF_HAVE_OLD;
808 }
809 update->flags = flags;
db7516ab
RS
810 if (msg)
811 update->msg = xstrdup(msg);
8e34800e 812 return 0;
caa4046c
MH
813}
814
b416af5b
RS
815int ref_transaction_create(struct ref_transaction *transaction,
816 const char *refname,
817 const unsigned char *new_sha1,
fec14ec3 818 unsigned int flags, const char *msg,
b416af5b 819 struct strbuf *err)
caa4046c 820{
f04c5b55
MH
821 if (!new_sha1 || is_null_sha1(new_sha1))
822 die("BUG: create called without valid new_sha1");
bc9f2925 823 return ref_transaction_update(transaction, refname, new_sha1,
1d147bdf 824 null_sha1, flags, msg, err);
caa4046c
MH
825}
826
8c8bdc0d
RS
827int ref_transaction_delete(struct ref_transaction *transaction,
828 const char *refname,
829 const unsigned char *old_sha1,
fb5a6bb6 830 unsigned int flags, const char *msg,
8c8bdc0d 831 struct strbuf *err)
caa4046c 832{
60294596
MH
833 if (old_sha1 && is_null_sha1(old_sha1))
834 die("BUG: delete called with old_sha1 set to zeros");
1d147bdf 835 return ref_transaction_update(transaction, refname,
fb5a6bb6 836 null_sha1, old_sha1,
1d147bdf 837 flags, msg, err);
caa4046c
MH
838}
839
16180334
MH
840int ref_transaction_verify(struct ref_transaction *transaction,
841 const char *refname,
842 const unsigned char *old_sha1,
843 unsigned int flags,
844 struct strbuf *err)
845{
846 if (!old_sha1)
847 die("BUG: verify called with old_sha1 set to NULL");
848 return ref_transaction_update(transaction, refname,
849 NULL, old_sha1,
850 flags, NULL, err);
851}
852
4b7b520b
MH
853int update_ref(const char *msg, const char *refname,
854 const unsigned char *new_sha1, const unsigned char *old_sha1,
fec14ec3 855 unsigned int flags, enum action_on_err onerr)
4738a333 856{
74ec19d4 857 struct ref_transaction *t = NULL;
b4d75ac1 858 struct strbuf err = STRBUF_INIT;
74ec19d4 859 int ret = 0;
b4d75ac1 860
74ec19d4
DT
861 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
862 ret = write_pseudoref(refname, new_sha1, old_sha1, &err);
863 } else {
864 t = ref_transaction_begin(&err);
865 if (!t ||
866 ref_transaction_update(t, refname, new_sha1, old_sha1,
867 flags, msg, &err) ||
868 ref_transaction_commit(t, &err)) {
869 ret = 1;
870 ref_transaction_free(t);
871 }
872 }
873 if (ret) {
b4d75ac1
RS
874 const char *str = "update_ref failed for ref '%s': %s";
875
b4d75ac1
RS
876 switch (onerr) {
877 case UPDATE_REFS_MSG_ON_ERR:
878 error(str, refname, err.buf);
879 break;
880 case UPDATE_REFS_DIE_ON_ERR:
881 die(str, refname, err.buf);
882 break;
883 case UPDATE_REFS_QUIET_ON_ERR:
884 break;
885 }
886 strbuf_release(&err);
4738a333 887 return 1;
b4d75ac1
RS
888 }
889 strbuf_release(&err);
74ec19d4
DT
890 if (t)
891 ref_transaction_free(t);
b4d75ac1 892 return 0;
4738a333
BK
893}
894
dfefa935 895char *shorten_unambiguous_ref(const char *refname, int strict)
7c2b3029
JK
896{
897 int i;
898 static char **scanf_fmts;
899 static int nr_rules;
900 char *short_name;
901
7c2b3029 902 if (!nr_rules) {
4346663a
MH
903 /*
904 * Pre-generate scanf formats from ref_rev_parse_rules[].
905 * Generate a format suitable for scanf from a
906 * ref_rev_parse_rules rule by interpolating "%s" at the
907 * location of the "%.*s".
908 */
7c2b3029 909 size_t total_len = 0;
84d5633f 910 size_t offset = 0;
7c2b3029
JK
911
912 /* the rule list is NULL terminated, count them first */
a4165851 913 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
914 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
915 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 916
50a6c8ef 917 scanf_fmts = xmalloc(st_add(st_mult(nr_rules, sizeof(char *)), total_len));
7c2b3029 918
84d5633f 919 offset = 0;
7c2b3029 920 for (i = 0; i < nr_rules; i++) {
4346663a 921 assert(offset < total_len);
84d5633f 922 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
4346663a
MH
923 offset += snprintf(scanf_fmts[i], total_len - offset,
924 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
925 }
926 }
927
928 /* bail out if there are no rules */
929 if (!nr_rules)
dfefa935 930 return xstrdup(refname);
7c2b3029 931
dfefa935
MH
932 /* buffer for scanf result, at most refname must fit */
933 short_name = xstrdup(refname);
7c2b3029
JK
934
935 /* skip first rule, it will always match */
936 for (i = nr_rules - 1; i > 0 ; --i) {
937 int j;
6e7b3309 938 int rules_to_fail = i;
7c2b3029
JK
939 int short_name_len;
940
dfefa935 941 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
942 continue;
943
944 short_name_len = strlen(short_name);
945
6e7b3309
BW
946 /*
947 * in strict mode, all (except the matched one) rules
948 * must fail to resolve to a valid non-ambiguous ref
949 */
950 if (strict)
951 rules_to_fail = nr_rules;
952
7c2b3029
JK
953 /*
954 * check if the short name resolves to a valid ref,
955 * but use only rules prior to the matched one
956 */
6e7b3309 957 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 958 const char *rule = ref_rev_parse_rules[j];
7c2b3029
JK
959 char refname[PATH_MAX];
960
6e7b3309
BW
961 /* skip matched rule */
962 if (i == j)
963 continue;
964
7c2b3029
JK
965 /*
966 * the short name is ambiguous, if it resolves
967 * (with this previous rule) to a valid ref
968 * read_ref() returns 0 on success
969 */
970 mksnpath(refname, sizeof(refname),
971 rule, short_name_len, short_name);
c6893323 972 if (ref_exists(refname))
7c2b3029
JK
973 break;
974 }
975
976 /*
977 * short name is non-ambiguous if all previous rules
978 * haven't resolved to a valid ref
979 */
6e7b3309 980 if (j == rules_to_fail)
7c2b3029
JK
981 return short_name;
982 }
983
984 free(short_name);
dfefa935 985 return xstrdup(refname);
7c2b3029 986}
daebaa78
JH
987
988static struct string_list *hide_refs;
989
990int parse_hide_refs_config(const char *var, const char *value, const char *section)
991{
992 if (!strcmp("transfer.hiderefs", var) ||
993 /* NEEDSWORK: use parse_config_key() once both are merged */
59556548 994 (starts_with(var, section) && var[strlen(section)] == '.' &&
daebaa78
JH
995 !strcmp(var + strlen(section), ".hiderefs"))) {
996 char *ref;
997 int len;
998
999 if (!value)
1000 return config_error_nonbool(var);
1001 ref = xstrdup(value);
1002 len = strlen(ref);
1003 while (len && ref[len - 1] == '/')
1004 ref[--len] = '\0';
1005 if (!hide_refs) {
1006 hide_refs = xcalloc(1, sizeof(*hide_refs));
1007 hide_refs->strdup_strings = 1;
1008 }
1009 string_list_append(hide_refs, ref);
1010 }
1011 return 0;
1012}
1013
78a766ab 1014int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1015{
2bc31d16 1016 int i;
daebaa78
JH
1017
1018 if (!hide_refs)
1019 return 0;
2bc31d16
JK
1020 for (i = hide_refs->nr - 1; i >= 0; i--) {
1021 const char *match = hide_refs->items[i].string;
78a766ab 1022 const char *subject;
2bc31d16 1023 int neg = 0;
daebaa78 1024 int len;
2bc31d16
JK
1025
1026 if (*match == '!') {
1027 neg = 1;
1028 match++;
1029 }
1030
78a766ab
LF
1031 if (*match == '^') {
1032 subject = refname_full;
1033 match++;
1034 } else {
1035 subject = refname;
1036 }
1037
1038 /* refname can be NULL when namespaces are used. */
1039 if (!subject || !starts_with(subject, match))
daebaa78 1040 continue;
2bc31d16 1041 len = strlen(match);
78a766ab 1042 if (!subject[len] || subject[len] == '/')
2bc31d16 1043 return !neg;
daebaa78
JH
1044 }
1045 return 0;
1046}
fa5b1830 1047
0845122c
DT
1048const char *find_descendant_ref(const char *dirname,
1049 const struct string_list *extras,
1050 const struct string_list *skip)
fa5b1830 1051{
0845122c 1052 int pos;
fa5b1830 1053
0845122c
DT
1054 if (!extras)
1055 return NULL;
fa5b1830
MH
1056
1057 /*
0845122c
DT
1058 * Look at the place where dirname would be inserted into
1059 * extras. If there is an entry at that position that starts
1060 * with dirname (remember, dirname includes the trailing
1061 * slash) and is not in skip, then we have a conflict.
fa5b1830 1062 */
0845122c
DT
1063 for (pos = string_list_find_insert_index(extras, dirname, 0);
1064 pos < extras->nr; pos++) {
1065 const char *extra_refname = extras->items[pos].string;
fa5b1830 1066
0845122c
DT
1067 if (!starts_with(extra_refname, dirname))
1068 break;
1069
1070 if (!skip || !string_list_has_string(skip, extra_refname))
1071 return extra_refname;
fa5b1830 1072 }
0845122c
DT
1073 return NULL;
1074}
fa5b1830 1075
0845122c
DT
1076int rename_ref_available(const char *oldname, const char *newname)
1077{
1078 struct string_list skip = STRING_LIST_INIT_NODUP;
1079 struct strbuf err = STRBUF_INIT;
1080 int ret;
fa5b1830 1081
0845122c
DT
1082 string_list_insert(&skip, oldname);
1083 ret = !verify_refname_available(newname, NULL, &skip, &err);
1084 if (!ret)
1085 error("%s", err.buf);
1086
1087 string_list_clear(&skip, 0);
1088 strbuf_release(&err);
1089 return ret;
fa5b1830 1090}
2bf68ed5
DT
1091
1092int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1093{
1094 struct object_id oid;
1095 int flag;
1096
1097 if (submodule) {
1098 if (resolve_gitlink_ref(submodule, "HEAD", oid.hash) == 0)
1099 return fn("HEAD", &oid, 0, cb_data);
1100
1101 return 0;
1102 }
1103
1104 if (!read_ref_full("HEAD", RESOLVE_REF_READING, oid.hash, &flag))
1105 return fn("HEAD", &oid, flag, cb_data);
1106
1107 return 0;
1108}
1109
1110int head_ref(each_ref_fn fn, void *cb_data)
1111{
1112 return head_ref_submodule(NULL, fn, cb_data);
1113}
93770590
DT
1114
1115int for_each_ref(each_ref_fn fn, void *cb_data)
1116{
1117 return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
1118}
1119
1120int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1121{
1122 return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
1123}
1124
1125int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1126{
1127 return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
1128}
1129
1130int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1131{
1132 unsigned int flag = 0;
1133
1134 if (broken)
1135 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1136 return do_for_each_ref(NULL, prefix, fn, 0, flag, cb_data);
1137}
1138
1139int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1140 each_ref_fn fn, void *cb_data)
1141{
1142 return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
1143}
1144
1145int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1146{
1147 return do_for_each_ref(NULL, git_replace_ref_base, fn,
1148 strlen(git_replace_ref_base), 0, cb_data);
1149}
1150
1151int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1152{
1153 struct strbuf buf = STRBUF_INIT;
1154 int ret;
1155 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1156 ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
1157 strbuf_release(&buf);
1158 return ret;
1159}
1160
1161int for_each_rawref(each_ref_fn fn, void *cb_data)
1162{
1163 return do_for_each_ref(NULL, "", fn, 0,
1164 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1165}
2d0663b2
DT
1166
1167/* This function needs to return a meaningful errno on failure */
1168const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1169 unsigned char *sha1, int *flags)
1170{
1171 static struct strbuf sb_refname = STRBUF_INIT;
1172 int unused_flags;
1173 int symref_count;
1174
1175 if (!flags)
1176 flags = &unused_flags;
1177
1178 *flags = 0;
1179
1180 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1181 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1182 !refname_is_safe(refname)) {
1183 errno = EINVAL;
1184 return NULL;
1185 }
1186
1187 /*
1188 * dwim_ref() uses REF_ISBROKEN to distinguish between
1189 * missing refs and refs that were present but invalid,
1190 * to complain about the latter to stderr.
1191 *
1192 * We don't know whether the ref exists, so don't set
1193 * REF_ISBROKEN yet.
1194 */
1195 *flags |= REF_BAD_NAME;
1196 }
1197
1198 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1199 unsigned int read_flags = 0;
1200
1201 if (read_raw_ref(refname, sha1, &sb_refname, &read_flags)) {
1202 *flags |= read_flags;
1203 if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING))
1204 return NULL;
1205 hashclr(sha1);
1206 if (*flags & REF_BAD_NAME)
1207 *flags |= REF_ISBROKEN;
1208 return refname;
1209 }
1210
1211 *flags |= read_flags;
1212
1213 if (!(read_flags & REF_ISSYMREF)) {
1214 if (*flags & REF_BAD_NAME) {
1215 hashclr(sha1);
1216 *flags |= REF_ISBROKEN;
1217 }
1218 return refname;
1219 }
1220
1221 refname = sb_refname.buf;
1222 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1223 hashclr(sha1);
1224 return refname;
1225 }
1226 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1227 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1228 !refname_is_safe(refname)) {
1229 errno = EINVAL;
1230 return NULL;
1231 }
1232
1233 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1234 }
1235 }
1236
1237 errno = ELOOP;
1238 return NULL;
1239}