pxar

type ACLDefault ¶

type ACLDefault struct {
	UserObjPermissions  uint64
	GroupObjPermissions uint64
	OtherPermissions    uint64
	MaskPermissions     uint64 // ACLNoMask when no mask entry exists
}

ACLDefault is the body of a TypeACLDefault record.

type ACLGroup ¶

type ACLGroup struct {
	GID         uint64
	Permissions uint64
}

ACLGroup is the body of TypeACLGroup and TypeACLDefaultGroup records.

type ACLUser ¶

type ACLUser struct {
	UID         uint64
	Permissions uint64
}

ACLUser is the body of TypeACLUser and TypeACLDefaultUser records.

type ACLs ¶ added in v0.4.0

type ACLs struct {
	Users    []ACLUser  // named users (access ACL)
	Groups   []ACLGroup // named groups (access ACL)
	GroupObj *uint64    // owning-group permissions; set only when a mask entry exists

	Default       *ACLDefault // default ACL object permissions (directories)
	DefaultUsers  []ACLUser
	DefaultGroups []ACLGroup
}

ACLs holds a node's POSIX ACL entries in encoder-ready form. A nil *ACLs means the node has no ACL records (a trivial ACL that only mirrors the mode bits does not count).

type Device ¶

type Device struct {
	Major uint64
	Minor uint64
}

Device is the body of a TypeDevice record.

type Entry ¶

type Entry struct {
	Mode       uint64 // full st_mode: type bits + permission bits
	Flags      uint64
	UID        uint32
	GID        uint32
	MtimeSecs  int64  // seconds since epoch (may be negative)
	MtimeNanos uint32 // nanoseconds within MtimeSecs
}

Entry is the stat record body (TypeEntry).

type FS ¶ added in v0.4.0

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

FS is a read-only, random-access view of an archive as an io/fs file system. It implements fs.FS, fs.ReadDirFS, fs.StatFS and fs.ReadLinkFS.

Paths are looked up through the directories' goodbye tables, so only the records on the way are read: over a remote index (see pbs OpenDynamicIndexAt) a lookup fetches a handful of chunks, not the archive. Listing a v2 directory reads the metadata stream only; payload records are checked when a file is opened.

Open and Stat follow symbolic links inside the archive; links with an absolute target, or a relative one leaving the archive, do not resolve. A hardlink resolves to the entry it links to, under its own name. FileInfo.Sys returns the *Node with the full metadata.

The file system is safe for concurrent use if its io.ReaderAt sources are.

func OpenV1(r io.ReaderAt, size int64) (*FS, error)

func OpenV2(meta io.ReaderAt, metaSize int64, payload io.ReaderAt) (*FS, error)

func (f *FS) Lstat(name string) (fs.FileInfo, error)

func (f *FS) Open(name string) (fs.File, error)

func (f *FS) ReadDir(name string) ([]fs.DirEntry, error)

func (f *FS) ReadLink(name string) (string, error)

func (f *FS) Stat(name string) (fs.FileInfo, error)

type GoodbyeItem ¶

type GoodbyeItem struct {
	Hash   uint64 // Hash(basename)
	Start  uint64
	Length uint64
}

GoodbyeItem describes one directory child for goodbye-table construction. Start and Length are in stream coordinates: Start is the absolute offset of the child's TypeFilename record, Length the child's total encoded length (filename record through goodbye table or payload, inclusive).

type MetaFile ¶ added in v0.3.0

type MetaFile struct {
	// Path is the archive-relative path ("" for the root, "dir/name" below it).
	Path string
	// Meta is the file's ENTRY record followed by its metadata records
	// (xattrs, ACLs, fcaps, quota project id), byte for byte as encoded.
	Meta []byte
	// Size is the content byte count.
	Size uint64
	// PayloadOffset is the position of the file's payload record header in
	// the payload stream (v2 only; 0 in a v1 archive).
	PayloadOffset uint64
}

MetaFile is one regular file found while decoding a pxar metadata stream.

type Node ¶ added in v0.4.0

type Node struct {
	// Path is the archive-relative path ("" for the root, "dir/name" below it).
	Path string
	// Entry is the stat record. It is zero for a hardlink, which carries no
	// metadata of its own.
	Entry

	// Hardlink marks a hardlink to an earlier entry of the archive.
	Hardlink bool
	// LinkTarget holds the symlink target, or for a hardlink the
	// archive-relative path of the entry it links to.
	LinkTarget string

	Xattrs      []Xattr
	ACL         *ACLs
	FCaps       []byte
	QuotaProjID uint64 // 0 = none
	Device      Device // block and char devices

	// Size is the content byte count of a regular file; Reader.Read returns
	// exactly that many bytes.
	Size uint64
	// PayloadOffset is the position of the file's payload record header in
	// the payload stream (v2 only).
	PayloadOffset uint64
	// contains filtered or unexported fields
}

Node is one archive entry as decoded by Reader.

type Reader ¶ added in v0.4.0

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

Reader reads a pxar archive entry by entry, in archive order, like archive/tar: Next advances to the next entry, Read returns the content of the current regular file. Unread content is skipped by Next.

Every entry is validated as it is decoded: filenames and hardlink targets must be plain relative names, records must have their exact sizes, and a stream must end exactly after the root directory's goodbye table.

func NewReaderV1(r io.Reader) *Reader

func NewReaderV2(meta io.Reader, payload io.ReaderAt) *Reader

func (r *Reader) Next() (*Node, error)

func (r *Reader) Read(p []byte) (int, error)

type Xattr ¶ added in v0.4.0

type Xattr struct {
	Name  string
	Value []byte
}

Xattr is one extended attribute. Values may contain arbitrary bytes.