...
Run Format

Source file src/archive/tar/reader_test.go

Documentation: archive/tar

  // 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"
  )
  
  func TestReader(t *testing.T) {
  	vectors := []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
  	}{{
  		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",
  		},
  	}, {
  		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",
  		},
  	}, {
  		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/pax-bad-hdr-file.tar",
  		err:  ErrHeader,
  	}, {
  		file: "testdata/pax-bad-mtime-file.tar",
  		err:  ErrHeader,
  	}, {
  		file: "testdata/pax-pos-size-file.tar",
  		headers: []*Header{{
  			Name:     "foo",
  			Mode:     0640,
  			Uid:      319973,
  			Gid:      5000,
  			Size:     999,
  			ModTime:  time.Unix(1442282516, 0),
  			Typeflag: '0',
  			Uname:    "joetsai",
  			Gname:    "eng",
  		}},
  		chksums: []string{
  			"0afb597b283fe61b5d4879669a350556",
  		},
  	}, {
  		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',
  		}},
  	}, {
  		// GNU tar file with atime and ctime fields set.
  		// Created with the GNU tar v1.27.1.
  		//	tar --incremental -S -cvf gnu-incremental.tar test2
  		file: "testdata/gnu-incremental.tar",
  		headers: []*Header{{
  			Name:       "test2/",
  			Mode:       16877,
  			Uid:        1000,
  			Gid:        1000,
  			Size:       14,
  			ModTime:    time.Unix(1441973427, 0),
  			Typeflag:   'D',
  			Uname:      "rawr",
  			Gname:      "dsnet",
  			AccessTime: time.Unix(1441974501, 0),
  			ChangeTime: time.Unix(1441973436, 0),
  		}, {
  			Name:       "test2/foo",
  			Mode:       33188,
  			Uid:        1000,
  			Gid:        1000,
  			Size:       64,
  			ModTime:    time.Unix(1441973363, 0),
  			Typeflag:   '0',
  			Uname:      "rawr",
  			Gname:      "dsnet",
  			AccessTime: time.Unix(1441974501, 0),
  			ChangeTime: time.Unix(1441973436, 0),
  		}, {
  			Name:       "test2/sparse",
  			Mode:       33188,
  			Uid:        1000,
  			Gid:        1000,
  			Size:       536870912,
  			ModTime:    time.Unix(1441973427, 0),
  			Typeflag:   'S',
  			Uname:      "rawr",
  			Gname:      "dsnet",
  			AccessTime: time.Unix(1441991948, 0),
  			ChangeTime: time.Unix(1441973436, 0),
  		}},
  	}, {
  		// 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,
  	}}
  
  	for i, v := range vectors {
  		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
  			rdbuf   = make([]byte, 8)
  		)
  		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.CopyBuffer(h, tr, rdbuf) // 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 TestSparseFileReader(t *testing.T) {
  	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 := &regFileReader{r: r, nb: int64(len(v.sparseData))}
  
  		var (
  			sfr *sparseFileReader
  			err error
  			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 TestReadOldGNUSparseMap(t *testing.T) {
  	const (
  		t00 = "00000000000\x0000000000000\x00"
  		t11 = "00000000001\x0000000000001\x00"
  		t12 = "00000000001\x0000000000002\x00"
  		t21 = "00000000002\x0000000000001\x00"
  	)
  
  	mkBlk := func(size, sp0, sp1, sp2, sp3, ext string, format int) *block {
  		var blk block
  		copy(blk.GNU().RealSize(), size)
  		copy(blk.GNU().Sparse().Entry(0), sp0)
  		copy(blk.GNU().Sparse().Entry(1), sp1)
  		copy(blk.GNU().Sparse().Entry(2), sp2)
  		copy(blk.GNU().Sparse().Entry(3), sp3)
  		copy(blk.GNU().Sparse().IsExtended(), ext)
  		if format != formatUnknown {
  			blk.SetFormat(format)
  		}
  		return &blk
  	}
  
  	vectors := []struct {
  		data   string        // Input data
  		rawHdr *block        // Input raw header
  		want   []sparseEntry // Expected sparse entries to be outputted
  		err    error         // Expected error to be returned
  	}{
  		{"", mkBlk("", "", "", "", "", "", formatUnknown), nil, ErrHeader},
  		{"", mkBlk("1234", "fewa", "", "", "", "", formatGNU), nil, ErrHeader},
  		{"", mkBlk("0031", "", "", "", "", "", formatGNU), nil, nil},
  		{"", mkBlk("1234", t00, t11, "", "", "", formatGNU),
  			[]sparseEntry{{0, 0}, {1, 1}}, nil},
  		{"", mkBlk("1234", t11, t12, t21, t11, "", formatGNU),
  			[]sparseEntry{{1, 1}, {1, 2}, {2, 1}, {1, 1}}, nil},
  		{"", mkBlk("1234", t11, t12, t21, t11, "\x80", formatGNU),
  			[]sparseEntry{}, io.ErrUnexpectedEOF},
  		{t11 + t11,
  			mkBlk("1234", t11, t12, t21, t11, "\x80", formatGNU),
  			[]sparseEntry{}, io.ErrUnexpectedEOF},
  		{t11 + t21 + strings.Repeat("\x00", 512),
  			mkBlk("1234", t11, t12, t21, t11, "\x80", formatGNU),
  			[]sparseEntry{{1, 1}, {1, 2}, {2, 1}, {1, 1}, {1, 1}, {2, 1}}, nil},
  	}
  
  	for i, v := range vectors {
  		tr := Reader{r: strings.NewReader(v.data)}
  		hdr := new(Header)
  		got, err := tr.readOldGNUSparseMap(hdr, v.rawHdr)
  		if !reflect.DeepEqual(got, v.want) && !(len(got) == 0 && len(v.want) == 0) {
  			t.Errorf("test %d, readOldGNUSparseMap(...): got %v, want %v", i, got, v.want)
  		}
  		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))
  	)
  
  	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) {
  	sp := []sparseEntry{{1, 2}, {3, 4}}
  	for i := 0; i < 98; i++ {
  		sp = append(sp, sparseEntry{54321, 12345})
  	}
  
  	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) {
  	f, err := os.Open("testdata/gnu.tar")
  	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
  
  	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},
  		{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++ {
  		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 TestMergePAX(t *testing.T) {
  	vectors := []struct {
  		in   map[string]string
  		want *Header
  		ok   bool
  	}{{
  		in: map[string]string{
  			"path":  "a/b/c",
  			"uid":   "1000",
  			"mtime": "1350244992.023960108",
  		},
  		want: &Header{
  			Name:    "a/b/c",
  			Uid:     1000,
  			ModTime: time.Unix(1350244992, 23960108),
  		},
  		ok: true,
  	}, {
  		in: map[string]string{
  			"gid": "gtgergergersagersgers",
  		},
  	}, {
  		in: map[string]string{
  			"missing":          "missing",
  			"SCHILY.xattr.key": "value",
  		},
  		want: &Header{
  			Xattrs: map[string]string{"key": "value"},
  		},
  		ok: true,
  	}}
  
  	for i, v := range vectors {
  		got := new(Header)
  		err := mergePAX(got, v.in)
  		if v.ok && !reflect.DeepEqual(*got, *v.want) {
  			t.Errorf("test %d, mergePAX(...):\ngot  %+v\nwant %+v", i, *got, *v.want)
  		}
  		if ok := err == nil; ok != v.ok {
  			t.Errorf("test %d, mergePAX(...): got %v, want %v", i, ok, v.ok)
  		}
  	}
  }
  
  func TestParsePAX(t *testing.T) {
  	vectors := []struct {
  		in   string
  		want map[string]string
  		ok   bool
  	}{
  		{"", nil, true},
  		{"6 k=1\n", map[string]string{"k": "1"}, true},
  		{"10 a=name\n", map[string]string{"a": "name"}, true},
  		{"9 a=name\n", map[string]string{"a": "name"}, true},
  		{"30 mtime=1350244992.023960108\n", map[string]string{"mtime": "1350244992.023960108"}, true},
  		{"3 somelongkey=\n", nil, false},
  		{"50 tooshort=\n", nil, false},
  		{"13 key1=haha\n13 key2=nana\n13 key3=kaka\n",
  			map[string]string{"key1": "haha", "key2": "nana", "key3": "kaka"}, true},
  		{"13 key1=val1\n13 key2=val2\n8 key1=\n",
  			map[string]string{"key2": "val2"}, true},
  		{"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=2\n" +
  			"23 GNU.sparse.offset=1\n25 GNU.sparse.numbytes=2\n" +
  			"23 GNU.sparse.offset=3\n25 GNU.sparse.numbytes=4\n",
  			map[string]string{paxGNUSparseSize: "10", paxGNUSparseNumBlocks: "2", paxGNUSparseMap: "1,2,3,4"}, true},
  		{"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
  			"25 GNU.sparse.numbytes=2\n23 GNU.sparse.offset=1\n",
  			nil, false},
  		{"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
  			"25 GNU.sparse.offset=1,2\n25 GNU.sparse.numbytes=2\n",
  			nil, false},
  	}
  
  	for i, v := range vectors {
  		r := strings.NewReader(v.in)
  		got, err := parsePAX(r)
  		if !reflect.DeepEqual(got, v.want) && !(len(got) == 0 && len(v.want) == 0) {
  			t.Errorf("test %d, parsePAX(...):\ngot  %v\nwant %v", i, got, v.want)
  		}
  		if ok := err == nil; ok != v.ok {
  			t.Errorf("test %d, parsePAX(...): got %v, want %v", i, ok, v.ok)
  		}
  	}
  }
  

View as plain text