package tar

Import Path
	archive/tar (on golang.org and go.dev)

Dependency Relation
	imports 17 packages, and imported by 0 packages

Involved Source Files
	d-> common.go
	    format.go
	    reader.go
	    stat_actime1.go
	    stat_unix.go
	    strconv.go
	    writer.go

Exported Type Names

type Format int Format represents the tar archive format. The original tar format was introduced in Unix V7. Since then, there have been multiple competing formats attempting to standardize or extend the V7 format to overcome its limitations. The most common formats are the USTAR, PAX, and GNU formats, each with their own advantages and limitations. The following table captures the capabilities of each format: | USTAR | PAX | GNU ------------------+--------+-----------+---------- Name | 256B | unlimited | unlimited Linkname | 100B | unlimited | unlimited Size | uint33 | unlimited | uint89 Mode | uint21 | uint21 | uint57 Uid/Gid | uint21 | unlimited | uint57 Uname/Gname | 32B | unlimited | 32B ModTime | uint33 | unlimited | int89 AccessTime | n/a | unlimited | int89 ChangeTime | n/a | unlimited | int89 Devmajor/Devminor | uint21 | uint21 | uint57 ------------------+--------+-----------+---------- string encoding | ASCII | UTF-8 | binary sub-second times | no | yes | no sparse files | no | yes | yes The table's upper portion shows the Header fields, where each format reports the maximum number of bytes allowed for each string field and the integer type used to store each numeric field (where timestamps are stored as the number of seconds since the Unix epoch). The table's lower portion shows specialized features of each format, such as supported string encodings, support for sub-second timestamps, or support for sparse files. The Writer currently provides no support for sparse files. (T) String() string T : expvar.Var T : fmt.Stringer const FormatGNU const FormatPAX const FormatUnknown const FormatUSTAR
type Header (struct) A Header represents a single header in a tar archive. Some fields may not be populated. For forward compatibility, users that retrieve a Header from Reader.Next, mutate it in some ways, and then pass it back to Writer.WriteHeader should do so by creating a new Header and copying the fields that they are interested in preserving. AccessTime time.Time ChangeTime time.Time Devmajor int64 Devminor int64 Format Format Gid int Gname string Linkname string ModTime time.Time Mode int64 Name string PAXRecords map[string]string Size int64 Typeflag byte Uid int Uname string Xattrs map[string]string (*T) FileInfo() os.FileInfo func FileInfoHeader(fi os.FileInfo, link string) (*Header, error) func (*Reader).Next() (*Header, error) func (*Writer).WriteHeader(hdr *Header) error
type Reader (struct) Reader provides sequential access to the contents of a tar archive. Reader.Next advances to the next file in the archive (including the first), and then Reader can be treated as an io.Reader to access the file's data. (*T) Next() (*Header, error) (*T) Read(b []byte) (int, error) *T : io.Reader func NewReader(r io.Reader) *Reader
type Writer (struct) Writer provides sequential writing of a tar archive. Write.WriteHeader begins a new file with the provided Header, and then Writer can be treated as an io.Writer to supply that file's data. (*T) Close() error (*T) Flush() error (*T) Write(b []byte) (int, error) (*T) WriteHeader(hdr *Header) error *T : io.Closer *T : io.WriteCloser *T : io.Writer func NewWriter(w io.Writer) *Writer
Exported Values
func FileInfoHeader(fi os.FileInfo, link string) (*Header, error) 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. Since os.FileInfo's Name method only returns the base name of the file it describes, it may be necessary to modify Header.Name to provide the full path name of the file.
const FormatGNU Format = 8 FormatGNU represents the GNU header format. The GNU header format is older than the USTAR and PAX standards and is not compatible with them. The GNU format supports arbitrary file sizes, filenames of arbitrary encoding and length, sparse files, and other features. It is recommended that PAX be chosen over GNU unless the target application can only parse GNU formatted archives. Reference: https://www.gnu.org/software/tar/manual/html_node/Standard.html
const FormatPAX Format = 4 FormatPAX represents the PAX header format defined in POSIX.1-2001. PAX extends USTAR by writing a special file with Typeflag TypeXHeader preceding the original header. This file contains a set of key-value records, which are used to overcome USTAR's shortcomings, in addition to providing the ability to have sub-second resolution for timestamps. Some newer formats add their own extensions to PAX by defining their own keys and assigning certain semantic meaning to the associated values. For example, sparse file support in PAX is implemented using keys defined by the GNU manual (e.g., "GNU.sparse.map"). Reference: http://pubs.opengroup.org/onlinepubs/009695399/utilities/pax.html
const FormatUnknown Format = 0 FormatUnknown indicates that the format is unknown.
const FormatUSTAR Format = 2 FormatUSTAR represents the USTAR header format defined in POSIX.1-1988. While this format is compatible with most tar readers, the format has several limitations making it unsuitable for some usages. Most notably, it cannot support sparse files, files larger than 8GiB, filenames larger than 256 characters, and non-ASCII filenames. Reference: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_06
func NewReader(r io.Reader) *Reader NewReader creates a new Reader reading from r.
func NewWriter(w io.Writer) *Writer NewWriter creates a new Writer writing to w.
const TypeBlock = 52 // Block device node Type flags for Header.Typeflag.
const TypeChar = 51 // Character device node Type flags for Header.Typeflag.
const TypeCont = 55 Type '7' is reserved.
const TypeDir = 53 // Directory Type flags for Header.Typeflag.
const TypeFifo = 54 // FIFO node Type flags for Header.Typeflag.
const TypeGNULongName = 76 Types 'L' and 'K' are used by the GNU format for a meta file used to store the path or link name for the next file. This package transparently handles these types.
const TypeGNUSparse = 83 Type 'S' indicates a sparse file in the GNU format.
const TypeReg = 48 Type '0' indicates a regular file.
const TypeRegA = 0 // Deprecated: Use TypeReg instead. Type flags for Header.Typeflag.
const TypeXGlobalHeader = 103 Type 'g' is used by the PAX format to store key-value records that are relevant to all subsequent files. This package only supports parsing and composing such headers, but does not currently support persisting the global state across files.
const TypeXHeader = 120 Type 'x' is used by the PAX format to store key-value records that are only relevant to the next file. This package transparently handles these types.