libgo/go/archive/tar/reader.go - chromiumos/third_party/gcc - Git at Google

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

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

 	if tr.err != nil {
 		tr.err = ErrHeader
 		return nil
 	}

 	// Maximum value of hdr.Size is 64 GB (12 octal digits),
 	// so there's no risk of int64 overflowing.
 	tr.nb = int64(hdr.Size)
 	tr.pad = -tr.nb & (blockSize - 1) // blockSize is a power of two

 	return hdr
 }

 // Read reads from the current entry in the tar archive.
 // It returns 0, io.EOF when it reaches the end of that entry,
 // until Next is called to advance to the next entry.
 func (tr *Reader) Read(b []byte) (n int, err error) {
 	if tr.nb == 0 {
 		// file consumed
 		return 0, io.EOF
 	}

 	if int64(len(b)) > tr.nb {
 		b = b[0:tr.nb]
 	}
 	n, err = tr.r.Read(b)
 	tr.nb -= int64(n)

 	if err == io.EOF && tr.nb > 0 {
 		err = io.ErrUnexpectedEOF
 	}
 	tr.err = err
 	return
 }
	// 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)
	}

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

	if tr.err != nil {
	tr.err = ErrHeader
	return nil
	}

	// Maximum value of hdr.Size is 64 GB (12 octal digits),
	// so there's no risk of int64 overflowing.
	tr.nb = int64(hdr.Size)
	tr.pad = -tr.nb & (blockSize - 1) // blockSize is a power of two

	return hdr
	}

	// Read reads from the current entry in the tar archive.
	// It returns 0, io.EOF when it reaches the end of that entry,
	// until Next is called to advance to the next entry.
	func (tr *Reader) Read(b []byte) (n int, err error) {
	if tr.nb == 0 {
	// file consumed
	return 0, io.EOF
	}

	if int64(len(b)) > tr.nb {
	b = b[0:tr.nb]
	}
	n, err = tr.r.Read(b)
	tr.nb -= int64(n)

	if err == io.EOF && tr.nb > 0 {
	err = io.ErrUnexpectedEOF
	}
	tr.err = err
	return
	}