2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
14 #include "submodule.h"
16 #include "argv-array.h"
17 #include "repository.h"
20 * List of all available backends
22 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
24 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
26 struct ref_storage_be
*be
;
27 for (be
= refs_backends
; be
; be
= be
->next
)
28 if (!strcmp(be
->name
, name
))
33 int ref_storage_backend_exists(const char *name
)
35 return find_ref_storage_backend(name
) != NULL
;
39 * How to handle various characters in refnames:
40 * 0: An acceptable character for refs
42 * 2: ., look for a preceding . to reject .. in refs
43 * 3: {, look for a preceding @ to reject @{ in refs
44 * 4: A bad character: ASCII control characters, and
45 * ":", "?", "[", "\", "^", "~", SP, or TAB
46 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
48 static unsigned char refname_disposition
[256] = {
49 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
50 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
51 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
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, 4, 4, 0, 4, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
60 * Try to read one refname component from the front of refname.
61 * Return the length of the component found, or -1 if the component is
62 * not legal. It is legal if it is something reasonable to have under
63 * ".git/refs/"; We do not like it if:
65 * - any path component of it begins with ".", or
66 * - it has double dots "..", or
67 * - it has ASCII control characters, or
68 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
69 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
70 * - it ends with a "/", or
71 * - it ends with ".lock", or
72 * - it contains a "@{" portion
74 static int check_refname_component(const char *refname
, int *flags
)
79 for (cp
= refname
; ; cp
++) {
81 unsigned char disp
= refname_disposition
[ch
];
87 return -1; /* Refname contains "..". */
91 return -1; /* Refname contains "@{". */
96 if (!(*flags
& REFNAME_REFSPEC_PATTERN
))
97 return -1; /* refspec can't be a pattern */
100 * Unset the pattern flag so that we only accept
101 * a single asterisk for one side of refspec.
103 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
110 return 0; /* Component has zero length. */
111 if (refname
[0] == '.')
112 return -1; /* Component starts with '.'. */
113 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
114 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
))
115 return -1; /* Refname ends with ".lock". */
119 int check_refname_format(const char *refname
, int flags
)
121 int component_len
, component_count
= 0;
123 if (!strcmp(refname
, "@"))
124 /* Refname is a single character '@'. */
128 /* We are at the start of a path component. */
129 component_len
= check_refname_component(refname
, &flags
);
130 if (component_len
<= 0)
134 if (refname
[component_len
] == '\0')
136 /* Skip to next component. */
137 refname
+= component_len
+ 1;
140 if (refname
[component_len
- 1] == '.')
141 return -1; /* Refname ends with '.'. */
142 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
143 return -1; /* Refname has only one component. */
147 int refname_is_safe(const char *refname
)
151 if (skip_prefix(refname
, "refs/", &rest
)) {
154 size_t restlen
= strlen(rest
);
156 /* rest must not be empty, or start or end with "/" */
157 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
161 * Does the refname try to escape refs/?
162 * For example: refs/foo/../bar is safe but refs/foo/../../bar
165 buf
= xmallocz(restlen
);
166 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
172 if (!isupper(*refname
) && *refname
!= '_')
180 * Return true if refname, which has the specified oid and flags, can
181 * be resolved to an object in the database. If the referred-to object
182 * does not exist, emit a warning and return false.
184 int ref_resolves_to_object(const char *refname
,
185 const struct object_id
*oid
,
188 if (flags
& REF_ISBROKEN
)
190 if (!has_sha1_file(oid
->hash
)) {
191 error("%s does not point to a valid object!", refname
);
197 char *refs_resolve_refdup(struct ref_store
*refs
,
198 const char *refname
, int resolve_flags
,
199 struct object_id
*oid
, int *flags
)
203 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
205 return xstrdup_or_null(result
);
208 char *resolve_refdup(const char *refname
, int resolve_flags
,
209 struct object_id
*oid
, int *flags
)
211 return refs_resolve_refdup(get_main_ref_store(the_repository
),
212 refname
, resolve_flags
,
216 /* The argument to filter_refs */
223 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
224 int resolve_flags
, struct object_id
*oid
, int *flags
)
226 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
, oid
, flags
))
231 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
233 return refs_read_ref_full(get_main_ref_store(the_repository
), refname
,
234 resolve_flags
, oid
, flags
);
237 int read_ref(const char *refname
, struct object_id
*oid
)
239 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
242 int ref_exists(const char *refname
)
244 return !!resolve_ref_unsafe(refname
, RESOLVE_REF_READING
, NULL
, NULL
);
247 static int match_ref_pattern(const char *refname
,
248 const struct string_list_item
*item
)
251 if (item
->util
== NULL
) {
252 if (!wildmatch(item
->string
, refname
, 0))
256 if (skip_prefix(refname
, item
->string
, &rest
) &&
257 (!*rest
|| *rest
== '/'))
263 int ref_filter_match(const char *refname
,
264 const struct string_list
*include_patterns
,
265 const struct string_list
*exclude_patterns
)
267 struct string_list_item
*item
;
269 if (exclude_patterns
&& exclude_patterns
->nr
) {
270 for_each_string_list_item(item
, exclude_patterns
) {
271 if (match_ref_pattern(refname
, item
))
276 if (include_patterns
&& include_patterns
->nr
) {
278 for_each_string_list_item(item
, include_patterns
) {
279 if (match_ref_pattern(refname
, item
)) {
291 static int filter_refs(const char *refname
, const struct object_id
*oid
,
292 int flags
, void *data
)
294 struct ref_filter
*filter
= (struct ref_filter
*)data
;
296 if (wildmatch(filter
->pattern
, refname
, 0))
298 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
301 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
303 struct object
*o
= lookup_unknown_object(name
->hash
);
305 if (o
->type
== OBJ_NONE
) {
306 int type
= oid_object_info(the_repository
, name
, NULL
);
307 if (type
< 0 || !object_as_type(o
, type
, 0))
311 if (o
->type
!= OBJ_TAG
)
314 o
= deref_tag_noverify(o
);
318 oidcpy(oid
, &o
->oid
);
322 struct warn_if_dangling_data
{
325 const struct string_list
*refnames
;
329 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
330 int flags
, void *cb_data
)
332 struct warn_if_dangling_data
*d
= cb_data
;
333 const char *resolves_to
;
335 if (!(flags
& REF_ISSYMREF
))
338 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
341 ? strcmp(resolves_to
, d
->refname
)
342 : !string_list_has_string(d
->refnames
, resolves_to
))) {
346 fprintf(d
->fp
, d
->msg_fmt
, refname
);
351 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
353 struct warn_if_dangling_data data
;
356 data
.refname
= refname
;
357 data
.refnames
= NULL
;
358 data
.msg_fmt
= msg_fmt
;
359 for_each_rawref(warn_if_dangling_symref
, &data
);
362 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
364 struct warn_if_dangling_data data
;
368 data
.refnames
= refnames
;
369 data
.msg_fmt
= msg_fmt
;
370 for_each_rawref(warn_if_dangling_symref
, &data
);
373 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
375 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
378 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
380 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
383 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
385 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
388 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
390 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
393 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
395 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
398 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
400 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
403 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
405 struct strbuf buf
= STRBUF_INIT
;
407 struct object_id oid
;
410 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
411 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
412 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
413 strbuf_release(&buf
);
418 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
421 struct strbuf normalized_pattern
= STRBUF_INIT
;
424 BUG("pattern must not start with '/'");
427 strbuf_addstr(&normalized_pattern
, prefix
);
429 else if (!starts_with(pattern
, "refs/"))
430 strbuf_addstr(&normalized_pattern
, "refs/");
431 strbuf_addstr(&normalized_pattern
, pattern
);
432 strbuf_strip_suffix(&normalized_pattern
, "/");
434 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
435 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
436 strbuf_release(&normalized_pattern
);
439 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
440 const char *prefix
, void *cb_data
)
442 struct strbuf real_pattern
= STRBUF_INIT
;
443 struct ref_filter filter
;
446 if (!prefix
&& !starts_with(pattern
, "refs/"))
447 strbuf_addstr(&real_pattern
, "refs/");
449 strbuf_addstr(&real_pattern
, prefix
);
450 strbuf_addstr(&real_pattern
, pattern
);
452 if (!has_glob_specials(pattern
)) {
453 /* Append implied '/' '*' if not present. */
454 strbuf_complete(&real_pattern
, '/');
455 /* No need to check for '*', there is none. */
456 strbuf_addch(&real_pattern
, '*');
459 filter
.pattern
= real_pattern
.buf
;
461 filter
.cb_data
= cb_data
;
462 ret
= for_each_ref(filter_refs
, &filter
);
464 strbuf_release(&real_pattern
);
468 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
470 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
473 const char *prettify_refname(const char *name
)
475 if (skip_prefix(name
, "refs/heads/", &name
) ||
476 skip_prefix(name
, "refs/tags/", &name
) ||
477 skip_prefix(name
, "refs/remotes/", &name
))
482 static const char *ref_rev_parse_rules
[] = {
488 "refs/remotes/%.*s/HEAD",
492 int refname_match(const char *abbrev_name
, const char *full_name
)
495 const int abbrev_name_len
= strlen(abbrev_name
);
497 for (p
= ref_rev_parse_rules
; *p
; p
++) {
498 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
))) {
507 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
508 * the results to 'prefixes'
510 void expand_ref_prefix(struct argv_array
*prefixes
, const char *prefix
)
513 int len
= strlen(prefix
);
515 for (p
= ref_rev_parse_rules
; *p
; p
++)
516 argv_array_pushf(prefixes
, *p
, len
, prefix
);
520 * *string and *len will only be substituted, and *string returned (for
521 * later free()ing) if the string passed in is a magic short-hand form
524 static char *substitute_branch_name(const char **string
, int *len
)
526 struct strbuf buf
= STRBUF_INIT
;
527 int ret
= interpret_branch_name(*string
, *len
, &buf
, 0);
531 *string
= strbuf_detach(&buf
, &size
);
533 return (char *)*string
;
539 int dwim_ref(const char *str
, int len
, struct object_id
*oid
, char **ref
)
541 char *last_branch
= substitute_branch_name(&str
, &len
);
542 int refs_found
= expand_ref(str
, len
, oid
, ref
);
547 int expand_ref(const char *str
, int len
, struct object_id
*oid
, char **ref
)
551 struct strbuf fullref
= STRBUF_INIT
;
554 for (p
= ref_rev_parse_rules
; *p
; p
++) {
555 struct object_id oid_from_ref
;
556 struct object_id
*this_result
;
559 this_result
= refs_found
? &oid_from_ref
: oid
;
560 strbuf_reset(&fullref
);
561 strbuf_addf(&fullref
, *p
, len
, str
);
562 r
= resolve_ref_unsafe(fullref
.buf
, RESOLVE_REF_READING
,
567 if (!warn_ambiguous_refs
)
569 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
570 warning("ignoring dangling symref %s.", fullref
.buf
);
571 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
572 warning("ignoring broken ref %s.", fullref
.buf
);
575 strbuf_release(&fullref
);
579 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
581 char *last_branch
= substitute_branch_name(&str
, &len
);
584 struct strbuf path
= STRBUF_INIT
;
587 for (p
= ref_rev_parse_rules
; *p
; p
++) {
588 struct object_id hash
;
589 const char *ref
, *it
;
592 strbuf_addf(&path
, *p
, len
, str
);
593 ref
= resolve_ref_unsafe(path
.buf
, RESOLVE_REF_READING
,
597 if (reflog_exists(path
.buf
))
599 else if (strcmp(ref
, path
.buf
) && reflog_exists(ref
))
607 if (!warn_ambiguous_refs
)
610 strbuf_release(&path
);
615 static int is_per_worktree_ref(const char *refname
)
617 return !strcmp(refname
, "HEAD") ||
618 starts_with(refname
, "refs/bisect/") ||
619 starts_with(refname
, "refs/rewritten/");
622 static int is_pseudoref_syntax(const char *refname
)
626 for (c
= refname
; *c
; c
++) {
627 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
634 enum ref_type
ref_type(const char *refname
)
636 if (is_per_worktree_ref(refname
))
637 return REF_TYPE_PER_WORKTREE
;
638 if (is_pseudoref_syntax(refname
))
639 return REF_TYPE_PSEUDOREF
;
640 return REF_TYPE_NORMAL
;
643 long get_files_ref_lock_timeout_ms(void)
645 static int configured
= 0;
647 /* The default timeout is 100 ms: */
648 static int timeout_ms
= 100;
651 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
658 static int write_pseudoref(const char *pseudoref
, const struct object_id
*oid
,
659 const struct object_id
*old_oid
, struct strbuf
*err
)
661 const char *filename
;
663 struct lock_file lock
= LOCK_INIT
;
664 struct strbuf buf
= STRBUF_INIT
;
670 strbuf_addf(&buf
, "%s\n", oid_to_hex(oid
));
672 filename
= git_path("%s", pseudoref
);
673 fd
= hold_lock_file_for_update_timeout(&lock
, filename
, 0,
674 get_files_ref_lock_timeout_ms());
676 strbuf_addf(err
, "could not open '%s' for writing: %s",
677 filename
, strerror(errno
));
682 struct object_id actual_old_oid
;
684 if (read_ref(pseudoref
, &actual_old_oid
))
685 die("could not read ref '%s'", pseudoref
);
686 if (oidcmp(&actual_old_oid
, old_oid
)) {
687 strbuf_addf(err
, "unexpected sha1 when writing '%s'", pseudoref
);
688 rollback_lock_file(&lock
);
693 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
694 strbuf_addf(err
, "could not write to '%s'", filename
);
695 rollback_lock_file(&lock
);
699 commit_lock_file(&lock
);
702 strbuf_release(&buf
);
706 static int delete_pseudoref(const char *pseudoref
, const struct object_id
*old_oid
)
708 const char *filename
;
710 filename
= git_path("%s", pseudoref
);
712 if (old_oid
&& !is_null_oid(old_oid
)) {
713 struct lock_file lock
= LOCK_INIT
;
715 struct object_id actual_old_oid
;
717 fd
= hold_lock_file_for_update_timeout(
719 get_files_ref_lock_timeout_ms());
721 error_errno(_("could not open '%s' for writing"),
725 if (read_ref(pseudoref
, &actual_old_oid
))
726 die("could not read ref '%s'", pseudoref
);
727 if (oidcmp(&actual_old_oid
, old_oid
)) {
728 warning("Unexpected sha1 when deleting %s", pseudoref
);
729 rollback_lock_file(&lock
);
734 rollback_lock_file(&lock
);
742 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
744 const struct object_id
*old_oid
,
747 struct ref_transaction
*transaction
;
748 struct strbuf err
= STRBUF_INIT
;
750 if (ref_type(refname
) == REF_TYPE_PSEUDOREF
) {
751 assert(refs
== get_main_ref_store(the_repository
));
752 return delete_pseudoref(refname
, old_oid
);
755 transaction
= ref_store_transaction_begin(refs
, &err
);
757 ref_transaction_delete(transaction
, refname
, old_oid
,
759 ref_transaction_commit(transaction
, &err
)) {
760 error("%s", err
.buf
);
761 ref_transaction_free(transaction
);
762 strbuf_release(&err
);
765 ref_transaction_free(transaction
);
766 strbuf_release(&err
);
770 int delete_ref(const char *msg
, const char *refname
,
771 const struct object_id
*old_oid
, unsigned int flags
)
773 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
777 int copy_reflog_msg(char *buf
, const char *msg
)
784 while ((c
= *msg
++)) {
785 if (wasspace
&& isspace(c
))
787 wasspace
= isspace(c
);
792 while (buf
< cp
&& isspace(cp
[-1]))
798 int should_autocreate_reflog(const char *refname
)
800 switch (log_all_ref_updates
) {
801 case LOG_REFS_ALWAYS
:
803 case LOG_REFS_NORMAL
:
804 return starts_with(refname
, "refs/heads/") ||
805 starts_with(refname
, "refs/remotes/") ||
806 starts_with(refname
, "refs/notes/") ||
807 !strcmp(refname
, "HEAD");
813 int is_branch(const char *refname
)
815 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
818 struct read_ref_at_cb
{
823 struct object_id
*oid
;
826 struct object_id ooid
;
827 struct object_id noid
;
831 timestamp_t
*cutoff_time
;
836 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
837 const char *email
, timestamp_t timestamp
, int tz
,
838 const char *message
, void *cb_data
)
840 struct read_ref_at_cb
*cb
= cb_data
;
844 cb
->date
= timestamp
;
846 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
848 *cb
->msg
= xstrdup(message
);
850 *cb
->cutoff_time
= timestamp
;
854 *cb
->cutoff_cnt
= cb
->reccnt
- 1;
856 * we have not yet updated cb->[n|o]oid so they still
857 * hold the values for the previous record.
859 if (!is_null_oid(&cb
->ooid
)) {
860 oidcpy(cb
->oid
, noid
);
861 if (oidcmp(&cb
->ooid
, noid
))
862 warning("Log for ref %s has gap after %s.",
863 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
865 else if (cb
->date
== cb
->at_time
)
866 oidcpy(cb
->oid
, noid
);
867 else if (oidcmp(noid
, cb
->oid
))
868 warning("Log for ref %s unexpectedly ended on %s.",
869 cb
->refname
, show_date(cb
->date
, cb
->tz
,
870 DATE_MODE(RFC2822
)));
871 oidcpy(&cb
->ooid
, ooid
);
872 oidcpy(&cb
->noid
, noid
);
876 oidcpy(&cb
->ooid
, ooid
);
877 oidcpy(&cb
->noid
, noid
);
883 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
884 const char *email
, timestamp_t timestamp
,
885 int tz
, const char *message
, void *cb_data
)
887 struct read_ref_at_cb
*cb
= cb_data
;
890 *cb
->msg
= xstrdup(message
);
892 *cb
->cutoff_time
= timestamp
;
896 *cb
->cutoff_cnt
= cb
->reccnt
;
897 oidcpy(cb
->oid
, ooid
);
898 if (is_null_oid(cb
->oid
))
899 oidcpy(cb
->oid
, noid
);
900 /* We just want the first entry */
904 int read_ref_at(const char *refname
, unsigned int flags
, timestamp_t at_time
, int cnt
,
905 struct object_id
*oid
, char **msg
,
906 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
908 struct read_ref_at_cb cb
;
910 memset(&cb
, 0, sizeof(cb
));
911 cb
.refname
= refname
;
912 cb
.at_time
= at_time
;
915 cb
.cutoff_time
= cutoff_time
;
916 cb
.cutoff_tz
= cutoff_tz
;
917 cb
.cutoff_cnt
= cutoff_cnt
;
920 for_each_reflog_ent_reverse(refname
, read_ref_at_ent
, &cb
);
923 if (flags
& GET_OID_QUIETLY
)
926 die("Log for %s is empty.", refname
);
931 for_each_reflog_ent(refname
, read_ref_at_ent_oldest
, &cb
);
936 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
939 struct ref_transaction
*tr
;
942 tr
= xcalloc(1, sizeof(struct ref_transaction
));
943 tr
->ref_store
= refs
;
947 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
949 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
952 void ref_transaction_free(struct ref_transaction
*transaction
)
959 switch (transaction
->state
) {
960 case REF_TRANSACTION_OPEN
:
961 case REF_TRANSACTION_CLOSED
:
964 case REF_TRANSACTION_PREPARED
:
965 die("BUG: free called on a prepared reference transaction");
968 die("BUG: unexpected reference transaction state");
972 for (i
= 0; i
< transaction
->nr
; i
++) {
973 free(transaction
->updates
[i
]->msg
);
974 free(transaction
->updates
[i
]);
976 free(transaction
->updates
);
980 struct ref_update
*ref_transaction_add_update(
981 struct ref_transaction
*transaction
,
982 const char *refname
, unsigned int flags
,
983 const struct object_id
*new_oid
,
984 const struct object_id
*old_oid
,
987 struct ref_update
*update
;
989 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
990 die("BUG: update called for transaction that is not open");
992 FLEX_ALLOC_STR(update
, refname
, refname
);
993 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
994 transaction
->updates
[transaction
->nr
++] = update
;
996 update
->flags
= flags
;
998 if (flags
& REF_HAVE_NEW
)
999 oidcpy(&update
->new_oid
, new_oid
);
1000 if (flags
& REF_HAVE_OLD
)
1001 oidcpy(&update
->old_oid
, old_oid
);
1002 update
->msg
= xstrdup_or_null(msg
);
1006 int ref_transaction_update(struct ref_transaction
*transaction
,
1007 const char *refname
,
1008 const struct object_id
*new_oid
,
1009 const struct object_id
*old_oid
,
1010 unsigned int flags
, const char *msg
,
1015 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1016 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1017 !refname_is_safe(refname
)) {
1018 strbuf_addf(err
, "refusing to update ref with bad name '%s'",
1023 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1024 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1026 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1028 ref_transaction_add_update(transaction
, refname
, flags
,
1029 new_oid
, old_oid
, msg
);
1033 int ref_transaction_create(struct ref_transaction
*transaction
,
1034 const char *refname
,
1035 const struct object_id
*new_oid
,
1036 unsigned int flags
, const char *msg
,
1039 if (!new_oid
|| is_null_oid(new_oid
))
1040 die("BUG: create called without valid new_oid");
1041 return ref_transaction_update(transaction
, refname
, new_oid
,
1042 &null_oid
, flags
, msg
, err
);
1045 int ref_transaction_delete(struct ref_transaction
*transaction
,
1046 const char *refname
,
1047 const struct object_id
*old_oid
,
1048 unsigned int flags
, const char *msg
,
1051 if (old_oid
&& is_null_oid(old_oid
))
1052 die("BUG: delete called with old_oid set to zeros");
1053 return ref_transaction_update(transaction
, refname
,
1058 int ref_transaction_verify(struct ref_transaction
*transaction
,
1059 const char *refname
,
1060 const struct object_id
*old_oid
,
1065 die("BUG: verify called with old_oid set to NULL");
1066 return ref_transaction_update(transaction
, refname
,
1071 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1072 const char *refname
, const struct object_id
*new_oid
,
1073 const struct object_id
*old_oid
, unsigned int flags
,
1074 enum action_on_err onerr
)
1076 struct ref_transaction
*t
= NULL
;
1077 struct strbuf err
= STRBUF_INIT
;
1080 if (ref_type(refname
) == REF_TYPE_PSEUDOREF
) {
1081 assert(refs
== get_main_ref_store(the_repository
));
1082 ret
= write_pseudoref(refname
, new_oid
, old_oid
, &err
);
1084 t
= ref_store_transaction_begin(refs
, &err
);
1086 ref_transaction_update(t
, refname
, new_oid
, old_oid
,
1087 flags
, msg
, &err
) ||
1088 ref_transaction_commit(t
, &err
)) {
1090 ref_transaction_free(t
);
1094 const char *str
= "update_ref failed for ref '%s': %s";
1097 case UPDATE_REFS_MSG_ON_ERR
:
1098 error(str
, refname
, err
.buf
);
1100 case UPDATE_REFS_DIE_ON_ERR
:
1101 die(str
, refname
, err
.buf
);
1103 case UPDATE_REFS_QUIET_ON_ERR
:
1106 strbuf_release(&err
);
1109 strbuf_release(&err
);
1111 ref_transaction_free(t
);
1115 int update_ref(const char *msg
, const char *refname
,
1116 const struct object_id
*new_oid
,
1117 const struct object_id
*old_oid
,
1118 unsigned int flags
, enum action_on_err onerr
)
1120 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1121 old_oid
, flags
, onerr
);
1124 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1127 static char **scanf_fmts
;
1128 static int nr_rules
;
1130 struct strbuf resolved_buf
= STRBUF_INIT
;
1134 * Pre-generate scanf formats from ref_rev_parse_rules[].
1135 * Generate a format suitable for scanf from a
1136 * ref_rev_parse_rules rule by interpolating "%s" at the
1137 * location of the "%.*s".
1139 size_t total_len
= 0;
1142 /* the rule list is NULL terminated, count them first */
1143 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1144 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1145 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1147 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1150 for (i
= 0; i
< nr_rules
; i
++) {
1151 assert(offset
< total_len
);
1152 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1153 offset
+= snprintf(scanf_fmts
[i
], total_len
- offset
,
1154 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1158 /* bail out if there are no rules */
1160 return xstrdup(refname
);
1162 /* buffer for scanf result, at most refname must fit */
1163 short_name
= xstrdup(refname
);
1165 /* skip first rule, it will always match */
1166 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1168 int rules_to_fail
= i
;
1171 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1174 short_name_len
= strlen(short_name
);
1177 * in strict mode, all (except the matched one) rules
1178 * must fail to resolve to a valid non-ambiguous ref
1181 rules_to_fail
= nr_rules
;
1184 * check if the short name resolves to a valid ref,
1185 * but use only rules prior to the matched one
1187 for (j
= 0; j
< rules_to_fail
; j
++) {
1188 const char *rule
= ref_rev_parse_rules
[j
];
1190 /* skip matched rule */
1195 * the short name is ambiguous, if it resolves
1196 * (with this previous rule) to a valid ref
1197 * read_ref() returns 0 on success
1199 strbuf_reset(&resolved_buf
);
1200 strbuf_addf(&resolved_buf
, rule
,
1201 short_name_len
, short_name
);
1202 if (ref_exists(resolved_buf
.buf
))
1207 * short name is non-ambiguous if all previous rules
1208 * haven't resolved to a valid ref
1210 if (j
== rules_to_fail
) {
1211 strbuf_release(&resolved_buf
);
1216 strbuf_release(&resolved_buf
);
1218 return xstrdup(refname
);
1221 static struct string_list
*hide_refs
;
1223 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1226 if (!strcmp("transfer.hiderefs", var
) ||
1227 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1228 !strcmp(key
, "hiderefs"))) {
1233 return config_error_nonbool(var
);
1234 ref
= xstrdup(value
);
1236 while (len
&& ref
[len
- 1] == '/')
1239 hide_refs
= xcalloc(1, sizeof(*hide_refs
));
1240 hide_refs
->strdup_strings
= 1;
1242 string_list_append(hide_refs
, ref
);
1247 int ref_is_hidden(const char *refname
, const char *refname_full
)
1253 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1254 const char *match
= hide_refs
->items
[i
].string
;
1255 const char *subject
;
1259 if (*match
== '!') {
1264 if (*match
== '^') {
1265 subject
= refname_full
;
1271 /* refname can be NULL when namespaces are used. */
1273 skip_prefix(subject
, match
, &p
) &&
1280 const char *find_descendant_ref(const char *dirname
,
1281 const struct string_list
*extras
,
1282 const struct string_list
*skip
)
1290 * Look at the place where dirname would be inserted into
1291 * extras. If there is an entry at that position that starts
1292 * with dirname (remember, dirname includes the trailing
1293 * slash) and is not in skip, then we have a conflict.
1295 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1296 pos
< extras
->nr
; pos
++) {
1297 const char *extra_refname
= extras
->items
[pos
].string
;
1299 if (!starts_with(extra_refname
, dirname
))
1302 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1303 return extra_refname
;
1308 int refs_rename_ref_available(struct ref_store
*refs
,
1309 const char *old_refname
,
1310 const char *new_refname
)
1312 struct string_list skip
= STRING_LIST_INIT_NODUP
;
1313 struct strbuf err
= STRBUF_INIT
;
1316 string_list_insert(&skip
, old_refname
);
1317 ok
= !refs_verify_refname_available(refs
, new_refname
,
1320 error("%s", err
.buf
);
1322 string_list_clear(&skip
, 0);
1323 strbuf_release(&err
);
1327 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1329 struct object_id oid
;
1332 if (!refs_read_ref_full(refs
, "HEAD", RESOLVE_REF_READING
,
1334 return fn("HEAD", &oid
, flag
, cb_data
);
1339 int head_ref(each_ref_fn fn
, void *cb_data
)
1341 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1344 struct ref_iterator
*refs_ref_iterator_begin(
1345 struct ref_store
*refs
,
1346 const char *prefix
, int trim
, int flags
)
1348 struct ref_iterator
*iter
;
1350 if (ref_paranoia
< 0)
1351 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 0);
1353 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1355 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1358 * `iterator_begin()` already takes care of prefix, but we
1359 * might need to do some trimming:
1362 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1364 /* Sanity check for subclasses: */
1366 BUG("reference iterator is not ordered");
1372 * Call fn for each reference in the specified submodule for which the
1373 * refname begins with prefix. If trim is non-zero, then trim that
1374 * many characters off the beginning of each refname before passing
1375 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1376 * include broken references in the iteration. If fn ever returns a
1377 * non-zero value, stop the iteration and return that value;
1378 * otherwise, return 0.
1380 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1381 each_ref_fn fn
, int trim
, int flags
, void *cb_data
)
1383 struct ref_iterator
*iter
;
1388 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1390 return do_for_each_ref_iterator(iter
, fn
, cb_data
);
1393 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1395 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1398 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1400 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1403 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1404 each_ref_fn fn
, void *cb_data
)
1406 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1409 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1411 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1414 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
, unsigned int broken
)
1416 unsigned int flag
= 0;
1419 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1420 return do_for_each_ref(get_main_ref_store(the_repository
),
1421 prefix
, fn
, 0, flag
, cb_data
);
1424 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1425 each_ref_fn fn
, void *cb_data
,
1426 unsigned int broken
)
1428 unsigned int flag
= 0;
1431 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1432 return do_for_each_ref(refs
, prefix
, fn
, 0, flag
, cb_data
);
1435 int for_each_replace_ref(struct repository
*r
, each_ref_fn fn
, void *cb_data
)
1437 return do_for_each_ref(get_main_ref_store(r
),
1438 git_replace_ref_base
, fn
,
1439 strlen(git_replace_ref_base
),
1440 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1443 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1445 struct strbuf buf
= STRBUF_INIT
;
1447 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1448 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1449 buf
.buf
, fn
, 0, 0, cb_data
);
1450 strbuf_release(&buf
);
1454 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1456 return do_for_each_ref(refs
, "", fn
, 0,
1457 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1460 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1462 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1465 int refs_read_raw_ref(struct ref_store
*ref_store
,
1466 const char *refname
, struct object_id
*oid
,
1467 struct strbuf
*referent
, unsigned int *type
)
1469 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
, type
);
1472 /* This function needs to return a meaningful errno on failure */
1473 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1474 const char *refname
,
1476 struct object_id
*oid
, int *flags
)
1478 static struct strbuf sb_refname
= STRBUF_INIT
;
1479 struct object_id unused_oid
;
1486 flags
= &unused_flags
;
1490 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1491 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1492 !refname_is_safe(refname
)) {
1498 * dwim_ref() uses REF_ISBROKEN to distinguish between
1499 * missing refs and refs that were present but invalid,
1500 * to complain about the latter to stderr.
1502 * We don't know whether the ref exists, so don't set
1505 *flags
|= REF_BAD_NAME
;
1508 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1509 unsigned int read_flags
= 0;
1511 if (refs_read_raw_ref(refs
, refname
,
1512 oid
, &sb_refname
, &read_flags
)) {
1513 *flags
|= read_flags
;
1515 /* In reading mode, refs must eventually resolve */
1516 if (resolve_flags
& RESOLVE_REF_READING
)
1520 * Otherwise a missing ref is OK. But the files backend
1521 * may show errors besides ENOENT if there are
1522 * similarly-named refs.
1524 if (errno
!= ENOENT
&&
1530 if (*flags
& REF_BAD_NAME
)
1531 *flags
|= REF_ISBROKEN
;
1535 *flags
|= read_flags
;
1537 if (!(read_flags
& REF_ISSYMREF
)) {
1538 if (*flags
& REF_BAD_NAME
) {
1540 *flags
|= REF_ISBROKEN
;
1545 refname
= sb_refname
.buf
;
1546 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1550 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1551 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1552 !refname_is_safe(refname
)) {
1557 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1565 /* backend functions */
1566 int refs_init_db(struct strbuf
*err
)
1568 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1570 return refs
->be
->init_db(refs
, err
);
1573 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1574 struct object_id
*oid
, int *flags
)
1576 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1577 resolve_flags
, oid
, flags
);
1580 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1581 struct object_id
*oid
)
1583 struct ref_store
*refs
;
1586 refs
= get_submodule_ref_store(submodule
);
1591 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1597 struct ref_store_hash_entry
1599 struct hashmap_entry ent
; /* must be the first member! */
1601 struct ref_store
*refs
;
1603 /* NUL-terminated identifier of the ref store: */
1604 char name
[FLEX_ARRAY
];
1607 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1608 const void *entry
, const void *entry_or_key
,
1609 const void *keydata
)
1611 const struct ref_store_hash_entry
*e1
= entry
, *e2
= entry_or_key
;
1612 const char *name
= keydata
? keydata
: e2
->name
;
1614 return strcmp(e1
->name
, name
);
1617 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1618 const char *name
, struct ref_store
*refs
)
1620 struct ref_store_hash_entry
*entry
;
1622 FLEX_ALLOC_STR(entry
, name
, name
);
1623 hashmap_entry_init(entry
, strhash(name
));
1628 /* A hashmap of ref_stores, stored by submodule name: */
1629 static struct hashmap submodule_ref_stores
;
1631 /* A hashmap of ref_stores, stored by worktree id: */
1632 static struct hashmap worktree_ref_stores
;
1635 * Look up a ref store by name. If that ref_store hasn't been
1636 * registered yet, return NULL.
1638 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1641 struct ref_store_hash_entry
*entry
;
1643 if (!map
->tablesize
)
1644 /* It's initialized on demand in register_ref_store(). */
1647 entry
= hashmap_get_from_hash(map
, strhash(name
), name
);
1648 return entry
? entry
->refs
: NULL
;
1652 * Create, record, and return a ref_store instance for the specified
1655 static struct ref_store
*ref_store_init(const char *gitdir
,
1658 const char *be_name
= "files";
1659 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1660 struct ref_store
*refs
;
1663 die("BUG: reference backend %s is unknown", be_name
);
1665 refs
= be
->init(gitdir
, flags
);
1669 struct ref_store
*get_main_ref_store(struct repository
*r
)
1675 BUG("attempting to get main_ref_store outside of repository");
1677 r
->refs
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1682 * Associate a ref store with a name. It is a fatal error to call this
1683 * function twice for the same name.
1685 static void register_ref_store_map(struct hashmap
*map
,
1687 struct ref_store
*refs
,
1690 if (!map
->tablesize
)
1691 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1693 if (hashmap_put(map
, alloc_ref_store_hash_entry(name
, refs
)))
1694 die("BUG: %s ref_store '%s' initialized twice", type
, name
);
1697 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1699 struct strbuf submodule_sb
= STRBUF_INIT
;
1700 struct ref_store
*refs
;
1701 char *to_free
= NULL
;
1707 len
= strlen(submodule
);
1708 while (len
&& is_dir_sep(submodule
[len
- 1]))
1714 /* We need to strip off one or more trailing slashes */
1715 submodule
= to_free
= xmemdupz(submodule
, len
);
1717 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1721 strbuf_addstr(&submodule_sb
, submodule
);
1722 if (!is_nonbare_repository_dir(&submodule_sb
))
1725 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1728 /* assume that add_submodule_odb() has been called */
1729 refs
= ref_store_init(submodule_sb
.buf
,
1730 REF_STORE_READ
| REF_STORE_ODB
);
1731 register_ref_store_map(&submodule_ref_stores
, "submodule",
1735 strbuf_release(&submodule_sb
);
1741 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1743 struct ref_store
*refs
;
1747 return get_main_ref_store(the_repository
);
1749 id
= wt
->id
? wt
->id
: "/";
1750 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1755 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1756 REF_STORE_ALL_CAPS
);
1758 refs
= ref_store_init(get_git_common_dir(),
1759 REF_STORE_ALL_CAPS
);
1762 register_ref_store_map(&worktree_ref_stores
, "worktree",
1767 void base_ref_store_init(struct ref_store
*refs
,
1768 const struct ref_storage_be
*be
)
1773 /* backend functions */
1774 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1776 return refs
->be
->pack_refs(refs
, flags
);
1779 int refs_peel_ref(struct ref_store
*refs
, const char *refname
,
1780 struct object_id
*oid
)
1783 struct object_id base
;
1785 if (current_ref_iter
&& current_ref_iter
->refname
== refname
) {
1786 struct object_id peeled
;
1788 if (ref_iterator_peel(current_ref_iter
, &peeled
))
1790 oidcpy(oid
, &peeled
);
1794 if (refs_read_ref_full(refs
, refname
,
1795 RESOLVE_REF_READING
, &base
, &flag
))
1798 return peel_object(&base
, oid
);
1801 int peel_ref(const char *refname
, struct object_id
*oid
)
1803 return refs_peel_ref(get_main_ref_store(the_repository
), refname
, oid
);
1806 int refs_create_symref(struct ref_store
*refs
,
1807 const char *ref_target
,
1808 const char *refs_heads_master
,
1811 return refs
->be
->create_symref(refs
, ref_target
,
1816 int create_symref(const char *ref_target
, const char *refs_heads_master
,
1819 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
1820 refs_heads_master
, logmsg
);
1823 int ref_update_reject_duplicates(struct string_list
*refnames
,
1826 size_t i
, n
= refnames
->nr
;
1830 for (i
= 1; i
< n
; i
++) {
1831 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
1832 refnames
->items
[i
].string
);
1836 "multiple updates for ref '%s' not allowed.",
1837 refnames
->items
[i
].string
);
1839 } else if (cmp
> 0) {
1840 die("BUG: ref_update_reject_duplicates() received unsorted list");
1846 int ref_transaction_prepare(struct ref_transaction
*transaction
,
1849 struct ref_store
*refs
= transaction
->ref_store
;
1851 switch (transaction
->state
) {
1852 case REF_TRANSACTION_OPEN
:
1855 case REF_TRANSACTION_PREPARED
:
1856 die("BUG: prepare called twice on reference transaction");
1858 case REF_TRANSACTION_CLOSED
:
1859 die("BUG: prepare called on a closed reference transaction");
1862 die("BUG: unexpected reference transaction state");
1866 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
1868 _("ref updates forbidden inside quarantine environment"));
1872 return refs
->be
->transaction_prepare(refs
, transaction
, err
);
1875 int ref_transaction_abort(struct ref_transaction
*transaction
,
1878 struct ref_store
*refs
= transaction
->ref_store
;
1881 switch (transaction
->state
) {
1882 case REF_TRANSACTION_OPEN
:
1883 /* No need to abort explicitly. */
1885 case REF_TRANSACTION_PREPARED
:
1886 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
1888 case REF_TRANSACTION_CLOSED
:
1889 die("BUG: abort called on a closed reference transaction");
1892 die("BUG: unexpected reference transaction state");
1896 ref_transaction_free(transaction
);
1900 int ref_transaction_commit(struct ref_transaction
*transaction
,
1903 struct ref_store
*refs
= transaction
->ref_store
;
1906 switch (transaction
->state
) {
1907 case REF_TRANSACTION_OPEN
:
1908 /* Need to prepare first. */
1909 ret
= ref_transaction_prepare(transaction
, err
);
1913 case REF_TRANSACTION_PREPARED
:
1914 /* Fall through to finish. */
1916 case REF_TRANSACTION_CLOSED
:
1917 die("BUG: commit called on a closed reference transaction");
1920 die("BUG: unexpected reference transaction state");
1924 return refs
->be
->transaction_finish(refs
, transaction
, err
);
1927 int refs_verify_refname_available(struct ref_store
*refs
,
1928 const char *refname
,
1929 const struct string_list
*extras
,
1930 const struct string_list
*skip
,
1934 const char *extra_refname
;
1935 struct strbuf dirname
= STRBUF_INIT
;
1936 struct strbuf referent
= STRBUF_INIT
;
1937 struct object_id oid
;
1939 struct ref_iterator
*iter
;
1944 * For the sake of comments in this function, suppose that
1945 * refname is "refs/foo/bar".
1950 strbuf_grow(&dirname
, strlen(refname
) + 1);
1951 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
1952 /* Expand dirname to the new prefix, not including the trailing slash: */
1953 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
1956 * We are still at a leading dir of the refname (e.g.,
1957 * "refs/foo"; if there is a reference with that name,
1958 * it is a conflict, *unless* it is in skip.
1960 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
1963 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
, &type
)) {
1964 strbuf_addf(err
, "'%s' exists; cannot create '%s'",
1965 dirname
.buf
, refname
);
1969 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
1970 strbuf_addf(err
, "cannot process '%s' and '%s' at the same time",
1971 refname
, dirname
.buf
);
1977 * We are at the leaf of our refname (e.g., "refs/foo/bar").
1978 * There is no point in searching for a reference with that
1979 * name, because a refname isn't considered to conflict with
1980 * itself. But we still need to check for references whose
1981 * names are in the "refs/foo/bar/" namespace, because they
1984 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
1985 strbuf_addch(&dirname
, '/');
1987 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
1988 DO_FOR_EACH_INCLUDE_BROKEN
);
1989 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
1991 string_list_has_string(skip
, iter
->refname
))
1994 strbuf_addf(err
, "'%s' exists; cannot create '%s'",
1995 iter
->refname
, refname
);
1996 ref_iterator_abort(iter
);
2000 if (ok
!= ITER_DONE
)
2001 die("BUG: error while iterating over references");
2003 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2005 strbuf_addf(err
, "cannot process '%s' and '%s' at the same time",
2006 refname
, extra_refname
);
2011 strbuf_release(&referent
);
2012 strbuf_release(&dirname
);
2016 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2018 struct ref_iterator
*iter
;
2020 iter
= refs
->be
->reflog_iterator_begin(refs
);
2022 return do_for_each_ref_iterator(iter
, fn
, cb_data
);
2025 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2027 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2030 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2031 const char *refname
,
2032 each_reflog_ent_fn fn
,
2035 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2039 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2042 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2043 refname
, fn
, cb_data
);
2046 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2047 each_reflog_ent_fn fn
, void *cb_data
)
2049 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2052 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2055 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2059 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2061 return refs
->be
->reflog_exists(refs
, refname
);
2064 int reflog_exists(const char *refname
)
2066 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2069 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2070 int force_create
, struct strbuf
*err
)
2072 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2075 int safe_create_reflog(const char *refname
, int force_create
,
2078 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2082 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2084 return refs
->be
->delete_reflog(refs
, refname
);
2087 int delete_reflog(const char *refname
)
2089 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2092 int refs_reflog_expire(struct ref_store
*refs
,
2093 const char *refname
, const struct object_id
*oid
,
2095 reflog_expiry_prepare_fn prepare_fn
,
2096 reflog_expiry_should_prune_fn should_prune_fn
,
2097 reflog_expiry_cleanup_fn cleanup_fn
,
2098 void *policy_cb_data
)
2100 return refs
->be
->reflog_expire(refs
, refname
, oid
, flags
,
2101 prepare_fn
, should_prune_fn
,
2102 cleanup_fn
, policy_cb_data
);
2105 int reflog_expire(const char *refname
, const struct object_id
*oid
,
2107 reflog_expiry_prepare_fn prepare_fn
,
2108 reflog_expiry_should_prune_fn should_prune_fn
,
2109 reflog_expiry_cleanup_fn cleanup_fn
,
2110 void *policy_cb_data
)
2112 return refs_reflog_expire(get_main_ref_store(the_repository
),
2113 refname
, oid
, flags
,
2114 prepare_fn
, should_prune_fn
,
2115 cleanup_fn
, policy_cb_data
);
2118 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2121 struct ref_store
*refs
= transaction
->ref_store
;
2123 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2126 int refs_delete_refs(struct ref_store
*refs
, const char *msg
,
2127 struct string_list
*refnames
, unsigned int flags
)
2129 return refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2132 int delete_refs(const char *msg
, struct string_list
*refnames
,
2135 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2138 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2139 const char *newref
, const char *logmsg
)
2141 return refs
->be
->rename_ref(refs
, oldref
, newref
, logmsg
);
2144 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2146 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2149 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2150 const char *newref
, const char *logmsg
)
2152 return refs
->be
->copy_ref(refs
, oldref
, newref
, logmsg
);
2155 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2157 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);