sha1_name: convert get_sha1_mb to struct object_id
[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) {
0568c8e9 507 strbuf_addf(err, "could not open '%s' for writing: %s",
74ec19d4
DT
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 517 if (hashcmp(actual_old_sha1, old_sha1)) {
0568c8e9 518 strbuf_addf(err, "unexpected sha1 when writing '%s'", pseudoref);
74ec19d4
DT
519 rollback_lock_file(&lock);
520 goto done;
521 }
522 }
523
524 if (write_in_full(fd, buf.buf, buf.len) != buf.len) {
0568c8e9 525 strbuf_addf(err, "could not write to '%s'", filename);
74ec19d4
DT
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
71564516
MH
769struct ref_update *ref_transaction_add_update(
770 struct ref_transaction *transaction,
771 const char *refname, unsigned int flags,
772 const unsigned char *new_sha1,
773 const unsigned char *old_sha1,
774 const char *msg)
caa4046c 775{
96ffc06f 776 struct ref_update *update;
71564516
MH
777
778 if (transaction->state != REF_TRANSACTION_OPEN)
779 die("BUG: update called for transaction that is not open");
780
781 if ((flags & REF_ISPRUNING) && !(flags & REF_NODEREF))
782 die("BUG: REF_ISPRUNING set without REF_NODEREF");
783
96ffc06f 784 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
785 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
786 transaction->updates[transaction->nr++] = update;
71564516
MH
787
788 update->flags = flags;
789
790 if (flags & REF_HAVE_NEW)
791 hashcpy(update->new_sha1, new_sha1);
792 if (flags & REF_HAVE_OLD)
793 hashcpy(update->old_sha1, old_sha1);
794 if (msg)
795 update->msg = xstrdup(msg);
caa4046c
MH
796 return update;
797}
798
8e34800e
RS
799int ref_transaction_update(struct ref_transaction *transaction,
800 const char *refname,
801 const unsigned char *new_sha1,
802 const unsigned char *old_sha1,
1d147bdf 803 unsigned int flags, const char *msg,
8e34800e 804 struct strbuf *err)
caa4046c 805{
5a603b04
JN
806 assert(err);
807
8a679de6
MH
808 if ((new_sha1 && !is_null_sha1(new_sha1)) ?
809 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
810 !refname_is_safe(refname)) {
0568c8e9 811 strbuf_addf(err, "refusing to update ref with bad name '%s'",
d0f810f0
RS
812 refname);
813 return -1;
814 }
815
71564516
MH
816 flags |= (new_sha1 ? REF_HAVE_NEW : 0) | (old_sha1 ? REF_HAVE_OLD : 0);
817
818 ref_transaction_add_update(transaction, refname, flags,
819 new_sha1, old_sha1, msg);
8e34800e 820 return 0;
caa4046c
MH
821}
822
b416af5b
RS
823int ref_transaction_create(struct ref_transaction *transaction,
824 const char *refname,
825 const unsigned char *new_sha1,
fec14ec3 826 unsigned int flags, const char *msg,
b416af5b 827 struct strbuf *err)
caa4046c 828{
f04c5b55
MH
829 if (!new_sha1 || is_null_sha1(new_sha1))
830 die("BUG: create called without valid new_sha1");
bc9f2925 831 return ref_transaction_update(transaction, refname, new_sha1,
1d147bdf 832 null_sha1, flags, msg, err);
caa4046c
MH
833}
834
8c8bdc0d
RS
835int ref_transaction_delete(struct ref_transaction *transaction,
836 const char *refname,
837 const unsigned char *old_sha1,
fb5a6bb6 838 unsigned int flags, const char *msg,
8c8bdc0d 839 struct strbuf *err)
caa4046c 840{
60294596
MH
841 if (old_sha1 && is_null_sha1(old_sha1))
842 die("BUG: delete called with old_sha1 set to zeros");
1d147bdf 843 return ref_transaction_update(transaction, refname,
fb5a6bb6 844 null_sha1, old_sha1,
1d147bdf 845 flags, msg, err);
caa4046c
MH
846}
847
16180334
MH
848int ref_transaction_verify(struct ref_transaction *transaction,
849 const char *refname,
850 const unsigned char *old_sha1,
851 unsigned int flags,
852 struct strbuf *err)
853{
854 if (!old_sha1)
855 die("BUG: verify called with old_sha1 set to NULL");
856 return ref_transaction_update(transaction, refname,
857 NULL, old_sha1,
858 flags, NULL, err);
859}
860
4b7b520b
MH
861int update_ref(const char *msg, const char *refname,
862 const unsigned char *new_sha1, const unsigned char *old_sha1,
fec14ec3 863 unsigned int flags, enum action_on_err onerr)
4738a333 864{
74ec19d4 865 struct ref_transaction *t = NULL;
b4d75ac1 866 struct strbuf err = STRBUF_INIT;
74ec19d4 867 int ret = 0;
b4d75ac1 868
74ec19d4
DT
869 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
870 ret = write_pseudoref(refname, new_sha1, old_sha1, &err);
871 } else {
872 t = ref_transaction_begin(&err);
873 if (!t ||
874 ref_transaction_update(t, refname, new_sha1, old_sha1,
875 flags, msg, &err) ||
876 ref_transaction_commit(t, &err)) {
877 ret = 1;
878 ref_transaction_free(t);
879 }
880 }
881 if (ret) {
b4d75ac1
RS
882 const char *str = "update_ref failed for ref '%s': %s";
883
b4d75ac1
RS
884 switch (onerr) {
885 case UPDATE_REFS_MSG_ON_ERR:
886 error(str, refname, err.buf);
887 break;
888 case UPDATE_REFS_DIE_ON_ERR:
889 die(str, refname, err.buf);
890 break;
891 case UPDATE_REFS_QUIET_ON_ERR:
892 break;
893 }
894 strbuf_release(&err);
4738a333 895 return 1;
b4d75ac1
RS
896 }
897 strbuf_release(&err);
74ec19d4
DT
898 if (t)
899 ref_transaction_free(t);
b4d75ac1 900 return 0;
4738a333
BK
901}
902
dfefa935 903char *shorten_unambiguous_ref(const char *refname, int strict)
7c2b3029
JK
904{
905 int i;
906 static char **scanf_fmts;
907 static int nr_rules;
908 char *short_name;
909
7c2b3029 910 if (!nr_rules) {
4346663a
MH
911 /*
912 * Pre-generate scanf formats from ref_rev_parse_rules[].
913 * Generate a format suitable for scanf from a
914 * ref_rev_parse_rules rule by interpolating "%s" at the
915 * location of the "%.*s".
916 */
7c2b3029 917 size_t total_len = 0;
84d5633f 918 size_t offset = 0;
7c2b3029
JK
919
920 /* the rule list is NULL terminated, count them first */
a4165851 921 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
922 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
923 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 924
50492f7b 925 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
7c2b3029 926
84d5633f 927 offset = 0;
7c2b3029 928 for (i = 0; i < nr_rules; i++) {
4346663a 929 assert(offset < total_len);
84d5633f 930 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
4346663a
MH
931 offset += snprintf(scanf_fmts[i], total_len - offset,
932 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
933 }
934 }
935
936 /* bail out if there are no rules */
937 if (!nr_rules)
dfefa935 938 return xstrdup(refname);
7c2b3029 939
dfefa935
MH
940 /* buffer for scanf result, at most refname must fit */
941 short_name = xstrdup(refname);
7c2b3029
JK
942
943 /* skip first rule, it will always match */
944 for (i = nr_rules - 1; i > 0 ; --i) {
945 int j;
6e7b3309 946 int rules_to_fail = i;
7c2b3029
JK
947 int short_name_len;
948
dfefa935 949 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
950 continue;
951
952 short_name_len = strlen(short_name);
953
6e7b3309
BW
954 /*
955 * in strict mode, all (except the matched one) rules
956 * must fail to resolve to a valid non-ambiguous ref
957 */
958 if (strict)
959 rules_to_fail = nr_rules;
960
7c2b3029
JK
961 /*
962 * check if the short name resolves to a valid ref,
963 * but use only rules prior to the matched one
964 */
6e7b3309 965 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 966 const char *rule = ref_rev_parse_rules[j];
7c2b3029
JK
967 char refname[PATH_MAX];
968
6e7b3309
BW
969 /* skip matched rule */
970 if (i == j)
971 continue;
972
7c2b3029
JK
973 /*
974 * the short name is ambiguous, if it resolves
975 * (with this previous rule) to a valid ref
976 * read_ref() returns 0 on success
977 */
978 mksnpath(refname, sizeof(refname),
979 rule, short_name_len, short_name);
c6893323 980 if (ref_exists(refname))
7c2b3029
JK
981 break;
982 }
983
984 /*
985 * short name is non-ambiguous if all previous rules
986 * haven't resolved to a valid ref
987 */
6e7b3309 988 if (j == rules_to_fail)
7c2b3029
JK
989 return short_name;
990 }
991
992 free(short_name);
dfefa935 993 return xstrdup(refname);
7c2b3029 994}
daebaa78
JH
995
996static struct string_list *hide_refs;
997
998int parse_hide_refs_config(const char *var, const char *value, const char *section)
999{
1000 if (!strcmp("transfer.hiderefs", var) ||
1001 /* NEEDSWORK: use parse_config_key() once both are merged */
59556548 1002 (starts_with(var, section) && var[strlen(section)] == '.' &&
daebaa78
JH
1003 !strcmp(var + strlen(section), ".hiderefs"))) {
1004 char *ref;
1005 int len;
1006
1007 if (!value)
1008 return config_error_nonbool(var);
1009 ref = xstrdup(value);
1010 len = strlen(ref);
1011 while (len && ref[len - 1] == '/')
1012 ref[--len] = '\0';
1013 if (!hide_refs) {
1014 hide_refs = xcalloc(1, sizeof(*hide_refs));
1015 hide_refs->strdup_strings = 1;
1016 }
1017 string_list_append(hide_refs, ref);
1018 }
1019 return 0;
1020}
1021
78a766ab 1022int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1023{
2bc31d16 1024 int i;
daebaa78
JH
1025
1026 if (!hide_refs)
1027 return 0;
2bc31d16
JK
1028 for (i = hide_refs->nr - 1; i >= 0; i--) {
1029 const char *match = hide_refs->items[i].string;
78a766ab 1030 const char *subject;
2bc31d16 1031 int neg = 0;
daebaa78 1032 int len;
2bc31d16
JK
1033
1034 if (*match == '!') {
1035 neg = 1;
1036 match++;
1037 }
1038
78a766ab
LF
1039 if (*match == '^') {
1040 subject = refname_full;
1041 match++;
1042 } else {
1043 subject = refname;
1044 }
1045
1046 /* refname can be NULL when namespaces are used. */
1047 if (!subject || !starts_with(subject, match))
daebaa78 1048 continue;
2bc31d16 1049 len = strlen(match);
78a766ab 1050 if (!subject[len] || subject[len] == '/')
2bc31d16 1051 return !neg;
daebaa78
JH
1052 }
1053 return 0;
1054}
fa5b1830 1055
0845122c
DT
1056const char *find_descendant_ref(const char *dirname,
1057 const struct string_list *extras,
1058 const struct string_list *skip)
fa5b1830 1059{
0845122c 1060 int pos;
fa5b1830 1061
0845122c
DT
1062 if (!extras)
1063 return NULL;
fa5b1830
MH
1064
1065 /*
0845122c
DT
1066 * Look at the place where dirname would be inserted into
1067 * extras. If there is an entry at that position that starts
1068 * with dirname (remember, dirname includes the trailing
1069 * slash) and is not in skip, then we have a conflict.
fa5b1830 1070 */
0845122c
DT
1071 for (pos = string_list_find_insert_index(extras, dirname, 0);
1072 pos < extras->nr; pos++) {
1073 const char *extra_refname = extras->items[pos].string;
fa5b1830 1074
0845122c
DT
1075 if (!starts_with(extra_refname, dirname))
1076 break;
1077
1078 if (!skip || !string_list_has_string(skip, extra_refname))
1079 return extra_refname;
fa5b1830 1080 }
0845122c
DT
1081 return NULL;
1082}
fa5b1830 1083
0845122c
DT
1084int rename_ref_available(const char *oldname, const char *newname)
1085{
1086 struct string_list skip = STRING_LIST_INIT_NODUP;
1087 struct strbuf err = STRBUF_INIT;
1088 int ret;
fa5b1830 1089
0845122c
DT
1090 string_list_insert(&skip, oldname);
1091 ret = !verify_refname_available(newname, NULL, &skip, &err);
1092 if (!ret)
1093 error("%s", err.buf);
1094
1095 string_list_clear(&skip, 0);
1096 strbuf_release(&err);
1097 return ret;
fa5b1830 1098}
2bf68ed5
DT
1099
1100int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1101{
1102 struct object_id oid;
1103 int flag;
1104
1105 if (submodule) {
1106 if (resolve_gitlink_ref(submodule, "HEAD", oid.hash) == 0)
1107 return fn("HEAD", &oid, 0, cb_data);
1108
1109 return 0;
1110 }
1111
1112 if (!read_ref_full("HEAD", RESOLVE_REF_READING, oid.hash, &flag))
1113 return fn("HEAD", &oid, flag, cb_data);
1114
1115 return 0;
1116}
1117
1118int head_ref(each_ref_fn fn, void *cb_data)
1119{
1120 return head_ref_submodule(NULL, fn, cb_data);
1121}
93770590 1122
4c4de895
MH
1123/*
1124 * Call fn for each reference in the specified submodule for which the
1125 * refname begins with prefix. If trim is non-zero, then trim that
1126 * many characters off the beginning of each refname before passing
1127 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1128 * include broken references in the iteration. If fn ever returns a
1129 * non-zero value, stop the iteration and return that value;
1130 * otherwise, return 0.
1131 */
1132static int do_for_each_ref(const char *submodule, const char *prefix,
1133 each_ref_fn fn, int trim, int flags, void *cb_data)
1134{
1135 struct ref_iterator *iter;
1136
1137 iter = files_ref_iterator_begin(submodule, prefix, flags);
1138 iter = prefix_ref_iterator_begin(iter, prefix, trim);
1139
1140 return do_for_each_ref_iterator(iter, fn, cb_data);
1141}
1142
93770590
DT
1143int for_each_ref(each_ref_fn fn, void *cb_data)
1144{
1145 return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
1146}
1147
1148int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1149{
1150 return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
1151}
1152
1153int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1154{
1155 return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
1156}
1157
1158int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1159{
1160 unsigned int flag = 0;
1161
1162 if (broken)
1163 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1164 return do_for_each_ref(NULL, prefix, fn, 0, flag, cb_data);
1165}
1166
1167int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1168 each_ref_fn fn, void *cb_data)
1169{
1170 return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
1171}
1172
1173int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1174{
1175 return do_for_each_ref(NULL, git_replace_ref_base, fn,
1176 strlen(git_replace_ref_base), 0, cb_data);
1177}
1178
1179int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1180{
1181 struct strbuf buf = STRBUF_INIT;
1182 int ret;
1183 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1184 ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
1185 strbuf_release(&buf);
1186 return ret;
1187}
1188
1189int for_each_rawref(each_ref_fn fn, void *cb_data)
1190{
1191 return do_for_each_ref(NULL, "", fn, 0,
1192 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1193}
2d0663b2
DT
1194
1195/* This function needs to return a meaningful errno on failure */
1196const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1197 unsigned char *sha1, int *flags)
1198{
1199 static struct strbuf sb_refname = STRBUF_INIT;
1200 int unused_flags;
1201 int symref_count;
1202
1203 if (!flags)
1204 flags = &unused_flags;
1205
1206 *flags = 0;
1207
1208 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1209 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1210 !refname_is_safe(refname)) {
1211 errno = EINVAL;
1212 return NULL;
1213 }
1214
1215 /*
1216 * dwim_ref() uses REF_ISBROKEN to distinguish between
1217 * missing refs and refs that were present but invalid,
1218 * to complain about the latter to stderr.
1219 *
1220 * We don't know whether the ref exists, so don't set
1221 * REF_ISBROKEN yet.
1222 */
1223 *flags |= REF_BAD_NAME;
1224 }
1225
1226 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1227 unsigned int read_flags = 0;
1228
1229 if (read_raw_ref(refname, sha1, &sb_refname, &read_flags)) {
1230 *flags |= read_flags;
1231 if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING))
1232 return NULL;
1233 hashclr(sha1);
1234 if (*flags & REF_BAD_NAME)
1235 *flags |= REF_ISBROKEN;
1236 return refname;
1237 }
1238
1239 *flags |= read_flags;
1240
1241 if (!(read_flags & REF_ISSYMREF)) {
1242 if (*flags & REF_BAD_NAME) {
1243 hashclr(sha1);
1244 *flags |= REF_ISBROKEN;
1245 }
1246 return refname;
1247 }
1248
1249 refname = sb_refname.buf;
1250 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1251 hashclr(sha1);
1252 return refname;
1253 }
1254 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1255 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1256 !refname_is_safe(refname)) {
1257 errno = EINVAL;
1258 return NULL;
1259 }
1260
1261 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1262 }
1263 }
1264
1265 errno = ELOOP;
1266 return NULL;
1267}