2005-06-06 20:31:29 +00:00
|
|
|
#ifndef REFS_H
|
|
|
|
#define REFS_H
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
struct ref_lock {
|
Enable the packed refs file format
This actually "turns on" the packed ref file format, now that the
infrastructure to do so sanely exists (ie notably the change to make the
reference reading logic take refnames rather than pathnames to the loose
objects that no longer necessarily even exist).
In particular, when the ref lookup hits a refname that has no loose file
associated with it, it falls back on the packed-ref information. Also, the
ref-locking code, while still using a loose file for the locking itself
(and _creating_ a loose file for the new ref) no longer requires that the
old ref be in such an unpacked state.
Finally, this does a minimal hack to git-checkout.sh to rather than check
the ref-file directly, do a "git-rev-parse" on the "heads/$refname".
That's not really wonderful - we should rather really have a special
routine to verify the names as proper branch head names, but it is a
workable solution for now.
With this, I can literally do something like
git pack-refs
find .git/refs -type f -print0 | xargs -0 rm -f --
and the end result is a largely working repository (ie I've done two
commits - which creates _one_ unpacked ref file - done things like run
"gitk" and "git log" etc, and it all looks ok).
There are probably things missing, but I'm hoping that the missing things
are now of the "small and obvious" kind, and that somebody else might want
to start looking at this too. Hint hint ;)
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-14 17:14:47 +00:00
|
|
|
char *ref_name;
|
2007-01-26 22:26:06 +00:00
|
|
|
char *orig_ref_name;
|
2006-06-06 20:54:14 +00:00
|
|
|
struct lock_file *lk;
|
2006-05-17 09:55:02 +00:00
|
|
|
unsigned char old_sha1[20];
|
|
|
|
int lock_fd;
|
2006-05-19 07:29:05 +00:00
|
|
|
int force_write;
|
2006-05-17 09:55:02 +00:00
|
|
|
};
|
|
|
|
|
2014-04-16 22:26:44 +00:00
|
|
|
/*
|
|
|
|
* A ref_transaction represents a collection of ref updates
|
|
|
|
* that should succeed or fail together.
|
|
|
|
*
|
|
|
|
* Calling sequence
|
|
|
|
* ----------------
|
|
|
|
* - Allocate and initialize a `struct ref_transaction` by calling
|
|
|
|
* `ref_transaction_begin()`.
|
|
|
|
*
|
|
|
|
* - List intended ref updates by calling functions like
|
|
|
|
* `ref_transaction_update()` and `ref_transaction_create()`.
|
|
|
|
*
|
|
|
|
* - Call `ref_transaction_commit()` to execute the transaction.
|
|
|
|
* If this succeeds, the ref updates will have taken place and
|
|
|
|
* the transaction cannot be rolled back.
|
|
|
|
*
|
|
|
|
* - At any time call `ref_transaction_free()` to discard the
|
|
|
|
* transaction and free associated resources. In particular,
|
|
|
|
* this rolls back the transaction if it has not been
|
|
|
|
* successfully committed.
|
|
|
|
*
|
|
|
|
* Error handling
|
|
|
|
* --------------
|
|
|
|
*
|
|
|
|
* On error, transaction functions append a message about what
|
|
|
|
* went wrong to the 'err' argument. The message mentions what
|
|
|
|
* ref was being updated (if any) when the error occurred so it
|
|
|
|
* can be passed to 'die' or 'error' as-is.
|
|
|
|
*
|
|
|
|
* The message is appended to err without first clearing err.
|
|
|
|
* err will not be '\n' terminated.
|
|
|
|
*/
|
2014-04-07 13:48:10 +00:00
|
|
|
struct ref_transaction;
|
|
|
|
|
2013-04-14 12:54:16 +00:00
|
|
|
/*
|
|
|
|
* Bit values set in the flags argument passed to each_ref_fn():
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Reference is a symbolic reference. */
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISSYMREF 0x01
|
2013-04-14 12:54:16 +00:00
|
|
|
|
|
|
|
/* Reference is a packed reference. */
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISPACKED 0x02
|
2013-04-14 12:54:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reference cannot be resolved to an object name: dangling symbolic
|
refs.c: allow listing and deleting badly named refs
We currently do not handle badly named refs well:
$ cp .git/refs/heads/master .git/refs/heads/master.....@\*@\\.
$ git branch
fatal: Reference has invalid format: 'refs/heads/master.....@*@\.'
$ git branch -D master.....@\*@\\.
error: branch 'master.....@*@\.' not found.
Users cannot recover from a badly named ref without manually finding
and deleting the loose ref file or appropriate line in packed-refs.
Making that easier will make it easier to tweak the ref naming rules
in the future, for example to forbid shell metacharacters like '`'
and '"', without putting people in a state that is hard to get out of.
So allow "branch --list" to show these refs and allow "branch -d/-D"
and "update-ref -d" to delete them. Other commands (for example to
rename refs) will continue to not handle these refs but can be changed
in later patches.
Details:
In resolving functions, refuse to resolve refs that don't pass the
git-check-ref-format(1) check unless the new RESOLVE_REF_ALLOW_BAD_NAME
flag is passed. Even with RESOLVE_REF_ALLOW_BAD_NAME, refuse to
resolve refs that escape the refs/ directory and do not match the
pattern [A-Z_]* (think "HEAD" and "MERGE_HEAD").
In locking functions, refuse to act on badly named refs unless they
are being deleted and either are in the refs/ directory or match [A-Z_]*.
Just like other invalid refs, flag resolved, badly named refs with the
REF_ISBROKEN flag, treat them as resolving to null_sha1, and skip them
in all iteration functions except for for_each_rawref.
Flag badly named refs (but not symrefs pointing to badly named refs)
with a REF_BAD_NAME flag to make it easier for future callers to
notice and handle them specially. For example, in a later patch
for-each-ref will use this flag to detect refs whose names can confuse
callers parsing for-each-ref output.
In the transaction API, refuse to create or update badly named refs,
but allow deleting them (unless they try to escape refs/ and don't match
[A-Z_]*).
Signed-off-by: Ronnie Sahlberg <sahlberg@google.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-09-03 18:45:43 +00:00
|
|
|
* reference (directly or indirectly), corrupt reference file,
|
|
|
|
* reference exists but name is bad, or symbolic reference refers to
|
|
|
|
* ill-formatted reference name.
|
2013-04-14 12:54:16 +00:00
|
|
|
*/
|
2011-10-19 20:45:50 +00:00
|
|
|
#define REF_ISBROKEN 0x04
|
2006-11-22 07:36:35 +00:00
|
|
|
|
refs.c: allow listing and deleting badly named refs
We currently do not handle badly named refs well:
$ cp .git/refs/heads/master .git/refs/heads/master.....@\*@\\.
$ git branch
fatal: Reference has invalid format: 'refs/heads/master.....@*@\.'
$ git branch -D master.....@\*@\\.
error: branch 'master.....@*@\.' not found.
Users cannot recover from a badly named ref without manually finding
and deleting the loose ref file or appropriate line in packed-refs.
Making that easier will make it easier to tweak the ref naming rules
in the future, for example to forbid shell metacharacters like '`'
and '"', without putting people in a state that is hard to get out of.
So allow "branch --list" to show these refs and allow "branch -d/-D"
and "update-ref -d" to delete them. Other commands (for example to
rename refs) will continue to not handle these refs but can be changed
in later patches.
Details:
In resolving functions, refuse to resolve refs that don't pass the
git-check-ref-format(1) check unless the new RESOLVE_REF_ALLOW_BAD_NAME
flag is passed. Even with RESOLVE_REF_ALLOW_BAD_NAME, refuse to
resolve refs that escape the refs/ directory and do not match the
pattern [A-Z_]* (think "HEAD" and "MERGE_HEAD").
In locking functions, refuse to act on badly named refs unless they
are being deleted and either are in the refs/ directory or match [A-Z_]*.
Just like other invalid refs, flag resolved, badly named refs with the
REF_ISBROKEN flag, treat them as resolving to null_sha1, and skip them
in all iteration functions except for for_each_rawref.
Flag badly named refs (but not symrefs pointing to badly named refs)
with a REF_BAD_NAME flag to make it easier for future callers to
notice and handle them specially. For example, in a later patch
for-each-ref will use this flag to detect refs whose names can confuse
callers parsing for-each-ref output.
In the transaction API, refuse to create or update badly named refs,
but allow deleting them (unless they try to escape refs/ and don't match
[A-Z_]*).
Signed-off-by: Ronnie Sahlberg <sahlberg@google.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-09-03 18:45:43 +00:00
|
|
|
/*
|
|
|
|
* Reference name is not well formed.
|
|
|
|
*
|
|
|
|
* See git-check-ref-format(1) for the definition of well formed ref names.
|
|
|
|
*/
|
|
|
|
#define REF_BAD_NAME 0x08
|
|
|
|
|
2005-07-03 03:23:36 +00:00
|
|
|
/*
|
2013-05-25 09:08:24 +00:00
|
|
|
* The signature for the callback function for the for_each_*()
|
|
|
|
* functions below. The memory pointed to by the refname and sha1
|
|
|
|
* arguments is only guaranteed to be valid for the duration of a
|
|
|
|
* single callback invocation.
|
|
|
|
*/
|
|
|
|
typedef int each_ref_fn(const char *refname,
|
|
|
|
const unsigned char *sha1, int flags, void *cb_data);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following functions invoke the specified callback function for
|
|
|
|
* each reference indicated. If the function ever returns a nonzero
|
|
|
|
* value, stop the iteration and return that value. Please note that
|
|
|
|
* it is not safe to modify references while an iteration is in
|
|
|
|
* progress, unless the same callback function invocation that
|
|
|
|
* modifies the reference also returns a nonzero value to immediately
|
|
|
|
* stop the iteration.
|
2005-07-03 03:23:36 +00:00
|
|
|
*/
|
2006-09-21 04:47:42 +00:00
|
|
|
extern int head_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_ref(each_ref_fn, void *);
|
2009-03-30 03:07:15 +00:00
|
|
|
extern int for_each_ref_in(const char *, each_ref_fn, void *);
|
2006-09-21 04:47:42 +00:00
|
|
|
extern int for_each_tag_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_branch_ref(each_ref_fn, void *);
|
|
|
|
extern int for_each_remote_ref(each_ref_fn, void *);
|
2009-01-23 09:06:38 +00:00
|
|
|
extern int for_each_replace_ref(each_ref_fn, void *);
|
2010-01-20 09:48:25 +00:00
|
|
|
extern int for_each_glob_ref(each_ref_fn, const char *pattern, void *);
|
2010-01-20 09:48:26 +00:00
|
|
|
extern int for_each_glob_ref_in(each_ref_fn, const char *pattern, const char* prefix, void *);
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
extern int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data);
|
|
|
|
|
ref namespaces: infrastructure
Add support for dividing the refs of a single repository into multiple
namespaces, each of which can have its own branches, tags, and HEAD.
Git can expose each namespace as an independent repository to pull from
and push to, while sharing the object store, and exposing all the refs
to operations such as git-gc.
Storing multiple repositories as namespaces of a single repository
avoids storing duplicate copies of the same objects, such as when
storing multiple branches of the same source. The alternates mechanism
provides similar support for avoiding duplicates, but alternates do not
prevent duplication between new objects added to the repositories
without ongoing maintenance, while namespaces do.
To specify a namespace, set the GIT_NAMESPACE environment variable to
the namespace. For each ref namespace, git stores the corresponding
refs in a directory under refs/namespaces/. For example,
GIT_NAMESPACE=foo will store refs under refs/namespaces/foo/. You can
also specify namespaces via the --namespace option to git.
Note that namespaces which include a / will expand to a hierarchy of
namespaces; for example, GIT_NAMESPACE=foo/bar will store refs under
refs/namespaces/foo/refs/namespaces/bar/. This makes paths in
GIT_NAMESPACE behave hierarchically, so that cloning with
GIT_NAMESPACE=foo/bar produces the same result as cloning with
GIT_NAMESPACE=foo and cloning from that repo with GIT_NAMESPACE=bar. It
also avoids ambiguity with strange namespace paths such as
foo/refs/heads/, which could otherwise generate directory/file conflicts
within the refs directory.
Add the infrastructure for ref namespaces: handle the GIT_NAMESPACE
environment variable and --namespace option, and support iterating over
refs in a namespace.
Signed-off-by: Josh Triplett <josh@joshtriplett.org>
Signed-off-by: Jamey Sharp <jamey@minilop.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-05 17:54:44 +00:00
|
|
|
extern int head_ref_namespaced(each_ref_fn fn, void *cb_data);
|
|
|
|
extern int for_each_namespaced_ref(each_ref_fn fn, void *cb_data);
|
|
|
|
|
2010-03-12 17:04:26 +00:00
|
|
|
static inline const char *has_glob_specials(const char *pattern)
|
|
|
|
{
|
|
|
|
return strpbrk(pattern, "?*[");
|
|
|
|
}
|
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
/* can be used to learn about broken ref and symref */
|
|
|
|
extern int for_each_rawref(each_ref_fn, void *);
|
|
|
|
|
2009-11-10 05:03:32 +00:00
|
|
|
extern void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname);
|
2014-08-31 20:11:31 +00:00
|
|
|
extern void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames);
|
2009-02-09 07:27:10 +00:00
|
|
|
|
2012-01-17 05:50:33 +00:00
|
|
|
/*
|
2013-06-20 08:37:46 +00:00
|
|
|
* Lock the packed-refs file for writing. Flags is passed to
|
|
|
|
* hold_lock_file_for_update(). Return 0 on success.
|
2014-06-20 14:42:48 +00:00
|
|
|
* Errno is set to something meaningful on error.
|
2013-06-20 08:37:46 +00:00
|
|
|
*/
|
|
|
|
extern int lock_packed_refs(int flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a reference to the in-memory packed reference cache. This may
|
|
|
|
* only be called while the packed-refs file is locked (see
|
|
|
|
* lock_packed_refs()). To actually write the packed-refs file, call
|
|
|
|
* commit_packed_refs().
|
2012-01-17 05:50:33 +00:00
|
|
|
*/
|
|
|
|
extern void add_packed_ref(const char *refname, const unsigned char *sha1);
|
|
|
|
|
2013-06-20 08:37:46 +00:00
|
|
|
/*
|
|
|
|
* Write the current version of the packed refs cache from memory to
|
|
|
|
* disk. The packed-refs file must already be locked for writing (see
|
|
|
|
* lock_packed_refs()). Return zero on success.
|
2014-06-20 14:42:53 +00:00
|
|
|
* Sets errno to something meaningful on error.
|
2013-06-20 08:37:46 +00:00
|
|
|
*/
|
|
|
|
extern int commit_packed_refs(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rollback the lockfile for the packed-refs file, and discard the
|
|
|
|
* in-memory packed reference cache. (The packed-refs file will be
|
|
|
|
* read anew if it is needed again after this function is called.)
|
|
|
|
*/
|
|
|
|
extern void rollback_packed_refs(void);
|
|
|
|
|
2013-04-22 19:52:32 +00:00
|
|
|
/*
|
|
|
|
* Flags for controlling behaviour of pack_refs()
|
|
|
|
* PACK_REFS_PRUNE: Prune loose refs after packing
|
|
|
|
* PACK_REFS_ALL: Pack _all_ refs, not just tags and already packed refs
|
|
|
|
*/
|
|
|
|
#define PACK_REFS_PRUNE 0x0001
|
|
|
|
#define PACK_REFS_ALL 0x0002
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write a packed-refs file for the current repository.
|
|
|
|
* flags: Combination of the above PACK_REFS_* flags.
|
|
|
|
*/
|
|
|
|
int pack_refs(unsigned int flags);
|
|
|
|
|
2014-06-20 14:42:49 +00:00
|
|
|
extern int repack_without_refs(const char **refnames, int n,
|
|
|
|
struct strbuf *err);
|
2014-05-23 10:29:45 +00:00
|
|
|
|
2011-10-10 22:56:19 +00:00
|
|
|
extern int ref_exists(const char *);
|
2008-04-27 17:39:24 +00:00
|
|
|
|
2014-07-15 23:02:38 +00:00
|
|
|
extern int is_branch(const char *refname);
|
|
|
|
|
2013-04-22 19:52:21 +00:00
|
|
|
/*
|
|
|
|
* If refname is a non-symbolic reference that refers to a tag object,
|
|
|
|
* and the tag can be (recursively) dereferenced to a non-tag object,
|
|
|
|
* store the SHA1 of the referred-to object to sha1 and return 0. If
|
|
|
|
* any of these conditions are not met, return a non-zero value.
|
|
|
|
* Symbolic references are considered unpeelable, even if they
|
|
|
|
* ultimately resolve to a peelable tag.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
extern int peel_ref(const char *refname, unsigned char *sha1);
|
2006-11-19 21:22:44 +00:00
|
|
|
|
2014-06-20 14:42:51 +00:00
|
|
|
/*
|
2014-04-30 16:03:36 +00:00
|
|
|
* Flags controlling lock_any_ref_for_update(), ref_transaction_update(),
|
|
|
|
* ref_transaction_create(), etc.
|
|
|
|
* REF_NODEREF: act on the ref directly, instead of dereferencing
|
|
|
|
* symbolic references.
|
2014-09-11 01:22:48 +00:00
|
|
|
* REF_DELETING: tolerate broken refs
|
2014-04-30 16:03:36 +00:00
|
|
|
*
|
|
|
|
* Flags >= 0x100 are reserved for internal use.
|
2014-06-20 14:42:51 +00:00
|
|
|
*/
|
2007-05-09 10:33:20 +00:00
|
|
|
#define REF_NODEREF 0x01
|
2014-09-11 01:22:48 +00:00
|
|
|
#define REF_DELETING 0x02
|
2014-04-30 16:03:36 +00:00
|
|
|
/*
|
|
|
|
* This function sets errno to something meaningful on failure.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
extern struct ref_lock *lock_any_ref_for_update(const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
2013-08-30 18:12:00 +00:00
|
|
|
int flags, int *type_p);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2008-02-22 18:57:30 +00:00
|
|
|
/** Close the file descriptor owned by a lock and return the status */
|
|
|
|
extern int close_ref(struct ref_lock *lock);
|
|
|
|
|
|
|
|
/** Close and commit the ref locked by the lock */
|
|
|
|
extern int commit_ref(struct ref_lock *lock);
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
/** Release any lock taken but not written. **/
|
2006-06-06 21:04:17 +00:00
|
|
|
extern void unlock_ref(struct ref_lock *lock);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2014-06-20 14:42:50 +00:00
|
|
|
/*
|
|
|
|
* Setup reflog before using. Set errno to something meaningful on failure.
|
|
|
|
*/
|
2014-11-30 08:24:28 +00:00
|
|
|
int log_ref_setup(const char *refname, struct strbuf *logfile);
|
2010-05-22 00:28:36 +00:00
|
|
|
|
2006-05-17 09:56:09 +00:00
|
|
|
/** Reads log for the value of ref during at_time. **/
|
2014-09-19 03:45:37 +00:00
|
|
|
extern int read_ref_at(const char *refname, unsigned int flags,
|
|
|
|
unsigned long at_time, int cnt,
|
2011-12-12 05:38:09 +00:00
|
|
|
unsigned char *sha1, char **msg,
|
|
|
|
unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt);
|
2006-05-17 09:56:09 +00:00
|
|
|
|
2014-05-06 22:45:52 +00:00
|
|
|
/** Check if a particular reflog exists */
|
|
|
|
extern int reflog_exists(const char *refname);
|
|
|
|
|
|
|
|
/** Delete a reflog */
|
|
|
|
extern int delete_reflog(const char *refname);
|
|
|
|
|
2006-12-18 09:18:16 +00:00
|
|
|
/* iterate over reflog entries */
|
2007-01-08 00:59:54 +00:00
|
|
|
typedef int each_reflog_ent_fn(unsigned char *osha1, unsigned char *nsha1, const char *, unsigned long, int, const char *, void *);
|
2011-12-12 05:38:09 +00:00
|
|
|
int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data);
|
2013-03-08 21:27:37 +00:00
|
|
|
int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data);
|
2006-12-18 09:18:16 +00:00
|
|
|
|
2007-02-03 18:25:43 +00:00
|
|
|
/*
|
|
|
|
* Calls the specified function for each reflog file until it returns nonzero,
|
|
|
|
* and returns the value
|
|
|
|
*/
|
|
|
|
extern int for_each_reflog(each_ref_fn, void *);
|
|
|
|
|
2011-09-15 21:10:25 +00:00
|
|
|
#define REFNAME_ALLOW_ONELEVEL 1
|
|
|
|
#define REFNAME_REFSPEC_PATTERN 2
|
|
|
|
|
|
|
|
/*
|
2011-12-12 05:38:09 +00:00
|
|
|
* Return 0 iff refname has the correct format for a refname according
|
|
|
|
* to the rules described in Documentation/git-check-ref-format.txt.
|
|
|
|
* If REFNAME_ALLOW_ONELEVEL is set in flags, then accept one-level
|
2011-09-15 21:10:25 +00:00
|
|
|
* reference names. If REFNAME_REFSPEC_PATTERN is set in flags, then
|
|
|
|
* allow a "*" wildcard character in place of one of the name
|
2014-09-26 19:22:22 +00:00
|
|
|
* components. No leading or repeated slashes are accepted.
|
2011-09-15 21:10:25 +00:00
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
extern int check_refname_format(const char *refname, int flags);
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2009-05-13 21:22:04 +00:00
|
|
|
extern const char *prettify_refname(const char *refname);
|
2011-12-12 05:38:09 +00:00
|
|
|
extern char *shorten_unambiguous_ref(const char *refname, int strict);
|
2009-03-09 01:06:05 +00:00
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
/** rename ref, return 0 on success **/
|
2006-11-30 02:16:56 +00:00
|
|
|
extern int rename_ref(const char *oldref, const char *newref, const char *logmsg);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2011-12-12 05:38:18 +00:00
|
|
|
/**
|
|
|
|
* Resolve refname in the nested "gitlink" repository that is located
|
|
|
|
* at path. If the resolution is successful, return 0 and set sha1 to
|
|
|
|
* the name of the object; otherwise, return a non-zero value.
|
|
|
|
*/
|
|
|
|
extern int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1);
|
2007-04-10 04:14:26 +00:00
|
|
|
|
2014-04-07 13:47:56 +00:00
|
|
|
enum action_on_err {
|
|
|
|
UPDATE_REFS_MSG_ON_ERR,
|
|
|
|
UPDATE_REFS_DIE_ON_ERR,
|
|
|
|
UPDATE_REFS_QUIET_ON_ERR
|
|
|
|
};
|
|
|
|
|
2014-04-07 13:48:10 +00:00
|
|
|
/*
|
|
|
|
* Begin a reference transaction. The reference transaction must
|
2014-06-20 14:42:43 +00:00
|
|
|
* be freed by calling ref_transaction_free().
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-05-19 17:42:34 +00:00
|
|
|
struct ref_transaction *ref_transaction_begin(struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The following functions add a reference check or update to a
|
|
|
|
* ref_transaction. In all of them, refname is the name of the
|
|
|
|
* reference to be affected. The functions make internal copies of
|
2014-04-30 19:22:42 +00:00
|
|
|
* refname and msg, so the caller retains ownership of these parameters.
|
|
|
|
* flags can be REF_NODEREF; it is passed to update_ref_lock().
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a reference update to transaction. new_sha1 is the value that
|
|
|
|
* the reference should have after the update, or zeros if it should
|
|
|
|
* be deleted. If have_old is true, then old_sha1 holds the value
|
|
|
|
* that the reference should have had before the update, or zeros if
|
|
|
|
* it must not have existed beforehand.
|
2014-06-20 14:43:00 +00:00
|
|
|
* Function returns 0 on success and non-zero on failure. A failure to update
|
|
|
|
* means that the transaction as a whole has failed and will need to be
|
2014-04-16 22:26:44 +00:00
|
|
|
* rolled back.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-06-20 14:43:00 +00:00
|
|
|
int ref_transaction_update(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *new_sha1,
|
|
|
|
const unsigned char *old_sha1,
|
2014-04-30 19:22:42 +00:00
|
|
|
int flags, int have_old, const char *msg,
|
2014-06-20 14:43:00 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a reference creation to transaction. new_sha1 is the value
|
|
|
|
* that the reference should have after the update; it must not be the
|
|
|
|
* null SHA-1. It is verified that the reference does not exist
|
|
|
|
* already.
|
2014-04-16 22:26:44 +00:00
|
|
|
* Function returns 0 on success and non-zero on failure. A failure to create
|
|
|
|
* means that the transaction as a whole has failed and will need to be
|
|
|
|
* rolled back.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-04-16 22:26:44 +00:00
|
|
|
int ref_transaction_create(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *new_sha1,
|
2014-04-30 19:22:42 +00:00
|
|
|
int flags, const char *msg,
|
2014-04-16 22:26:44 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a reference deletion to transaction. If have_old is true, then
|
|
|
|
* old_sha1 holds the value that the reference should have had before
|
|
|
|
* the update (which must not be the null SHA-1).
|
2014-04-16 22:27:45 +00:00
|
|
|
* Function returns 0 on success and non-zero on failure. A failure to delete
|
|
|
|
* means that the transaction as a whole has failed and will need to be
|
|
|
|
* rolled back.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-04-16 22:27:45 +00:00
|
|
|
int ref_transaction_delete(struct ref_transaction *transaction,
|
|
|
|
const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
2014-04-30 19:22:42 +00:00
|
|
|
int flags, int have_old, const char *msg,
|
2014-04-16 22:27:45 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit all of the changes that have been queued in transaction, as
|
2014-05-16 21:14:38 +00:00
|
|
|
* atomically as possible.
|
|
|
|
*
|
|
|
|
* Returns 0 for success, or one of the below error codes for errors.
|
2014-04-07 13:48:10 +00:00
|
|
|
*/
|
2014-05-16 21:14:38 +00:00
|
|
|
/* Naming conflict (for example, the ref names A and A/B conflict). */
|
|
|
|
#define TRANSACTION_NAME_CONFLICT -1
|
|
|
|
/* All other errors. */
|
|
|
|
#define TRANSACTION_GENERIC_ERROR -2
|
2014-04-07 13:48:10 +00:00
|
|
|
int ref_transaction_commit(struct ref_transaction *transaction,
|
2014-04-30 19:22:42 +00:00
|
|
|
struct strbuf *err);
|
2014-04-07 13:48:10 +00:00
|
|
|
|
2014-06-20 14:42:42 +00:00
|
|
|
/*
|
|
|
|
* Free an existing transaction and all associated data.
|
|
|
|
*/
|
|
|
|
void ref_transaction_free(struct ref_transaction *transaction);
|
|
|
|
|
2014-04-07 13:47:56 +00:00
|
|
|
/** Lock a ref and then write its file */
|
2007-09-05 01:38:24 +00:00
|
|
|
int update_ref(const char *action, const char *refname,
|
|
|
|
const unsigned char *sha1, const unsigned char *oldval,
|
|
|
|
int flags, enum action_on_err onerr);
|
|
|
|
|
upload/receive-pack: allow hiding ref hierarchies
A repository may have refs that are only used for its internal
bookkeeping purposes that should not be exposed to the others that
come over the network.
Teach upload-pack to omit some refs from its initial advertisement
by paying attention to the uploadpack.hiderefs multi-valued
configuration variable. Do the same to receive-pack via the
receive.hiderefs variable. As a convenient short-hand, allow using
transfer.hiderefs to set the value to both of these variables.
Any ref that is under the hierarchies listed on the value of these
variable is excluded from responses to requests made by "ls-remote",
"fetch", etc. (for upload-pack) and "push" (for receive-pack).
Because these hidden refs do not count as OUR_REF, an attempt to
fetch objects at the tip of them will be rejected, and because these
refs do not get advertised, "git push :" will not see local branches
that have the same name as them as "matching" ones to be sent.
An attempt to update/delete these hidden refs with an explicit
refspec, e.g. "git push origin :refs/hidden/22", is rejected. This
is not a new restriction. To the pusher, it would appear that there
is no such ref, so its push request will conclude with "Now that I
sent you all the data, it is time for you to update the refs. I saw
that the ref did not exist when I started pushing, and I want the
result to point at this commit". The receiving end will apply the
compare-and-swap rule to this request and rejects the push with
"Well, your update request conflicts with somebody else; I see there
is such a ref.", which is the right thing to do. Otherwise a push to
a hidden ref will always be "the last one wins", which is not a good
default.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-19 00:08:30 +00:00
|
|
|
extern int parse_hide_refs_config(const char *var, const char *value, const char *);
|
|
|
|
extern int ref_is_hidden(const char *);
|
|
|
|
|
2005-06-06 20:31:29 +00:00
|
|
|
#endif /* REFS_H */
|