216 lines
6.8 KiB
C
216 lines
6.8 KiB
C
#ifndef REFS_REFS_INTERNAL_H
|
|
#define REFS_REFS_INTERNAL_H
|
|
|
|
/*
|
|
* 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: */
|
|
PEEL_PEELED = 0,
|
|
|
|
/*
|
|
* object cannot be peeled because the named object (or an
|
|
* object referred to by a tag in the peel chain), does not
|
|
* exist.
|
|
*/
|
|
PEEL_INVALID = -1,
|
|
|
|
/* object cannot be peeled because it is not a tag: */
|
|
PEEL_NON_TAG = -2,
|
|
|
|
/* ref_entry contains no peeled value because it is a symref: */
|
|
PEEL_IS_SYMREF = -3,
|
|
|
|
/*
|
|
* ref_entry cannot be peeled because it is broken (i.e., the
|
|
* symbolic reference cannot even be resolved to an object
|
|
* name):
|
|
*/
|
|
PEEL_BROKEN = -4
|
|
};
|
|
|
|
/*
|
|
* 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];
|
|
/*
|
|
* One or more of REF_HAVE_NEW, REF_HAVE_OLD, REF_NODEREF,
|
|
* REF_DELETING, and REF_ISPRUNING:
|
|
*/
|
|
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 {
|
|
REF_TRANSACTION_OPEN = 0,
|
|
REF_TRANSACTION_CLOSED = 1
|
|
};
|
|
|
|
/*
|
|
* 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);
|
|
|
|
/* We allow "recursive" symbolic refs. Only within reason, though */
|
|
#define SYMREF_MAXDEPTH 5
|
|
|
|
/* Include broken references in a do_for_each_ref*() iteration: */
|
|
#define DO_FOR_EACH_INCLUDE_BROKEN 0x01
|
|
|
|
/*
|
|
* The common backend for the for_each_*ref* functions
|
|
*/
|
|
int do_for_each_ref(const char *submodule, const char *base,
|
|
each_ref_fn fn, int trim, int flags, void *cb_data);
|
|
|
|
int read_raw_ref(const char *refname, unsigned char *sha1,
|
|
struct strbuf *symref, unsigned int *flags);
|
|
|
|
#endif /* REFS_REFS_INTERNAL_H */
|