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"
|
2005-06-06 20:31:29 +00:00
|
|
|
|
2006-11-22 07:36:35 +00:00
|
|
|
/* ISSYMREF=01 and ISPACKED=02 are public interfaces */
|
|
|
|
#define REF_KNOWS_PEELED 04
|
|
|
|
|
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
|
|
|
struct ref_list {
|
|
|
|
struct ref_list *next;
|
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];
|
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];
|
|
|
|
};
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
|
2006-11-22 07:36:35 +00:00
|
|
|
int flag, struct ref_list *list,
|
|
|
|
struct ref_list **new_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
|
|
|
{
|
|
|
|
int len;
|
2007-04-17 01:42:50 +00:00
|
|
|
struct ref_list *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
|
|
|
|
|
|
|
/* Allocate it and add it in.. */
|
|
|
|
len = strlen(name) + 1;
|
|
|
|
entry = xmalloc(sizeof(struct ref_list) + len);
|
|
|
|
hashcpy(entry->sha1, sha1);
|
2006-11-22 07:36:35 +00:00
|
|
|
hashclr(entry->peeled);
|
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
|
|
|
memcpy(entry->name, name, len);
|
2006-09-21 05:02:01 +00:00
|
|
|
entry->flag = flag;
|
2007-04-17 01:42:50 +00:00
|
|
|
entry->next = list;
|
2006-11-22 07:36:35 +00:00
|
|
|
if (new_entry)
|
|
|
|
*new_entry = entry;
|
2007-04-17 01:42:50 +00:00
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* merge sort the ref list */
|
|
|
|
static struct ref_list *sort_ref_list(struct ref_list *list)
|
|
|
|
{
|
|
|
|
int psize, qsize, last_merge_count, cmp;
|
|
|
|
struct ref_list *p, *q, *l, *e;
|
|
|
|
struct ref_list *new_list = list;
|
|
|
|
int k = 1;
|
|
|
|
int merge_count = 0;
|
|
|
|
|
|
|
|
if (!list)
|
|
|
|
return list;
|
|
|
|
|
|
|
|
do {
|
|
|
|
last_merge_count = merge_count;
|
|
|
|
merge_count = 0;
|
|
|
|
|
|
|
|
psize = 0;
|
|
|
|
|
|
|
|
p = new_list;
|
|
|
|
q = new_list;
|
|
|
|
new_list = NULL;
|
|
|
|
l = NULL;
|
|
|
|
|
|
|
|
while (p) {
|
|
|
|
merge_count++;
|
|
|
|
|
|
|
|
while (psize < k && q->next) {
|
|
|
|
q = q->next;
|
|
|
|
psize++;
|
|
|
|
}
|
|
|
|
qsize = k;
|
|
|
|
|
|
|
|
while ((psize > 0) || (qsize > 0 && q)) {
|
|
|
|
if (qsize == 0 || !q) {
|
|
|
|
e = p;
|
|
|
|
p = p->next;
|
|
|
|
psize--;
|
|
|
|
} else if (psize == 0) {
|
|
|
|
e = q;
|
|
|
|
q = q->next;
|
|
|
|
qsize--;
|
|
|
|
} else {
|
|
|
|
cmp = strcmp(q->name, p->name);
|
|
|
|
if (cmp < 0) {
|
|
|
|
e = q;
|
|
|
|
q = q->next;
|
|
|
|
qsize--;
|
|
|
|
} else if (cmp > 0) {
|
|
|
|
e = p;
|
|
|
|
p = p->next;
|
|
|
|
psize--;
|
|
|
|
} else {
|
|
|
|
if (hashcmp(q->sha1, p->sha1))
|
|
|
|
die("Duplicated ref, and SHA1s don't match: %s",
|
|
|
|
q->name);
|
|
|
|
warning("Duplicated ref: %s", q->name);
|
|
|
|
e = q;
|
|
|
|
q = q->next;
|
|
|
|
qsize--;
|
|
|
|
free(e);
|
|
|
|
e = p;
|
|
|
|
p = p->next;
|
|
|
|
psize--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
e->next = NULL;
|
|
|
|
|
|
|
|
if (l)
|
|
|
|
l->next = e;
|
|
|
|
if (!new_list)
|
|
|
|
new_list = e;
|
|
|
|
l = e;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = q;
|
|
|
|
};
|
|
|
|
|
|
|
|
k = k * 2;
|
|
|
|
} while ((last_merge_count != merge_count) || (last_merge_count != 1));
|
|
|
|
|
|
|
|
return new_list;
|
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.
|
|
|
|
*/
|
2007-06-13 08:42:05 +00:00
|
|
|
static struct cached_refs {
|
2006-09-30 19:37:37 +00:00
|
|
|
char did_loose;
|
|
|
|
char did_packed;
|
|
|
|
struct ref_list *loose;
|
|
|
|
struct ref_list *packed;
|
|
|
|
} cached_refs;
|
|
|
|
|
|
|
|
static void free_ref_list(struct ref_list *list)
|
|
|
|
{
|
|
|
|
struct ref_list *next;
|
|
|
|
for ( ; list; list = next) {
|
|
|
|
next = list->next;
|
|
|
|
free(list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void invalidate_cached_refs(void)
|
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
|
|
|
struct cached_refs *ca = &cached_refs;
|
|
|
|
|
|
|
|
if (ca->did_loose && ca->loose)
|
|
|
|
free_ref_list(ca->loose);
|
|
|
|
if (ca->did_packed && ca->packed)
|
|
|
|
free_ref_list(ca->packed);
|
|
|
|
ca->loose = ca->packed = NULL;
|
|
|
|
ca->did_loose = ca->did_packed = 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
|
|
|
|
2006-11-22 07:36:35 +00:00
|
|
|
static void read_packed_refs(FILE *f, struct cached_refs *cached_refs)
|
|
|
|
{
|
|
|
|
struct ref_list *list = NULL;
|
|
|
|
struct ref_list *last = NULL;
|
|
|
|
char refline[PATH_MAX];
|
|
|
|
int flag = REF_ISPACKED;
|
|
|
|
|
|
|
|
while (fgets(refline, sizeof(refline), f)) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
const char *name;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
name = parse_ref_line(refline, sha1);
|
|
|
|
if (name) {
|
|
|
|
list = add_ref(name, sha1, flag, list, &last);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (last &&
|
|
|
|
refline[0] == '^' &&
|
|
|
|
strlen(refline) == 42 &&
|
|
|
|
refline[41] == '\n' &&
|
|
|
|
!get_sha1_hex(refline + 1, sha1))
|
|
|
|
hashcpy(last->peeled, sha1);
|
|
|
|
}
|
2007-04-17 01:42:50 +00:00
|
|
|
cached_refs->packed = sort_ref_list(list);
|
2006-11-22 07:36:35 +00:00
|
|
|
}
|
|
|
|
|
2006-09-30 19:37:37 +00:00
|
|
|
static struct ref_list *get_packed_refs(void)
|
|
|
|
{
|
|
|
|
if (!cached_refs.did_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
|
|
|
FILE *f = fopen(git_path("packed-refs"), "r");
|
2006-11-22 07:36:35 +00:00
|
|
|
cached_refs.packed = 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 (f) {
|
2006-11-22 07:36:35 +00:00
|
|
|
read_packed_refs(f, &cached_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
|
|
|
fclose(f);
|
|
|
|
}
|
2006-09-30 19:37:37 +00:00
|
|
|
cached_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
|
|
|
}
|
2006-09-30 19:37:37 +00:00
|
|
|
return cached_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
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(git_path("%s", base));
|
|
|
|
|
|
|
|
if (dir) {
|
|
|
|
struct dirent *de;
|
|
|
|
int baselen = strlen(base);
|
2006-09-12 03:17:35 +00:00
|
|
|
char *ref = 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
|
|
|
|
2006-09-12 03:17:35 +00:00
|
|
|
memcpy(ref, 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] != '/')
|
2006-09-12 03:17:35 +00:00
|
|
|
ref[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;
|
|
|
|
|
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
namelen = strlen(de->d_name);
|
|
|
|
if (namelen > 255)
|
|
|
|
continue;
|
|
|
|
if (has_extension(de->d_name, ".lock"))
|
|
|
|
continue;
|
2006-09-12 03:17:35 +00:00
|
|
|
memcpy(ref + baselen, de->d_name, namelen+1);
|
|
|
|
if (stat(git_path("%s", ref), &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)) {
|
2006-09-12 03:17:35 +00:00
|
|
|
list = get_ref_dir(ref, list);
|
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;
|
|
|
|
}
|
2006-09-21 05:02:01 +00:00
|
|
|
if (!resolve_ref(ref, sha1, 1, &flag)) {
|
2006-09-12 03:17:35 +00:00
|
|
|
error("%s points nowhere!", 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
|
|
|
continue;
|
|
|
|
}
|
2006-11-22 07:36:35 +00:00
|
|
|
list = add_ref(ref, sha1, flag, list, 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
|
|
|
}
|
2006-09-12 03:17:35 +00:00
|
|
|
free(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
|
|
|
closedir(dir);
|
|
|
|
}
|
2007-04-17 01:42:50 +00:00
|
|
|
return sort_ref_list(list);
|
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
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_list *get_loose_refs(void)
|
|
|
|
{
|
2006-09-30 19:37:37 +00:00
|
|
|
if (!cached_refs.did_loose) {
|
|
|
|
cached_refs.loose = get_ref_dir("refs", NULL);
|
|
|
|
cached_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
|
|
|
}
|
2006-09-30 19:37:37 +00:00
|
|
|
return cached_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)
|
|
|
|
|
|
|
|
static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
|
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
struct cached_refs refs;
|
|
|
|
struct ref_list *ref;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
strcpy(name + pathlen, "packed-refs");
|
|
|
|
f = fopen(name, "r");
|
|
|
|
if (!f)
|
|
|
|
return -1;
|
|
|
|
read_packed_refs(f, &refs);
|
|
|
|
fclose(f);
|
|
|
|
ref = refs.packed;
|
|
|
|
retval = -1;
|
|
|
|
while (ref) {
|
|
|
|
if (!strcmp(ref->name, refname)) {
|
|
|
|
retval = 0;
|
|
|
|
memcpy(result, ref->sha1, 20);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ref = ref->next;
|
|
|
|
}
|
|
|
|
free_ref_list(refs.packed);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int resolve_gitlink_ref_recursive(char *name, int pathlen, const char *refname, unsigned char *result, int recursion)
|
|
|
|
{
|
|
|
|
int fd, len = strlen(refname);
|
|
|
|
char buffer[128], *p;
|
|
|
|
|
|
|
|
if (recursion > MAXDEPTH || len > MAXREFLEN)
|
|
|
|
return -1;
|
|
|
|
memcpy(name + pathlen, refname, len+1);
|
|
|
|
fd = open(name, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return resolve_gitlink_packed_ref(name, pathlen, refname, result);
|
|
|
|
|
|
|
|
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? */
|
|
|
|
if (!get_sha1_hex(buffer, result))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Symref? */
|
|
|
|
if (strncmp(buffer, "ref:", 4))
|
|
|
|
return -1;
|
|
|
|
p = buffer + 4;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
|
|
|
|
return resolve_gitlink_ref_recursive(name, pathlen, p, result, recursion+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *result)
|
|
|
|
{
|
|
|
|
int len = strlen(path), retval;
|
|
|
|
char *gitdir;
|
|
|
|
|
|
|
|
while (len && path[len-1] == '/')
|
|
|
|
len--;
|
|
|
|
if (!len)
|
|
|
|
return -1;
|
|
|
|
gitdir = xmalloc(len + MAXREFLEN + 8);
|
|
|
|
memcpy(gitdir, path, len);
|
|
|
|
memcpy(gitdir + len, "/.git/", 7);
|
|
|
|
|
|
|
|
retval = resolve_gitlink_ref_recursive(gitdir, len+6, refname, result, 0);
|
|
|
|
free(gitdir);
|
|
|
|
return retval;
|
|
|
|
}
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
|
2005-07-03 03:23:36 +00:00
|
|
|
{
|
2005-09-30 21:08:25 +00:00
|
|
|
int depth = MAXDEPTH, len;
|
|
|
|
char buffer[256];
|
2006-09-12 03:17:35 +00:00
|
|
|
static char ref_buffer[256];
|
2005-09-25 16:59:37 +00:00
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
if (flag)
|
|
|
|
*flag = 0;
|
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
for (;;) {
|
2006-09-12 03:17:35 +00:00
|
|
|
const char *path = git_path("%s", ref);
|
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
|
|
|
|
2005-09-30 21:08:25 +00:00
|
|
|
/* Special case: non-existing file.
|
|
|
|
* Not having the refs/heads/new-branch is OK
|
|
|
|
* if we are writing into it, so is .git/HEAD
|
|
|
|
* that points at refs/heads/master still to be
|
|
|
|
* born. It is NOT OK if we are resolving for
|
|
|
|
* reading.
|
|
|
|
*/
|
|
|
|
if (lstat(path, &st) < 0) {
|
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
|
|
|
struct ref_list *list = get_packed_refs();
|
|
|
|
while (list) {
|
2006-11-22 07:36:35 +00:00
|
|
|
if (!strcmp(ref, list->name)) {
|
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
|
|
|
hashcpy(sha1, list->sha1);
|
2006-09-21 05:02:01 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISPACKED;
|
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
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
list = list->next;
|
|
|
|
}
|
2005-09-30 21:08:25 +00:00
|
|
|
if (reading || errno != ENOENT)
|
|
|
|
return NULL;
|
2006-08-23 06:49:00 +00:00
|
|
|
hashclr(sha1);
|
2006-09-12 03:17:35 +00:00
|
|
|
return ref;
|
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);
|
|
|
|
if (len >= 5 && !memcmp("refs/", buffer, 5)) {
|
2006-09-12 03:17:35 +00:00
|
|
|
buffer[len] = 0;
|
|
|
|
strcpy(ref_buffer, buffer);
|
|
|
|
ref = ref_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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is it a symbolic ref?
|
|
|
|
*/
|
|
|
|
if (len < 4 || memcmp("ref:", buffer, 4))
|
|
|
|
break;
|
|
|
|
buf = buffer + 4;
|
|
|
|
len -= 4;
|
|
|
|
while (len && isspace(*buf))
|
|
|
|
buf++, len--;
|
|
|
|
while (len && isspace(buf[len-1]))
|
2006-09-12 03:17:35 +00:00
|
|
|
len--;
|
|
|
|
buf[len] = 0;
|
|
|
|
memcpy(ref_buffer, buf, len + 1);
|
|
|
|
ref = ref_buffer;
|
2006-09-21 05:02:01 +00:00
|
|
|
if (flag)
|
|
|
|
*flag |= REF_ISSYMREF;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
2005-09-30 21:08:25 +00:00
|
|
|
if (len < 40 || get_sha1_hex(buffer, sha1))
|
|
|
|
return NULL;
|
2006-09-12 03:17:35 +00:00
|
|
|
return ref;
|
2005-09-30 21:08:25 +00:00
|
|
|
}
|
|
|
|
|
2006-09-12 03:17:35 +00:00
|
|
|
int read_ref(const char *ref, unsigned char *sha1)
|
2005-09-30 21:08:25 +00:00
|
|
|
{
|
2006-09-21 05:02:01 +00:00
|
|
|
if (resolve_ref(ref, sha1, 1, NULL))
|
2005-09-30 21:08:25 +00:00
|
|
|
return 0;
|
|
|
|
return -1;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2006-11-19 06:13:33 +00:00
|
|
|
static int do_one_ref(const char *base, each_ref_fn fn, int trim,
|
|
|
|
void *cb_data, struct ref_list *entry)
|
|
|
|
{
|
|
|
|
if (strncmp(base, entry->name, trim))
|
|
|
|
return 0;
|
|
|
|
if (is_null_sha1(entry->sha1))
|
|
|
|
return 0;
|
|
|
|
if (!has_sha1_file(entry->sha1)) {
|
|
|
|
error("%s does not point to a valid object!", entry->name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
|
|
|
|
}
|
|
|
|
|
2006-11-19 21:22:44 +00:00
|
|
|
int peel_ref(const char *ref, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
int flag;
|
|
|
|
unsigned char base[20];
|
|
|
|
struct object *o;
|
|
|
|
|
|
|
|
if (!resolve_ref(ref, base, 1, &flag))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if ((flag & REF_ISPACKED)) {
|
|
|
|
struct ref_list *list = get_packed_refs();
|
|
|
|
|
|
|
|
while (list) {
|
2006-11-22 07:36:35 +00:00
|
|
|
if (!strcmp(list->name, ref)) {
|
|
|
|
if (list->flag & REF_KNOWS_PEELED) {
|
|
|
|
hashcpy(sha1, list->peeled);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* older pack-refs did not leave peeled ones */
|
|
|
|
break;
|
2006-11-19 21:22:44 +00:00
|
|
|
}
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-22 07:36:35 +00:00
|
|
|
/* fallback - callers should not call this for unpacked refs */
|
2006-11-19 21:22:44 +00:00
|
|
|
o = parse_object(base);
|
|
|
|
if (o->type == OBJ_TAG) {
|
|
|
|
o = deref_tag(o, ref, 0);
|
|
|
|
if (o) {
|
|
|
|
hashcpy(sha1, o->sha1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-09-21 05:02:01 +00:00
|
|
|
static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
|
|
|
|
void *cb_data)
|
2005-07-03 03:23:36 +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
|
|
|
int retval;
|
|
|
|
struct ref_list *packed = get_packed_refs();
|
|
|
|
struct ref_list *loose = get_loose_refs();
|
2005-07-03 03:23:36 +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
|
|
|
while (packed && loose) {
|
|
|
|
struct ref_list *entry;
|
|
|
|
int cmp = strcmp(packed->name, loose->name);
|
|
|
|
if (!cmp) {
|
|
|
|
packed = packed->next;
|
|
|
|
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) {
|
|
|
|
entry = loose;
|
|
|
|
loose = loose->next;
|
|
|
|
} else {
|
|
|
|
entry = packed;
|
|
|
|
packed = packed->next;
|
|
|
|
}
|
2006-11-19 06:13:33 +00:00
|
|
|
retval = do_one_ref(base, fn, trim, 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)
|
|
|
|
return retval;
|
|
|
|
}
|
2005-07-03 03:23:36 +00:00
|
|
|
|
2006-11-19 06:13:33 +00:00
|
|
|
for (packed = packed ? packed : loose; packed; packed = packed->next) {
|
|
|
|
retval = do_one_ref(base, fn, trim, cb_data, packed);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2005-07-03 03:23:36 +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 0;
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
int head_ref(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;
|
|
|
|
|
|
|
|
if (resolve_ref("HEAD", sha1, 1, &flag))
|
|
|
|
return fn("HEAD", sha1, flag, cb_data);
|
2005-07-05 22:45:00 +00:00
|
|
|
return 0;
|
2005-07-05 18:31:32 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2006-09-21 04:47:42 +00:00
|
|
|
return do_for_each_ref("refs/", fn, 0, cb_data);
|
2006-05-14 01:43:00 +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
|
|
|
{
|
2006-09-21 04:47:42 +00:00
|
|
|
return do_for_each_ref("refs/tags/", fn, 10, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2006-09-21 04:47:42 +00:00
|
|
|
return do_for_each_ref("refs/heads/", fn, 11, cb_data);
|
2006-05-14 01:43:00 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2006-09-21 04:47:42 +00:00
|
|
|
return do_for_each_ref("refs/remotes/", fn, 13, cb_data);
|
2005-07-03 03:23:36 +00:00
|
|
|
}
|
|
|
|
|
2006-09-21 04:47:42 +00:00
|
|
|
/* NEEDSWORK: This is only used by ssh-upload and it should go; the
|
|
|
|
* caller should do resolve_ref or read_ref like everybody else. Or
|
|
|
|
* maybe everybody else should use get_ref_sha1() instead of doing
|
|
|
|
* read_ref().
|
|
|
|
*/
|
2005-06-06 20:31:29 +00:00
|
|
|
int get_ref_sha1(const char *ref, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
if (check_ref_format(ref))
|
|
|
|
return -1;
|
2006-09-12 03:17:35 +00:00
|
|
|
return read_ref(mkpath("refs/%s", ref), sha1);
|
2005-06-06 20:31:29 +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 "/".
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int bad_ref_char(int ch)
|
|
|
|
{
|
2007-05-25 05:20:56 +00:00
|
|
|
if (((unsigned) ch) <= ' ' ||
|
|
|
|
ch == '~' || ch == '^' || ch == ':')
|
|
|
|
return 1;
|
|
|
|
/* 2.13 Pattern Matching Notation */
|
|
|
|
if (ch == '?' || ch == '[') /* Unsupported */
|
|
|
|
return 1;
|
|
|
|
if (ch == '*') /* Supported at the end */
|
|
|
|
return 2;
|
|
|
|
return 0;
|
2005-10-14 01:57:39 +00:00
|
|
|
}
|
|
|
|
|
2005-06-06 20:31:29 +00:00
|
|
|
int check_ref_format(const char *ref)
|
|
|
|
{
|
2007-05-25 05:20:56 +00:00
|
|
|
int ch, level, bad_type;
|
2005-10-14 01:57:39 +00:00
|
|
|
const char *cp = ref;
|
|
|
|
|
|
|
|
level = 0;
|
|
|
|
while (1) {
|
|
|
|
while ((ch = *cp++) == '/')
|
|
|
|
; /* tolerate duplicated slashes */
|
|
|
|
if (!ch)
|
|
|
|
return -1; /* should not end with slashes */
|
|
|
|
|
|
|
|
/* we are at the beginning of the path component */
|
2007-05-25 05:20:56 +00:00
|
|
|
if (ch == '.')
|
2005-10-14 01:57:39 +00:00
|
|
|
return -1;
|
2007-05-25 05:20:56 +00:00
|
|
|
bad_type = bad_ref_char(ch);
|
|
|
|
if (bad_type) {
|
|
|
|
return (bad_type == 2 && !*cp) ? -3 : -1;
|
|
|
|
}
|
2005-10-14 01:57:39 +00:00
|
|
|
|
|
|
|
/* scan the rest of the path component */
|
|
|
|
while ((ch = *cp++) != 0) {
|
2007-05-25 05:20:56 +00:00
|
|
|
bad_type = bad_ref_char(ch);
|
|
|
|
if (bad_type) {
|
|
|
|
return (bad_type == 2 && !*cp) ? -3 : -1;
|
|
|
|
}
|
2005-10-14 01:57:39 +00:00
|
|
|
if (ch == '/')
|
|
|
|
break;
|
|
|
|
if (ch == '.' && *cp == '.')
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
level++;
|
|
|
|
if (!ch) {
|
|
|
|
if (level < 2)
|
2006-12-13 18:30:11 +00:00
|
|
|
return -2; /* at least of form "heads/blah" */
|
2005-10-14 01:57:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2005-06-06 20:31:29 +00:00
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2006-09-21 05:02:01 +00:00
|
|
|
if (!resolve_ref(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;
|
|
|
|
}
|
|
|
|
|
2006-09-30 09:25:30 +00:00
|
|
|
static int remove_empty_dir_recursive(char *path, int len)
|
|
|
|
{
|
|
|
|
DIR *dir = opendir(path);
|
|
|
|
struct dirent *e;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
return -1;
|
|
|
|
if (path[len-1] != '/')
|
|
|
|
path[len++] = '/';
|
|
|
|
while ((e = readdir(dir)) != NULL) {
|
|
|
|
struct stat st;
|
|
|
|
int namlen;
|
|
|
|
if ((e->d_name[0] == '.') &&
|
|
|
|
((e->d_name[1] == 0) ||
|
|
|
|
((e->d_name[1] == '.') && e->d_name[2] == 0)))
|
|
|
|
continue; /* "." and ".." */
|
|
|
|
|
|
|
|
namlen = strlen(e->d_name);
|
|
|
|
if ((len + namlen < PATH_MAX) &&
|
|
|
|
strcpy(path + len, e->d_name) &&
|
|
|
|
!lstat(path, &st) &&
|
|
|
|
S_ISDIR(st.st_mode) &&
|
2006-10-01 12:36:49 +00:00
|
|
|
!remove_empty_dir_recursive(path, len + namlen))
|
2006-09-30 09:25:30 +00:00
|
|
|
continue; /* happy */
|
|
|
|
|
|
|
|
/* path too long, stat fails, or non-directory still exists */
|
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
if (!ret) {
|
|
|
|
path[len] = 0;
|
|
|
|
ret = rmdir(path);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int remove_empty_directories(char *file)
|
|
|
|
{
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
char path[PATH_MAX];
|
|
|
|
int len = strlen(file);
|
|
|
|
|
|
|
|
if (len >= PATH_MAX) /* path too long ;-) */
|
|
|
|
return -1;
|
|
|
|
strcpy(path, file);
|
|
|
|
return remove_empty_dir_recursive(path, len);
|
|
|
|
}
|
|
|
|
|
2006-11-28 14:47:40 +00:00
|
|
|
static int is_refname_available(const char *ref, const char *oldref,
|
|
|
|
struct ref_list *list, int quiet)
|
|
|
|
{
|
|
|
|
int namlen = strlen(ref); /* e.g. 'foo/bar' */
|
|
|
|
while (list) {
|
|
|
|
/* list->name could be 'foo' or 'foo/bar/baz' */
|
|
|
|
if (!oldref || strcmp(oldref, list->name)) {
|
|
|
|
int len = strlen(list->name);
|
|
|
|
int cmplen = (namlen < len) ? namlen : len;
|
|
|
|
const char *lead = (namlen < len) ? list->name : ref;
|
|
|
|
if (!strncmp(ref, list->name, cmplen) &&
|
|
|
|
lead[cmplen] == '/') {
|
|
|
|
if (!quiet)
|
|
|
|
error("'%s' exists; cannot create '%s'",
|
|
|
|
list->name, ref);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
static struct ref_lock *lock_ref_sha1_basic(const char *ref, 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;
|
2006-09-12 03:17:35 +00:00
|
|
|
const char *orig_ref = ref;
|
2006-05-17 09:55:02 +00:00
|
|
|
struct ref_lock *lock;
|
2006-05-19 07:29:05 +00:00
|
|
|
struct stat st;
|
2006-09-30 21:14:31 +00:00
|
|
|
int last_errno = 0;
|
2007-05-09 10:33:20 +00:00
|
|
|
int type;
|
2006-09-27 08:09:18 +00:00
|
|
|
int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
|
2006-05-17 09:55:02 +00:00
|
|
|
|
|
|
|
lock = xcalloc(1, sizeof(struct ref_lock));
|
|
|
|
lock->lock_fd = -1;
|
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
ref = resolve_ref(ref, lock->old_sha1, mustexist, &type);
|
2006-09-30 09:25:30 +00:00
|
|
|
if (!ref && errno == EISDIR) {
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
ref_file = git_path("%s", orig_ref);
|
2006-09-30 21:14:31 +00:00
|
|
|
if (remove_empty_directories(ref_file)) {
|
|
|
|
last_errno = errno;
|
|
|
|
error("there are still refs under '%s'", orig_ref);
|
|
|
|
goto error_return;
|
|
|
|
}
|
2007-05-09 10:33:20 +00:00
|
|
|
ref = resolve_ref(orig_ref, 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;
|
2006-09-12 03:17:35 +00:00
|
|
|
if (!ref) {
|
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",
|
2006-09-12 03:17:35 +00:00
|
|
|
orig_ref, strerror(errno));
|
2006-09-30 21:14:31 +00:00
|
|
|
goto error_return;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
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.
|
|
|
|
*/
|
|
|
|
if (is_null_sha1(lock->old_sha1) &&
|
|
|
|
!is_refname_available(ref, NULL, get_packed_refs(), 0))
|
|
|
|
goto error_return;
|
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
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
if (flags & REF_NODEREF)
|
|
|
|
ref = orig_ref;
|
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
|
|
|
lock->ref_name = xstrdup(ref);
|
2007-01-26 22:26:06 +00:00
|
|
|
lock->orig_ref_name = xstrdup(orig_ref);
|
2006-09-22 23:08:45 +00:00
|
|
|
ref_file = git_path("%s", ref);
|
2007-05-09 10:33:20 +00:00
|
|
|
if (lstat(ref_file, &st) && errno == ENOENT)
|
|
|
|
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;
|
|
|
|
}
|
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
|
|
|
lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);
|
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
|
|
|
}
|
|
|
|
|
2006-09-27 08:09:18 +00:00
|
|
|
struct ref_lock *lock_ref_sha1(const char *ref, 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];
|
2005-06-06 20:31:29 +00:00
|
|
|
if (check_ref_format(ref))
|
2006-05-17 09:55:02 +00:00
|
|
|
return NULL;
|
2006-09-19 20:58:23 +00:00
|
|
|
strcpy(refpath, mkpath("refs/%s", ref));
|
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
|
|
|
}
|
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags)
|
2006-05-17 09:55:02 +00:00
|
|
|
{
|
2007-01-29 08:57:07 +00:00
|
|
|
if (check_ref_format(ref) == -1)
|
|
|
|
return NULL;
|
2007-05-09 10:33:20 +00:00
|
|
|
return lock_ref_sha1_basic(ref, 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)
|
|
|
|
{
|
|
|
|
struct ref_list *list, *packed_ref_list;
|
|
|
|
int fd;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
packed_ref_list = get_packed_refs();
|
|
|
|
for (list = packed_ref_list; list; list = list->next) {
|
|
|
|
if (!strcmp(refname, list->name)) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found)
|
|
|
|
return 0;
|
|
|
|
fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
|
|
|
|
if (fd < 0)
|
|
|
|
return error("cannot delete '%s' from packed refs", refname);
|
|
|
|
|
|
|
|
for (list = packed_ref_list; list; list = list->next) {
|
|
|
|
char line[PATH_MAX + 100];
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!strcmp(refname, list->name))
|
|
|
|
continue;
|
|
|
|
len = snprintf(line, sizeof(line), "%s %s\n",
|
|
|
|
sha1_to_hex(list->sha1), list->name);
|
|
|
|
/* this should not happen but just being defensive */
|
|
|
|
if (len > sizeof(line))
|
|
|
|
die("too long a refname '%s'", list->name);
|
|
|
|
write_or_die(fd, line, len);
|
|
|
|
}
|
|
|
|
return commit_lock_file(&packlock);
|
|
|
|
}
|
|
|
|
|
2007-04-18 03:34:34 +00:00
|
|
|
int delete_ref(const char *refname, const unsigned char *sha1)
|
2006-09-30 22:02:00 +00:00
|
|
|
{
|
|
|
|
struct ref_lock *lock;
|
|
|
|
int err, i, ret = 0, flag = 0;
|
|
|
|
|
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;
|
|
|
|
if (!(flag & REF_ISPACKED)) {
|
|
|
|
/* loose */
|
|
|
|
i = strlen(lock->lk->filename) - 5; /* .lock */
|
|
|
|
lock->lk->filename[i] = 0;
|
|
|
|
err = unlink(lock->lk->filename);
|
|
|
|
if (err) {
|
|
|
|
ret = 1;
|
|
|
|
error("unlink(%s) failed: %s",
|
|
|
|
lock->lk->filename, strerror(errno));
|
|
|
|
}
|
|
|
|
lock->lk->filename[i] = '.';
|
|
|
|
}
|
|
|
|
/* 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);
|
|
|
|
|
2007-01-26 22:26:05 +00:00
|
|
|
err = unlink(git_path("logs/%s", lock->ref_name));
|
2006-09-30 22:02:00 +00:00
|
|
|
if (err && errno != ENOENT)
|
|
|
|
fprintf(stderr, "warning: unlink(%s) failed: %s",
|
2007-01-26 22:26:05 +00:00
|
|
|
git_path("logs/%s", lock->ref_name), strerror(errno));
|
2006-09-30 22:02:00 +00:00
|
|
|
invalidate_cached_refs();
|
|
|
|
unlock_ref(lock);
|
|
|
|
return ret;
|
2006-05-17 09:55:02 +00:00
|
|
|
}
|
|
|
|
|
2006-11-30 02:16:56 +00:00
|
|
|
int rename_ref(const char *oldref, const char *newref, const char *logmsg)
|
2006-11-28 14:47:40 +00:00
|
|
|
{
|
|
|
|
static const char renamed_ref[] = "RENAMED-REF";
|
|
|
|
unsigned char sha1[20], orig_sha1[20];
|
|
|
|
int flag = 0, logmoved = 0;
|
|
|
|
struct ref_lock *lock;
|
|
|
|
struct stat loginfo;
|
2006-11-29 20:44:56 +00:00
|
|
|
int log = !lstat(git_path("logs/%s", oldref), &loginfo);
|
2006-11-28 14:47:40 +00:00
|
|
|
|
|
|
|
if (S_ISLNK(loginfo.st_mode))
|
|
|
|
return error("reflog for %s is a symlink", oldref);
|
|
|
|
|
|
|
|
if (!resolve_ref(oldref, orig_sha1, 1, &flag))
|
|
|
|
return error("refname %s not found", oldref);
|
|
|
|
|
|
|
|
if (!is_refname_available(newref, oldref, get_packed_refs(), 0))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (!is_refname_available(newref, oldref, get_loose_refs(), 0))
|
|
|
|
return 1;
|
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_ref_sha1_basic(renamed_ref, NULL, 0, NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!lock)
|
|
|
|
return error("unable to lock %s", renamed_ref);
|
|
|
|
lock->force_write = 1;
|
2006-11-30 02:16:56 +00:00
|
|
|
if (write_ref_sha1(lock, orig_sha1, logmsg))
|
2006-11-28 14:47:40 +00:00
|
|
|
return error("unable to save current sha1 in %s", renamed_ref);
|
|
|
|
|
|
|
|
if (log && rename(git_path("logs/%s", oldref), git_path("tmp-renamed-log")))
|
|
|
|
return error("unable to move logfile logs/%s to tmp-renamed-log: %s",
|
|
|
|
oldref, strerror(errno));
|
|
|
|
|
|
|
|
if (delete_ref(oldref, orig_sha1)) {
|
|
|
|
error("unable to delete old %s", oldref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resolve_ref(newref, sha1, 1, &flag) && delete_ref(newref, sha1)) {
|
|
|
|
if (errno==EISDIR) {
|
|
|
|
if (remove_empty_directories(git_path("%s", newref))) {
|
|
|
|
error("Directory not empty: %s", newref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
error("unable to delete existing %s", newref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log && safe_create_leading_directories(git_path("logs/%s", newref))) {
|
|
|
|
error("unable to create directory for %s", newref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
retry:
|
|
|
|
if (log && rename(git_path("tmp-renamed-log"), git_path("logs/%s", newref))) {
|
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.
|
|
|
|
*/
|
2006-11-28 14:47:40 +00:00
|
|
|
if (remove_empty_directories(git_path("logs/%s", newref))) {
|
|
|
|
error("Directory not empty: logs/%s", newref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
goto retry;
|
|
|
|
} else {
|
|
|
|
error("unable to move logfile tmp-renamed-log to logs/%s: %s",
|
|
|
|
newref, strerror(errno));
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
logmoved = log;
|
|
|
|
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_ref_sha1_basic(newref, NULL, 0, NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!lock) {
|
|
|
|
error("unable to lock %s for update", newref);
|
|
|
|
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)) {
|
2006-11-28 14:47:40 +00:00
|
|
|
error("unable to write current sha1 into %s", newref);
|
|
|
|
goto rollback;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rollback:
|
2007-05-09 10:33:20 +00:00
|
|
|
lock = lock_ref_sha1_basic(oldref, NULL, 0, NULL);
|
2006-11-28 14:47:40 +00:00
|
|
|
if (!lock) {
|
|
|
|
error("unable to lock %s for rollback", oldref);
|
|
|
|
goto rollbacklog;
|
|
|
|
}
|
|
|
|
|
|
|
|
lock->force_write = 1;
|
|
|
|
flag = log_all_ref_updates;
|
|
|
|
log_all_ref_updates = 0;
|
|
|
|
if (write_ref_sha1(lock, orig_sha1, NULL))
|
|
|
|
error("unable to write current sha1 into %s", oldref);
|
|
|
|
log_all_ref_updates = flag;
|
|
|
|
|
|
|
|
rollbacklog:
|
|
|
|
if (logmoved && rename(git_path("logs/%s", newref), git_path("logs/%s", oldref)))
|
|
|
|
error("unable to restore logfile %s from %s: %s",
|
|
|
|
oldref, newref, strerror(errno));
|
|
|
|
if (!logmoved && log &&
|
|
|
|
rename(git_path("tmp-renamed-log"), git_path("logs/%s", oldref)))
|
|
|
|
error("unable to restore logfile %s from tmp-renamed-log: %s",
|
|
|
|
oldref, strerror(errno));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-06-06 21:04:17 +00:00
|
|
|
void unlock_ref(struct ref_lock *lock)
|
2006-05-17 09:55:02 +00:00
|
|
|
{
|
|
|
|
if (lock->lock_fd >= 0) {
|
|
|
|
close(lock->lock_fd);
|
2006-06-06 20:54:14 +00:00
|
|
|
/* Do not free lock->lk -- atexit() still looks at them */
|
|
|
|
if (lock->lk)
|
|
|
|
rollback_lock_file(lock->lk);
|
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
|
|
|
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-01-26 22:26:05 +00:00
|
|
|
static int log_ref_write(const char *ref_name, const unsigned char *old_sha1,
|
|
|
|
const unsigned char *new_sha1, const char *msg)
|
2006-05-17 09:55:40 +00:00
|
|
|
{
|
|
|
|
int logfd, written, oflags = O_APPEND | O_WRONLY;
|
|
|
|
unsigned maxlen, len;
|
2007-01-26 10:26:04 +00:00
|
|
|
int msglen;
|
2007-01-26 22:26:05 +00:00
|
|
|
char *log_file, *logrec;
|
2006-07-09 09:36:24 +00:00
|
|
|
const char *committer;
|
2006-05-17 09:55:40 +00:00
|
|
|
|
Move initialization of log_all_ref_updates
The patches to prevent Porcelainish that require working tree
from doing any damage in a bare repository make a lot of sense,
and I want to make the is_bare_git_dir() function more reliable.
In order to allow the repository owner override the heuristic
implemented in is_bare_git_dir() if/when it misidentifies a
particular repository, it would make sense to introduce a new
configuration variable "[core] bare = true/false", and make
is_bare_git_dir() notice it.
The scripts would do a 'repo-config --bool --get core.bare' and
iff the command fails (i.e. there is no such variable in the
configuration file), it would use the heuristic implemented at
the script level [*1*].
However, setup_git_env() which is called a lot earlier than we
even read from the repository configuration currently makes a
call to is_bare_git_dir(), in order to change the default
setting for log_all_ref_updates. It somehow feels that this is
a hack.
By the way, [*1*] is another thing I hate about the current
config mechanism. "git-repo-config --get" does not know what
the possible configuration variables are, let alone what the
default values for them are. It allows us not to maintain a
centralized configuration table, which makes it easy to
introduce ad-hoc variables and gives a warm fuzzy feeling of
being modular, but my feeling is that it is turning out to be a
rather high price to pay for scripts.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-07 09:35:34 +00:00
|
|
|
if (log_all_ref_updates < 0)
|
2007-01-07 10:00:28 +00:00
|
|
|
log_all_ref_updates = !is_bare_repository();
|
Move initialization of log_all_ref_updates
The patches to prevent Porcelainish that require working tree
from doing any damage in a bare repository make a lot of sense,
and I want to make the is_bare_git_dir() function more reliable.
In order to allow the repository owner override the heuristic
implemented in is_bare_git_dir() if/when it misidentifies a
particular repository, it would make sense to introduce a new
configuration variable "[core] bare = true/false", and make
is_bare_git_dir() notice it.
The scripts would do a 'repo-config --bool --get core.bare' and
iff the command fails (i.e. there is no such variable in the
configuration file), it would use the heuristic implemented at
the script level [*1*].
However, setup_git_env() which is called a lot earlier than we
even read from the repository configuration currently makes a
call to is_bare_git_dir(), in order to change the default
setting for log_all_ref_updates. It somehow feels that this is
a hack.
By the way, [*1*] is another thing I hate about the current
config mechanism. "git-repo-config --get" does not know what
the possible configuration variables are, let alone what the
default values for them are. It allows us not to maintain a
centralized configuration table, which makes it easy to
introduce ad-hoc variables and gives a warm fuzzy feeling of
being modular, but my feeling is that it is turning out to be a
rather high price to pay for scripts.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-07 09:35:34 +00:00
|
|
|
|
2007-01-26 22:26:05 +00:00
|
|
|
log_file = git_path("logs/%s", ref_name);
|
|
|
|
|
2006-10-08 08:35:18 +00:00
|
|
|
if (log_all_ref_updates &&
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
(!prefixcmp(ref_name, "refs/heads/") ||
|
|
|
|
!prefixcmp(ref_name, "refs/remotes/") ||
|
2007-01-26 22:26:07 +00:00
|
|
|
!strcmp(ref_name, "HEAD"))) {
|
2007-01-26 22:26:05 +00:00
|
|
|
if (safe_create_leading_directories(log_file) < 0)
|
2006-05-17 09:55:40 +00:00
|
|
|
return error("unable to create directory for %s",
|
2007-01-26 22:26:05 +00:00
|
|
|
log_file);
|
2006-05-17 09:55:40 +00:00
|
|
|
oflags |= O_CREAT;
|
|
|
|
}
|
|
|
|
|
2007-01-26 22:26:05 +00:00
|
|
|
logfd = open(log_file, 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) {
|
2007-01-26 22:26:05 +00:00
|
|
|
if (remove_empty_directories(log_file)) {
|
2006-10-19 08:28:47 +00:00
|
|
|
return error("There are still logs under '%s'",
|
2007-01-26 22:26:05 +00:00
|
|
|
log_file);
|
2006-10-19 08:28:47 +00:00
|
|
|
}
|
2007-01-26 22:26:05 +00:00
|
|
|
logfd = open(log_file, oflags, 0666);
|
2006-10-19 08:28:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (logfd < 0)
|
|
|
|
return error("Unable to append to %s: %s",
|
2007-01-26 22:26:05 +00:00
|
|
|
log_file, strerror(errno));
|
2006-05-17 09:55:40 +00:00
|
|
|
}
|
|
|
|
|
2007-03-09 22:38:57 +00:00
|
|
|
adjust_shared_perm(log_file);
|
|
|
|
|
2007-01-26 10:26:04 +00:00
|
|
|
msglen = 0;
|
2006-05-17 09:55:40 +00:00
|
|
|
if (msg) {
|
2007-01-26 10:26:04 +00:00
|
|
|
/* clean up the message and make sure it is a single line */
|
|
|
|
for ( ; *msg; msg++)
|
|
|
|
if (!isspace(*msg))
|
|
|
|
break;
|
|
|
|
if (*msg) {
|
|
|
|
const char *ep = strchr(msg, '\n');
|
|
|
|
if (ep)
|
|
|
|
msglen = ep - msg;
|
|
|
|
else
|
|
|
|
msglen = strlen(msg);
|
|
|
|
}
|
2006-05-17 09:55:40 +00:00
|
|
|
}
|
2007-01-26 10:26:04 +00:00
|
|
|
|
|
|
|
committer = git_committer_info(-1);
|
|
|
|
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)
|
|
|
|
len += sprintf(logrec + len - 1, "\t%.*s\n", msglen, 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;
|
|
|
|
}
|
|
|
|
|
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';
|
|
|
|
|
|
|
|
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
|
|
|
}
|
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
|
2006-05-17 09:55:02 +00:00
|
|
|
|| close(lock->lock_fd) < 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;
|
|
|
|
}
|
2006-09-30 19:37:37 +00:00
|
|
|
invalidate_cached_refs();
|
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;
|
|
|
|
head_ref = resolve_ref("HEAD", head_sha1, 1, &head_flag);
|
|
|
|
if (head_ref && (head_flag & REF_ISSYMREF) &&
|
|
|
|
!strcmp(head_ref, lock->ref_name))
|
|
|
|
log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
|
|
|
|
}
|
2006-06-06 20:54:14 +00:00
|
|
|
if (commit_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
|
|
|
error("Couldn't set %s", lock->ref_name);
|
2006-05-17 09:55:02 +00:00
|
|
|
unlock_ref(lock);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
lock->lock_fd = -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;
|
2007-01-27 01:49:00 +00:00
|
|
|
char *git_HEAD = xstrdup(git_path("%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:
|
|
|
|
unlink(lockpath);
|
|
|
|
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;
|
|
|
|
char *msg;
|
|
|
|
|
|
|
|
line += 82;
|
|
|
|
for (ep = line; ep < endp && *ep != '\n'; ep++)
|
|
|
|
;
|
|
|
|
msg = xmalloc(ep - line + 1);
|
|
|
|
memcpy(msg, line, ep - line);
|
|
|
|
msg[ep - line] = 0;
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
int read_ref_at(const char *ref, 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
|
|
|
|
|
|
|
logfile = git_path("logs/%s", ref);
|
|
|
|
logfd = open(logfile, O_RDONLY, 0);
|
|
|
|
if (logfd < 0)
|
|
|
|
die("Unable to read log %s: %s", logfile, strerror(errno));
|
|
|
|
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)) {
|
2006-05-19 07:28:19 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"warning: Log %s has gap after %s.\n",
|
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)) {
|
2006-05-19 07:28:19 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
"warning: Log %s unexpectedly ended on %s.\n",
|
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);
|
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
|
|
|
|
2007-01-08 00:59:54 +00:00
|
|
|
int for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data)
|
2006-12-18 09:18:16 +00:00
|
|
|
{
|
|
|
|
const char *logfile;
|
|
|
|
FILE *logfp;
|
|
|
|
char buf[1024];
|
2007-01-19 07:25:54 +00:00
|
|
|
int ret = 0;
|
2006-12-18 09:18:16 +00:00
|
|
|
|
|
|
|
logfile = git_path("logs/%s", ref);
|
|
|
|
logfp = fopen(logfile, "r");
|
|
|
|
if (!logfp)
|
2007-01-08 00:59:54 +00:00
|
|
|
return -1;
|
2006-12-18 09:18:16 +00:00
|
|
|
while (fgets(buf, sizeof(buf), logfp)) {
|
|
|
|
unsigned char osha1[20], nsha1[20];
|
2007-01-08 00:59:54 +00:00
|
|
|
char *email_end, *message;
|
|
|
|
unsigned long timestamp;
|
2007-01-19 07:25:54 +00:00
|
|
|
int len, tz;
|
2006-12-18 09:18:16 +00:00
|
|
|
|
|
|
|
/* old SP new SP name <email> SP time TAB msg LF */
|
|
|
|
len = strlen(buf);
|
|
|
|
if (len < 83 || buf[len-1] != '\n' ||
|
|
|
|
get_sha1_hex(buf, osha1) || buf[40] != ' ' ||
|
2007-01-08 00:59:54 +00:00
|
|
|
get_sha1_hex(buf + 41, nsha1) || buf[81] != ' ' ||
|
|
|
|
!(email_end = strchr(buf + 82, '>')) ||
|
|
|
|
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;
|
2007-01-08 00:59:54 +00:00
|
|
|
ret = fn(osha1, nsha1, buf+82, timestamp, tz, message, cb_data);
|
|
|
|
if (ret)
|
2007-01-19 07:25:54 +00:00
|
|
|
break;
|
2006-12-18 09:18:16 +00:00
|
|
|
}
|
|
|
|
fclose(logfp);
|
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
|
|
|
|
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];
|
|
|
|
if (!resolve_ref(log, sha1, 0, NULL))
|
|
|
|
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);
|
|
|
|
}
|