Merge https://github.com/prati0100/git-gui
[git] / refs / refs-internal.h
1 #ifndef REFS_REFS_INTERNAL_H
2 #define REFS_REFS_INTERNAL_H
3
4 #include "cache.h"
5 #include "refs.h"
6 #include "iterator.h"
7
8 struct ref_transaction;
9
10 /*
11  * Data structures and functions for the internal use of the refs
12  * module. Code outside of the refs module should use only the public
13  * functions defined in "refs.h", and should *not* include this file.
14  */
15
16 /*
17  * The following flags can appear in `ref_update::flags`. Their
18  * numerical values must not conflict with those of REF_NO_DEREF and
19  * REF_FORCE_CREATE_REFLOG, which are also stored in
20  * `ref_update::flags`.
21  */
22
23 /*
24  * The reference should be updated to new_oid.
25  */
26 #define REF_HAVE_NEW (1 << 2)
27
28 /*
29  * The current reference's value should be checked to make sure that
30  * it agrees with old_oid.
31  */
32 #define REF_HAVE_OLD (1 << 3)
33
34 /*
35  * Used as a flag in ref_update::flags when we want to log a ref
36  * update but not actually perform it.  This is used when a symbolic
37  * ref update is split up.
38  */
39 #define REF_LOG_ONLY (1 << 7)
40
41 /*
42  * Return the length of time to retry acquiring a loose reference lock
43  * before giving up, in milliseconds:
44  */
45 long get_files_ref_lock_timeout_ms(void);
46
47 /*
48  * Return true iff refname is minimally safe. "Safe" here means that
49  * deleting a loose reference by this name will not do any damage, for
50  * example by causing a file that is not a reference to be deleted.
51  * This function does not check that the reference name is legal; for
52  * that, use check_refname_format().
53  *
54  * A refname that starts with "refs/" is considered safe iff it
55  * doesn't contain any "." or ".." components or consecutive '/'
56  * characters, end with '/', or (on Windows) contain any '\'
57  * characters. Names that do not start with "refs/" are considered
58  * safe iff they consist entirely of upper case characters and '_'
59  * (like "HEAD" and "MERGE_HEAD" but not "config" or "FOO/BAR").
60  */
61 int refname_is_safe(const char *refname);
62
63 /*
64  * Helper function: return true if refname, which has the specified
65  * oid and flags, can be resolved to an object in the database. If the
66  * referred-to object does not exist, emit a warning and return false.
67  */
68 int ref_resolves_to_object(const char *refname,
69                            const struct object_id *oid,
70                            unsigned int flags);
71
72 enum peel_status {
73         /* object was peeled successfully: */
74         PEEL_PEELED = 0,
75
76         /*
77          * object cannot be peeled because the named object (or an
78          * object referred to by a tag in the peel chain), does not
79          * exist.
80          */
81         PEEL_INVALID = -1,
82
83         /* object cannot be peeled because it is not a tag: */
84         PEEL_NON_TAG = -2,
85
86         /* ref_entry contains no peeled value because it is a symref: */
87         PEEL_IS_SYMREF = -3,
88
89         /*
90          * ref_entry cannot be peeled because it is broken (i.e., the
91          * symbolic reference cannot even be resolved to an object
92          * name):
93          */
94         PEEL_BROKEN = -4
95 };
96
97 /*
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.
103  */
104 enum peel_status peel_object(const struct object_id *name, struct object_id *oid);
105
106 /**
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
111  * before update.
112  */
113 struct ref_update {
114         /*
115          * If (flags & REF_HAVE_NEW), set the reference to this value
116          * (or delete it, if `new_oid` is `null_oid`).
117          */
118         struct object_id new_oid;
119
120         /*
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`).
124          */
125         struct object_id old_oid;
126
127         /*
128          * One or more of REF_NO_DEREF, REF_FORCE_CREATE_REFLOG,
129          * REF_HAVE_NEW, REF_HAVE_OLD, or backend-specific flags.
130          */
131         unsigned int flags;
132
133         void *backend_data;
134         unsigned int type;
135         char *msg;
136
137         /*
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.
146          */
147         struct ref_update *parent_update;
148
149         const char refname[FLEX_ARRAY];
150 };
151
152 int refs_read_raw_ref(struct ref_store *ref_store,
153                       const char *refname, struct object_id *oid,
154                       struct strbuf *referent, unsigned int *type);
155
156 /*
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.
160  */
161 int ref_update_reject_duplicates(struct string_list *refnames,
162                                  struct strbuf *err);
163
164 /*
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.
170  */
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,
176                 const char *msg);
177
178 /*
179  * Transaction states.
180  *
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).
185  *
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
190  *         aborted.
191  *
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.
196  */
197 enum ref_transaction_state {
198         REF_TRANSACTION_OPEN     = 0,
199         REF_TRANSACTION_PREPARED = 1,
200         REF_TRANSACTION_CLOSED   = 2
201 };
202
203 /*
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.
207  */
208 struct ref_transaction {
209         struct ref_store *ref_store;
210         struct ref_update **updates;
211         size_t alloc;
212         size_t nr;
213         enum ref_transaction_state state;
214         void *backend_data;
215 };
216
217 /*
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.
223  *
224  * extras and skip must be sorted lists of reference names. Either one
225  * can be NULL, signifying the empty list.
226  */
227 const char *find_descendant_ref(const char *dirname,
228                                 const struct string_list *extras,
229                                 const struct string_list *skip);
230
231 /*
232  * Check whether an attempt to rename old_refname to new_refname would
233  * cause a D/F conflict with any existing reference (other than
234  * possibly old_refname). If there would be a conflict, emit an error
235  * message and return false; otherwise, return true.
236  *
237  * Note that this function is not safe against all races with other
238  * processes (though rename_ref() catches some races that might get by
239  * this check).
240  */
241 int refs_rename_ref_available(struct ref_store *refs,
242                               const char *old_refname,
243                               const char *new_refname);
244
245 /* We allow "recursive" symbolic refs. Only within reason, though */
246 #define SYMREF_MAXDEPTH 5
247
248 /* Include broken references in a do_for_each_ref*() iteration: */
249 #define DO_FOR_EACH_INCLUDE_BROKEN 0x01
250
251 /*
252  * Reference iterators
253  *
254  * A reference iterator encapsulates the state of an in-progress
255  * iteration over references. Create an instance of `struct
256  * ref_iterator` via one of the functions in this module.
257  *
258  * A freshly-created ref_iterator doesn't yet point at a reference. To
259  * advance the iterator, call ref_iterator_advance(). If successful,
260  * this sets the iterator's refname, oid, and flags fields to describe
261  * the next reference and returns ITER_OK. The data pointed at by
262  * refname and oid belong to the iterator; if you want to retain them
263  * after calling ref_iterator_advance() again or calling
264  * ref_iterator_abort(), you must make a copy. When the iteration has
265  * been exhausted, ref_iterator_advance() releases any resources
266  * associated with the iteration, frees the ref_iterator object, and
267  * returns ITER_DONE. If you want to abort the iteration early, call
268  * ref_iterator_abort(), which also frees the ref_iterator object and
269  * any associated resources. If there was an internal error advancing
270  * to the next entry, ref_iterator_advance() aborts the iteration,
271  * frees the ref_iterator, and returns ITER_ERROR.
272  *
273  * The reference currently being looked at can be peeled by calling
274  * ref_iterator_peel(). This function is often faster than peel_ref(),
275  * so it should be preferred when iterating over references.
276  *
277  * Putting it all together, a typical iteration looks like this:
278  *
279  *     int ok;
280  *     struct ref_iterator *iter = ...;
281  *
282  *     while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
283  *             if (want_to_stop_iteration()) {
284  *                     ok = ref_iterator_abort(iter);
285  *                     break;
286  *             }
287  *
288  *             // Access information about the current reference:
289  *             if (!(iter->flags & REF_ISSYMREF))
290  *                     printf("%s is %s\n", iter->refname, oid_to_hex(iter->oid));
291  *
292  *             // If you need to peel the reference:
293  *             ref_iterator_peel(iter, &oid);
294  *     }
295  *
296  *     if (ok != ITER_DONE)
297  *             handle_error();
298  */
299 struct ref_iterator {
300         struct ref_iterator_vtable *vtable;
301
302         /*
303          * Does this `ref_iterator` iterate over references in order
304          * by refname?
305          */
306         unsigned int ordered : 1;
307
308         const char *refname;
309         const struct object_id *oid;
310         unsigned int flags;
311 };
312
313 /*
314  * Advance the iterator to the first or next item and return ITER_OK.
315  * If the iteration is exhausted, free the resources associated with
316  * the ref_iterator and return ITER_DONE. On errors, free the iterator
317  * resources and return ITER_ERROR. It is a bug to use ref_iterator or
318  * call this function again after it has returned ITER_DONE or
319  * ITER_ERROR.
320  */
321 int ref_iterator_advance(struct ref_iterator *ref_iterator);
322
323 /*
324  * If possible, peel the reference currently being viewed by the
325  * iterator. Return 0 on success.
326  */
327 int ref_iterator_peel(struct ref_iterator *ref_iterator,
328                       struct object_id *peeled);
329
330 /*
331  * End the iteration before it has been exhausted, freeing the
332  * reference iterator and any associated resources and returning
333  * ITER_DONE. If the abort itself failed, return ITER_ERROR.
334  */
335 int ref_iterator_abort(struct ref_iterator *ref_iterator);
336
337 /*
338  * An iterator over nothing (its first ref_iterator_advance() call
339  * returns ITER_DONE).
340  */
341 struct ref_iterator *empty_ref_iterator_begin(void);
342
343 /*
344  * Return true iff ref_iterator is an empty_ref_iterator.
345  */
346 int is_empty_ref_iterator(struct ref_iterator *ref_iterator);
347
348 /*
349  * Return an iterator that goes over each reference in `refs` for
350  * which the refname begins with prefix. If trim is non-zero, then
351  * trim that many characters off the beginning of each refname.
352  * The output is ordered by refname. The following flags are supported:
353  *
354  * DO_FOR_EACH_INCLUDE_BROKEN: include broken references in
355  *         the iteration.
356  *
357  * DO_FOR_EACH_PER_WORKTREE_ONLY: only produce REF_TYPE_PER_WORKTREE refs.
358  */
359 struct ref_iterator *refs_ref_iterator_begin(
360                 struct ref_store *refs,
361                 const char *prefix, int trim, int flags);
362
363 /*
364  * A callback function used to instruct merge_ref_iterator how to
365  * interleave the entries from iter0 and iter1. The function should
366  * return one of the constants defined in enum iterator_selection. It
367  * must not advance either of the iterators itself.
368  *
369  * The function must be prepared to handle the case that iter0 and/or
370  * iter1 is NULL, which indicates that the corresponding sub-iterator
371  * has been exhausted. Its return value must be consistent with the
372  * current states of the iterators; e.g., it must not return
373  * ITER_SKIP_1 if iter1 has already been exhausted.
374  */
375 typedef enum iterator_selection ref_iterator_select_fn(
376                 struct ref_iterator *iter0, struct ref_iterator *iter1,
377                 void *cb_data);
378
379 /*
380  * Iterate over the entries from iter0 and iter1, with the values
381  * interleaved as directed by the select function. The iterator takes
382  * ownership of iter0 and iter1 and frees them when the iteration is
383  * over. A derived class should set `ordered` to 1 or 0 based on
384  * whether it generates its output in order by reference name.
385  */
386 struct ref_iterator *merge_ref_iterator_begin(
387                 int ordered,
388                 struct ref_iterator *iter0, struct ref_iterator *iter1,
389                 ref_iterator_select_fn *select, void *cb_data);
390
391 /*
392  * An iterator consisting of the union of the entries from front and
393  * back. If there are entries common to the two sub-iterators, use the
394  * one from front. Each iterator must iterate over its entries in
395  * strcmp() order by refname for this to work.
396  *
397  * The new iterator takes ownership of its arguments and frees them
398  * when the iteration is over. As a convenience to callers, if front
399  * or back is an empty_ref_iterator, then abort that one immediately
400  * and return the other iterator directly, without wrapping it.
401  */
402 struct ref_iterator *overlay_ref_iterator_begin(
403                 struct ref_iterator *front, struct ref_iterator *back);
404
405 /*
406  * Wrap iter0, only letting through the references whose names start
407  * with prefix. If trim is set, set iter->refname to the name of the
408  * reference with that many characters trimmed off the front;
409  * otherwise set it to the full refname. The new iterator takes over
410  * ownership of iter0 and frees it when iteration is over. It makes
411  * its own copy of prefix.
412  *
413  * As an convenience to callers, if prefix is the empty string and
414  * trim is zero, this function returns iter0 directly, without
415  * wrapping it.
416  *
417  * The resulting ref_iterator is ordered if iter0 is.
418  */
419 struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0,
420                                                const char *prefix,
421                                                int trim);
422
423 /* Internal implementation of reference iteration: */
424
425 /*
426  * Base class constructor for ref_iterators. Initialize the
427  * ref_iterator part of iter, setting its vtable pointer as specified.
428  * `ordered` should be set to 1 if the iterator will iterate over
429  * references in order by refname; otherwise it should be set to 0.
430  * This is meant to be called only by the initializers of derived
431  * classes.
432  */
433 void base_ref_iterator_init(struct ref_iterator *iter,
434                             struct ref_iterator_vtable *vtable,
435                             int ordered);
436
437 /*
438  * Base class destructor for ref_iterators. Destroy the ref_iterator
439  * part of iter and shallow-free the object. This is meant to be
440  * called only by the destructors of derived classes.
441  */
442 void base_ref_iterator_free(struct ref_iterator *iter);
443
444 /* Virtual function declarations for ref_iterators: */
445
446 /*
447  * backend-specific implementation of ref_iterator_advance. For symrefs, the
448  * function should set REF_ISSYMREF, and it should also dereference the symref
449  * to provide the OID referent. If DO_FOR_EACH_INCLUDE_BROKEN is set, symrefs
450  * with non-existent referents and refs pointing to non-existent object names
451  * should also be returned. If DO_FOR_EACH_PER_WORKTREE_ONLY, only
452  * REF_TYPE_PER_WORKTREE refs should be returned.
453  */
454 typedef int ref_iterator_advance_fn(struct ref_iterator *ref_iterator);
455
456 typedef int ref_iterator_peel_fn(struct ref_iterator *ref_iterator,
457                                  struct object_id *peeled);
458
459 /*
460  * Implementations of this function should free any resources specific
461  * to the derived class, then call base_ref_iterator_free() to clean
462  * up and free the ref_iterator object.
463  */
464 typedef int ref_iterator_abort_fn(struct ref_iterator *ref_iterator);
465
466 struct ref_iterator_vtable {
467         ref_iterator_advance_fn *advance;
468         ref_iterator_peel_fn *peel;
469         ref_iterator_abort_fn *abort;
470 };
471
472 /*
473  * current_ref_iter is a performance hack: when iterating over
474  * references using the for_each_ref*() functions, current_ref_iter is
475  * set to the reference iterator before calling the callback function.
476  * If the callback function calls peel_ref(), then peel_ref() first
477  * checks whether the reference to be peeled is the one referred to by
478  * the iterator (it usually is) and if so, asks the iterator for the
479  * peeled version of the reference if it is available. This avoids a
480  * refname lookup in a common case. current_ref_iter is set to NULL
481  * when the iteration is over.
482  */
483 extern struct ref_iterator *current_ref_iter;
484
485 /*
486  * The common backend for the for_each_*ref* functions. Call fn for
487  * each reference in iter. If the iterator itself ever returns
488  * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop
489  * the iteration and return that value. Otherwise, return 0. In any
490  * case, free the iterator when done. This function is basically an
491  * adapter between the callback style of reference iteration and the
492  * iterator style.
493  */
494 int do_for_each_repo_ref_iterator(struct repository *r,
495                                   struct ref_iterator *iter,
496                                   each_repo_ref_fn fn, void *cb_data);
497
498 /*
499  * Only include per-worktree refs in a do_for_each_ref*() iteration.
500  * Normally this will be used with a files ref_store, since that's
501  * where all reference backends will presumably store their
502  * per-worktree refs.
503  */
504 #define DO_FOR_EACH_PER_WORKTREE_ONLY 0x02
505
506 struct ref_store;
507
508 /* refs backends */
509
510 /* ref_store_init flags */
511 #define REF_STORE_READ          (1 << 0)
512 #define REF_STORE_WRITE         (1 << 1) /* can perform update operations */
513 #define REF_STORE_ODB           (1 << 2) /* has access to object database */
514 #define REF_STORE_MAIN          (1 << 3)
515 #define REF_STORE_ALL_CAPS      (REF_STORE_READ | \
516                                  REF_STORE_WRITE | \
517                                  REF_STORE_ODB | \
518                                  REF_STORE_MAIN)
519
520 /*
521  * Initialize the ref_store for the specified gitdir. These functions
522  * should call base_ref_store_init() to initialize the shared part of
523  * the ref_store and to record the ref_store for later lookup.
524  */
525 typedef struct ref_store *ref_store_init_fn(const char *gitdir,
526                                             unsigned int flags);
527
528 typedef int ref_init_db_fn(struct ref_store *refs, struct strbuf *err);
529
530 typedef int ref_transaction_prepare_fn(struct ref_store *refs,
531                                        struct ref_transaction *transaction,
532                                        struct strbuf *err);
533
534 typedef int ref_transaction_finish_fn(struct ref_store *refs,
535                                       struct ref_transaction *transaction,
536                                       struct strbuf *err);
537
538 typedef int ref_transaction_abort_fn(struct ref_store *refs,
539                                      struct ref_transaction *transaction,
540                                      struct strbuf *err);
541
542 typedef int ref_transaction_commit_fn(struct ref_store *refs,
543                                       struct ref_transaction *transaction,
544                                       struct strbuf *err);
545
546 typedef int pack_refs_fn(struct ref_store *ref_store, unsigned int flags);
547 typedef int create_symref_fn(struct ref_store *ref_store,
548                              const char *ref_target,
549                              const char *refs_heads_master,
550                              const char *logmsg);
551 typedef int delete_refs_fn(struct ref_store *ref_store, const char *msg,
552                            struct string_list *refnames, unsigned int flags);
553 typedef int rename_ref_fn(struct ref_store *ref_store,
554                           const char *oldref, const char *newref,
555                           const char *logmsg);
556 typedef int copy_ref_fn(struct ref_store *ref_store,
557                           const char *oldref, const char *newref,
558                           const char *logmsg);
559
560 /*
561  * Iterate over the references in `ref_store` whose names start with
562  * `prefix`. `prefix` is matched as a literal string, without regard
563  * for path separators. If prefix is NULL or the empty string, iterate
564  * over all references in `ref_store`. The output is ordered by
565  * refname.
566  */
567 typedef struct ref_iterator *ref_iterator_begin_fn(
568                 struct ref_store *ref_store,
569                 const char *prefix, unsigned int flags);
570
571 /* reflog functions */
572
573 /*
574  * Iterate over the references in the specified ref_store that have a
575  * reflog. The refs are iterated over in arbitrary order.
576  */
577 typedef struct ref_iterator *reflog_iterator_begin_fn(
578                 struct ref_store *ref_store);
579
580 typedef int for_each_reflog_ent_fn(struct ref_store *ref_store,
581                                    const char *refname,
582                                    each_reflog_ent_fn fn,
583                                    void *cb_data);
584 typedef int for_each_reflog_ent_reverse_fn(struct ref_store *ref_store,
585                                            const char *refname,
586                                            each_reflog_ent_fn fn,
587                                            void *cb_data);
588 typedef int reflog_exists_fn(struct ref_store *ref_store, const char *refname);
589 typedef int create_reflog_fn(struct ref_store *ref_store, const char *refname,
590                              int force_create, struct strbuf *err);
591 typedef int delete_reflog_fn(struct ref_store *ref_store, const char *refname);
592 typedef int reflog_expire_fn(struct ref_store *ref_store,
593                              const char *refname, const struct object_id *oid,
594                              unsigned int flags,
595                              reflog_expiry_prepare_fn prepare_fn,
596                              reflog_expiry_should_prune_fn should_prune_fn,
597                              reflog_expiry_cleanup_fn cleanup_fn,
598                              void *policy_cb_data);
599
600 /*
601  * Read a reference from the specified reference store, non-recursively.
602  * Set type to describe the reference, and:
603  *
604  * - If refname is the name of a normal reference, fill in oid
605  *   (leaving referent unchanged).
606  *
607  * - If refname is the name of a symbolic reference, write the full
608  *   name of the reference to which it refers (e.g.
609  *   "refs/heads/master") to referent and set the REF_ISSYMREF bit in
610  *   type (leaving oid unchanged). The caller is responsible for
611  *   validating that referent is a valid reference name.
612  *
613  * WARNING: refname might be used as part of a filename, so it is
614  * important from a security standpoint that it be safe in the sense
615  * of refname_is_safe(). Moreover, for symrefs this function sets
616  * referent to whatever the repository says, which might not be a
617  * properly-formatted or even safe reference name. NEITHER INPUT NOR
618  * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION.
619  *
620  * Return 0 on success. If the ref doesn't exist, set errno to ENOENT
621  * and return -1. If the ref exists but is neither a symbolic ref nor
622  * an object ID, it is broken; set REF_ISBROKEN in type, set errno to
623  * EINVAL, and return -1. If there is another error reading the ref,
624  * set errno appropriately and return -1.
625  *
626  * Backend-specific flags might be set in type as well, regardless of
627  * outcome.
628  *
629  * It is OK for refname to point into referent. If so:
630  *
631  * - if the function succeeds with REF_ISSYMREF, referent will be
632  *   overwritten and the memory formerly pointed to by it might be
633  *   changed or even freed.
634  *
635  * - in all other cases, referent will be untouched, and therefore
636  *   refname will still be valid and unchanged.
637  */
638 typedef int read_raw_ref_fn(struct ref_store *ref_store,
639                             const char *refname, struct object_id *oid,
640                             struct strbuf *referent, unsigned int *type);
641
642 struct ref_storage_be {
643         struct ref_storage_be *next;
644         const char *name;
645         ref_store_init_fn *init;
646         ref_init_db_fn *init_db;
647
648         ref_transaction_prepare_fn *transaction_prepare;
649         ref_transaction_finish_fn *transaction_finish;
650         ref_transaction_abort_fn *transaction_abort;
651         ref_transaction_commit_fn *initial_transaction_commit;
652
653         pack_refs_fn *pack_refs;
654         create_symref_fn *create_symref;
655         delete_refs_fn *delete_refs;
656         rename_ref_fn *rename_ref;
657         copy_ref_fn *copy_ref;
658
659         ref_iterator_begin_fn *iterator_begin;
660         read_raw_ref_fn *read_raw_ref;
661
662         reflog_iterator_begin_fn *reflog_iterator_begin;
663         for_each_reflog_ent_fn *for_each_reflog_ent;
664         for_each_reflog_ent_reverse_fn *for_each_reflog_ent_reverse;
665         reflog_exists_fn *reflog_exists;
666         create_reflog_fn *create_reflog;
667         delete_reflog_fn *delete_reflog;
668         reflog_expire_fn *reflog_expire;
669 };
670
671 extern struct ref_storage_be refs_be_files;
672 extern struct ref_storage_be refs_be_packed;
673
674 /*
675  * A representation of the reference store for the main repository or
676  * a submodule. The ref_store instances for submodules are kept in a
677  * hash map; see get_submodule_ref_store() for more info.
678  */
679 struct ref_store {
680         /* The backend describing this ref_store's storage scheme: */
681         const struct ref_storage_be *be;
682
683         /* The gitdir that this ref_store applies to: */
684         char *gitdir;
685 };
686
687 /*
688  * Parse contents of a loose ref file.
689  */
690 int parse_loose_ref_contents(const char *buf, struct object_id *oid,
691                              struct strbuf *referent, unsigned int *type);
692
693 /*
694  * Fill in the generic part of refs and add it to our collection of
695  * reference stores.
696  */
697 void base_ref_store_init(struct ref_store *refs,
698                          const struct ref_storage_be *be);
699
700 /*
701  * Support GIT_TRACE_REFS by optionally wrapping the given ref_store instance.
702  */
703 struct ref_store *maybe_debug_wrap_ref_store(const char *gitdir, struct ref_store *store);
704
705 #endif /* REFS_REFS_INTERNAL_H */