blob: c7dded35f47e0c30131839b3378100e5a778476c [file] [log] [blame]
* Data structures and functions for the internal use of the refs
* module. Code outside of the refs module should use only the public
* functions defined in "refs.h", and should *not* include this file.
* Flag passed to lock_ref_sha1_basic() telling it to tolerate broken
* refs (i.e., because the reference is about to be deleted anyway).
#define REF_DELETING 0x02
* Used as a flag in ref_update::flags when a loose ref is being
* pruned.
#define REF_ISPRUNING 0x04
* Used as a flag in ref_update::flags when the reference should be
* updated to new_sha1.
#define REF_HAVE_NEW 0x08
* Used as a flag in ref_update::flags when old_sha1 should be
* checked.
#define REF_HAVE_OLD 0x10
* Used as a flag in ref_update::flags when the lockfile needs to be
* committed.
#define REF_NEEDS_COMMIT 0x20
* 0x40 is REF_FORCE_CREATE_REFLOG, so skip it if you're adding a
* value to ref_update::flags
* Return true iff refname is minimally safe. "Safe" here means that
* deleting a loose reference by this name will not do any damage, for
* example by causing a file that is not a reference to be deleted.
* This function does not check that the reference name is legal; for
* that, use check_refname_format().
* We consider a refname that starts with "refs/" to be safe as long
* as any ".." components that it might contain do not escape "refs/".
* Names that do not start with "refs/" are considered safe iff they
* consist entirely of upper case characters and '_' (like "HEAD" and
* "MERGE_HEAD" but not "config" or "FOO/BAR").
int refname_is_safe(const char *refname);
enum peel_status {
/* object was peeled successfully: */
* object cannot be peeled because the named object (or an
* object referred to by a tag in the peel chain), does not
* exist.
/* object cannot be peeled because it is not a tag: */
/* ref_entry contains no peeled value because it is a symref: */
* ref_entry cannot be peeled because it is broken (i.e., the
* symbolic reference cannot even be resolved to an object
* name):
* Peel the named object; i.e., if the object is a tag, resolve the
* tag recursively until a non-tag is found. If successful, store the
* result to sha1 and return PEEL_PEELED. If the object is not a tag
* or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
* and leave sha1 unchanged.
enum peel_status peel_object(const unsigned char *name, unsigned char *sha1);
* Return 0 if a reference named refname could be created without
* conflicting with the name of an existing reference. Otherwise,
* return a negative value and write an explanation to err. If extras
* is non-NULL, it is a list of additional refnames with which refname
* is not allowed to conflict. If skip is non-NULL, ignore potential
* conflicts with refs in skip (e.g., because they are scheduled for
* deletion in the same operation). Behavior is undefined if the same
* name is listed in both extras and skip.
* Two reference names conflict if one of them exactly matches the
* leading components of the other; e.g., "foo/bar" conflicts with
* both "foo" and with "foo/bar/baz" but not with "foo/bar" or
* "foo/barbados".
* extras and skip must be sorted.
int verify_refname_available(const char *newname,
struct string_list *extras,
struct string_list *skip,
struct strbuf *err);
* Copy the reflog message msg to buf, which has been allocated sufficiently
* large, while cleaning up the whitespaces. Especially, convert LF to space,
* because reflog file is one line per entry.
int copy_reflog_msg(char *buf, const char *msg);
int should_autocreate_reflog(const char *refname);
* Information needed for a single ref update. Set new_sha1 to the new
* value or to null_sha1 to delete the ref. To check the old value
* while the ref is locked, set (flags & REF_HAVE_OLD) and set
* old_sha1 to the old value, or to null_sha1 to ensure the ref does
* not exist before update.
struct ref_update {
* If (flags & REF_HAVE_NEW), set the reference to this value:
unsigned char new_sha1[20];
* If (flags & REF_HAVE_OLD), check that the reference
* previously had this value:
unsigned char old_sha1[20];
unsigned int flags;
struct ref_lock *lock;
int type;
char *msg;
const char refname[FLEX_ARRAY];
* Transaction states.
* OPEN: The transaction is in a valid state and can accept new updates.
* An OPEN transaction can be committed.
* CLOSED: A closed transaction is no longer active and no other operations
* than free can be used on it in this state.
* A transaction can either become closed by successfully committing
* an active transaction or if there is a failure while building
* the transaction thus rendering it failed/inactive.
enum ref_transaction_state {
* Data structure for holding a reference transaction, which can
* consist of checks and updates to multiple references, carried out
* as atomically as possible. This structure is opaque to callers.
struct ref_transaction {
struct ref_update **updates;
size_t alloc;
size_t nr;
enum ref_transaction_state state;
int files_log_ref_write(const char *refname, const unsigned char *old_sha1,
const unsigned char *new_sha1, const char *msg,
int flags, struct strbuf *err);
* Check for entries in extras that are within the specified
* directory, where dirname is a reference directory name including
* the trailing slash (e.g., "refs/heads/foo/"). Ignore any
* conflicting references that are found in skip. If there is a
* conflicting reference, return its name.
* extras and skip must be sorted lists of reference names. Either one
* can be NULL, signifying the empty list.
const char *find_descendant_ref(const char *dirname,
const struct string_list *extras,
const struct string_list *skip);
int rename_ref_available(const char *oldname, const char *newname);