t5000: test tar files that overflow ustar headers

The ustar format only has room for 11 (or 12, depending on
some implementations) octal digits for the size and mtime of
each file. For values larger than this, we have to add pax
extended headers to specify the real data, and git does not
yet know how to do so.

Before fixing that, let's start off with some test
infrastructure, as designing portable and efficient tests
for this is non-trivial.

We want to use the system tar to check our output (because
what we really care about is interoperability), but we can't
rely on it:

  1. being able to read pax headers

  2. being able to handle huge sizes or mtimes

  3. supporting a "t" format we can parse

So as a prerequisite, we can feed the system tar a reference
tarball to make sure it can handle these features. The
reference tar here was created with:

  dd if=/dev/zero seek=64G bs=1 count=1 of=huge
  touch -d @68719476737 huge
  tar cf - --format=pax |
  head -c 2048

using GNU tar. Note that this is not a complete tarfile, but
it's enough to contain the headers we want to examine.

Likewise, we need to convince git that it has a 64GB blob to
output. Running "git add" on that 64GB file takes many
minutes of CPU, and even compressed, the result is 64MB. So
again, I pre-generated that loose object, and then took only
the first 2k of it. That should be enough to generate 2MB of
data before hitting an inflate error, which is plenty for us
to generate the tar header (and then die of SIGPIPE while
streaming the rest out).

The tests are split so that we test as much as we can even
with an uncooperative system tar. This actually catches the
current breakage (which is that we die("BUG") trying to
write the ustar header) on every system, and then on systems
where we can, we go farther and actually verify the result.

Helped-by: Robin H. Johnson <robbat2@gentoo.org>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/t/t5000-tar-tree.sh b/t/t5000-tar-tree.sh
index 4b68bbafbe9016d66ce4f96f2058ac67640ed147..950bdd31e7114b921a5553bdceae9cfed7bf8d51 100755 (executable)
--- a/t/t5000-tar-tree.sh
+++ b/t/t5000-tar-tree.sh
@@ -319,4 +319,78 @@ test_expect_success 'catch non-matching pathspec' '
        test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
 '
 
+# Pull the size and date of each entry in a tarfile using the system tar.
+#
+# We'll pull out only the year from the date; that avoids any question of
+# timezones impacting the result (as long as we keep our test times away from a
+# year boundary; our reference times are all in August).
+#
+# The output of tar_info is expected to be "<size> <year>", both in decimal. It
+# ignores the return value of tar. We have to do this, because some of our test
+# input is only partial (the real data is 64GB in some cases).
+tar_info () {
+       "$TAR" tvf "$1" |
+       awk '{
+               split($4, date, "-")
+               print $3 " " date[1]
+       }'
+}
+
+# See if our system tar can handle a tar file with huge sizes and dates far in
+# the future, and that we can actually parse its output.
+#
+# The reference file was generated by GNU tar, and the magic time and size are
+# both octal 01000000000001, which overflows normal ustar fields.
+test_lazy_prereq TAR_HUGE '
+       echo "68719476737 4147" >expect &&
+       tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'set up repository with huge blob' '
+       obj_d=19 &&
+       obj_f=f9c8273ec45a8938e6999cb59b3ff66739902a &&
+       obj=${obj_d}${obj_f} &&
+       mkdir -p .git/objects/$obj_d &&
+       cp "$TEST_DIRECTORY"/t5000/$obj .git/objects/$obj_d/$obj_f &&
+       rm -f .git/index &&
+       git update-index --add --cacheinfo 100644,$obj,huge &&
+       git commit -m huge
+'
+
+# We expect git to die with SIGPIPE here (otherwise we
+# would generate the whole 64GB).
+test_expect_failure 'generate tar with huge size' '
+       {
+               git archive HEAD
+               echo $? >exit-code
+       } | test_copy_bytes 4096 >huge.tar &&
+       echo 141 >expect &&
+       test_cmp expect exit-code
+'
+
+test_expect_failure TAR_HUGE 'system tar can read our huge size' '
+       echo 68719476737 >expect &&
+       tar_info huge.tar | cut -d" " -f1 >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'set up repository with far-future commit' '
+       rm -f .git/index &&
+       echo content >file &&
+       git add file &&
+       GIT_COMMITTER_DATE="@68719476737 +0000" \
+               git commit -m "tempori parendum"
+'
+
+test_expect_failure 'generate tar with future mtime' '
+       git archive HEAD >future.tar
+'
+
+test_expect_failure TAR_HUGE 'system tar can read our future mtime' '
+       echo 4147 >expect &&
+       tar_info future.tar | cut -d" " -f2 >actual &&
+       test_cmp expect actual
+'
+
 test_done

diff --git a/t/t5000/19f9c8273ec45a8938e6999cb59b3ff66739902a b/t/t5000/19f9c8273ec45a8938e6999cb59b3ff66739902a
new file mode 100644 (file)
index 0000000..5cbe9ec
Binary files /dev/null and b/t/t5000/19f9c8273ec45a8938e6999cb59b3ff66739902a differ

diff --git a/t/t5000/huge-and-future.tar b/t/t5000/huge-and-future.tar
new file mode 100644 (file)
index 0000000..63155e1
Binary files /dev/null and b/t/t5000/huge-and-future.tar differ