git-for-windows/git
1
0
Fork 0
mirror of https://github.com/git-for-windows/git.git synced 2026-04-10 08:22:54 -05:00
Code Issues Packages Projects Releases 335 Wiki Activity
Files
0437b650cfda170b928ee82c469e749b765f14d9
git/t/t5003-archive-zip.sh
Patrick Steinhardt 7a4bd1b836 packfile: always declare object info to be OI_PACKED 
When reading object info via a packfile we yield one of two types:

  - The object can either be OI_PACKED, which is what a caller would
    typically expect.

  - Or it can be OI_DBCACHED if it is stored in the delta base cache.

The latter really is an implementation detail though, and callers
typically don't care at all about the difference. Furthermore, the
information whether or not it is part of the delta base cache can
already be derived via the `is_delta` field, so the fact that we discern
between OI_PACKED and OI_DBCACHED only further complicates the
interface.

There aren't all that many callers that care about the `whence` field in
the first place. In fact, there's only three:

  - `packfile_store_read_object_info()` checks for `whence == OI_PACKED`
    and then populates the packfile information of the object info
    structure. We now start to do this also for deltified objects, which
    gives its callers strictly more information.

  - `repack_local_links()` wants to determine whether the object is part
    of a promisor pack and checks for `whence == OI_PACKED`. If so, it
    verifies that the packfile is a promisor pack. It's arguably wrong
    to declare that an object is not part of a promisor pack only
    because it is stored in the delta base cache.

  - `is_not_in_promisor_pack_obj()` does the same, but checks that a
    specific object is _not_ part of a promisor pack. The same reasoning
    as above applies.

Drop the OI_DBCACHED enum completely. None of the callers seem to care
about the distinction.

Note that this also fixes a segfault introduced in 8c1b84bc97
(streaming: move logic to read packed objects streams into backend,
2025-11-23), which refactors how we stream packed objects. The intent is
to only read packed objects in case they are stored non-deltified as
we'd otherwise have to deflate them first. But the check for whether or
not the object is stored as a delta was unconditionally done via
`oi.u.packed.is_delta`, which is only valid in case `oi.whence` is
`OI_PACKED`. But under some circumstances we got `OI_DBCACHED` here,
which means that none of the `oi.u.packed` fields were initialized at
all. Consequently, we assumed the object was not stored as a delta, and
then try to read the object from `oi.u.packed.pack`, which is a `NULL`
pointer and thus causes a segfault.

Add a test case for this issue so that this cannot regress in the
future anymore.

Reported-by: Matt Smiley <msmiley@gitlab.com>
Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2026-01-12 06:51:14 -08:00

311 lines
8.7 KiB
Bash
Executable File
Raw Blame History

#!/bin/sh
test_description='git archive --format=zip test'
TEST_CREATE_REPO_NO_TEMPLATE=1
. ./test-lib.sh
SUBSTFORMAT=%H%n
test_lazy_prereq UNZIP_SYMLINKS '
"$GIT_UNZIP" "$TEST_DIRECTORY"/t5003/infozip-symlinks.zip &&
test -h symlink
'
test_lazy_prereq UNZIP_CONVERT '
"$GIT_UNZIP" -a "$TEST_DIRECTORY"/t5003/infozip-symlinks.zip
'
check_zip() {
zipfile=$1.zip
listfile=$1.lst
dir=$1
dir_with_prefix=$dir/$2
test_expect_success UNZIP " extract ZIP archive" '
(mkdir $dir && cd $dir && "$GIT_UNZIP" ../$zipfile)
'
test_expect_success UNZIP " validate filenames" "
(cd ${dir_with_prefix}a && find .) | sort >$listfile &&
test_cmp a.lst $listfile
"
test_expect_success UNZIP " validate file contents" "
diff -r a ${dir_with_prefix}a
"
dir=eol_$1
dir_with_prefix=$dir/$2
extracted=${dir_with_prefix}a
original=a
test_expect_success UNZIP_CONVERT " extract ZIP archive with EOL conversion" '
(mkdir $dir && cd $dir && "$GIT_UNZIP" -a ../$zipfile)
'
test_expect_success UNZIP_CONVERT " validate that text files are converted" "
test_cmp_bin $extracted/text.cr $extracted/text.crlf &&
test_cmp_bin $extracted/text.cr $extracted/text.lf
"
test_expect_success UNZIP_CONVERT " validate that binary files are unchanged" "
test_cmp_bin $original/binary.cr $extracted/binary.cr &&
test_cmp_bin $original/binary.crlf $extracted/binary.crlf &&
test_cmp_bin $original/binary.lf $extracted/binary.lf
"
test_expect_success UNZIP_CONVERT " validate that diff files are converted" "
test_cmp_bin $extracted/diff.cr $extracted/diff.crlf &&
test_cmp_bin $extracted/diff.cr $extracted/diff.lf
"
test_expect_success UNZIP_CONVERT " validate that -diff files are unchanged" "
test_cmp_bin $original/nodiff.cr $extracted/nodiff.cr &&
test_cmp_bin $original/nodiff.crlf $extracted/nodiff.crlf &&
test_cmp_bin $original/nodiff.lf $extracted/nodiff.lf
"
test_expect_success UNZIP_CONVERT " validate that custom diff is unchanged " "
test_cmp_bin $original/custom.cr $extracted/custom.cr &&
test_cmp_bin $original/custom.crlf $extracted/custom.crlf &&
test_cmp_bin $original/custom.lf $extracted/custom.lf
"
}
check_added() {
dir=$1
path_in_fs=$2
path_in_archive=$3
test_expect_success UNZIP " validate extra file $path_in_archive" '
diff -r $path_in_fs $dir/$path_in_archive
'
}
test_expect_success \
'populate workdir' \
'mkdir a &&
echo simple textfile >a/a &&
mkdir a/bin &&
cp /bin/sh a/bin &&
printf "text\r" >a/text.cr &&
printf "text\r\n" >a/text.crlf &&
printf "text\n" >a/text.lf &&
printf "text\r" >a/nodiff.cr &&
printf "text\r\n" >a/nodiff.crlf &&
printf "text\n" >a/nodiff.lf &&
printf "text\r" >a/custom.cr &&
printf "text\r\n" >a/custom.crlf &&
printf "text\n" >a/custom.lf &&
printf "\0\r" >a/binary.cr &&
printf "\0\r\n" >a/binary.crlf &&
printf "\0\n" >a/binary.lf &&
printf "\0\r" >a/diff.cr &&
printf "\0\r\n" >a/diff.crlf &&
printf "\0\n" >a/diff.lf &&
printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
printf "A not substituted O" >a/substfile2 &&
(p=long_path_to_a_file && cd a &&
for depth in 1 2 3 4 5; do mkdir $p && cd $p || exit 1; done &&
echo text >file_with_long_path)
'
test_expect_success SYMLINKS,UNZIP_SYMLINKS 'add symlink' '
ln -s a a/symlink_to_a
'
test_expect_success 'prepare file list' '
(cd a && find .) | sort >a.lst
'
test_expect_success \
'add ignored file' \
'echo ignore me >a/ignored &&
mkdir .git/info &&
echo ignored export-ignore >.git/info/attributes'
test_expect_success 'add files to repository' '
git add a &&
GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
'
test_expect_success 'setup export-subst and diff attributes' '
echo "a/nodiff.* -diff" >>.git/info/attributes &&
echo "a/diff.* diff" >>.git/info/attributes &&
echo "a/custom.* diff=custom" >>.git/info/attributes &&
git config diff.custom.binary true &&
echo "substfile?" export-subst >>.git/info/attributes &&
git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
>a/substfile1
'
test_expect_success 'create bare clone' '
git clone --template= --bare . bare.git &&
mkdir bare.git/info &&
cp .git/info/attributes bare.git/info/attributes &&
# Recreate our changes to .git/config rather than just copying it, as
# we do not want to clobber core.bare or other settings.
git -C bare.git config diff.custom.binary true
'
test_expect_success \
'remove ignored file' \
'rm a/ignored'
test_expect_success \
'git archive --format=zip' \
'git archive --format=zip HEAD >d.zip'
check_zip d
test_expect_success \
'git archive --format=zip in a bare repo' \
'(cd bare.git && git archive --format=zip HEAD) >d1.zip'
test_expect_success \
'git archive --format=zip vs. the same in a bare repo' \
'test_cmp_bin d.zip d1.zip'
test_expect_success 'git archive --format=zip with --output' \
'git archive --format=zip --output=d2.zip HEAD &&
test_cmp_bin d.zip d2.zip'
test_expect_success 'git archive with --output, inferring format (local)' '
git archive --output=d3.zip HEAD &&
test_cmp_bin d.zip d3.zip
'
test_expect_success 'git archive with --output, inferring format (remote)' '
git archive --remote=. --output=d4.zip HEAD &&
test_cmp_bin d.zip d4.zip
'
test_expect_success \
'git archive --format=zip with prefix' \
'git archive --format=zip --prefix=prefix/ HEAD >e.zip'
check_zip e prefix/
test_expect_success 'git archive -0 --format=zip on large files' '
test_config core.bigfilethreshold 1 &&
git archive -0 --format=zip HEAD >large.zip
'
check_zip large
test_expect_success 'git archive --format=zip on large files' '
test_config core.bigfilethreshold 1 &&
git archive --format=zip HEAD >large-compressed.zip
'
check_zip large-compressed
test_expect_success 'git archive --format=zip --add-file' '
echo untracked >untracked &&
git archive --format=zip --add-file=untracked HEAD >with_untracked.zip
'
check_zip with_untracked
check_added with_untracked untracked untracked
test_expect_success UNZIP 'git archive --format=zip --add-virtual-file' '
if test_have_prereq FUNNYNAMES
then
PATHNAME="pathname with : colon"
else
PATHNAME="pathname without colon"
fi &&
git archive --format=zip >with_file_with_content.zip \
--add-virtual-file=\""$PATHNAME"\": \
--add-virtual-file=hello:world $EMPTY_TREE &&
test_when_finished "rm -rf tmp-unpack" &&
mkdir tmp-unpack && (
cd tmp-unpack &&
"$GIT_UNZIP" ../with_file_with_content.zip &&
test_path_is_file hello &&
test_path_is_file "$PATHNAME" &&
test world = $(cat hello)
)
'
test_expect_success 'git archive --format=zip --add-file twice' '
echo untracked >untracked &&
git archive --format=zip --prefix=one/ --add-file=untracked \
--prefix=two/ --add-file=untracked \
--prefix= HEAD >with_untracked2.zip
'
check_zip with_untracked2
check_added with_untracked2 untracked one/untracked
check_added with_untracked2 untracked two/untracked
test_expect_success 'git-archive --format=zip with bigFile delta chains' '
test_when_finished rm -rf repo &&
git init repo &&
(
cd repo &&
test-tool genrandom foo 100000 >base &&
{
cat base &&
echo "trailing data"
} >delta-1 &&
{
cat delta-1 &&
echo "trailing data"
} >delta-2 &&
git add . &&
git commit -m "blobs" &&
git repack -Ad &&
git verify-pack -v .git/objects/pack/pack-*.idx >stats &&
test_grep "chain length = 1: 1 object" stats &&
test_grep "chain length = 2: 1 object" stats &&
git -c core.bigFileThreshold=1k archive --format=zip HEAD >archive.zip &&
if test_have_prereq UNZIP
then
mkdir unpack &&
cd unpack &&
"$GIT_UNZIP" ../archive.zip &&
test_cmp base ../base &&
test_cmp delta-1 ../delta-1 &&
test_cmp delta-2 ../delta-2
fi
)
'
# Test remote archive over HTTP protocol.
#
# Note: this should be the last part of this test suite, because
# by including lib-httpd.sh, the test may end early if httpd tests
# should not be run.
#
. "$TEST_DIRECTORY"/lib-httpd.sh
start_httpd
test_expect_success "setup for HTTP protocol" '
cp -R bare.git "$HTTPD_DOCUMENT_ROOT_PATH/bare.git" &&
git -C "$HTTPD_DOCUMENT_ROOT_PATH/bare.git" \
config http.uploadpack true &&
set_askpass user@host pass@host
'
setup_askpass_helper
test_expect_success 'remote archive does not work with protocol v1' '
test_must_fail git -c protocol.version=1 archive \
--remote="$HTTPD_URL/auth/smart/bare.git" \
--output=remote-http.zip HEAD >actual 2>&1 &&
cat >expect <<-EOF &&
fatal: can${SQ}t connect to subservice git-upload-archive
EOF
test_cmp expect actual
'
test_expect_success 'archive remote http repository' '
git archive --remote="$HTTPD_URL/auth/smart/bare.git" \
--output=remote-http.zip HEAD &&
test_cmp_bin d.zip remote-http.zip
'
test_done
Reference in New Issue View Git Blame Copy Permalink