1 #ifndef REFS_REFS_INTERNAL_H
2 #define REFS_REFS_INTERNAL_H
7 struct ref_transaction
;
10 * Data structures and functions for the internal use of the refs
11 * module. Code outside of the refs module should use only the public
12 * functions defined in "refs.h", and should *not* include this file.
16 * The following flags can appear in `ref_update::flags`. Their
17 * numerical values must not conflict with those of REF_NO_DEREF and
18 * REF_FORCE_CREATE_REFLOG, which are also stored in
19 * `ref_update::flags`.
23 * The reference should be updated to new_oid.
25 #define REF_HAVE_NEW (1 << 2)
28 * The current reference's value should be checked to make sure that
29 * it agrees with old_oid.
31 #define REF_HAVE_OLD (1 << 3)
34 * Used as a flag in ref_update::flags when we want to log a ref
35 * update but not actually perform it. This is used when a symbolic
36 * ref update is split up.
38 #define REF_LOG_ONLY (1 << 7)
41 * Return the length of time to retry acquiring a loose reference lock
42 * before giving up, in milliseconds:
44 long get_files_ref_lock_timeout_ms(void);
47 * Return true iff refname is minimally safe. "Safe" here means that
48 * deleting a loose reference by this name will not do any damage, for
49 * example by causing a file that is not a reference to be deleted.
50 * This function does not check that the reference name is legal; for
51 * that, use check_refname_format().
53 * A refname that starts with "refs/" is considered safe iff it
54 * doesn't contain any "." or ".." components or consecutive '/'
55 * characters, end with '/', or (on Windows) contain any '\'
56 * characters. Names that do not start with "refs/" are considered
57 * safe iff they consist entirely of upper case characters and '_'
58 * (like "HEAD" and "MERGE_HEAD" but not "config" or "FOO/BAR").
60 int refname_is_safe(const char *refname
);
63 * Helper function: return true if refname, which has the specified
64 * oid and flags, can be resolved to an object in the database. If the
65 * referred-to object does not exist, emit a warning and return false.
67 int ref_resolves_to_object(const char *refname
,
68 struct repository
*repo
,
69 const struct object_id
*oid
,
73 /* object was peeled successfully: */
77 * object cannot be peeled because the named object (or an
78 * object referred to by a tag in the peel chain), does not
83 /* object cannot be peeled because it is not a tag: */
86 /* ref_entry contains no peeled value because it is a symref: */
90 * ref_entry cannot be peeled because it is broken (i.e., the
91 * symbolic reference cannot even be resolved to an object
98 * Peel the named object; i.e., if the object is a tag, resolve the
99 * tag recursively until a non-tag is found. If successful, store the
100 * result to oid and return PEEL_PEELED. If the object is not a tag
101 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
102 * and leave oid unchanged.
104 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
);
107 * Information needed for a single ref update. Set new_oid to the new
108 * value or to null_oid to delete the ref. To check the old value
109 * while the ref is locked, set (flags & REF_HAVE_OLD) and set old_oid
110 * to the old value, or to null_oid to ensure the ref does not exist
115 * If (flags & REF_HAVE_NEW), set the reference to this value
116 * (or delete it, if `new_oid` is `null_oid`).
118 struct object_id new_oid
;
121 * If (flags & REF_HAVE_OLD), check that the reference
122 * previously had this value (or didn't previously exist, if
123 * `old_oid` is `null_oid`).
125 struct object_id old_oid
;
128 * One or more of REF_NO_DEREF, REF_FORCE_CREATE_REFLOG,
129 * REF_HAVE_NEW, REF_HAVE_OLD, or backend-specific flags.
138 * If this ref_update was split off of a symref update via
139 * split_symref_update(), then this member points at that
140 * update. This is used for two purposes:
141 * 1. When reporting errors, we report the refname under which
142 * the update was originally requested.
143 * 2. When we read the old value of this reference, we
144 * propagate it back to its parent update for recording in
145 * the latter's reflog.
147 struct ref_update
*parent_update
;
149 const char refname
[FLEX_ARRAY
];
152 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
153 struct object_id
*oid
, struct strbuf
*referent
,
154 unsigned int *type
, int *failure_errno
);
157 * Write an error to `err` and return a nonzero value iff the same
158 * refname appears multiple times in `refnames`. `refnames` must be
159 * sorted on entry to this function.
161 int ref_update_reject_duplicates(struct string_list
*refnames
,
165 * Add a ref_update with the specified properties to transaction, and
166 * return a pointer to the new object. This function does not verify
167 * that refname is well-formed. new_oid and old_oid are only
168 * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits,
169 * respectively, are set in flags.
171 struct ref_update
*ref_transaction_add_update(
172 struct ref_transaction
*transaction
,
173 const char *refname
, unsigned int flags
,
174 const struct object_id
*new_oid
,
175 const struct object_id
*old_oid
,
179 * Transaction states.
181 * OPEN: The transaction is initialized and new updates can still be
182 * added to it. An OPEN transaction can be prepared,
183 * committed, freed, or aborted (freeing and aborting an open
184 * transaction are equivalent).
186 * PREPARED: ref_transaction_prepare(), which locks all of the
187 * references involved in the update and checks that the
188 * update has no errors, has been called successfully for the
189 * transaction. A PREPARED transaction can be committed or
192 * CLOSED: The transaction is no longer active. A transaction becomes
193 * CLOSED if there is a failure while building the transaction
194 * or if a transaction is committed or aborted. A CLOSED
195 * transaction can only be freed.
197 enum ref_transaction_state
{
198 REF_TRANSACTION_OPEN
= 0,
199 REF_TRANSACTION_PREPARED
= 1,
200 REF_TRANSACTION_CLOSED
= 2
204 * Data structure for holding a reference transaction, which can
205 * consist of checks and updates to multiple references, carried out
206 * as atomically as possible. This structure is opaque to callers.
208 struct ref_transaction
{
209 struct ref_store
*ref_store
;
210 struct ref_update
**updates
;
213 enum ref_transaction_state state
;
218 * Check for entries in extras that are within the specified
219 * directory, where dirname is a reference directory name including
220 * the trailing slash (e.g., "refs/heads/foo/"). Ignore any
221 * conflicting references that are found in skip. If there is a
222 * conflicting reference, return its name.
224 * extras and skip must be sorted lists of reference names. Either one
225 * can be NULL, signifying the empty list.
227 const char *find_descendant_ref(const char *dirname
,
228 const struct string_list
*extras
,
229 const struct string_list
*skip
);
231 /* We allow "recursive" symbolic refs. Only within reason, though */
232 #define SYMREF_MAXDEPTH 5
235 * These flags are passed to refs_ref_iterator_begin() (and do_for_each_ref(),
238 enum do_for_each_ref_flags
{
240 * Include broken references in a do_for_each_ref*() iteration, which
241 * would normally be omitted. This includes both refs that point to
242 * missing objects (a true repository corruption), ones with illegal
243 * names (which we prefer not to expose to callers), as well as
244 * dangling symbolic refs (i.e., those that point to a non-existent
245 * ref; this is not a corruption, but as they have no valid oid, we
246 * omit them from normal iteration results).
248 DO_FOR_EACH_INCLUDE_BROKEN
= (1 << 0),
251 * Only include per-worktree refs in a do_for_each_ref*() iteration.
252 * Normally this will be used with a files ref_store, since that's
253 * where all reference backends will presumably store their
256 DO_FOR_EACH_PER_WORKTREE_ONLY
= (1 << 1),
259 * Omit dangling symrefs from output; this only has an effect with
260 * INCLUDE_BROKEN, since they are otherwise not included at all.
262 DO_FOR_EACH_OMIT_DANGLING_SYMREFS
= (1 << 2),
266 * Reference iterators
268 * A reference iterator encapsulates the state of an in-progress
269 * iteration over references. Create an instance of `struct
270 * ref_iterator` via one of the functions in this module.
272 * A freshly-created ref_iterator doesn't yet point at a reference. To
273 * advance the iterator, call ref_iterator_advance(). If successful,
274 * this sets the iterator's refname, oid, and flags fields to describe
275 * the next reference and returns ITER_OK. The data pointed at by
276 * refname and oid belong to the iterator; if you want to retain them
277 * after calling ref_iterator_advance() again or calling
278 * ref_iterator_abort(), you must make a copy. When the iteration has
279 * been exhausted, ref_iterator_advance() releases any resources
280 * associated with the iteration, frees the ref_iterator object, and
281 * returns ITER_DONE. If you want to abort the iteration early, call
282 * ref_iterator_abort(), which also frees the ref_iterator object and
283 * any associated resources. If there was an internal error advancing
284 * to the next entry, ref_iterator_advance() aborts the iteration,
285 * frees the ref_iterator, and returns ITER_ERROR.
287 * The reference currently being looked at can be peeled by calling
288 * ref_iterator_peel(). This function is often faster than peel_ref(),
289 * so it should be preferred when iterating over references.
291 * Putting it all together, a typical iteration looks like this:
294 * struct ref_iterator *iter = ...;
296 * while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
297 * if (want_to_stop_iteration()) {
298 * ok = ref_iterator_abort(iter);
302 * // Access information about the current reference:
303 * if (!(iter->flags & REF_ISSYMREF))
304 * printf("%s is %s\n", iter->refname, oid_to_hex(iter->oid));
306 * // If you need to peel the reference:
307 * ref_iterator_peel(iter, &oid);
310 * if (ok != ITER_DONE)
313 struct ref_iterator
{
314 struct ref_iterator_vtable
*vtable
;
317 * Does this `ref_iterator` iterate over references in order
320 unsigned int ordered
: 1;
323 const struct object_id
*oid
;
328 * Advance the iterator to the first or next item and return ITER_OK.
329 * If the iteration is exhausted, free the resources associated with
330 * the ref_iterator and return ITER_DONE. On errors, free the iterator
331 * resources and return ITER_ERROR. It is a bug to use ref_iterator or
332 * call this function again after it has returned ITER_DONE or
335 int ref_iterator_advance(struct ref_iterator
*ref_iterator
);
338 * If possible, peel the reference currently being viewed by the
339 * iterator. Return 0 on success.
341 int ref_iterator_peel(struct ref_iterator
*ref_iterator
,
342 struct object_id
*peeled
);
345 * End the iteration before it has been exhausted, freeing the
346 * reference iterator and any associated resources and returning
347 * ITER_DONE. If the abort itself failed, return ITER_ERROR.
349 int ref_iterator_abort(struct ref_iterator
*ref_iterator
);
352 * An iterator over nothing (its first ref_iterator_advance() call
353 * returns ITER_DONE).
355 struct ref_iterator
*empty_ref_iterator_begin(void);
358 * Return true iff ref_iterator is an empty_ref_iterator.
360 int is_empty_ref_iterator(struct ref_iterator
*ref_iterator
);
363 * Return an iterator that goes over each reference in `refs` for
364 * which the refname begins with prefix. If trim is non-zero, then
365 * trim that many characters off the beginning of each refname.
366 * The output is ordered by refname.
368 struct ref_iterator
*refs_ref_iterator_begin(
369 struct ref_store
*refs
,
370 const char *prefix
, const char **exclude_patterns
,
371 int trim
, enum do_for_each_ref_flags flags
);
374 * A callback function used to instruct merge_ref_iterator how to
375 * interleave the entries from iter0 and iter1. The function should
376 * return one of the constants defined in enum iterator_selection. It
377 * must not advance either of the iterators itself.
379 * The function must be prepared to handle the case that iter0 and/or
380 * iter1 is NULL, which indicates that the corresponding sub-iterator
381 * has been exhausted. Its return value must be consistent with the
382 * current states of the iterators; e.g., it must not return
383 * ITER_SKIP_1 if iter1 has already been exhausted.
385 typedef enum iterator_selection
ref_iterator_select_fn(
386 struct ref_iterator
*iter0
, struct ref_iterator
*iter1
,
390 * Iterate over the entries from iter0 and iter1, with the values
391 * interleaved as directed by the select function. The iterator takes
392 * ownership of iter0 and iter1 and frees them when the iteration is
393 * over. A derived class should set `ordered` to 1 or 0 based on
394 * whether it generates its output in order by reference name.
396 struct ref_iterator
*merge_ref_iterator_begin(
398 struct ref_iterator
*iter0
, struct ref_iterator
*iter1
,
399 ref_iterator_select_fn
*select
, void *cb_data
);
402 * An iterator consisting of the union of the entries from front and
403 * back. If there are entries common to the two sub-iterators, use the
404 * one from front. Each iterator must iterate over its entries in
405 * strcmp() order by refname for this to work.
407 * The new iterator takes ownership of its arguments and frees them
408 * when the iteration is over. As a convenience to callers, if front
409 * or back is an empty_ref_iterator, then abort that one immediately
410 * and return the other iterator directly, without wrapping it.
412 struct ref_iterator
*overlay_ref_iterator_begin(
413 struct ref_iterator
*front
, struct ref_iterator
*back
);
416 * Wrap iter0, only letting through the references whose names start
417 * with prefix. If trim is set, set iter->refname to the name of the
418 * reference with that many characters trimmed off the front;
419 * otherwise set it to the full refname. The new iterator takes over
420 * ownership of iter0 and frees it when iteration is over. It makes
421 * its own copy of prefix.
423 * As an convenience to callers, if prefix is the empty string and
424 * trim is zero, this function returns iter0 directly, without
427 * The resulting ref_iterator is ordered if iter0 is.
429 struct ref_iterator
*prefix_ref_iterator_begin(struct ref_iterator
*iter0
,
433 /* Internal implementation of reference iteration: */
436 * Base class constructor for ref_iterators. Initialize the
437 * ref_iterator part of iter, setting its vtable pointer as specified.
438 * `ordered` should be set to 1 if the iterator will iterate over
439 * references in order by refname; otherwise it should be set to 0.
440 * This is meant to be called only by the initializers of derived
443 void base_ref_iterator_init(struct ref_iterator
*iter
,
444 struct ref_iterator_vtable
*vtable
,
448 * Base class destructor for ref_iterators. Destroy the ref_iterator
449 * part of iter and shallow-free the object. This is meant to be
450 * called only by the destructors of derived classes.
452 void base_ref_iterator_free(struct ref_iterator
*iter
);
454 /* Virtual function declarations for ref_iterators: */
457 * backend-specific implementation of ref_iterator_advance. For symrefs, the
458 * function should set REF_ISSYMREF, and it should also dereference the symref
459 * to provide the OID referent. It should respect do_for_each_ref_flags
460 * that were passed to refs_ref_iterator_begin().
462 typedef int ref_iterator_advance_fn(struct ref_iterator
*ref_iterator
);
465 * Peels the current ref, returning 0 for success or -1 for failure.
467 typedef int ref_iterator_peel_fn(struct ref_iterator
*ref_iterator
,
468 struct object_id
*peeled
);
471 * Implementations of this function should free any resources specific
472 * to the derived class, then call base_ref_iterator_free() to clean
473 * up and free the ref_iterator object.
475 typedef int ref_iterator_abort_fn(struct ref_iterator
*ref_iterator
);
477 struct ref_iterator_vtable
{
478 ref_iterator_advance_fn
*advance
;
479 ref_iterator_peel_fn
*peel
;
480 ref_iterator_abort_fn
*abort
;
484 * current_ref_iter is a performance hack: when iterating over
485 * references using the for_each_ref*() functions, current_ref_iter is
486 * set to the reference iterator before calling the callback function.
487 * If the callback function calls peel_ref(), then peel_ref() first
488 * checks whether the reference to be peeled is the one referred to by
489 * the iterator (it usually is) and if so, asks the iterator for the
490 * peeled version of the reference if it is available. This avoids a
491 * refname lookup in a common case. current_ref_iter is set to NULL
492 * when the iteration is over.
494 extern struct ref_iterator
*current_ref_iter
;
497 * The common backend for the for_each_*ref* functions. Call fn for
498 * each reference in iter. If the iterator itself ever returns
499 * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop
500 * the iteration and return that value. Otherwise, return 0. In any
501 * case, free the iterator when done. This function is basically an
502 * adapter between the callback style of reference iteration and the
505 int do_for_each_repo_ref_iterator(struct repository
*r
,
506 struct ref_iterator
*iter
,
507 each_repo_ref_fn fn
, void *cb_data
);
513 /* ref_store_init flags */
514 #define REF_STORE_READ (1 << 0)
515 #define REF_STORE_WRITE (1 << 1) /* can perform update operations */
516 #define REF_STORE_ODB (1 << 2) /* has access to object database */
517 #define REF_STORE_MAIN (1 << 3)
518 #define REF_STORE_ALL_CAPS (REF_STORE_READ | \
524 * Initialize the ref_store for the specified gitdir. These functions
525 * should call base_ref_store_init() to initialize the shared part of
526 * the ref_store and to record the ref_store for later lookup.
528 typedef struct ref_store
*ref_store_init_fn(struct repository
*repo
,
532 typedef int ref_init_db_fn(struct ref_store
*refs
, struct strbuf
*err
);
534 typedef int ref_transaction_prepare_fn(struct ref_store
*refs
,
535 struct ref_transaction
*transaction
,
538 typedef int ref_transaction_finish_fn(struct ref_store
*refs
,
539 struct ref_transaction
*transaction
,
542 typedef int ref_transaction_abort_fn(struct ref_store
*refs
,
543 struct ref_transaction
*transaction
,
546 typedef int ref_transaction_commit_fn(struct ref_store
*refs
,
547 struct ref_transaction
*transaction
,
550 typedef int pack_refs_fn(struct ref_store
*ref_store
,
551 struct pack_refs_opts
*opts
);
552 typedef int create_symref_fn(struct ref_store
*ref_store
,
553 const char *ref_target
,
554 const char *refs_heads_master
,
556 typedef int delete_refs_fn(struct ref_store
*ref_store
, const char *msg
,
557 struct string_list
*refnames
, unsigned int flags
);
558 typedef int rename_ref_fn(struct ref_store
*ref_store
,
559 const char *oldref
, const char *newref
,
561 typedef int copy_ref_fn(struct ref_store
*ref_store
,
562 const char *oldref
, const char *newref
,
566 * Iterate over the references in `ref_store` whose names start with
567 * `prefix`. `prefix` is matched as a literal string, without regard
568 * for path separators. If prefix is NULL or the empty string, iterate
569 * over all references in `ref_store`. The output is ordered by
572 typedef struct ref_iterator
*ref_iterator_begin_fn(
573 struct ref_store
*ref_store
,
574 const char *prefix
, const char **exclude_patterns
,
577 /* reflog functions */
580 * Iterate over the references in the specified ref_store that have a
581 * reflog. The refs are iterated over in arbitrary order.
583 typedef struct ref_iterator
*reflog_iterator_begin_fn(
584 struct ref_store
*ref_store
);
586 typedef int for_each_reflog_ent_fn(struct ref_store
*ref_store
,
588 each_reflog_ent_fn fn
,
590 typedef int for_each_reflog_ent_reverse_fn(struct ref_store
*ref_store
,
592 each_reflog_ent_fn fn
,
594 typedef int reflog_exists_fn(struct ref_store
*ref_store
, const char *refname
);
595 typedef int create_reflog_fn(struct ref_store
*ref_store
, const char *refname
,
597 typedef int delete_reflog_fn(struct ref_store
*ref_store
, const char *refname
);
598 typedef int reflog_expire_fn(struct ref_store
*ref_store
,
601 reflog_expiry_prepare_fn prepare_fn
,
602 reflog_expiry_should_prune_fn should_prune_fn
,
603 reflog_expiry_cleanup_fn cleanup_fn
,
604 void *policy_cb_data
);
607 * Read a reference from the specified reference store, non-recursively.
608 * Set type to describe the reference, and:
610 * - If refname is the name of a normal reference, fill in oid
611 * (leaving referent unchanged).
613 * - If refname is the name of a symbolic reference, write the full
614 * name of the reference to which it refers (e.g.
615 * "refs/heads/master") to referent and set the REF_ISSYMREF bit in
616 * type (leaving oid unchanged). The caller is responsible for
617 * validating that referent is a valid reference name.
619 * WARNING: refname might be used as part of a filename, so it is
620 * important from a security standpoint that it be safe in the sense
621 * of refname_is_safe(). Moreover, for symrefs this function sets
622 * referent to whatever the repository says, which might not be a
623 * properly-formatted or even safe reference name. NEITHER INPUT NOR
624 * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION.
626 * Return 0 on success, or -1 on failure. If the ref exists but is neither a
627 * symbolic ref nor an object ID, it is broken. In this case set REF_ISBROKEN in
628 * type, and return -1 (failure_errno should not be ENOENT)
630 * failure_errno provides errno codes that are interpreted beyond error
631 * reporting. The following error codes have special meaning:
632 * * ENOENT: the ref doesn't exist
633 * * EISDIR: ref name is a directory
634 * * ENOTDIR: ref prefix is not a directory
636 * Backend-specific flags might be set in type as well, regardless of
639 * It is OK for refname to point into referent. If so:
641 * - if the function succeeds with REF_ISSYMREF, referent will be
642 * overwritten and the memory formerly pointed to by it might be
643 * changed or even freed.
645 * - in all other cases, referent will be untouched, and therefore
646 * refname will still be valid and unchanged.
648 typedef int read_raw_ref_fn(struct ref_store
*ref_store
, const char *refname
,
649 struct object_id
*oid
, struct strbuf
*referent
,
650 unsigned int *type
, int *failure_errno
);
653 * Read a symbolic reference from the specified reference store. This function
654 * is optional: if not implemented by a backend, then `read_raw_ref_fn` is used
655 * to read the symbolcic reference instead. It is intended to be implemented
656 * only in case the backend can optimize the reading of symbolic references.
658 * Return 0 on success, or -1 on failure. `referent` will be set to the target
659 * of the symbolic reference on success. This function explicitly does not
660 * distinguish between error cases and the reference not being a symbolic
661 * reference to allow backends to optimize this operation in case symbolic and
662 * non-symbolic references are treated differently.
664 typedef int read_symbolic_ref_fn(struct ref_store
*ref_store
, const char *refname
,
665 struct strbuf
*referent
);
667 struct ref_storage_be
{
668 struct ref_storage_be
*next
;
670 ref_store_init_fn
*init
;
671 ref_init_db_fn
*init_db
;
673 ref_transaction_prepare_fn
*transaction_prepare
;
674 ref_transaction_finish_fn
*transaction_finish
;
675 ref_transaction_abort_fn
*transaction_abort
;
676 ref_transaction_commit_fn
*initial_transaction_commit
;
678 pack_refs_fn
*pack_refs
;
679 create_symref_fn
*create_symref
;
680 delete_refs_fn
*delete_refs
;
681 rename_ref_fn
*rename_ref
;
682 copy_ref_fn
*copy_ref
;
684 ref_iterator_begin_fn
*iterator_begin
;
685 read_raw_ref_fn
*read_raw_ref
;
686 read_symbolic_ref_fn
*read_symbolic_ref
;
688 reflog_iterator_begin_fn
*reflog_iterator_begin
;
689 for_each_reflog_ent_fn
*for_each_reflog_ent
;
690 for_each_reflog_ent_reverse_fn
*for_each_reflog_ent_reverse
;
691 reflog_exists_fn
*reflog_exists
;
692 create_reflog_fn
*create_reflog
;
693 delete_reflog_fn
*delete_reflog
;
694 reflog_expire_fn
*reflog_expire
;
697 extern struct ref_storage_be refs_be_files
;
698 extern struct ref_storage_be refs_be_packed
;
701 * A representation of the reference store for the main repository or
702 * a submodule. The ref_store instances for submodules are kept in a
703 * hash map; see get_submodule_ref_store() for more info.
706 /* The backend describing this ref_store's storage scheme: */
707 const struct ref_storage_be
*be
;
709 struct repository
*repo
;
712 * The gitdir that this ref_store applies to. Note that this is not
713 * necessarily repo->gitdir if the repo has multiple worktrees.
719 * Parse contents of a loose ref file. *failure_errno maybe be set to EINVAL for
722 int parse_loose_ref_contents(const char *buf
, struct object_id
*oid
,
723 struct strbuf
*referent
, unsigned int *type
,
727 * Fill in the generic part of refs and add it to our collection of
730 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
731 const char *path
, const struct ref_storage_be
*be
);
734 * Support GIT_TRACE_REFS by optionally wrapping the given ref_store instance.
736 struct ref_store
*maybe_debug_wrap_ref_store(const char *gitdir
, struct ref_store
*store
);
738 #endif /* REFS_REFS_INTERNAL_H */