1#ifndef REFS_REFS_INTERNAL_H 2#define REFS_REFS_INTERNAL_H 3 4/* 5 * Data structures and functions for the internal use of the refs 6 * module. Code outside of the refs module should use only the public 7 * functions defined in "refs.h", and should *not* include this file. 8 */ 9 10/* 11 * Flag passed to lock_ref_sha1_basic() telling it to tolerate broken 12 * refs (i.e., because the reference is about to be deleted anyway). 13 */ 14#define REF_DELETING 0x02 15 16/* 17 * Used as a flag in ref_update::flags when a loose ref is being 18 * pruned. This flag must only be used when REF_NODEREF is set. 19 */ 20#define REF_ISPRUNING 0x04 21 22/* 23 * Used as a flag in ref_update::flags when the reference should be 24 * updated to new_sha1. 25 */ 26#define REF_HAVE_NEW 0x08 27 28/* 29 * Used as a flag in ref_update::flags when old_sha1 should be 30 * checked. 31 */ 32#define REF_HAVE_OLD 0x10 33 34/* 35 * Used as a flag in ref_update::flags when the lockfile needs to be 36 * committed. 37 */ 38#define REF_NEEDS_COMMIT 0x20 39 40/* 41 * 0x40 is REF_FORCE_CREATE_REFLOG, so skip it if you're adding a 42 * value to ref_update::flags 43 */ 44 45/* 46 * Used as a flag in ref_update::flags when we want to log a ref 47 * update but not actually perform it. This is used when a symbolic 48 * ref update is split up. 49 */ 50#define REF_LOG_ONLY 0x80 51 52/* 53 * Internal flag, meaning that the containing ref_update was via an 54 * update to HEAD. 55 */ 56#define REF_UPDATE_VIA_HEAD 0x100 57 58/* 59 * Return true iff refname is minimally safe. "Safe" here means that 60 * deleting a loose reference by this name will not do any damage, for 61 * example by causing a file that is not a reference to be deleted. 62 * This function does not check that the reference name is legal; for 63 * that, use check_refname_format(). 64 * 65 * We consider a refname that starts with "refs/" to be safe as long 66 * as any ".." components that it might contain do not escape "refs/". 67 * Names that do not start with "refs/" are considered safe iff they 68 * consist entirely of upper case characters and '_' (like "HEAD" and 69 * "MERGE_HEAD" but not "config" or "FOO/BAR"). 70 */ 71intrefname_is_safe(const char*refname); 72 73enum 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 sha1 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 sha1 unchanged. 104 */ 105enum peel_status peel_object(const unsigned char*name,unsigned char*sha1); 106 107/* 108 * Return 0 if a reference named refname could be created without 109 * conflicting with the name of an existing reference. Otherwise, 110 * return a negative value and write an explanation to err. If extras 111 * is non-NULL, it is a list of additional refnames with which refname 112 * is not allowed to conflict. If skip is non-NULL, ignore potential 113 * conflicts with refs in skip (e.g., because they are scheduled for 114 * deletion in the same operation). Behavior is undefined if the same 115 * name is listed in both extras and skip. 116 * 117 * Two reference names conflict if one of them exactly matches the 118 * leading components of the other; e.g., "foo/bar" conflicts with 119 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or 120 * "foo/barbados". 121 * 122 * extras and skip must be sorted. 123 */ 124intverify_refname_available(const char*newname, 125const struct string_list *extras, 126const struct string_list *skip, 127struct strbuf *err); 128 129/* 130 * Copy the reflog message msg to buf, which has been allocated sufficiently 131 * large, while cleaning up the whitespaces. Especially, convert LF to space, 132 * because reflog file is one line per entry. 133 */ 134intcopy_reflog_msg(char*buf,const char*msg); 135 136/** 137 * Information needed for a single ref update. Set new_sha1 to the new 138 * value or to null_sha1 to delete the ref. To check the old value 139 * while the ref is locked, set (flags & REF_HAVE_OLD) and set 140 * old_sha1 to the old value, or to null_sha1 to ensure the ref does 141 * not exist before update. 142 */ 143struct ref_update { 144 145/* 146 * If (flags & REF_HAVE_NEW), set the reference to this value: 147 */ 148unsigned char new_sha1[20]; 149 150/* 151 * If (flags & REF_HAVE_OLD), check that the reference 152 * previously had this value: 153 */ 154unsigned char old_sha1[20]; 155 156/* 157 * One or more of REF_HAVE_NEW, REF_HAVE_OLD, REF_NODEREF, 158 * REF_DELETING, REF_ISPRUNING, REF_LOG_ONLY, and 159 * REF_UPDATE_VIA_HEAD: 160 */ 161unsigned int flags; 162 163void*backend_data; 164unsigned int type; 165char*msg; 166 167/* 168 * If this ref_update was split off of a symref update via 169 * split_symref_update(), then this member points at that 170 * update. This is used for two purposes: 171 * 1. When reporting errors, we report the refname under which 172 * the update was originally requested. 173 * 2. When we read the old value of this reference, we 174 * propagate it back to its parent update for recording in 175 * the latter's reflog. 176 */ 177struct ref_update *parent_update; 178 179const char refname[FLEX_ARRAY]; 180}; 181 182/* 183 * Add a ref_update with the specified properties to transaction, and 184 * return a pointer to the new object. This function does not verify 185 * that refname is well-formed. new_sha1 and old_sha1 are only 186 * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits, 187 * respectively, are set in flags. 188 */ 189struct ref_update *ref_transaction_add_update( 190struct ref_transaction *transaction, 191const char*refname,unsigned int flags, 192const unsigned char*new_sha1, 193const unsigned char*old_sha1, 194const char*msg); 195 196/* 197 * Transaction states. 198 * OPEN: The transaction is in a valid state and can accept new updates. 199 * An OPEN transaction can be committed. 200 * CLOSED: A closed transaction is no longer active and no other operations 201 * than free can be used on it in this state. 202 * A transaction can either become closed by successfully committing 203 * an active transaction or if there is a failure while building 204 * the transaction thus rendering it failed/inactive. 205 */ 206enum ref_transaction_state { 207 REF_TRANSACTION_OPEN =0, 208 REF_TRANSACTION_CLOSED =1 209}; 210 211/* 212 * Data structure for holding a reference transaction, which can 213 * consist of checks and updates to multiple references, carried out 214 * as atomically as possible. This structure is opaque to callers. 215 */ 216struct ref_transaction { 217struct ref_update **updates; 218size_t alloc; 219size_t nr; 220enum ref_transaction_state state; 221}; 222 223intfiles_log_ref_write(const char*refname,const unsigned char*old_sha1, 224const unsigned char*new_sha1,const char*msg, 225int flags,struct strbuf *err); 226 227/* 228 * Check for entries in extras that are within the specified 229 * directory, where dirname is a reference directory name including 230 * the trailing slash (e.g., "refs/heads/foo/"). Ignore any 231 * conflicting references that are found in skip. If there is a 232 * conflicting reference, return its name. 233 * 234 * extras and skip must be sorted lists of reference names. Either one 235 * can be NULL, signifying the empty list. 236 */ 237const char*find_descendant_ref(const char*dirname, 238const struct string_list *extras, 239const struct string_list *skip); 240 241/* 242 * Check whether an attempt to rename old_refname to new_refname would 243 * cause a D/F conflict with any existing reference (other than 244 * possibly old_refname). If there would be a conflict, emit an error 245 * message and return false; otherwise, return true. 246 * 247 * Note that this function is not safe against all races with other 248 * processes (though rename_ref() catches some races that might get by 249 * this check). 250 */ 251intrename_ref_available(const char*old_refname,const char*new_refname); 252 253/* We allow "recursive" symbolic refs. Only within reason, though */ 254#define SYMREF_MAXDEPTH 5 255 256/* Include broken references in a do_for_each_ref*() iteration: */ 257#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 258 259/* 260 * Reference iterators 261 * 262 * A reference iterator encapsulates the state of an in-progress 263 * iteration over references. Create an instance of `struct 264 * ref_iterator` via one of the functions in this module. 265 * 266 * A freshly-created ref_iterator doesn't yet point at a reference. To 267 * advance the iterator, call ref_iterator_advance(). If successful, 268 * this sets the iterator's refname, oid, and flags fields to describe 269 * the next reference and returns ITER_OK. The data pointed at by 270 * refname and oid belong to the iterator; if you want to retain them 271 * after calling ref_iterator_advance() again or calling 272 * ref_iterator_abort(), you must make a copy. When the iteration has 273 * been exhausted, ref_iterator_advance() releases any resources 274 * assocated with the iteration, frees the ref_iterator object, and 275 * returns ITER_DONE. If you want to abort the iteration early, call 276 * ref_iterator_abort(), which also frees the ref_iterator object and 277 * any associated resources. If there was an internal error advancing 278 * to the next entry, ref_iterator_advance() aborts the iteration, 279 * frees the ref_iterator, and returns ITER_ERROR. 280 * 281 * The reference currently being looked at can be peeled by calling 282 * ref_iterator_peel(). This function is often faster than peel_ref(), 283 * so it should be preferred when iterating over references. 284 * 285 * Putting it all together, a typical iteration looks like this: 286 * 287 * int ok; 288 * struct ref_iterator *iter = ...; 289 * 290 * while ((ok = ref_iterator_advance(iter)) == ITER_OK) { 291 * if (want_to_stop_iteration()) { 292 * ok = ref_iterator_abort(iter); 293 * break; 294 * } 295 * 296 * // Access information about the current reference: 297 * if (!(iter->flags & REF_ISSYMREF)) 298 * printf("%s is %s\n", iter->refname, oid_to_hex(&iter->oid)); 299 * 300 * // If you need to peel the reference: 301 * ref_iterator_peel(iter, &oid); 302 * } 303 * 304 * if (ok != ITER_DONE) 305 * handle_error(); 306 */ 307struct ref_iterator { 308struct ref_iterator_vtable *vtable; 309const char*refname; 310const struct object_id *oid; 311unsigned int flags; 312}; 313 314/* 315 * Advance the iterator to the first or next item and return ITER_OK. 316 * If the iteration is exhausted, free the resources associated with 317 * the ref_iterator and return ITER_DONE. On errors, free the iterator 318 * resources and return ITER_ERROR. It is a bug to use ref_iterator or 319 * call this function again after it has returned ITER_DONE or 320 * ITER_ERROR. 321 */ 322intref_iterator_advance(struct ref_iterator *ref_iterator); 323 324/* 325 * If possible, peel the reference currently being viewed by the 326 * iterator. Return 0 on success. 327 */ 328intref_iterator_peel(struct ref_iterator *ref_iterator, 329struct object_id *peeled); 330 331/* 332 * End the iteration before it has been exhausted, freeing the 333 * reference iterator and any associated resources and returning 334 * ITER_DONE. If the abort itself failed, return ITER_ERROR. 335 */ 336intref_iterator_abort(struct ref_iterator *ref_iterator); 337 338/* 339 * An iterator over nothing (its first ref_iterator_advance() call 340 * returns ITER_DONE). 341 */ 342struct ref_iterator *empty_ref_iterator_begin(void); 343 344/* 345 * Return true iff ref_iterator is an empty_ref_iterator. 346 */ 347intis_empty_ref_iterator(struct ref_iterator *ref_iterator); 348 349/* 350 * A callback function used to instruct merge_ref_iterator how to 351 * interleave the entries from iter0 and iter1. The function should 352 * return one of the constants defined in enum iterator_selection. It 353 * must not advance either of the iterators itself. 354 * 355 * The function must be prepared to handle the case that iter0 and/or 356 * iter1 is NULL, which indicates that the corresponding sub-iterator 357 * has been exhausted. Its return value must be consistent with the 358 * current states of the iterators; e.g., it must not return 359 * ITER_SKIP_1 if iter1 has already been exhausted. 360 */ 361typedefenum iterator_selection ref_iterator_select_fn( 362struct ref_iterator *iter0,struct ref_iterator *iter1, 363void*cb_data); 364 365/* 366 * Iterate over the entries from iter0 and iter1, with the values 367 * interleaved as directed by the select function. The iterator takes 368 * ownership of iter0 and iter1 and frees them when the iteration is 369 * over. 370 */ 371struct ref_iterator *merge_ref_iterator_begin( 372struct ref_iterator *iter0,struct ref_iterator *iter1, 373 ref_iterator_select_fn *select,void*cb_data); 374 375/* 376 * An iterator consisting of the union of the entries from front and 377 * back. If there are entries common to the two sub-iterators, use the 378 * one from front. Each iterator must iterate over its entries in 379 * strcmp() order by refname for this to work. 380 * 381 * The new iterator takes ownership of its arguments and frees them 382 * when the iteration is over. As a convenience to callers, if front 383 * or back is an empty_ref_iterator, then abort that one immediately 384 * and return the other iterator directly, without wrapping it. 385 */ 386struct ref_iterator *overlay_ref_iterator_begin( 387struct ref_iterator *front,struct ref_iterator *back); 388 389/* 390 * Wrap iter0, only letting through the references whose names start 391 * with prefix. If trim is set, set iter->refname to the name of the 392 * reference with that many characters trimmed off the front; 393 * otherwise set it to the full refname. The new iterator takes over 394 * ownership of iter0 and frees it when iteration is over. It makes 395 * its own copy of prefix. 396 * 397 * As an convenience to callers, if prefix is the empty string and 398 * trim is zero, this function returns iter0 directly, without 399 * wrapping it. 400 */ 401struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, 402const char*prefix, 403int trim); 404 405/* Internal implementation of reference iteration: */ 406 407/* 408 * Base class constructor for ref_iterators. Initialize the 409 * ref_iterator part of iter, setting its vtable pointer as specified. 410 * This is meant to be called only by the initializers of derived 411 * classes. 412 */ 413voidbase_ref_iterator_init(struct ref_iterator *iter, 414struct ref_iterator_vtable *vtable); 415 416/* 417 * Base class destructor for ref_iterators. Destroy the ref_iterator 418 * part of iter and shallow-free the object. This is meant to be 419 * called only by the destructors of derived classes. 420 */ 421voidbase_ref_iterator_free(struct ref_iterator *iter); 422 423/* Virtual function declarations for ref_iterators: */ 424 425typedefintref_iterator_advance_fn(struct ref_iterator *ref_iterator); 426 427typedefintref_iterator_peel_fn(struct ref_iterator *ref_iterator, 428struct object_id *peeled); 429 430/* 431 * Implementations of this function should free any resources specific 432 * to the derived class, then call base_ref_iterator_free() to clean 433 * up and free the ref_iterator object. 434 */ 435typedefintref_iterator_abort_fn(struct ref_iterator *ref_iterator); 436 437struct ref_iterator_vtable { 438 ref_iterator_advance_fn *advance; 439 ref_iterator_peel_fn *peel; 440 ref_iterator_abort_fn *abort; 441}; 442 443/* 444 * current_ref_iter is a performance hack: when iterating over 445 * references using the for_each_ref*() functions, current_ref_iter is 446 * set to the reference iterator before calling the callback function. 447 * If the callback function calls peel_ref(), then peel_ref() first 448 * checks whether the reference to be peeled is the one referred to by 449 * the iterator (it usually is) and if so, asks the iterator for the 450 * peeled version of the reference if it is available. This avoids a 451 * refname lookup in a common case. current_ref_iter is set to NULL 452 * when the iteration is over. 453 */ 454externstruct ref_iterator *current_ref_iter; 455 456/* 457 * The common backend for the for_each_*ref* functions. Call fn for 458 * each reference in iter. If the iterator itself ever returns 459 * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop 460 * the iteration and return that value. Otherwise, return 0. In any 461 * case, free the iterator when done. This function is basically an 462 * adapter between the callback style of reference iteration and the 463 * iterator style. 464 */ 465intdo_for_each_ref_iterator(struct ref_iterator *iter, 466 each_ref_fn fn,void*cb_data); 467 468/* 469 * Only include per-worktree refs in a do_for_each_ref*() iteration. 470 * Normally this will be used with a files ref_store, since that's 471 * where all reference backends will presumably store their 472 * per-worktree refs. 473 */ 474#define DO_FOR_EACH_PER_WORKTREE_ONLY 0x02 475 476struct ref_store; 477 478/* refs backends */ 479 480/* 481 * Initialize the ref_store for the specified submodule, or for the 482 * main repository if submodule == NULL. These functions should call 483 * base_ref_store_init() to initialize the shared part of the 484 * ref_store and to record the ref_store for later lookup. 485 */ 486typedefstruct ref_store *ref_store_init_fn(const char*submodule); 487 488typedefintref_init_db_fn(struct ref_store *refs,struct strbuf *err); 489 490typedefintref_transaction_commit_fn(struct ref_store *refs, 491struct ref_transaction *transaction, 492struct strbuf *err); 493 494typedefintpack_refs_fn(struct ref_store *ref_store,unsigned int flags); 495typedefintpeel_ref_fn(struct ref_store *ref_store, 496const char*refname,unsigned char*sha1); 497typedefintcreate_symref_fn(struct ref_store *ref_store, 498const char*ref_target, 499const char*refs_heads_master, 500const char*logmsg); 501typedefintdelete_refs_fn(struct ref_store *ref_store, 502struct string_list *refnames,unsigned int flags); 503typedefintrename_ref_fn(struct ref_store *ref_store, 504const char*oldref,const char*newref, 505const char*logmsg); 506 507/* 508 * Iterate over the references in the specified ref_store that are 509 * within find_containing_dir(prefix). If prefix is NULL or the empty 510 * string, iterate over all references in the submodule. 511 */ 512typedefstruct ref_iterator *ref_iterator_begin_fn( 513struct ref_store *ref_store, 514const char*prefix,unsigned int flags); 515 516/* reflog functions */ 517 518/* 519 * Iterate over the references in the specified ref_store that have a 520 * reflog. The refs are iterated over in arbitrary order. 521 */ 522typedefstruct ref_iterator *reflog_iterator_begin_fn( 523struct ref_store *ref_store); 524 525typedefintfor_each_reflog_ent_fn(struct ref_store *ref_store, 526const char*refname, 527 each_reflog_ent_fn fn, 528void*cb_data); 529typedefintfor_each_reflog_ent_reverse_fn(struct ref_store *ref_store, 530const char*refname, 531 each_reflog_ent_fn fn, 532void*cb_data); 533typedefintreflog_exists_fn(struct ref_store *ref_store,const char*refname); 534typedefintcreate_reflog_fn(struct ref_store *ref_store,const char*refname, 535int force_create,struct strbuf *err); 536typedefintdelete_reflog_fn(struct ref_store *ref_store,const char*refname); 537typedefintreflog_expire_fn(struct ref_store *ref_store, 538const char*refname,const unsigned char*sha1, 539unsigned int flags, 540 reflog_expiry_prepare_fn prepare_fn, 541 reflog_expiry_should_prune_fn should_prune_fn, 542 reflog_expiry_cleanup_fn cleanup_fn, 543void*policy_cb_data); 544 545/* 546 * Read a reference from the specified reference store, non-recursively. 547 * Set type to describe the reference, and: 548 * 549 * - If refname is the name of a normal reference, fill in sha1 550 * (leaving referent unchanged). 551 * 552 * - If refname is the name of a symbolic reference, write the full 553 * name of the reference to which it refers (e.g. 554 * "refs/heads/master") to referent and set the REF_ISSYMREF bit in 555 * type (leaving sha1 unchanged). The caller is responsible for 556 * validating that referent is a valid reference name. 557 * 558 * WARNING: refname might be used as part of a filename, so it is 559 * important from a security standpoint that it be safe in the sense 560 * of refname_is_safe(). Moreover, for symrefs this function sets 561 * referent to whatever the repository says, which might not be a 562 * properly-formatted or even safe reference name. NEITHER INPUT NOR 563 * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION. 564 * 565 * Return 0 on success. If the ref doesn't exist, set errno to ENOENT 566 * and return -1. If the ref exists but is neither a symbolic ref nor 567 * a sha1, it is broken; set REF_ISBROKEN in type, set errno to 568 * EINVAL, and return -1. If there is another error reading the ref, 569 * set errno appropriately and return -1. 570 * 571 * Backend-specific flags might be set in type as well, regardless of 572 * outcome. 573 * 574 * It is OK for refname to point into referent. If so: 575 * 576 * - if the function succeeds with REF_ISSYMREF, referent will be 577 * overwritten and the memory formerly pointed to by it might be 578 * changed or even freed. 579 * 580 * - in all other cases, referent will be untouched, and therefore 581 * refname will still be valid and unchanged. 582 */ 583typedefintread_raw_ref_fn(struct ref_store *ref_store, 584const char*refname,unsigned char*sha1, 585struct strbuf *referent,unsigned int*type); 586 587typedefintverify_refname_available_fn(struct ref_store *ref_store, 588const char*newname, 589const struct string_list *extras, 590const struct string_list *skip, 591struct strbuf *err); 592 593struct ref_storage_be { 594struct ref_storage_be *next; 595const char*name; 596 ref_store_init_fn *init; 597 ref_init_db_fn *init_db; 598 ref_transaction_commit_fn *transaction_commit; 599 ref_transaction_commit_fn *initial_transaction_commit; 600 601 pack_refs_fn *pack_refs; 602 peel_ref_fn *peel_ref; 603 create_symref_fn *create_symref; 604 delete_refs_fn *delete_refs; 605 rename_ref_fn *rename_ref; 606 607 ref_iterator_begin_fn *iterator_begin; 608 read_raw_ref_fn *read_raw_ref; 609 verify_refname_available_fn *verify_refname_available; 610 611 reflog_iterator_begin_fn *reflog_iterator_begin; 612 for_each_reflog_ent_fn *for_each_reflog_ent; 613 for_each_reflog_ent_reverse_fn *for_each_reflog_ent_reverse; 614 reflog_exists_fn *reflog_exists; 615 create_reflog_fn *create_reflog; 616 delete_reflog_fn *delete_reflog; 617 reflog_expire_fn *reflog_expire; 618}; 619 620externstruct ref_storage_be refs_be_files; 621 622/* 623 * A representation of the reference store for the main repository or 624 * a submodule. The ref_store instances for submodules are kept in a 625 * linked list. 626 */ 627struct ref_store { 628/* The backend describing this ref_store's storage scheme: */ 629const struct ref_storage_be *be; 630 631/* 632 * The name of the submodule represented by this object, or 633 * the empty string if it represents the main repository's 634 * reference store: 635 */ 636const char*submodule; 637 638/* 639 * Submodule reference store instances are stored in a linked 640 * list using this pointer. 641 */ 642struct ref_store *next; 643}; 644 645/* 646 * Fill in the generic part of refs for the specified submodule and 647 * add it to our collection of reference stores. 648 */ 649voidbase_ref_store_init(struct ref_store *refs, 650const struct ref_storage_be *be, 651const char*submodule); 652 653/* 654 * Create, record, and return a ref_store instance for the specified 655 * submodule (or the main repository if submodule is NULL). 656 * 657 * For backwards compatibility, submodule=="" is treated the same as 658 * submodule==NULL. 659 */ 660struct ref_store *ref_store_init(const char*submodule); 661 662/* 663 * Return the ref_store instance for the specified submodule (or the 664 * main repository if submodule is NULL). If that ref_store hasn't 665 * been initialized yet, return NULL. 666 * 667 * For backwards compatibility, submodule=="" is treated the same as 668 * submodule==NULL. 669 */ 670struct ref_store *lookup_ref_store(const char*submodule); 671 672/* 673 * Return the ref_store instance for the specified submodule. For the 674 * main repository, use submodule==NULL; such a call cannot fail. For 675 * a submodule, the submodule must exist and be a nonbare repository, 676 * otherwise return NULL. If the requested reference store has not yet 677 * been initialized, initialize it first. 678 * 679 * For backwards compatibility, submodule=="" is treated the same as 680 * submodule==NULL. 681 */ 682struct ref_store *get_ref_store(const char*submodule); 683 684/* 685 * Die if refs is for a submodule (i.e., not for the main repository). 686 * caller is used in any necessary error messages. 687 */ 688voidassert_main_repository(struct ref_store *refs,const char*caller); 689 690#endif/* REFS_REFS_INTERNAL_H */