forked from mirrors/tar-split
1124 lines
29 KiB
Go
1124 lines
29 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package tar
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/md5"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"math"
|
|
"os"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type untarTest struct {
|
|
file string // Test input file
|
|
headers []*Header // Expected output headers
|
|
chksums []string // MD5 checksum of files, leave as nil if not checked
|
|
err error // Expected error to occur
|
|
}
|
|
|
|
var gnuTarTest = &untarTest{
|
|
file: "testdata/gnu.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "small.txt",
|
|
Mode: 0640,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 5,
|
|
ModTime: time.Unix(1244428340, 0),
|
|
Typeflag: '0',
|
|
Uname: "dsymonds",
|
|
Gname: "eng",
|
|
},
|
|
{
|
|
Name: "small2.txt",
|
|
Mode: 0640,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 11,
|
|
ModTime: time.Unix(1244436044, 0),
|
|
Typeflag: '0',
|
|
Uname: "dsymonds",
|
|
Gname: "eng",
|
|
},
|
|
},
|
|
chksums: []string{
|
|
"e38b27eaccb4391bdec553a7f3ae6b2f",
|
|
"c65bd2e50a56a2138bf1716f2fd56fe9",
|
|
},
|
|
}
|
|
|
|
var sparseTarTest = &untarTest{
|
|
file: "testdata/sparse-formats.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "sparse-gnu",
|
|
Mode: 420,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Size: 200,
|
|
ModTime: time.Unix(1392395740, 0),
|
|
Typeflag: 0x53,
|
|
Linkname: "",
|
|
Uname: "david",
|
|
Gname: "david",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
{
|
|
Name: "sparse-posix-0.0",
|
|
Mode: 420,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Size: 200,
|
|
ModTime: time.Unix(1392342187, 0),
|
|
Typeflag: 0x30,
|
|
Linkname: "",
|
|
Uname: "david",
|
|
Gname: "david",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
{
|
|
Name: "sparse-posix-0.1",
|
|
Mode: 420,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Size: 200,
|
|
ModTime: time.Unix(1392340456, 0),
|
|
Typeflag: 0x30,
|
|
Linkname: "",
|
|
Uname: "david",
|
|
Gname: "david",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
{
|
|
Name: "sparse-posix-1.0",
|
|
Mode: 420,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Size: 200,
|
|
ModTime: time.Unix(1392337404, 0),
|
|
Typeflag: 0x30,
|
|
Linkname: "",
|
|
Uname: "david",
|
|
Gname: "david",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
{
|
|
Name: "end",
|
|
Mode: 420,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Size: 4,
|
|
ModTime: time.Unix(1392398319, 0),
|
|
Typeflag: 0x30,
|
|
Linkname: "",
|
|
Uname: "david",
|
|
Gname: "david",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
},
|
|
chksums: []string{
|
|
"6f53234398c2449fe67c1812d993012f",
|
|
"6f53234398c2449fe67c1812d993012f",
|
|
"6f53234398c2449fe67c1812d993012f",
|
|
"6f53234398c2449fe67c1812d993012f",
|
|
"b0061974914468de549a2af8ced10316",
|
|
},
|
|
}
|
|
|
|
var untarTests = []*untarTest{
|
|
gnuTarTest,
|
|
sparseTarTest,
|
|
{
|
|
file: "testdata/star.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "small.txt",
|
|
Mode: 0640,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 5,
|
|
ModTime: time.Unix(1244592783, 0),
|
|
Typeflag: '0',
|
|
Uname: "dsymonds",
|
|
Gname: "eng",
|
|
AccessTime: time.Unix(1244592783, 0),
|
|
ChangeTime: time.Unix(1244592783, 0),
|
|
},
|
|
{
|
|
Name: "small2.txt",
|
|
Mode: 0640,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 11,
|
|
ModTime: time.Unix(1244592783, 0),
|
|
Typeflag: '0',
|
|
Uname: "dsymonds",
|
|
Gname: "eng",
|
|
AccessTime: time.Unix(1244592783, 0),
|
|
ChangeTime: time.Unix(1244592783, 0),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
file: "testdata/v7.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "small.txt",
|
|
Mode: 0444,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 5,
|
|
ModTime: time.Unix(1244593104, 0),
|
|
Typeflag: '\x00',
|
|
},
|
|
{
|
|
Name: "small2.txt",
|
|
Mode: 0444,
|
|
Uid: 73025,
|
|
Gid: 5000,
|
|
Size: 11,
|
|
ModTime: time.Unix(1244593104, 0),
|
|
Typeflag: '\x00',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
file: "testdata/pax.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
|
|
Mode: 0664,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Uname: "shane",
|
|
Gname: "shane",
|
|
Size: 7,
|
|
ModTime: time.Unix(1350244992, 23960108),
|
|
ChangeTime: time.Unix(1350244992, 23960108),
|
|
AccessTime: time.Unix(1350244992, 23960108),
|
|
Typeflag: TypeReg,
|
|
},
|
|
{
|
|
Name: "a/b",
|
|
Mode: 0777,
|
|
Uid: 1000,
|
|
Gid: 1000,
|
|
Uname: "shane",
|
|
Gname: "shane",
|
|
Size: 0,
|
|
ModTime: time.Unix(1350266320, 910238425),
|
|
ChangeTime: time.Unix(1350266320, 910238425),
|
|
AccessTime: time.Unix(1350266320, 910238425),
|
|
Typeflag: TypeSymlink,
|
|
Linkname: "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
file: "testdata/nil-uid.tar", // golang.org/issue/5290
|
|
headers: []*Header{
|
|
{
|
|
Name: "P1050238.JPG.log",
|
|
Mode: 0664,
|
|
Uid: 0,
|
|
Gid: 0,
|
|
Size: 14,
|
|
ModTime: time.Unix(1365454838, 0),
|
|
Typeflag: TypeReg,
|
|
Linkname: "",
|
|
Uname: "eyefi",
|
|
Gname: "eyefi",
|
|
Devmajor: 0,
|
|
Devminor: 0,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
file: "testdata/xattrs.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "small.txt",
|
|
Mode: 0644,
|
|
Uid: 1000,
|
|
Gid: 10,
|
|
Size: 5,
|
|
ModTime: time.Unix(1386065770, 448252320),
|
|
Typeflag: '0',
|
|
Uname: "alex",
|
|
Gname: "wheel",
|
|
AccessTime: time.Unix(1389782991, 419875220),
|
|
ChangeTime: time.Unix(1389782956, 794414986),
|
|
Xattrs: map[string]string{
|
|
"user.key": "value",
|
|
"user.key2": "value2",
|
|
// Interestingly, selinux encodes the terminating null inside the xattr
|
|
"security.selinux": "unconfined_u:object_r:default_t:s0\x00",
|
|
},
|
|
},
|
|
{
|
|
Name: "small2.txt",
|
|
Mode: 0644,
|
|
Uid: 1000,
|
|
Gid: 10,
|
|
Size: 11,
|
|
ModTime: time.Unix(1386065770, 449252304),
|
|
Typeflag: '0',
|
|
Uname: "alex",
|
|
Gname: "wheel",
|
|
AccessTime: time.Unix(1389782991, 419875220),
|
|
ChangeTime: time.Unix(1386065770, 449252304),
|
|
Xattrs: map[string]string{
|
|
"security.selinux": "unconfined_u:object_r:default_t:s0\x00",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Matches the behavior of GNU, BSD, and STAR tar utilities.
|
|
file: "testdata/gnu-multi-hdrs.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "GNU2/GNU2/long-path-name",
|
|
Linkname: "GNU4/GNU4/long-linkpath-name",
|
|
ModTime: time.Unix(0, 0),
|
|
Typeflag: '2',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Matches the behavior of GNU and BSD tar utilities.
|
|
file: "testdata/pax-multi-hdrs.tar",
|
|
headers: []*Header{
|
|
{
|
|
Name: "bar",
|
|
Linkname: "PAX4/PAX4/long-linkpath-name",
|
|
ModTime: time.Unix(0, 0),
|
|
Typeflag: '2',
|
|
},
|
|
},
|
|
},
|
|
{
|
|
file: "testdata/neg-size.tar",
|
|
err: ErrHeader,
|
|
},
|
|
{
|
|
file: "testdata/issue10968.tar",
|
|
err: ErrHeader,
|
|
},
|
|
{
|
|
file: "testdata/issue11169.tar",
|
|
err: ErrHeader,
|
|
},
|
|
{
|
|
file: "testdata/issue12435.tar",
|
|
err: ErrHeader,
|
|
},
|
|
}
|
|
|
|
func TestReader(t *testing.T) {
|
|
for i, v := range untarTests {
|
|
f, err := os.Open(v.file)
|
|
if err != nil {
|
|
t.Errorf("file %s, test %d: unexpected error: %v", v.file, i, err)
|
|
continue
|
|
}
|
|
defer f.Close()
|
|
|
|
// Capture all headers and checksums.
|
|
var (
|
|
tr = NewReader(f)
|
|
hdrs []*Header
|
|
chksums []string
|
|
)
|
|
for {
|
|
var hdr *Header
|
|
hdr, err = tr.Next()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
err = nil // Expected error
|
|
}
|
|
break
|
|
}
|
|
hdrs = append(hdrs, hdr)
|
|
|
|
if v.chksums == nil {
|
|
continue
|
|
}
|
|
h := md5.New()
|
|
_, err = io.Copy(h, tr) // Effectively an incremental read
|
|
if err != nil {
|
|
break
|
|
}
|
|
chksums = append(chksums, fmt.Sprintf("%x", h.Sum(nil)))
|
|
}
|
|
|
|
for j, hdr := range hdrs {
|
|
if j >= len(v.headers) {
|
|
t.Errorf("file %s, test %d, entry %d: unexpected header:\ngot %+v",
|
|
v.file, i, j, *hdr)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(*hdr, *v.headers[j]) {
|
|
t.Errorf("file %s, test %d, entry %d: incorrect header:\ngot %+v\nwant %+v",
|
|
v.file, i, j, *hdr, *v.headers[j])
|
|
}
|
|
}
|
|
if len(hdrs) != len(v.headers) {
|
|
t.Errorf("file %s, test %d: got %d headers, want %d headers",
|
|
v.file, i, len(hdrs), len(v.headers))
|
|
}
|
|
|
|
for j, sum := range chksums {
|
|
if j >= len(v.chksums) {
|
|
t.Errorf("file %s, test %d, entry %d: unexpected sum: got %s",
|
|
v.file, i, j, sum)
|
|
continue
|
|
}
|
|
if sum != v.chksums[j] {
|
|
t.Errorf("file %s, test %d, entry %d: incorrect checksum: got %s, want %s",
|
|
v.file, i, j, sum, v.chksums[j])
|
|
}
|
|
}
|
|
|
|
if err != v.err {
|
|
t.Errorf("file %s, test %d: unexpected error: got %v, want %v",
|
|
v.file, i, err, v.err)
|
|
}
|
|
f.Close()
|
|
}
|
|
}
|
|
|
|
func TestPartialRead(t *testing.T) {
|
|
f, err := os.Open("testdata/gnu.tar")
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
tr := NewReader(f)
|
|
|
|
// Read the first four bytes; Next() should skip the last byte.
|
|
hdr, err := tr.Next()
|
|
if err != nil || hdr == nil {
|
|
t.Fatalf("Didn't get first file: %v", err)
|
|
}
|
|
buf := make([]byte, 4)
|
|
if _, err := io.ReadFull(tr, buf); err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if expected := []byte("Kilt"); !bytes.Equal(buf, expected) {
|
|
t.Errorf("Contents = %v, want %v", buf, expected)
|
|
}
|
|
|
|
// Second file
|
|
hdr, err = tr.Next()
|
|
if err != nil || hdr == nil {
|
|
t.Fatalf("Didn't get second file: %v", err)
|
|
}
|
|
buf = make([]byte, 6)
|
|
if _, err := io.ReadFull(tr, buf); err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
if expected := []byte("Google"); !bytes.Equal(buf, expected) {
|
|
t.Errorf("Contents = %v, want %v", buf, expected)
|
|
}
|
|
}
|
|
|
|
func TestParsePAXHeader(t *testing.T) {
|
|
paxTests := [][3]string{
|
|
{"a", "a=name", "10 a=name\n"}, // Test case involving multiple acceptable lengths
|
|
{"a", "a=name", "9 a=name\n"}, // Test case involving multiple acceptable length
|
|
{"mtime", "mtime=1350244992.023960108", "30 mtime=1350244992.023960108\n"}}
|
|
for _, test := range paxTests {
|
|
key, expected, raw := test[0], test[1], test[2]
|
|
reader := bytes.NewReader([]byte(raw))
|
|
headers, err := parsePAX(reader)
|
|
if err != nil {
|
|
t.Errorf("Couldn't parse correctly formatted headers: %v", err)
|
|
continue
|
|
}
|
|
if strings.EqualFold(headers[key], expected) {
|
|
t.Errorf("mtime header incorrectly parsed: got %s, wanted %s", headers[key], expected)
|
|
continue
|
|
}
|
|
trailer := make([]byte, 100)
|
|
n, err := reader.Read(trailer)
|
|
if err != io.EOF || n != 0 {
|
|
t.Error("Buffer wasn't consumed")
|
|
}
|
|
}
|
|
badHeaderTests := [][]byte{
|
|
[]byte("3 somelongkey=\n"),
|
|
[]byte("50 tooshort=\n"),
|
|
}
|
|
for _, test := range badHeaderTests {
|
|
if _, err := parsePAX(bytes.NewReader(test)); err != ErrHeader {
|
|
t.Fatal("Unexpected success when parsing bad header")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParsePAXTime(t *testing.T) {
|
|
// Some valid PAX time values
|
|
timestamps := map[string]time.Time{
|
|
"1350244992.023960108": time.Unix(1350244992, 23960108), // The common case
|
|
"1350244992.02396010": time.Unix(1350244992, 23960100), // Lower precision value
|
|
"1350244992.0239601089": time.Unix(1350244992, 23960108), // Higher precision value
|
|
"1350244992": time.Unix(1350244992, 0), // Low precision value
|
|
}
|
|
for input, expected := range timestamps {
|
|
ts, err := parsePAXTime(input)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !ts.Equal(expected) {
|
|
t.Fatalf("Time parsing failure %s %s", ts, expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMergePAX(t *testing.T) {
|
|
hdr := new(Header)
|
|
// Test a string, integer, and time based value.
|
|
headers := map[string]string{
|
|
"path": "a/b/c",
|
|
"uid": "1000",
|
|
"mtime": "1350244992.023960108",
|
|
}
|
|
err := mergePAX(hdr, headers)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := &Header{
|
|
Name: "a/b/c",
|
|
Uid: 1000,
|
|
ModTime: time.Unix(1350244992, 23960108),
|
|
}
|
|
if !reflect.DeepEqual(hdr, want) {
|
|
t.Errorf("incorrect merge: got %+v, want %+v", hdr, want)
|
|
}
|
|
}
|
|
|
|
func TestSparseFileReader(t *testing.T) {
|
|
var vectors = []struct {
|
|
realSize int64 // Real size of the output file
|
|
sparseMap []sparseEntry // Input sparse map
|
|
sparseData string // Input compact data
|
|
expected string // Expected output data
|
|
err error // Expected error outcome
|
|
}{{
|
|
realSize: 8,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 0, numBytes: 2},
|
|
{offset: 5, numBytes: 3},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "ab\x00\x00\x00cde",
|
|
}, {
|
|
realSize: 10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 0, numBytes: 2},
|
|
{offset: 5, numBytes: 3},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "ab\x00\x00\x00cde\x00\x00",
|
|
}, {
|
|
realSize: 8,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 2},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "\x00abc\x00\x00de",
|
|
}, {
|
|
realSize: 8,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 0},
|
|
{offset: 6, numBytes: 0},
|
|
{offset: 6, numBytes: 2},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "\x00abc\x00\x00de",
|
|
}, {
|
|
realSize: 10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 2},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "\x00abc\x00\x00de\x00\x00",
|
|
}, {
|
|
realSize: 10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 2},
|
|
{offset: 8, numBytes: 0},
|
|
{offset: 8, numBytes: 0},
|
|
{offset: 8, numBytes: 0},
|
|
{offset: 8, numBytes: 0},
|
|
},
|
|
sparseData: "abcde",
|
|
expected: "\x00abc\x00\x00de\x00\x00",
|
|
}, {
|
|
realSize: 2,
|
|
sparseMap: []sparseEntry{},
|
|
sparseData: "",
|
|
expected: "\x00\x00",
|
|
}, {
|
|
realSize: -2,
|
|
sparseMap: []sparseEntry{},
|
|
err: ErrHeader,
|
|
}, {
|
|
realSize: -10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 2},
|
|
},
|
|
sparseData: "abcde",
|
|
err: ErrHeader,
|
|
}, {
|
|
realSize: 10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 5},
|
|
},
|
|
sparseData: "abcde",
|
|
err: ErrHeader,
|
|
}, {
|
|
realSize: 35,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: 5},
|
|
},
|
|
sparseData: "abcde",
|
|
err: io.ErrUnexpectedEOF,
|
|
}, {
|
|
realSize: 35,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 6, numBytes: -5},
|
|
},
|
|
sparseData: "abcde",
|
|
err: ErrHeader,
|
|
}, {
|
|
realSize: 35,
|
|
sparseMap: []sparseEntry{
|
|
{offset: math.MaxInt64, numBytes: 3},
|
|
{offset: 6, numBytes: -5},
|
|
},
|
|
sparseData: "abcde",
|
|
err: ErrHeader,
|
|
}, {
|
|
realSize: 10,
|
|
sparseMap: []sparseEntry{
|
|
{offset: 1, numBytes: 3},
|
|
{offset: 2, numBytes: 2},
|
|
},
|
|
sparseData: "abcde",
|
|
err: ErrHeader,
|
|
}}
|
|
|
|
for i, v := range vectors {
|
|
r := bytes.NewReader([]byte(v.sparseData))
|
|
rfr := ®FileReader{r: r, nb: int64(len(v.sparseData))}
|
|
|
|
var sfr *sparseFileReader
|
|
var err error
|
|
var buf []byte
|
|
|
|
sfr, err = newSparseFileReader(rfr, v.sparseMap, v.realSize)
|
|
if err != nil {
|
|
goto fail
|
|
}
|
|
if sfr.numBytes() != int64(len(v.sparseData)) {
|
|
t.Errorf("test %d, numBytes() before reading: got %d, want %d", i, sfr.numBytes(), len(v.sparseData))
|
|
}
|
|
buf, err = ioutil.ReadAll(sfr)
|
|
if err != nil {
|
|
goto fail
|
|
}
|
|
if string(buf) != v.expected {
|
|
t.Errorf("test %d, ReadAll(): got %q, want %q", i, string(buf), v.expected)
|
|
}
|
|
if sfr.numBytes() != 0 {
|
|
t.Errorf("test %d, numBytes() after reading: got %d, want %d", i, sfr.numBytes(), 0)
|
|
}
|
|
|
|
fail:
|
|
if err != v.err {
|
|
t.Errorf("test %d, unexpected error: got %v, want %v", i, err, v.err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReadGNUSparseMap0x1(t *testing.T) {
|
|
const (
|
|
maxUint = ^uint(0)
|
|
maxInt = int(maxUint >> 1)
|
|
)
|
|
var (
|
|
big1 = fmt.Sprintf("%d", int64(maxInt))
|
|
big2 = fmt.Sprintf("%d", (int64(maxInt)/2)+1)
|
|
big3 = fmt.Sprintf("%d", (int64(maxInt) / 3))
|
|
)
|
|
|
|
var vectors = []struct {
|
|
extHdrs map[string]string // Input data
|
|
sparseMap []sparseEntry // Expected sparse entries to be outputted
|
|
err error // Expected errors that may be raised
|
|
}{{
|
|
extHdrs: map[string]string{paxGNUSparseNumBlocks: "-4"},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{paxGNUSparseNumBlocks: "fee "},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: big1,
|
|
paxGNUSparseMap: "0,5,10,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: big2,
|
|
paxGNUSparseMap: "0,5,10,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: big3,
|
|
paxGNUSparseMap: "0,5,10,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: "4",
|
|
paxGNUSparseMap: "0.5,5,10,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: "4",
|
|
paxGNUSparseMap: "0,5.5,10,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: "4",
|
|
paxGNUSparseMap: "0,fewafewa.5,fewafw,5,20,5,30,5",
|
|
},
|
|
err: ErrHeader,
|
|
}, {
|
|
extHdrs: map[string]string{
|
|
paxGNUSparseNumBlocks: "4",
|
|
paxGNUSparseMap: "0,5,10,5,20,5,30,5",
|
|
},
|
|
sparseMap: []sparseEntry{{0, 5}, {10, 5}, {20, 5}, {30, 5}},
|
|
}}
|
|
|
|
for i, v := range vectors {
|
|
sp, err := readGNUSparseMap0x1(v.extHdrs)
|
|
if !reflect.DeepEqual(sp, v.sparseMap) && !(len(sp) == 0 && len(v.sparseMap) == 0) {
|
|
t.Errorf("test %d, readGNUSparseMap0x1(...): got %v, want %v", i, sp, v.sparseMap)
|
|
}
|
|
if err != v.err {
|
|
t.Errorf("test %d, unexpected error: got %v, want %v", i, err, v.err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReadGNUSparseMap1x0(t *testing.T) {
|
|
var sp = []sparseEntry{{1, 2}, {3, 4}}
|
|
for i := 0; i < 98; i++ {
|
|
sp = append(sp, sparseEntry{54321, 12345})
|
|
}
|
|
|
|
var vectors = []struct {
|
|
input string // Input data
|
|
sparseMap []sparseEntry // Expected sparse entries to be outputted
|
|
cnt int // Expected number of bytes read
|
|
err error // Expected errors that may be raised
|
|
}{{
|
|
input: "",
|
|
cnt: 0,
|
|
err: io.ErrUnexpectedEOF,
|
|
}, {
|
|
input: "ab",
|
|
cnt: 2,
|
|
err: io.ErrUnexpectedEOF,
|
|
}, {
|
|
input: strings.Repeat("\x00", 512),
|
|
cnt: 512,
|
|
err: io.ErrUnexpectedEOF,
|
|
}, {
|
|
input: strings.Repeat("\x00", 511) + "\n",
|
|
cnt: 512,
|
|
err: ErrHeader,
|
|
}, {
|
|
input: strings.Repeat("\n", 512),
|
|
cnt: 512,
|
|
err: ErrHeader,
|
|
}, {
|
|
input: "0\n" + strings.Repeat("\x00", 510) + strings.Repeat("a", 512),
|
|
sparseMap: []sparseEntry{},
|
|
cnt: 512,
|
|
}, {
|
|
input: strings.Repeat("0", 512) + "0\n" + strings.Repeat("\x00", 510),
|
|
sparseMap: []sparseEntry{},
|
|
cnt: 1024,
|
|
}, {
|
|
input: strings.Repeat("0", 1024) + "1\n2\n3\n" + strings.Repeat("\x00", 506),
|
|
sparseMap: []sparseEntry{{2, 3}},
|
|
cnt: 1536,
|
|
}, {
|
|
input: strings.Repeat("0", 1024) + "1\n2\n\n" + strings.Repeat("\x00", 509),
|
|
cnt: 1536,
|
|
err: ErrHeader,
|
|
}, {
|
|
input: strings.Repeat("0", 1024) + "1\n2\n" + strings.Repeat("\x00", 508),
|
|
cnt: 1536,
|
|
err: io.ErrUnexpectedEOF,
|
|
}, {
|
|
input: "-1\n2\n\n" + strings.Repeat("\x00", 506),
|
|
cnt: 512,
|
|
err: ErrHeader,
|
|
}, {
|
|
input: "1\nk\n2\n" + strings.Repeat("\x00", 506),
|
|
cnt: 512,
|
|
err: ErrHeader,
|
|
}, {
|
|
input: "100\n1\n2\n3\n4\n" + strings.Repeat("54321\n0000000000000012345\n", 98) + strings.Repeat("\x00", 512),
|
|
cnt: 2560,
|
|
sparseMap: sp,
|
|
}}
|
|
|
|
for i, v := range vectors {
|
|
r := strings.NewReader(v.input)
|
|
sp, err := readGNUSparseMap1x0(r)
|
|
if !reflect.DeepEqual(sp, v.sparseMap) && !(len(sp) == 0 && len(v.sparseMap) == 0) {
|
|
t.Errorf("test %d, readGNUSparseMap1x0(...): got %v, want %v", i, sp, v.sparseMap)
|
|
}
|
|
if numBytes := len(v.input) - r.Len(); numBytes != v.cnt {
|
|
t.Errorf("test %d, bytes read: got %v, want %v", i, numBytes, v.cnt)
|
|
}
|
|
if err != v.err {
|
|
t.Errorf("test %d, unexpected error: got %v, want %v", i, err, v.err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUninitializedRead(t *testing.T) {
|
|
test := gnuTarTest
|
|
f, err := os.Open(test.file)
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
tr := NewReader(f)
|
|
_, err = tr.Read([]byte{})
|
|
if err == nil || err != io.EOF {
|
|
t.Errorf("Unexpected error: %v, wanted %v", err, io.EOF)
|
|
}
|
|
|
|
}
|
|
|
|
type reader struct{ io.Reader }
|
|
type readSeeker struct{ io.ReadSeeker }
|
|
type readBadSeeker struct{ io.ReadSeeker }
|
|
|
|
func (rbs *readBadSeeker) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("illegal seek") }
|
|
|
|
// TestReadTruncation test the ending condition on various truncated files and
|
|
// that truncated files are still detected even if the underlying io.Reader
|
|
// satisfies io.Seeker.
|
|
func TestReadTruncation(t *testing.T) {
|
|
var ss []string
|
|
for _, p := range []string{
|
|
"testdata/gnu.tar",
|
|
"testdata/ustar-file-reg.tar",
|
|
"testdata/pax-path-hdr.tar",
|
|
"testdata/sparse-formats.tar",
|
|
} {
|
|
buf, err := ioutil.ReadFile(p)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
ss = append(ss, string(buf))
|
|
}
|
|
|
|
data1, data2, pax, sparse := ss[0], ss[1], ss[2], ss[3]
|
|
data2 += strings.Repeat("\x00", 10*512)
|
|
trash := strings.Repeat("garbage ", 64) // Exactly 512 bytes
|
|
|
|
var vectors = []struct {
|
|
input string // Input stream
|
|
cnt int // Expected number of headers read
|
|
err error // Expected error outcome
|
|
}{
|
|
{"", 0, io.EOF}, // Empty file is a "valid" tar file
|
|
{data1[:511], 0, io.ErrUnexpectedEOF},
|
|
{data1[:512], 1, io.ErrUnexpectedEOF},
|
|
{data1[:1024], 1, io.EOF},
|
|
{data1[:1536], 2, io.ErrUnexpectedEOF},
|
|
{data1[:2048], 2, io.EOF},
|
|
{data1, 2, io.EOF},
|
|
{data1[:2048] + data2[:1536], 3, io.EOF},
|
|
{data2[:511], 0, io.ErrUnexpectedEOF},
|
|
{data2[:512], 1, io.ErrUnexpectedEOF},
|
|
{data2[:1195], 1, io.ErrUnexpectedEOF},
|
|
{data2[:1196], 1, io.EOF}, // Exact end of data and start of padding
|
|
{data2[:1200], 1, io.EOF},
|
|
{data2[:1535], 1, io.EOF},
|
|
{data2[:1536], 1, io.EOF}, // Exact end of padding
|
|
{data2[:1536] + trash[:1], 1, io.ErrUnexpectedEOF},
|
|
{data2[:1536] + trash[:511], 1, io.ErrUnexpectedEOF},
|
|
{data2[:1536] + trash, 1, ErrHeader},
|
|
{data2[:2048], 1, io.EOF}, // Exactly 1 empty block
|
|
{data2[:2048] + trash[:1], 1, io.ErrUnexpectedEOF},
|
|
{data2[:2048] + trash[:511], 1, io.ErrUnexpectedEOF},
|
|
{data2[:2048] + trash, 1, ErrHeader},
|
|
{data2[:2560], 1, io.EOF}, // Exactly 2 empty blocks (normal end-of-stream)
|
|
{data2[:2560] + trash[:1], 1, io.EOF},
|
|
{data2[:2560] + trash[:511], 1, io.EOF},
|
|
{data2[:2560] + trash, 1, io.EOF},
|
|
{data2[:3072], 1, io.EOF},
|
|
{pax, 0, io.EOF}, // PAX header without data is a "valid" tar file
|
|
{pax + trash[:1], 0, io.ErrUnexpectedEOF},
|
|
{pax + trash[:511], 0, io.ErrUnexpectedEOF},
|
|
{sparse[:511], 0, io.ErrUnexpectedEOF},
|
|
// TODO(dsnet): This should pass, but currently fails.
|
|
// {sparse[:512], 0, io.ErrUnexpectedEOF},
|
|
{sparse[:3584], 1, io.EOF},
|
|
{sparse[:9200], 1, io.EOF}, // Terminate in padding of sparse header
|
|
{sparse[:9216], 1, io.EOF},
|
|
{sparse[:9728], 2, io.ErrUnexpectedEOF},
|
|
{sparse[:10240], 2, io.EOF},
|
|
{sparse[:11264], 2, io.ErrUnexpectedEOF},
|
|
{sparse, 5, io.EOF},
|
|
{sparse + trash, 5, io.EOF},
|
|
}
|
|
|
|
for i, v := range vectors {
|
|
for j := 0; j < 6; j++ {
|
|
var tr *Reader
|
|
var s1, s2 string
|
|
|
|
switch j {
|
|
case 0:
|
|
tr = NewReader(&reader{strings.NewReader(v.input)})
|
|
s1, s2 = "io.Reader", "auto"
|
|
case 1:
|
|
tr = NewReader(&reader{strings.NewReader(v.input)})
|
|
s1, s2 = "io.Reader", "manual"
|
|
case 2:
|
|
tr = NewReader(&readSeeker{strings.NewReader(v.input)})
|
|
s1, s2 = "io.ReadSeeker", "auto"
|
|
case 3:
|
|
tr = NewReader(&readSeeker{strings.NewReader(v.input)})
|
|
s1, s2 = "io.ReadSeeker", "manual"
|
|
case 4:
|
|
tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
|
|
s1, s2 = "ReadBadSeeker", "auto"
|
|
case 5:
|
|
tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
|
|
s1, s2 = "ReadBadSeeker", "manual"
|
|
}
|
|
|
|
var cnt int
|
|
var err error
|
|
for {
|
|
if _, err = tr.Next(); err != nil {
|
|
break
|
|
}
|
|
cnt++
|
|
if s2 == "manual" {
|
|
if _, err = io.Copy(ioutil.Discard, tr); err != nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if err != v.err {
|
|
t.Errorf("test %d, NewReader(%s(...)) with %s discard: got %v, want %v",
|
|
i, s1, s2, err, v.err)
|
|
}
|
|
if cnt != v.cnt {
|
|
t.Errorf("test %d, NewReader(%s(...)) with %s discard: got %d headers, want %d headers",
|
|
i, s1, s2, cnt, v.cnt)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestReadHeaderOnly tests that Reader does not attempt to read special
|
|
// header-only files.
|
|
func TestReadHeaderOnly(t *testing.T) {
|
|
f, err := os.Open("testdata/hdr-only.tar")
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
var hdrs []*Header
|
|
tr := NewReader(f)
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Errorf("Next(): got %v, want %v", err, nil)
|
|
continue
|
|
}
|
|
hdrs = append(hdrs, hdr)
|
|
|
|
// If a special flag, we should read nothing.
|
|
cnt, _ := io.ReadFull(tr, []byte{0})
|
|
if cnt > 0 && hdr.Typeflag != TypeReg {
|
|
t.Errorf("ReadFull(...): got %d bytes, want 0 bytes", cnt)
|
|
}
|
|
}
|
|
|
|
// File is crafted with 16 entries. The later 8 are identical to the first
|
|
// 8 except that the size is set.
|
|
if len(hdrs) != 16 {
|
|
t.Fatalf("len(hdrs): got %d, want %d", len(hdrs), 16)
|
|
}
|
|
for i := 0; i < 8; i++ {
|
|
var hdr1, hdr2 = hdrs[i+0], hdrs[i+8]
|
|
hdr1.Size, hdr2.Size = 0, 0
|
|
if !reflect.DeepEqual(*hdr1, *hdr2) {
|
|
t.Errorf("incorrect header:\ngot %+v\nwant %+v", *hdr1, *hdr2)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParsePAXRecord(t *testing.T) {
|
|
var medName = strings.Repeat("CD", 50)
|
|
var longName = strings.Repeat("AB", 100)
|
|
|
|
var vectors = []struct {
|
|
input string
|
|
residual string
|
|
outputKey string
|
|
outputVal string
|
|
ok bool
|
|
}{
|
|
{"6 k=v\n\n", "\n", "k", "v", true},
|
|
{"19 path=/etc/hosts\n", "", "path", "/etc/hosts", true},
|
|
{"210 path=" + longName + "\nabc", "abc", "path", longName, true},
|
|
{"110 path=" + medName + "\n", "", "path", medName, true},
|
|
{"9 foo=ba\n", "", "foo", "ba", true},
|
|
{"11 foo=bar\n\x00", "\x00", "foo", "bar", true},
|
|
{"18 foo=b=\nar=\n==\x00\n", "", "foo", "b=\nar=\n==\x00", true},
|
|
{"27 foo=hello9 foo=ba\nworld\n", "", "foo", "hello9 foo=ba\nworld", true},
|
|
{"27 ☺☻☹=日a本b語ç\nmeow mix", "meow mix", "☺☻☹", "日a本b語ç", true},
|
|
{"17 \x00hello=\x00world\n", "", "\x00hello", "\x00world", true},
|
|
{"1 k=1\n", "1 k=1\n", "", "", false},
|
|
{"6 k~1\n", "6 k~1\n", "", "", false},
|
|
{"6_k=1\n", "6_k=1\n", "", "", false},
|
|
{"6 k=1 ", "6 k=1 ", "", "", false},
|
|
{"632 k=1\n", "632 k=1\n", "", "", false},
|
|
{"16 longkeyname=hahaha\n", "16 longkeyname=hahaha\n", "", "", false},
|
|
{"3 somelongkey=\n", "3 somelongkey=\n", "", "", false},
|
|
{"50 tooshort=\n", "50 tooshort=\n", "", "", false},
|
|
}
|
|
|
|
for _, v := range vectors {
|
|
key, val, res, err := parsePAXRecord(v.input)
|
|
ok := (err == nil)
|
|
if v.ok != ok {
|
|
if v.ok {
|
|
t.Errorf("parsePAXRecord(%q): got parsing failure, want success", v.input)
|
|
} else {
|
|
t.Errorf("parsePAXRecord(%q): got parsing success, want failure", v.input)
|
|
}
|
|
}
|
|
if ok && (key != v.outputKey || val != v.outputVal) {
|
|
t.Errorf("parsePAXRecord(%q): got (%q: %q), want (%q: %q)",
|
|
v.input, key, val, v.outputKey, v.outputVal)
|
|
}
|
|
if res != v.residual {
|
|
t.Errorf("parsePAXRecord(%q): got residual %q, want residual %q",
|
|
v.input, res, v.residual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseNumeric(t *testing.T) {
|
|
var vectors = []struct {
|
|
input string
|
|
output int64
|
|
ok bool
|
|
}{
|
|
// Test base-256 (binary) encoded values.
|
|
{"", 0, true},
|
|
{"\x80", 0, true},
|
|
{"\x80\x00", 0, true},
|
|
{"\x80\x00\x00", 0, true},
|
|
{"\xbf", (1 << 6) - 1, true},
|
|
{"\xbf\xff", (1 << 14) - 1, true},
|
|
{"\xbf\xff\xff", (1 << 22) - 1, true},
|
|
{"\xff", -1, true},
|
|
{"\xff\xff", -1, true},
|
|
{"\xff\xff\xff", -1, true},
|
|
{"\xc0", -1 * (1 << 6), true},
|
|
{"\xc0\x00", -1 * (1 << 14), true},
|
|
{"\xc0\x00\x00", -1 * (1 << 22), true},
|
|
{"\x87\x76\xa2\x22\xeb\x8a\x72\x61", 537795476381659745, true},
|
|
{"\x80\x00\x00\x00\x07\x76\xa2\x22\xeb\x8a\x72\x61", 537795476381659745, true},
|
|
{"\xf7\x76\xa2\x22\xeb\x8a\x72\x61", -615126028225187231, true},
|
|
{"\xff\xff\xff\xff\xf7\x76\xa2\x22\xeb\x8a\x72\x61", -615126028225187231, true},
|
|
{"\x80\x7f\xff\xff\xff\xff\xff\xff\xff", math.MaxInt64, true},
|
|
{"\x80\x80\x00\x00\x00\x00\x00\x00\x00", 0, false},
|
|
{"\xff\x80\x00\x00\x00\x00\x00\x00\x00", math.MinInt64, true},
|
|
{"\xff\x7f\xff\xff\xff\xff\xff\xff\xff", 0, false},
|
|
{"\xf5\xec\xd1\xc7\x7e\x5f\x26\x48\x81\x9f\x8f\x9b", 0, false},
|
|
|
|
// Test base-8 (octal) encoded values.
|
|
{"0000000\x00", 0, true},
|
|
{" \x0000000\x00", 0, true},
|
|
{" \x0000003\x00", 3, true},
|
|
{"00000000227\x00", 0227, true},
|
|
{"032033\x00 ", 032033, true},
|
|
{"320330\x00 ", 0320330, true},
|
|
{"0000660\x00 ", 0660, true},
|
|
{"\x00 0000660\x00 ", 0660, true},
|
|
{"0123456789abcdef", 0, false},
|
|
{"0123456789\x00abcdef", 0, false},
|
|
{"01234567\x0089abcdef", 342391, true},
|
|
{"0123\x7e\x5f\x264123", 0, false},
|
|
}
|
|
|
|
for _, v := range vectors {
|
|
var p parser
|
|
num := p.parseNumeric([]byte(v.input))
|
|
ok := (p.err == nil)
|
|
if v.ok != ok {
|
|
if v.ok {
|
|
t.Errorf("parseNumeric(%q): got parsing failure, want success", v.input)
|
|
} else {
|
|
t.Errorf("parseNumeric(%q): got parsing success, want failure", v.input)
|
|
}
|
|
}
|
|
if ok && num != v.output {
|
|
t.Errorf("parseNumeric(%q): got %d, want %d", v.input, num, v.output)
|
|
}
|
|
}
|
|
}
|