1#ifndef REFS_H 2#define REFS_H 3 4struct object_id; 5struct ref_store; 6struct strbuf; 7struct string_list; 8 9/* 10 * Resolve a reference, recursively following symbolic refererences. 11 * 12 * Store the referred-to object's name in sha1 and return the name of 13 * the non-symbolic reference that ultimately pointed at it. The 14 * return value, if not NULL, is a pointer into either a static buffer 15 * or the input ref. 16 * 17 * If the reference cannot be resolved to an object, the behavior 18 * depends on the RESOLVE_REF_READING flag: 19 * 20 * - If RESOLVE_REF_READING is set, return NULL. 21 * 22 * - If RESOLVE_REF_READING is not set, clear sha1 and return the name of 23 * the last reference name in the chain, which will either be a non-symbolic 24 * reference or an undefined reference. If this is a prelude to 25 * "writing" to the ref, the return value is the name of the ref 26 * that will actually be created or changed. 27 * 28 * If the RESOLVE_REF_NO_RECURSE flag is passed, only resolves one 29 * level of symbolic reference. The value stored in sha1 for a symbolic 30 * reference will always be null_sha1 in this case, and the return 31 * value is the reference that the symref refers to directly. 32 * 33 * If flags is non-NULL, set the value that it points to the 34 * combination of REF_ISPACKED (if the reference was found among the 35 * packed references), REF_ISSYMREF (if the initial reference was a 36 * symbolic reference), REF_BAD_NAME (if the reference name is ill 37 * formed --- see RESOLVE_REF_ALLOW_BAD_NAME below), and REF_ISBROKEN 38 * (if the ref is malformed or has a bad name). See refs.h for more detail 39 * on each flag. 40 * 41 * If ref is not a properly-formatted, normalized reference, return 42 * NULL. If more than MAXDEPTH recursive symbolic lookups are needed, 43 * give up and return NULL. 44 * 45 * RESOLVE_REF_ALLOW_BAD_NAME allows resolving refs even when their 46 * name is invalid according to git-check-ref-format(1). If the name 47 * is bad then the value stored in sha1 will be null_sha1 and the two 48 * flags REF_ISBROKEN and REF_BAD_NAME will be set. 49 * 50 * Even with RESOLVE_REF_ALLOW_BAD_NAME, names that escape the refs/ 51 * directory and do not consist of all caps and underscores cannot be 52 * resolved. The function returns NULL for such ref names. 53 * Caps and underscores refers to the special refs, such as HEAD, 54 * FETCH_HEAD and friends, that all live outside of the refs/ directory. 55 */ 56#define RESOLVE_REF_READING 0x01 57#define RESOLVE_REF_NO_RECURSE 0x02 58#define RESOLVE_REF_ALLOW_BAD_NAME 0x04 59 60const char*refs_resolve_ref_unsafe(struct ref_store *refs, 61const char*refname, 62int resolve_flags, 63unsigned char*sha1, 64int*flags); 65const char*resolve_ref_unsafe(const char*refname,int resolve_flags, 66unsigned char*sha1,int*flags); 67 68char*refs_resolve_refdup(struct ref_store *refs, 69const char*refname,int resolve_flags, 70unsigned char*sha1,int*flags); 71char*resolve_refdup(const char*refname,int resolve_flags, 72unsigned char*sha1,int*flags); 73 74intrefs_read_ref_full(struct ref_store *refs,const char*refname, 75int resolve_flags,unsigned char*sha1,int*flags); 76intread_ref_full(const char*refname,int resolve_flags, 77unsigned char*sha1,int*flags); 78intread_ref(const char*refname,unsigned char*sha1); 79 80/* 81 * Return 0 if a reference named refname could be created without 82 * conflicting with the name of an existing reference. Otherwise, 83 * return a negative value and write an explanation to err. If extras 84 * is non-NULL, it is a list of additional refnames with which refname 85 * is not allowed to conflict. If skip is non-NULL, ignore potential 86 * conflicts with refs in skip (e.g., because they are scheduled for 87 * deletion in the same operation). Behavior is undefined if the same 88 * name is listed in both extras and skip. 89 * 90 * Two reference names conflict if one of them exactly matches the 91 * leading components of the other; e.g., "foo/bar" conflicts with 92 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or 93 * "foo/barbados". 94 * 95 * extras and skip must be sorted. 96 */ 97 98intrefs_verify_refname_available(struct ref_store *refs, 99const char*refname, 100const struct string_list *extra, 101const struct string_list *skip, 102struct strbuf *err); 103 104intref_exists(const char*refname); 105 106intshould_autocreate_reflog(const char*refname); 107 108intis_branch(const char*refname); 109 110externintrefs_init_db(struct strbuf *err); 111 112/* 113 * If refname is a non-symbolic reference that refers to a tag object, 114 * and the tag can be (recursively) dereferenced to a non-tag object, 115 * store the SHA1 of the referred-to object to sha1 and return 0. If 116 * any of these conditions are not met, return a non-zero value. 117 * Symbolic references are considered unpeelable, even if they 118 * ultimately resolve to a peelable tag. 119 */ 120intrefs_peel_ref(struct ref_store *refs,const char*refname, 121unsigned char*sha1); 122intpeel_ref(const char*refname,unsigned char*sha1); 123 124/** 125 * Resolve refname in the nested "gitlink" repository in the specified 126 * submodule (which must be non-NULL). If the resolution is 127 * successful, return 0 and set sha1 to the name of the object; 128 * otherwise, return a non-zero value. 129 */ 130intresolve_gitlink_ref(const char*submodule,const char*refname, 131unsigned char*sha1); 132 133/* 134 * Return true iff abbrev_name is a possible abbreviation for 135 * full_name according to the rules defined by ref_rev_parse_rules in 136 * refs.c. 137 */ 138intrefname_match(const char*abbrev_name,const char*full_name); 139 140intexpand_ref(const char*str,int len,unsigned char*sha1,char**ref); 141intdwim_ref(const char*str,int len,unsigned char*sha1,char**ref); 142intdwim_log(const char*str,int len,unsigned char*sha1,char**ref); 143 144/* 145 * A ref_transaction represents a collection of ref updates 146 * that should succeed or fail together. 147 * 148 * Calling sequence 149 * ---------------- 150 * - Allocate and initialize a `struct ref_transaction` by calling 151 * `ref_transaction_begin()`. 152 * 153 * - List intended ref updates by calling functions like 154 * `ref_transaction_update()` and `ref_transaction_create()`. 155 * 156 * - Call `ref_transaction_commit()` to execute the transaction. 157 * If this succeeds, the ref updates will have taken place and 158 * the transaction cannot be rolled back. 159 * 160 * - Instead of `ref_transaction_commit`, use 161 * `initial_ref_transaction_commit()` if the ref database is known 162 * to be empty (e.g. during clone). This is likely to be much 163 * faster. 164 * 165 * - At any time call `ref_transaction_free()` to discard the 166 * transaction and free associated resources. In particular, 167 * this rolls back the transaction if it has not been 168 * successfully committed. 169 * 170 * Error handling 171 * -------------- 172 * 173 * On error, transaction functions append a message about what 174 * went wrong to the 'err' argument. The message mentions what 175 * ref was being updated (if any) when the error occurred so it 176 * can be passed to 'die' or 'error' as-is. 177 * 178 * The message is appended to err without first clearing err. 179 * err will not be '\n' terminated. 180 * 181 * Caveats 182 * ------- 183 * 184 * Note that no locks are taken, and no refs are read, until 185 * `ref_transaction_commit` is called. So `ref_transaction_verify` 186 * won't report a verification failure until the commit is attempted. 187 */ 188struct ref_transaction; 189 190/* 191 * Bit values set in the flags argument passed to each_ref_fn() and 192 * stored in ref_iterator::flags. Other bits are for internal use 193 * only: 194 */ 195 196/* Reference is a symbolic reference. */ 197#define REF_ISSYMREF 0x01 198 199/* Reference is a packed reference. */ 200#define REF_ISPACKED 0x02 201 202/* 203 * Reference cannot be resolved to an object name: dangling symbolic 204 * reference (directly or indirectly), corrupt reference file, 205 * reference exists but name is bad, or symbolic reference refers to 206 * ill-formatted reference name. 207 */ 208#define REF_ISBROKEN 0x04 209 210/* 211 * Reference name is not well formed. 212 * 213 * See git-check-ref-format(1) for the definition of well formed ref names. 214 */ 215#define REF_BAD_NAME 0x08 216 217/* 218 * The signature for the callback function for the for_each_*() 219 * functions below. The memory pointed to by the refname and sha1 220 * arguments is only guaranteed to be valid for the duration of a 221 * single callback invocation. 222 */ 223typedefinteach_ref_fn(const char*refname, 224const struct object_id *oid,int flags,void*cb_data); 225 226/* 227 * The following functions invoke the specified callback function for 228 * each reference indicated. If the function ever returns a nonzero 229 * value, stop the iteration and return that value. Please note that 230 * it is not safe to modify references while an iteration is in 231 * progress, unless the same callback function invocation that 232 * modifies the reference also returns a nonzero value to immediately 233 * stop the iteration. 234 */ 235intrefs_for_each_ref(struct ref_store *refs, 236 each_ref_fn fn,void*cb_data); 237intrefs_for_each_ref_in(struct ref_store *refs,const char*prefix, 238 each_ref_fn fn,void*cb_data); 239intrefs_for_each_tag_ref(struct ref_store *refs, 240 each_ref_fn fn,void*cb_data); 241intrefs_for_each_branch_ref(struct ref_store *refs, 242 each_ref_fn fn,void*cb_data); 243intrefs_for_each_remote_ref(struct ref_store *refs, 244 each_ref_fn fn,void*cb_data); 245 246inthead_ref(each_ref_fn fn,void*cb_data); 247intfor_each_ref(each_ref_fn fn,void*cb_data); 248intfor_each_ref_in(const char*prefix, each_ref_fn fn,void*cb_data); 249intfor_each_fullref_in(const char*prefix, each_ref_fn fn,void*cb_data, 250unsigned int broken); 251intfor_each_tag_ref(each_ref_fn fn,void*cb_data); 252intfor_each_branch_ref(each_ref_fn fn,void*cb_data); 253intfor_each_remote_ref(each_ref_fn fn,void*cb_data); 254intfor_each_replace_ref(each_ref_fn fn,void*cb_data); 255intfor_each_glob_ref(each_ref_fn fn,const char*pattern,void*cb_data); 256intfor_each_glob_ref_in(each_ref_fn fn,const char*pattern, 257const char*prefix,void*cb_data); 258 259inthead_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data); 260intfor_each_ref_submodule(const char*submodule, 261 each_ref_fn fn,void*cb_data); 262intfor_each_ref_in_submodule(const char*submodule,const char*prefix, 263 each_ref_fn fn,void*cb_data); 264intfor_each_tag_ref_submodule(const char*submodule, 265 each_ref_fn fn,void*cb_data); 266intfor_each_branch_ref_submodule(const char*submodule, 267 each_ref_fn fn,void*cb_data); 268intfor_each_remote_ref_submodule(const char*submodule, 269 each_ref_fn fn,void*cb_data); 270 271inthead_ref_namespaced(each_ref_fn fn,void*cb_data); 272intfor_each_namespaced_ref(each_ref_fn fn,void*cb_data); 273 274/* can be used to learn about broken ref and symref */ 275intrefs_for_each_rawref(struct ref_store *refs, each_ref_fn fn,void*cb_data); 276intfor_each_rawref(each_ref_fn fn,void*cb_data); 277 278staticinlineconst char*has_glob_specials(const char*pattern) 279{ 280returnstrpbrk(pattern,"?*["); 281} 282 283voidwarn_dangling_symref(FILE*fp,const char*msg_fmt,const char*refname); 284voidwarn_dangling_symrefs(FILE*fp,const char*msg_fmt, 285const struct string_list *refnames); 286 287/* 288 * Flags for controlling behaviour of pack_refs() 289 * PACK_REFS_PRUNE: Prune loose refs after packing 290 * PACK_REFS_ALL: Pack _all_ refs, not just tags and already packed refs 291 */ 292#define PACK_REFS_PRUNE 0x0001 293#define PACK_REFS_ALL 0x0002 294 295/* 296 * Write a packed-refs file for the current repository. 297 * flags: Combination of the above PACK_REFS_* flags. 298 */ 299intrefs_pack_refs(struct ref_store *refs,unsigned int flags); 300intpack_refs(unsigned int flags); 301 302/* 303 * Flags controlling ref_transaction_update(), ref_transaction_create(), etc. 304 * REF_NODEREF: act on the ref directly, instead of dereferencing 305 * symbolic references. 306 * 307 * Other flags are reserved for internal use. 308 */ 309#define REF_NODEREF 0x01 310#define REF_FORCE_CREATE_REFLOG 0x40 311 312/* 313 * Setup reflog before using. Fill in err and return -1 on failure. 314 */ 315intrefs_create_reflog(struct ref_store *refs,const char*refname, 316int force_create,struct strbuf *err); 317intsafe_create_reflog(const char*refname,int force_create,struct strbuf *err); 318 319/** Reads log for the value of ref during at_time. **/ 320intread_ref_at(const char*refname,unsigned int flags, 321unsigned long at_time,int cnt, 322unsigned char*sha1,char**msg, 323unsigned long*cutoff_time,int*cutoff_tz,int*cutoff_cnt); 324 325/** Check if a particular reflog exists */ 326intrefs_reflog_exists(struct ref_store *refs,const char*refname); 327intreflog_exists(const char*refname); 328 329/* 330 * Delete the specified reference. If old_sha1 is non-NULL, then 331 * verify that the current value of the reference is old_sha1 before 332 * deleting it. If old_sha1 is NULL, delete the reference if it 333 * exists, regardless of its old value. It is an error for old_sha1 to 334 * be NULL_SHA1. flags is passed through to ref_transaction_delete(). 335 */ 336intrefs_delete_ref(struct ref_store *refs,const char*msg, 337const char*refname, 338const unsigned char*old_sha1, 339unsigned int flags); 340intdelete_ref(const char*msg,const char*refname, 341const unsigned char*old_sha1,unsigned int flags); 342 343/* 344 * Delete the specified references. If there are any problems, emit 345 * errors but attempt to keep going (i.e., the deletes are not done in 346 * an all-or-nothing transaction). flags is passed through to 347 * ref_transaction_delete(). 348 */ 349intrefs_delete_refs(struct ref_store *refs,struct string_list *refnames, 350unsigned int flags); 351intdelete_refs(struct string_list *refnames,unsigned int flags); 352 353/** Delete a reflog */ 354intrefs_delete_reflog(struct ref_store *refs,const char*refname); 355intdelete_reflog(const char*refname); 356 357/* iterate over reflog entries */ 358typedefinteach_reflog_ent_fn( 359struct object_id *old_oid,struct object_id *new_oid, 360const char*committer,unsigned long timestamp, 361int tz,const char*msg,void*cb_data); 362 363intrefs_for_each_reflog_ent(struct ref_store *refs,const char*refname, 364 each_reflog_ent_fn fn,void*cb_data); 365intrefs_for_each_reflog_ent_reverse(struct ref_store *refs, 366const char*refname, 367 each_reflog_ent_fn fn, 368void*cb_data); 369intfor_each_reflog_ent(const char*refname, each_reflog_ent_fn fn,void*cb_data); 370intfor_each_reflog_ent_reverse(const char*refname, each_reflog_ent_fn fn,void*cb_data); 371 372/* 373 * Calls the specified function for each reflog file until it returns nonzero, 374 * and returns the value 375 */ 376intrefs_for_each_reflog(struct ref_store *refs, each_ref_fn fn,void*cb_data); 377intfor_each_reflog(each_ref_fn fn,void*cb_data); 378 379#define REFNAME_ALLOW_ONELEVEL 1 380#define REFNAME_REFSPEC_PATTERN 2 381 382/* 383 * Return 0 iff refname has the correct format for a refname according 384 * to the rules described in Documentation/git-check-ref-format.txt. 385 * If REFNAME_ALLOW_ONELEVEL is set in flags, then accept one-level 386 * reference names. If REFNAME_REFSPEC_PATTERN is set in flags, then 387 * allow a single "*" wildcard character in the refspec. No leading or 388 * repeated slashes are accepted. 389 */ 390intcheck_refname_format(const char*refname,int flags); 391 392const char*prettify_refname(const char*refname); 393 394char*shorten_unambiguous_ref(const char*refname,int strict); 395 396/** rename ref, return 0 on success **/ 397intrefs_rename_ref(struct ref_store *refs,const char*oldref, 398const char*newref,const char*logmsg); 399intrename_ref(const char*oldref,const char*newref,const char*logmsg); 400 401intrefs_create_symref(struct ref_store *refs,const char*refname, 402const char*target,const char*logmsg); 403intcreate_symref(const char*refname,const char*target,const char*logmsg); 404 405/* 406 * Update HEAD of the specified gitdir. 407 * Similar to create_symref("relative-git-dir/HEAD", target, NULL), but 408 * this can update the main working tree's HEAD regardless of where 409 * $GIT_DIR points to. 410 * Return 0 if successful, non-zero otherwise. 411 * */ 412intset_worktree_head_symref(const char*gitdir,const char*target, 413const char*logmsg); 414 415enum action_on_err { 416 UPDATE_REFS_MSG_ON_ERR, 417 UPDATE_REFS_DIE_ON_ERR, 418 UPDATE_REFS_QUIET_ON_ERR 419}; 420 421/* 422 * Begin a reference transaction. The reference transaction must 423 * be freed by calling ref_transaction_free(). 424 */ 425struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs, 426struct strbuf *err); 427struct ref_transaction *ref_transaction_begin(struct strbuf *err); 428 429/* 430 * Reference transaction updates 431 * 432 * The following four functions add a reference check or update to a 433 * ref_transaction. They have some common similar parameters: 434 * 435 * transaction -- a pointer to an open ref_transaction, obtained 436 * from ref_transaction_begin(). 437 * 438 * refname -- the name of the reference to be affected. 439 * 440 * flags -- flags affecting the update, passed to 441 * update_ref_lock(). Can be REF_NODEREF, which means that 442 * symbolic references should not be followed. 443 * 444 * msg -- a message describing the change (for the reflog). 445 * 446 * err -- a strbuf for receiving a description of any error that 447 * might have occurred. 448 * 449 * The functions make internal copies of refname and msg, so the 450 * caller retains ownership of these parameters. 451 * 452 * The functions return 0 on success and non-zero on failure. A 453 * failure means that the transaction as a whole has failed and needs 454 * to be rolled back. 455 */ 456 457/* 458 * Add a reference update to transaction. new_sha1 is the value that 459 * the reference should have after the update, or null_sha1 if it 460 * should be deleted. If new_sha1 is NULL, then the reference is not 461 * changed at all. old_sha1 is the value that the reference must have 462 * before the update, or null_sha1 if it must not have existed 463 * beforehand. The old value is checked after the lock is taken to 464 * prevent races. If the old value doesn't agree with old_sha1, the 465 * whole transaction fails. If old_sha1 is NULL, then the previous 466 * value is not checked. 467 * 468 * See the above comment "Reference transaction updates" for more 469 * information. 470 */ 471intref_transaction_update(struct ref_transaction *transaction, 472const char*refname, 473const unsigned char*new_sha1, 474const unsigned char*old_sha1, 475unsigned int flags,const char*msg, 476struct strbuf *err); 477 478/* 479 * Add a reference creation to transaction. new_sha1 is the value that 480 * the reference should have after the update; it must not be 481 * null_sha1. It is verified that the reference does not exist 482 * already. 483 * 484 * See the above comment "Reference transaction updates" for more 485 * information. 486 */ 487intref_transaction_create(struct ref_transaction *transaction, 488const char*refname, 489const unsigned char*new_sha1, 490unsigned int flags,const char*msg, 491struct strbuf *err); 492 493/* 494 * Add a reference deletion to transaction. If old_sha1 is non-NULL, 495 * then it holds the value that the reference should have had before 496 * the update (which must not be null_sha1). 497 * 498 * See the above comment "Reference transaction updates" for more 499 * information. 500 */ 501intref_transaction_delete(struct ref_transaction *transaction, 502const char*refname, 503const unsigned char*old_sha1, 504unsigned int flags,const char*msg, 505struct strbuf *err); 506 507/* 508 * Verify, within a transaction, that refname has the value old_sha1, 509 * or, if old_sha1 is null_sha1, then verify that the reference 510 * doesn't exist. old_sha1 must be non-NULL. 511 * 512 * See the above comment "Reference transaction updates" for more 513 * information. 514 */ 515intref_transaction_verify(struct ref_transaction *transaction, 516const char*refname, 517const unsigned char*old_sha1, 518unsigned int flags, 519struct strbuf *err); 520 521/* 522 * Commit all of the changes that have been queued in transaction, as 523 * atomically as possible. 524 * 525 * Returns 0 for success, or one of the below error codes for errors. 526 */ 527/* Naming conflict (for example, the ref names A and A/B conflict). */ 528#define TRANSACTION_NAME_CONFLICT -1 529/* All other errors. */ 530#define TRANSACTION_GENERIC_ERROR -2 531intref_transaction_commit(struct ref_transaction *transaction, 532struct strbuf *err); 533 534/* 535 * Like ref_transaction_commit(), but optimized for creating 536 * references when originally initializing a repository (e.g., by "git 537 * clone"). It writes the new references directly to packed-refs 538 * without locking the individual references. 539 * 540 * It is a bug to call this function when there might be other 541 * processes accessing the repository or if there are existing 542 * references that might conflict with the ones being created. All 543 * old_sha1 values must either be absent or NULL_SHA1. 544 */ 545intinitial_ref_transaction_commit(struct ref_transaction *transaction, 546struct strbuf *err); 547 548/* 549 * Free an existing transaction and all associated data. 550 */ 551voidref_transaction_free(struct ref_transaction *transaction); 552 553/** 554 * Lock, update, and unlock a single reference. This function 555 * basically does a transaction containing a single call to 556 * ref_transaction_update(). The parameters to this function have the 557 * same meaning as the corresponding parameters to 558 * ref_transaction_update(). Handle errors as requested by the `onerr` 559 * argument. 560 */ 561intrefs_update_ref(struct ref_store *refs,const char*msg,const char*refname, 562const unsigned char*new_sha1,const unsigned char*old_sha1, 563unsigned int flags,enum action_on_err onerr); 564intupdate_ref(const char*msg,const char*refname, 565const unsigned char*new_sha1,const unsigned char*old_sha1, 566unsigned int flags,enum action_on_err onerr); 567intupdate_ref_oid(const char*msg,const char*refname, 568const struct object_id *new_oid,const struct object_id *old_oid, 569unsigned int flags,enum action_on_err onerr); 570 571intparse_hide_refs_config(const char*var,const char*value,const char*); 572 573/* 574 * Check whether a ref is hidden. If no namespace is set, both the first and 575 * the second parameter point to the full ref name. If a namespace is set and 576 * the ref is inside that namespace, the first parameter is a pointer to the 577 * name of the ref with the namespace prefix removed. If a namespace is set and 578 * the ref is outside that namespace, the first parameter is NULL. The second 579 * parameter always points to the full ref name. 580 */ 581intref_is_hidden(const char*,const char*); 582 583enum ref_type { 584 REF_TYPE_PER_WORKTREE, 585 REF_TYPE_PSEUDOREF, 586 REF_TYPE_NORMAL, 587}; 588 589enum ref_type ref_type(const char*refname); 590 591enum expire_reflog_flags { 592 EXPIRE_REFLOGS_DRY_RUN =1<<0, 593 EXPIRE_REFLOGS_UPDATE_REF =1<<1, 594 EXPIRE_REFLOGS_VERBOSE =1<<2, 595 EXPIRE_REFLOGS_REWRITE =1<<3 596}; 597 598/* 599 * The following interface is used for reflog expiration. The caller 600 * calls reflog_expire(), supplying it with three callback functions, 601 * of the following types. The callback functions define the 602 * expiration policy that is desired. 603 * 604 * reflog_expiry_prepare_fn -- Called once after the reference is 605 * locked. 606 * 607 * reflog_expiry_should_prune_fn -- Called once for each entry in the 608 * existing reflog. It should return true iff that entry should be 609 * pruned. 610 * 611 * reflog_expiry_cleanup_fn -- Called once before the reference is 612 * unlocked again. 613 */ 614typedefvoidreflog_expiry_prepare_fn(const char*refname, 615const unsigned char*sha1, 616void*cb_data); 617typedefintreflog_expiry_should_prune_fn(unsigned char*osha1, 618unsigned char*nsha1, 619const char*email, 620unsigned long timestamp,int tz, 621const char*message,void*cb_data); 622typedefvoidreflog_expiry_cleanup_fn(void*cb_data); 623 624/* 625 * Expire reflog entries for the specified reference. sha1 is the old 626 * value of the reference. flags is a combination of the constants in 627 * enum expire_reflog_flags. The three function pointers are described 628 * above. On success, return zero. 629 */ 630intrefs_reflog_expire(struct ref_store *refs, 631const char*refname, 632const unsigned char*sha1, 633unsigned int flags, 634 reflog_expiry_prepare_fn prepare_fn, 635 reflog_expiry_should_prune_fn should_prune_fn, 636 reflog_expiry_cleanup_fn cleanup_fn, 637void*policy_cb_data); 638intreflog_expire(const char*refname,const unsigned char*sha1, 639unsigned int flags, 640 reflog_expiry_prepare_fn prepare_fn, 641 reflog_expiry_should_prune_fn should_prune_fn, 642 reflog_expiry_cleanup_fn cleanup_fn, 643void*policy_cb_data); 644 645intref_storage_backend_exists(const char*name); 646 647struct ref_store *get_main_ref_store(void); 648/* 649 * Return the ref_store instance for the specified submodule. For the 650 * main repository, use submodule==NULL; such a call cannot fail. For 651 * a submodule, the submodule must exist and be a nonbare repository, 652 * otherwise return NULL. If the requested reference store has not yet 653 * been initialized, initialize it first. 654 * 655 * For backwards compatibility, submodule=="" is treated the same as 656 * submodule==NULL. 657 */ 658struct ref_store *get_submodule_ref_store(const char*submodule); 659 660#endif/* REFS_H */