2008-02-25 21:46:04 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "blob.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "tree-walk.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "fsck.h"
|
fsck: complain about HFS+ ".git" aliases in trees
Now that the index can block pathnames that case-fold to
".git" on HFS+, it would be helpful for fsck to notice such
problematic paths. This lets servers which use
receive.fsckObjects block them before the damage spreads.
Note that the fsck check is always on, even for systems
without core.protectHFS set. This is technically more
restrictive than we need to be, as a set of users on ext4
could happily use these odd filenames without caring about
HFS+.
However, on balance, it's helpful for all servers to block
these (because the paths can be used for mischief, and
servers which bother to fsck would want to stop the spread
whether they are on HFS+ themselves or not), and hardly
anybody will be affected (because the blocked names are
variants of .git with invisible Unicode code-points mixed
in, meaning mischief is almost certainly what the tree
author had in mind).
Ideally these would be controlled by a separate
"fsck.protectHFS" flag. However, it would be much nicer to
be able to enable/disable _any_ fsck flag individually, and
any scheme we choose should match such a system. Given the
likelihood of anybody using such a path in practice, it is
not unreasonable to wait until such a system materializes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-12-15 23:21:57 +00:00
|
|
|
#include "utf8.h"
|
2008-02-25 21:46:04 +00:00
|
|
|
|
|
|
|
static int fsck_walk_tree(struct tree *tree, fsck_walk_func walk, void *data)
|
|
|
|
{
|
|
|
|
struct tree_desc desc;
|
|
|
|
struct name_entry entry;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
if (parse_tree(tree))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
|
|
|
while (tree_entry(&desc, &entry)) {
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (S_ISGITLINK(entry.mode))
|
|
|
|
continue;
|
|
|
|
if (S_ISDIR(entry.mode))
|
|
|
|
result = walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data);
|
|
|
|
else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode))
|
|
|
|
result = walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data);
|
|
|
|
else {
|
2012-04-30 00:28:45 +00:00
|
|
|
result = error("in tree %s: entry %s has bad mode %.6o",
|
2008-02-25 21:46:04 +00:00
|
|
|
sha1_to_hex(tree->object.sha1), entry.path, entry.mode);
|
|
|
|
}
|
|
|
|
if (result < 0)
|
|
|
|
return result;
|
|
|
|
if (!res)
|
|
|
|
res = result;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsck_walk_commit(struct commit *commit, fsck_walk_func walk, void *data)
|
|
|
|
{
|
|
|
|
struct commit_list *parents;
|
|
|
|
int res;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (parse_commit(commit))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
result = walk((struct object *)commit->tree, OBJ_TREE, data);
|
|
|
|
if (result < 0)
|
|
|
|
return result;
|
|
|
|
res = result;
|
|
|
|
|
|
|
|
parents = commit->parents;
|
|
|
|
while (parents) {
|
|
|
|
result = walk((struct object *)parents->item, OBJ_COMMIT, data);
|
|
|
|
if (result < 0)
|
|
|
|
return result;
|
|
|
|
if (!res)
|
|
|
|
res = result;
|
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsck_walk_tag(struct tag *tag, fsck_walk_func walk, void *data)
|
|
|
|
{
|
|
|
|
if (parse_tag(tag))
|
|
|
|
return -1;
|
|
|
|
return walk(tag->tagged, OBJ_ANY, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
int fsck_walk(struct object *obj, fsck_walk_func walk, void *data)
|
|
|
|
{
|
|
|
|
if (!obj)
|
|
|
|
return -1;
|
|
|
|
switch (obj->type) {
|
|
|
|
case OBJ_BLOB:
|
|
|
|
return 0;
|
|
|
|
case OBJ_TREE:
|
|
|
|
return fsck_walk_tree((struct tree *)obj, walk, data);
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
return fsck_walk_commit((struct commit *)obj, walk, data);
|
|
|
|
case OBJ_TAG:
|
|
|
|
return fsck_walk_tag((struct tag *)obj, walk, data);
|
|
|
|
default:
|
|
|
|
error("Unknown object type for %s", sha1_to_hex(obj->sha1));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2008-02-25 21:46:08 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The entries in a tree are ordered in the _path_ order,
|
|
|
|
* which means that a directory entry is ordered by adding
|
|
|
|
* a slash to the end of it.
|
|
|
|
*
|
|
|
|
* So a directory called "a" is ordered _after_ a file
|
|
|
|
* called "a.c", because "a/" sorts after "a.c".
|
|
|
|
*/
|
|
|
|
#define TREE_UNORDERED (-1)
|
|
|
|
#define TREE_HAS_DUPS (-2)
|
|
|
|
|
|
|
|
static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
|
|
|
|
{
|
|
|
|
int len1 = strlen(name1);
|
|
|
|
int len2 = strlen(name2);
|
|
|
|
int len = len1 < len2 ? len1 : len2;
|
|
|
|
unsigned char c1, c2;
|
|
|
|
int cmp;
|
|
|
|
|
|
|
|
cmp = memcmp(name1, name2, len);
|
|
|
|
if (cmp < 0)
|
|
|
|
return 0;
|
|
|
|
if (cmp > 0)
|
|
|
|
return TREE_UNORDERED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, the first <len> characters are the same.
|
|
|
|
* Now we need to order the next one, but turn
|
|
|
|
* a '\0' into a '/' for a directory entry.
|
|
|
|
*/
|
|
|
|
c1 = name1[len];
|
|
|
|
c2 = name2[len];
|
|
|
|
if (!c1 && !c2)
|
|
|
|
/*
|
|
|
|
* git-write-tree used to write out a nonsense tree that has
|
|
|
|
* entries with the same name, one blob and one tree. Make
|
|
|
|
* sure we do not have duplicate entries.
|
|
|
|
*/
|
|
|
|
return TREE_HAS_DUPS;
|
|
|
|
if (!c1 && S_ISDIR(mode1))
|
|
|
|
c1 = '/';
|
|
|
|
if (!c2 && S_ISDIR(mode2))
|
|
|
|
c2 = '/';
|
|
|
|
return c1 < c2 ? 0 : TREE_UNORDERED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsck_tree(struct tree *item, int strict, fsck_error error_func)
|
|
|
|
{
|
|
|
|
int retval;
|
2012-07-28 15:06:29 +00:00
|
|
|
int has_null_sha1 = 0;
|
2008-02-25 21:46:08 +00:00
|
|
|
int has_full_path = 0;
|
|
|
|
int has_empty_name = 0;
|
2012-11-28 02:27:37 +00:00
|
|
|
int has_dot = 0;
|
|
|
|
int has_dotdot = 0;
|
2012-11-28 21:35:29 +00:00
|
|
|
int has_dotgit = 0;
|
2008-02-25 21:46:08 +00:00
|
|
|
int has_zero_pad = 0;
|
|
|
|
int has_bad_modes = 0;
|
|
|
|
int has_dup_entries = 0;
|
|
|
|
int not_properly_sorted = 0;
|
|
|
|
struct tree_desc desc;
|
|
|
|
unsigned o_mode;
|
|
|
|
const char *o_name;
|
|
|
|
|
|
|
|
init_tree_desc(&desc, item->buffer, item->size);
|
|
|
|
|
|
|
|
o_mode = 0;
|
|
|
|
o_name = NULL;
|
|
|
|
|
|
|
|
while (desc.size) {
|
|
|
|
unsigned mode;
|
|
|
|
const char *name;
|
2012-07-28 15:06:29 +00:00
|
|
|
const unsigned char *sha1;
|
2008-02-25 21:46:08 +00:00
|
|
|
|
2012-07-28 15:06:29 +00:00
|
|
|
sha1 = tree_entry_extract(&desc, &name, &mode);
|
2008-02-25 21:46:08 +00:00
|
|
|
|
2014-03-19 23:02:04 +00:00
|
|
|
has_null_sha1 |= is_null_sha1(sha1);
|
|
|
|
has_full_path |= !!strchr(name, '/');
|
|
|
|
has_empty_name |= !*name;
|
|
|
|
has_dot |= !strcmp(name, ".");
|
|
|
|
has_dotdot |= !strcmp(name, "..");
|
2014-12-17 19:28:02 +00:00
|
|
|
has_dotgit |= (!strcmp(name, ".git") ||
|
|
|
|
is_hfs_dotgit(name) ||
|
|
|
|
is_ntfs_dotgit(name));
|
2008-02-25 21:46:08 +00:00
|
|
|
has_zero_pad |= *(char *)desc.buffer == '0';
|
|
|
|
update_tree_entry(&desc);
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
/*
|
|
|
|
* Standard modes..
|
|
|
|
*/
|
|
|
|
case S_IFREG | 0755:
|
|
|
|
case S_IFREG | 0644:
|
|
|
|
case S_IFLNK:
|
|
|
|
case S_IFDIR:
|
|
|
|
case S_IFGITLINK:
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* This is nonstandard, but we had a few of these
|
|
|
|
* early on when we honored the full set of mode
|
|
|
|
* bits..
|
|
|
|
*/
|
|
|
|
case S_IFREG | 0664:
|
|
|
|
if (!strict)
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
has_bad_modes = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o_name) {
|
|
|
|
switch (verify_ordered(o_mode, o_name, mode, name)) {
|
|
|
|
case TREE_UNORDERED:
|
|
|
|
not_properly_sorted = 1;
|
|
|
|
break;
|
|
|
|
case TREE_HAS_DUPS:
|
|
|
|
has_dup_entries = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
o_mode = mode;
|
|
|
|
o_name = name;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = 0;
|
2012-07-28 15:06:29 +00:00
|
|
|
if (has_null_sha1)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains entries pointing to null sha1");
|
2008-02-25 21:46:08 +00:00
|
|
|
if (has_full_path)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains full pathnames");
|
|
|
|
if (has_empty_name)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains empty pathname");
|
2012-11-28 02:27:37 +00:00
|
|
|
if (has_dot)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains '.'");
|
|
|
|
if (has_dotdot)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains '..'");
|
2012-11-28 21:35:29 +00:00
|
|
|
if (has_dotgit)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains '.git'");
|
2008-02-25 21:46:08 +00:00
|
|
|
if (has_zero_pad)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains zero-padded file modes");
|
|
|
|
if (has_bad_modes)
|
|
|
|
retval += error_func(&item->object, FSCK_WARN, "contains bad file modes");
|
|
|
|
if (has_dup_entries)
|
|
|
|
retval += error_func(&item->object, FSCK_ERROR, "contains duplicate file entries");
|
|
|
|
if (not_properly_sorted)
|
|
|
|
retval += error_func(&item->object, FSCK_ERROR, "not properly sorted");
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-03-13 04:45:50 +00:00
|
|
|
static int fsck_ident(const char **ident, struct object *obj, fsck_error error_func)
|
2010-04-24 16:06:08 +00:00
|
|
|
{
|
fsck: report integer overflow in author timestamps
When we check commit objects, we complain if commit->date is
ULONG_MAX, which is an indication that we saw integer
overflow when parsing it. However, we do not do any check at
all for author lines, which also contain a timestamp.
Let's actually check the timestamps on each ident line
with strtoul. This catches both author and committer lines,
and we can get rid of the now-redundant commit->date check.
Note that like the existing check, we compare only against
ULONG_MAX. Now that we are calling strtoul at the site of
the check, we could be slightly more careful and also check
that errno is set to ERANGE. However, this will make further
refactoring in future patches a little harder, and it
doesn't really matter in practice.
For 32-bit systems, one would have to create a commit at the
exact wrong second in 2038. But by the time we get close to
that, all systems will hopefully have moved to 64-bit (and
if they haven't, they have a real problem one second later).
For 64-bit systems, by the time we get close to ULONG_MAX,
all systems will hopefully have been consumed in the fiery
wrath of our expanding Sun.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-02-24 07:39:04 +00:00
|
|
|
char *end;
|
|
|
|
|
2011-08-11 10:21:10 +00:00
|
|
|
if (**ident == '<')
|
2010-04-24 16:06:08 +00:00
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before email");
|
2011-08-11 10:21:10 +00:00
|
|
|
*ident += strcspn(*ident, "<>\n");
|
|
|
|
if (**ident == '>')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad name");
|
2010-04-24 16:06:08 +00:00
|
|
|
if (**ident != '<')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing email");
|
2011-08-11 10:21:10 +00:00
|
|
|
if ((*ident)[-1] != ' ')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before email");
|
2010-04-24 16:06:08 +00:00
|
|
|
(*ident)++;
|
|
|
|
*ident += strcspn(*ident, "<>\n");
|
|
|
|
if (**ident != '>')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad email");
|
|
|
|
(*ident)++;
|
|
|
|
if (**ident != ' ')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before date");
|
|
|
|
(*ident)++;
|
|
|
|
if (**ident == '0' && (*ident)[1] != ' ')
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - zero-padded date");
|
2014-02-24 07:39:45 +00:00
|
|
|
if (date_overflows(strtoul(*ident, &end, 10)))
|
fsck: report integer overflow in author timestamps
When we check commit objects, we complain if commit->date is
ULONG_MAX, which is an indication that we saw integer
overflow when parsing it. However, we do not do any check at
all for author lines, which also contain a timestamp.
Let's actually check the timestamps on each ident line
with strtoul. This catches both author and committer lines,
and we can get rid of the now-redundant commit->date check.
Note that like the existing check, we compare only against
ULONG_MAX. Now that we are calling strtoul at the site of
the check, we could be slightly more careful and also check
that errno is set to ERANGE. However, this will make further
refactoring in future patches a little harder, and it
doesn't really matter in practice.
For 32-bit systems, one would have to create a commit at the
exact wrong second in 2038. But by the time we get close to
that, all systems will hopefully have moved to 64-bit (and
if they haven't, they have a real problem one second later).
For 64-bit systems, by the time we get close to ULONG_MAX,
all systems will hopefully have been consumed in the fiery
wrath of our expanding Sun.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-02-24 07:39:04 +00:00
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - date causes integer overflow");
|
|
|
|
if (end == *ident || *end != ' ')
|
2010-04-24 16:06:08 +00:00
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad date");
|
fsck: report integer overflow in author timestamps
When we check commit objects, we complain if commit->date is
ULONG_MAX, which is an indication that we saw integer
overflow when parsing it. However, we do not do any check at
all for author lines, which also contain a timestamp.
Let's actually check the timestamps on each ident line
with strtoul. This catches both author and committer lines,
and we can get rid of the now-redundant commit->date check.
Note that like the existing check, we compare only against
ULONG_MAX. Now that we are calling strtoul at the site of
the check, we could be slightly more careful and also check
that errno is set to ERANGE. However, this will make further
refactoring in future patches a little harder, and it
doesn't really matter in practice.
For 32-bit systems, one would have to create a commit at the
exact wrong second in 2038. But by the time we get close to
that, all systems will hopefully have moved to 64-bit (and
if they haven't, they have a real problem one second later).
For 64-bit systems, by the time we get close to ULONG_MAX,
all systems will hopefully have been consumed in the fiery
wrath of our expanding Sun.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-02-24 07:39:04 +00:00
|
|
|
*ident = end + 1;
|
2010-04-24 16:06:08 +00:00
|
|
|
if ((**ident != '+' && **ident != '-') ||
|
|
|
|
!isdigit((*ident)[1]) ||
|
|
|
|
!isdigit((*ident)[2]) ||
|
|
|
|
!isdigit((*ident)[3]) ||
|
|
|
|
!isdigit((*ident)[4]) ||
|
|
|
|
((*ident)[5] != '\n'))
|
|
|
|
return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad time zone");
|
|
|
|
(*ident) += 6;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-10 21:41:51 +00:00
|
|
|
static int fsck_commit_buffer(struct commit *commit, const char *buffer,
|
|
|
|
fsck_error error_func)
|
2008-02-25 21:46:08 +00:00
|
|
|
{
|
|
|
|
unsigned char tree_sha1[20], sha1[20];
|
|
|
|
struct commit_graft *graft;
|
2014-07-10 09:48:26 +00:00
|
|
|
unsigned parent_count, parent_line_count = 0;
|
2010-04-24 16:06:08 +00:00
|
|
|
int err;
|
2008-02-25 21:46:08 +00:00
|
|
|
|
refactor skip_prefix to return a boolean
The skip_prefix() function returns a pointer to the content
past the prefix, or NULL if the prefix was not found. While
this is nice and simple, in practice it makes it hard to use
for two reasons:
1. When you want to conditionally skip or keep the string
as-is, you have to introduce a temporary variable.
For example:
tmp = skip_prefix(buf, "foo");
if (tmp)
buf = tmp;
2. It is verbose to check the outcome in a conditional, as
you need extra parentheses to silence compiler
warnings. For example:
if ((cp = skip_prefix(buf, "foo"))
/* do something with cp */
Both of these make it harder to use for long if-chains, and
we tend to use starts_with() instead. However, the first line
of "do something" is often to then skip forward in buf past
the prefix, either using a magic constant or with an extra
strlen(3) (which is generally computed at compile time, but
means we are repeating ourselves).
This patch refactors skip_prefix() to return a simple boolean,
and to provide the pointer value as an out-parameter. If the
prefix is not found, the out-parameter is untouched. This
lets you write:
if (skip_prefix(arg, "foo ", &arg))
do_foo(arg);
else if (skip_prefix(arg, "bar ", &arg))
do_bar(arg);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 19:44:19 +00:00
|
|
|
if (!skip_prefix(buffer, "tree ", &buffer))
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'tree' line");
|
2014-03-13 04:45:51 +00:00
|
|
|
if (get_sha1_hex(buffer, tree_sha1) || buffer[40] != '\n')
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "invalid 'tree' line format - bad sha1");
|
2014-03-13 04:45:51 +00:00
|
|
|
buffer += 41;
|
refactor skip_prefix to return a boolean
The skip_prefix() function returns a pointer to the content
past the prefix, or NULL if the prefix was not found. While
this is nice and simple, in practice it makes it hard to use
for two reasons:
1. When you want to conditionally skip or keep the string
as-is, you have to introduce a temporary variable.
For example:
tmp = skip_prefix(buf, "foo");
if (tmp)
buf = tmp;
2. It is verbose to check the outcome in a conditional, as
you need extra parentheses to silence compiler
warnings. For example:
if ((cp = skip_prefix(buf, "foo"))
/* do something with cp */
Both of these make it harder to use for long if-chains, and
we tend to use starts_with() instead. However, the first line
of "do something" is often to then skip forward in buf past
the prefix, either using a magic constant or with an extra
strlen(3) (which is generally computed at compile time, but
means we are repeating ourselves).
This patch refactors skip_prefix() to return a simple boolean,
and to provide the pointer value as an out-parameter. If the
prefix is not found, the out-parameter is untouched. This
lets you write:
if (skip_prefix(arg, "foo ", &arg))
do_foo(arg);
else if (skip_prefix(arg, "bar ", &arg))
do_bar(arg);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 19:44:19 +00:00
|
|
|
while (skip_prefix(buffer, "parent ", &buffer)) {
|
2014-03-13 04:45:51 +00:00
|
|
|
if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n')
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "invalid 'parent' line format - bad sha1");
|
2014-03-13 04:45:51 +00:00
|
|
|
buffer += 41;
|
2014-07-10 09:48:26 +00:00
|
|
|
parent_line_count++;
|
2008-02-25 21:46:08 +00:00
|
|
|
}
|
|
|
|
graft = lookup_commit_graft(commit->object.sha1);
|
2014-07-10 09:48:26 +00:00
|
|
|
parent_count = commit_list_count(commit->parents);
|
2008-02-25 21:46:08 +00:00
|
|
|
if (graft) {
|
2014-07-10 09:48:26 +00:00
|
|
|
if (graft->nr_parent == -1 && !parent_count)
|
2008-02-25 21:46:08 +00:00
|
|
|
; /* shallow commit */
|
2014-07-10 09:48:26 +00:00
|
|
|
else if (graft->nr_parent != parent_count)
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "graft objects missing");
|
|
|
|
} else {
|
2014-07-10 09:48:26 +00:00
|
|
|
if (parent_count != parent_line_count)
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "parent objects missing");
|
|
|
|
}
|
refactor skip_prefix to return a boolean
The skip_prefix() function returns a pointer to the content
past the prefix, or NULL if the prefix was not found. While
this is nice and simple, in practice it makes it hard to use
for two reasons:
1. When you want to conditionally skip or keep the string
as-is, you have to introduce a temporary variable.
For example:
tmp = skip_prefix(buf, "foo");
if (tmp)
buf = tmp;
2. It is verbose to check the outcome in a conditional, as
you need extra parentheses to silence compiler
warnings. For example:
if ((cp = skip_prefix(buf, "foo"))
/* do something with cp */
Both of these make it harder to use for long if-chains, and
we tend to use starts_with() instead. However, the first line
of "do something" is often to then skip forward in buf past
the prefix, either using a magic constant or with an extra
strlen(3) (which is generally computed at compile time, but
means we are repeating ourselves).
This patch refactors skip_prefix() to return a simple boolean,
and to provide the pointer value as an out-parameter. If the
prefix is not found, the out-parameter is untouched. This
lets you write:
if (skip_prefix(arg, "foo ", &arg))
do_foo(arg);
else if (skip_prefix(arg, "bar ", &arg))
do_bar(arg);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 19:44:19 +00:00
|
|
|
if (!skip_prefix(buffer, "author ", &buffer))
|
2008-02-25 21:46:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'author' line");
|
2010-04-24 16:06:08 +00:00
|
|
|
err = fsck_ident(&buffer, &commit->object, error_func);
|
|
|
|
if (err)
|
|
|
|
return err;
|
refactor skip_prefix to return a boolean
The skip_prefix() function returns a pointer to the content
past the prefix, or NULL if the prefix was not found. While
this is nice and simple, in practice it makes it hard to use
for two reasons:
1. When you want to conditionally skip or keep the string
as-is, you have to introduce a temporary variable.
For example:
tmp = skip_prefix(buf, "foo");
if (tmp)
buf = tmp;
2. It is verbose to check the outcome in a conditional, as
you need extra parentheses to silence compiler
warnings. For example:
if ((cp = skip_prefix(buf, "foo"))
/* do something with cp */
Both of these make it harder to use for long if-chains, and
we tend to use starts_with() instead. However, the first line
of "do something" is often to then skip forward in buf past
the prefix, either using a magic constant or with an extra
strlen(3) (which is generally computed at compile time, but
means we are repeating ourselves).
This patch refactors skip_prefix() to return a simple boolean,
and to provide the pointer value as an out-parameter. If the
prefix is not found, the out-parameter is untouched. This
lets you write:
if (skip_prefix(arg, "foo ", &arg))
do_foo(arg);
else if (skip_prefix(arg, "bar ", &arg))
do_bar(arg);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 19:44:19 +00:00
|
|
|
if (!skip_prefix(buffer, "committer ", &buffer))
|
2010-04-24 16:06:08 +00:00
|
|
|
return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'committer' line");
|
|
|
|
err = fsck_ident(&buffer, &commit->object, error_func);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2008-02-25 21:46:08 +00:00
|
|
|
if (!commit->tree)
|
|
|
|
return error_func(&commit->object, FSCK_ERROR, "could not load commit's tree %s", sha1_to_hex(tree_sha1));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-10 21:41:51 +00:00
|
|
|
static int fsck_commit(struct commit *commit, fsck_error error_func)
|
|
|
|
{
|
2014-06-10 21:44:13 +00:00
|
|
|
const char *buffer = get_commit_buffer(commit, NULL);
|
2014-06-10 21:41:51 +00:00
|
|
|
int ret = fsck_commit_buffer(commit, buffer, error_func);
|
|
|
|
unuse_commit_buffer(commit, buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-25 21:46:08 +00:00
|
|
|
static int fsck_tag(struct tag *tag, fsck_error error_func)
|
|
|
|
{
|
|
|
|
struct object *tagged = tag->tagged;
|
|
|
|
|
|
|
|
if (!tagged)
|
|
|
|
return error_func(&tag->object, FSCK_ERROR, "could not load tagged object");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fsck_object(struct object *obj, int strict, fsck_error error_func)
|
|
|
|
{
|
|
|
|
if (!obj)
|
|
|
|
return error_func(obj, FSCK_ERROR, "no valid object to fsck");
|
|
|
|
|
|
|
|
if (obj->type == OBJ_BLOB)
|
|
|
|
return 0;
|
|
|
|
if (obj->type == OBJ_TREE)
|
|
|
|
return fsck_tree((struct tree *) obj, strict, error_func);
|
|
|
|
if (obj->type == OBJ_COMMIT)
|
|
|
|
return fsck_commit((struct commit *) obj, error_func);
|
|
|
|
if (obj->type == OBJ_TAG)
|
|
|
|
return fsck_tag((struct tag *) obj, error_func);
|
|
|
|
|
|
|
|
return error_func(obj, FSCK_ERROR, "unknown type '%d' (internal fsck error)",
|
|
|
|
obj->type);
|
|
|
|
}
|
2008-02-25 21:46:09 +00:00
|
|
|
|
|
|
|
int fsck_error_function(struct object *obj, int type, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2008-02-25 21:46:09 +00:00
|
|
|
|
2011-05-26 13:58:16 +00:00
|
|
|
strbuf_addf(&sb, "object %s:", sha1_to_hex(obj->sha1));
|
2008-02-25 21:46:09 +00:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2011-02-26 05:08:53 +00:00
|
|
|
strbuf_vaddf(&sb, fmt, ap);
|
2008-02-25 21:46:09 +00:00
|
|
|
va_end(ap);
|
|
|
|
|
2008-11-10 21:07:52 +00:00
|
|
|
error("%s", sb.buf);
|
2008-02-25 21:46:09 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return 1;
|
|
|
|
}
|