mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Ævar Arnfjörð Bjarmason](/assets/img/avatar_default.png)
Improve the error that's emitted in cases where we find a loose object we parse, but which isn't at the location we expect it to be. Before this change we'd prefix the error with a not-a-OID derived from the path at which the object was found, due to an emergent behavior in how we'd end up with an "OID" in these codepaths. Now we'll instead say what object we hashed, and what path it was found at. Before this patch series e.g.: $ git hash-object --stdin -w -t blob </dev/nulle69de29bb2
$ mv objects/e6/ objects/e7 Would emit ("[...]" used to abbreviate the OIDs): git fsck error: hash mismatch for ./objects/e7/9d[...] (expected e79d[...]) error: e79d[...]: object corrupt or missing: ./objects/e7/9d[...] Now we'll instead emit: error: e69d[...]: hash-path mismatch, found at: ./objects/e7/9d[...] Furthermore, we'll do the right thing when the object type and its location are bad. I.e. this case: $ git hash-object --stdin -w -t garbage --literally </dev/null 8315a83d2acc4c174aed59430f9a9c4ed926440f $ mv objects/83 objects/84 As noted in an earlier commits we'd simply die early in those cases, until preceding commits fixed the hard die on invalid object type: $ git fsck fatal: invalid object type Now we'll instead emit sensible error messages: $ git fsck error: 8315[...]: hash-path mismatch, found at: ./objects/84/15[...] error: 8315[...]: object is of unknown type 'garbage': ./objects/84/15[...] In both fsck.c and object-file.c we're using null_oid as a sentinel value for checking whether we got far enough to be certain that the issue was indeed this OID mismatch. We need to add the "object corrupt or missing" special-case to deal with cases where read_loose_object() will return an error before completing check_object_signature(), e.g. if we have an error in unpack_loose_rest() because we find garbage after the valid gzip content: $ git hash-object --stdin -w -t blob </dev/nulle69de29bb2
$ chmod 755 objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 $ echo garbage >>objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 $ git fsck error: garbage at end of loose object 'e69d[...]' error: unable to unpack contents of ./objects/e6/9d[...] error: e69d[...]: object corrupt or missing: ./objects/e6/9d[...] There is currently some weird messaging in the edge case when the two are combined, i.e. because we're not explicitly passing along an error state about this specific scenario from check_stream_oid() via read_loose_object() we'll end up printing the null OID if an object is of an unknown type *and* it can't be unpacked by zlib, e.g.: $ git hash-object --stdin -w -t garbage --literally </dev/null 8315a83d2acc4c174aed59430f9a9c4ed926440f $ chmod 755 objects/83/15a83d2acc4c174aed59430f9a9c4ed926440f $ echo garbage >>objects/83/15a83d2acc4c174aed59430f9a9c4ed926440f $ /usr/bin/git fsck fatal: invalid object type $ ~/g/git/git fsck error: garbage at end of loose object '8315a83d2acc4c174aed59430f9a9c4ed926440f' error: unable to unpack contents of ./objects/83/15a83d2acc4c174aed59430f9a9c4ed926440f error: 8315a83d2acc4c174aed59430f9a9c4ed926440f: object corrupt or missing: ./objects/83/15a83d2acc4c174aed59430f9a9c4ed926440f error: 0000000000000000000000000000000000000000: object is of unknown type 'garbage': ./objects/83/15a83d2acc4c174aed59430f9a9c4ed926440f [...] I think it's OK to leave that for future improvements, which would involve enum-ifying more error state as we've done with "enum unpack_loose_header_result" in preceding commits. In these increasingly more obscure cases the worst that can happen is that we'll get slightly nonsensical or inapplicable error messages. There's other such potential edge cases, all of which might produce some confusing messaging, but still be handled correctly as far as passing along errors goes. E.g. if check_object_signature() returns and oideq(real_oid, null_oid()) is true, which could happen if it returns -1 due to the read_istream() call having failed. Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
110 lines
2.9 KiB
C
110 lines
2.9 KiB
C
#include "builtin.h"
|
|
#include "parse-options.h"
|
|
#include "tag.h"
|
|
#include "replace-object.h"
|
|
#include "object-store.h"
|
|
#include "fsck.h"
|
|
#include "config.h"
|
|
|
|
static char const * const builtin_mktag_usage[] = {
|
|
N_("git mktag"),
|
|
NULL
|
|
};
|
|
static int option_strict = 1;
|
|
|
|
static struct fsck_options fsck_options = FSCK_OPTIONS_STRICT;
|
|
|
|
static int mktag_fsck_error_func(struct fsck_options *o,
|
|
const struct object_id *oid,
|
|
enum object_type object_type,
|
|
enum fsck_msg_type msg_type,
|
|
enum fsck_msg_id msg_id,
|
|
const char *message)
|
|
{
|
|
switch (msg_type) {
|
|
case FSCK_WARN:
|
|
if (!option_strict) {
|
|
fprintf_ln(stderr, _("warning: tag input does not pass fsck: %s"), message);
|
|
return 0;
|
|
|
|
}
|
|
/* fallthrough */
|
|
case FSCK_ERROR:
|
|
/*
|
|
* We treat both warnings and errors as errors, things
|
|
* like missing "tagger" lines are "only" warnings
|
|
* under fsck, we've always considered them an error.
|
|
*/
|
|
fprintf_ln(stderr, _("error: tag input does not pass fsck: %s"), message);
|
|
return 1;
|
|
default:
|
|
BUG(_("%d (FSCK_IGNORE?) should never trigger this callback"),
|
|
msg_type);
|
|
}
|
|
}
|
|
|
|
static int verify_object_in_tag(struct object_id *tagged_oid, int *tagged_type)
|
|
{
|
|
int ret;
|
|
enum object_type type;
|
|
unsigned long size;
|
|
void *buffer;
|
|
const struct object_id *repl;
|
|
|
|
buffer = read_object_file(tagged_oid, &type, &size);
|
|
if (!buffer)
|
|
die(_("could not read tagged object '%s'"),
|
|
oid_to_hex(tagged_oid));
|
|
if (type != *tagged_type)
|
|
die(_("object '%s' tagged as '%s', but is a '%s' type"),
|
|
oid_to_hex(tagged_oid),
|
|
type_name(*tagged_type), type_name(type));
|
|
|
|
repl = lookup_replace_object(the_repository, tagged_oid);
|
|
ret = check_object_signature(the_repository, repl,
|
|
buffer, size, type_name(*tagged_type),
|
|
NULL);
|
|
free(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int cmd_mktag(int argc, const char **argv, const char *prefix)
|
|
{
|
|
static struct option builtin_mktag_options[] = {
|
|
OPT_BOOL(0, "strict", &option_strict,
|
|
N_("enable more strict checking")),
|
|
OPT_END(),
|
|
};
|
|
struct strbuf buf = STRBUF_INIT;
|
|
struct object_id tagged_oid;
|
|
int tagged_type;
|
|
struct object_id result;
|
|
|
|
argc = parse_options(argc, argv, NULL,
|
|
builtin_mktag_options,
|
|
builtin_mktag_usage, 0);
|
|
|
|
if (strbuf_read(&buf, 0, 0) < 0)
|
|
die_errno(_("could not read from stdin"));
|
|
|
|
fsck_options.error_func = mktag_fsck_error_func;
|
|
fsck_set_msg_type_from_ids(&fsck_options, FSCK_MSG_EXTRA_HEADER_ENTRY,
|
|
FSCK_WARN);
|
|
/* config might set fsck.extraHeaderEntry=* again */
|
|
git_config(git_fsck_config, &fsck_options);
|
|
if (fsck_tag_standalone(NULL, buf.buf, buf.len, &fsck_options,
|
|
&tagged_oid, &tagged_type))
|
|
die(_("tag on stdin did not pass our strict fsck check"));
|
|
|
|
if (verify_object_in_tag(&tagged_oid, &tagged_type))
|
|
die(_("tag on stdin did not refer to a valid object"));
|
|
|
|
if (write_object_file(buf.buf, buf.len, tag_type, &result) < 0)
|
|
die(_("unable to write tag file"));
|
|
|
|
strbuf_release(&buf);
|
|
puts(oid_to_hex(&result));
|
|
return 0;
|
|
}
|