Documentation ¶
Overview ¶
Package p9 is a 9P2000.L implementation.
Index ¶
- Constants
- Variables
- func HighestVersionString() string
- func StatToAttr(s *syscall.Stat_t, req AttrMask) (Attr, AttrMask)
- func VersionSupportsAnonymous(v uint32) bool
- func VersionSupportsConnect(v uint32) bool
- func VersionSupportsMultiUser(v uint32) bool
- func VersionSupportsTflushf(v uint32) bool
- type Attacher
- type Attr
- type AttrMask
- type Client
- type ConnectFlags
- type DefaultWalkGetAttr
- type Dirent
- type ErrBadResponse
- type ErrInvalidMsgType
- type ErrMessageTooLarge
- type ErrSocket
- type FID
- type FSStat
- type File
- type FileMode
- func (m FileMode) FileType() FileMode
- func (m FileMode) IsBlockDevice() bool
- func (m FileMode) IsCharacterDevice() bool
- func (m FileMode) IsDir() bool
- func (m FileMode) IsExecutable() bool
- func (m FileMode) IsNamedPipe() bool
- func (m FileMode) IsReadable() bool
- func (m FileMode) IsRegular() bool
- func (m FileMode) IsSocket() bool
- func (m FileMode) IsSymlink() bool
- func (m FileMode) IsWritable() bool
- func (m FileMode) OSMode() os.FileMode
- func (m FileMode) Permissions() FileMode
- func (m FileMode) QIDType() QIDType
- func (m FileMode) Writable() FileMode
- type GID
- type MsgType
- type OpenFlags
- type QID
- type QIDGenerator
- type QIDType
- type Rattach
- type Rauth
- type Rclunk
- type ReadWriterFile
- type Rflush
- type Rflushf
- type Rfsync
- type Rgetattr
- type Rlconnect
- type Rlcreate
- type Rlerror
- type Rlink
- type Rlopen
- type Rmkdir
- type Rmknod
- type Rread
- type Rreaddir
- type Rreadlink
- type Rremove
- type Rrename
- type Rrenameat
- type Rsetattr
- type Rstatfs
- type Rsymlink
- type Rucreate
- type Rumkdir
- type Rumknod
- type Runlinkat
- type Rusymlink
- type Rversion
- type Rwalk
- type Rwalkgetattr
- type Rwrite
- type Rxattrcreate
- type Rxattrwalk
- type Server
- type SetAttr
- type SetAttrMask
- type Tag
- type Tattach
- type Tauth
- type Tclunk
- type Tflush
- type Tflushf
- type Tfsync
- type Tgetattr
- type Tlconnect
- type Tlcreate
- type Tlink
- type Tlopen
- type Tmkdir
- type Tmknod
- type Tread
- type Treaddir
- type Treadlink
- type Tremove
- type Trename
- type Trenameat
- type Tsetattr
- type Tstatfs
- type Tsymlink
- type Tucreate
- type Tumkdir
- type Tumknod
- type Tunlinkat
- type Tusymlink
- type Tversion
- type Twalk
- type Twalkgetattr
- type Twrite
- type Txattrcreate
- type Txattrwalk
- type UID
Constants ¶
const ( // NoTag is a sentinel used to indicate no valid tag. NoTag Tag = math.MaxUint16 // NoFID is a sentinel used to indicate no valid FID. NoFID FID = math.MaxUint32 // NoUID is a sentinel used to indicate no valid UID. NoUID UID = math.MaxUint32 // NoGID is a sentinel used to indicate no valid GID. NoGID GID = math.MaxUint32 )
const ( MsgTlerror MsgType = 6 MsgRlerror = 7 MsgTstatfs = 8 MsgRstatfs = 9 MsgTlopen = 12 MsgRlopen = 13 MsgTlcreate = 14 MsgRlcreate = 15 MsgTsymlink = 16 MsgRsymlink = 17 MsgTmknod = 18 MsgRmknod = 19 MsgTrename = 20 MsgRrename = 21 MsgTreadlink = 22 MsgRreadlink = 23 MsgTgetattr = 24 MsgRgetattr = 25 MsgTsetattr = 26 MsgRsetattr = 27 MsgTxattrwalk = 30 MsgRxattrwalk = 31 MsgTxattrcreate = 32 MsgRxattrcreate = 33 MsgTreaddir = 40 MsgRreaddir = 41 MsgTfsync = 50 MsgRfsync = 51 MsgTlink = 70 MsgRlink = 71 MsgTmkdir = 72 MsgRmkdir = 73 MsgTrenameat = 74 MsgRrenameat = 75 MsgTunlinkat = 76 MsgRunlinkat = 77 MsgTversion = 100 MsgRversion = 101 MsgTauth = 102 MsgRauth = 103 MsgTattach = 104 MsgRattach = 105 MsgTflush = 108 MsgRflush = 109 MsgTwalk = 110 MsgRwalk = 111 MsgTread = 116 MsgRread = 117 MsgTwrite = 118 MsgRwrite = 119 MsgTclunk = 120 MsgRclunk = 121 MsgTremove = 122 MsgRremove = 123 MsgTflushf = 124 MsgRflushf = 125 MsgTwalkgetattr = 126 MsgRwalkgetattr = 127 MsgTucreate = 128 MsgRucreate = 129 MsgTumkdir = 130 MsgRumkdir = 131 MsgTumknod = 132 MsgRumknod = 133 MsgTusymlink = 134 MsgRusymlink = 135 MsgTlconnect = 136 MsgRlconnect = 137 )
MsgType declarations.
Variables ¶
var ErrBadVersionString = errors.New("bad version string")
ErrBadVersionString indicates that the version string is malformed or unsupported.
var ErrNoValidMessage = errors.New("buffer contained no valid message")
ErrNoValidMessage indicates no valid message could be decoded.
var ErrOutOfFIDs = errors.New("out of FIDs -- messages lost?")
ErrOutOfFIDs indicates no more FIDs are available.
var ErrOutOfTags = errors.New("out of tags -- messages lost?")
ErrOutOfTags indicates no tags are available.
var ErrUnexpectedTag = errors.New("unexpected tag in response")
ErrUnexpectedTag indicates a response with an unexpected tag was received.
var ErrVersionsExhausted = errors.New("exhausted all versions to negotiate")
ErrVersionsExhausted indicates that all versions to negotiate have been exhausted.
Functions ¶
func HighestVersionString ¶
func HighestVersionString() string
HighestVersionString returns the highest possible version string that a client may request or a server may support.
func StatToAttr ¶
StatToAttr converts a Linux syscall stat structure to an Attr.
func VersionSupportsAnonymous ¶
VersionSupportsAnonymous returns true if version v supports Tlconnect with the AnonymousSocket mode. This predicate must be checked by clients before attempting to use the AnonymousSocket Tlconnect mode.
func VersionSupportsConnect ¶
VersionSupportsConnect returns true if version v supports the Tlconnect message. This predicate must be checked by clients before attempting to make a Tlconnect request. If Tlconnect messages are not supported, Tlopen should be used.
func VersionSupportsMultiUser ¶
VersionSupportsMultiUser returns true if version v supports multi-user fake directory permissions and ID values.
func VersionSupportsTflushf ¶
VersionSupportsTflushf returns true if version v supports the Tflushf message. This predicate must be checked by clients before attempting to make a Tflushf request. If this predicate returns false, then clients may safely no-op.
Types ¶
type Attr ¶
type Attr struct { Mode FileMode UID UID GID GID NLink uint64 RDev uint64 Size uint64 BlockSize uint64 Blocks uint64 ATimeSeconds uint64 ATimeNanoSeconds uint64 MTimeSeconds uint64 MTimeNanoSeconds uint64 CTimeSeconds uint64 CTimeNanoSeconds uint64 BTimeSeconds uint64 BTimeNanoSeconds uint64 Gen uint64 DataVersion uint64 }
Attr is a set of attributes for getattr.
type AttrMask ¶
type AttrMask struct { Mode bool NLink bool UID bool GID bool RDev bool ATime bool MTime bool CTime bool INo bool Size bool Blocks bool BTime bool Gen bool DataVersion bool }
AttrMask is a mask of attributes for getattr.
func AttrMaskAll ¶
func AttrMaskAll() AttrMask
AttrMaskAll returns an AttrMask with all fields masked.
type Client ¶
type Client struct {
// contains filtered or unexported fields
}
Client is at least a 9P2000.L client.
func NewClient ¶
NewClient creates a new client. It performs a Tversion exchange with the server to assert that messageSize is ok to use.
You should not use the same socket for multiple clients.
type ConnectFlags ¶
type ConnectFlags uint32
ConnectFlags is the mode passed to Connect operations.
These correspond to bits sent over the wire.
const ( // StreamSocket is a Tlconnect flag indicating SOCK_STREAM mode. StreamSocket ConnectFlags = 0 // DgramSocket is a Tlconnect flag indicating SOCK_DGRAM mode. DgramSocket ConnectFlags = 1 // SeqpacketSocket is a Tlconnect flag indicating SOCK_SEQPACKET mode. SeqpacketSocket ConnectFlags = 2 // AnonymousSocket is a Tlconnect flag indicating that the mode does not // matter and that the requester will accept any socket type. AnonymousSocket ConnectFlags = 3 )
type DefaultWalkGetAttr ¶
type DefaultWalkGetAttr struct{}
DefaultWalkGetAttr implements File.WalkGetAttr to return ENOSYS for server-side Files.
func (DefaultWalkGetAttr) WalkGetAttr ¶
WalkGetAttr implements File.WalkGetAttr.
type Dirent ¶
type Dirent struct { // QID is the entry QID. QID QID // Offset is the offset in the directory. // // This will be communicated back the original caller. Offset uint64 // Type is the 9P type. Type QIDType // Name is the name of the entry (i.e. basename). Name string }
Dirent is used for readdir.
type ErrBadResponse ¶
ErrBadResponse indicates the response didn't match the request.
func (*ErrBadResponse) Error ¶
func (e *ErrBadResponse) Error() string
Error returns a highly descriptive error.
type ErrInvalidMsgType ¶
type ErrInvalidMsgType struct {
MsgType
}
ErrInvalidMsgType is returned when an unsupported message type is found.
func (*ErrInvalidMsgType) Error ¶
func (e *ErrInvalidMsgType) Error() string
Error returns a useful string.
type ErrMessageTooLarge ¶
type ErrMessageTooLarge struct {
// contains filtered or unexported fields
}
ErrMessageTooLarge indicates the size was larger than reasonable.
func (*ErrMessageTooLarge) Error ¶
func (e *ErrMessageTooLarge) Error() string
Error returns a sensible error.
type ErrSocket ¶
type ErrSocket struct {
// contains filtered or unexported fields
}
ErrSocket is returned in cases of a socket issue.
This may be treated differently than other errors.
type FSStat ¶
type FSStat struct { // Type is the filesystem type. Type uint32 // BlockSize is the blocksize. BlockSize uint32 // Blocks is the number of blocks. Blocks uint64 // BlocksFree is the number of free blocks. BlocksFree uint64 // BlocksAvailable is the number of blocks *available*. BlocksAvailable uint64 // Files is the number of files available. Files uint64 // FilesFree is the number of free file nodes. FilesFree uint64 // FSID is the filesystem ID. FSID uint64 // NameLength is the maximum name length. NameLength uint32 }
FSStat is used by statfs.
type File ¶
type File interface { // Walk walks to the path components given in names. // // Walk returns QIDs in the same order that the names were passed in. // // An empty list of arguments should return a copy of the current file. Walk(names []string) ([]QID, File, error) // StatFS returns information about the file system associated with // this file. StatFS() (FSStat, error) // GetAttr returns attributes of this node. GetAttr(req AttrMask) (QID, AttrMask, Attr, error) // SetAttr sets attributes on this node. SetAttr(valid SetAttrMask, attr SetAttr) error // Remove removes the file. // // This is deprecated in favor of UnlinkAt below. Remove() error // Rename renames the file. Rename(directory File, name string) error // Close is called when all references are dropped on the server side, // and Close should be called by the client to drop all references. // // For server-side implementations of Close, the error is ignored. // // Close must be called even when Open has not been called. Close() error // Open is called prior to using read/write. // // The *fd.FD may be nil. If an *fd.FD is provided, ownership now // belongs to the caller and the FD must be non-blocking. // // If Open returns a non-nil *fd.FD, it should do so for all possible // OpenFlags. If Open returns a nil *fd.FD, it should similarly return // a nil *fd.FD for all possible OpenFlags. // // This can be assumed to be one-shot only. Open(mode OpenFlags) (*fd.FD, QID, uint32, error) // Read reads from this file. // // This may return io.EOF in addition to syscall.Errno values. // // Preconditions: Open has been called and returned success. ReadAt(p []byte, offset uint64) (int, error) // Write writes to this file. // // This may return io.EOF in addition to syscall.Errno values. // // Preconditions: Open has been called and returned success. WriteAt(p []byte, offset uint64) (int, error) // FSync syncs this node. // // Preconditions: Open has been called and returned success. FSync() error // Create creates a new regular file and opens it according to the // flags given. // // See p9.File.Open for a description of *fd.FD. Create(name string, flags OpenFlags, permissions FileMode, uid UID, gid GID) (*fd.FD, File, QID, uint32, error) // Mkdir creates a subdirectory. Mkdir(name string, permissions FileMode, uid UID, gid GID) (QID, error) // Symlink makes a new symbolic link. Symlink(oldname string, newname string, uid UID, gid GID) (QID, error) // Link makes a new hard link. Link(target File, newname string) error // Mknod makes a new device node. Mknod(name string, permissions FileMode, major uint32, minor uint32, uid UID, gid GID) (QID, error) // RenameAt renames a given file to a new name in a potentially new // directory. // // oldname must be a name relative to this file, which must be a // directory. newname is a name relative to newdir. // // This is deprecated in favor of Rename. RenameAt(oldname string, newdir File, newname string) error // UnlinkAt the given named file. // // name must be a file relative to this directory. // // Flags are implementation-specific (e.g. O_DIRECTORY), but are // generally Linux unlinkat(2) flags. UnlinkAt(name string, flags uint32) error // Readdir reads directory entries. // // This may return io.EOF in addition to syscall.Errno values. // // Preconditions: Open has been called and returned success. Readdir(offset uint64, count uint32) ([]Dirent, error) // Readlink reads the link target. Readlink() (string, error) // Flush is called prior to Close. // // Whereas Close drops all references to the file, Flush cleans up the // file state. Behavior is implementation-specific. // // Flush is not related to flush(9p). Flush is an extension to 9P2000.L, // see version.go. Flush() error // WalkGetAttr walks to the next file and returns its maximal set of // attributes. // // Server-side p9.Files may return syscall.ENOSYS to indicate that Walk // and GetAttr should be used separately to satisfy this request. WalkGetAttr([]string) ([]QID, File, AttrMask, Attr, error) // Connect establishes a new host-socket backed connection with a // socket. A File does not need to be opened before it can be connected // and it can be connected to multiple times resulting in a unique // *fd.FD each time. In addition, the lifetime of the *fd.FD is // independent from the lifetime of the p9.File and must be managed by // the caller. // // The returned FD must be non-blocking. // // flags indicates the requested type of socket. Connect(flags ConnectFlags) (*fd.FD, error) }
File is a set of operations corresponding to a single node.
Functions below MUST return syscall.Errno values. TODO: Enforce that with the type.
These must be implemented in all circumstances.
type FileMode ¶
type FileMode uint32
FileMode are flags corresponding to file modes.
These correspond to bits sent over the wire. These also correspond to mode_t bits.
const ( // FileModeMask is a mask of all the file mode bits of FileMode. FileModeMask FileMode = 0170000 // ModeSocket is an (unused) mode bit for a socket. ModeSocket FileMode = 0140000 // ModeSymlink is a mode bit for a symlink. ModeSymlink FileMode = 0120000 // ModeRegular is a mode bit for regular files. ModeRegular FileMode = 0100000 // ModeBlockDevice is a mode bit for block devices. ModeBlockDevice FileMode = 060000 // ModeDirectory is a mode bit for directories. ModeDirectory FileMode = 040000 // ModeCharacterDevice is a mode bit for a character device. ModeCharacterDevice FileMode = 020000 // ModeNamedPipe is a mode bit for a named pipe. ModeNamedPipe FileMode = 010000 // Read is a mode bit indicating read permission. Read FileMode = 04 // Write is a mode bit indicating write permission. Write FileMode = 02 // Exec is a mode bit indicating exec permission. Exec FileMode = 01 // PermissionsMask is the mask to apply to FileModes for permissions. PermissionsMask FileMode = 0777 )
func ModeFromOS ¶
ModeFromOS returns a FileMode from an os.FileMode.
func (FileMode) IsBlockDevice ¶
IsBlockDevice returns true if m represents a character device.
func (FileMode) IsCharacterDevice ¶
IsCharacterDevice returns true if m represents a character device.
func (FileMode) IsExecutable ¶
IsExecutable returns true if m represents a file that can be executed.
func (FileMode) IsNamedPipe ¶
IsNamedPipe returns true if m represents a named pipe.
func (FileMode) IsReadable ¶
IsReadable returns true if m represents a file that can be read.
func (FileMode) IsWritable ¶
IsWritable returns true if m represents a file that can be written to.
func (FileMode) Permissions ¶
Permissions returns just the permission bits of the mode.
type OpenFlags ¶
type OpenFlags uint32
OpenFlags is the mode passed to Open and Create operations.
These correspond to bits sent over the wire.
const ( // ReadOnly is a Topen and Tcreate flag indicating read-only mode. ReadOnly OpenFlags = 0 // WriteOnly is a Topen and Tcreate flag indicating write-only mode. WriteOnly OpenFlags = 1 // ReadWrite is a Topen flag indicates read-write mode. ReadWrite OpenFlags = 2 // OpenFlagsModeMask is a mask of valid OpenFlags mode bits. OpenFlagsModeMask OpenFlags = 3 )
type QID ¶
type QID struct { // Type is the highest order byte of the file mode. Type QIDType // Version is an arbitrary server version number. Version uint32 // Path is a unique server identifier for this path (e.g. inode). Path uint64 }
QID is a unique file identifier.
This may be embedded in other requests and responses.
type QIDGenerator ¶
type QIDGenerator struct {
// contains filtered or unexported fields
}
QIDGenerator is a simple generator for QIDs that atomically increments Path values.
func (*QIDGenerator) Get ¶
func (q *QIDGenerator) Get(t QIDType) QID
Get returns a new 9P unique ID with a unique Path given a QID type.
While the 9P spec allows Version to be incremented every time the file is modified, we currently do not use the Version member for anything. Hence, it is set to 0.
type QIDType ¶
type QIDType uint8
QIDType represents the file type for QIDs.
QIDType corresponds to the high 8 bits of a Plan 9 file mode.
const ( // TypeDir represents a directory type. TypeDir QIDType = 0x80 // TypeAppendOnly represents an append only file. TypeAppendOnly QIDType = 0x40 // TypeExclusive represents an exclusive-use file. TypeExclusive QIDType = 0x20 // TypeMount represents a mounted channel. TypeMount QIDType = 0x10 // TypeAuth represents an authentication file. TypeAuth QIDType = 0x08 // TypeTemporary represents a temporary file. TypeTemporary QIDType = 0x04 // TypeSymlink represents a symlink. TypeSymlink QIDType = 0x02 // TypeLink represents a hard link. TypeLink QIDType = 0x01 // TypeRegular represents a regular file. TypeRegular QIDType = 0x00 )
type Rauth ¶
type Rauth struct {
QID
}
Rauth is an authentication response.
Encode, Decode and Length are inherited directly from QID.
type ReadWriterFile ¶
ReadWriterFile wraps a File and implements io.ReadWriter, io.ReaderAt, and io.WriterAt.
func (*ReadWriterFile) Read ¶
func (r *ReadWriterFile) Read(p []byte) (int, error)
Read implements part of the io.ReadWriter interface.
func (*ReadWriterFile) ReadAt ¶
func (r *ReadWriterFile) ReadAt(p []byte, offset int64) (int, error)
ReadAt implements the io.ReaderAt interface.
type Rgetattr ¶
type Rgetattr struct { // Valid indicates which fields are valid. Valid AttrMask // QID is the QID for this file. QID // Attr is the set of attributes. Attr Attr }
Rgetattr is a getattr response.
type Rlconnect ¶
Rlconnect is a connect response.
func (*Rlconnect) FilePayload ¶
FilePayload returns the file payload.
func (*Rlconnect) SetFilePayload ¶
SetFilePayload sets the received file.
type Rlcreate ¶
type Rlcreate struct {
Rlopen
}
Rlcreate is a create response.
The Encode, Decode, etc. methods are inherited from Rlopen.
type Rlerror ¶
type Rlerror struct {
Error uint32
}
Rlerror is an error response.
Note that this replaces the error code used in 9p.
type Rlopen ¶
type Rlopen struct { // QID is the file's QID. QID QID // IoUnit is the recommended I/O unit. IoUnit uint32 // File may be attached via the socket. // // This is an extension specific to this package. File *fd.FD }
Rlopen is a open response.
func (*Rlopen) FilePayload ¶
FilePayload returns the file payload.
func (*Rlopen) SetFilePayload ¶
SetFilePayload sets the received file.
type Rmkdir ¶
type Rmkdir struct { // QID is the resulting QID. QID QID }
Rmkdir is a mkdir response.
type Rmknod ¶
type Rmknod struct { // QID is the resulting QID. QID QID }
Rmknod is a mknod response.
type Rread ¶
type Rread struct { // Data is the resulting data. Data []byte }
Rread is the response for a Tread.
func (*Rread) Decode ¶
func (r *Rread) Decode(b *buffer)
Decode implements encoder.Decode.
Data is automatically decoded via Payload.
func (*Rread) Encode ¶
func (r *Rread) Encode(b *buffer)
Encode implements encoder.Encode.
Data is automatically encoded via Payload.
func (*Rread) SetPayload ¶
SetPayload implements payloader.SetPayload.
type Rreaddir ¶
type Rreaddir struct { // Count is the byte limit. // // This should always be set from the Treaddir request. Count uint32 // Entries are the resulting entries. // // This may be constructed in decode. Entries []Dirent // contains filtered or unexported fields }
Rreaddir is a readdir response.
func (*Rreaddir) SetPayload ¶
SetPayload implements payloader.SetPayload.
type Rreadlink ¶
type Rreadlink struct { // Target is the symlink target. Target string }
Rreadlink is a readlink response.
type Rstatfs ¶
type Rstatfs struct { // FSStat is the stat result. FSStat FSStat }
Rstatfs is the response for a Tstatfs.
type Rsymlink ¶
type Rsymlink struct { // QID is the new symlink's QID. QID QID }
Rsymlink is a symlink response.
type Rversion ¶
type Rversion struct { // MSize is the negotiated size. MSize uint32 // Version is the negotiated version. Version string }
Rversion is a version response.
type Rwalk ¶
type Rwalk struct { // QIDs are the set of QIDs returned. QIDs []QID }
Rwalk is a walk response.
type Rwalkgetattr ¶
type Rwalkgetattr struct { // Valid indicates which fields are valid in the Attr below. Valid AttrMask // Attr is the set of attributes for the last QID (the file walked to). Attr Attr // QIDs are the set of QIDs returned. QIDs []QID }
Rwalkgetattr is a walk response.
func (*Rwalkgetattr) Decode ¶
func (r *Rwalkgetattr) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Rwalkgetattr) Encode ¶
func (r *Rwalkgetattr) Encode(b *buffer)
Encode implements encoder.Encode.
func (*Rwalkgetattr) String ¶
func (r *Rwalkgetattr) String() string
String implements fmt.Stringer.
type Rwrite ¶
type Rwrite struct { // Count indicates the number of bytes successfully written. Count uint32 }
Rwrite is the response for a Twrite.
type Rxattrcreate ¶
type Rxattrcreate struct { }
Rxattrcreate is a xattrcreate response.
func (*Rxattrcreate) Decode ¶
func (r *Rxattrcreate) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Rxattrcreate) Encode ¶
func (r *Rxattrcreate) Encode(b *buffer)
Encode implements encoder.Encode.
func (*Rxattrcreate) String ¶
func (r *Rxattrcreate) String() string
String implements fmt.Stringer.
type Rxattrwalk ¶
type Rxattrwalk struct { // Size is the size of the extended attribute. Size uint64 }
Rxattrwalk is a xattrwalk response.
func (*Rxattrwalk) Decode ¶
func (r *Rxattrwalk) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Rxattrwalk) Encode ¶
func (r *Rxattrwalk) Encode(b *buffer)
Encode implements encoder.Encode.
type Server ¶
type Server struct {
// contains filtered or unexported fields
}
Server is a 9p2000.L server.
type SetAttr ¶
type SetAttr struct { Permissions FileMode UID UID GID GID Size uint64 ATimeSeconds uint64 ATimeNanoSeconds uint64 MTimeSeconds uint64 MTimeNanoSeconds uint64 }
SetAttr specifies a set of attributes for a setattr.
type SetAttrMask ¶
type SetAttrMask struct { Permissions bool UID bool GID bool Size bool ATime bool MTime bool CTime bool ATimeNotSystemTime bool MTimeNotSystemTime bool }
SetAttrMask specifies a valid mask for setattr.
func (*SetAttrMask) Decode ¶
func (s *SetAttrMask) Decode(b *buffer)
Decode implements encoder.Decode.
func (SetAttrMask) Empty ¶
func (s SetAttrMask) Empty() bool
Empty returns true if no fields are masked.
func (*SetAttrMask) Encode ¶
func (s *SetAttrMask) Encode(b *buffer)
Encode implements encoder.Encode.
func (SetAttrMask) IsSubsetOf ¶
func (s SetAttrMask) IsSubsetOf(m SetAttrMask) bool
IsSubsetOf returns whether s is a subset of m.
type Tattach ¶
type Tattach struct { // FID is the FID to be attached. FID FID // Auth is the embedded authentication request. // // See client.Attach for information regarding authentication. Auth Tauth }
Tattach is an attach request.
type Tauth ¶
type Tauth struct { // AuthenticationFID is the FID to attach the authentication result. AuthenticationFID FID // UserName is the user to attach. UserName string // AttachName is the attach name. AttachName string // UserID is the numeric identifier for UserName. UID UID }
Tauth is an authentication request.
type Tclunk ¶
type Tclunk struct { // FID is the FID to be closed. FID FID }
Tclunk is a close request.
type Tflush ¶
type Tflush struct { // OldTag is the tag to wait on. OldTag Tag }
Tflush is a flush request.
type Tflushf ¶
type Tflushf struct { // FID is the FID to be flushed. FID FID }
Tflushf is a flush file request, not to be confused with Tflush.
type Tgetattr ¶
type Tgetattr struct { // FID is the FID to get attributes for. FID FID // AttrMask is the set of attributes to get. AttrMask AttrMask }
Tgetattr is a getattr request.
type Tlconnect ¶
type Tlconnect struct { // FID is the FID to be connected. FID FID // Flags are the connect flags. Flags ConnectFlags }
Tlconnect is a connect request.
type Tlcreate ¶
type Tlcreate struct { // FID is the parent FID. // // This becomes the new file. FID FID // Name is the file name to create. Name string // Mode is the open mode (O_RDWR, etc.). // // Note that flags like O_TRUNC are ignored, as is O_EXCL. All // create operations are exclusive. OpenFlags OpenFlags // Permissions is the set of permission bits. Permissions FileMode // GID is the group ID to use for creating the file. GID GID }
Tlcreate is a create request.
type Tlink ¶
type Tlink struct { // Directory is the directory to contain the link. Directory FID // FID is the target. Target FID // Name is the new source name. Name string }
Tlink is a link request.
type Tlopen ¶
type Tlopen struct { // FID is the FID to be opened. FID FID // Flags are the open flags. Flags OpenFlags }
Tlopen is an open request.
type Tmkdir ¶
type Tmkdir struct { // Directory is the parent directory. Directory FID // Name is the new directory name. Name string // Permissions is the set of permission bits. Permissions FileMode // GID is the owning group. GID GID }
Tmkdir is a mkdir request.
type Tmknod ¶
type Tmknod struct { // Directory is the parent directory. Directory FID // Name is the device name. Name string // Permissions are the device permissions. Permissions FileMode // Major is the device major number. Major uint32 // Minor is the device minor number. Minor uint32 // GID is the device GID. GID GID }
Tmknod is a mknod request.
type Tread ¶
type Tread struct { // FID is the FID to read. FID FID // Offset indicates the file offset. Offset uint64 // Count indicates the number of bytes to read. Count uint32 }
Tread is a read request.
type Treaddir ¶
type Treaddir struct { // Directory is the directory FID to read. Directory FID // Offset is the offset to read at. Offset uint64 // Count is the number of bytes to read. Count uint32 }
Treaddir is a readdir request.
type Treadlink ¶
type Treadlink struct { // FID is the symlink. FID FID }
Treadlink is a readlink request.
type Tremove ¶
type Tremove struct { // FID is the FID to be removed. FID FID }
Tremove is a remove request.
This will eventually be replaced by Tunlinkat.
type Trename ¶
type Trename struct { // FID is the FID to rename. FID FID // Directory is the target directory. Directory FID // Name is the new file name. Name string }
Trename is a rename request.
Note that this generally isn't used anymore, and ideally all rename calls should Trenameat below.
type Trenameat ¶
type Trenameat struct { // OldDirectory is the source directory. OldDirectory FID // OldName is the source file name. OldName string // NewDirectory is the target directory. NewDirectory FID // NewName is the new file name. NewName string }
Trenameat is a rename request.
type Tsetattr ¶
type Tsetattr struct { // FID is the FID to change. FID FID // Valid is the set of bits which will be used. Valid SetAttrMask // SetAttr is the set request. SetAttr SetAttr }
Tsetattr is a setattr request.
type Tsymlink ¶
type Tsymlink struct { // Directory is the directory FID. Directory FID // Name is the new in the directory. Name string // Target is the symlink target. Target string // GID is the owning group. GID GID }
Tsymlink is a symlink request.
type Tucreate ¶
type Tucreate struct { Tlcreate // UID is the UID to use as the effective UID in creation messages. UID UID }
Tucreate is a Tlcreate message that includes a UID.
type Tumkdir ¶
type Tumkdir struct { Tmkdir // UID is the UID to use as the effective UID in creation messages. UID UID }
Tumkdir is a Tmkdir message that includes a UID.
type Tumknod ¶
type Tumknod struct { Tmknod // UID is the UID to use as the effective UID in creation messages. UID UID }
Tumknod is a Tmknod message that includes a UID.
type Tunlinkat ¶
type Tunlinkat struct { // Directory is the originating directory. Directory FID // Name is the name of the entry to unlink. Name string // Flags are extra flags (e.g. O_DIRECTORY). These are not interpreted by p9. Flags uint32 }
Tunlinkat is an unlink request.
type Tusymlink ¶
type Tusymlink struct { Tsymlink // UID is the UID to use as the effective UID in creation messages. UID UID }
Tusymlink is a Tsymlink message that includes a UID.
type Tversion ¶
type Tversion struct { // MSize is the message size to use. MSize uint32 // Version is the version string. // // For this implementation, this must be 9P2000.L. Version string }
Tversion is a version request.
type Twalk ¶
type Twalk struct { // FID is the FID to be walked. FID FID // NewFID is the resulting FID. NewFID FID // Names are the set of names to be walked. Names []string }
Twalk is a walk request.
type Twalkgetattr ¶
type Twalkgetattr struct { // FID is the FID to be walked. FID FID // NewFID is the resulting FID. NewFID FID // Names are the set of names to be walked. Names []string }
Twalkgetattr is a walk request.
func (*Twalkgetattr) Decode ¶
func (t *Twalkgetattr) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Twalkgetattr) Encode ¶
func (t *Twalkgetattr) Encode(b *buffer)
Encode implements encoder.Encode.
func (*Twalkgetattr) String ¶
func (t *Twalkgetattr) String() string
String implements fmt.Stringer.
type Twrite ¶
type Twrite struct { // FID is the FID to read. FID FID // Offset indicates the file offset. Offset uint64 // Data is the data to be written. Data []byte }
Twrite is a write request.
func (*Twrite) Encode ¶
func (t *Twrite) Encode(b *buffer)
Encode implements encoder.Encode.
This uses the buffer payload to avoid a copy.
func (*Twrite) SetPayload ¶
SetPayload implements payloader.SetPayload.
type Txattrcreate ¶
type Txattrcreate struct { // FID is input/output parameter, it identifies the file on which // extended attributes will be set but after successful Rxattrcreate // it is used to write the extended attribute value. FID FID // Name is the attribute name. Name string // Size of the attribute value. When the FID is clunked it has to match // the number of bytes written to the FID. AttrSize uint64 // Linux setxattr(2) flags. Flags uint32 }
Txattrcreate prepare to set extended attributes.
func (*Txattrcreate) Decode ¶
func (t *Txattrcreate) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Txattrcreate) Encode ¶
func (t *Txattrcreate) Encode(b *buffer)
Encode implements encoder.Encode.
func (*Txattrcreate) String ¶
func (t *Txattrcreate) String() string
String implements fmt.Stringer.
type Txattrwalk ¶
type Txattrwalk struct { // FID is the FID to check for attributes. FID FID // NewFID is the new FID associated with the attributes. NewFID FID // Name is the attribute name. Name string }
Txattrwalk walks extended attributes.
func (*Txattrwalk) Decode ¶
func (t *Txattrwalk) Decode(b *buffer)
Decode implements encoder.Decode.
func (*Txattrwalk) Encode ¶
func (t *Txattrwalk) Encode(b *buffer)
Encode implements encoder.Encode.
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Binary local_server provides a local 9P2000.L server for the p9 package.
|
Binary local_server provides a local 9P2000.L server for the p9 package. |