@@ -3,6 +3,7 @@

 package windows // import "github.com/docker/docker/daemon/graphdriver/windows"

 import (

+	"archive/tar"

 	"bufio"

 	"bytes"

 	"encoding/json"

@@ -20,7 +21,6 @@ import (

 	"unsafe"

 	winio "github.com/Microsoft/go-winio"

-	"github.com/Microsoft/go-winio/archive/tar"

 	"github.com/Microsoft/go-winio/backuptar"

 	"github.com/Microsoft/go-winio/vhd"

 	"github.com/Microsoft/hcsshim"

@@ -1,6 +1,6 @@

 github.com/Azure/go-ansiterm                        d6e3b3328b783f23731bc4d058875b0371ff8109

 github.com/Microsoft/hcsshim                        9dcb42f100215f8d375b4a9265e5bba009217a85 # moby branch

-github.com/Microsoft/go-winio                       6c72808b55902eae4c5943626030429ff20f3b63 # v0.4.14

+github.com/Microsoft/go-winio                       5b44b70ab3ab4d291a7c1d28afe7b4afeced0ed4 # v0.4.15-0.20200908182639-5b44b70ab3ab

 github.com/docker/libtrust                          9cbd2a1374f46905c68a4eb3694a130610adc62a

 github.com/golang/gddo                              72a348e765d293ed6d1ded7b699591f14d6cd921

 github.com/google/uuid                              0cd6bf5da1e1c83f8b45653022c74f71af0538a4 # v1.1.1

deleted file mode 100644

@@ -1,27 +0,0 @@

-Copyright (c) 2012 The Go Authors. All rights reserved.

-

-Redistribution and use in source and binary forms, with or without

-modification, are permitted provided that the following conditions are

-met:

-

-   * Redistributions of source code must retain the above copyright

-notice, this list of conditions and the following disclaimer.

-   * Redistributions in binary form must reproduce the above

-copyright notice, this list of conditions and the following disclaimer

-in the documentation and/or other materials provided with the

-distribution.

-   * Neither the name of Google Inc. nor the names of its

-contributors may be used to endorse or promote products derived from

-this software without specific prior written permission.

-

-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deleted file mode 100644

@@ -1,344 +0,0 @@

-// 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 implements access to tar archives.

-// It aims to cover most of the variations, including those produced

-// by GNU and BSD tars.

-//

-// References:

-//   http://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5

-//   http://www.gnu.org/software/tar/manual/html_node/Standard.html

-//   http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html

-package tar

-

-import (

-	"bytes"

-	"errors"

-	"fmt"

-	"os"

-	"path"

-	"time"

-)

-

-const (

-	blockSize = 512

-

-	// Types

-	TypeReg           = '0'    // regular file

-	TypeRegA          = '\x00' // regular file

-	TypeLink          = '1'    // hard link

-	TypeSymlink       = '2'    // symbolic link

-	TypeChar          = '3'    // character device node

-	TypeBlock         = '4'    // block device node

-	TypeDir           = '5'    // directory

-	TypeFifo          = '6'    // fifo node

-	TypeCont          = '7'    // reserved

-	TypeXHeader       = 'x'    // extended header

-	TypeXGlobalHeader = 'g'    // global extended header

-	TypeGNULongName   = 'L'    // Next file has a long name

-	TypeGNULongLink   = 'K'    // Next file symlinks to a file w/ a long name

-	TypeGNUSparse     = 'S'    // sparse file

-)

-

-// A Header represents a single header in a tar archive.

-// Some fields may not be populated.

-type Header struct {

-	Name         string    // name of header file entry

-	Mode         int64     // permission and mode bits

-	Uid          int       // user id of owner

-	Gid          int       // group id of owner

-	Size         int64     // length in bytes

-	ModTime      time.Time // modified time

-	Typeflag     byte      // type of header entry

-	Linkname     string    // target name of link

-	Uname        string    // user name of owner

-	Gname        string    // group name of owner

-	Devmajor     int64     // major number of character or block device

-	Devminor     int64     // minor number of character or block device

-	AccessTime   time.Time // access time

-	ChangeTime   time.Time // status change time

-	CreationTime time.Time // creation time

-	Xattrs       map[string]string

-	Winheaders   map[string]string

-}

-

-// File name constants from the tar spec.

-const (

-	fileNameSize       = 100 // Maximum number of bytes in a standard tar name.

-	fileNamePrefixSize = 155 // Maximum number of ustar extension bytes.

-)

-

-// FileInfo returns an os.FileInfo for the Header.

-func (h *Header) FileInfo() os.FileInfo {

-	return headerFileInfo{h}

-}

-

-// headerFileInfo implements os.FileInfo.

-type headerFileInfo struct {

-	h *Header

-}

-

-func (fi headerFileInfo) Size() int64        { return fi.h.Size }

-func (fi headerFileInfo) IsDir() bool        { return fi.Mode().IsDir() }

-func (fi headerFileInfo) ModTime() time.Time { return fi.h.ModTime }

-func (fi headerFileInfo) Sys() interface{}   { return fi.h }

-

-// Name returns the base name of the file.

-func (fi headerFileInfo) Name() string {

-	if fi.IsDir() {

-		return path.Base(path.Clean(fi.h.Name))

-	}

-	return path.Base(fi.h.Name)

-}

-

-// Mode returns the permission and mode bits for the headerFileInfo.

-func (fi headerFileInfo) Mode() (mode os.FileMode) {

-	// Set file permission bits.

-	mode = os.FileMode(fi.h.Mode).Perm()

-

-	// Set setuid, setgid and sticky bits.

-	if fi.h.Mode&c_ISUID != 0 {

-		// setuid

-		mode |= os.ModeSetuid

-	}

-	if fi.h.Mode&c_ISGID != 0 {

-		// setgid

-		mode |= os.ModeSetgid

-	}

-	if fi.h.Mode&c_ISVTX != 0 {

-		// sticky

-		mode |= os.ModeSticky

-	}

-

-	// Set file mode bits.

-	// clear perm, setuid, setgid and sticky bits.

-	m := os.FileMode(fi.h.Mode) &^ 07777

-	if m == c_ISDIR {

-		// directory

-		mode |= os.ModeDir

-	}

-	if m == c_ISFIFO {

-		// named pipe (FIFO)

-		mode |= os.ModeNamedPipe

-	}

-	if m == c_ISLNK {

-		// symbolic link

-		mode |= os.ModeSymlink

-	}

-	if m == c_ISBLK {

-		// device file

-		mode |= os.ModeDevice

-	}

-	if m == c_ISCHR {

-		// Unix character device

-		mode |= os.ModeDevice

-		mode |= os.ModeCharDevice

-	}

-	if m == c_ISSOCK {

-		// Unix domain socket

-		mode |= os.ModeSocket

-	}

-

-	switch fi.h.Typeflag {

-	case TypeSymlink:

-		// symbolic link

-		mode |= os.ModeSymlink

-	case TypeChar:

-		// character device node

-		mode |= os.ModeDevice

-		mode |= os.ModeCharDevice

-	case TypeBlock:

-		// block device node

-		mode |= os.ModeDevice

-	case TypeDir:

-		// directory

-		mode |= os.ModeDir

-	case TypeFifo:

-		// fifo node

-		mode |= os.ModeNamedPipe

-	}

-

-	return mode

-}

-

-// sysStat, if non-nil, populates h from system-dependent fields of fi.

-var sysStat func(fi os.FileInfo, h *Header) error

-

-// Mode constants from the tar spec.

-const (

-	c_ISUID  = 04000   // Set uid

-	c_ISGID  = 02000   // Set gid

-	c_ISVTX  = 01000   // Save text (sticky bit)

-	c_ISDIR  = 040000  // Directory

-	c_ISFIFO = 010000  // FIFO

-	c_ISREG  = 0100000 // Regular file

-	c_ISLNK  = 0120000 // Symbolic link

-	c_ISBLK  = 060000  // Block special file

-	c_ISCHR  = 020000  // Character special file

-	c_ISSOCK = 0140000 // Socket

-)

-

-// Keywords for the PAX Extended Header

-const (

-	paxAtime        = "atime"

-	paxCharset      = "charset"

-	paxComment      = "comment"

-	paxCtime        = "ctime" // please note that ctime is not a valid pax header.

-	paxCreationTime = "LIBARCHIVE.creationtime"

-	paxGid          = "gid"

-	paxGname        = "gname"

-	paxLinkpath     = "linkpath"

-	paxMtime        = "mtime"

-	paxPath         = "path"

-	paxSize         = "size"

-	paxUid          = "uid"

-	paxUname        = "uname"

-	paxXattr        = "SCHILY.xattr."

-	paxWindows      = "MSWINDOWS."

-	paxNone         = ""

-)

-

-// FileInfoHeader creates a partially-populated Header from fi.

-// If fi describes a symlink, FileInfoHeader records link as the link target.

-// If fi describes a directory, a slash is appended to the name.

-// Because os.FileInfo's Name method returns only the base name of

-// the file it describes, it may be necessary to modify the Name field

-// of the returned header to provide the full path name of the file.

-func FileInfoHeader(fi os.FileInfo, link string) (*Header, error) {

-	if fi == nil {

-		return nil, errors.New("tar: FileInfo is nil")

-	}

-	fm := fi.Mode()

-	h := &Header{

-		Name:    fi.Name(),

-		ModTime: fi.ModTime(),

-		Mode:    int64(fm.Perm()), // or'd with c_IS* constants later

-	}

-	switch {

-	case fm.IsRegular():

-		h.Mode |= c_ISREG

-		h.Typeflag = TypeReg

-		h.Size = fi.Size()

-	case fi.IsDir():

-		h.Typeflag = TypeDir

-		h.Mode |= c_ISDIR

-		h.Name += "/"

-	case fm&os.ModeSymlink != 0:

-		h.Typeflag = TypeSymlink

-		h.Mode |= c_ISLNK

-		h.Linkname = link

-	case fm&os.ModeDevice != 0:

-		if fm&os.ModeCharDevice != 0 {

-			h.Mode |= c_ISCHR

-			h.Typeflag = TypeChar

-		} else {

-			h.Mode |= c_ISBLK

-			h.Typeflag = TypeBlock

-		}

-	case fm&os.ModeNamedPipe != 0:

-		h.Typeflag = TypeFifo

-		h.Mode |= c_ISFIFO

-	case fm&os.ModeSocket != 0:

-		h.Mode |= c_ISSOCK

-	default:

-		return nil, fmt.Errorf("archive/tar: unknown file mode %v", fm)

-	}

-	if fm&os.ModeSetuid != 0 {

-		h.Mode |= c_ISUID

-	}

-	if fm&os.ModeSetgid != 0 {

-		h.Mode |= c_ISGID

-	}

-	if fm&os.ModeSticky != 0 {

-		h.Mode |= c_ISVTX

-	}

-	// If possible, populate additional fields from OS-specific

-	// FileInfo fields.

-	if sys, ok := fi.Sys().(*Header); ok {

-		// This FileInfo came from a Header (not the OS). Use the

-		// original Header to populate all remaining fields.

-		h.Uid = sys.Uid

-		h.Gid = sys.Gid

-		h.Uname = sys.Uname

-		h.Gname = sys.Gname

-		h.AccessTime = sys.AccessTime

-		h.ChangeTime = sys.ChangeTime

-		if sys.Xattrs != nil {

-			h.Xattrs = make(map[string]string)

-			for k, v := range sys.Xattrs {

-				h.Xattrs[k] = v

-			}

-		}

-		if sys.Typeflag == TypeLink {

-			// hard link

-			h.Typeflag = TypeLink

-			h.Size = 0

-			h.Linkname = sys.Linkname

-		}

-	}

-	if sysStat != nil {

-		return h, sysStat(fi, h)

-	}

-	return h, nil

-}

-

-var zeroBlock = make([]byte, blockSize)

-

-// POSIX specifies a sum of the unsigned byte values, but the Sun tar uses signed byte values.

-// We compute and return both.

-func checksum(header []byte) (unsigned int64, signed int64) {

-	for i := 0; i < len(header); i++ {

-		if i == 148 {

-			// The chksum field (header[148:156]) is special: it should be treated as space bytes.

-			unsigned += ' ' * 8

-			signed += ' ' * 8

-			i += 7

-			continue

-		}

-		unsigned += int64(header[i])

-		signed += int64(int8(header[i]))

-	}

-	return

-}

-

-type slicer []byte

-

-func (sp *slicer) next(n int) (b []byte) {

-	s := *sp

-	b, *sp = s[0:n], s[n:]

-	return

-}

-

-func isASCII(s string) bool {

-	for _, c := range s {

-		if c >= 0x80 {

-			return false

-		}

-	}

-	return true

-}

-

-func toASCII(s string) string {

-	if isASCII(s) {

-		return s

-	}

-	var buf bytes.Buffer

-	for _, c := range s {

-		if c < 0x80 {

-			buf.WriteByte(byte(c))

-		}

-	}

-	return buf.String()

-}

-

-// isHeaderOnlyType checks if the given type flag is of the type that has no

-// data section even if a size is specified.

-func isHeaderOnlyType(flag byte) bool {

-	switch flag {

-	case TypeLink, TypeSymlink, TypeChar, TypeBlock, TypeDir, TypeFifo:

-		return true

-	default:

-		return false

-	}

-}

deleted file mode 100644

@@ -1,1002 +0,0 @@

-// 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

-

-// TODO(dsymonds):

-//   - pax extensions

-

-import (

-	"bytes"

-	"errors"

-	"io"

-	"io/ioutil"

-	"math"

-	"os"

-	"strconv"

-	"strings"

-	"time"

-)

-

-var (

-	ErrHeader = errors.New("archive/tar: invalid tar header")

-)

-

-const maxNanoSecondIntSize = 9

-

-// A Reader provides sequential access to the contents of a tar archive.

-// A tar archive consists of a sequence of files.

-// The Next method advances to the next file in the archive (including the first),

-// and then it can be treated as an io.Reader to access the file's data.

-type Reader struct {

-	r       io.Reader

-	err     error

-	pad     int64           // amount of padding (ignored) after current file entry

-	curr    numBytesReader  // reader for current file entry

-	hdrBuff [blockSize]byte // buffer to use in readHeader

-}

-

-type parser struct {

-	err error // Last error seen

-}

-

-// A numBytesReader is an io.Reader with a numBytes method, returning the number

-// of bytes remaining in the underlying encoded data.

-type numBytesReader interface {

-	io.Reader

-	numBytes() int64

-}

-

-// A regFileReader is a numBytesReader for reading file data from a tar archive.

-type regFileReader struct {

-	r  io.Reader // underlying reader

-	nb int64     // number of unread bytes for current file entry

-}

-

-// A sparseFileReader is a numBytesReader for reading sparse file data from a

-// tar archive.

-type sparseFileReader struct {

-	rfr   numBytesReader // Reads the sparse-encoded file data

-	sp    []sparseEntry  // The sparse map for the file

-	pos   int64          // Keeps track of file position

-	total int64          // Total size of the file

-}

-

-// A sparseEntry holds a single entry in a sparse file's sparse map.

-//

-// Sparse files are represented using a series of sparseEntrys.

-// Despite the name, a sparseEntry represents an actual data fragment that

-// references data found in the underlying archive stream. All regions not

-// covered by a sparseEntry are logically filled with zeros.

-//

-// For example, if the underlying raw file contains the 10-byte data:

-//	var compactData = "abcdefgh"

-//

-// And the sparse map has the following entries:

-//	var sp = []sparseEntry{

-//		{offset: 2,  numBytes: 5} // Data fragment for [2..7]

-//		{offset: 18, numBytes: 3} // Data fragment for [18..21]

-//	}

-//

-// Then the content of the resulting sparse file with a "real" size of 25 is:

-//	var sparseData = "\x00"*2 + "abcde" + "\x00"*11 + "fgh" + "\x00"*4

-type sparseEntry struct {

-	offset   int64 // Starting position of the fragment

-	numBytes int64 // Length of the fragment

-}

-

-// Keywords for GNU sparse files in a PAX extended header

-const (

-	paxGNUSparseNumBlocks = "GNU.sparse.numblocks"

-	paxGNUSparseOffset    = "GNU.sparse.offset"

-	paxGNUSparseNumBytes  = "GNU.sparse.numbytes"

-	paxGNUSparseMap       = "GNU.sparse.map"

-	paxGNUSparseName      = "GNU.sparse.name"

-	paxGNUSparseMajor     = "GNU.sparse.major"

-	paxGNUSparseMinor     = "GNU.sparse.minor"

-	paxGNUSparseSize      = "GNU.sparse.size"

-	paxGNUSparseRealSize  = "GNU.sparse.realsize"

-)

-

-// Keywords for old GNU sparse headers

-const (

-	oldGNUSparseMainHeaderOffset               = 386

-	oldGNUSparseMainHeaderIsExtendedOffset     = 482

-	oldGNUSparseMainHeaderNumEntries           = 4

-	oldGNUSparseExtendedHeaderIsExtendedOffset = 504

-	oldGNUSparseExtendedHeaderNumEntries       = 21

-	oldGNUSparseOffsetSize                     = 12

-	oldGNUSparseNumBytesSize                   = 12

-)

-

-// NewReader creates a new Reader reading from r.

-func NewReader(r io.Reader) *Reader { return &Reader{r: r} }

-

-// Next advances to the next entry in the tar archive.

-//

-// io.EOF is returned at the end of the input.

-func (tr *Reader) Next() (*Header, error) {

-	if tr.err != nil {

-		return nil, tr.err

-	}

-

-	var hdr *Header

-	var extHdrs map[string]string

-

-	// Externally, Next iterates through the tar archive as if it is a series of

-	// files. Internally, the tar format often uses fake "files" to add meta

-	// data that describes the next file. These meta data "files" should not

-	// normally be visible to the outside. As such, this loop iterates through

-	// one or more "header files" until it finds a "normal file".

-loop:

-	for {

-		tr.err = tr.skipUnread()

-		if tr.err != nil {

-			return nil, tr.err

-		}

-

-		hdr = tr.readHeader()

-		if tr.err != nil {

-			return nil, tr.err

-		}

-

-		// Check for PAX/GNU special headers and files.

-		switch hdr.Typeflag {

-		case TypeXHeader:

-			extHdrs, tr.err = parsePAX(tr)

-			if tr.err != nil {

-				return nil, tr.err

-			}

-			continue loop // This is a meta header affecting the next header

-		case TypeGNULongName, TypeGNULongLink:

-			var realname []byte

-			realname, tr.err = ioutil.ReadAll(tr)

-			if tr.err != nil {

-				return nil, tr.err

-			}

-

-			// Convert GNU extensions to use PAX headers.

-			if extHdrs == nil {

-				extHdrs = make(map[string]string)

-			}

-			var p parser

-			switch hdr.Typeflag {

-			case TypeGNULongName:

-				extHdrs[paxPath] = p.parseString(realname)

-			case TypeGNULongLink:

-				extHdrs[paxLinkpath] = p.parseString(realname)

-			}

-			if p.err != nil {

-				tr.err = p.err

-				return nil, tr.err

-			}

-			continue loop // This is a meta header affecting the next header

-		default:

-			mergePAX(hdr, extHdrs)

-

-			// Check for a PAX format sparse file

-			sp, err := tr.checkForGNUSparsePAXHeaders(hdr, extHdrs)

-			if err != nil {

-				tr.err = err

-				return nil, err

-			}

-			if sp != nil {

-				// Current file is a PAX format GNU sparse file.

-				// Set the current file reader to a sparse file reader.

-				tr.curr, tr.err = newSparseFileReader(tr.curr, sp, hdr.Size)

-				if tr.err != nil {

-					return nil, tr.err

-				}

-			}

-			break loop // This is a file, so stop

-		}

-	}

-	return hdr, nil

-}

-

-// checkForGNUSparsePAXHeaders checks the PAX headers for GNU sparse headers. If they are found, then

-// this function reads the sparse map and returns it. Unknown sparse formats are ignored, causing the file to

-// be treated as a regular file.

-func (tr *Reader) checkForGNUSparsePAXHeaders(hdr *Header, headers map[string]string) ([]sparseEntry, error) {

-	var sparseFormat string

-

-	// Check for sparse format indicators

-	major, majorOk := headers[paxGNUSparseMajor]

-	minor, minorOk := headers[paxGNUSparseMinor]

-	sparseName, sparseNameOk := headers[paxGNUSparseName]

-	_, sparseMapOk := headers[paxGNUSparseMap]

-	sparseSize, sparseSizeOk := headers[paxGNUSparseSize]

-	sparseRealSize, sparseRealSizeOk := headers[paxGNUSparseRealSize]

-

-	// Identify which, if any, sparse format applies from which PAX headers are set

-	if majorOk && minorOk {

-		sparseFormat = major + "." + minor

-	} else if sparseNameOk && sparseMapOk {

-		sparseFormat = "0.1"

-	} else if sparseSizeOk {

-		sparseFormat = "0.0"

-	} else {

-		// Not a PAX format GNU sparse file.

-		return nil, nil

-	}

-

-	// Check for unknown sparse format

-	if sparseFormat != "0.0" && sparseFormat != "0.1" && sparseFormat != "1.0" {

-		return nil, nil

-	}

-

-	// Update hdr from GNU sparse PAX headers

-	if sparseNameOk {

-		hdr.Name = sparseName

-	}

-	if sparseSizeOk {

-		realSize, err := strconv.ParseInt(sparseSize, 10, 0)

-		if err != nil {

-			return nil, ErrHeader

-		}

-		hdr.Size = realSize

-	} else if sparseRealSizeOk {

-		realSize, err := strconv.ParseInt(sparseRealSize, 10, 0)

-		if err != nil {

-			return nil, ErrHeader

-		}

-		hdr.Size = realSize

-	}

-

-	// Set up the sparse map, according to the particular sparse format in use

-	var sp []sparseEntry

-	var err error

-	switch sparseFormat {

-	case "0.0", "0.1":

-		sp, err = readGNUSparseMap0x1(headers)

-	case "1.0":

-		sp, err = readGNUSparseMap1x0(tr.curr)

-	}

-	return sp, err

-}

-

-// mergePAX merges well known headers according to PAX standard.

-// In general headers with the same name as those found

-// in the header struct overwrite those found in the header

-// struct with higher precision or longer values. Esp. useful

-// for name and linkname fields.

-func mergePAX(hdr *Header, headers map[string]string) error {

-	for k, v := range headers {

-		switch k {

-		case paxPath:

-			hdr.Name = v

-		case paxLinkpath:

-			hdr.Linkname = v

-		case paxGname:

-			hdr.Gname = v

-		case paxUname:

-			hdr.Uname = v

-		case paxUid:

-			uid, err := strconv.ParseInt(v, 10, 0)

-			if err != nil {

-				return err

-			}

-			hdr.Uid = int(uid)

-		case paxGid:

-			gid, err := strconv.ParseInt(v, 10, 0)

-			if err != nil {

-				return err

-			}

-			hdr.Gid = int(gid)

-		case paxAtime:

-			t, err := parsePAXTime(v)

-			if err != nil {

-				return err

-			}

-			hdr.AccessTime = t

-		case paxMtime:

-			t, err := parsePAXTime(v)

-			if err != nil {

-				return err

-			}

-			hdr.ModTime = t

-		case paxCtime:

-			t, err := parsePAXTime(v)

-			if err != nil {

-				return err

-			}

-			hdr.ChangeTime = t

-		case paxCreationTime:

-			t, err := parsePAXTime(v)

-			if err != nil {

-				return err

-			}

-			hdr.CreationTime = t

-		case paxSize:

-			size, err := strconv.ParseInt(v, 10, 0)

-			if err != nil {

-				return err

-			}

-			hdr.Size = int64(size)

-		default:

-			if strings.HasPrefix(k, paxXattr) {

-				if hdr.Xattrs == nil {

-					hdr.Xattrs = make(map[string]string)

-				}

-				hdr.Xattrs[k[len(paxXattr):]] = v

-			} else if strings.HasPrefix(k, paxWindows) {

-				if hdr.Winheaders == nil {

-					hdr.Winheaders = make(map[string]string)

-				}

-				hdr.Winheaders[k[len(paxWindows):]] = v

-			}

-		}

-	}

-	return nil

-}

-

-// parsePAXTime takes a string of the form %d.%d as described in

-// the PAX specification.

-func parsePAXTime(t string) (time.Time, error) {

-	buf := []byte(t)

-	pos := bytes.IndexByte(buf, '.')

-	var seconds, nanoseconds int64

-	var err error

-	if pos == -1 {

-		seconds, err = strconv.ParseInt(t, 10, 0)

-		if err != nil {

-			return time.Time{}, err

-		}

-	} else {

-		seconds, err = strconv.ParseInt(string(buf[:pos]), 10, 0)

-		if err != nil {

-			return time.Time{}, err

-		}

-		nano_buf := string(buf[pos+1:])

-		// Pad as needed before converting to a decimal.

-		// For example .030 -> .030000000 -> 30000000 nanoseconds

-		if len(nano_buf) < maxNanoSecondIntSize {

-			// Right pad

-			nano_buf += strings.Repeat("0", maxNanoSecondIntSize-len(nano_buf))

-		} else if len(nano_buf) > maxNanoSecondIntSize {

-			// Right truncate

-			nano_buf = nano_buf[:maxNanoSecondIntSize]

-		}

-		nanoseconds, err = strconv.ParseInt(string(nano_buf), 10, 0)

-		if err != nil {

-			return time.Time{}, err

-		}

-	}

-	ts := time.Unix(seconds, nanoseconds)

-	return ts, nil

-}

-

-// parsePAX parses PAX headers.

-// If an extended header (type 'x') is invalid, ErrHeader is returned

-func parsePAX(r io.Reader) (map[string]string, error) {

-	buf, err := ioutil.ReadAll(r)

-	if err != nil {

-		return nil, err

-	}

-	sbuf := string(buf)

-

-	// For GNU PAX sparse format 0.0 support.

-	// This function transforms the sparse format 0.0 headers into sparse format 0.1 headers.

-	var sparseMap bytes.Buffer

-

-	headers := make(map[string]string)

-	// Each record is constructed as

-	//     "%d %s=%s\n", length, keyword, value

-	for len(sbuf) > 0 {

-		key, value, residual, err := parsePAXRecord(sbuf)

-		if err != nil {

-			return nil, ErrHeader

-		}

-		sbuf = residual

-

-		keyStr := string(key)

-		if keyStr == paxGNUSparseOffset || keyStr == paxGNUSparseNumBytes {

-			// GNU sparse format 0.0 special key. Write to sparseMap instead of using the headers map.

-			sparseMap.WriteString(value)

-			sparseMap.Write([]byte{','})

-		} else {

-			// Normal key. Set the value in the headers map.

-			headers[keyStr] = string(value)

-		}

-	}

-	if sparseMap.Len() != 0 {

-		// Add sparse info to headers, chopping off the extra comma

-		sparseMap.Truncate(sparseMap.Len() - 1)

-		headers[paxGNUSparseMap] = sparseMap.String()

-	}

-	return headers, nil

-}

-

-// parsePAXRecord parses the input PAX record string into a key-value pair.

-// If parsing is successful, it will slice off the currently read record and

-// return the remainder as r.

-//

-// A PAX record is of the following form:

-//	"%d %s=%s\n" % (size, key, value)

-func parsePAXRecord(s string) (k, v, r string, err error) {

-	// The size field ends at the first space.

-	sp := strings.IndexByte(s, ' ')

-	if sp == -1 {

-		return "", "", s, ErrHeader

-	}

-

-	// Parse the first token as a decimal integer.

-	n, perr := strconv.ParseInt(s[:sp], 10, 0) // Intentionally parse as native int

-	if perr != nil || n < 5 || int64(len(s)) < n {

-		return "", "", s, ErrHeader

-	}

-

-	// Extract everything between the space and the final newline.

-	rec, nl, rem := s[sp+1:n-1], s[n-1:n], s[n:]

-	if nl != "\n" {

-		return "", "", s, ErrHeader

-	}

-

-	// The first equals separates the key from the value.

-	eq := strings.IndexByte(rec, '=')

-	if eq == -1 {

-		return "", "", s, ErrHeader

-	}

-	return rec[:eq], rec[eq+1:], rem, nil

-}

-

-// parseString parses bytes as a NUL-terminated C-style string.

-// If a NUL byte is not found then the whole slice is returned as a string.

-func (*parser) parseString(b []byte) string {

-	n := 0

-	for n < len(b) && b[n] != 0 {

-		n++

-	}

-	return string(b[0:n])

-}

-

-// parseNumeric parses the input as being encoded in either base-256 or octal.

-// This function may return negative numbers.

-// If parsing fails or an integer overflow occurs, err will be set.

-func (p *parser) parseNumeric(b []byte) int64 {

-	// Check for base-256 (binary) format first.

-	// If the first bit is set, then all following bits constitute a two's

-	// complement encoded number in big-endian byte order.

-	if len(b) > 0 && b[0]&0x80 != 0 {

-		// Handling negative numbers relies on the following identity:

-		//	-a-1 == ^a

-		//

-		// If the number is negative, we use an inversion mask to invert the

-		// data bytes and treat the value as an unsigned number.

-		var inv byte // 0x00 if positive or zero, 0xff if negative

-		if b[0]&0x40 != 0 {

-			inv = 0xff

-		}

-

-		var x uint64