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