cd61509bc88a07081717870acb2fbbe27cc10cde
1/*
2 * The backend-independent part of the reference module.
3 */
4
5#include "cache.h"
6#include "config.h"
7#include "hashmap.h"
8#include "lockfile.h"
9#include "iterator.h"
10#include "refs.h"
11#include "refs/refs-internal.h"
12#include "object.h"
13#include "tag.h"
14#include "submodule.h"
15#include "worktree.h"
16
17/*
18 * List of all available backends
19 */
20static struct ref_storage_be *refs_backends = &refs_be_files;
21
22static struct ref_storage_be *find_ref_storage_backend(const char *name)
23{
24 struct ref_storage_be *be;
25 for (be = refs_backends; be; be = be->next)
26 if (!strcmp(be->name, name))
27 return be;
28 return NULL;
29}
30
31int ref_storage_backend_exists(const char *name)
32{
33 return find_ref_storage_backend(name) != NULL;
34}
35
36/*
37 * How to handle various characters in refnames:
38 * 0: An acceptable character for refs
39 * 1: End-of-component
40 * 2: ., look for a preceding . to reject .. in refs
41 * 3: {, look for a preceding @ to reject @{ in refs
42 * 4: A bad character: ASCII control characters, and
43 * ":", "?", "[", "\", "^", "~", SP, or TAB
44 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
45 */
46static unsigned char refname_disposition[256] = {
47 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
48 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
49 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
50 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
55};
56
57/*
58 * Try to read one refname component from the front of refname.
59 * Return the length of the component found, or -1 if the component is
60 * not legal. It is legal if it is something reasonable to have under
61 * ".git/refs/"; We do not like it if:
62 *
63 * - any path component of it begins with ".", or
64 * - it has double dots "..", or
65 * - it has ASCII control characters, or
66 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
67 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
68 * - it ends with a "/", or
69 * - it ends with ".lock", or
70 * - it contains a "@{" portion
71 */
72static int check_refname_component(const char *refname, int *flags)
73{
74 const char *cp;
75 char last = '\0';
76
77 for (cp = refname; ; cp++) {
78 int ch = *cp & 255;
79 unsigned char disp = refname_disposition[ch];
80 switch (disp) {
81 case 1:
82 goto out;
83 case 2:
84 if (last == '.')
85 return -1; /* Refname contains "..". */
86 break;
87 case 3:
88 if (last == '@')
89 return -1; /* Refname contains "@{". */
90 break;
91 case 4:
92 return -1;
93 case 5:
94 if (!(*flags & REFNAME_REFSPEC_PATTERN))
95 return -1; /* refspec can't be a pattern */
96
97 /*
98 * Unset the pattern flag so that we only accept
99 * a single asterisk for one side of refspec.
100 */
101 *flags &= ~ REFNAME_REFSPEC_PATTERN;
102 break;
103 }
104 last = ch;
105 }
106out:
107 if (cp == refname)
108 return 0; /* Component has zero length. */
109 if (refname[0] == '.')
110 return -1; /* Component starts with '.'. */
111 if (cp - refname >= LOCK_SUFFIX_LEN &&
112 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN))
113 return -1; /* Refname ends with ".lock". */
114 return cp - refname;
115}
116
117int check_refname_format(const char *refname, int flags)
118{
119 int component_len, component_count = 0;
120
121 if (!strcmp(refname, "@"))
122 /* Refname is a single character '@'. */
123 return -1;
124
125 while (1) {
126 /* We are at the start of a path component. */
127 component_len = check_refname_component(refname, &flags);
128 if (component_len <= 0)
129 return -1;
130
131 component_count++;
132 if (refname[component_len] == '\0')
133 break;
134 /* Skip to next component. */
135 refname += component_len + 1;
136 }
137
138 if (refname[component_len - 1] == '.')
139 return -1; /* Refname ends with '.'. */
140 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
141 return -1; /* Refname has only one component. */
142 return 0;
143}
144
145int refname_is_safe(const char *refname)
146{
147 const char *rest;
148
149 if (skip_prefix(refname, "refs/", &rest)) {
150 char *buf;
151 int result;
152 size_t restlen = strlen(rest);
153
154 /* rest must not be empty, or start or end with "/" */
155 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
156 return 0;
157
158 /*
159 * Does the refname try to escape refs/?
160 * For example: refs/foo/../bar is safe but refs/foo/../../bar
161 * is not.
162 */
163 buf = xmallocz(restlen);
164 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
165 free(buf);
166 return result;
167 }
168
169 do {
170 if (!isupper(*refname) && *refname != '_')
171 return 0;
172 refname++;
173 } while (*refname);
174 return 1;
175}
176
177/*
178 * Return true if refname, which has the specified oid and flags, can
179 * be resolved to an object in the database. If the referred-to object
180 * does not exist, emit a warning and return false.
181 */
182int ref_resolves_to_object(const char *refname,
183 const struct object_id *oid,
184 unsigned int flags)
185{
186 if (flags & REF_ISBROKEN)
187 return 0;
188 if (!has_sha1_file(oid->hash)) {
189 error("%s does not point to a valid object!", refname);
190 return 0;
191 }
192 return 1;
193}
194
195char *refs_resolve_refdup(struct ref_store *refs,
196 const char *refname, int resolve_flags,
197 unsigned char *sha1, int *flags)
198{
199 const char *result;
200
201 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
202 sha1, flags);
203 return xstrdup_or_null(result);
204}
205
206char *resolve_refdup(const char *refname, int resolve_flags,
207 unsigned char *sha1, int *flags)
208{
209 return refs_resolve_refdup(get_main_ref_store(),
210 refname, resolve_flags,
211 sha1, flags);
212}
213
214/* The argument to filter_refs */
215struct ref_filter {
216 const char *pattern;
217 each_ref_fn *fn;
218 void *cb_data;
219};
220
221int refs_read_ref_full(struct ref_store *refs, const char *refname,
222 int resolve_flags, unsigned char *sha1, int *flags)
223{
224 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, sha1, flags))
225 return 0;
226 return -1;
227}
228
229int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
230{
231 return refs_read_ref_full(get_main_ref_store(), refname,
232 resolve_flags, sha1, flags);
233}
234
235int read_ref(const char *refname, unsigned char *sha1)
236{
237 return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
238}
239
240int ref_exists(const char *refname)
241{
242 unsigned char sha1[20];
243 return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
244}
245
246static int filter_refs(const char *refname, const struct object_id *oid,
247 int flags, void *data)
248{
249 struct ref_filter *filter = (struct ref_filter *)data;
250
251 if (wildmatch(filter->pattern, refname, 0))
252 return 0;
253 return filter->fn(refname, oid, flags, filter->cb_data);
254}
255
256enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
257{
258 struct object *o = lookup_unknown_object(name);
259
260 if (o->type == OBJ_NONE) {
261 int type = sha1_object_info(name, NULL);
262 if (type < 0 || !object_as_type(o, type, 0))
263 return PEEL_INVALID;
264 }
265
266 if (o->type != OBJ_TAG)
267 return PEEL_NON_TAG;
268
269 o = deref_tag_noverify(o);
270 if (!o)
271 return PEEL_INVALID;
272
273 hashcpy(sha1, o->oid.hash);
274 return PEEL_PEELED;
275}
276
277struct warn_if_dangling_data {
278 FILE *fp;
279 const char *refname;
280 const struct string_list *refnames;
281 const char *msg_fmt;
282};
283
284static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
285 int flags, void *cb_data)
286{
287 struct warn_if_dangling_data *d = cb_data;
288 const char *resolves_to;
289 struct object_id junk;
290
291 if (!(flags & REF_ISSYMREF))
292 return 0;
293
294 resolves_to = resolve_ref_unsafe(refname, 0, junk.hash, NULL);
295 if (!resolves_to
296 || (d->refname
297 ? strcmp(resolves_to, d->refname)
298 : !string_list_has_string(d->refnames, resolves_to))) {
299 return 0;
300 }
301
302 fprintf(d->fp, d->msg_fmt, refname);
303 fputc('\n', d->fp);
304 return 0;
305}
306
307void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
308{
309 struct warn_if_dangling_data data;
310
311 data.fp = fp;
312 data.refname = refname;
313 data.refnames = NULL;
314 data.msg_fmt = msg_fmt;
315 for_each_rawref(warn_if_dangling_symref, &data);
316}
317
318void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
319{
320 struct warn_if_dangling_data data;
321
322 data.fp = fp;
323 data.refname = NULL;
324 data.refnames = refnames;
325 data.msg_fmt = msg_fmt;
326 for_each_rawref(warn_if_dangling_symref, &data);
327}
328
329int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
330{
331 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
332}
333
334int for_each_tag_ref(each_ref_fn fn, void *cb_data)
335{
336 return refs_for_each_tag_ref(get_main_ref_store(), fn, cb_data);
337}
338
339int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
340{
341 return refs_for_each_tag_ref(get_submodule_ref_store(submodule),
342 fn, cb_data);
343}
344
345int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
346{
347 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
348}
349
350int for_each_branch_ref(each_ref_fn fn, void *cb_data)
351{
352 return refs_for_each_branch_ref(get_main_ref_store(), fn, cb_data);
353}
354
355int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
356{
357 return refs_for_each_branch_ref(get_submodule_ref_store(submodule),
358 fn, cb_data);
359}
360
361int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
362{
363 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
364}
365
366int for_each_remote_ref(each_ref_fn fn, void *cb_data)
367{
368 return refs_for_each_remote_ref(get_main_ref_store(), fn, cb_data);
369}
370
371int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
372{
373 return refs_for_each_remote_ref(get_submodule_ref_store(submodule),
374 fn, cb_data);
375}
376
377int head_ref_namespaced(each_ref_fn fn, void *cb_data)
378{
379 struct strbuf buf = STRBUF_INIT;
380 int ret = 0;
381 struct object_id oid;
382 int flag;
383
384 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
385 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, oid.hash, &flag))
386 ret = fn(buf.buf, &oid, flag, cb_data);
387 strbuf_release(&buf);
388
389 return ret;
390}
391
392int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
393 const char *prefix, void *cb_data)
394{
395 struct strbuf real_pattern = STRBUF_INIT;
396 struct ref_filter filter;
397 int ret;
398
399 if (!prefix && !starts_with(pattern, "refs/"))
400 strbuf_addstr(&real_pattern, "refs/");
401 else if (prefix)
402 strbuf_addstr(&real_pattern, prefix);
403 strbuf_addstr(&real_pattern, pattern);
404
405 if (!has_glob_specials(pattern)) {
406 /* Append implied '/' '*' if not present. */
407 strbuf_complete(&real_pattern, '/');
408 /* No need to check for '*', there is none. */
409 strbuf_addch(&real_pattern, '*');
410 }
411
412 filter.pattern = real_pattern.buf;
413 filter.fn = fn;
414 filter.cb_data = cb_data;
415 ret = for_each_ref(filter_refs, &filter);
416
417 strbuf_release(&real_pattern);
418 return ret;
419}
420
421int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
422{
423 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
424}
425
426const char *prettify_refname(const char *name)
427{
428 if (skip_prefix(name, "refs/heads/", &name) ||
429 skip_prefix(name, "refs/tags/", &name) ||
430 skip_prefix(name, "refs/remotes/", &name))
431 ; /* nothing */
432 return name;
433}
434
435static const char *ref_rev_parse_rules[] = {
436 "%.*s",
437 "refs/%.*s",
438 "refs/tags/%.*s",
439 "refs/heads/%.*s",
440 "refs/remotes/%.*s",
441 "refs/remotes/%.*s/HEAD",
442 NULL
443};
444
445int refname_match(const char *abbrev_name, const char *full_name)
446{
447 const char **p;
448 const int abbrev_name_len = strlen(abbrev_name);
449
450 for (p = ref_rev_parse_rules; *p; p++) {
451 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
452 return 1;
453 }
454 }
455
456 return 0;
457}
458
459/*
460 * *string and *len will only be substituted, and *string returned (for
461 * later free()ing) if the string passed in is a magic short-hand form
462 * to name a branch.
463 */
464static char *substitute_branch_name(const char **string, int *len)
465{
466 struct strbuf buf = STRBUF_INIT;
467 int ret = interpret_branch_name(*string, *len, &buf, 0);
468
469 if (ret == *len) {
470 size_t size;
471 *string = strbuf_detach(&buf, &size);
472 *len = size;
473 return (char *)*string;
474 }
475
476 return NULL;
477}
478
479int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
480{
481 char *last_branch = substitute_branch_name(&str, &len);
482 int refs_found = expand_ref(str, len, sha1, ref);
483 free(last_branch);
484 return refs_found;
485}
486
487int expand_ref(const char *str, int len, unsigned char *sha1, char **ref)
488{
489 const char **p, *r;
490 int refs_found = 0;
491 struct strbuf fullref = STRBUF_INIT;
492
493 *ref = NULL;
494 for (p = ref_rev_parse_rules; *p; p++) {
495 unsigned char sha1_from_ref[20];
496 unsigned char *this_result;
497 int flag;
498
499 this_result = refs_found ? sha1_from_ref : sha1;
500 strbuf_reset(&fullref);
501 strbuf_addf(&fullref, *p, len, str);
502 r = resolve_ref_unsafe(fullref.buf, RESOLVE_REF_READING,
503 this_result, &flag);
504 if (r) {
505 if (!refs_found++)
506 *ref = xstrdup(r);
507 if (!warn_ambiguous_refs)
508 break;
509 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
510 warning("ignoring dangling symref %s.", fullref.buf);
511 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
512 warning("ignoring broken ref %s.", fullref.buf);
513 }
514 }
515 strbuf_release(&fullref);
516 return refs_found;
517}
518
519int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
520{
521 char *last_branch = substitute_branch_name(&str, &len);
522 const char **p;
523 int logs_found = 0;
524 struct strbuf path = STRBUF_INIT;
525
526 *log = NULL;
527 for (p = ref_rev_parse_rules; *p; p++) {
528 unsigned char hash[20];
529 const char *ref, *it;
530
531 strbuf_reset(&path);
532 strbuf_addf(&path, *p, len, str);
533 ref = resolve_ref_unsafe(path.buf, RESOLVE_REF_READING,
534 hash, NULL);
535 if (!ref)
536 continue;
537 if (reflog_exists(path.buf))
538 it = path.buf;
539 else if (strcmp(ref, path.buf) && reflog_exists(ref))
540 it = ref;
541 else
542 continue;
543 if (!logs_found++) {
544 *log = xstrdup(it);
545 hashcpy(sha1, hash);
546 }
547 if (!warn_ambiguous_refs)
548 break;
549 }
550 strbuf_release(&path);
551 free(last_branch);
552 return logs_found;
553}
554
555static int is_per_worktree_ref(const char *refname)
556{
557 return !strcmp(refname, "HEAD") ||
558 starts_with(refname, "refs/bisect/");
559}
560
561static int is_pseudoref_syntax(const char *refname)
562{
563 const char *c;
564
565 for (c = refname; *c; c++) {
566 if (!isupper(*c) && *c != '-' && *c != '_')
567 return 0;
568 }
569
570 return 1;
571}
572
573enum ref_type ref_type(const char *refname)
574{
575 if (is_per_worktree_ref(refname))
576 return REF_TYPE_PER_WORKTREE;
577 if (is_pseudoref_syntax(refname))
578 return REF_TYPE_PSEUDOREF;
579 return REF_TYPE_NORMAL;
580}
581
582static int write_pseudoref(const char *pseudoref, const unsigned char *sha1,
583 const unsigned char *old_sha1, struct strbuf *err)
584{
585 const char *filename;
586 int fd;
587 static struct lock_file lock;
588 struct strbuf buf = STRBUF_INIT;
589 int ret = -1;
590
591 strbuf_addf(&buf, "%s\n", sha1_to_hex(sha1));
592
593 filename = git_path("%s", pseudoref);
594 fd = hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);
595 if (fd < 0) {
596 strbuf_addf(err, "could not open '%s' for writing: %s",
597 filename, strerror(errno));
598 return -1;
599 }
600
601 if (old_sha1) {
602 unsigned char actual_old_sha1[20];
603
604 if (read_ref(pseudoref, actual_old_sha1))
605 die("could not read ref '%s'", pseudoref);
606 if (hashcmp(actual_old_sha1, old_sha1)) {
607 strbuf_addf(err, "unexpected sha1 when writing '%s'", pseudoref);
608 rollback_lock_file(&lock);
609 goto done;
610 }
611 }
612
613 if (write_in_full(fd, buf.buf, buf.len) != buf.len) {
614 strbuf_addf(err, "could not write to '%s'", filename);
615 rollback_lock_file(&lock);
616 goto done;
617 }
618
619 commit_lock_file(&lock);
620 ret = 0;
621done:
622 strbuf_release(&buf);
623 return ret;
624}
625
626static int delete_pseudoref(const char *pseudoref, const unsigned char *old_sha1)
627{
628 static struct lock_file lock;
629 const char *filename;
630
631 filename = git_path("%s", pseudoref);
632
633 if (old_sha1 && !is_null_sha1(old_sha1)) {
634 int fd;
635 unsigned char actual_old_sha1[20];
636
637 fd = hold_lock_file_for_update(&lock, filename,
638 LOCK_DIE_ON_ERROR);
639 if (fd < 0)
640 die_errno(_("Could not open '%s' for writing"), filename);
641 if (read_ref(pseudoref, actual_old_sha1))
642 die("could not read ref '%s'", pseudoref);
643 if (hashcmp(actual_old_sha1, old_sha1)) {
644 warning("Unexpected sha1 when deleting %s", pseudoref);
645 rollback_lock_file(&lock);
646 return -1;
647 }
648
649 unlink(filename);
650 rollback_lock_file(&lock);
651 } else {
652 unlink(filename);
653 }
654
655 return 0;
656}
657
658int refs_delete_ref(struct ref_store *refs, const char *msg,
659 const char *refname,
660 const unsigned char *old_sha1,
661 unsigned int flags)
662{
663 struct ref_transaction *transaction;
664 struct strbuf err = STRBUF_INIT;
665
666 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
667 assert(refs == get_main_ref_store());
668 return delete_pseudoref(refname, old_sha1);
669 }
670
671 transaction = ref_store_transaction_begin(refs, &err);
672 if (!transaction ||
673 ref_transaction_delete(transaction, refname, old_sha1,
674 flags, msg, &err) ||
675 ref_transaction_commit(transaction, &err)) {
676 error("%s", err.buf);
677 ref_transaction_free(transaction);
678 strbuf_release(&err);
679 return 1;
680 }
681 ref_transaction_free(transaction);
682 strbuf_release(&err);
683 return 0;
684}
685
686int delete_ref(const char *msg, const char *refname,
687 const unsigned char *old_sha1, unsigned int flags)
688{
689 return refs_delete_ref(get_main_ref_store(), msg, refname,
690 old_sha1, flags);
691}
692
693int copy_reflog_msg(char *buf, const char *msg)
694{
695 char *cp = buf;
696 char c;
697 int wasspace = 1;
698
699 *cp++ = '\t';
700 while ((c = *msg++)) {
701 if (wasspace && isspace(c))
702 continue;
703 wasspace = isspace(c);
704 if (wasspace)
705 c = ' ';
706 *cp++ = c;
707 }
708 while (buf < cp && isspace(cp[-1]))
709 cp--;
710 *cp++ = '\n';
711 return cp - buf;
712}
713
714int should_autocreate_reflog(const char *refname)
715{
716 switch (log_all_ref_updates) {
717 case LOG_REFS_ALWAYS:
718 return 1;
719 case LOG_REFS_NORMAL:
720 return starts_with(refname, "refs/heads/") ||
721 starts_with(refname, "refs/remotes/") ||
722 starts_with(refname, "refs/notes/") ||
723 !strcmp(refname, "HEAD");
724 default:
725 return 0;
726 }
727}
728
729int is_branch(const char *refname)
730{
731 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
732}
733
734struct read_ref_at_cb {
735 const char *refname;
736 timestamp_t at_time;
737 int cnt;
738 int reccnt;
739 unsigned char *sha1;
740 int found_it;
741
742 unsigned char osha1[20];
743 unsigned char nsha1[20];
744 int tz;
745 timestamp_t date;
746 char **msg;
747 timestamp_t *cutoff_time;
748 int *cutoff_tz;
749 int *cutoff_cnt;
750};
751
752static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
753 const char *email, timestamp_t timestamp, int tz,
754 const char *message, void *cb_data)
755{
756 struct read_ref_at_cb *cb = cb_data;
757
758 cb->reccnt++;
759 cb->tz = tz;
760 cb->date = timestamp;
761
762 if (timestamp <= cb->at_time || cb->cnt == 0) {
763 if (cb->msg)
764 *cb->msg = xstrdup(message);
765 if (cb->cutoff_time)
766 *cb->cutoff_time = timestamp;
767 if (cb->cutoff_tz)
768 *cb->cutoff_tz = tz;
769 if (cb->cutoff_cnt)
770 *cb->cutoff_cnt = cb->reccnt - 1;
771 /*
772 * we have not yet updated cb->[n|o]sha1 so they still
773 * hold the values for the previous record.
774 */
775 if (!is_null_sha1(cb->osha1)) {
776 hashcpy(cb->sha1, noid->hash);
777 if (hashcmp(cb->osha1, noid->hash))
778 warning("Log for ref %s has gap after %s.",
779 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
780 }
781 else if (cb->date == cb->at_time)
782 hashcpy(cb->sha1, noid->hash);
783 else if (hashcmp(noid->hash, cb->sha1))
784 warning("Log for ref %s unexpectedly ended on %s.",
785 cb->refname, show_date(cb->date, cb->tz,
786 DATE_MODE(RFC2822)));
787 hashcpy(cb->osha1, ooid->hash);
788 hashcpy(cb->nsha1, noid->hash);
789 cb->found_it = 1;
790 return 1;
791 }
792 hashcpy(cb->osha1, ooid->hash);
793 hashcpy(cb->nsha1, noid->hash);
794 if (cb->cnt > 0)
795 cb->cnt--;
796 return 0;
797}
798
799static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
800 const char *email, timestamp_t timestamp,
801 int tz, const char *message, void *cb_data)
802{
803 struct read_ref_at_cb *cb = cb_data;
804
805 if (cb->msg)
806 *cb->msg = xstrdup(message);
807 if (cb->cutoff_time)
808 *cb->cutoff_time = timestamp;
809 if (cb->cutoff_tz)
810 *cb->cutoff_tz = tz;
811 if (cb->cutoff_cnt)
812 *cb->cutoff_cnt = cb->reccnt;
813 hashcpy(cb->sha1, ooid->hash);
814 if (is_null_sha1(cb->sha1))
815 hashcpy(cb->sha1, noid->hash);
816 /* We just want the first entry */
817 return 1;
818}
819
820int read_ref_at(const char *refname, unsigned int flags, timestamp_t at_time, int cnt,
821 unsigned char *sha1, char **msg,
822 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
823{
824 struct read_ref_at_cb cb;
825
826 memset(&cb, 0, sizeof(cb));
827 cb.refname = refname;
828 cb.at_time = at_time;
829 cb.cnt = cnt;
830 cb.msg = msg;
831 cb.cutoff_time = cutoff_time;
832 cb.cutoff_tz = cutoff_tz;
833 cb.cutoff_cnt = cutoff_cnt;
834 cb.sha1 = sha1;
835
836 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
837
838 if (!cb.reccnt) {
839 if (flags & GET_OID_QUIETLY)
840 exit(128);
841 else
842 die("Log for %s is empty.", refname);
843 }
844 if (cb.found_it)
845 return 0;
846
847 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
848
849 return 1;
850}
851
852struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
853 struct strbuf *err)
854{
855 struct ref_transaction *tr;
856 assert(err);
857
858 tr = xcalloc(1, sizeof(struct ref_transaction));
859 tr->ref_store = refs;
860 return tr;
861}
862
863struct ref_transaction *ref_transaction_begin(struct strbuf *err)
864{
865 return ref_store_transaction_begin(get_main_ref_store(), err);
866}
867
868void ref_transaction_free(struct ref_transaction *transaction)
869{
870 size_t i;
871
872 if (!transaction)
873 return;
874
875 switch (transaction->state) {
876 case REF_TRANSACTION_OPEN:
877 case REF_TRANSACTION_CLOSED:
878 /* OK */
879 break;
880 case REF_TRANSACTION_PREPARED:
881 die("BUG: free called on a prepared reference transaction");
882 break;
883 default:
884 die("BUG: unexpected reference transaction state");
885 break;
886 }
887
888 for (i = 0; i < transaction->nr; i++) {
889 free(transaction->updates[i]->msg);
890 free(transaction->updates[i]);
891 }
892 free(transaction->updates);
893 free(transaction);
894}
895
896struct ref_update *ref_transaction_add_update(
897 struct ref_transaction *transaction,
898 const char *refname, unsigned int flags,
899 const unsigned char *new_sha1,
900 const unsigned char *old_sha1,
901 const char *msg)
902{
903 struct ref_update *update;
904
905 if (transaction->state != REF_TRANSACTION_OPEN)
906 die("BUG: update called for transaction that is not open");
907
908 if ((flags & REF_ISPRUNING) && !(flags & REF_NODEREF))
909 die("BUG: REF_ISPRUNING set without REF_NODEREF");
910
911 FLEX_ALLOC_STR(update, refname, refname);
912 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
913 transaction->updates[transaction->nr++] = update;
914
915 update->flags = flags;
916
917 if (flags & REF_HAVE_NEW)
918 hashcpy(update->new_oid.hash, new_sha1);
919 if (flags & REF_HAVE_OLD)
920 hashcpy(update->old_oid.hash, old_sha1);
921 update->msg = xstrdup_or_null(msg);
922 return update;
923}
924
925int ref_transaction_update(struct ref_transaction *transaction,
926 const char *refname,
927 const unsigned char *new_sha1,
928 const unsigned char *old_sha1,
929 unsigned int flags, const char *msg,
930 struct strbuf *err)
931{
932 assert(err);
933
934 if ((new_sha1 && !is_null_sha1(new_sha1)) ?
935 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
936 !refname_is_safe(refname)) {
937 strbuf_addf(err, "refusing to update ref with bad name '%s'",
938 refname);
939 return -1;
940 }
941
942 flags |= (new_sha1 ? REF_HAVE_NEW : 0) | (old_sha1 ? REF_HAVE_OLD : 0);
943
944 ref_transaction_add_update(transaction, refname, flags,
945 new_sha1, old_sha1, msg);
946 return 0;
947}
948
949int ref_transaction_create(struct ref_transaction *transaction,
950 const char *refname,
951 const unsigned char *new_sha1,
952 unsigned int flags, const char *msg,
953 struct strbuf *err)
954{
955 if (!new_sha1 || is_null_sha1(new_sha1))
956 die("BUG: create called without valid new_sha1");
957 return ref_transaction_update(transaction, refname, new_sha1,
958 null_sha1, flags, msg, err);
959}
960
961int ref_transaction_delete(struct ref_transaction *transaction,
962 const char *refname,
963 const unsigned char *old_sha1,
964 unsigned int flags, const char *msg,
965 struct strbuf *err)
966{
967 if (old_sha1 && is_null_sha1(old_sha1))
968 die("BUG: delete called with old_sha1 set to zeros");
969 return ref_transaction_update(transaction, refname,
970 null_sha1, old_sha1,
971 flags, msg, err);
972}
973
974int ref_transaction_verify(struct ref_transaction *transaction,
975 const char *refname,
976 const unsigned char *old_sha1,
977 unsigned int flags,
978 struct strbuf *err)
979{
980 if (!old_sha1)
981 die("BUG: verify called with old_sha1 set to NULL");
982 return ref_transaction_update(transaction, refname,
983 NULL, old_sha1,
984 flags, NULL, err);
985}
986
987int update_ref_oid(const char *msg, const char *refname,
988 const struct object_id *new_oid, const struct object_id *old_oid,
989 unsigned int flags, enum action_on_err onerr)
990{
991 return update_ref(msg, refname, new_oid ? new_oid->hash : NULL,
992 old_oid ? old_oid->hash : NULL, flags, onerr);
993}
994
995int refs_update_ref(struct ref_store *refs, const char *msg,
996 const char *refname, const unsigned char *new_sha1,
997 const unsigned char *old_sha1, unsigned int flags,
998 enum action_on_err onerr)
999{
1000 struct ref_transaction *t = NULL;
1001 struct strbuf err = STRBUF_INIT;
1002 int ret = 0;
1003
1004 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
1005 assert(refs == get_main_ref_store());
1006 ret = write_pseudoref(refname, new_sha1, old_sha1, &err);
1007 } else {
1008 t = ref_store_transaction_begin(refs, &err);
1009 if (!t ||
1010 ref_transaction_update(t, refname, new_sha1, old_sha1,
1011 flags, msg, &err) ||
1012 ref_transaction_commit(t, &err)) {
1013 ret = 1;
1014 ref_transaction_free(t);
1015 }
1016 }
1017 if (ret) {
1018 const char *str = "update_ref failed for ref '%s': %s";
1019
1020 switch (onerr) {
1021 case UPDATE_REFS_MSG_ON_ERR:
1022 error(str, refname, err.buf);
1023 break;
1024 case UPDATE_REFS_DIE_ON_ERR:
1025 die(str, refname, err.buf);
1026 break;
1027 case UPDATE_REFS_QUIET_ON_ERR:
1028 break;
1029 }
1030 strbuf_release(&err);
1031 return 1;
1032 }
1033 strbuf_release(&err);
1034 if (t)
1035 ref_transaction_free(t);
1036 return 0;
1037}
1038
1039int update_ref(const char *msg, const char *refname,
1040 const unsigned char *new_sha1,
1041 const unsigned char *old_sha1,
1042 unsigned int flags, enum action_on_err onerr)
1043{
1044 return refs_update_ref(get_main_ref_store(), msg, refname, new_sha1,
1045 old_sha1, flags, onerr);
1046}
1047
1048char *shorten_unambiguous_ref(const char *refname, int strict)
1049{
1050 int i;
1051 static char **scanf_fmts;
1052 static int nr_rules;
1053 char *short_name;
1054 struct strbuf resolved_buf = STRBUF_INIT;
1055
1056 if (!nr_rules) {
1057 /*
1058 * Pre-generate scanf formats from ref_rev_parse_rules[].
1059 * Generate a format suitable for scanf from a
1060 * ref_rev_parse_rules rule by interpolating "%s" at the
1061 * location of the "%.*s".
1062 */
1063 size_t total_len = 0;
1064 size_t offset = 0;
1065
1066 /* the rule list is NULL terminated, count them first */
1067 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
1068 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1069 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
1070
1071 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
1072
1073 offset = 0;
1074 for (i = 0; i < nr_rules; i++) {
1075 assert(offset < total_len);
1076 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
1077 offset += snprintf(scanf_fmts[i], total_len - offset,
1078 ref_rev_parse_rules[i], 2, "%s") + 1;
1079 }
1080 }
1081
1082 /* bail out if there are no rules */
1083 if (!nr_rules)
1084 return xstrdup(refname);
1085
1086 /* buffer for scanf result, at most refname must fit */
1087 short_name = xstrdup(refname);
1088
1089 /* skip first rule, it will always match */
1090 for (i = nr_rules - 1; i > 0 ; --i) {
1091 int j;
1092 int rules_to_fail = i;
1093 int short_name_len;
1094
1095 if (1 != sscanf(refname, scanf_fmts[i], short_name))
1096 continue;
1097
1098 short_name_len = strlen(short_name);
1099
1100 /*
1101 * in strict mode, all (except the matched one) rules
1102 * must fail to resolve to a valid non-ambiguous ref
1103 */
1104 if (strict)
1105 rules_to_fail = nr_rules;
1106
1107 /*
1108 * check if the short name resolves to a valid ref,
1109 * but use only rules prior to the matched one
1110 */
1111 for (j = 0; j < rules_to_fail; j++) {
1112 const char *rule = ref_rev_parse_rules[j];
1113
1114 /* skip matched rule */
1115 if (i == j)
1116 continue;
1117
1118 /*
1119 * the short name is ambiguous, if it resolves
1120 * (with this previous rule) to a valid ref
1121 * read_ref() returns 0 on success
1122 */
1123 strbuf_reset(&resolved_buf);
1124 strbuf_addf(&resolved_buf, rule,
1125 short_name_len, short_name);
1126 if (ref_exists(resolved_buf.buf))
1127 break;
1128 }
1129
1130 /*
1131 * short name is non-ambiguous if all previous rules
1132 * haven't resolved to a valid ref
1133 */
1134 if (j == rules_to_fail) {
1135 strbuf_release(&resolved_buf);
1136 return short_name;
1137 }
1138 }
1139
1140 strbuf_release(&resolved_buf);
1141 free(short_name);
1142 return xstrdup(refname);
1143}
1144
1145static struct string_list *hide_refs;
1146
1147int parse_hide_refs_config(const char *var, const char *value, const char *section)
1148{
1149 const char *key;
1150 if (!strcmp("transfer.hiderefs", var) ||
1151 (!parse_config_key(var, section, NULL, NULL, &key) &&
1152 !strcmp(key, "hiderefs"))) {
1153 char *ref;
1154 int len;
1155
1156 if (!value)
1157 return config_error_nonbool(var);
1158 ref = xstrdup(value);
1159 len = strlen(ref);
1160 while (len && ref[len - 1] == '/')
1161 ref[--len] = '\0';
1162 if (!hide_refs) {
1163 hide_refs = xcalloc(1, sizeof(*hide_refs));
1164 hide_refs->strdup_strings = 1;
1165 }
1166 string_list_append(hide_refs, ref);
1167 }
1168 return 0;
1169}
1170
1171int ref_is_hidden(const char *refname, const char *refname_full)
1172{
1173 int i;
1174
1175 if (!hide_refs)
1176 return 0;
1177 for (i = hide_refs->nr - 1; i >= 0; i--) {
1178 const char *match = hide_refs->items[i].string;
1179 const char *subject;
1180 int neg = 0;
1181 const char *p;
1182
1183 if (*match == '!') {
1184 neg = 1;
1185 match++;
1186 }
1187
1188 if (*match == '^') {
1189 subject = refname_full;
1190 match++;
1191 } else {
1192 subject = refname;
1193 }
1194
1195 /* refname can be NULL when namespaces are used. */
1196 if (subject &&
1197 skip_prefix(subject, match, &p) &&
1198 (!*p || *p == '/'))
1199 return !neg;
1200 }
1201 return 0;
1202}
1203
1204const char *find_descendant_ref(const char *dirname,
1205 const struct string_list *extras,
1206 const struct string_list *skip)
1207{
1208 int pos;
1209
1210 if (!extras)
1211 return NULL;
1212
1213 /*
1214 * Look at the place where dirname would be inserted into
1215 * extras. If there is an entry at that position that starts
1216 * with dirname (remember, dirname includes the trailing
1217 * slash) and is not in skip, then we have a conflict.
1218 */
1219 for (pos = string_list_find_insert_index(extras, dirname, 0);
1220 pos < extras->nr; pos++) {
1221 const char *extra_refname = extras->items[pos].string;
1222
1223 if (!starts_with(extra_refname, dirname))
1224 break;
1225
1226 if (!skip || !string_list_has_string(skip, extra_refname))
1227 return extra_refname;
1228 }
1229 return NULL;
1230}
1231
1232int refs_rename_ref_available(struct ref_store *refs,
1233 const char *old_refname,
1234 const char *new_refname)
1235{
1236 struct string_list skip = STRING_LIST_INIT_NODUP;
1237 struct strbuf err = STRBUF_INIT;
1238 int ok;
1239
1240 string_list_insert(&skip, old_refname);
1241 ok = !refs_verify_refname_available(refs, new_refname,
1242 NULL, &skip, &err);
1243 if (!ok)
1244 error("%s", err.buf);
1245
1246 string_list_clear(&skip, 0);
1247 strbuf_release(&err);
1248 return ok;
1249}
1250
1251int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1252{
1253 struct object_id oid;
1254 int flag;
1255
1256 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
1257 oid.hash, &flag))
1258 return fn("HEAD", &oid, flag, cb_data);
1259
1260 return 0;
1261}
1262
1263int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1264{
1265 struct ref_store *refs = get_submodule_ref_store(submodule);
1266
1267 if (!refs)
1268 return -1;
1269 return refs_head_ref(refs, fn, cb_data);
1270}
1271
1272int head_ref(each_ref_fn fn, void *cb_data)
1273{
1274 return refs_head_ref(get_main_ref_store(), fn, cb_data);
1275}
1276
1277struct ref_iterator *refs_ref_iterator_begin(
1278 struct ref_store *refs,
1279 const char *prefix, int trim, int flags)
1280{
1281 struct ref_iterator *iter;
1282
1283 if (ref_paranoia < 0)
1284 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1285 if (ref_paranoia)
1286 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1287
1288 iter = refs->be->iterator_begin(refs, prefix, flags);
1289
1290 /*
1291 * `iterator_begin()` already takes care of prefix, but we
1292 * might need to do some trimming:
1293 */
1294 if (trim)
1295 iter = prefix_ref_iterator_begin(iter, "", trim);
1296
1297 return iter;
1298}
1299
1300/*
1301 * Call fn for each reference in the specified submodule for which the
1302 * refname begins with prefix. If trim is non-zero, then trim that
1303 * many characters off the beginning of each refname before passing
1304 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1305 * include broken references in the iteration. If fn ever returns a
1306 * non-zero value, stop the iteration and return that value;
1307 * otherwise, return 0.
1308 */
1309static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1310 each_ref_fn fn, int trim, int flags, void *cb_data)
1311{
1312 struct ref_iterator *iter;
1313
1314 if (!refs)
1315 return 0;
1316
1317 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1318
1319 return do_for_each_ref_iterator(iter, fn, cb_data);
1320}
1321
1322int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1323{
1324 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1325}
1326
1327int for_each_ref(each_ref_fn fn, void *cb_data)
1328{
1329 return refs_for_each_ref(get_main_ref_store(), fn, cb_data);
1330}
1331
1332int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1333{
1334 return refs_for_each_ref(get_submodule_ref_store(submodule), fn, cb_data);
1335}
1336
1337int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1338 each_ref_fn fn, void *cb_data)
1339{
1340 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
1341}
1342
1343int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1344{
1345 return refs_for_each_ref_in(get_main_ref_store(), prefix, fn, cb_data);
1346}
1347
1348int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1349{
1350 unsigned int flag = 0;
1351
1352 if (broken)
1353 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1354 return do_for_each_ref(get_main_ref_store(),
1355 prefix, fn, 0, flag, cb_data);
1356}
1357
1358int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1359 each_ref_fn fn, void *cb_data)
1360{
1361 return refs_for_each_ref_in(get_submodule_ref_store(submodule),
1362 prefix, fn, cb_data);
1363}
1364
1365int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1366 each_ref_fn fn, void *cb_data,
1367 unsigned int broken)
1368{
1369 unsigned int flag = 0;
1370
1371 if (broken)
1372 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1373 return do_for_each_ref(refs, prefix, fn, 0, flag, cb_data);
1374}
1375
1376int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1377{
1378 return do_for_each_ref(get_main_ref_store(),
1379 git_replace_ref_base, fn,
1380 strlen(git_replace_ref_base),
1381 0, cb_data);
1382}
1383
1384int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1385{
1386 struct strbuf buf = STRBUF_INIT;
1387 int ret;
1388 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1389 ret = do_for_each_ref(get_main_ref_store(),
1390 buf.buf, fn, 0, 0, cb_data);
1391 strbuf_release(&buf);
1392 return ret;
1393}
1394
1395int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1396{
1397 return do_for_each_ref(refs, "", fn, 0,
1398 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1399}
1400
1401int for_each_rawref(each_ref_fn fn, void *cb_data)
1402{
1403 return refs_for_each_rawref(get_main_ref_store(), fn, cb_data);
1404}
1405
1406int refs_read_raw_ref(struct ref_store *ref_store,
1407 const char *refname, unsigned char *sha1,
1408 struct strbuf *referent, unsigned int *type)
1409{
1410 return ref_store->be->read_raw_ref(ref_store, refname, sha1, referent, type);
1411}
1412
1413/* This function needs to return a meaningful errno on failure */
1414const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1415 const char *refname,
1416 int resolve_flags,
1417 unsigned char *sha1, int *flags)
1418{
1419 static struct strbuf sb_refname = STRBUF_INIT;
1420 int unused_flags;
1421 int symref_count;
1422
1423 if (!flags)
1424 flags = &unused_flags;
1425
1426 *flags = 0;
1427
1428 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1429 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1430 !refname_is_safe(refname)) {
1431 errno = EINVAL;
1432 return NULL;
1433 }
1434
1435 /*
1436 * dwim_ref() uses REF_ISBROKEN to distinguish between
1437 * missing refs and refs that were present but invalid,
1438 * to complain about the latter to stderr.
1439 *
1440 * We don't know whether the ref exists, so don't set
1441 * REF_ISBROKEN yet.
1442 */
1443 *flags |= REF_BAD_NAME;
1444 }
1445
1446 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1447 unsigned int read_flags = 0;
1448
1449 if (refs_read_raw_ref(refs, refname,
1450 sha1, &sb_refname, &read_flags)) {
1451 *flags |= read_flags;
1452 if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING))
1453 return NULL;
1454 hashclr(sha1);
1455 if (*flags & REF_BAD_NAME)
1456 *flags |= REF_ISBROKEN;
1457 return refname;
1458 }
1459
1460 *flags |= read_flags;
1461
1462 if (!(read_flags & REF_ISSYMREF)) {
1463 if (*flags & REF_BAD_NAME) {
1464 hashclr(sha1);
1465 *flags |= REF_ISBROKEN;
1466 }
1467 return refname;
1468 }
1469
1470 refname = sb_refname.buf;
1471 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1472 hashclr(sha1);
1473 return refname;
1474 }
1475 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1476 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1477 !refname_is_safe(refname)) {
1478 errno = EINVAL;
1479 return NULL;
1480 }
1481
1482 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1483 }
1484 }
1485
1486 errno = ELOOP;
1487 return NULL;
1488}
1489
1490/* backend functions */
1491int refs_init_db(struct strbuf *err)
1492{
1493 struct ref_store *refs = get_main_ref_store();
1494
1495 return refs->be->init_db(refs, err);
1496}
1497
1498const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1499 unsigned char *sha1, int *flags)
1500{
1501 return refs_resolve_ref_unsafe(get_main_ref_store(), refname,
1502 resolve_flags, sha1, flags);
1503}
1504
1505int resolve_gitlink_ref(const char *submodule, const char *refname,
1506 unsigned char *sha1)
1507{
1508 struct ref_store *refs;
1509 int flags;
1510
1511 refs = get_submodule_ref_store(submodule);
1512
1513 if (!refs)
1514 return -1;
1515
1516 if (!refs_resolve_ref_unsafe(refs, refname, 0, sha1, &flags) ||
1517 is_null_sha1(sha1))
1518 return -1;
1519 return 0;
1520}
1521
1522struct ref_store_hash_entry
1523{
1524 struct hashmap_entry ent; /* must be the first member! */
1525
1526 struct ref_store *refs;
1527
1528 /* NUL-terminated identifier of the ref store: */
1529 char name[FLEX_ARRAY];
1530};
1531
1532static int ref_store_hash_cmp(const void *unused_cmp_data,
1533 const void *entry, const void *entry_or_key,
1534 const void *keydata)
1535{
1536 const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
1537 const char *name = keydata ? keydata : e2->name;
1538
1539 return strcmp(e1->name, name);
1540}
1541
1542static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1543 const char *name, struct ref_store *refs)
1544{
1545 struct ref_store_hash_entry *entry;
1546
1547 FLEX_ALLOC_STR(entry, name, name);
1548 hashmap_entry_init(entry, strhash(name));
1549 entry->refs = refs;
1550 return entry;
1551}
1552
1553/* A pointer to the ref_store for the main repository: */
1554static struct ref_store *main_ref_store;
1555
1556/* A hashmap of ref_stores, stored by submodule name: */
1557static struct hashmap submodule_ref_stores;
1558
1559/* A hashmap of ref_stores, stored by worktree id: */
1560static struct hashmap worktree_ref_stores;
1561
1562/*
1563 * Look up a ref store by name. If that ref_store hasn't been
1564 * registered yet, return NULL.
1565 */
1566static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1567 const char *name)
1568{
1569 struct ref_store_hash_entry *entry;
1570
1571 if (!map->tablesize)
1572 /* It's initialized on demand in register_ref_store(). */
1573 return NULL;
1574
1575 entry = hashmap_get_from_hash(map, strhash(name), name);
1576 return entry ? entry->refs : NULL;
1577}
1578
1579/*
1580 * Create, record, and return a ref_store instance for the specified
1581 * gitdir.
1582 */
1583static struct ref_store *ref_store_init(const char *gitdir,
1584 unsigned int flags)
1585{
1586 const char *be_name = "files";
1587 struct ref_storage_be *be = find_ref_storage_backend(be_name);
1588 struct ref_store *refs;
1589
1590 if (!be)
1591 die("BUG: reference backend %s is unknown", be_name);
1592
1593 refs = be->init(gitdir, flags);
1594 return refs;
1595}
1596
1597struct ref_store *get_main_ref_store(void)
1598{
1599 if (main_ref_store)
1600 return main_ref_store;
1601
1602 main_ref_store = ref_store_init(get_git_dir(), REF_STORE_ALL_CAPS);
1603 return main_ref_store;
1604}
1605
1606/*
1607 * Associate a ref store with a name. It is a fatal error to call this
1608 * function twice for the same name.
1609 */
1610static void register_ref_store_map(struct hashmap *map,
1611 const char *type,
1612 struct ref_store *refs,
1613 const char *name)
1614{
1615 if (!map->tablesize)
1616 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
1617
1618 if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
1619 die("BUG: %s ref_store '%s' initialized twice", type, name);
1620}
1621
1622struct ref_store *get_submodule_ref_store(const char *submodule)
1623{
1624 struct strbuf submodule_sb = STRBUF_INIT;
1625 struct ref_store *refs;
1626 char *to_free = NULL;
1627 size_t len;
1628
1629 if (submodule) {
1630 len = strlen(submodule);
1631 while (len && is_dir_sep(submodule[len - 1]))
1632 len--;
1633 if (!len)
1634 return NULL;
1635 }
1636
1637 if (!submodule || !*submodule) {
1638 /*
1639 * FIXME: This case is ideally not allowed. But that
1640 * can't happen until we clean up all the callers.
1641 */
1642 return get_main_ref_store();
1643 }
1644
1645 if (submodule[len])
1646 /* We need to strip off one or more trailing slashes */
1647 submodule = to_free = xmemdupz(submodule, len);
1648
1649 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
1650 if (refs)
1651 goto done;
1652
1653 strbuf_addstr(&submodule_sb, submodule);
1654 if (!is_nonbare_repository_dir(&submodule_sb))
1655 goto done;
1656
1657 if (submodule_to_gitdir(&submodule_sb, submodule))
1658 goto done;
1659
1660 /* assume that add_submodule_odb() has been called */
1661 refs = ref_store_init(submodule_sb.buf,
1662 REF_STORE_READ | REF_STORE_ODB);
1663 register_ref_store_map(&submodule_ref_stores, "submodule",
1664 refs, submodule);
1665
1666done:
1667 strbuf_release(&submodule_sb);
1668 free(to_free);
1669
1670 return refs;
1671}
1672
1673struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1674{
1675 struct ref_store *refs;
1676 const char *id;
1677
1678 if (wt->is_current)
1679 return get_main_ref_store();
1680
1681 id = wt->id ? wt->id : "/";
1682 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1683 if (refs)
1684 return refs;
1685
1686 if (wt->id)
1687 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1688 REF_STORE_ALL_CAPS);
1689 else
1690 refs = ref_store_init(get_git_common_dir(),
1691 REF_STORE_ALL_CAPS);
1692
1693 if (refs)
1694 register_ref_store_map(&worktree_ref_stores, "worktree",
1695 refs, id);
1696 return refs;
1697}
1698
1699void base_ref_store_init(struct ref_store *refs,
1700 const struct ref_storage_be *be)
1701{
1702 refs->be = be;
1703}
1704
1705/* backend functions */
1706int refs_pack_refs(struct ref_store *refs, unsigned int flags)
1707{
1708 return refs->be->pack_refs(refs, flags);
1709}
1710
1711int refs_peel_ref(struct ref_store *refs, const char *refname,
1712 unsigned char *sha1)
1713{
1714 return refs->be->peel_ref(refs, refname, sha1);
1715}
1716
1717int peel_ref(const char *refname, unsigned char *sha1)
1718{
1719 return refs_peel_ref(get_main_ref_store(), refname, sha1);
1720}
1721
1722int refs_create_symref(struct ref_store *refs,
1723 const char *ref_target,
1724 const char *refs_heads_master,
1725 const char *logmsg)
1726{
1727 return refs->be->create_symref(refs, ref_target,
1728 refs_heads_master,
1729 logmsg);
1730}
1731
1732int create_symref(const char *ref_target, const char *refs_heads_master,
1733 const char *logmsg)
1734{
1735 return refs_create_symref(get_main_ref_store(), ref_target,
1736 refs_heads_master, logmsg);
1737}
1738
1739int ref_update_reject_duplicates(struct string_list *refnames,
1740 struct strbuf *err)
1741{
1742 size_t i, n = refnames->nr;
1743
1744 assert(err);
1745
1746 for (i = 1; i < n; i++) {
1747 int cmp = strcmp(refnames->items[i - 1].string,
1748 refnames->items[i].string);
1749
1750 if (!cmp) {
1751 strbuf_addf(err,
1752 "multiple updates for ref '%s' not allowed.",
1753 refnames->items[i].string);
1754 return 1;
1755 } else if (cmp > 0) {
1756 die("BUG: ref_update_reject_duplicates() received unsorted list");
1757 }
1758 }
1759 return 0;
1760}
1761
1762int ref_transaction_prepare(struct ref_transaction *transaction,
1763 struct strbuf *err)
1764{
1765 struct ref_store *refs = transaction->ref_store;
1766
1767 switch (transaction->state) {
1768 case REF_TRANSACTION_OPEN:
1769 /* Good. */
1770 break;
1771 case REF_TRANSACTION_PREPARED:
1772 die("BUG: prepare called twice on reference transaction");
1773 break;
1774 case REF_TRANSACTION_CLOSED:
1775 die("BUG: prepare called on a closed reference transaction");
1776 break;
1777 default:
1778 die("BUG: unexpected reference transaction state");
1779 break;
1780 }
1781
1782 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
1783 strbuf_addstr(err,
1784 _("ref updates forbidden inside quarantine environment"));
1785 return -1;
1786 }
1787
1788 return refs->be->transaction_prepare(refs, transaction, err);
1789}
1790
1791int ref_transaction_abort(struct ref_transaction *transaction,
1792 struct strbuf *err)
1793{
1794 struct ref_store *refs = transaction->ref_store;
1795 int ret = 0;
1796
1797 switch (transaction->state) {
1798 case REF_TRANSACTION_OPEN:
1799 /* No need to abort explicitly. */
1800 break;
1801 case REF_TRANSACTION_PREPARED:
1802 ret = refs->be->transaction_abort(refs, transaction, err);
1803 break;
1804 case REF_TRANSACTION_CLOSED:
1805 die("BUG: abort called on a closed reference transaction");
1806 break;
1807 default:
1808 die("BUG: unexpected reference transaction state");
1809 break;
1810 }
1811
1812 ref_transaction_free(transaction);
1813 return ret;
1814}
1815
1816int ref_transaction_commit(struct ref_transaction *transaction,
1817 struct strbuf *err)
1818{
1819 struct ref_store *refs = transaction->ref_store;
1820 int ret;
1821
1822 switch (transaction->state) {
1823 case REF_TRANSACTION_OPEN:
1824 /* Need to prepare first. */
1825 ret = ref_transaction_prepare(transaction, err);
1826 if (ret)
1827 return ret;
1828 break;
1829 case REF_TRANSACTION_PREPARED:
1830 /* Fall through to finish. */
1831 break;
1832 case REF_TRANSACTION_CLOSED:
1833 die("BUG: commit called on a closed reference transaction");
1834 break;
1835 default:
1836 die("BUG: unexpected reference transaction state");
1837 break;
1838 }
1839
1840 return refs->be->transaction_finish(refs, transaction, err);
1841}
1842
1843int refs_verify_refname_available(struct ref_store *refs,
1844 const char *refname,
1845 const struct string_list *extras,
1846 const struct string_list *skip,
1847 struct strbuf *err)
1848{
1849 const char *slash;
1850 const char *extra_refname;
1851 struct strbuf dirname = STRBUF_INIT;
1852 struct strbuf referent = STRBUF_INIT;
1853 struct object_id oid;
1854 unsigned int type;
1855 struct ref_iterator *iter;
1856 int ok;
1857 int ret = -1;
1858
1859 /*
1860 * For the sake of comments in this function, suppose that
1861 * refname is "refs/foo/bar".
1862 */
1863
1864 assert(err);
1865
1866 strbuf_grow(&dirname, strlen(refname) + 1);
1867 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
1868 /* Expand dirname to the new prefix, not including the trailing slash: */
1869 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
1870
1871 /*
1872 * We are still at a leading dir of the refname (e.g.,
1873 * "refs/foo"; if there is a reference with that name,
1874 * it is a conflict, *unless* it is in skip.
1875 */
1876 if (skip && string_list_has_string(skip, dirname.buf))
1877 continue;
1878
1879 if (!refs_read_raw_ref(refs, dirname.buf, oid.hash, &referent, &type)) {
1880 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1881 dirname.buf, refname);
1882 goto cleanup;
1883 }
1884
1885 if (extras && string_list_has_string(extras, dirname.buf)) {
1886 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1887 refname, dirname.buf);
1888 goto cleanup;
1889 }
1890 }
1891
1892 /*
1893 * We are at the leaf of our refname (e.g., "refs/foo/bar").
1894 * There is no point in searching for a reference with that
1895 * name, because a refname isn't considered to conflict with
1896 * itself. But we still need to check for references whose
1897 * names are in the "refs/foo/bar/" namespace, because they
1898 * *do* conflict.
1899 */
1900 strbuf_addstr(&dirname, refname + dirname.len);
1901 strbuf_addch(&dirname, '/');
1902
1903 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
1904 DO_FOR_EACH_INCLUDE_BROKEN);
1905 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
1906 if (skip &&
1907 string_list_has_string(skip, iter->refname))
1908 continue;
1909
1910 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1911 iter->refname, refname);
1912 ref_iterator_abort(iter);
1913 goto cleanup;
1914 }
1915
1916 if (ok != ITER_DONE)
1917 die("BUG: error while iterating over references");
1918
1919 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
1920 if (extra_refname)
1921 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1922 refname, extra_refname);
1923 else
1924 ret = 0;
1925
1926cleanup:
1927 strbuf_release(&referent);
1928 strbuf_release(&dirname);
1929 return ret;
1930}
1931
1932int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1933{
1934 struct ref_iterator *iter;
1935
1936 iter = refs->be->reflog_iterator_begin(refs);
1937
1938 return do_for_each_ref_iterator(iter, fn, cb_data);
1939}
1940
1941int for_each_reflog(each_ref_fn fn, void *cb_data)
1942{
1943 return refs_for_each_reflog(get_main_ref_store(), fn, cb_data);
1944}
1945
1946int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
1947 const char *refname,
1948 each_reflog_ent_fn fn,
1949 void *cb_data)
1950{
1951 return refs->be->for_each_reflog_ent_reverse(refs, refname,
1952 fn, cb_data);
1953}
1954
1955int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
1956 void *cb_data)
1957{
1958 return refs_for_each_reflog_ent_reverse(get_main_ref_store(),
1959 refname, fn, cb_data);
1960}
1961
1962int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
1963 each_reflog_ent_fn fn, void *cb_data)
1964{
1965 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
1966}
1967
1968int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
1969 void *cb_data)
1970{
1971 return refs_for_each_reflog_ent(get_main_ref_store(), refname,
1972 fn, cb_data);
1973}
1974
1975int refs_reflog_exists(struct ref_store *refs, const char *refname)
1976{
1977 return refs->be->reflog_exists(refs, refname);
1978}
1979
1980int reflog_exists(const char *refname)
1981{
1982 return refs_reflog_exists(get_main_ref_store(), refname);
1983}
1984
1985int refs_create_reflog(struct ref_store *refs, const char *refname,
1986 int force_create, struct strbuf *err)
1987{
1988 return refs->be->create_reflog(refs, refname, force_create, err);
1989}
1990
1991int safe_create_reflog(const char *refname, int force_create,
1992 struct strbuf *err)
1993{
1994 return refs_create_reflog(get_main_ref_store(), refname,
1995 force_create, err);
1996}
1997
1998int refs_delete_reflog(struct ref_store *refs, const char *refname)
1999{
2000 return refs->be->delete_reflog(refs, refname);
2001}
2002
2003int delete_reflog(const char *refname)
2004{
2005 return refs_delete_reflog(get_main_ref_store(), refname);
2006}
2007
2008int refs_reflog_expire(struct ref_store *refs,
2009 const char *refname, const unsigned char *sha1,
2010 unsigned int flags,
2011 reflog_expiry_prepare_fn prepare_fn,
2012 reflog_expiry_should_prune_fn should_prune_fn,
2013 reflog_expiry_cleanup_fn cleanup_fn,
2014 void *policy_cb_data)
2015{
2016 return refs->be->reflog_expire(refs, refname, sha1, flags,
2017 prepare_fn, should_prune_fn,
2018 cleanup_fn, policy_cb_data);
2019}
2020
2021int reflog_expire(const char *refname, const unsigned char *sha1,
2022 unsigned int flags,
2023 reflog_expiry_prepare_fn prepare_fn,
2024 reflog_expiry_should_prune_fn should_prune_fn,
2025 reflog_expiry_cleanup_fn cleanup_fn,
2026 void *policy_cb_data)
2027{
2028 return refs_reflog_expire(get_main_ref_store(),
2029 refname, sha1, flags,
2030 prepare_fn, should_prune_fn,
2031 cleanup_fn, policy_cb_data);
2032}
2033
2034int initial_ref_transaction_commit(struct ref_transaction *transaction,
2035 struct strbuf *err)
2036{
2037 struct ref_store *refs = transaction->ref_store;
2038
2039 return refs->be->initial_transaction_commit(refs, transaction, err);
2040}
2041
2042int refs_delete_refs(struct ref_store *refs, const char *msg,
2043 struct string_list *refnames, unsigned int flags)
2044{
2045 return refs->be->delete_refs(refs, msg, refnames, flags);
2046}
2047
2048int delete_refs(const char *msg, struct string_list *refnames,
2049 unsigned int flags)
2050{
2051 return refs_delete_refs(get_main_ref_store(), msg, refnames, flags);
2052}
2053
2054int refs_rename_ref(struct ref_store *refs, const char *oldref,
2055 const char *newref, const char *logmsg)
2056{
2057 return refs->be->rename_ref(refs, oldref, newref, logmsg);
2058}
2059
2060int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2061{
2062 return refs_rename_ref(get_main_ref_store(), oldref, newref, logmsg);
2063}