mirror of
https://github.com/git/git.git
synced 2024-10-31 14:27:54 +01:00
51054177b3
When we notice that we have a local copy of an incoming object, we compare the two objects to make sure we haven't found a collision. Before we get to the actual object bytes, though, we compare the type and size from sha1_object_info(). If our local object is corrupted, then the type will be OBJ_BAD, which obviously will not match the incoming type, and we'll report "SHA1 COLLISION FOUND" (with capital letters and everything). This is confusing, as the problem is not a collision but rather local corruption. We should report that instead (just like we do if reading the rest of the object content fails a few lines later). Note that we _could_ just ignore the error and mark it as a non-collision. That would let you "git fetch" to replace a corrupted object. But it's not a very reliable method for repairing a repository. The earlier want/have negotiation tries to get the other side to omit objects we already have, and it would not realize that we are "missing" this corrupted object. So we're better off complaining loudly when we see corruption, and letting the user take more drastic measures to repair (like making a full clone elsewhere and copying the pack into place). Note that the test sets transfer.unpackLimit in the receiving repository so that we use index-pack (which is what does the collision check). Normally for such a small push we'd use unpack-objects, which would simply try to write the loose object, and discard the new one when we see that there's already an old one. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
128 lines
3.1 KiB
Bash
Executable file
128 lines
3.1 KiB
Bash
Executable file
#!/bin/sh
|
|
|
|
test_description='see how we handle various forms of corruption'
|
|
. ./test-lib.sh
|
|
|
|
# convert "1234abcd" to ".git/objects/12/34abcd"
|
|
obj_to_file() {
|
|
echo "$(git rev-parse --git-dir)/objects/$(git rev-parse "$1" | sed 's,..,&/,')"
|
|
}
|
|
|
|
# Convert byte at offset "$2" of object "$1" into '\0'
|
|
corrupt_byte() {
|
|
obj_file=$(obj_to_file "$1") &&
|
|
chmod +w "$obj_file" &&
|
|
printf '\0' | dd of="$obj_file" bs=1 seek="$2" conv=notrunc
|
|
}
|
|
|
|
test_expect_success 'setup corrupt repo' '
|
|
git init bit-error &&
|
|
(
|
|
cd bit-error &&
|
|
test_commit content &&
|
|
corrupt_byte HEAD:content.t 10
|
|
) &&
|
|
git init no-bit-error &&
|
|
(
|
|
# distinct commit from bit-error, but containing a
|
|
# non-corrupted version of the same blob
|
|
cd no-bit-error &&
|
|
test_tick &&
|
|
test_commit content
|
|
)
|
|
'
|
|
|
|
test_expect_success 'setup repo with missing object' '
|
|
git init missing &&
|
|
(
|
|
cd missing &&
|
|
test_commit content &&
|
|
rm -f "$(obj_to_file HEAD:content.t)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'setup repo with misnamed object' '
|
|
git init misnamed &&
|
|
(
|
|
cd misnamed &&
|
|
test_commit content &&
|
|
good=$(obj_to_file HEAD:content.t) &&
|
|
blob=$(echo corrupt | git hash-object -w --stdin) &&
|
|
bad=$(obj_to_file $blob) &&
|
|
rm -f "$good" &&
|
|
mv "$bad" "$good"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'streaming a corrupt blob fails' '
|
|
(
|
|
cd bit-error &&
|
|
test_must_fail git cat-file blob HEAD:content.t
|
|
)
|
|
'
|
|
|
|
test_expect_success 'getting type of a corrupt blob fails' '
|
|
(
|
|
cd bit-error &&
|
|
test_must_fail git cat-file -s HEAD:content.t
|
|
)
|
|
'
|
|
|
|
test_expect_success 'read-tree -u detects bit-errors in blobs' '
|
|
(
|
|
cd bit-error &&
|
|
rm -f content.t &&
|
|
test_must_fail git read-tree --reset -u HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'read-tree -u detects missing objects' '
|
|
(
|
|
cd missing &&
|
|
rm -f content.t &&
|
|
test_must_fail git read-tree --reset -u HEAD
|
|
)
|
|
'
|
|
|
|
# We use --bare to make sure that the transport detects it, not the checkout
|
|
# phase.
|
|
test_expect_success 'clone --no-local --bare detects corruption' '
|
|
test_must_fail git clone --no-local --bare bit-error corrupt-transport
|
|
'
|
|
|
|
test_expect_success 'clone --no-local --bare detects missing object' '
|
|
test_must_fail git clone --no-local --bare missing missing-transport
|
|
'
|
|
|
|
test_expect_success 'clone --no-local --bare detects misnamed object' '
|
|
test_must_fail git clone --no-local --bare misnamed misnamed-transport
|
|
'
|
|
|
|
# We do not expect --local to detect corruption at the transport layer,
|
|
# so we are really checking the checkout() code path.
|
|
test_expect_success 'clone --local detects corruption' '
|
|
test_must_fail git clone --local bit-error corrupt-checkout
|
|
'
|
|
|
|
test_expect_success 'error detected during checkout leaves repo intact' '
|
|
test_path_is_dir corrupt-checkout/.git
|
|
'
|
|
|
|
test_expect_success 'clone --local detects missing objects' '
|
|
test_must_fail git clone --local missing missing-checkout
|
|
'
|
|
|
|
test_expect_failure 'clone --local detects misnamed objects' '
|
|
test_must_fail git clone --local misnamed misnamed-checkout
|
|
'
|
|
|
|
test_expect_success 'fetch into corrupted repo with index-pack' '
|
|
(
|
|
cd bit-error &&
|
|
test_must_fail git -c transfer.unpackLimit=1 \
|
|
fetch ../no-bit-error 2>stderr &&
|
|
test_i18ngrep ! -i collision stderr
|
|
)
|
|
'
|
|
|
|
test_done
|