tar

Documentation

Overview

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

Index

• Constants
• Variables
• type Header
• type Reader
  • func NewReader(r io.Reader) *Reader
  • func (tr *Reader) Next() (*Header, os.Error)
  • func (tr *Reader) Read(b []byte) (n int, err os.Error)
• type Writer
  • func NewWriter(w io.Writer) *Writer
  • func (tw *Writer) Close() os.Error
  • func (tw *Writer) Flush() os.Error
  • func (tw *Writer) Write(b []byte) (n int, err os.Error)
  • func (tw *Writer) WriteHeader(hdr *Header) os.Error

Constants

const (

	// Types
	TypeReg           = '0'
	TypeRegA          = '\x00'
	TypeLink          = '1'
	TypeSymlink       = '2'
	TypeChar          = '3'
	TypeBlock         = '4'
	TypeDir           = '5'
	TypeFifo          = '6'
	TypeCont          = '7'
	TypeXHeader       = 'x'
	TypeXGlobalHeader = 'g'
)

Variables

var (
	ErrWriteTooLong    = os.NewError("write too long")
	ErrFieldTooLong    = os.NewError("header field too long")
	ErrWriteAfterClose = os.NewError("write after close")
)

var (
	HeaderError = os.NewError("invalid tar header")
)

Types

type Header

type Header struct {
	Name     string
	Mode     int64
	Uid      int
	Gid      int
	Size     int64
	Mtime    int64
	Typeflag byte
	Linkname string
	Uname    string
	Gname    string
	Devmajor int64
	Devminor int64
	Atime    int64
	Ctime    int64
}

A Header represents a single header in a tar archive. Some fields may not be populated.

type Reader

type Reader struct {
	// contains filtered or unexported fields
}

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.

Example:

tr := tar.NewReader(r)
for {
	hdr, err := tr.Next()
	if err == os.EOF {
		// end of tar archive
		break
	}
	if err != nil {
		// handle error
	}
	io.Copy(data, tr)
}

func NewReader

func NewReader(r io.Reader) *Reader

NewReader creates a new Reader reading from r.

func (*Reader) Next

func (tr *Reader) Next() (*Header, os.Error)

Next advances to the next entry in the tar archive.

func (*Reader) Read

func (tr *Reader) Read(b []byte) (n int, err os.Error)

Read reads from the current entry in the tar archive. It returns 0, os.EOF when it reaches the end of that entry, until Next is called to advance to the next entry.

type Writer

type Writer struct {
	// contains filtered or unexported fields
}

A Writer provides sequential writing of a tar archive in POSIX.1 format. A tar archive consists of a sequence of files. Call WriteHeader to begin a new file, and then call Write to supply that file's data, writing at most hdr.Size bytes in total.

Example:

tw := tar.NewWriter(w)
hdr := new(Header)
hdr.Size = length of data in bytes
// populate other hdr fields as desired
if err := tw.WriteHeader(hdr); err != nil {
	// handle error
}
io.Copy(tw, data)
tw.Close()

func NewWriter

func NewWriter(w io.Writer) *Writer

NewWriter creates a new Writer writing to w.

func (*Writer) Close

func (tw *Writer) Close() os.Error

Close closes the tar archive, flushing any unwritten data to the underlying writer.

func (*Writer) Flush

func (tw *Writer) Flush() os.Error

Flush finishes writing the current file (optional).

func (*Writer) Write

func (tw *Writer) Write(b []byte) (n int, err os.Error)

Write writes to the current entry in the tar archive. Write returns the error ErrWriteTooLong if more than hdr.Size bytes are written after WriteHeader.

func (*Writer) WriteHeader

func (tw *Writer) WriteHeader(hdr *Header) os.Error

WriteHeader writes hdr and prepares to accept the file's contents. WriteHeader calls Flush if it is not the first header. Calling after a Close will return ErrWriteAfterClose.