@@ -1,8 +1,8 @@

 package archive

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"compress/bzip2"

 	"compress/gzip"

 	"errors"

@@ -1,8 +1,8 @@

 package archive

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"fmt"

 	"io"

 	"io/ioutil"

@@ -1,7 +1,7 @@

 package archive

 import (

-	"archive/tar"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"fmt"

 	"github.com/dotcloud/docker/utils"

 	"io"

@@ -1,7 +1,7 @@

 package archive

 import (

-	"archive/tar"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"io"

 	"os"

 	"path/filepath"

@@ -1,8 +1,8 @@

 package archive

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"io/ioutil"

 )

@@ -50,3 +50,11 @@ clone git github.com/syndtr/gocapability 3454319be2

 clone hg code.google.com/p/go.net 84a4013f96e0

 clone hg code.google.com/p/gosqlite 74691fb6f837

+

+# get Go tip's archive/tar, for xattr support

+# TODO after Go 1.3 drops, bump our minimum supported version and drop this vendored dep

+clone hg code.google.com/p/go a15f344a9efa

+mv src/code.google.com/p/go/src/pkg/archive/tar tmp-tar

+rm -rf src/code.google.com/p/go

+mkdir -p src/code.google.com/p/go/src/pkg/archive

+mv tmp-tar src/code.google.com/p/go/src/pkg/archive/tar

@@ -1,9 +1,9 @@

 package docker

 import (

-	"archive/tar"

 	"bufio"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"encoding/json"

 	"fmt"

 	"github.com/dotcloud/docker"

@@ -1,8 +1,8 @@

 package docker

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"fmt"

 	"io"

 	"io/ioutil"

@@ -1,8 +1,8 @@

 package utils

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"compress/gzip"

 	"crypto/sha256"

 	"encoding/hex"

@@ -1,8 +1,8 @@

 package docker

 import (

-	"archive/tar"

 	"bytes"

+	"code.google.com/p/go/src/pkg/archive/tar"

 	"io"

 )

new file mode 100644

@@ -0,0 +1,304 @@

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

+)

+

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

+	Xattrs     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 TypeLink, TypeSymlink:

+		// hard link, 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.

+	paxGid      = "gid"

+	paxGname    = "gname"

+	paxLinkpath = "linkpath"

+	paxMtime    = "mtime"

+	paxPath     = "path"

+	paxSize     = "size"

+	paxUid      = "uid"

+	paxUname    = "uname"

+	paxXattr    = "SCHILY.xattr."

+	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 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()

+}

new file mode 100644

@@ -0,0 +1,79 @@

+// Copyright 2013 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_test

+

+import (

+	"archive/tar"

+	"bytes"

+	"fmt"

+	"io"

+	"log"

+	"os"

+)

+

+func Example() {

+	// Create a buffer to write our archive to.

+	buf := new(bytes.Buffer)

+

+	// Create a new tar archive.

+	tw := tar.NewWriter(buf)

+

+	// Add some files to the archive.

+	var files = []struct {

+		Name, Body string

+	}{

+		{"readme.txt", "This archive contains some text files."},

+		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},

+		{"todo.txt", "Get animal handling licence."},

+	}

+	for _, file := range files {

+		hdr := &tar.Header{

+			Name: file.Name,

+			Size: int64(len(file.Body)),

+		}

+		if err := tw.WriteHeader(hdr); err != nil {

+			log.Fatalln(err)

+		}

+		if _, err := tw.Write([]byte(file.Body)); err != nil {

+			log.Fatalln(err)

+		}

+	}

+	// Make sure to check the error on Close.

+	if err := tw.Close(); err != nil {

+		log.Fatalln(err)

+	}

+

+	// Open the tar archive for reading.

+	r := bytes.NewReader(buf.Bytes())

+	tr := tar.NewReader(r)

+

+	// Iterate through the files in the archive.

+	for {

+		hdr, err := tr.Next()

+		if err == io.EOF {

+			// end of tar archive

+			break

+		}

+		if err != nil {

+			log.Fatalln(err)

+		}

+		fmt.Printf("Contents of %s:\n", hdr.Name)

+		if _, err := io.Copy(os.Stdout, tr); err != nil {

+			log.Fatalln(err)

+		}

+		fmt.Println()

+	}

+

+	// Output:

+	// Contents of readme.txt:

+	// This archive contains some text files.

+	// Contents of gopher.txt:

+	// Gopher names:

+	// George

+	// Geoffrey

+	// Gonzo

+	// Contents of todo.txt:

+	// Get animal handling licence.

+}

new file mode 100644

@@ -0,0 +1,402 @@

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

+	"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

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

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

+}

+

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

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

+	var hdr *Header

+	if tr.err == nil {

+		tr.skipUnread()

+	}

+	if tr.err != nil {

+		return hdr, tr.err

+	}

+	hdr = tr.readHeader()

+	if hdr == nil {

+		return hdr, tr.err

+	}

+	// Check for PAX/GNU header.

+	switch hdr.Typeflag {

+	case TypeXHeader:

+		//  PAX extended header

+		headers, err := parsePAX(tr)

+		if err != nil {

+			return nil, err

+		}

+		// We actually read the whole file,

+		// but this skips alignment padding

+		tr.skipUnread()

+		hdr = tr.readHeader()

+		mergePAX(hdr, headers)

+		return hdr, nil

+	case TypeGNULongName:

+		// We have a GNU long name header. Its contents are the real file name.

+		realname, err := ioutil.ReadAll(tr)

+		if err != nil {

+			return nil, err

+		}

+		hdr, err := tr.Next()

+		hdr.Name = cString(realname)

+		return hdr, err

+	case TypeGNULongLink:

+		// We have a GNU long link header.

+		realname, err := ioutil.ReadAll(tr)

+		if err != nil {

+			return nil, err

+		}

+		hdr, err := tr.Next()

+		hdr.Linkname = cString(realname)

+		return hdr, err

+	}

+	return hdr, tr.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 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

+			}

+		}

+	}

+	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

+	}

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

+	// Each record is constructed as

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

+	for len(buf) > 0 {

+		// or the header was empty to start with.

+		var sp int

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

+		sp = bytes.IndexByte(buf, ' ')

+		if sp == -1 {

+			return nil, ErrHeader

+		}

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

+		n, err := strconv.ParseInt(string(buf[:sp]), 10, 0)

+		if err != nil {

+			return nil, ErrHeader

+		}

+		// Extract everything between the decimal and the n -1 on the

+		// beginning to to eat the ' ', -1 on the end to skip the newline.

+		var record []byte

+		record, buf = buf[sp+1:n-1], buf[n:]

+		// The first equals is guaranteed to mark the end of the key.

+		// Everything else is value.

+		eq := bytes.IndexByte(record, '=')

+		if eq == -1 {

+			return nil, ErrHeader

+		}

+		key, value := record[:eq], record[eq+1:]

+		headers[string(key)] = string(value)

+	}

+	return headers, nil

+}

+

+// cString 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 cString(b []byte) string {

+	n := 0

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

+		n++

+	}

+	return string(b[0:n])

+}

+

+func (tr *Reader) octal(b []byte) int64 {

+	// Check for binary format first.

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

+		var x int64

+		for i, c := range b {

+			if i == 0 {

+				c &= 0x7f // ignore signal bit in first byte

+			}

+			x = x<<8 | int64(c)

+		}

+		return x

+	}

+

+	// Because unused fields are filled with NULs, we need

+	// to skip leading NULs. Fields may also be padded with

+	// spaces or NULs.

+	// So we remove leading and trailing NULs and spaces to

+	// be sure.

+	b = bytes.Trim(b, " \x00")

+

+	if len(b) == 0 {

+		return 0

+	}

+	x, err := strconv.ParseUint(cString(b), 8, 64)

+	if err != nil {

+		tr.err = err

+	}

+	return int64(x)

+}

+

+// skipUnread skips any unread bytes in the existing file entry, as well as any alignment padding.

+func (tr *Reader) skipUnread() {

+	nr := tr.nb + tr.pad // number of bytes to skip

+	tr.nb, tr.pad = 0, 0

+	if sr, ok := tr.r.(io.Seeker); ok {

+		if _, err := sr.Seek(nr, os.SEEK_CUR); err == nil {

+			return

+		}

+	}

+	_, tr.err = io.CopyN(ioutil.Discard, tr.r, nr)

+}

+

+func (tr *Reader) verifyChecksum(header []byte) bool {

+	if tr.err != nil {

+		return false

+	}

+

+	given := tr.octal(header[148:156])

+	unsigned, signed := checksum(header)

+	return given == unsigned || given == signed

+}

+

+func (tr *Reader) readHeader() *Header {

+	header := make([]byte, blockSize)

+	if _, tr.err = io.ReadFull(tr.r, header); tr.err != nil {

+		return nil

+	}

+

+	// Two blocks of zero bytes marks the end of the archive.

+	if bytes.Equal(header, zeroBlock[0:blockSize]) {

+		if _, tr.err = io.ReadFull(tr.r, header); tr.err != nil {

+			return nil

+		}

+		if bytes.Equal(header, zeroBlock[0:blockSize]) {

+			tr.err = io.EOF

+		} else {

+			tr.err = ErrHeader // zero block and then non-zero block

+		}

+		return nil

+	}

+

+	if !tr.verifyChecksum(header) {

+		tr.err = ErrHeader

+		return nil

+	}

+

+	// Unpack

+	hdr := new(Header)

+	s := slicer(header)

+

+	hdr.Name = cString(s.next(100))

+	hdr.Mode = tr.octal(s.next(8))

+	hdr.Uid = int(tr.octal(s.next(8)))

+	hdr.Gid = int(tr.octal(s.next(8)))

+	hdr.Size = tr.octal(s.next(12))

+	hdr.ModTime = time.Unix(tr.octal(s.next(12)), 0)

+	s.next(8) // chksum

+	hdr.Typeflag = s.next(1)[0]

+	hdr.Linkname = cString(s.next(100))

+

+	// The remainder of the header depends on the value of magic.

+	// The original (v7) version of tar had no explicit magic field,

+	// so its magic bytes, like the rest of the block, are NULs.

+	magic := string(s.next(8)) // contains version field as well.

+	var format string

+	switch magic {

+	case "ustar\x0000": // POSIX tar (1003.1-1988)

+		if string(header[508:512]) == "tar\x00" {

+			format = "star"

+		} else {

+			format = "posix"

+		}

+	case "ustar  \x00": // old GNU tar

+		format = "gnu"

+	}

+

+	switch format {

+	case "posix", "gnu", "star":

+		hdr.Uname = cString(s.next(32))

+		hdr.Gname = cString(s.next(32))

+		devmajor := s.next(8)

+		devminor := s.next(8)

+		if hdr.Typeflag == TypeChar || hdr.Typeflag == TypeBlock {

+			hdr.Devmajor = tr.octal(devmajor)

+			hdr.Devminor = tr.octal(devminor)

+		}

+		var prefix string

+		switch format {

+		case "posix", "gnu":

+			prefix = cString(s.next(155))

+		case "star":

+			prefix = cString(s.next(131))

+			hdr.AccessTime = time.Unix(tr.octal(s.next(12)), 0)

+			hdr.ChangeTime = time.Unix(tr.octal(s.next(12)), 0)

+		}

+		if len(prefix) > 0 {

+			hdr.Name = prefix + "/" + hdr.Name

+		}

+	}