2005-06-06 20:31:29 +00:00
|
|
|
#include "cache.h"
|
2006-12-19 22:34:12 +00:00
|
|
|
#include "refs.h"
|
2006-11-19 21:22:44 +00:00
|
|
|
#include "object.h"
|
|
|
|
#include "tag.h"
|
2007-09-28 15:28:54 +00:00
|
|
|
#include "dir.h"
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2011-10-19 20:45:50 +00:00
|
|
|
/* ISSYMREF=0x01, ISPACKED=0x02 and ISBROKEN=0x04 are public interfaces */
|
|
|
|
#define REF_KNOWS_PEELED 0x10
|
2006-11-22 07:36:35 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_entry {
|
2006-11-22 07:36:35 +00:00
|
|
|
unsigned char flag; /* ISSYMREF? ISPACKED? */
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
unsigned char sha1[20];
|
2006-11-22 07:36:35 +00:00
|
|
|
unsigned char peeled[20];
|
2011-12-12 05:38:08 +00:00
|
|
|
/* The full name of the reference (e.g., "refs/heads/master"): */
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
char name[FLEX_ARRAY];
|
|
|
|
};
|
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_array {
|
|
|
|
int nr, alloc;
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Entries with index 0 <= i < sorted are sorted by name. New
|
|
|
|
* entries are appended to the list unsorted, and are sorted
|
|
|
|
* only when required; thus we avoid the need to sort the list
|
|
|
|
* after the addition of every reference.
|
|
|
|
*/
|
|
|
|
int sorted;
|
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_entry **refs;
|
|
|
|
};
|
|
|
|
|
2011-12-12 05:38:13 +00:00
|
|
|
/*
|
|
|
|
* Parse one line from a packed-refs file. Write the SHA1 to sha1.
|
|
|
|
* Return a pointer to the refname within the line (null-terminated),
|
|
|
|
* or NULL if there was a problem.
|
|
|
|
*/
|
2006-11-22 07:36:35 +00:00
|
|
|
static const char *parse_ref_line(char *line, unsigned char *sha1)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 42: the answer to everything.
|
|
|
|
*
|
|
|
|
* In this case, it happens to be the answer to
|
|
|
|
* 40 (length of sha1 hex representation)
|
|
|
|
* +1 (space in between hex and name)
|
|
|
|
* +1 (newline at the end of the line)
|
|
|
|
*/
|
|
|
|
int len = strlen(line) - 42;
|
|
|
|
|
|
|
|
if (len <= 0)
|
|
|
|
return NULL;
|
|
|
|
if (get_sha1_hex(line, sha1) < 0)
|
|
|
|
return NULL;
|
|
|
|
if (!isspace(line[40]))
|
|
|
|
return NULL;
|
|
|
|
line += 41;
|
2006-11-22 07:36:35 +00:00
|
|
|
if (isspace(*line))
|
|
|
|
return NULL;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (line[len] != '\n')
|
|
|
|
return NULL;
|
|
|
|
line[len] = 0;
|
2006-11-19 21:22:44 +00:00
|
|
|
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
return line;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:22 +00:00
|
|
|
static struct ref_entry *create_ref_entry(const char *refname,
|
|
|
|
const unsigned char *sha1, int flag,
|
|
|
|
int check_name)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
{
|
|
|
|
int len;
|
2011-12-12 05:38:22 +00:00
|
|
|
struct ref_entry *ref;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
2011-11-17 00:54:32 +00:00
|
|
|
if (check_name &&
|
2011-12-12 05:38:09 +00:00
|
|
|
check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
|
|
|
|
die("Reference has invalid format: '%s'", refname);
|
2011-12-12 05:38:22 +00:00
|
|
|
len = strlen(refname) + 1;
|
|
|
|
ref = xmalloc(sizeof(struct ref_entry) + len);
|
|
|
|
hashcpy(ref->sha1, sha1);
|
|
|
|
hashclr(ref->peeled);
|
|
|
|
memcpy(ref->name, refname, len);
|
|
|
|
ref->flag = flag;
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a ref_entry to the end of the ref_array (unsorted). */
|
2011-12-12 05:38:23 +00:00
|
|
|
static void add_ref(struct ref_array *refs, struct ref_entry *ref)
|
2011-12-12 05:38:22 +00:00
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
ALLOC_GROW(refs->refs, refs->nr + 1, refs->alloc);
|
2011-12-12 05:38:22 +00:00
|
|
|
refs->refs[refs->nr++] = ref;
|
2007-04-17 01:42:50 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
static int ref_entry_cmp(const void *a, const void *b)
|
2007-04-17 01:42:50 +00:00
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_entry *one = *(struct ref_entry **)a;
|
|
|
|
struct ref_entry *two = *(struct ref_entry **)b;
|
|
|
|
return strcmp(one->name, two->name);
|
|
|
|
}
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-12-12 05:38:15 +00:00
|
|
|
/*
|
|
|
|
* Emit a warning and return true iff ref1 and ref2 have the same name
|
|
|
|
* and the same sha1. Die if they have the same name but different
|
|
|
|
* sha1s.
|
|
|
|
*/
|
|
|
|
static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2)
|
|
|
|
{
|
|
|
|
if (!strcmp(ref1->name, ref2->name)) {
|
|
|
|
/* Duplicate name; make sure that the SHA1s match: */
|
|
|
|
if (hashcmp(ref1->sha1, ref2->sha1))
|
|
|
|
die("Duplicated ref, and SHA1s don't match: %s",
|
|
|
|
ref1->name);
|
|
|
|
warning("Duplicated ref: %s", ref1->name);
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
/*
|
|
|
|
* Sort the entries in array (if they are not already sorted).
|
|
|
|
*/
|
2011-09-29 22:11:42 +00:00
|
|
|
static void sort_ref_array(struct ref_array *array)
|
|
|
|
{
|
2011-12-12 05:38:15 +00:00
|
|
|
int i, j;
|
2007-04-17 01:42:50 +00:00
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
/*
|
|
|
|
* This check also prevents passing a zero-length array to qsort(),
|
|
|
|
* which is a problem on some platforms.
|
|
|
|
*/
|
|
|
|
if (array->sorted == array->nr)
|
2011-09-29 22:11:42 +00:00
|
|
|
return;
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
qsort(array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
/* Remove any duplicates from the ref_array */
|
2011-12-12 05:38:15 +00:00
|
|
|
i = 0;
|
|
|
|
for (j = 1; j < array->nr; j++) {
|
|
|
|
if (is_dup_ref(array->refs[i], array->refs[j])) {
|
|
|
|
free(array->refs[j]);
|
2011-09-29 22:11:42 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-12-12 05:38:15 +00:00
|
|
|
array->refs[++i] = array->refs[j];
|
2011-09-29 22:11:42 +00:00
|
|
|
}
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
array->sorted = array->nr = i + 1;
|
2011-09-29 22:11:42 +00:00
|
|
|
}
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
static struct ref_entry *search_ref_array(struct ref_array *array, const char *refname)
|
2011-09-29 22:11:42 +00:00
|
|
|
{
|
|
|
|
struct ref_entry *e, **r;
|
|
|
|
int len;
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (refname == NULL)
|
2011-09-29 22:11:42 +00:00
|
|
|
return NULL;
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-10-08 03:20:21 +00:00
|
|
|
if (!array->nr)
|
|
|
|
return NULL;
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
sort_ref_array(array);
|
2011-12-12 05:38:09 +00:00
|
|
|
len = strlen(refname) + 1;
|
2011-09-29 22:11:42 +00:00
|
|
|
e = xmalloc(sizeof(struct ref_entry) + len);
|
2011-12-12 05:38:09 +00:00
|
|
|
memcpy(e->name, refname, len);
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
r = bsearch(&e, array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
free(e);
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
if (r == NULL)
|
|
|
|
return NULL;
|
2007-04-17 01:42:50 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
return *r;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
|
|
|
|
2006-09-30 19:37:37 +00:00
|
|
|
/*
|
|
|
|
* Future: need to be in "struct repository"
|
|
|
|
* when doing a full libification.
|
|
|
|
*/
|
2011-10-17 02:38:05 +00:00
|
|
|
static struct ref_cache {
|
|
|
|
struct ref_cache *next;
|
2006-09-30 19:37:37 +00:00
|
|
|
char did_loose;
|
|
|
|
char did_packed;
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_array loose;
|
|
|
|
struct ref_array packed;
|
2011-08-12 22:36:28 +00:00
|
|
|
/* The submodule name, or "" for the main repo. */
|
|
|
|
char name[FLEX_ARRAY];
|
2011-10-17 02:38:05 +00:00
|
|
|
} *ref_cache;
|
2011-08-12 22:36:29 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
static struct ref_entry *current_ref;
|
2006-09-30 19:37:37 +00:00
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
/*
|
|
|
|
* Never call sort_ref_array() on the extra_refs, because it is
|
|
|
|
* allowed to contain entries with duplicate names.
|
|
|
|
*/
|
2011-09-29 22:11:42 +00:00
|
|
|
static struct ref_array extra_refs;
|
2008-04-27 17:39:24 +00:00
|
|
|
|
2011-12-12 05:38:11 +00:00
|
|
|
static void clear_ref_array(struct ref_array *array)
|
2006-09-30 19:37:37 +00:00
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < array->nr; i++)
|
|
|
|
free(array->refs[i]);
|
|
|
|
free(array->refs);
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
array->sorted = array->nr = array->alloc = 0;
|
2011-09-29 22:11:42 +00:00
|
|
|
array->refs = NULL;
|
2006-09-30 19:37:37 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 02:38:09 +00:00
|
|
|
static void clear_packed_ref_cache(struct ref_cache *refs)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
{
|
2011-10-17 02:38:08 +00:00
|
|
|
if (refs->did_packed)
|
2011-12-12 05:38:11 +00:00
|
|
|
clear_ref_array(&refs->packed);
|
2011-10-17 02:38:09 +00:00
|
|
|
refs->did_packed = 0;
|
2006-09-30 19:37:37 +00:00
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
2011-10-17 02:38:09 +00:00
|
|
|
static void clear_loose_ref_cache(struct ref_cache *refs)
|
|
|
|
{
|
|
|
|
if (refs->did_loose)
|
2011-12-12 05:38:11 +00:00
|
|
|
clear_ref_array(&refs->loose);
|
2011-10-17 02:38:09 +00:00
|
|
|
refs->did_loose = 0;
|
|
|
|
}
|
|
|
|
|
2011-10-17 02:38:05 +00:00
|
|
|
static struct ref_cache *create_ref_cache(const char *submodule)
|
2011-08-12 22:36:27 +00:00
|
|
|
{
|
2011-08-12 22:36:28 +00:00
|
|
|
int len;
|
2011-10-17 02:38:05 +00:00
|
|
|
struct ref_cache *refs;
|
2011-08-12 22:36:28 +00:00
|
|
|
if (!submodule)
|
|
|
|
submodule = "";
|
|
|
|
len = strlen(submodule) + 1;
|
2011-10-17 02:38:05 +00:00
|
|
|
refs = xcalloc(1, sizeof(struct ref_cache) + len);
|
2011-08-12 22:36:28 +00:00
|
|
|
memcpy(refs->name, submodule, len);
|
2011-08-12 22:36:27 +00:00
|
|
|
return refs;
|
|
|
|
}
|
|
|
|
|
2011-08-12 22:36:25 +00:00
|
|
|
/*
|
2011-10-17 02:38:05 +00:00
|
|
|
* Return a pointer to a ref_cache for the specified submodule. For
|
2011-08-12 22:36:25 +00:00
|
|
|
* the main repository, use submodule==NULL. The returned structure
|
|
|
|
* will be allocated and initialized but not necessarily populated; it
|
|
|
|
* should not be freed.
|
|
|
|
*/
|
2011-10-17 02:38:05 +00:00
|
|
|
static struct ref_cache *get_ref_cache(const char *submodule)
|
2011-08-12 22:36:25 +00:00
|
|
|
{
|
2011-10-17 02:38:05 +00:00
|
|
|
struct ref_cache *refs = ref_cache;
|
2011-08-12 22:36:29 +00:00
|
|
|
if (!submodule)
|
|
|
|
submodule = "";
|
|
|
|
while (refs) {
|
|
|
|
if (!strcmp(submodule, refs->name))
|
|
|
|
return refs;
|
|
|
|
refs = refs->next;
|
2011-08-12 22:36:25 +00:00
|
|
|
}
|
2011-08-12 22:36:29 +00:00
|
|
|
|
2011-10-17 02:38:05 +00:00
|
|
|
refs = create_ref_cache(submodule);
|
|
|
|
refs->next = ref_cache;
|
|
|
|
ref_cache = refs;
|
2011-08-12 22:36:29 +00:00
|
|
|
return refs;
|
2011-08-12 22:36:25 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 02:38:07 +00:00
|
|
|
void invalidate_ref_cache(const char *submodule)
|
2011-08-12 22:36:24 +00:00
|
|
|
{
|
2011-10-17 02:38:11 +00:00
|
|
|
struct ref_cache *refs = get_ref_cache(submodule);
|
|
|
|
clear_packed_ref_cache(refs);
|
|
|
|
clear_loose_ref_cache(refs);
|
2006-09-30 19:37:37 +00:00
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
2011-10-10 22:56:19 +00:00
|
|
|
static void read_packed_refs(FILE *f, struct ref_array *array)
|
2006-11-22 07:36:35 +00:00
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_entry *last = NULL;
|
2006-11-22 07:36:35 +00:00
|
|
|
char refline[PATH_MAX];
|
|
|
|
int flag = REF_ISPACKED;
|
|
|
|
|
|
|
|
while (fgets(refline, sizeof(refline), f)) {
|
|
|
|
unsigned char sha1[20];
|
2011-12-12 05:38:09 +00:00
|
|
|
const char *refname;
|
2006-11-22 07:36:35 +00:00
|
|
|
static const char header[] = "# pack-refs with:";
|
|
|
|
|
|
|
|
if (!strncmp(refline, header, sizeof(header)-1)) {
|
|
|
|
const char *traits = refline + sizeof(header) - 1;
|
|
|
|
if (strstr(traits, " peeled "))
|
|
|
|
flag |= REF_KNOWS_PEELED;
|
|
|
|
/* perhaps other traits later as well */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
refname = parse_ref_line(refline, sha1);
|
|
|
|
if (refname) {
|
2011-12-12 05:38:23 +00:00
|
|
|
last = create_ref_entry(refname, sha1, flag, 1);
|
|
|
|
add_ref(array, last);
|
2006-11-22 07:36:35 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (last &&
|
|
|
|
refline[0] == '^' &&
|
|
|
|
strlen(refline) == 42 &&
|
|
|
|
refline[41] == '\n' &&
|
|
|
|
!get_sha1_hex(refline + 1, sha1))
|
|
|
|
hashcpy(last->peeled, sha1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
void add_extra_ref(const char *refname, const unsigned char *sha1, int flag)
|
2008-04-27 17:39:24 +00:00
|
|
|
{
|
2011-12-12 05:38:23 +00:00
|
|
|
add_ref(&extra_refs, create_ref_entry(refname, sha1, flag, 0));
|
2008-04-27 17:39:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void clear_extra_refs(void)
|
|
|
|
{
|
2011-12-12 05:38:11 +00:00
|
|
|
clear_ref_array(&extra_refs);
|
2008-04-27 17:39:24 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
static struct ref_array *get_packed_refs(struct ref_cache *refs)
|
2006-09-30 19:37:37 +00:00
|
|
|
{
|
2011-08-12 22:36:25 +00:00
|
|
|
if (!refs->did_packed) {
|
|
|
|
const char *packed_refs_file;
|
|
|
|
FILE *f;
|
2010-07-07 13:39:11 +00:00
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
if (*refs->name)
|
|
|
|
packed_refs_file = git_path_submodule(refs->name, "packed-refs");
|
2011-08-12 22:36:25 +00:00
|
|
|
else
|
|
|
|
packed_refs_file = git_path("packed-refs");
|
|
|
|
f = fopen(packed_refs_file, "r");
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (f) {
|
2011-10-10 22:56:19 +00:00
|
|
|
read_packed_refs(f, &refs->packed);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
fclose(f);
|
|
|
|
}
|
2010-07-07 13:39:11 +00:00
|
|
|
refs->did_packed = 1;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
2011-09-29 22:11:42 +00:00
|
|
|
return &refs->packed;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
|
|
|
|
2012-01-17 05:50:33 +00:00
|
|
|
void add_packed_ref(const char *refname, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
add_ref(get_packed_refs(get_ref_cache(NULL)),
|
|
|
|
create_ref_entry(refname, sha1, REF_ISPACKED, 1));
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:17 +00:00
|
|
|
static void get_ref_dir(struct ref_cache *refs, const char *base,
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_array *array)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
{
|
2010-07-07 13:39:11 +00:00
|
|
|
DIR *dir;
|
|
|
|
const char *path;
|
|
|
|
|
2011-12-12 05:38:17 +00:00
|
|
|
if (*refs->name)
|
|
|
|
path = git_path_submodule(refs->name, "%s", base);
|
2010-07-07 13:39:11 +00:00
|
|
|
else
|
|
|
|
path = git_path("%s", base);
|
|
|
|
|
|
|
|
|
|
|
|
dir = opendir(path);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
|
|
|
if (dir) {
|
|
|
|
struct dirent *de;
|
|
|
|
int baselen = strlen(base);
|
2011-12-12 05:38:09 +00:00
|
|
|
char *refname = xmalloc(baselen + 257);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
memcpy(refname, base, baselen);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (baselen && base[baselen-1] != '/')
|
2011-12-12 05:38:09 +00:00
|
|
|
refname[baselen++] = '/';
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct stat st;
|
2006-09-21 05:02:01 +00:00
|
|
|
int flag;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
int namelen;
|
2010-07-07 13:39:11 +00:00
|
|
|
const char *refdir;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
|
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
namelen = strlen(de->d_name);
|
|
|
|
if (namelen > 255)
|
|
|
|
continue;
|
|
|
|
if (has_extension(de->d_name, ".lock"))
|
|
|
|
continue;
|
2011-12-12 05:38:09 +00:00
|
|
|
memcpy(refname + baselen, de->d_name, namelen+1);
|
2011-12-12 05:38:17 +00:00
|
|
|
refdir = *refs->name
|
|
|
|
? git_path_submodule(refs->name, "%s", refname)
|
2011-12-12 05:38:09 +00:00
|
|
|
: git_path("%s", refname);
|
2010-07-07 13:39:11 +00:00
|
|
|
if (stat(refdir, &st) < 0)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
continue;
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2011-12-12 05:38:17 +00:00
|
|
|
get_ref_dir(refs, refname, array);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-12-12 05:38:17 +00:00
|
|
|
if (*refs->name) {
|
2009-02-09 07:27:10 +00:00
|
|
|
hashclr(sha1);
|
2010-07-07 13:39:11 +00:00
|
|
|
flag = 0;
|
2011-12-12 05:38:17 +00:00
|
|
|
if (resolve_gitlink_ref(refs->name, refname, sha1) < 0) {
|
2010-07-07 13:39:11 +00:00
|
|
|
hashclr(sha1);
|
2011-10-19 20:45:50 +00:00
|
|
|
flag |= REF_ISBROKEN;
|
2010-07-07 13:39:11 +00:00
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
} else if (read_ref_full(refname, sha1, 1, &flag)) {
|
2011-11-17 00:54:32 +00:00
|
|
|
hashclr(sha1);
|
|
|
|
flag |= REF_ISBROKEN;
|
|
|
|
}
|
2011-12-12 05:38:23 +00:00
|
|
|
add_ref(array, create_ref_entry(refname, sha1, flag, 1));
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
free(refname);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
struct warn_if_dangling_data {
|
2009-11-10 05:03:32 +00:00
|
|
|
FILE *fp;
|
2009-02-09 07:27:10 +00:00
|
|
|
const char *refname;
|
|
|
|
const char *msg_fmt;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
|
|
|
|
int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct warn_if_dangling_data *d = cb_data;
|
|
|
|
const char *resolves_to;
|
|
|
|
unsigned char junk[20];
|
|
|
|
|
|
|
|
if (!(flags & REF_ISSYMREF))
|
|
|
|
return 0;
|
|
|
|
|
2011-12-12 11:20:32 +00:00
|
|
|
resolves_to = resolve_ref_unsafe(refname, junk, 0, NULL);
|
2009-02-09 07:27:10 +00:00
|
|
|
if (!resolves_to || strcmp(resolves_to, d->refname))
|
|
|
|
return 0;
|
|
|
|
|
2009-11-10 05:03:32 +00:00
|
|
|
fprintf(d->fp, d->msg_fmt, refname);
|
2009-02-09 07:27:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-10 05:03:32 +00:00
|
|
|
void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
|
2009-02-09 07:27:10 +00:00
|
|
|
{
|
2010-05-14 09:31:33 +00:00
|
|
|
struct warn_if_dangling_data data;
|
|
|
|
|
|
|
|
data.fp = fp;
|
|
|
|
data.refname = refname;
|
|
|
|
data.msg_fmt = msg_fmt;
|
2009-02-09 07:27:10 +00:00
|
|
|
for_each_rawref(warn_if_dangling_symref, &data);
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
static struct ref_array *get_loose_refs(struct ref_cache *refs)
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
{
|
2011-08-12 22:36:25 +00:00
|
|
|
if (!refs->did_loose) {
|
2011-12-12 05:38:17 +00:00
|
|
|
get_ref_dir(refs, "refs", &refs->loose);
|
2011-08-12 22:36:25 +00:00
|
|
|
refs->did_loose = 1;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
2011-10-10 22:56:19 +00:00
|
|
|
return &refs->loose;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
|
|
|
|
2005-09-25 16:59:37 +00:00
|
|
|
/* We allow "recursive" symbolic refs. Only within reason, though */
|
|
|
|
#define MAXDEPTH 5
|
2007-04-10 04:14:26 +00:00
|
|
|
#define MAXREFLEN (1024)
|
|
|
|
|
2011-10-17 18:43:30 +00:00
|
|
|
/*
|
|
|
|
* Called by resolve_gitlink_ref_recursive() after it failed to read
|
2011-12-12 05:38:19 +00:00
|
|
|
* from the loose refs in ref_cache refs. Find <refname> in the
|
|
|
|
* packed-refs file for the submodule.
|
2011-10-17 18:43:30 +00:00
|
|
|
*/
|
2011-12-12 05:38:19 +00:00
|
|
|
static int resolve_gitlink_packed_ref(struct ref_cache *refs,
|
2011-12-12 05:38:10 +00:00
|
|
|
const char *refname, unsigned char *sha1)
|
2007-04-10 04:14:26 +00:00
|
|
|
{
|
2011-10-10 22:56:19 +00:00
|
|
|
struct ref_entry *ref;
|
2011-12-12 05:38:19 +00:00
|
|
|
struct ref_array *array = get_packed_refs(refs);
|
2007-04-10 04:14:26 +00:00
|
|
|
|
2011-10-10 22:56:19 +00:00
|
|
|
ref = search_ref_array(array, refname);
|
2011-12-12 05:38:19 +00:00
|
|
|
if (ref == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
memcpy(sha1, ref->sha1, 20);
|
|
|
|
return 0;
|
2007-04-10 04:14:26 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:19 +00:00
|
|
|
static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
|
2011-12-12 05:38:10 +00:00
|
|
|
const char *refname, unsigned char *sha1,
|
2011-12-12 05:38:09 +00:00
|
|
|
int recursion)
|
2007-04-10 04:14:26 +00:00
|
|
|
{
|
2011-12-12 05:38:20 +00:00
|
|
|
int fd, len;
|
2007-04-10 04:14:26 +00:00
|
|
|
char buffer[128], *p;
|
2011-12-12 05:38:20 +00:00
|
|
|
char *path;
|
2007-04-10 04:14:26 +00:00
|
|
|
|
2011-12-12 05:38:20 +00:00
|
|
|
if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
|
2007-04-10 04:14:26 +00:00
|
|
|
return -1;
|
2011-12-12 05:38:20 +00:00
|
|
|
path = *refs->name
|
|
|
|
? git_path_submodule(refs->name, "%s", refname)
|
|
|
|
: git_path("%s", refname);
|
|
|
|
fd = open(path, O_RDONLY);
|
2007-04-10 04:14:26 +00:00
|
|
|
if (fd < 0)
|
2011-12-12 05:38:19 +00:00
|
|
|
return resolve_gitlink_packed_ref(refs, refname, sha1);
|
2007-04-10 04:14:26 +00:00
|
|
|
|
|
|
|
len = read(fd, buffer, sizeof(buffer)-1);
|
|
|
|
close(fd);
|
|
|
|
if (len < 0)
|
|
|
|
return -1;
|
|
|
|
while (len && isspace(buffer[len-1]))
|
|
|
|
len--;
|
|
|
|
buffer[len] = 0;
|
|
|
|
|
|
|
|
/* Was it a detached head or an old-fashioned symlink? */
|
2011-12-12 05:38:10 +00:00
|
|
|
if (!get_sha1_hex(buffer, sha1))
|
2007-04-10 04:14:26 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Symref? */
|
|
|
|
if (strncmp(buffer, "ref:", 4))
|
|
|
|
return -1;
|
|
|
|
p = buffer + 4;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
|
2011-12-12 05:38:20 +00:00
|
|
|
return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
|
2007-04-10 04:14:26 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:10 +00:00
|
|
|
int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
|
2007-04-10 04:14:26 +00:00
|
|
|
{
|
|
|
|
int len = strlen(path), retval;
|
2011-12-12 05:38:20 +00:00
|
|
|
char *submodule;
|
2011-12-12 05:38:19 +00:00
|
|
|
struct ref_cache *refs;
|
2007-04-10 04:14:26 +00:00
|
|
|
|
|
|
|
while (len && path[len-1] == '/')
|
|
|
|
len--;
|
|
|
|
if (!len)
|
|
|
|
return -1;
|
2011-12-12 05:38:19 +00:00
|
|
|
submodule = xstrndup(path, len);
|
|
|
|
refs = get_ref_cache(submodule);
|
|
|
|
free(submodule);
|
|
|
|
|
2011-12-12 05:38:20 +00:00
|
|
|
retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
|
2007-04-10 04:14:26 +00:00
|
|
|
return retval;
|
|
|
|
}
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2008-09-09 05:10:56 +00:00
|
|
|
/*
|
2011-09-15 21:10:35 +00:00
|
|
|
* Try to read ref from the packed references. On success, set sha1
|
|
|
|
* and return 0; otherwise, return -1.
|
2008-09-09 05:10:56 +00:00
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
static int get_packed_ref(const char *refname, unsigned char *sha1)
|
2011-09-15 21:10:35 +00:00
|
|
|
{
|
2011-12-12 05:38:16 +00:00
|
|
|
struct ref_array *packed = get_packed_refs(get_ref_cache(NULL));
|
2011-12-12 05:38:09 +00:00
|
|
|
struct ref_entry *entry = search_ref_array(packed, refname);
|
2011-10-10 22:56:19 +00:00
|
|
|
if (entry) {
|
|
|
|
hashcpy(sha1, entry->sha1);
|
|
|
|
return 0;
|
2011-09-15 21:10:35 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-12-20 21:25:53 +00:00
|
|
|
const char *resolve_ref_unsafe(const char *refname, unsigned char *sha1, int reading, int *flag)
|
2005-07-03 03:23:36 +00:00
|
|
|
{
|
2008-04-27 18:21:58 +00:00
|
|
|
int depth = MAXDEPTH;
|
|
|
|
ssize_t len;
|
2005-09-30 21:08:25 +00:00
|
|
|
char buffer[256];
|
2011-12-12 05:38:09 +00:00
|
|
|
static char refname_buffer[256];
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
if (flag)
|
|
|
|
*flag = 0;
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
2011-09-15 21:10:39 +00:00
|
|
|
return NULL;
|
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
for (;;) {
|
2011-10-19 20:55:49 +00:00
|
|
|
char path[PATH_MAX];
|
2005-09-30 21:08:25 +00:00
|
|
|
struct stat st;
|
|
|
|
char *buf;
|
|
|
|
int fd;
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
if (--depth < 0)
|
|
|
|
return NULL;
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
git_snpath(path, sizeof(path), "%s", refname);
|
2011-09-15 21:10:35 +00:00
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
if (lstat(path, &st) < 0) {
|
2011-09-15 21:10:35 +00:00
|
|
|
if (errno != ENOENT)
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
|
|
* The loose reference file does not exist;
|
|
|
|
* check for a packed reference.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
if (!get_packed_ref(refname, sha1)) {
|
2011-09-15 21:10:35 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISPACKED;
|
2011-12-12 05:38:09 +00:00
|
|
|
return refname;
|
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
|
|
|
}
|
2011-09-15 21:10:35 +00:00
|
|
|
/* The reference is not a packed reference, either. */
|
|
|
|
if (reading) {
|
2005-09-30 21:08:25 +00:00
|
|
|
return NULL;
|
2011-09-15 21:10:35 +00:00
|
|
|
} else {
|
|
|
|
hashclr(sha1);
|
2011-12-12 05:38:09 +00:00
|
|
|
return refname;
|
2011-09-15 21:10:35 +00:00
|
|
|
}
|
2005-09-30 21:08:25 +00:00
|
|
|
}
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
/* Follow "normalized" - ie "refs/.." symlinks by hand */
|
|
|
|
if (S_ISLNK(st.st_mode)) {
|
|
|
|
len = readlink(path, buffer, sizeof(buffer)-1);
|
2011-09-15 21:10:31 +00:00
|
|
|
if (len < 0)
|
|
|
|
return NULL;
|
2011-09-15 21:10:32 +00:00
|
|
|
buffer[len] = 0;
|
2011-09-15 21:10:33 +00:00
|
|
|
if (!prefixcmp(buffer, "refs/") &&
|
|
|
|
!check_refname_format(buffer, 0)) {
|
2011-12-12 05:38:09 +00:00
|
|
|
strcpy(refname_buffer, buffer);
|
|
|
|
refname = refname_buffer;
|
2006-09-21 05:02:01 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISSYMREF;
|
2005-09-30 21:08:25 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-09-25 16:59:37 +00:00
|
|
|
}
|
2005-09-30 21:08:25 +00:00
|
|
|
|
2006-10-02 17:23:53 +00:00
|
|
|
/* Is it a directory? */
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
errno = EISDIR;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
/*
|
|
|
|
* Anything else, just open it and try to use it as
|
|
|
|
* a ref
|
|
|
|
*/
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return NULL;
|
2007-01-08 15:58:08 +00:00
|
|
|
len = read_in_full(fd, buffer, sizeof(buffer)-1);
|
2005-09-30 21:08:25 +00:00
|
|
|
close(fd);
|
2011-09-15 21:10:34 +00:00
|
|
|
if (len < 0)
|
|
|
|
return NULL;
|
|
|
|
while (len && isspace(buffer[len-1]))
|
|
|
|
len--;
|
|
|
|
buffer[len] = '\0';
|
2005-09-30 21:08:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Is it a symbolic ref?
|
|
|
|
*/
|
2011-09-15 21:10:34 +00:00
|
|
|
if (prefixcmp(buffer, "ref:"))
|
2005-09-30 21:08:25 +00:00
|
|
|
break;
|
2011-10-19 20:55:49 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISSYMREF;
|
2005-09-30 21:08:25 +00:00
|
|
|
buf = buffer + 4;
|
2011-09-15 21:10:34 +00:00
|
|
|
while (isspace(*buf))
|
|
|
|
buf++;
|
2011-09-15 21:10:36 +00:00
|
|
|
if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
|
2011-10-19 20:55:49 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISBROKEN;
|
2011-09-15 21:10:36 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
refname = strcpy(refname_buffer, buf);
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
2011-09-15 21:10:41 +00:00
|
|
|
/* Please note that FETCH_HEAD has a second line containing other data. */
|
|
|
|
if (get_sha1_hex(buffer, sha1) || (buffer[40] != '\0' && !isspace(buffer[40]))) {
|
2011-10-19 20:55:49 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISBROKEN;
|
2005-09-30 21:08:25 +00:00
|
|
|
return NULL;
|
2011-09-15 21:10:40 +00:00
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
return refname;
|
2005-09-30 21:08:25 +00:00
|
|
|
}
|
|
|
|
|
2011-12-13 14:17:48 +00:00
|
|
|
char *resolve_refdup(const char *ref, unsigned char *sha1, int reading, int *flag)
|
|
|
|
{
|
2011-12-12 11:20:32 +00:00
|
|
|
const char *ret = resolve_ref_unsafe(ref, sha1, reading, flag);
|
2011-12-13 14:17:48 +00:00
|
|
|
return ret ? xstrdup(ret) : NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-20 09:48:25 +00:00
|
|
|
/* The argument to filter_refs */
|
|
|
|
struct ref_filter {
|
|
|
|
const char *pattern;
|
|
|
|
each_ref_fn *fn;
|
|
|
|
void *cb_data;
|
|
|
|
};
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int read_ref_full(const char *refname, unsigned char *sha1, int reading, int *flags)
|
2005-09-30 21:08:25 +00:00
|
|
|
{
|
2011-12-20 21:25:53 +00:00
|
|
|
if (resolve_ref_unsafe(refname, sha1, reading, flags))
|
2005-09-30 21:08:25 +00:00
|
|
|
return 0;
|
|
|
|
return -1;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int read_ref(const char *refname, unsigned char *sha1)
|
2011-11-13 10:22:14 +00:00
|
|
|
{
|
2011-12-12 05:38:09 +00:00
|
|
|
return read_ref_full(refname, sha1, 1, NULL);
|
2011-11-13 10:22:14 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
#define DO_FOR_EACH_INCLUDE_BROKEN 01
|
2006-11-19 06:13:33 +00:00
|
|
|
static int do_one_ref(const char *base, each_ref_fn fn, int trim,
|
2011-09-29 22:11:42 +00:00
|
|
|
int flags, void *cb_data, struct ref_entry *entry)
|
2006-11-19 06:13:33 +00:00
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
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:21 +00:00
|
|
|
if (prefixcmp(entry->name, base))
|
2006-11-19 06:13:33 +00:00
|
|
|
return 0;
|
2010-03-16 05:12:55 +00:00
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
|
2011-10-19 20:45:50 +00:00
|
|
|
if (entry->flag & REF_ISBROKEN)
|
|
|
|
return 0; /* ignore broken refs e.g. dangling symref */
|
2009-02-09 07:27:10 +00:00
|
|
|
if (!has_sha1_file(entry->sha1)) {
|
|
|
|
error("%s does not point to a valid object!", entry->name);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-11-19 06:13:33 +00:00
|
|
|
}
|
2008-02-24 08:07:22 +00:00
|
|
|
current_ref = entry;
|
2006-11-19 06:13:33 +00:00
|
|
|
return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:10 +00:00
|
|
|
static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
|
2011-12-12 05:38:09 +00:00
|
|
|
void *data)
|
2010-01-20 09:48:25 +00:00
|
|
|
{
|
|
|
|
struct ref_filter *filter = (struct ref_filter *)data;
|
2011-12-12 05:38:09 +00:00
|
|
|
if (fnmatch(filter->pattern, refname, 0))
|
2010-01-20 09:48:25 +00:00
|
|
|
return 0;
|
2011-12-12 05:38:10 +00:00
|
|
|
return filter->fn(refname, sha1, flags, filter->cb_data);
|
2010-01-20 09:48:25 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int peel_ref(const char *refname, unsigned char *sha1)
|
2006-11-19 21:22:44 +00:00
|
|
|
{
|
|
|
|
int flag;
|
|
|
|
unsigned char base[20];
|
|
|
|
struct object *o;
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (current_ref && (current_ref->name == refname
|
|
|
|
|| !strcmp(current_ref->name, refname))) {
|
2008-02-24 08:07:22 +00:00
|
|
|
if (current_ref->flag & REF_KNOWS_PEELED) {
|
|
|
|
hashcpy(sha1, current_ref->peeled);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
hashcpy(base, current_ref->sha1);
|
|
|
|
goto fallback;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (read_ref_full(refname, base, 1, &flag))
|
2006-11-19 21:22:44 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if ((flag & REF_ISPACKED)) {
|
2011-12-12 05:38:16 +00:00
|
|
|
struct ref_array *array = get_packed_refs(get_ref_cache(NULL));
|
2011-12-12 05:38:09 +00:00
|
|
|
struct ref_entry *r = search_ref_array(array, refname);
|
2006-11-19 21:22:44 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
if (r != NULL && r->flag & REF_KNOWS_PEELED) {
|
|
|
|
hashcpy(sha1, r->peeled);
|
|
|
|
return 0;
|
2006-11-19 21:22:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-24 08:07:22 +00:00
|
|
|
fallback:
|
2006-11-19 21:22:44 +00:00
|
|
|
o = parse_object(base);
|
2008-02-24 08:07:19 +00:00
|
|
|
if (o && o->type == OBJ_TAG) {
|
2011-12-12 05:38:09 +00:00
|
|
|
o = deref_tag(o, refname, 0);
|
2006-11-19 21:22:44 +00:00
|
|
|
if (o) {
|
|
|
|
hashcpy(sha1, o->sha1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:11 +00:00
|
|
|
static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn fn,
|
|
|
|
int trim, int flags, void *cb_data)
|
2005-07-03 03:23:36 +00:00
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
int retval = 0, i, p = 0, l = 0;
|
2011-12-12 05:38:16 +00:00
|
|
|
struct ref_cache *refs = get_ref_cache(submodule);
|
|
|
|
struct ref_array *packed = get_packed_refs(refs);
|
|
|
|
struct ref_array *loose = get_loose_refs(refs);
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_array *extra = &extra_refs;
|
2008-04-27 17:39:24 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
for (i = 0; i < extra->nr; i++)
|
|
|
|
retval = do_one_ref(base, fn, trim, flags, cb_data, extra->refs[i]);
|
2008-04-27 17:39:24 +00:00
|
|
|
|
ref_array: keep track of whether references are sorted
Keep track of how many entries at the beginning of a ref_array are already
sorted. In sort_ref_array(), return early if the the array is already
sorted (i.e., if no new references has been appended to the end of the
list since the last call to sort_ref_array()).
Sort ref_arrays only when needed, namely in search_ref_array() and in
do_for_each_ref(). However, never call sort_ref_array() on the
extra_refs, because extra_refs can contain multiple entries with the same
name and because sort_ref_array() not only sorts, but de-dups its
contents.
This change is currently not useful, because entries are not added to
ref_arrays after they are created. But in a moment they will be...
Implementation note: we could store a binary "sorted" value instead of
an integer, but storing the number of sorted entries leaves the way
open for a couple of possible future optimizations:
* In sort_ref_array(), sort *only* the unsorted entries, then merge
them with the sorted entries. This should be faster if most of the
entries are already sorted.
* Teach search_ref_array() to do a binary search of any sorted
entries, and if unsuccessful do a linear search of any unsorted
entries. This would avoid the need to sort the list every time that
search_ref_array() is called, and (given some intelligence about how
often to sort) could significantly improve the speed in certain
hypothetical usage patterns.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-01-17 05:50:32 +00:00
|
|
|
sort_ref_array(packed);
|
|
|
|
sort_ref_array(loose);
|
2011-09-29 22:11:42 +00:00
|
|
|
while (p < packed->nr && l < loose->nr) {
|
|
|
|
struct ref_entry *entry;
|
|
|
|
int cmp = strcmp(packed->refs[p]->name, loose->refs[l]->name);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (!cmp) {
|
2011-09-29 22:11:42 +00:00
|
|
|
p++;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
continue;
|
2005-07-04 22:28:19 +00:00
|
|
|
}
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (cmp > 0) {
|
2011-09-29 22:11:42 +00:00
|
|
|
entry = loose->refs[l++];
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
} else {
|
2011-09-29 22:11:42 +00:00
|
|
|
entry = packed->refs[p++];
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
2009-02-09 07:27:10 +00:00
|
|
|
retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
if (retval)
|
2008-02-24 08:07:22 +00:00
|
|
|
goto end_each;
|
Start handling references internally as a sorted in-memory list
This also adds some very rudimentary support for the notion of packed
refs. HOWEVER! At this point it isn't used to actually look up a ref
yet, only for listing them (ie "for_each_ref()" and friends see the
packed refs, but none of the other single-ref lookup routines).
Note how we keep two separate lists: one for the loose refs, and one for
the packed refs we read. That's so that we can easily keep the two apart,
and read only one set or the other (and still always make sure that the
loose refs take precedence).
[ From this, it's not actually obvious why we'd keep the two separate
lists, but it's important to have the packed refs on their own list
later on, when I add support for looking up a single loose one.
For that case, we will want to read _just_ the packed refs in case the
single-ref lookup fails, yet we may end up needing the other list at
some point in the future, so keeping them separated is important ]
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-09-11 23:37:32 +00:00
|
|
|
}
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
if (l < loose->nr) {
|
|
|
|
p = l;
|
|
|
|
packed = loose;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; p < packed->nr; p++) {
|
|
|
|
retval = do_one_ref(base, fn, trim, flags, cb_data, packed->refs[p]);
|
2006-11-19 06:13:33 +00:00
|
|
|
if (retval)
|
2008-02-24 08:07:22 +00:00
|
|
|
goto end_each;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
2008-02-24 08:07:22 +00:00
|
|
|
|
|
|
|
end_each:
|
|
|
|
current_ref = NULL;
|
|
|
|
return retval;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:11 +00:00
|
|
|
|
|
|
|
static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
|
2005-07-05 18:31:32 +00:00
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
2006-09-21 05:02:01 +00:00
|
|
|
int flag;
|
|
|
|
|
2010-07-07 13:39:11 +00:00
|
|
|
if (submodule) {
|
|
|
|
if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
|
|
|
|
return fn("HEAD", sha1, 0, cb_data);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-13 10:22:14 +00:00
|
|
|
if (!read_ref_full("HEAD", sha1, 1, &flag))
|
2006-09-21 05:02:01 +00:00
|
|
|
return fn("HEAD", sha1, flag, cb_data);
|
2010-07-07 13:39:11 +00:00
|
|
|
|
2005-07-05 22:45:00 +00:00
|
|
|
return 0;
|
2005-07-05 18:31:32 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:11 +00:00
|
|
|
int head_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_head_ref(NULL, fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_head_ref(submodule, fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
int for_each_ref(each_ref_fn fn, void *cb_data)
|
2005-07-03 03:23:36 +00:00
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
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:21 +00:00
|
|
|
return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
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:21 +00:00
|
|
|
return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
2009-03-30 03:07:15 +00:00
|
|
|
int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
2010-07-07 13:39:11 +00:00
|
|
|
return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
|
2009-03-30 03:07:15 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
|
|
|
each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
|
2009-03-30 03:07:15 +00:00
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
int for_each_tag_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 01:43:00 +00:00
|
|
|
{
|
2009-03-30 03:07:15 +00:00
|
|
|
return for_each_ref_in("refs/tags/", fn, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
int for_each_branch_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 01:43:00 +00:00
|
|
|
{
|
2009-03-30 03:07:15 +00:00
|
|
|
return for_each_ref_in("refs/heads/", fn, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
int for_each_remote_ref(each_ref_fn fn, void *cb_data)
|
2006-05-14 01:43:00 +00:00
|
|
|
{
|
2009-03-30 03:07:15 +00:00
|
|
|
return for_each_ref_in("refs/remotes/", fn, cb_data);
|
2009-02-09 07:27:10 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:12 +00:00
|
|
|
int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2009-01-23 09:06:38 +00:00
|
|
|
int for_each_replace_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
2010-07-07 13:39:11 +00:00
|
|
|
return do_for_each_ref(NULL, "refs/replace/", fn, 13, 0, cb_data);
|
2009-01-23 09:06:38 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
int head_ref_namespaced(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret = 0;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%sHEAD", get_git_namespace());
|
2011-11-13 10:22:14 +00:00
|
|
|
if (!read_ref_full(buf.buf, sha1, 1, &flag))
|
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
|
|
|
ret = fn(buf.buf, sha1, flag, cb_data);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret;
|
|
|
|
strbuf_addf(&buf, "%srefs/", get_git_namespace());
|
|
|
|
ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-20 09:48:26 +00:00
|
|
|
int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
|
|
|
|
const char *prefix, void *cb_data)
|
2010-01-20 09:48:25 +00:00
|
|
|
{
|
|
|
|
struct strbuf real_pattern = STRBUF_INIT;
|
|
|
|
struct ref_filter filter;
|
|
|
|
int ret;
|
|
|
|
|
2010-01-20 09:48:26 +00:00
|
|
|
if (!prefix && prefixcmp(pattern, "refs/"))
|
2010-01-20 09:48:25 +00:00
|
|
|
strbuf_addstr(&real_pattern, "refs/");
|
2010-01-20 09:48:26 +00:00
|
|
|
else if (prefix)
|
|
|
|
strbuf_addstr(&real_pattern, prefix);
|
2010-01-20 09:48:25 +00:00
|
|
|
strbuf_addstr(&real_pattern, pattern);
|
|
|
|
|
2010-03-12 17:04:26 +00:00
|
|
|
if (!has_glob_specials(pattern)) {
|
2010-02-04 05:23:18 +00:00
|
|
|
/* Append implied '/' '*' if not present. */
|
2010-01-20 09:48:25 +00:00
|
|
|
if (real_pattern.buf[real_pattern.len - 1] != '/')
|
|
|
|
strbuf_addch(&real_pattern, '/');
|
|
|
|
/* No need to check for '*', there is none. */
|
|
|
|
strbuf_addch(&real_pattern, '*');
|
|
|
|
}
|
|
|
|
|
|
|
|
filter.pattern = real_pattern.buf;
|
|
|
|
filter.fn = fn;
|
|
|
|
filter.cb_data = cb_data;
|
|
|
|
ret = for_each_ref(filter_refs, &filter);
|
|
|
|
|
|
|
|
strbuf_release(&real_pattern);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-20 09:48:26 +00:00
|
|
|
int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
|
|
|
|
{
|
|
|
|
return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
|
|
|
|
}
|
|
|
|
|
2009-02-09 07:27:10 +00:00
|
|
|
int for_each_rawref(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
Fix prefix handling in ref iteration functions
The do_for_each_ref iteration function accepts a prefix and a trim, and
checks for the prefix on each ref before passing in that ref; it also
supports trimming off part of the ref before passing it. However,
do_for_each_ref used trim as the length of the prefix to check, ignoring
the actual length of the prefix. Switch to using prefixcmp, checking
the entire length of the prefix string, to properly support a trim value
different than the length of the prefix.
Several callers passed a prefix of "refs/" to filter out everything
outside of refs/, but a trim of 0 to avoid trimming off the "refs/"; the
trim of 0 meant that the filter of "refs/" no longer applied. Change
these callers to pass an empty prefix instead, to avoid changing the
existing behavior. Various callers count on this lack of filtering,
such as receive-pack which uses add_extra_ref to add alternates as refs
named ".have"; adding filtering would break that, causing
t5501-fetch-push-alternates.sh to fail. That lack of filtering doesn't
currently have any other effect, since the loose ref functions can never
supply refs outside of "refs/", and packed-refs will not normally
include such refs unless manually edited.
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:21 +00:00
|
|
|
return do_for_each_ref(NULL, "", fn, 0,
|
2009-02-09 07:27:10 +00:00
|
|
|
DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2005-10-14 01:57:39 +00:00
|
|
|
/*
|
|
|
|
* Make sure "ref" is something reasonable to have under ".git/refs/";
|
|
|
|
* We do not like it if:
|
|
|
|
*
|
|
|
|
* - any path component of it begins with ".", or
|
|
|
|
* - it has double dots "..", or
|
|
|
|
* - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
|
|
|
|
* - it ends with a "/".
|
2009-03-24 23:31:01 +00:00
|
|
|
* - it ends with ".lock"
|
2009-05-08 05:32:37 +00:00
|
|
|
* - it contains a "\" (backslash)
|
2005-10-14 01:57:39 +00:00
|
|
|
*/
|
|
|
|
|
2011-09-15 21:10:24 +00:00
|
|
|
/* Return true iff ch is not allowed in reference names. */
|
2005-10-14 01:57:39 +00:00
|
|
|
static inline int bad_ref_char(int ch)
|
|
|
|
{
|
2011-08-27 04:12:44 +00:00
|
|
|
if (((unsigned) ch) <= ' ' || ch == 0x7f ||
|
2009-05-08 05:32:37 +00:00
|
|
|
ch == '~' || ch == '^' || ch == ':' || ch == '\\')
|
2007-05-25 05:20:56 +00:00
|
|
|
return 1;
|
|
|
|
/* 2.13 Pattern Matching Notation */
|
2011-09-15 21:10:24 +00:00
|
|
|
if (ch == '*' || ch == '?' || ch == '[') /* Unsupported */
|
2007-05-25 05:20:56 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
2005-10-14 01:57:39 +00:00
|
|
|
}
|
|
|
|
|
2011-09-15 21:10:26 +00:00
|
|
|
/*
|
2011-12-12 05:38:09 +00:00
|
|
|
* Try to read one refname component from the front of refname. Return
|
2011-09-15 21:10:26 +00:00
|
|
|
* the length of the component found, or -1 if the component is not
|
|
|
|
* legal.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
static int check_refname_component(const char *refname, int flags)
|
2005-06-06 20:31:29 +00:00
|
|
|
{
|
2011-09-15 21:10:26 +00:00
|
|
|
const char *cp;
|
|
|
|
char last = '\0';
|
2005-10-14 01:57:39 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
for (cp = refname; ; cp++) {
|
2011-09-15 21:10:26 +00:00
|
|
|
char ch = *cp;
|
|
|
|
if (ch == '\0' || ch == '/')
|
|
|
|
break;
|
|
|
|
if (bad_ref_char(ch))
|
|
|
|
return -1; /* Illegal character in refname. */
|
|
|
|
if (last == '.' && ch == '.')
|
|
|
|
return -1; /* Refname contains "..". */
|
|
|
|
if (last == '@' && ch == '{')
|
|
|
|
return -1; /* Refname contains "@{". */
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 20:27:31 +00:00
|
|
|
last = ch;
|
2011-09-15 21:10:26 +00:00
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
if (cp == refname)
|
2011-09-15 21:10:26 +00:00
|
|
|
return -1; /* Component has zero length. */
|
2011-12-12 05:38:09 +00:00
|
|
|
if (refname[0] == '.') {
|
2011-09-15 21:10:43 +00:00
|
|
|
if (!(flags & REFNAME_DOT_COMPONENT))
|
|
|
|
return -1; /* Component starts with '.'. */
|
|
|
|
/*
|
|
|
|
* Even if leading dots are allowed, don't allow "."
|
|
|
|
* as a component (".." is prevented by a rule above).
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
if (refname[1] == '\0')
|
2011-09-15 21:10:43 +00:00
|
|
|
return -1; /* Component equals ".". */
|
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
if (cp - refname >= 5 && !memcmp(cp - 5, ".lock", 5))
|
2011-09-15 21:10:27 +00:00
|
|
|
return -1; /* Refname ends with ".lock". */
|
2011-12-12 05:38:09 +00:00
|
|
|
return cp - refname;
|
2011-09-15 21:10:26 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int check_refname_format(const char *refname, int flags)
|
2005-06-06 20:31:29 +00:00
|
|
|
{
|
2011-09-15 21:10:26 +00:00
|
|
|
int component_len, component_count = 0;
|
2005-10-14 01:57:39 +00:00
|
|
|
|
|
|
|
while (1) {
|
2011-09-15 21:10:26 +00:00
|
|
|
/* We are at the start of a path component. */
|
2011-12-12 05:38:09 +00:00
|
|
|
component_len = check_refname_component(refname, flags);
|
2011-09-15 21:10:26 +00:00
|
|
|
if (component_len < 0) {
|
|
|
|
if ((flags & REFNAME_REFSPEC_PATTERN) &&
|
2011-12-12 05:38:09 +00:00
|
|
|
refname[0] == '*' &&
|
|
|
|
(refname[1] == '\0' || refname[1] == '/')) {
|
2011-09-15 21:10:25 +00:00
|
|
|
/* Accept one wildcard as a full refname component. */
|
|
|
|
flags &= ~REFNAME_REFSPEC_PATTERN;
|
2011-09-15 21:10:26 +00:00
|
|
|
component_len = 1;
|
|
|
|
} else {
|
2011-09-15 21:10:25 +00:00
|
|
|
return -1;
|
2011-09-15 21:10:26 +00:00
|
|
|
}
|
2005-10-14 01:57:39 +00:00
|
|
|
}
|
2011-09-15 21:10:26 +00:00
|
|
|
component_count++;
|
2011-12-12 05:38:09 +00:00
|
|
|
if (refname[component_len] == '\0')
|
2011-09-15 21:10:26 +00:00
|
|
|
break;
|
|
|
|
/* Skip to next component. */
|
2011-12-12 05:38:09 +00:00
|
|
|
refname += component_len + 1;
|
2005-10-14 01:57:39 +00:00
|
|
|
}
|
2011-09-15 21:10:26 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (refname[component_len - 1] == '.')
|
2011-09-15 21:10:26 +00:00
|
|
|
return -1; /* Refname ends with '.'. */
|
|
|
|
if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
|
|
|
|
return -1; /* Refname has only one component. */
|
|
|
|
return 0;
|
2005-06-06 20:31:29 +00:00
|
|
|
}
|
|
|
|
|
2009-05-13 21:22:04 +00:00
|
|
|
const char *prettify_refname(const char *name)
|
2009-03-09 01:06:05 +00:00
|
|
|
{
|
|
|
|
return name + (
|
|
|
|
!prefixcmp(name, "refs/heads/") ? 11 :
|
|
|
|
!prefixcmp(name, "refs/tags/") ? 10 :
|
|
|
|
!prefixcmp(name, "refs/remotes/") ? 13 :
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
add refname_match()
We use at least two rulesets for matching abbreviated refnames with
full refnames (starting with 'refs/'). git-rev-parse and git-fetch
use slightly different rules.
This commit introduces a new function refname_match
(const char *abbrev_name, const char *full_name, const char **rules).
abbrev_name is expanded using the rules and matched against full_name.
If a match is found the function returns true. rules is a NULL-terminate
list of format patterns with "%.*s", for example:
const char *ref_rev_parse_rules[] = {
"%.*s",
"refs/%.*s",
"refs/tags/%.*s",
"refs/heads/%.*s",
"refs/remotes/%.*s",
"refs/remotes/%.*s/HEAD",
NULL
};
Asterisks are included in the format strings because this is the form
required in sha1_name.c. Sharing the list with the functions there is
a good idea to avoid duplicating the rules. Hopefully this
facilitates unified matching rules in the future.
This commit makes the rules used by rev-parse for resolving refs to
sha1s available for string comparison. Before this change, the rules
were buried in get_sha1*() and dwim_ref().
A follow-up commit will refactor the rules used by fetch.
refname_match() will be used for matching refspecs in git-send-pack.
Thanks to Daniel Barkalow <barkalow@iabervon.org> for pointing
out that ref_matches_abbrev in remote.c solves a similar problem
and care should be taken to avoid confusion.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-11 14:01:46 +00:00
|
|
|
const char *ref_rev_parse_rules[] = {
|
|
|
|
"%.*s",
|
|
|
|
"refs/%.*s",
|
|
|
|
"refs/tags/%.*s",
|
|
|
|
"refs/heads/%.*s",
|
|
|
|
"refs/remotes/%.*s",
|
|
|
|
"refs/remotes/%.*s/HEAD",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
|
|
|
|
{
|
|
|
|
const char **p;
|
|
|
|
const int abbrev_name_len = strlen(abbrev_name);
|
|
|
|
|
|
|
|
for (p = rules; *p; p++) {
|
|
|
|
if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-06 21:04:17 +00:00
|
|
|
static struct ref_lock *verify_lock(struct ref_lock *lock,
|
2006-05-17 09:55:02 +00:00
|
|
|
const unsigned char *old_sha1, int mustexist)
|
|
|
|
{
|
2011-11-13 10:22:14 +00:00
|
|
|
if (read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
|
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
|
|
|
error("Can't verify ref %s", lock->ref_name);
|
2006-05-17 09:55:02 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-08-17 18:54:57 +00:00
|
|
|
if (hashcmp(lock->old_sha1, old_sha1)) {
|
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
|
|
|
error("Ref %s is at %s but expected %s", lock->ref_name,
|
2006-05-17 09:55:02 +00:00
|
|
|
sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
|
|
|
|
unlock_ref(lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return lock;
|
|
|
|
}
|
|
|
|
|
2007-09-28 15:28:54 +00:00
|
|
|
static int remove_empty_directories(const char *file)
|
2006-09-30 09:25:30 +00:00
|
|
|
{
|
|
|
|
/* we want to create a file but there is a directory there;
|
|
|
|
* if that is an empty directory (or a directory that contains
|
|
|
|
* only empty directories), remove them.
|
|
|
|
*/
|
2007-09-28 15:28:54 +00:00
|
|
|
struct strbuf path;
|
|
|
|
int result;
|
2006-09-30 09:25:30 +00:00
|
|
|
|
2007-09-28 15:28:54 +00:00
|
|
|
strbuf_init(&path, 20);
|
|
|
|
strbuf_addstr(&path, file);
|
|
|
|
|
2009-06-30 22:33:45 +00:00
|
|
|
result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
|
2007-09-28 15:28:54 +00:00
|
|
|
|
|
|
|
strbuf_release(&path);
|
|
|
|
|
|
|
|
return result;
|
2006-09-30 09:25:30 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:12 +00:00
|
|
|
/*
|
|
|
|
* Return true iff a reference named refname could be created without
|
|
|
|
* conflicting with the name of an existing reference. If oldrefname
|
|
|
|
* is non-NULL, ignore potential conflicts with oldrefname (e.g.,
|
|
|
|
* because oldrefname is scheduled for deletion in the same
|
|
|
|
* operation).
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
static int is_refname_available(const char *refname, const char *oldrefname,
|
2011-12-12 05:38:12 +00:00
|
|
|
struct ref_array *array)
|
2006-11-28 14:47:40 +00:00
|
|
|
{
|
2011-12-12 05:38:09 +00:00
|
|
|
int i, namlen = strlen(refname); /* e.g. 'foo/bar' */
|
2011-09-29 22:11:42 +00:00
|
|
|
for (i = 0; i < array->nr; i++ ) {
|
|
|
|
struct ref_entry *entry = array->refs[i];
|
|
|
|
/* entry->name could be 'foo' or 'foo/bar/baz' */
|
2011-12-12 05:38:09 +00:00
|
|
|
if (!oldrefname || strcmp(oldrefname, entry->name)) {
|
2011-09-29 22:11:42 +00:00
|
|
|
int len = strlen(entry->name);
|
2006-11-28 14:47:40 +00:00
|
|
|
int cmplen = (namlen < len) ? namlen : len;
|
2011-12-12 05:38:09 +00:00
|
|
|
const char *lead = (namlen < len) ? entry->name : refname;
|
|
|
|
if (!strncmp(refname, entry->name, cmplen) &&
|
2006-11-28 14:47:40 +00:00
|
|
|
lead[cmplen] == '/') {
|
2011-12-12 05:38:12 +00:00
|
|
|
error("'%s' exists; cannot create '%s'",
|
|
|
|
entry->name, refname);
|
2006-11-28 14:47:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-10-12 17:35:38 +00:00
|
|
|
/*
|
|
|
|
* *string and *len will only be substituted, and *string returned (for
|
|
|
|
* later free()ing) if the string passed in is a magic short-hand form
|
|
|
|
* to name a branch.
|
|
|
|
*/
|
|
|
|
static char *substitute_branch_name(const char **string, int *len)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret = interpret_branch_name(*string, &buf);
|
|
|
|
|
|
|
|
if (ret == *len) {
|
|
|
|
size_t size;
|
|
|
|
*string = strbuf_detach(&buf, &size);
|
|
|
|
*len = size;
|
|
|
|
return (char *)*string;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
|
|
|
|
{
|
|
|
|
char *last_branch = substitute_branch_name(&str, &len);
|
|
|
|
const char **p, *r;
|
|
|
|
int refs_found = 0;
|
|
|
|
|
|
|
|
*ref = NULL;
|
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
|
|
|
char fullref[PATH_MAX];
|
|
|
|
unsigned char sha1_from_ref[20];
|
|
|
|
unsigned char *this_result;
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
this_result = refs_found ? sha1_from_ref : sha1;
|
|
|
|
mksnpath(fullref, sizeof(fullref), *p, len, str);
|
2011-12-12 11:20:32 +00:00
|
|
|
r = resolve_ref_unsafe(fullref, this_result, 1, &flag);
|
2011-10-12 17:35:38 +00:00
|
|
|
if (r) {
|
|
|
|
if (!refs_found++)
|
|
|
|
*ref = xstrdup(r);
|
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
2011-10-19 20:55:49 +00:00
|
|
|
} else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
|
2011-10-12 17:35:38 +00:00
|
|
|
warning("ignoring dangling symref %s.", fullref);
|
2011-10-19 20:55:49 +00:00
|
|
|
} else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
|
|
|
|
warning("ignoring broken ref %s.", fullref);
|
|
|
|
}
|
2011-10-12 17:35:38 +00:00
|
|
|
}
|
|
|
|
free(last_branch);
|
|
|
|
return refs_found;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
|
|
|
|
{
|
|
|
|
char *last_branch = substitute_branch_name(&str, &len);
|
|
|
|
const char **p;
|
|
|
|
int logs_found = 0;
|
|
|
|
|
|
|
|
*log = NULL;
|
|
|
|
for (p = ref_rev_parse_rules; *p; p++) {
|
|
|
|
struct stat st;
|
|
|
|
unsigned char hash[20];
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *ref, *it;
|
|
|
|
|
|
|
|
mksnpath(path, sizeof(path), *p, len, str);
|
2011-12-12 11:20:32 +00:00
|
|
|
ref = resolve_ref_unsafe(path, hash, 1, NULL);
|
2011-10-12 17:35:38 +00:00
|
|
|
if (!ref)
|
|
|
|
continue;
|
|
|
|
if (!stat(git_path("logs/%s", path), &st) &&
|
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = path;
|
|
|
|
else if (strcmp(ref, path) &&
|
|
|
|
!stat(git_path("logs/%s", ref), &st) &&
|
|
|
|
S_ISREG(st.st_mode))
|
|
|
|
it = ref;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
if (!logs_found++) {
|
|
|
|
*log = xstrdup(it);
|
|
|
|
hashcpy(sha1, hash);
|
|
|
|
}
|
|
|
|
if (!warn_ambiguous_refs)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(last_branch);
|
|
|
|
return logs_found;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
static struct ref_lock *lock_ref_sha1_basic(const char *refname,
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
int flags, int *type_p)
|
2006-05-17 09:55:02 +00:00
|
|
|
{
|
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_file;
|
2011-12-12 05:38:09 +00:00
|
|
|
const char *orig_refname = refname;
|
2006-05-17 09:55:02 +00:00
|
|
|
struct ref_lock *lock;
|
2006-09-30 21:14:31 +00:00
|
|
|
int last_errno = 0;
|
2008-10-17 22:44:39 +00:00
|
|
|
int type, lflags;
|
2006-09-27 08:09:18 +00:00
|
|
|
int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
|
2008-11-05 20:55:53 +00:00
|
|
|
int missing = 0;
|
2006-05-17 09:55:02 +00:00
|
|
|
|
|
|
|
lock = xcalloc(1, sizeof(struct ref_lock));
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
|
2011-12-20 21:25:53 +00:00
|
|
|
refname = resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);
|
2011-12-12 05:38:09 +00:00
|
|
|
if (!refname && errno == EISDIR) {
|
2006-09-30 09:25:30 +00:00
|
|
|
/* we are trying to lock foo but we used to
|
|
|
|
* have foo/bar which now does not exist;
|
|
|
|
* it is normal for the empty directory 'foo'
|
|
|
|
* to remain.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
ref_file = git_path("%s", orig_refname);
|
2006-09-30 21:14:31 +00:00
|
|
|
if (remove_empty_directories(ref_file)) {
|
|
|
|
last_errno = errno;
|
2011-12-12 05:38:09 +00:00
|
|
|
error("there are still refs under '%s'", orig_refname);
|
2006-09-30 21:14:31 +00:00
|
|
|
goto error_return;
|
|
|
|
}
|
2011-12-20 21:25:53 +00:00
|
|
|
refname = resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);
|
2006-09-30 09:25:30 +00:00
|
|
|
}
|
2007-05-09 10:33:20 +00:00
|
|
|
if (type_p)
|
|
|
|
*type_p = type;
|
2011-12-12 05:38:09 +00:00
|
|
|
if (!refname) {
|
2006-09-30 21:14:31 +00:00
|
|
|
last_errno = errno;
|
2006-07-29 03:44:51 +00:00
|
|
|
error("unable to resolve reference %s: %s",
|
2011-12-12 05:38:09 +00:00
|
|
|
orig_refname, strerror(errno));
|
2006-09-30 21:14:31 +00:00
|
|
|
goto error_return;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
2008-11-05 20:55:53 +00:00
|
|
|
missing = is_null_sha1(lock->old_sha1);
|
2006-11-28 14:47:40 +00:00
|
|
|
/* When the ref did not exist and we are creating it,
|
|
|
|
* make sure there is no existing ref that is packed
|
|
|
|
* whose name begins with our refname, nor a ref whose
|
|
|
|
* name is a proper prefix of our refname.
|
|
|
|
*/
|
2008-11-05 20:55:53 +00:00
|
|
|
if (missing &&
|
2011-12-12 05:38:16 +00:00
|
|
|
!is_refname_available(refname, NULL, get_packed_refs(get_ref_cache(NULL)))) {
|
2009-05-25 10:37:15 +00:00
|
|
|
last_errno = ENOTDIR;
|
2006-11-28 14:47:40 +00:00
|
|
|
goto error_return;
|
2009-05-25 10:37:15 +00:00
|
|
|
}
|
2006-09-30 21:19:25 +00:00
|
|
|
|
2006-06-06 20:54:14 +00:00
|
|
|
lock->lk = xcalloc(1, sizeof(struct lock_file));
|
2006-05-17 09:55:02 +00:00
|
|
|
|
2008-10-17 22:44:39 +00:00
|
|
|
lflags = LOCK_DIE_ON_ERROR;
|
|
|
|
if (flags & REF_NODEREF) {
|
2011-12-12 05:38:09 +00:00
|
|
|
refname = orig_refname;
|
2008-10-17 22:44:39 +00:00
|
|
|
lflags |= LOCK_NODEREF;
|
|
|
|
}
|
2011-12-12 05:38:09 +00:00
|
|
|
lock->ref_name = xstrdup(refname);
|
|
|
|
lock->orig_ref_name = xstrdup(orig_refname);
|
|
|
|
ref_file = git_path("%s", refname);
|
2008-11-05 20:55:53 +00:00
|
|
|
if (missing)
|
2007-05-09 10:33:20 +00:00
|
|
|
lock->force_write = 1;
|
|
|
|
if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
|
|
|
|
lock->force_write = 1;
|
2006-05-17 09:55:02 +00:00
|
|
|
|
2006-09-30 21:14:31 +00:00
|
|
|
if (safe_create_leading_directories(ref_file)) {
|
|
|
|
last_errno = errno;
|
|
|
|
error("unable to create directory for %s", ref_file);
|
|
|
|
goto error_return;
|
|
|
|
}
|
2006-05-17 09:55:02 +00:00
|
|
|
|
2008-10-17 22:44:39 +00:00
|
|
|
lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
|
2006-05-17 09:55:02 +00:00
|
|
|
return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
|
2006-09-30 21:14:31 +00:00
|
|
|
|
|
|
|
error_return:
|
|
|
|
unlock_ref(lock);
|
|
|
|
errno = last_errno;
|
|
|
|
return NULL;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
struct ref_lock *lock_ref_sha1(const char *refname, const unsigned char *old_sha1)
|
2005-06-06 20:31:29 +00:00
|
|
|
{
|
2006-09-19 20:58:23 +00:00
|
|
|
char refpath[PATH_MAX];
|
2011-12-12 05:38:09 +00:00
|
|
|
if (check_refname_format(refname, 0))
|
2006-05-17 09:55:02 +00:00
|
|
|
return NULL;
|
2011-12-12 05:38:09 +00:00
|
|
|
strcpy(refpath, mkpath("refs/%s", refname));
|
2007-05-09 10:33:20 +00:00
|
|
|
return lock_ref_sha1_basic(refpath, old_sha1, 0, NULL);
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
struct ref_lock *lock_any_ref_for_update(const char *refname,
|
|
|
|
const unsigned char *old_sha1, int flags)
|
2006-05-17 09:55:02 +00:00
|
|
|
{
|
2011-12-12 05:38:09 +00:00
|
|
|
if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
|
2008-01-02 19:14:40 +00:00
|
|
|
return NULL;
|
2011-12-12 05:38:09 +00:00
|
|
|
return lock_ref_sha1_basic(refname, old_sha1, flags, NULL);
|
2006-09-30 22:02:00 +00:00
|
|
|
}
|
|
|
|
|
2006-10-01 18:41:00 +00:00
|
|
|
static struct lock_file packlock;
|
|
|
|
|
2006-09-30 22:02:00 +00:00
|
|
|
static int repack_without_ref(const char *refname)
|
|
|
|
{
|
2011-09-29 22:11:42 +00:00
|
|
|
struct ref_array *packed;
|
|
|
|
int fd, i;
|
2006-09-30 22:02:00 +00:00
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
packed = get_packed_refs(get_ref_cache(NULL));
|
2011-12-12 05:38:21 +00:00
|
|
|
if (search_ref_array(packed, refname) == NULL)
|
2006-09-30 22:02:00 +00:00
|
|
|
return 0;
|
|
|
|
fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
|
2009-09-26 23:15:09 +00:00
|
|
|
if (fd < 0) {
|
|
|
|
unable_to_lock_error(git_path("packed-refs"), errno);
|
2006-09-30 22:02:00 +00:00
|
|
|
return error("cannot delete '%s' from packed refs", refname);
|
2009-09-26 23:15:09 +00:00
|
|
|
}
|
2006-09-30 22:02:00 +00:00
|
|
|
|
2011-09-29 22:11:42 +00:00
|
|
|
for (i = 0; i < packed->nr; i++) {
|
2006-09-30 22:02:00 +00:00
|
|
|
char line[PATH_MAX + 100];
|
|
|
|
int len;
|
2011-12-12 05:38:21 +00:00
|
|
|
struct ref_entry *ref = packed->refs[i];
|
2011-09-29 22:11:42 +00:00
|
|
|
|
|
|
|
if (!strcmp(refname, ref->name))
|
2006-09-30 22:02:00 +00:00
|
|
|
continue;
|
|
|
|
len = snprintf(line, sizeof(line), "%s %s\n",
|
2011-09-29 22:11:42 +00:00
|
|
|
sha1_to_hex(ref->sha1), ref->name);
|
2006-09-30 22:02:00 +00:00
|
|
|
/* this should not happen but just being defensive */
|
|
|
|
if (len > sizeof(line))
|
2011-09-29 22:11:42 +00:00
|
|
|
die("too long a refname '%s'", ref->name);
|
2006-09-30 22:02:00 +00:00
|
|
|
write_or_die(fd, line, len);
|
|
|
|
}
|
|
|
|
return commit_lock_file(&packlock);
|
|
|
|
}
|
|
|
|
|
2008-10-26 02:33:56 +00:00
|
|
|
int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
|
2006-09-30 22:02:00 +00:00
|
|
|
{
|
|
|
|
struct ref_lock *lock;
|
2008-10-26 02:33:56 +00:00
|
|
|
int err, i = 0, ret = 0, flag = 0;
|
2006-09-30 22:02:00 +00:00
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_ref_sha1_basic(refname, sha1, 0, &flag);
|
2006-09-30 22:02:00 +00:00
|
|
|
if (!lock)
|
|
|
|
return 1;
|
2008-10-31 23:25:44 +00:00
|
|
|
if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
|
2006-09-30 22:02:00 +00:00
|
|
|
/* loose */
|
2008-10-26 02:33:56 +00:00
|
|
|
const char *path;
|
|
|
|
|
|
|
|
if (!(delopt & REF_NODEREF)) {
|
|
|
|
i = strlen(lock->lk->filename) - 5; /* .lock */
|
|
|
|
lock->lk->filename[i] = 0;
|
|
|
|
path = lock->lk->filename;
|
|
|
|
} else {
|
2008-11-10 21:07:52 +00:00
|
|
|
path = git_path("%s", refname);
|
2008-10-26 02:33:56 +00:00
|
|
|
}
|
2009-04-29 21:22:56 +00:00
|
|
|
err = unlink_or_warn(path);
|
|
|
|
if (err && errno != ENOENT)
|
2006-09-30 22:02:00 +00:00
|
|
|
ret = 1;
|
2009-04-29 21:22:56 +00:00
|
|
|
|
2008-10-26 02:33:56 +00:00
|
|
|
if (!(delopt & REF_NODEREF))
|
|
|
|
lock->lk->filename[i] = '.';
|
2006-09-30 22:02:00 +00:00
|
|
|
}
|
|
|
|
/* removing the loose one could have resurrected an earlier
|
|
|
|
* packed one. Also, if it was not loose we need to repack
|
|
|
|
* without it.
|
|
|
|
*/
|
|
|
|
ret |= repack_without_ref(refname);
|
|
|
|
|
2009-04-29 21:22:56 +00:00
|
|
|
unlink_or_warn(git_path("logs/%s", lock->ref_name));
|
2011-10-17 02:38:06 +00:00
|
|
|
invalidate_ref_cache(NULL);
|
2006-09-30 22:02:00 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return ret;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
|
|
|
|
2010-07-07 07:47:20 +00:00
|
|
|
/*
|
|
|
|
* People using contrib's git-new-workdir have .git/logs/refs ->
|
|
|
|
* /some/other/path/.git/logs/refs, and that may live on another device.
|
|
|
|
*
|
|
|
|
* IOW, to avoid cross device rename errors, the temporary renamed log must
|
|
|
|
* live into logs/refs.
|
|
|
|
*/
|
|
|
|
#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
|
2006-11-28 14:47:40 +00:00
|
|
|
{
|
|
|
|
unsigned char sha1[20], orig_sha1[20];
|
|
|
|
int flag = 0, logmoved = 0;
|
|
|
|
struct ref_lock *lock;
|
|
|
|
struct stat loginfo;
|
2011-12-12 05:38:09 +00:00
|
|
|
int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
|
2008-10-26 02:33:56 +00:00
|
|
|
const char *symref = NULL;
|
2011-12-12 05:38:16 +00:00
|
|
|
struct ref_cache *refs = get_ref_cache(NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2008-10-26 02:33:57 +00:00
|
|
|
if (log && S_ISLNK(loginfo.st_mode))
|
2011-12-12 05:38:09 +00:00
|
|
|
return error("reflog for %s is a symlink", oldrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2011-12-20 21:25:53 +00:00
|
|
|
symref = resolve_ref_unsafe(oldrefname, orig_sha1, 1, &flag);
|
2008-10-26 02:33:56 +00:00
|
|
|
if (flag & REF_ISSYMREF)
|
2008-10-29 00:05:27 +00:00
|
|
|
return error("refname %s is a symbolic ref, renaming it is not supported",
|
2011-12-12 05:38:09 +00:00
|
|
|
oldrefname);
|
2008-10-26 02:33:56 +00:00
|
|
|
if (!symref)
|
2011-12-12 05:38:09 +00:00
|
|
|
return error("refname %s not found", oldrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
if (!is_refname_available(newrefname, oldrefname, get_packed_refs(refs)))
|
2006-11-28 14:47:40 +00:00
|
|
|
return 1;
|
|
|
|
|
2011-12-12 05:38:16 +00:00
|
|
|
if (!is_refname_available(newrefname, oldrefname, get_loose_refs(refs)))
|
2006-11-28 14:47:40 +00:00
|
|
|
return 1;
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
|
2010-07-07 07:47:20 +00:00
|
|
|
return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
|
2011-12-12 05:38:09 +00:00
|
|
|
oldrefname, strerror(errno));
|
2006-11-28 14:47:40 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
|
|
|
|
error("unable to delete old %s", oldrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (!read_ref_full(newrefname, sha1, 1, &flag) &&
|
|
|
|
delete_ref(newrefname, sha1, REF_NODEREF)) {
|
2006-11-28 14:47:40 +00:00
|
|
|
if (errno==EISDIR) {
|
2011-12-12 05:38:09 +00:00
|
|
|
if (remove_empty_directories(git_path("%s", newrefname))) {
|
|
|
|
error("Directory not empty: %s", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
} else {
|
2011-12-12 05:38:09 +00:00
|
|
|
error("unable to delete existing %s", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (log && safe_create_leading_directories(git_path("logs/%s", newrefname))) {
|
|
|
|
error("unable to create directory for %s", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
retry:
|
2011-12-12 05:38:09 +00:00
|
|
|
if (log && rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
|
2007-01-16 01:30:59 +00:00
|
|
|
if (errno==EISDIR || errno==ENOTDIR) {
|
|
|
|
/*
|
|
|
|
* rename(a, b) when b is an existing
|
|
|
|
* directory ought to result in ISDIR, but
|
|
|
|
* Solaris 5.8 gives ENOTDIR. Sheesh.
|
|
|
|
*/
|
2011-12-12 05:38:09 +00:00
|
|
|
if (remove_empty_directories(git_path("logs/%s", newrefname))) {
|
|
|
|
error("Directory not empty: logs/%s", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
goto retry;
|
|
|
|
} else {
|
2010-07-07 07:47:20 +00:00
|
|
|
error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
|
2011-12-12 05:38:09 +00:00
|
|
|
newrefname, strerror(errno));
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
logmoved = log;
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
lock = lock_ref_sha1_basic(newrefname, NULL, 0, NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!lock) {
|
2011-12-12 05:38:09 +00:00
|
|
|
error("unable to lock %s for update", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
lock->force_write = 1;
|
|
|
|
hashcpy(lock->old_sha1, orig_sha1);
|
2006-11-30 02:16:56 +00:00
|
|
|
if (write_ref_sha1(lock, orig_sha1, logmsg)) {
|
2011-12-12 05:38:09 +00:00
|
|
|
error("unable to write current sha1 into %s", newrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rollback:
|
2011-12-12 05:38:09 +00:00
|
|
|
lock = lock_ref_sha1_basic(oldrefname, NULL, 0, NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!lock) {
|
2011-12-12 05:38:09 +00:00
|
|
|
error("unable to lock %s for rollback", oldrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
goto rollbacklog;
|
|
|
|
}
|
|
|
|
|
|
|
|
lock->force_write = 1;
|
|
|
|
flag = log_all_ref_updates;
|
|
|
|
log_all_ref_updates = 0;
|
|
|
|
if (write_ref_sha1(lock, orig_sha1, NULL))
|
2011-12-12 05:38:09 +00:00
|
|
|
error("unable to write current sha1 into %s", oldrefname);
|
2006-11-28 14:47:40 +00:00
|
|
|
log_all_ref_updates = flag;
|
|
|
|
|
|
|
|
rollbacklog:
|
2011-12-12 05:38:09 +00:00
|
|
|
if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
|
2006-11-28 14:47:40 +00:00
|
|
|
error("unable to restore logfile %s from %s: %s",
|
2011-12-12 05:38:09 +00:00
|
|
|
oldrefname, newrefname, strerror(errno));
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!logmoved && log &&
|
2011-12-12 05:38:09 +00:00
|
|
|
rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
|
2010-07-07 07:47:20 +00:00
|
|
|
error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
|
2011-12-12 05:38:09 +00:00
|
|
|
oldrefname, strerror(errno));
|
2006-11-28 14:47:40 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-22 18:57:30 +00:00
|
|
|
int close_ref(struct ref_lock *lock)
|
2008-01-16 19:14:30 +00:00
|
|
|
{
|
|
|
|
if (close_lock_file(lock->lk))
|
|
|
|
return -1;
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-22 18:57:30 +00:00
|
|
|
int commit_ref(struct ref_lock *lock)
|
2008-01-16 19:14:30 +00:00
|
|
|
{
|
|
|
|
if (commit_lock_file(lock->lk))
|
|
|
|
return -1;
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-06 21:04:17 +00:00
|
|
|
void unlock_ref(struct ref_lock *lock)
|
2006-05-17 09:55:02 +00:00
|
|
|
{
|
2008-01-16 19:12:46 +00:00
|
|
|
/* Do not free lock->lk -- atexit() still looks at them */
|
|
|
|
if (lock->lk)
|
|
|
|
rollback_lock_file(lock->lk);
|
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
|
|
|
free(lock->ref_name);
|
2007-01-26 22:26:06 +00:00
|
|
|
free(lock->orig_ref_name);
|
2006-05-17 09:55:02 +00:00
|
|
|
free(lock);
|
|
|
|
}
|
|
|
|
|
2007-07-29 00:17:17 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int copy_msg(char *buf, const char *msg)
|
|
|
|
{
|
|
|
|
char *cp = buf;
|
|
|
|
char c;
|
|
|
|
int wasspace = 1;
|
|
|
|
|
|
|
|
*cp++ = '\t';
|
|
|
|
while ((c = *msg++)) {
|
|
|
|
if (wasspace && isspace(c))
|
|
|
|
continue;
|
|
|
|
wasspace = isspace(c);
|
|
|
|
if (wasspace)
|
|
|
|
c = ' ';
|
|
|
|
*cp++ = c;
|
|
|
|
}
|
|
|
|
while (buf < cp && isspace(cp[-1]))
|
|
|
|
cp--;
|
|
|
|
*cp++ = '\n';
|
|
|
|
return cp - buf;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int log_ref_setup(const char *refname, char *logfile, int bufsize)
|
2006-05-17 09:55:40 +00:00
|
|
|
{
|
2010-05-22 00:28:36 +00:00
|
|
|
int logfd, oflags = O_APPEND | O_WRONLY;
|
2007-01-26 22:26:05 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
git_snpath(logfile, bufsize, "logs/%s", refname);
|
2006-10-08 08:35:18 +00:00
|
|
|
if (log_all_ref_updates &&
|
2011-12-12 05:38:09 +00:00
|
|
|
(!prefixcmp(refname, "refs/heads/") ||
|
|
|
|
!prefixcmp(refname, "refs/remotes/") ||
|
|
|
|
!prefixcmp(refname, "refs/notes/") ||
|
|
|
|
!strcmp(refname, "HEAD"))) {
|
2010-06-10 12:54:03 +00:00
|
|
|
if (safe_create_leading_directories(logfile) < 0)
|
2006-05-17 09:55:40 +00:00
|
|
|
return error("unable to create directory for %s",
|
2010-06-10 12:54:03 +00:00
|
|
|
logfile);
|
2006-05-17 09:55:40 +00:00
|
|
|
oflags |= O_CREAT;
|
|
|
|
}
|
|
|
|
|
2010-06-10 12:54:03 +00:00
|
|
|
logfd = open(logfile, oflags, 0666);
|
2006-05-17 09:55:40 +00:00
|
|
|
if (logfd < 0) {
|
2006-10-10 04:15:59 +00:00
|
|
|
if (!(oflags & O_CREAT) && errno == ENOENT)
|
2006-05-17 09:55:40 +00:00
|
|
|
return 0;
|
2006-10-19 08:28:47 +00:00
|
|
|
|
|
|
|
if ((oflags & O_CREAT) && errno == EISDIR) {
|
2010-06-10 12:54:03 +00:00
|
|
|
if (remove_empty_directories(logfile)) {
|
2006-10-19 08:28:47 +00:00
|
|
|
return error("There are still logs under '%s'",
|
2010-06-10 12:54:03 +00:00
|
|
|
logfile);
|
2006-10-19 08:28:47 +00:00
|
|
|
}
|
2010-06-10 12:54:03 +00:00
|
|
|
logfd = open(logfile, oflags, 0666);
|
2006-10-19 08:28:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (logfd < 0)
|
|
|
|
return error("Unable to append to %s: %s",
|
2010-06-10 12:54:03 +00:00
|
|
|
logfile, strerror(errno));
|
2006-05-17 09:55:40 +00:00
|
|
|
}
|
|
|
|
|
2010-06-10 12:54:03 +00:00
|
|
|
adjust_shared_perm(logfile);
|
2010-05-22 00:28:36 +00:00
|
|
|
close(logfd);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-03-09 22:38:57 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
static int log_ref_write(const char *refname, const unsigned char *old_sha1,
|
2010-05-22 00:28:36 +00:00
|
|
|
const unsigned char *new_sha1, const char *msg)
|
|
|
|
{
|
|
|
|
int logfd, result, written, oflags = O_APPEND | O_WRONLY;
|
|
|
|
unsigned maxlen, len;
|
|
|
|
int msglen;
|
2010-06-10 12:54:03 +00:00
|
|
|
char log_file[PATH_MAX];
|
2010-05-22 00:28:36 +00:00
|
|
|
char *logrec;
|
|
|
|
const char *committer;
|
|
|
|
|
|
|
|
if (log_all_ref_updates < 0)
|
|
|
|
log_all_ref_updates = !is_bare_repository();
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
result = log_ref_setup(refname, log_file, sizeof(log_file));
|
2010-05-22 00:28:36 +00:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
logfd = open(log_file, oflags);
|
|
|
|
if (logfd < 0)
|
|
|
|
return 0;
|
2007-07-29 00:17:17 +00:00
|
|
|
msglen = msg ? strlen(msg) : 0;
|
2007-12-09 01:32:08 +00:00
|
|
|
committer = git_committer_info(0);
|
2007-01-26 10:26:04 +00:00
|
|
|
maxlen = strlen(committer) + msglen + 100;
|
|
|
|
logrec = xmalloc(maxlen);
|
|
|
|
len = sprintf(logrec, "%s %s %s\n",
|
2007-01-26 22:26:05 +00:00
|
|
|
sha1_to_hex(old_sha1),
|
|
|
|
sha1_to_hex(new_sha1),
|
2007-01-26 10:26:04 +00:00
|
|
|
committer);
|
|
|
|
if (msglen)
|
2007-07-29 00:17:17 +00:00
|
|
|
len += copy_msg(logrec + len - 1, msg) - 1;
|
2007-01-08 15:58:23 +00:00
|
|
|
written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
|
2006-05-17 09:55:40 +00:00
|
|
|
free(logrec);
|
2007-06-24 19:20:41 +00:00
|
|
|
if (close(logfd) != 0 || written != len)
|
2007-01-26 22:26:05 +00:00
|
|
|
return error("Unable to append to %s", log_file);
|
2006-05-17 09:55:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-15 23:50:17 +00:00
|
|
|
static int is_branch(const char *refname)
|
|
|
|
{
|
|
|
|
return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/");
|
|
|
|
}
|
|
|
|
|
2006-05-17 09:55:02 +00:00
|
|
|
int write_ref_sha1(struct ref_lock *lock,
|
|
|
|
const unsigned char *sha1, const char *logmsg)
|
|
|
|
{
|
|
|
|
static char term = '\n';
|
2008-01-15 23:50:17 +00:00
|
|
|
struct object *o;
|
2006-05-17 09:55:02 +00:00
|
|
|
|
|
|
|
if (!lock)
|
2005-06-06 20:31:29 +00:00
|
|
|
return -1;
|
2006-08-17 18:54:57 +00:00
|
|
|
if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
|
2006-05-17 09:55:02 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return 0;
|
2005-06-06 20:31:29 +00:00
|
|
|
}
|
2008-01-15 23:50:17 +00:00
|
|
|
o = parse_object(sha1);
|
|
|
|
if (!o) {
|
2011-06-16 13:42:48 +00:00
|
|
|
error("Trying to write ref %s with nonexistent object %s",
|
2008-01-15 23:50:17 +00:00
|
|
|
lock->ref_name, sha1_to_hex(sha1));
|
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
|
|
|
|
error("Trying to write non-commit object %s to branch %s",
|
|
|
|
sha1_to_hex(sha1), lock->ref_name);
|
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-01-08 15:58:23 +00:00
|
|
|
if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
|
|
|
|
write_in_full(lock->lock_fd, &term, 1) != 1
|
2008-01-16 19:14:30 +00:00
|
|
|
|| close_ref(lock) < 0) {
|
2006-06-06 20:54:14 +00:00
|
|
|
error("Couldn't write %s", lock->lk->filename);
|
2006-05-17 09:55:02 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2011-10-17 02:38:10 +00:00
|
|
|
clear_loose_ref_cache(get_ref_cache(NULL));
|
2007-01-26 22:26:07 +00:00
|
|
|
if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
|
|
|
|
(strcmp(lock->ref_name, lock->orig_ref_name) &&
|
|
|
|
log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
|
2006-05-17 09:55:40 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-03-21 21:11:44 +00:00
|
|
|
if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
|
|
|
|
/*
|
|
|
|
* Special hack: If a branch is updated directly and HEAD
|
|
|
|
* points to it (may happen on the remote side of a push
|
|
|
|
* for example) then logically the HEAD reflog should be
|
|
|
|
* updated too.
|
|
|
|
* A generic solution implies reverse symref information,
|
|
|
|
* but finding all symrefs pointing to the given branch
|
|
|
|
* would be rather costly for this rare event (the direct
|
|
|
|
* update of a branch) to be worth it. So let's cheat and
|
|
|
|
* check with HEAD only which should cover 99% of all usage
|
|
|
|
* scenarios (even 100% of the default ones).
|
|
|
|
*/
|
|
|
|
unsigned char head_sha1[20];
|
|
|
|
int head_flag;
|
|
|
|
const char *head_ref;
|
2011-12-12 11:20:32 +00:00
|
|
|
head_ref = resolve_ref_unsafe("HEAD", head_sha1, 1, &head_flag);
|
2007-03-21 21:11:44 +00:00
|
|
|
if (head_ref && (head_flag & REF_ISSYMREF) &&
|
|
|
|
!strcmp(head_ref, lock->ref_name))
|
|
|
|
log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
|
|
|
|
}
|
2008-01-16 19:14:30 +00:00
|
|
|
if (commit_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
|
|
|
error("Couldn't set %s", lock->ref_name);
|
2006-05-17 09:55:02 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
unlock_ref(lock);
|
|
|
|
return 0;
|
2005-06-06 20:31:29 +00:00
|
|
|
}
|
2006-05-17 09:56:09 +00:00
|
|
|
|
2007-01-26 22:26:10 +00:00
|
|
|
int create_symref(const char *ref_target, const char *refs_heads_master,
|
|
|
|
const char *logmsg)
|
2007-01-26 22:26:09 +00:00
|
|
|
{
|
|
|
|
const char *lockpath;
|
|
|
|
char ref[1000];
|
|
|
|
int fd, len, written;
|
2008-10-27 10:22:09 +00:00
|
|
|
char *git_HEAD = git_pathdup("%s", ref_target);
|
2007-01-26 22:26:10 +00:00
|
|
|
unsigned char old_sha1[20], new_sha1[20];
|
|
|
|
|
|
|
|
if (logmsg && read_ref(ref_target, old_sha1))
|
|
|
|
hashclr(old_sha1);
|
2007-01-26 22:26:09 +00:00
|
|
|
|
2007-02-08 07:41:43 +00:00
|
|
|
if (safe_create_leading_directories(git_HEAD) < 0)
|
|
|
|
return error("unable to create directory for %s", git_HEAD);
|
|
|
|
|
2007-01-26 22:26:09 +00:00
|
|
|
#ifndef NO_SYMLINK_HEAD
|
|
|
|
if (prefer_symlink_refs) {
|
|
|
|
unlink(git_HEAD);
|
|
|
|
if (!symlink(refs_heads_master, git_HEAD))
|
2007-01-26 22:26:10 +00:00
|
|
|
goto done;
|
2007-01-26 22:26:09 +00:00
|
|
|
fprintf(stderr, "no symlink - falling back to symbolic ref\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
|
|
|
|
if (sizeof(ref) <= len) {
|
|
|
|
error("refname too long: %s", refs_heads_master);
|
2007-01-27 01:49:00 +00:00
|
|
|
goto error_free_return;
|
2007-01-26 22:26:09 +00:00
|
|
|
}
|
|
|
|
lockpath = mkpath("%s.lock", git_HEAD);
|
|
|
|
fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
|
|
|
|
if (fd < 0) {
|
|
|
|
error("Unable to open %s for writing", lockpath);
|
2007-01-27 01:49:00 +00:00
|
|
|
goto error_free_return;
|
2007-01-26 22:26:09 +00:00
|
|
|
}
|
|
|
|
written = write_in_full(fd, ref, len);
|
2007-06-24 19:20:41 +00:00
|
|
|
if (close(fd) != 0 || written != len) {
|
2007-01-26 22:26:09 +00:00
|
|
|
error("Unable to write to %s", lockpath);
|
2007-01-27 01:49:00 +00:00
|
|
|
goto error_unlink_return;
|
2007-01-26 22:26:09 +00:00
|
|
|
}
|
|
|
|
if (rename(lockpath, git_HEAD) < 0) {
|
|
|
|
error("Unable to create %s", git_HEAD);
|
2007-01-27 01:49:00 +00:00
|
|
|
goto error_unlink_return;
|
2007-01-26 22:26:09 +00:00
|
|
|
}
|
|
|
|
if (adjust_shared_perm(git_HEAD)) {
|
|
|
|
error("Unable to fix permissions on %s", lockpath);
|
2007-01-27 01:49:00 +00:00
|
|
|
error_unlink_return:
|
2009-04-29 21:22:56 +00:00
|
|
|
unlink_or_warn(lockpath);
|
2007-01-27 01:49:00 +00:00
|
|
|
error_free_return:
|
|
|
|
free(git_HEAD);
|
|
|
|
return -1;
|
2007-01-26 22:26:09 +00:00
|
|
|
}
|
2007-01-26 22:26:10 +00:00
|
|
|
|
2007-03-03 18:28:46 +00:00
|
|
|
#ifndef NO_SYMLINK_HEAD
|
2007-01-26 22:26:10 +00:00
|
|
|
done:
|
2007-03-03 18:28:46 +00:00
|
|
|
#endif
|
2007-01-26 22:26:10 +00:00
|
|
|
if (logmsg && !read_ref(refs_heads_master, new_sha1))
|
|
|
|
log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
|
|
|
|
|
2007-01-27 01:49:00 +00:00
|
|
|
free(git_HEAD);
|
2007-01-26 22:26:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-19 09:19:05 +00:00
|
|
|
static char *ref_msg(const char *line, const char *endp)
|
|
|
|
{
|
|
|
|
const char *ep;
|
|
|
|
line += 82;
|
2007-09-15 22:32:36 +00:00
|
|
|
ep = memchr(line, '\n', endp - line);
|
|
|
|
if (!ep)
|
|
|
|
ep = endp;
|
|
|
|
return xmemdupz(line, ep - line);
|
2007-01-19 09:19:05 +00:00
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int read_ref_at(const char *refname, unsigned long at_time, int cnt,
|
|
|
|
unsigned char *sha1, char **msg,
|
|
|
|
unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
|
2006-05-17 09:56:09 +00:00
|
|
|
{
|
2006-05-19 07:28:19 +00:00
|
|
|
const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
|
2006-05-17 09:56:09 +00:00
|
|
|
char *tz_c;
|
2006-12-19 06:07:45 +00:00
|
|
|
int logfd, tz, reccnt = 0;
|
2006-05-17 09:56:09 +00:00
|
|
|
struct stat st;
|
|
|
|
unsigned long date;
|
2006-05-19 07:28:19 +00:00
|
|
|
unsigned char logged_sha1[20];
|
2007-01-19 08:39:32 +00:00
|
|
|
void *log_mapped;
|
2007-03-07 01:44:37 +00:00
|
|
|
size_t mapsz;
|
2006-05-17 09:56:09 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
logfile = git_path("logs/%s", refname);
|
2006-05-17 09:56:09 +00:00
|
|
|
logfd = open(logfile, O_RDONLY, 0);
|
|
|
|
if (logfd < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("Unable to read log '%s'", logfile);
|
2006-05-17 09:56:09 +00:00
|
|
|
fstat(logfd, &st);
|
|
|
|
if (!st.st_size)
|
|
|
|
die("Log %s is empty.", logfile);
|
2007-03-07 01:44:37 +00:00
|
|
|
mapsz = xsize_t(st.st_size);
|
|
|
|
log_mapped = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd, 0);
|
2007-01-19 08:39:32 +00:00
|
|
|
logdata = log_mapped;
|
2006-05-17 09:56:09 +00:00
|
|
|
close(logfd);
|
|
|
|
|
2006-05-19 07:28:19 +00:00
|
|
|
lastrec = NULL;
|
2006-05-17 09:56:09 +00:00
|
|
|
rec = logend = logdata + st.st_size;
|
|
|
|
while (logdata < rec) {
|
2006-12-19 06:07:45 +00:00
|
|
|
reccnt++;
|
2006-05-17 09:56:09 +00:00
|
|
|
if (logdata < rec && *(rec-1) == '\n')
|
|
|
|
rec--;
|
2006-05-19 07:28:19 +00:00
|
|
|
lastgt = NULL;
|
|
|
|
while (logdata < rec && *(rec-1) != '\n') {
|
2006-05-17 09:56:09 +00:00
|
|
|
rec--;
|
2006-05-19 07:28:19 +00:00
|
|
|
if (*rec == '>')
|
|
|
|
lastgt = rec;
|
|
|
|
}
|
|
|
|
if (!lastgt)
|
2006-05-17 09:56:09 +00:00
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-05-19 07:28:19 +00:00
|
|
|
date = strtoul(lastgt + 1, &tz_c, 10);
|
2006-10-06 06:16:15 +00:00
|
|
|
if (date <= at_time || cnt == 0) {
|
show-branch --reflog: show the reflog message at the top.
This changes the output so the list at the top shows the reflog
message, along with their relative timestamps.
You can use --reflog=<n> to show <n> most recent log entries, or
use --reflog=<n>,<b> to show <n> entries going back from the
entry <b>. <b> can be either a number (so --reflog=4,20 shows 4
records starting from @{20}) or a timestamp (e.g. --reflog='4,1 day').
Here is a sample output (with --list option):
$ git show-branch --reflog=10 --list jc/show-reflog
[jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
[jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
[jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow retrievi
[jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
[jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --reflog: use
This shows what I did more cleanly:
$ git show-branch --reflog=10 jc/show-reflog
! [jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
! [jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
! [jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_
! [jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read
! [jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend rea
! [jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow
! [jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
! [jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --r
----------
+ [jc/show-reflog@{0}] show-branch --reflog: show the reflog
+ [jc/show-reflog@{2}] show-branch --reflog: show the reflog
+++ [jc/show-reflog@{1}] show-branch --reflog: show the reflog
+++++ [jc/show-reflog@{4}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{5}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{6}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{7}] read_ref_at(): allow retrieving the r
+ [jc/show-reflog@{9}] show-branch --reflog: use updated rea
+ [jc/show-reflog@{9}^] read_ref_at(): allow reporting the c
+ [jc/show-reflog@{9}~2] show-branch --reflog: show the refl
+ [jc/show-reflog@{9}~3] read_ref_at(): allow retrieving the
++++++++++ [jc/show-reflog@{8}] dwim_ref(): Separate name-to-ref DWIM
At @{9}, I had a commit to complete 5 patch series, but I wanted
to consolidate two commits that enhances read_ref_at() into one
(they were @{9}^ and @{9}~3), and another two that touch show-branch
into one (@{9} and @{9}~2).
I first saved them with "format-patch -4", and then did a reset
at @{8}. At @{7}, I applied one of them with "am", and then
used "git-apply" on the other one, and amended the commit at
@{6} (so @{6} and @{7} has the same parent). I did not like the
log message, so I amended again at @{5}.
Then I cherry-picked @{9}~2 to create @{3} (the log message
shows that it needs to learn to set GIT_REFLOG_ACTION -- it uses
"git-commit" and the log entry is attributed for it). Another
cherry-pick built @{2} out of @{9}, but what I wanted to do was
to squash these two into one, so I did a "reset HEAD^" at @{1}
and then made the final commit by amending what was at the top.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-19 09:20:23 +00:00
|
|
|
tz = strtoul(tz_c, NULL, 10);
|
2007-01-19 09:19:05 +00:00
|
|
|
if (msg)
|
|
|
|
*msg = ref_msg(rec, logend);
|
|
|
|
if (cutoff_time)
|
|
|
|
*cutoff_time = date;
|
|
|
|
if (cutoff_tz)
|
|
|
|
*cutoff_tz = tz;
|
|
|
|
if (cutoff_cnt)
|
show-branch --reflog: show the reflog message at the top.
This changes the output so the list at the top shows the reflog
message, along with their relative timestamps.
You can use --reflog=<n> to show <n> most recent log entries, or
use --reflog=<n>,<b> to show <n> entries going back from the
entry <b>. <b> can be either a number (so --reflog=4,20 shows 4
records starting from @{20}) or a timestamp (e.g. --reflog='4,1 day').
Here is a sample output (with --list option):
$ git show-branch --reflog=10 --list jc/show-reflog
[jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
[jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
[jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog: sho
[jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend read_ref_a
[jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow retrievi
[jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
[jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --reflog: use
This shows what I did more cleanly:
$ git show-branch --reflog=10 jc/show-reflog
! [jc/show-reflog@{0}] (3 minutes ago) commit (amend): show-branch --ref
! [jc/show-reflog@{1}] (5 minutes ago) reset HEAD^
! [jc/show-reflog@{2}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{3}] (14 minutes ago) commit: show-branch --reflog:
! [jc/show-reflog@{4}] (18 minutes ago) commit (amend): Extend read_
! [jc/show-reflog@{5}] (18 minutes ago) commit (amend): Extend read
! [jc/show-reflog@{6}] (18 minutes ago) commit (amend): Extend rea
! [jc/show-reflog@{7}] (18 minutes ago) am: read_ref_at(): allow
! [jc/show-reflog@{8}] (18 minutes ago) reset --hard HEAD~4
! [jc/show-reflog@{9}] (61 minutes ago) commit: show-branch --r
----------
+ [jc/show-reflog@{0}] show-branch --reflog: show the reflog
+ [jc/show-reflog@{2}] show-branch --reflog: show the reflog
+++ [jc/show-reflog@{1}] show-branch --reflog: show the reflog
+++++ [jc/show-reflog@{4}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{5}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{6}] Extend read_ref_at() to be usable fro
+ [jc/show-reflog@{7}] read_ref_at(): allow retrieving the r
+ [jc/show-reflog@{9}] show-branch --reflog: use updated rea
+ [jc/show-reflog@{9}^] read_ref_at(): allow reporting the c
+ [jc/show-reflog@{9}~2] show-branch --reflog: show the refl
+ [jc/show-reflog@{9}~3] read_ref_at(): allow retrieving the
++++++++++ [jc/show-reflog@{8}] dwim_ref(): Separate name-to-ref DWIM
At @{9}, I had a commit to complete 5 patch series, but I wanted
to consolidate two commits that enhances read_ref_at() into one
(they were @{9}^ and @{9}~3), and another two that touch show-branch
into one (@{9} and @{9}~2).
I first saved them with "format-patch -4", and then did a reset
at @{8}. At @{7}, I applied one of them with "am", and then
used "git-apply" on the other one, and amended the commit at
@{6} (so @{6} and @{7} has the same parent). I did not like the
log message, so I amended again at @{5}.
Then I cherry-picked @{9}~2 to create @{3} (the log message
shows that it needs to learn to set GIT_REFLOG_ACTION -- it uses
"git-commit" and the log entry is attributed for it). Another
cherry-pick built @{2} out of @{9}, but what I wanted to do was
to squash these two into one, so I did a "reset HEAD^" at @{1}
and then made the final commit by amending what was at the top.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-19 09:20:23 +00:00
|
|
|
*cutoff_cnt = reccnt - 1;
|
2006-05-19 07:28:19 +00:00
|
|
|
if (lastrec) {
|
|
|
|
if (get_sha1_hex(lastrec, logged_sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
|
|
|
if (get_sha1_hex(rec + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-08-17 18:54:57 +00:00
|
|
|
if (hashcmp(logged_sha1, sha1)) {
|
2009-03-24 01:09:17 +00:00
|
|
|
warning("Log %s has gap after %s.",
|
2007-07-14 06:14:52 +00:00
|
|
|
logfile, show_date(date, tz, DATE_RFC2822));
|
2006-05-19 07:28:19 +00:00
|
|
|
}
|
2006-06-06 21:04:17 +00:00
|
|
|
}
|
|
|
|
else if (date == at_time) {
|
2006-05-19 07:28:19 +00:00
|
|
|
if (get_sha1_hex(rec + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-06-06 21:04:17 +00:00
|
|
|
}
|
|
|
|
else {
|
2006-05-19 07:28:19 +00:00
|
|
|
if (get_sha1_hex(rec + 41, logged_sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-08-17 18:54:57 +00:00
|
|
|
if (hashcmp(logged_sha1, sha1)) {
|
2009-03-24 01:09:17 +00:00
|
|
|
warning("Log %s unexpectedly ended on %s.",
|
2007-07-14 06:14:52 +00:00
|
|
|
logfile, show_date(date, tz, DATE_RFC2822));
|
2006-05-19 07:28:19 +00:00
|
|
|
}
|
|
|
|
}
|
2007-03-07 01:44:37 +00:00
|
|
|
munmap(log_mapped, mapsz);
|
2006-05-17 09:56:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-05-19 07:28:19 +00:00
|
|
|
lastrec = rec;
|
2006-10-06 06:16:15 +00:00
|
|
|
if (cnt > 0)
|
|
|
|
cnt--;
|
2006-05-17 09:56:09 +00:00
|
|
|
}
|
|
|
|
|
2006-05-19 07:28:19 +00:00
|
|
|
rec = logdata;
|
|
|
|
while (rec < logend && *rec != '>' && *rec != '\n')
|
|
|
|
rec++;
|
|
|
|
if (rec == logend || *rec == '\n')
|
2006-05-17 09:56:09 +00:00
|
|
|
die("Log %s is corrupt.", logfile);
|
2006-05-19 07:28:19 +00:00
|
|
|
date = strtoul(rec + 1, &tz_c, 10);
|
2006-05-17 09:56:09 +00:00
|
|
|
tz = strtoul(tz_c, NULL, 10);
|
|
|
|
if (get_sha1_hex(logdata, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
2008-07-08 04:38:54 +00:00
|
|
|
if (is_null_sha1(sha1)) {
|
|
|
|
if (get_sha1_hex(logdata + 41, sha1))
|
|
|
|
die("Log %s is corrupt.", logfile);
|
|
|
|
}
|
2007-01-19 09:19:05 +00:00
|
|
|
if (msg)
|
|
|
|
*msg = ref_msg(logdata, logend);
|
2007-03-07 01:44:37 +00:00
|
|
|
munmap(log_mapped, mapsz);
|
2007-01-19 09:19:05 +00:00
|
|
|
|
|
|
|
if (cutoff_time)
|
|
|
|
*cutoff_time = date;
|
|
|
|
if (cutoff_tz)
|
|
|
|
*cutoff_tz = tz;
|
|
|
|
if (cutoff_cnt)
|
|
|
|
*cutoff_cnt = reccnt;
|
|
|
|
return 1;
|
2006-05-17 09:56:09 +00:00
|
|
|
}
|
2006-12-18 09:18:16 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int for_each_recent_reflog_ent(const char *refname, each_reflog_ent_fn fn, long ofs, void *cb_data)
|
2006-12-18 09:18:16 +00:00
|
|
|
{
|
|
|
|
const char *logfile;
|
|
|
|
FILE *logfp;
|
2010-03-13 17:37:50 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-01-19 07:25:54 +00:00
|
|
|
int ret = 0;
|
2006-12-18 09:18:16 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
logfile = git_path("logs/%s", refname);
|
2006-12-18 09:18:16 +00:00
|
|
|
logfp = fopen(logfile, "r");
|
|
|
|
if (!logfp)
|
2007-01-08 00:59:54 +00:00
|
|
|
return -1;
|
2009-01-20 06:18:29 +00:00
|
|
|
|
|
|
|
if (ofs) {
|
|
|
|
struct stat statbuf;
|
|
|
|
if (fstat(fileno(logfp), &statbuf) ||
|
|
|
|
statbuf.st_size < ofs ||
|
|
|
|
fseek(logfp, -ofs, SEEK_END) ||
|
2010-03-13 17:37:50 +00:00
|
|
|
strbuf_getwholeline(&sb, logfp, '\n')) {
|
2009-07-16 21:25:18 +00:00
|
|
|
fclose(logfp);
|
2010-03-13 17:37:50 +00:00
|
|
|
strbuf_release(&sb);
|
2009-01-20 06:18:29 +00:00
|
|
|
return -1;
|
2009-07-16 21:25:18 +00:00
|
|
|
}
|
2009-01-20 06:18:29 +00:00
|
|
|
}
|
|
|
|
|
2010-03-13 17:37:50 +00:00
|
|
|
while (!strbuf_getwholeline(&sb, logfp, '\n')) {
|
2006-12-18 09:18:16 +00:00
|
|
|
unsigned char osha1[20], nsha1[20];
|
2007-01-08 00:59:54 +00:00
|
|
|
char *email_end, *message;
|
|
|
|
unsigned long timestamp;
|
2010-03-13 17:37:50 +00:00
|
|
|
int tz;
|
2006-12-18 09:18:16 +00:00
|
|
|
|
|
|
|
/* old SP new SP name <email> SP time TAB msg LF */
|
2010-03-13 17:37:50 +00:00
|
|
|
if (sb.len < 83 || sb.buf[sb.len - 1] != '\n' ||
|
|
|
|
get_sha1_hex(sb.buf, osha1) || sb.buf[40] != ' ' ||
|
|
|
|
get_sha1_hex(sb.buf + 41, nsha1) || sb.buf[81] != ' ' ||
|
|
|
|
!(email_end = strchr(sb.buf + 82, '>')) ||
|
2007-01-08 00:59:54 +00:00
|
|
|
email_end[1] != ' ' ||
|
|
|
|
!(timestamp = strtoul(email_end + 2, &message, 10)) ||
|
|
|
|
!message || message[0] != ' ' ||
|
|
|
|
(message[1] != '+' && message[1] != '-') ||
|
|
|
|
!isdigit(message[2]) || !isdigit(message[3]) ||
|
2007-02-08 23:59:47 +00:00
|
|
|
!isdigit(message[4]) || !isdigit(message[5]))
|
2006-12-18 09:18:16 +00:00
|
|
|
continue; /* corrupt? */
|
2007-01-08 00:59:54 +00:00
|
|
|
email_end[1] = '\0';
|
|
|
|
tz = strtol(message + 1, NULL, 10);
|
2007-02-08 23:59:47 +00:00
|
|
|
if (message[6] != '\t')
|
|
|
|
message += 6;
|
|
|
|
else
|
|
|
|
message += 7;
|
2010-03-13 17:37:50 +00:00
|
|
|
ret = fn(osha1, nsha1, sb.buf + 82, timestamp, tz, message,
|
|
|
|
cb_data);
|
2007-01-08 00:59:54 +00:00
|
|
|
if (ret)
|
2007-01-19 07:25:54 +00:00
|
|
|
break;
|
2006-12-18 09:18:16 +00:00
|
|
|
}
|
|
|
|
fclose(logfp);
|
2010-03-13 17:37:50 +00:00
|
|
|
strbuf_release(&sb);
|
2007-01-19 07:25:54 +00:00
|
|
|
return ret;
|
2006-12-18 09:18:16 +00:00
|
|
|
}
|
2006-12-19 06:07:45 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
|
2009-01-20 06:18:29 +00:00
|
|
|
{
|
2011-12-12 05:38:09 +00:00
|
|
|
return for_each_recent_reflog_ent(refname, fn, 0, cb_data);
|
2009-01-20 06:18:29 +00:00
|
|
|
}
|
|
|
|
|
2007-02-03 18:25:43 +00:00
|
|
|
static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(git_path("logs/%s", base));
|
2007-02-07 17:18:57 +00:00
|
|
|
int retval = 0;
|
2007-02-03 18:25:43 +00:00
|
|
|
|
|
|
|
if (dir) {
|
|
|
|
struct dirent *de;
|
|
|
|
int baselen = strlen(base);
|
|
|
|
char *log = xmalloc(baselen + 257);
|
|
|
|
|
|
|
|
memcpy(log, base, baselen);
|
|
|
|
if (baselen && base[baselen-1] != '/')
|
|
|
|
log[baselen++] = '/';
|
|
|
|
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
|
|
struct stat st;
|
|
|
|
int namelen;
|
|
|
|
|
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
namelen = strlen(de->d_name);
|
|
|
|
if (namelen > 255)
|
|
|
|
continue;
|
|
|
|
if (has_extension(de->d_name, ".lock"))
|
|
|
|
continue;
|
|
|
|
memcpy(log + baselen, de->d_name, namelen+1);
|
|
|
|
if (stat(git_path("logs/%s", log), &st) < 0)
|
|
|
|
continue;
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
retval = do_for_each_reflog(log, fn, cb_data);
|
|
|
|
} else {
|
|
|
|
unsigned char sha1[20];
|
2011-11-13 10:22:14 +00:00
|
|
|
if (read_ref_full(log, sha1, 0, NULL))
|
2007-02-03 18:25:43 +00:00
|
|
|
retval = error("bad ref for %s", log);
|
|
|
|
else
|
|
|
|
retval = fn(log, sha1, 0, cb_data);
|
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(log);
|
|
|
|
closedir(dir);
|
|
|
|
}
|
2007-02-13 07:21:34 +00:00
|
|
|
else if (*base)
|
2007-02-07 17:18:57 +00:00
|
|
|
return errno;
|
2007-02-03 18:25:43 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int for_each_reflog(each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return do_for_each_reflog("", fn, cb_data);
|
|
|
|
}
|
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)
|
|
|
|
{
|
|
|
|
static struct ref_lock *lock;
|
|
|
|
lock = lock_any_ref_for_update(refname, oldval, flags);
|
|
|
|
if (!lock) {
|
|
|
|
const char *str = "Cannot lock the ref '%s'.";
|
|
|
|
switch (onerr) {
|
|
|
|
case MSG_ON_ERR: error(str, refname); break;
|
|
|
|
case DIE_ON_ERR: die(str, refname); break;
|
|
|
|
case QUIET_ON_ERR: break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (write_ref_sha1(lock, sha1, action) < 0) {
|
|
|
|
const char *str = "Cannot update the ref '%s'.";
|
|
|
|
switch (onerr) {
|
|
|
|
case MSG_ON_ERR: error(str, refname); break;
|
|
|
|
case DIE_ON_ERR: die(str, refname); break;
|
|
|
|
case QUIET_ON_ERR: break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-11-18 07:13:10 +00:00
|
|
|
|
2011-10-10 22:56:19 +00:00
|
|
|
int ref_exists(const char *refname)
|
2011-06-06 05:17:04 +00:00
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
2011-12-12 11:20:32 +00:00
|
|
|
return !!resolve_ref_unsafe(refname, sha1, 1, NULL);
|
2011-06-06 05:17:04 +00:00
|
|
|
}
|
|
|
|
|
2009-02-25 08:32:10 +00:00
|
|
|
struct ref *find_ref_by_name(const struct ref *list, const char *name)
|
2007-11-18 07:13:10 +00:00
|
|
|
{
|
|
|
|
for ( ; list; list = list->next)
|
|
|
|
if (!strcmp(list->name, name))
|
2009-02-25 08:32:10 +00:00
|
|
|
return (struct ref *)list;
|
2007-11-18 07:13:10 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-04-07 07:14:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* generate a format suitable for scanf from a ref_rev_parse_rules
|
|
|
|
* rule, that is replace the "%.*s" spec with a "%s" spec
|
|
|
|
*/
|
|
|
|
static void gen_scanf_fmt(char *scanf_fmt, const char *rule)
|
|
|
|
{
|
|
|
|
char *spec;
|
|
|
|
|
|
|
|
spec = strstr(rule, "%.*s");
|
|
|
|
if (!spec || strstr(spec + 4, "%.*s"))
|
|
|
|
die("invalid rule in ref_rev_parse_rules: %s", rule);
|
|
|
|
|
|
|
|
/* copy all until spec */
|
|
|
|
strncpy(scanf_fmt, rule, spec - rule);
|
|
|
|
scanf_fmt[spec - rule] = '\0';
|
|
|
|
/* copy new spec */
|
|
|
|
strcat(scanf_fmt, "%s");
|
|
|
|
/* copy remaining rule */
|
|
|
|
strcat(scanf_fmt, spec + 4);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
char *shorten_unambiguous_ref(const char *refname, int strict)
|
2009-04-07 07:14:20 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
static char **scanf_fmts;
|
|
|
|
static int nr_rules;
|
|
|
|
char *short_name;
|
|
|
|
|
|
|
|
/* pre generate scanf formats from ref_rev_parse_rules[] */
|
|
|
|
if (!nr_rules) {
|
|
|
|
size_t total_len = 0;
|
|
|
|
|
|
|
|
/* the rule list is NULL terminated, count them first */
|
|
|
|
for (; ref_rev_parse_rules[nr_rules]; nr_rules++)
|
|
|
|
/* no +1 because strlen("%s") < strlen("%.*s") */
|
|
|
|
total_len += strlen(ref_rev_parse_rules[nr_rules]);
|
|
|
|
|
|
|
|
scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
|
|
|
|
|
|
|
|
total_len = 0;
|
|
|
|
for (i = 0; i < nr_rules; i++) {
|
|
|
|
scanf_fmts[i] = (char *)&scanf_fmts[nr_rules]
|
|
|
|
+ total_len;
|
|
|
|
gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);
|
|
|
|
total_len += strlen(ref_rev_parse_rules[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* bail out if there are no rules */
|
|
|
|
if (!nr_rules)
|
2011-12-12 05:38:09 +00:00
|
|
|
return xstrdup(refname);
|
2009-04-07 07:14:20 +00:00
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
/* buffer for scanf result, at most refname must fit */
|
|
|
|
short_name = xstrdup(refname);
|
2009-04-07 07:14:20 +00:00
|
|
|
|
|
|
|
/* skip first rule, it will always match */
|
|
|
|
for (i = nr_rules - 1; i > 0 ; --i) {
|
|
|
|
int j;
|
2009-04-13 10:25:46 +00:00
|
|
|
int rules_to_fail = i;
|
2009-04-07 07:14:20 +00:00
|
|
|
int short_name_len;
|
|
|
|
|
2011-12-12 05:38:09 +00:00
|
|
|
if (1 != sscanf(refname, scanf_fmts[i], short_name))
|
2009-04-07 07:14:20 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
short_name_len = strlen(short_name);
|
|
|
|
|
2009-04-13 10:25:46 +00:00
|
|
|
/*
|
|
|
|
* in strict mode, all (except the matched one) rules
|
|
|
|
* must fail to resolve to a valid non-ambiguous ref
|
|
|
|
*/
|
|
|
|
if (strict)
|
|
|
|
rules_to_fail = nr_rules;
|
|
|
|
|
2009-04-07 07:14:20 +00:00
|
|
|
/*
|
|
|
|
* check if the short name resolves to a valid ref,
|
|
|
|
* but use only rules prior to the matched one
|
|
|
|
*/
|
2009-04-13 10:25:46 +00:00
|
|
|
for (j = 0; j < rules_to_fail; j++) {
|
2009-04-07 07:14:20 +00:00
|
|
|
const char *rule = ref_rev_parse_rules[j];
|
|
|
|
char refname[PATH_MAX];
|
|
|
|
|
2009-04-13 10:25:46 +00:00
|
|
|
/* skip matched rule */
|
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2009-04-07 07:14:20 +00:00
|
|
|
/*
|
|
|
|
* the short name is ambiguous, if it resolves
|
|
|
|
* (with this previous rule) to a valid ref
|
|
|
|
* read_ref() returns 0 on success
|
|
|
|
*/
|
|
|
|
mksnpath(refname, sizeof(refname),
|
|
|
|
rule, short_name_len, short_name);
|
2011-11-13 10:22:14 +00:00
|
|
|
if (ref_exists(refname))
|
2009-04-07 07:14:20 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* short name is non-ambiguous if all previous rules
|
|
|
|
* haven't resolved to a valid ref
|
|
|
|
*/
|
2009-04-13 10:25:46 +00:00
|
|
|
if (j == rules_to_fail)
|
2009-04-07 07:14:20 +00:00
|
|
|
return short_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(short_name);
|
2011-12-12 05:38:09 +00:00
|
|
|
return xstrdup(refname);
|
2009-04-07 07:14:20 +00:00
|
|
|
}
|