type Writer … // NewWriter creates a new Writer writing to w. func NewWriter(w io.Writer) *Writer { … } type fileWriter … // Flush finishes writing the current file's block padding. // The current file must be fully written before Flush can be called. // // This is unnecessary as the next call to [Writer.WriteHeader] or [Writer.Close] // will implicitly flush out the file's padding. func (tw *Writer) Flush() error { … } // WriteHeader writes hdr and prepares to accept the file's contents. // The Header.Size determines how many bytes can be written for the next file. // If the current file is not fully written, then this returns an error. // This implicitly flushes any padding necessary before writing the header. func (tw *Writer) WriteHeader(hdr *Header) error { … } func (tw *Writer) writeUSTARHeader(hdr *Header) error { … } func (tw *Writer) writePAXHeader(hdr *Header, paxHdrs map[string]string) error { … } func (tw *Writer) writeGNUHeader(hdr *Header) error { … } type stringFormatter … type numberFormatter … // templateV7Plus fills out the V7 fields of a block using values from hdr. // It also fills out fields (uname, gname, devmajor, devminor) that are // shared in the USTAR, PAX, and GNU formats using the provided formatters. // // The block returned is only valid until the next call to // templateV7Plus or writeRawFile. func (tw *Writer) templateV7Plus(hdr *Header, fmtStr stringFormatter, fmtNum numberFormatter) *block { … } // writeRawFile writes a minimal file with the given name and flag type. // It uses format to encode the header format and will write data as the body. // It uses default values for all of the other fields (as BSD and GNU tar does). func (tw *Writer) writeRawFile(name, data string, flag byte, format Format) error { … } // writeRawHeader writes the value of blk, regardless of its value. // It sets up the Writer such that it can accept a file of the given size. // If the flag is a special header-only flag, then the size is treated as zero. func (tw *Writer) writeRawHeader(blk *block, size int64, flag byte) error { … } // AddFS adds the files from fs.FS to the archive. // It walks the directory tree starting at the root of the filesystem // adding each file to the tar archive while maintaining the directory structure. func (tw *Writer) AddFS(fsys fs.FS) error { … } // splitUSTARPath splits a path according to USTAR prefix and suffix rules. // If the path is not splittable, then it will return ("", "", false). func splitUSTARPath(name string) (prefix, suffix string, ok bool) { … } // Write writes to the current file in the tar archive. // Write returns the error [ErrWriteTooLong] if more than // Header.Size bytes are written after [Writer.WriteHeader]. // // Calling Write on special types like [TypeLink], [TypeSymlink], [TypeChar], // [TypeBlock], [TypeDir], and [TypeFifo] returns (0, [ErrWriteTooLong]) regardless // of what the [Header.Size] claims. func (tw *Writer) Write(b []byte) (int, error) { … } // readFrom populates the content of the current file by reading from r. // The bytes read must match the number of remaining bytes in the current file. // // If the current file is sparse and r is an io.ReadSeeker, // then readFrom uses Seek to skip past holes defined in Header.SparseHoles, // assuming that skipped regions are all NULs. // This always reads the last byte to ensure r is the right size. // // TODO(dsnet): Re-export this when adding sparse file support. // See https://golang.org/issue/22735 func (tw *Writer) readFrom(r io.Reader) (int64, error) { … } // Close closes the tar archive by flushing the padding, and writing the footer. // If the current file (from a prior call to [Writer.WriteHeader]) is not fully written, // then this returns an error. func (tw *Writer) Close() error { … } type regFileWriter … func (fw *regFileWriter) Write(b []byte) (n int, err error) { … } func (fw *regFileWriter) ReadFrom(r io.Reader) (int64, error) { … } // logicalRemaining implements fileState.logicalRemaining. func (fw regFileWriter) logicalRemaining() int64 { … } // physicalRemaining implements fileState.physicalRemaining. func (fw regFileWriter) physicalRemaining() int64 { … } type sparseFileWriter … func (sw *sparseFileWriter) Write(b []byte) (n int, err error) { … } func (sw *sparseFileWriter) ReadFrom(r io.Reader) (n int64, err error) { … } func (sw sparseFileWriter) logicalRemaining() int64 { … } func (sw sparseFileWriter) physicalRemaining() int64 { … } type zeroWriter … func (zeroWriter) Write(b []byte) (int, error) { … } // ensureEOF checks whether r is at EOF, reporting ErrWriteTooLong if not so. func ensureEOF(r io.Reader) error { … }
Codebase Browser
go