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 struct repository *repo, 70 const struct object_id *oid, 71 unsigned int flags); 72 73 enum peel_status { 74 /* object was peeled successfully: */ 75 PEEL_PEELED = 0, 76 77 /* 78 * object cannot be peeled because the named object (or an 79 * object referred to by a tag in the peel chain), does not 80 * exist. 81 */ 82 PEEL_INVALID = -1, 83 84 /* object cannot be peeled because it is not a tag: */ 85 PEEL_NON_TAG = -2, 86 87 /* ref_entry contains no peeled value because it is a symref: */ 88 PEEL_IS_SYMREF = -3, 89 90 /* 91 * ref_entry cannot be peeled because it is broken (i.e., the 92 * symbolic reference cannot even be resolved to an object 93 * name): 94 */ 95 PEEL_BROKEN = -4 96 }; 97 98 /* 99 * Peel the named object; i.e., if the object is a tag, resolve the 100 * tag recursively until a non-tag is found. If successful, store the 101 * result to oid and return PEEL_PEELED. If the object is not a tag 102 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively, 103 * and leave oid unchanged. 104 */ 105 enum peel_status peel_object(const struct object_id *name, struct object_id *oid); 106 107 /** 108 * Information needed for a single ref update. Set new_oid to the new 109 * value or to null_oid to delete the ref. To check the old value 110 * while the ref is locked, set (flags & REF_HAVE_OLD) and set old_oid 111 * to the old value, or to null_oid to ensure the ref does not exist 112 * before update. 113 */ 114 struct ref_update { 115 /* 116 * If (flags & REF_HAVE_NEW), set the reference to this value 117 * (or delete it, if `new_oid` is `null_oid`). 118 */ 119 struct object_id new_oid; 120 121 /* 122 * If (flags & REF_HAVE_OLD), check that the reference 123 * previously had this value (or didn't previously exist, if 124 * `old_oid` is `null_oid`). 125 */ 126 struct object_id old_oid; 127 128 /* 129 * One or more of REF_NO_DEREF, REF_FORCE_CREATE_REFLOG, 130 * REF_HAVE_NEW, REF_HAVE_OLD, or backend-specific flags. 131 */ 132 unsigned int flags; 133 134 void *backend_data; 135 unsigned int type; 136 char *msg; 137 138 /* 139 * If this ref_update was split off of a symref update via 140 * split_symref_update(), then this member points at that 141 * update. This is used for two purposes: 142 * 1. When reporting errors, we report the refname under which 143 * the update was originally requested. 144 * 2. When we read the old value of this reference, we 145 * propagate it back to its parent update for recording in 146 * the latter's reflog. 147 */ 148 struct ref_update *parent_update; 149 150 const char refname[FLEX_ARRAY]; 151 }; 152 153 int refs_read_raw_ref(struct ref_store *ref_store, 154 const char *refname, struct object_id *oid, 155 struct strbuf *referent, unsigned int *type); 156 157 /* 158 * Write an error to `err` and return a nonzero value iff the same 159 * refname appears multiple times in `refnames`. `refnames` must be 160 * sorted on entry to this function. 161 */ 162 int ref_update_reject_duplicates(struct string_list *refnames, 163 struct strbuf *err); 164 165 /* 166 * Add a ref_update with the specified properties to transaction, and 167 * return a pointer to the new object. This function does not verify 168 * that refname is well-formed. new_oid and old_oid are only 169 * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits, 170 * respectively, are set in flags. 171 */ 172 struct ref_update *ref_transaction_add_update( 173 struct ref_transaction *transaction, 174 const char *refname, unsigned int flags, 175 const struct object_id *new_oid, 176 const struct object_id *old_oid, 177 const char *msg); 178 179 /* 180 * Transaction states. 181 * 182 * OPEN: The transaction is initialized and new updates can still be 183 * added to it. An OPEN transaction can be prepared, 184 * committed, freed, or aborted (freeing and aborting an open 185 * transaction are equivalent). 186 * 187 * PREPARED: ref_transaction_prepare(), which locks all of the 188 * references involved in the update and checks that the 189 * update has no errors, has been called successfully for the 190 * transaction. A PREPARED transaction can be committed or 191 * aborted. 192 * 193 * CLOSED: The transaction is no longer active. A transaction becomes 194 * CLOSED if there is a failure while building the transaction 195 * or if a transaction is committed or aborted. A CLOSED 196 * transaction can only be freed. 197 */ 198 enum ref_transaction_state { 199 REF_TRANSACTION_OPEN = 0, 200 REF_TRANSACTION_PREPARED = 1, 201 REF_TRANSACTION_CLOSED = 2 202 }; 203 204 /* 205 * Data structure for holding a reference transaction, which can 206 * consist of checks and updates to multiple references, carried out 207 * as atomically as possible. This structure is opaque to callers. 208 */ 209 struct ref_transaction { 210 struct ref_store *ref_store; 211 struct ref_update **updates; 212 size_t alloc; 213 size_t nr; 214 enum ref_transaction_state state; 215 void *backend_data; 216 }; 217 218 /* 219 * Check for entries in extras that are within the specified 220 * directory, where dirname is a reference directory name including 221 * the trailing slash (e.g., "refs/heads/foo/"). Ignore any 222 * conflicting references that are found in skip. If there is a 223 * conflicting reference, return its name. 224 * 225 * extras and skip must be sorted lists of reference names. Either one 226 * can be NULL, signifying the empty list. 227 */ 228 const char *find_descendant_ref(const char *dirname, 229 const struct string_list *extras, 230 const struct string_list *skip); 231 232 /* 233 * Check whether an attempt to rename old_refname to new_refname would 234 * cause a D/F conflict with any existing reference (other than 235 * possibly old_refname). If there would be a conflict, emit an error 236 * message and return false; otherwise, return true. 237 * 238 * Note that this function is not safe against all races with other 239 * processes (though rename_ref() catches some races that might get by 240 * this check). 241 */ 242 int refs_rename_ref_available(struct ref_store *refs, 243 const char *old_refname, 244 const char *new_refname); 245 246 /* We allow "recursive" symbolic refs. Only within reason, though */ 247 #define SYMREF_MAXDEPTH 5 248 249 /* 250 * These flags are passed to refs_ref_iterator_begin() (and do_for_each_ref(), 251 * which feeds it). 252 */ 253 enum do_for_each_ref_flags { 254 /* 255 * Include broken references in a do_for_each_ref*() iteration, which 256 * would normally be omitted. This includes both refs that point to 257 * missing objects (a true repository corruption), ones with illegal 258 * names (which we prefer not to expose to callers), as well as 259 * dangling symbolic refs (i.e., those that point to a non-existent 260 * ref; this is not a corruption, but as they have no valid oid, we 261 * omit them from normal iteration results). 262 */ 263 DO_FOR_EACH_INCLUDE_BROKEN = (1 << 0), 264 265 /* 266 * Only include per-worktree refs in a do_for_each_ref*() iteration. 267 * Normally this will be used with a files ref_store, since that's 268 * where all reference backends will presumably store their 269 * per-worktree refs. 270 */ 271 DO_FOR_EACH_PER_WORKTREE_ONLY = (1 << 1), 272 273 /* 274 * Omit dangling symrefs from output; this only has an effect with 275 * INCLUDE_BROKEN, since they are otherwise not included at all. 276 */ 277 DO_FOR_EACH_OMIT_DANGLING_SYMREFS = (1 << 2), 278 }; 279 280 /* 281 * Reference iterators 282 * 283 * A reference iterator encapsulates the state of an in-progress 284 * iteration over references. Create an instance of `struct 285 * ref_iterator` via one of the functions in this module. 286 * 287 * A freshly-created ref_iterator doesn't yet point at a reference. To 288 * advance the iterator, call ref_iterator_advance(). If successful, 289 * this sets the iterator's refname, oid, and flags fields to describe 290 * the next reference and returns ITER_OK. The data pointed at by 291 * refname and oid belong to the iterator; if you want to retain them 292 * after calling ref_iterator_advance() again or calling 293 * ref_iterator_abort(), you must make a copy. When the iteration has 294 * been exhausted, ref_iterator_advance() releases any resources 295 * associated with the iteration, frees the ref_iterator object, and 296 * returns ITER_DONE. If you want to abort the iteration early, call 297 * ref_iterator_abort(), which also frees the ref_iterator object and 298 * any associated resources. If there was an internal error advancing 299 * to the next entry, ref_iterator_advance() aborts the iteration, 300 * frees the ref_iterator, and returns ITER_ERROR. 301 * 302 * The reference currently being looked at can be peeled by calling 303 * ref_iterator_peel(). This function is often faster than peel_ref(), 304 * so it should be preferred when iterating over references. 305 * 306 * Putting it all together, a typical iteration looks like this: 307 * 308 * int ok; 309 * struct ref_iterator *iter = ...; 310 * 311 * while ((ok = ref_iterator_advance(iter)) == ITER_OK) { 312 * if (want_to_stop_iteration()) { 313 * ok = ref_iterator_abort(iter); 314 * break; 315 * } 316 * 317 * // Access information about the current reference: 318 * if (!(iter->flags & REF_ISSYMREF)) 319 * printf("%s is %s\n", iter->refname, oid_to_hex(iter->oid)); 320 * 321 * // If you need to peel the reference: 322 * ref_iterator_peel(iter, &oid); 323 * } 324 * 325 * if (ok != ITER_DONE) 326 * handle_error(); 327 */ 328 struct ref_iterator { 329 struct ref_iterator_vtable *vtable; 330 331 /* 332 * Does this `ref_iterator` iterate over references in order 333 * by refname? 334 */ 335 unsigned int ordered : 1; 336 337 const char *refname; 338 const struct object_id *oid; 339 unsigned int flags; 340 }; 341 342 /* 343 * Advance the iterator to the first or next item and return ITER_OK. 344 * If the iteration is exhausted, free the resources associated with 345 * the ref_iterator and return ITER_DONE. On errors, free the iterator 346 * resources and return ITER_ERROR. It is a bug to use ref_iterator or 347 * call this function again after it has returned ITER_DONE or 348 * ITER_ERROR. 349 */ 350 int ref_iterator_advance(struct ref_iterator *ref_iterator); 351 352 /* 353 * If possible, peel the reference currently being viewed by the 354 * iterator. Return 0 on success. 355 */ 356 int ref_iterator_peel(struct ref_iterator *ref_iterator, 357 struct object_id *peeled); 358 359 /* 360 * End the iteration before it has been exhausted, freeing the 361 * reference iterator and any associated resources and returning 362 * ITER_DONE. If the abort itself failed, return ITER_ERROR. 363 */ 364 int ref_iterator_abort(struct ref_iterator *ref_iterator); 365 366 /* 367 * An iterator over nothing (its first ref_iterator_advance() call 368 * returns ITER_DONE). 369 */ 370 struct ref_iterator *empty_ref_iterator_begin(void); 371 372 /* 373 * Return true iff ref_iterator is an empty_ref_iterator. 374 */ 375 int is_empty_ref_iterator(struct ref_iterator *ref_iterator); 376 377 /* 378 * Return an iterator that goes over each reference in `refs` for 379 * which the refname begins with prefix. If trim is non-zero, then 380 * trim that many characters off the beginning of each refname. 381 * The output is ordered by refname. 382 */ 383 struct ref_iterator *refs_ref_iterator_begin( 384 struct ref_store *refs, 385 const char *prefix, int trim, 386 enum do_for_each_ref_flags flags); 387 388 /* 389 * A callback function used to instruct merge_ref_iterator how to 390 * interleave the entries from iter0 and iter1. The function should 391 * return one of the constants defined in enum iterator_selection. It 392 * must not advance either of the iterators itself. 393 * 394 * The function must be prepared to handle the case that iter0 and/or 395 * iter1 is NULL, which indicates that the corresponding sub-iterator 396 * has been exhausted. Its return value must be consistent with the 397 * current states of the iterators; e.g., it must not return 398 * ITER_SKIP_1 if iter1 has already been exhausted. 399 */ 400 typedef enum iterator_selection ref_iterator_select_fn( 401 struct ref_iterator *iter0, struct ref_iterator *iter1, 402 void *cb_data); 403 404 /* 405 * Iterate over the entries from iter0 and iter1, with the values 406 * interleaved as directed by the select function. The iterator takes 407 * ownership of iter0 and iter1 and frees them when the iteration is 408 * over. A derived class should set `ordered` to 1 or 0 based on 409 * whether it generates its output in order by reference name. 410 */ 411 struct ref_iterator *merge_ref_iterator_begin( 412 int ordered, 413 struct ref_iterator *iter0, struct ref_iterator *iter1, 414 ref_iterator_select_fn *select, void *cb_data); 415 416 /* 417 * An iterator consisting of the union of the entries from front and 418 * back. If there are entries common to the two sub-iterators, use the 419 * one from front. Each iterator must iterate over its entries in 420 * strcmp() order by refname for this to work. 421 * 422 * The new iterator takes ownership of its arguments and frees them 423 * when the iteration is over. As a convenience to callers, if front 424 * or back is an empty_ref_iterator, then abort that one immediately 425 * and return the other iterator directly, without wrapping it. 426 */ 427 struct ref_iterator *overlay_ref_iterator_begin( 428 struct ref_iterator *front, struct ref_iterator *back); 429 430 /* 431 * Wrap iter0, only letting through the references whose names start 432 * with prefix. If trim is set, set iter->refname to the name of the 433 * reference with that many characters trimmed off the front; 434 * otherwise set it to the full refname. The new iterator takes over 435 * ownership of iter0 and frees it when iteration is over. It makes 436 * its own copy of prefix. 437 * 438 * As an convenience to callers, if prefix is the empty string and 439 * trim is zero, this function returns iter0 directly, without 440 * wrapping it. 441 * 442 * The resulting ref_iterator is ordered if iter0 is. 443 */ 444 struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, 445 const char *prefix, 446 int trim); 447 448 /* Internal implementation of reference iteration: */ 449 450 /* 451 * Base class constructor for ref_iterators. Initialize the 452 * ref_iterator part of iter, setting its vtable pointer as specified. 453 * `ordered` should be set to 1 if the iterator will iterate over 454 * references in order by refname; otherwise it should be set to 0. 455 * This is meant to be called only by the initializers of derived 456 * classes. 457 */ 458 void base_ref_iterator_init(struct ref_iterator *iter, 459 struct ref_iterator_vtable *vtable, 460 int ordered); 461 462 /* 463 * Base class destructor for ref_iterators. Destroy the ref_iterator 464 * part of iter and shallow-free the object. This is meant to be 465 * called only by the destructors of derived classes. 466 */ 467 void base_ref_iterator_free(struct ref_iterator *iter); 468 469 /* Virtual function declarations for ref_iterators: */ 470 471 /* 472 * backend-specific implementation of ref_iterator_advance. For symrefs, the 473 * function should set REF_ISSYMREF, and it should also dereference the symref 474 * to provide the OID referent. It should respect do_for_each_ref_flags 475 * that were passed to refs_ref_iterator_begin(). 476 */ 477 typedef int ref_iterator_advance_fn(struct ref_iterator *ref_iterator); 478 479 /* 480 * Peels the current ref, returning 0 for success or -1 for failure. 481 */ 482 typedef int ref_iterator_peel_fn(struct ref_iterator *ref_iterator, 483 struct object_id *peeled); 484 485 /* 486 * Implementations of this function should free any resources specific 487 * to the derived class, then call base_ref_iterator_free() to clean 488 * up and free the ref_iterator object. 489 */ 490 typedef int ref_iterator_abort_fn(struct ref_iterator *ref_iterator); 491 492 struct ref_iterator_vtable { 493 ref_iterator_advance_fn *advance; 494 ref_iterator_peel_fn *peel; 495 ref_iterator_abort_fn *abort; 496 }; 497 498 /* 499 * current_ref_iter is a performance hack: when iterating over 500 * references using the for_each_ref*() functions, current_ref_iter is 501 * set to the reference iterator before calling the callback function. 502 * If the callback function calls peel_ref(), then peel_ref() first 503 * checks whether the reference to be peeled is the one referred to by 504 * the iterator (it usually is) and if so, asks the iterator for the 505 * peeled version of the reference if it is available. This avoids a 506 * refname lookup in a common case. current_ref_iter is set to NULL 507 * when the iteration is over. 508 */ 509 extern struct ref_iterator *current_ref_iter; 510 511 /* 512 * The common backend for the for_each_*ref* functions. Call fn for 513 * each reference in iter. If the iterator itself ever returns 514 * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop 515 * the iteration and return that value. Otherwise, return 0. In any 516 * case, free the iterator when done. This function is basically an 517 * adapter between the callback style of reference iteration and the 518 * iterator style. 519 */ 520 int do_for_each_repo_ref_iterator(struct repository *r, 521 struct ref_iterator *iter, 522 each_repo_ref_fn fn, void *cb_data); 523 524 struct ref_store; 525 526 /* refs backends */ 527 528 /* ref_store_init flags */ 529 #define REF_STORE_READ (1 << 0) 530 #define REF_STORE_WRITE (1 << 1) /* can perform update operations */ 531 #define REF_STORE_ODB (1 << 2) /* has access to object database */ 532 #define REF_STORE_MAIN (1 << 3) 533 #define REF_STORE_ALL_CAPS (REF_STORE_READ | \ 534 REF_STORE_WRITE | \ 535 REF_STORE_ODB | \ 536 REF_STORE_MAIN) 537 538 /* 539 * Initialize the ref_store for the specified gitdir. These functions 540 * should call base_ref_store_init() to initialize the shared part of 541 * the ref_store and to record the ref_store for later lookup. 542 */ 543 typedef struct ref_store *ref_store_init_fn(struct repository *repo, 544 const char *gitdir, 545 unsigned int flags); 546 547 typedef int ref_init_db_fn(struct ref_store *refs, struct strbuf *err); 548 549 typedef int ref_transaction_prepare_fn(struct ref_store *refs, 550 struct ref_transaction *transaction, 551 struct strbuf *err); 552 553 typedef int ref_transaction_finish_fn(struct ref_store *refs, 554 struct ref_transaction *transaction, 555 struct strbuf *err); 556 557 typedef int ref_transaction_abort_fn(struct ref_store *refs, 558 struct ref_transaction *transaction, 559 struct strbuf *err); 560 561 typedef int ref_transaction_commit_fn(struct ref_store *refs, 562 struct ref_transaction *transaction, 563 struct strbuf *err); 564 565 typedef int pack_refs_fn(struct ref_store *ref_store, unsigned int flags); 566 typedef int create_symref_fn(struct ref_store *ref_store, 567 const char *ref_target, 568 const char *refs_heads_master, 569 const char *logmsg); 570 typedef int delete_refs_fn(struct ref_store *ref_store, const char *msg, 571 struct string_list *refnames, unsigned int flags); 572 typedef int rename_ref_fn(struct ref_store *ref_store, 573 const char *oldref, const char *newref, 574 const char *logmsg); 575 typedef int copy_ref_fn(struct ref_store *ref_store, 576 const char *oldref, const char *newref, 577 const char *logmsg); 578 579 /* 580 * Iterate over the references in `ref_store` whose names start with 581 * `prefix`. `prefix` is matched as a literal string, without regard 582 * for path separators. If prefix is NULL or the empty string, iterate 583 * over all references in `ref_store`. The output is ordered by 584 * refname. 585 */ 586 typedef struct ref_iterator *ref_iterator_begin_fn( 587 struct ref_store *ref_store, 588 const char *prefix, unsigned int flags); 589 590 /* reflog functions */ 591 592 /* 593 * Iterate over the references in the specified ref_store that have a 594 * reflog. The refs are iterated over in arbitrary order. 595 */ 596 typedef struct ref_iterator *reflog_iterator_begin_fn( 597 struct ref_store *ref_store); 598 599 typedef int for_each_reflog_ent_fn(struct ref_store *ref_store, 600 const char *refname, 601 each_reflog_ent_fn fn, 602 void *cb_data); 603 typedef int for_each_reflog_ent_reverse_fn(struct ref_store *ref_store, 604 const char *refname, 605 each_reflog_ent_fn fn, 606 void *cb_data); 607 typedef int reflog_exists_fn(struct ref_store *ref_store, const char *refname); 608 typedef int create_reflog_fn(struct ref_store *ref_store, const char *refname, 609 int force_create, struct strbuf *err); 610 typedef int delete_reflog_fn(struct ref_store *ref_store, const char *refname); 611 typedef int reflog_expire_fn(struct ref_store *ref_store, 612 const char *refname, 613 unsigned int flags, 614 reflog_expiry_prepare_fn prepare_fn, 615 reflog_expiry_should_prune_fn should_prune_fn, 616 reflog_expiry_cleanup_fn cleanup_fn, 617 void *policy_cb_data); 618 619 /* 620 * Read a reference from the specified reference store, non-recursively. 621 * Set type to describe the reference, and: 622 * 623 * - If refname is the name of a normal reference, fill in oid 624 * (leaving referent unchanged). 625 * 626 * - If refname is the name of a symbolic reference, write the full 627 * name of the reference to which it refers (e.g. 628 * "refs/heads/master") to referent and set the REF_ISSYMREF bit in 629 * type (leaving oid unchanged). The caller is responsible for 630 * validating that referent is a valid reference name. 631 * 632 * WARNING: refname might be used as part of a filename, so it is 633 * important from a security standpoint that it be safe in the sense 634 * of refname_is_safe(). Moreover, for symrefs this function sets 635 * referent to whatever the repository says, which might not be a 636 * properly-formatted or even safe reference name. NEITHER INPUT NOR 637 * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION. 638 * 639 * Return 0 on success, or -1 on failure. If the ref exists but is neither a 640 * symbolic ref nor an object ID, it is broken. In this case set REF_ISBROKEN in 641 * type, and return -1 (failure_errno should not be ENOENT) 642 * 643 * failure_errno provides errno codes that are interpreted beyond error 644 * reporting. The following error codes have special meaning: 645 * * ENOENT: the ref doesn't exist 646 * * EISDIR: ref name is a directory 647 * * ENOTDIR: ref prefix is not a directory 648 * 649 * Backend-specific flags might be set in type as well, regardless of 650 * outcome. 651 * 652 * It is OK for refname to point into referent. If so: 653 * 654 * - if the function succeeds with REF_ISSYMREF, referent will be 655 * overwritten and the memory formerly pointed to by it might be 656 * changed or even freed. 657 * 658 * - in all other cases, referent will be untouched, and therefore 659 * refname will still be valid and unchanged. 660 */ 661 typedef int read_raw_ref_fn(struct ref_store *ref_store, const char *refname, 662 struct object_id *oid, struct strbuf *referent, 663 unsigned int *type, int *failure_errno); 664 665 struct ref_storage_be { 666 struct ref_storage_be *next; 667 const char *name; 668 ref_store_init_fn *init; 669 ref_init_db_fn *init_db; 670 671 ref_transaction_prepare_fn *transaction_prepare; 672 ref_transaction_finish_fn *transaction_finish; 673 ref_transaction_abort_fn *transaction_abort; 674 ref_transaction_commit_fn *initial_transaction_commit; 675 676 pack_refs_fn *pack_refs; 677 create_symref_fn *create_symref; 678 delete_refs_fn *delete_refs; 679 rename_ref_fn *rename_ref; 680 copy_ref_fn *copy_ref; 681 682 ref_iterator_begin_fn *iterator_begin; 683 read_raw_ref_fn *read_raw_ref; 684 685 reflog_iterator_begin_fn *reflog_iterator_begin; 686 for_each_reflog_ent_fn *for_each_reflog_ent; 687 for_each_reflog_ent_reverse_fn *for_each_reflog_ent_reverse; 688 reflog_exists_fn *reflog_exists; 689 create_reflog_fn *create_reflog; 690 delete_reflog_fn *delete_reflog; 691 reflog_expire_fn *reflog_expire; 692 }; 693 694 extern struct ref_storage_be refs_be_files; 695 extern struct ref_storage_be refs_be_packed; 696 697 /* 698 * A representation of the reference store for the main repository or 699 * a submodule. The ref_store instances for submodules are kept in a 700 * hash map; see get_submodule_ref_store() for more info. 701 */ 702 struct ref_store { 703 /* The backend describing this ref_store's storage scheme: */ 704 const struct ref_storage_be *be; 705 706 struct repository *repo; 707 708 /* 709 * The gitdir that this ref_store applies to. Note that this is not 710 * necessarily repo->gitdir if the repo has multiple worktrees. 711 */ 712 char *gitdir; 713 }; 714 715 /* 716 * Parse contents of a loose ref file. 717 */ 718 int parse_loose_ref_contents(const char *buf, struct object_id *oid, 719 struct strbuf *referent, unsigned int *type); 720 721 /* 722 * Fill in the generic part of refs and add it to our collection of 723 * reference stores. 724 */ 725 void base_ref_store_init(struct ref_store *refs, 726 const struct ref_storage_be *be); 727 728 /* 729 * Support GIT_TRACE_REFS by optionally wrapping the given ref_store instance. 730 */ 731 struct ref_store *maybe_debug_wrap_ref_store(const char *gitdir, struct ref_store *store); 732 733 #endif /* REFS_REFS_INTERNAL_H */ 734