p9p

type Channel interface {
	// ReadFcall reads one fcall frame into the provided fcall structure. The
	// Fcall may be cleared whether there is an error or not. If the operation
	// is successful, the contents of the fcall will be populated in the
	// argument. ReadFcall cannot be called concurrently with other calls to
	// ReadFcall. This both to preserve message ordering and to allow lockless
	// buffer reusage.
	ReadFcall(ctx context.Context, fcall *Fcall) error

	// WriteFcall writes the provided fcall to the channel. WriteFcall cannot
	// be called concurrently with other calls to WriteFcall.
	WriteFcall(ctx context.Context, fcall *Fcall) error

	// MSize returns the current msize for the channel.
	MSize() int

	// SetMSize sets the maximum message size for the channel. This must never
	// be called currently with ReadFcall or WriteFcall.
	SetMSize(msize int)
}

type Codec interface {
	// Unmarshal from data into the value pointed to by v.
	Unmarshal(data []byte, v interface{}) error

	// Marshal the value v into a byte slice.
	Marshal(v interface{}) ([]byte, error)

	// Size returns the encoded size for the target of v.
	Size(v interface{}) int
}

type Dir struct {
	Type uint16
	Dev  uint32
	Qid  Qid
	Mode uint32

	AccessTime time.Time
	ModTime    time.Time

	Length uint64
	Name   string
	UID    string
	GID    string
	MUID   string
}

type Fcall struct {
	Type    FcallType
	Tag     Tag
	Message Message
}

type FcallType uint8

type Fid uint32

type Flag uint8

type Handler interface {
	Handle(ctx context.Context, msg Message) (Message, error)
}

type HandlerFunc func(ctx context.Context, msg Message) (Message, error)

type Message interface {
	// Type returns the type of call for the target message.
	Type() FcallType
}

type MessageRattach struct {
	Qid Qid
}

type MessageRauth struct {
	Qid Qid
}

type MessageRclunk struct{}

type MessageRcreate struct {
	Qid    Qid
	IOUnit uint32
}

type MessageRerror struct {
	Ename string
}

type MessageRflush struct{}

type MessageRopen struct {
	Qid    Qid
	IOUnit uint32
}

type MessageRread struct {
	Data []byte
}

type MessageRremove struct{}

type MessageRstat struct {
	Stat Dir
}

type MessageRversion struct {
	MSize   uint32
	Version string
}

type MessageRwalk struct {
	Qids []Qid
}

type MessageRwrite struct {
	Count uint32
}

type MessageRwstat struct{}

type MessageTattach struct {
	Fid   Fid
	Afid  Fid
	Uname string
	Aname string
}

type MessageTauth struct {
	Afid  Fid
	Uname string
	Aname string
}

type MessageTclunk struct {
	Fid Fid
}

type MessageTcreate struct {
	Fid  Fid
	Name string
	Perm uint32
	Mode Flag
}

type MessageTflush struct {
	Oldtag Tag
}

type MessageTopen struct {
	Fid  Fid
	Mode Flag
}

type MessageTread struct {
	Fid    Fid
	Offset uint64
	Count  uint32
}

type MessageTremove struct {
	Fid Fid
}

type MessageTstat struct {
	Fid Fid
}

type MessageTversion struct {
	MSize   uint32
	Version string
}

type MessageTwalk struct {
	Fid    Fid
	Newfid Fid
	Wnames []string
}

type MessageTwrite struct {
	Fid    Fid
	Offset uint64
	Data   []byte
}

type MessageTwstat struct {
	Fid  Fid
	Stat Dir
}

type QType uint8

type Qid struct {
	Type    QType `9p:"type,1"`
	Version uint32
	Path    uint64
}

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

type Session interface {
	Auth(ctx context.Context, afid Fid, uname, aname string) (Qid, error)
	Attach(ctx context.Context, fid, afid Fid, uname, aname string) (Qid, error)
	Clunk(ctx context.Context, fid Fid) error
	Remove(ctx context.Context, fid Fid) error
	Walk(ctx context.Context, fid Fid, newfid Fid, names ...string) ([]Qid, error)

	// Read follows the semantics of io.ReaderAt.ReadAtt method except it takes
	// a contxt and Fid.
	Read(ctx context.Context, fid Fid, p []byte, offset int64) (n int, err error)

	// Write follows the semantics of io.WriterAt.WriteAt except takes a context and an Fid.
	//
	// If n == len(p), no error is returned.
	// If n < len(p), io.ErrShortWrite will be returned.
	Write(ctx context.Context, fid Fid, p []byte, offset int64) (n int, err error)

	Open(ctx context.Context, fid Fid, mode Flag) (Qid, uint32, error)
	Create(ctx context.Context, parent Fid, name string, perm uint32, mode Flag) (Qid, uint32, error)
	Stat(ctx context.Context, fid Fid) (Dir, error)
	WStat(ctx context.Context, fid Fid, dir Dir) error

	// Version returns the supported version and msize of the session. This
	// can be affected by negotiating or the level of support provided by the
	// session implementation.
	Version() (msize int, version string)
}

type Tag uint16