commit 6924559fb2165ec052ec4c40a9d1f7dc76294ee4
parent f62e5a3699de784ec9d8cf593496188a7aca38ae
Author: Matsuda Kenji <info@mtkn.jp>
Date: Fri, 27 Oct 2023 08:03:53 +0900
change message struct
Diffstat:
| M | fcall.go | | | 821 | +++++++++++++++++++++++++++++++++++++------------------------------------------ |
| M | server.go | | | 142 | +++++++++++++++++++++++++++++++++++++++---------------------------------------- |
2 files changed, 453 insertions(+), 510 deletions(-)
diff --git a/fcall.go b/fcall.go
@@ -40,14 +40,14 @@ const (
)
// Ample room for Twrite/Rread header (iounit).
-// Twrite: size[4] type[1] tag[2] fid[4] offset[8] count[4] = 23
-// Rread: size[4] type[1] tag[2] count[4] = 11
+// Twrite: size[4] type[1] Tag[2] fid[4] offset[8] count[4] = 23
+// Rread: size[4] type[1] Tag[2] count[4] = 11
// In Plan9, this const is 24.
const IOHDRSZ = 23
-// The tag used by version messages.
+// The Tag used by version messages.
// The client can use it, when establishing a connection, to
-// override tag matching in version messages.
+// override Tag matching in version messages.
const NOTAG = ^uint16(0)
// Msg represents any kind of message of 9P.
@@ -63,10 +63,12 @@ type Msg interface {
Size() uint32
// Type returns the type field of message.
Type() MsgType
- // Tag returns the tag of message.
+ // GetTag returns the Tag of message.
// Tag is the identifier of each message.
- Tag() uint16
- // SetTag sets the tag field of the message.
+ // The Get prefix is to avoid name confliction with the each
+ // message's Tag field.
+ GetTag() uint16
+ // SetTag sets the Tag field of the message.
SetTag(uint16)
// Marshal convert Msg to byte array to be transmitted.
@@ -80,7 +82,7 @@ type bufMsg []byte
func (msg bufMsg) Size() uint32 { return gbit32(msg[0:4]) }
func (msg bufMsg) Type() MsgType { return MsgType(msg[4]) }
-func (msg bufMsg) Tag() uint16 { return gbit16(msg[5:7]) }
+func (msg bufMsg) GetTag() uint16 { return gbit16(msg[5:7]) }
func (msg bufMsg) SetTag(t uint16) { pbit16(msg[5:7], t) }
func (msg bufMsg) marshal() []byte { return []byte(msg)[:msg.Size()] }
func (msg bufMsg) String() string {
@@ -145,32 +147,30 @@ func (msg bufMsg) String() string {
}
type TVersion struct {
- tag uint16
- mSize uint32
- version string
+ Tag uint16
+ Msize uint32
+ Version string
}
func newTVersion(buf []byte) *TVersion {
msg := new(TVersion)
- msg.tag = gbit16(buf[5:7])
- msg.mSize = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Msize = gbit32(buf[7:11])
vs := gbit16(buf[11:13])
- msg.version = string(buf[13 : 13+vs])
+ msg.Version = string(buf[13 : 13+vs])
return msg
}
-func (msg *TVersion) Size() uint32 { return uint32(4 + 1 + 2 + 4 + 2 + len(msg.version)) }
+func (msg *TVersion) Size() uint32 { return uint32(4 + 1 + 2 + 4 + 2 + len(msg.Version)) }
func (msg *TVersion) Type() MsgType { return Tversion }
-func (msg *TVersion) Tag() uint16 { return msg.tag }
-func (msg *TVersion) SetTag(t uint16) { msg.tag = t }
-func (msg *TVersion) MSize() uint32 { return msg.mSize }
-func (msg *TVersion) Version() string { return msg.version }
+func (msg *TVersion) GetTag() uint16 { return msg.Tag }
+func (msg *TVersion) SetTag(t uint16) { msg.Tag = t }
func (msg *TVersion) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(Tversion)
- pbit16(m[5:7], msg.Tag())
- pbit32(m[7:11], msg.MSize())
- v := msg.Version()
+ pbit16(m[5:7], msg.Tag)
+ pbit32(m[7:11], msg.Msize)
+ v := msg.Version
pbit16(m[11:13], uint16(len(v)))
for i := 0; i < len(v); i++ {
m[13+i] = v[i]
@@ -178,32 +178,28 @@ func (msg *TVersion) marshal() []byte {
return m
}
func (msg *TVersion) String() string {
- return fmt.Sprintf("Tversion tag %d msize %d version '%s'",
- msg.Tag(), msg.MSize(), msg.Version())
+ return fmt.Sprintf("Tversion Tag %d msize %d version '%s'",
+ msg.Tag, msg.Msize, msg.Version)
}
type RVersion struct {
- tag uint16
- mSize uint32
- version string
+ Tag uint16
+ Msize uint32
+ Version string
}
func newRVersion(buf []byte) *RVersion {
msg := new(RVersion)
- msg.tag = gbit16(buf[5:7])
- msg.mSize = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Msize = gbit32(buf[7:11])
vs := gbit16(buf[11:13])
- msg.version = string(buf[13 : 13+vs])
+ msg.Version = string(buf[13 : 13+vs])
return msg
}
-func (msg *RVersion) Size() uint32 { return uint32(4 + 1 + 2 + 4 + 2 + len(msg.version)) }
+func (msg *RVersion) Size() uint32 { return uint32(4 + 1 + 2 + 4 + 2 + len(msg.Version)) }
func (msg *RVersion) Type() MsgType { return Rversion }
-func (msg *RVersion) Tag() uint16 { return msg.tag }
-func (msg *RVersion) SetTag(t uint16) { msg.tag = t }
-func (msg *RVersion) MSize() uint32 { return msg.mSize }
-func (msg *RVersion) SetMSize(s uint32) { msg.mSize = s }
-func (msg *RVersion) Version() string { return msg.version }
-func (msg *RVersion) SetVersion(v string) { msg.version = v }
+func (msg *RVersion) GetTag() uint16 { return msg.Tag }
+func (msg *RVersion) SetTag(t uint16) { msg.Tag = t }
func (msg *RVersion) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -211,31 +207,31 @@ func (msg *RVersion) marshal() []byte {
cur += 4
buf[cur] = uint8(Rversion)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.MSize())
+ pbit32(buf[cur:cur+4], msg.Msize)
cur += 4
- pbit16(buf[cur:cur+2], uint16(len(msg.Version())))
+ pbit16(buf[cur:cur+2], uint16(len(msg.Version)))
cur += 2
- for i, b := range []byte(msg.Version()) {
+ for i, b := range []byte(msg.Version) {
buf[cur+i] = b
}
- cur += len(msg.Version())
+ cur += len(msg.Version)
if cur != len(buf) {
panic("length of buf and cursor not match")
}
return buf
}
func (msg *RVersion) String() string {
- return fmt.Sprintf("Rversion tag %d msize %d version '%s'",
- msg.Tag(), msg.MSize(), msg.Version())
+ return fmt.Sprintf("Rversion Tag %d msize %d version '%s'",
+ msg.Tag, msg.Msize, msg.Version)
}
type TAuth struct {
- tag uint16
- afid uint32
- uname string
- aname string
+ Tag uint16
+ Afid uint32
+ Uname string
+ Aname string
}
func newTAuth(buf []byte) *TAuth {
@@ -243,17 +239,17 @@ func newTAuth(buf []byte) *TAuth {
msg := new(TAuth)
cur += 4
cur += 1 // message type
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.afid = gbit32(buf[cur : cur+4])
+ msg.Afid = gbit32(buf[cur : cur+4])
cur += 4
l := int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.uname = string(buf[cur : cur+l])
+ msg.Uname = string(buf[cur : cur+l])
cur += l
l = int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.aname = string(buf[cur : cur+l])
+ msg.Aname = string(buf[cur : cur+l])
cur += l
if cur != int(gbit32(buf[0:4])) {
panic("length of buf and cursor position not match")
@@ -261,14 +257,11 @@ func newTAuth(buf []byte) *TAuth {
return msg
}
func (msg *TAuth) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + 2 + len(msg.uname) + 2 + len(msg.aname))
+ return uint32(4 + 1 + 2 + 4 + 2 + len(msg.Uname) + 2 + len(msg.Aname))
}
func (msg *TAuth) Type() MsgType { return Tauth }
-func (msg *TAuth) Tag() uint16 { return msg.tag }
-func (msg *TAuth) SetTag(t uint16) { msg.tag = t }
-func (msg *TAuth) AFid() uint32 { return msg.afid }
-func (msg *TAuth) UName() string { return msg.uname }
-func (msg *TAuth) AName() string { return msg.aname }
+func (msg *TAuth) GetTag() uint16 { return msg.Tag }
+func (msg *TAuth) SetTag(t uint16) { msg.Tag = t }
func (msg *TAuth) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -276,54 +269,51 @@ func (msg *TAuth) marshal() []byte {
cur += 4
buf[cur] = uint8(Tauth)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.AFid())
+ pbit32(buf[cur:cur+4], msg.Afid)
cur += 4
- uname := msg.UName()
- pbit16(buf[cur:cur+2], uint16(len(uname)))
+ pbit16(buf[cur:cur+2], uint16(len(msg.Uname)))
cur += 2
- for i := 0; i < len(uname); i++ {
- buf[cur+i] = uname[i]
+ for i := 0; i < len(msg.Uname); i++ {
+ buf[cur+i] = msg.Uname[i]
}
- cur += len(uname)
- aname := msg.AName()
- pbit16(buf[cur:cur+2], uint16(len(aname)))
+ cur += len(msg.Uname)
+ pbit16(buf[cur:cur+2], uint16(len(msg.Aname)))
cur += 2
- for i := 0; i < len(aname); i++ {
- buf[cur+i] = aname[i]
+ for i := 0; i < len(msg.Aname); i++ {
+ buf[cur+i] = msg.Aname[i]
}
- cur += len(aname)
+ cur += len(msg.Aname)
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
return buf
}
func (msg *TAuth) String() string {
- afid := int64(msg.AFid())
+ afid := int64(msg.Afid)
if afid == int64(NOFID) {
afid = -1
}
- return fmt.Sprintf("Tauth tag %d afid %d uname %s aname %s",
- msg.Tag(), afid, msg.UName(), msg.AName())
+ return fmt.Sprintf("Tauth Tag %d afid %d uname %s aname %s",
+ msg.Tag, afid, msg.Uname, msg.Aname)
}
type RAuth struct {
- tag uint16
- aqid Qid
+ Tag uint16
+ Aqid Qid
}
func newRAuth(buf []byte) *RAuth {
msg := new(RAuth)
- msg.tag = gbit16(buf[5:7])
- msg.aqid = unmarshalQid(buf[7:])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Aqid = unmarshalQid(buf[7:])
return msg
}
func (msg *RAuth) Size() uint32 { return 4 + 1 + 2 + 13 }
func (msg *RAuth) Type() MsgType { return Rauth }
-func (msg *RAuth) Tag() uint16 { return msg.tag }
-func (msg *RAuth) SetTag(t uint16) { msg.tag = t }
-func (msg *RAuth) AQid() Qid { return msg.aqid }
+func (msg *RAuth) GetTag() uint16 { return msg.Tag }
+func (msg *RAuth) SetTag(t uint16) { msg.Tag = t }
func (msg *RAuth) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -331,9 +321,9 @@ func (msg *RAuth) marshal() []byte {
cur += 4
buf[cur] = uint8(Rauth)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- qid := msg.AQid().marshal()
+ qid := msg.Aqid.marshal()
for i := 0; i < len(qid); i++ {
buf[cur+i] = qid[i]
}
@@ -344,16 +334,16 @@ func (msg *RAuth) marshal() []byte {
return buf
}
func (msg *RAuth) String() string {
- return fmt.Sprintf("Tauth tag %d aqid %v",
- msg.Tag(), msg.AQid())
+ return fmt.Sprintf("Tauth Tag %d aqid %v",
+ msg.Tag, msg.Aqid)
}
type TAttach struct {
- tag uint16
- fid uint32
- afid uint32
- uname string
- aname string
+ Tag uint16
+ Fid uint32
+ Afid uint32
+ Uname string
+ Aname string
}
func newTAttach(buf []byte) *TAttach {
@@ -361,19 +351,19 @@ func newTAttach(buf []byte) *TAttach {
msg := new(TAttach)
cur += 4
cur += 1 // message type
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
- msg.afid = gbit32(buf[cur : cur+4])
+ msg.Afid = gbit32(buf[cur : cur+4])
cur += 4
l := int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.uname = string(buf[cur : cur+l])
+ msg.Uname = string(buf[cur : cur+l])
cur += l
l = int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.aname = string(buf[cur : cur+l])
+ msg.Aname = string(buf[cur : cur+l])
cur += l
if cur != int(gbit32(buf[0:4])) {
panic("length of buf and cursor position not match")
@@ -381,15 +371,11 @@ func newTAttach(buf []byte) *TAttach {
return msg
}
func (msg *TAttach) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + 4 + 2 + len(msg.uname) + 2 + len(msg.aname))
+ return uint32(4 + 1 + 2 + 4 + 4 + 2 + len(msg.Uname) + 2 + len(msg.Aname))
}
func (msg *TAttach) Type() MsgType { return Tattach }
-func (msg *TAttach) Tag() uint16 { return msg.tag }
-func (msg *TAttach) SetTag(t uint16) { msg.tag = t }
-func (msg *TAttach) Fid() uint32 { return msg.fid }
-func (msg *TAttach) AFid() uint32 { return msg.afid }
-func (msg *TAttach) UName() string { return msg.uname }
-func (msg *TAttach) AName() string { return msg.aname }
+func (msg *TAttach) GetTag() uint16 { return msg.Tag }
+func (msg *TAttach) SetTag(t uint16) { msg.Tag = t }
func (msg *TAttach) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -397,60 +383,57 @@ func (msg *TAttach) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- pbit32(buf[cur:cur+4], msg.AFid())
+ pbit32(buf[cur:cur+4], msg.Afid)
cur += 4
- uname := msg.UName()
- pbit16(buf[cur:cur+2], uint16(len(uname)))
+ pbit16(buf[cur:cur+2], uint16(len(msg.Uname)))
cur += 2
- for i := 0; i < len(uname); i++ {
- buf[cur+i] = uname[i]
+ for i := 0; i < len(msg.Uname); i++ {
+ buf[cur+i] = msg.Uname[i]
}
- cur += len(uname)
- aname := msg.AName()
- pbit16(buf[cur:cur+2], uint16(len(aname)))
+ cur += len(msg.Uname)
+ pbit16(buf[cur:cur+2], uint16(len(msg.Aname)))
cur += 2
- for i := 0; i < len(aname); i++ {
- buf[cur+i] = aname[i]
+ for i := 0; i < len(msg.Aname); i++ {
+ buf[cur+i] = msg.Aname[i]
}
- cur += len(aname)
+ cur += len(msg.Aname)
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
return buf
}
func (msg *TAttach) String() string {
- fid := int64(msg.Fid())
+ fid := int64(msg.Fid)
if fid == int64(NOFID) {
fid = -1
}
- afid := int64(msg.AFid())
+ afid := int64(msg.Afid)
if afid == int64(NOFID) {
afid = -1
}
- return fmt.Sprintf("Tattach tag %d fid %d afid %d uname %s aname %s",
- msg.Tag(), fid, afid, msg.UName(), msg.AName())
+ return fmt.Sprintf("Tattach Tag %d fid %d afid %d uname %s aname %s",
+ msg.Tag, fid, afid, msg.Uname, msg.Aname)
}
type RAttach struct {
- tag uint16
- qid Qid
+ Tag uint16
+ Qid Qid
}
func newRAttach(buf []byte) *RAttach {
msg := new(RAttach)
- msg.tag = gbit16(buf[5:7])
- msg.qid = unmarshalQid(buf[7:])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Qid = unmarshalQid(buf[7:])
return msg
}
func (msg *RAttach) Size() uint32 { return 4 + 1 + 2 + 13 }
func (msg *RAttach) Type() MsgType { return Rattach }
-func (msg *RAttach) Tag() uint16 { return msg.tag }
-func (msg *RAttach) SetTag(t uint16) { msg.tag = t }
-func (msg *RAttach) Qid() Qid { return msg.qid }
+func (msg *RAttach) GetTag() uint16 { return msg.Tag }
+func (msg *RAttach) SetTag(t uint16) { msg.Tag = t }
func (msg *RAttach) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -458,9 +441,9 @@ func (msg *RAttach) marshal() []byte {
cur += 4
buf[cur] = uint8(Rattach)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- qid := msg.Qid().marshal()
+ qid := msg.Qid.marshal()
for i := 0; i < len(qid); i++ {
buf[cur+i] = qid[i]
}
@@ -471,27 +454,26 @@ func (msg *RAttach) marshal() []byte {
return buf
}
func (msg *RAttach) String() string {
- return fmt.Sprintf("Rattach tag %d qid %v",
- msg.Tag(), msg.Qid())
+ return fmt.Sprintf("Rattach Tag %d qid %v",
+ msg.Tag, msg.Qid)
}
type RError struct {
- tag uint16
- ename error
+ Tag uint16
+ Ename error
}
func newRError(buf []byte) *RError {
msg := new(RError)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
es := gbit16(buf[7:9])
- msg.ename = fmt.Errorf("%s", string(buf[9:9+es]))
+ msg.Ename = fmt.Errorf("%s", string(buf[9:9+es]))
return msg
}
-func (msg *RError) Size() uint32 { return uint32(4 + 1 + 2 + 2 + len(msg.EName())) }
+func (msg *RError) Size() uint32 { return uint32(4 + 1 + 2 + 2 + len(msg.Ename.Error())) }
func (msg *RError) Type() MsgType { return Rerror }
-func (msg *RError) Tag() uint16 { return msg.tag }
-func (msg *RError) SetTag(t uint16) { msg.tag = t }
-func (msg *RError) EName() string { return msg.ename.Error() }
+func (msg *RError) GetTag() uint16 { return msg.Tag }
+func (msg *RError) SetTag(t uint16) { msg.Tag = t }
func (msg *RError) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -499,9 +481,9 @@ func (msg *RError) marshal() []byte {
cur += 4
buf[cur] = uint8(Rerror)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- ename := msg.EName()
+ ename := msg.Ename.Error()
pbit16(buf[cur:cur+2], uint16(len(ename)))
cur += 2
for i := 0; i < len(ename); i++ {
@@ -515,68 +497,67 @@ func (msg *RError) marshal() []byte {
}
func (msg *RError) String() string {
- return fmt.Sprintf("Rerror tag %d ename %v", msg.Tag(), msg.EName())
+ return fmt.Sprintf("Rerror Tag %d ename %v", msg.Tag, msg.Ename.Error())
}
type TFlush struct {
- tag uint16
- oldtag uint16
+ Tag uint16
+ Oldtag uint16
}
func newTFlush(buf []byte) *TFlush {
msg := new(TFlush)
- msg.tag = gbit16(buf[5:7])
- msg.oldtag = gbit16(buf[7:9])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Oldtag = gbit16(buf[7:9])
return msg
}
func (msg *TFlush) Size() uint32 { return 9 }
func (msg *TFlush) Type() MsgType { return Tflush }
-func (msg *TFlush) Tag() uint16 { return msg.tag }
-func (msg *TFlush) SetTag(t uint16) { msg.tag = t }
-func (msg *TFlush) OldTag() uint16 { return msg.oldtag }
+func (msg *TFlush) GetTag() uint16 { return msg.Tag }
+func (msg *TFlush) SetTag(t uint16) { msg.Tag = t }
func (msg *TFlush) marshal() []byte {
buf := make([]byte, msg.Size())
pbit32(buf[0:4], msg.Size())
buf[4] = uint8(msg.Type())
- pbit16(buf[5:7], msg.Tag())
- pbit16(buf[7:9], msg.OldTag())
+ pbit16(buf[5:7], msg.Tag)
+ pbit16(buf[7:9], msg.Oldtag)
return buf
}
func (msg *TFlush) String() string {
- return fmt.Sprintf("Tflush tag %d oldtag %d", msg.Tag(), msg.OldTag())
+ return fmt.Sprintf("Tflush Tag %d oldTag %d", msg.Tag, msg.Oldtag)
}
type RFlush struct {
- tag uint16
+ Tag uint16
}
func newRFlush(buf []byte) *RFlush {
msg := new(RFlush)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
return msg
}
func (msg *RFlush) Size() uint32 { return 7 }
func (msg *RFlush) Type() MsgType { return Rflush }
-func (msg *RFlush) Tag() uint16 { return msg.tag }
-func (msg *RFlush) SetTag(t uint16) { msg.tag = t }
+func (msg *RFlush) GetTag() uint16 { return msg.Tag }
+func (msg *RFlush) SetTag(t uint16) { msg.Tag = t }
func (msg *RFlush) marshal() []byte {
buf := make([]byte, msg.Size())
pbit32(buf[0:4], msg.Size())
buf[4] = uint8(msg.Type())
- pbit16(buf[5:7], msg.Tag())
+ pbit16(buf[5:7], msg.Tag)
return buf
}
func (msg *RFlush) String() string {
- return fmt.Sprintf("Rflush tag %d", msg.Tag())
+ return fmt.Sprintf("Rflush Tag %d", msg.Tag)
}
type TWalk struct {
- tag uint16
- fid uint32
- newFid uint32
- wname []string
+ Tag uint16
+ Fid uint32
+ Newfid uint32
+ Wnames []string
}
func newTWalk(buf []byte) *TWalk {
@@ -585,19 +566,19 @@ func newTWalk(buf []byte) *TWalk {
msize := gbit32(buf[cur : cur+4])
cur += 4
cur += 1 // msgType
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
- msg.newFid = gbit32(buf[cur : cur+4])
+ msg.Newfid = gbit32(buf[cur : cur+4])
cur += 4
nwname := gbit16(buf[cur : cur+2])
cur += 2
- msg.wname = make([]string, nwname)
+ msg.Wnames = make([]string, nwname)
for i := 0; i < int(nwname); i++ {
size := int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.wname[i] = string(buf[cur : cur+size])
+ msg.Wnames[i] = string(buf[cur : cur+size])
cur += size
}
if cur != int(msize) {
@@ -608,18 +589,14 @@ func newTWalk(buf []byte) *TWalk {
func (msg *TWalk) Size() uint32 {
size := uint32(4 + 1 + 2 + 4 + 4 + 2)
- for _, wname := range msg.wname {
- size += 2 + uint32(len(wname))
+ for _, wn := range msg.Wnames {
+ size += 2 + uint32(len(wn))
}
return size
}
func (msg *TWalk) Type() MsgType { return Twalk }
-func (msg *TWalk) Tag() uint16 { return msg.tag }
-func (msg *TWalk) SetTag(t uint16) { msg.tag = t }
-func (msg *TWalk) Fid() uint32 { return msg.fid }
-func (msg *TWalk) NewFid() uint32 { return msg.newFid }
-func (msg *TWalk) NWName() uint16 { return uint16(len(msg.wname)) }
-func (msg *TWalk) WName() []string { return msg.wname }
+func (msg *TWalk) GetTag() uint16 { return msg.Tag }
+func (msg *TWalk) SetTag(t uint16) { msg.Tag = t }
func (msg *TWalk) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -627,48 +604,48 @@ func (msg *TWalk) marshal() []byte {
cur += 4
buf[cur] = uint8(Twalk)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- pbit32(buf[cur:cur+4], msg.NewFid())
+ pbit32(buf[cur:cur+4], msg.Newfid)
cur += 4
- nwname := msg.NWName()
+ nwname := uint16(len(msg.Wnames))
pbit16(buf[cur:cur+2], nwname)
cur += 2
- for _, wname := range msg.WName() {
- pbit16(buf[cur:cur+2], uint16(len(wname)))
+ for _, wn := range msg.Wnames {
+ pbit16(buf[cur:cur+2], uint16(len(wn)))
cur += 2
- for i := 0; i < len(wname); i++ {
- buf[cur+i] = wname[i]
+ for i := 0; i < len(wn); i++ {
+ buf[cur+i] = wn[i]
}
- cur += len(wname)
+ cur += len(wn)
}
return buf
}
func (msg *TWalk) String() string {
- s := fmt.Sprintf("Twalk tag %d fid %d newfid %d nwname %d",
- msg.Tag(), msg.Fid(), msg.NewFid(), msg.NWName())
- for i, wname := range msg.WName() {
- s += fmt.Sprintf(" %d:%s", i, wname)
+ s := fmt.Sprintf("Twalk Tag %d fid %d newfid %d nwname %d",
+ msg.Tag, msg.Fid, msg.Newfid, len(msg.Wnames))
+ for i, wn := range msg.Wnames {
+ s += fmt.Sprintf(" %d:%s", i, wn)
}
return s
}
type RWalk struct {
- tag uint16
- qid []Qid
+ Tag uint16
+ Qids []Qid
}
func newRWalk(buf []byte) *RWalk {
msg := new(RWalk)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
nwqid := int(gbit16(buf[7:9]))
- msg.qid = make([]Qid, nwqid)
+ msg.Qids = make([]Qid, nwqid)
cur := 9
for i := 0; i < nwqid; i++ {
- msg.qid[i] = unmarshalQid(buf[cur : cur+13])
+ msg.Qids[i] = unmarshalQid(buf[cur : cur+13])
cur += 13
}
if int(msg.Size()) != cur {
@@ -677,12 +654,11 @@ func newRWalk(buf []byte) *RWalk {
return msg
}
func (msg *RWalk) Size() uint32 {
- return uint32(4 + 1 + 2 + 2 + len(msg.Qid())*13)
+ return uint32(4 + 1 + 2 + 2 + len(msg.Qids)*13)
}
func (msg *RWalk) Type() MsgType { return Rwalk }
-func (msg *RWalk) Tag() uint16 { return msg.tag }
-func (msg *RWalk) SetTag(t uint16) { msg.tag = t }
-func (msg *RWalk) Qid() []Qid { return msg.qid }
+func (msg *RWalk) GetTag() uint16 { return msg.Tag }
+func (msg *RWalk) SetTag(t uint16) { msg.Tag = t }
func (msg *RWalk) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -690,11 +666,11 @@ func (msg *RWalk) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit16(buf[cur:cur+2], uint16(len(msg.Qid())))
+ pbit16(buf[cur:cur+2], uint16(len(msg.Qids)))
cur += 2
- for _, qid := range msg.Qid() {
+ for _, qid := range msg.Qids {
for i, bit := range qid.marshal() {
buf[cur+i] = bit
}
@@ -706,17 +682,17 @@ func (msg *RWalk) marshal() []byte {
return buf
}
func (msg *RWalk) String() string {
- s := fmt.Sprintf("Rwalk tag %d nwqid %d", msg.Tag(), len(msg.Qid()))
- for i, q := range msg.Qid() {
+ s := fmt.Sprintf("Rwalk Tag %d nwqid %d", msg.Tag, len(msg.Qids))
+ for i, q := range msg.Qids {
s += fmt.Sprintf(" %d:%v", i, q)
}
return s
}
type TOpen struct {
- tag uint16
- fid uint32
- mode OpenMode
+ Tag uint16
+ Fid uint32
+ Mode OpenMode
}
func newTOpen(buf []byte) *TOpen {
@@ -725,11 +701,11 @@ func newTOpen(buf []byte) *TOpen {
size := gbit32(buf[cur : cur+4])
cur += 4
cur += 1 // type
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
- msg.mode = OpenMode(buf[cur])
+ msg.Mode = OpenMode(buf[cur])
cur += 1
if cur != int(size) {
panic("size and cursor position don't match")
@@ -738,10 +714,8 @@ func newTOpen(buf []byte) *TOpen {
}
func (msg *TOpen) Size() uint32 { return 4 + 1 + 2 + 4 + 1 }
func (msg *TOpen) Type() MsgType { return Topen }
-func (msg *TOpen) Tag() uint16 { return msg.tag }
-func (msg *TOpen) SetTag(t uint16) { msg.tag = t }
-func (msg *TOpen) Fid() uint32 { return msg.fid }
-func (msg *TOpen) Mode() OpenMode { return msg.mode }
+func (msg *TOpen) GetTag() uint16 { return msg.Tag }
+func (msg *TOpen) SetTag(t uint16) { msg.Tag = t }
func (msg *TOpen) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -749,11 +723,11 @@ func (msg *TOpen) marshal() []byte {
cur += 4
buf[cur] = uint8(Topen)
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- buf[cur] = uint8(msg.Mode())
+ buf[cur] = uint8(msg.Mode)
cur += 1
if cur != len(buf) {
panic("length of buf and cursor position don't match")
@@ -762,31 +736,29 @@ func (msg *TOpen) marshal() []byte {
}
func (msg *TOpen) String() string {
- return fmt.Sprintf("Topen tag %d fid %d mode 0x%x",
- msg.Tag(), msg.Fid(), msg.Mode())
+ return fmt.Sprintf("Topen Tag %d fid %d mode 0x%x",
+ msg.Tag, msg.Fid, msg.Mode)
}
type ROpen struct {
- tag uint16
- qid Qid
- iounit uint32
+ Tag uint16
+ Qid Qid
+ Iounit uint32
}
func newROpen(buf []byte) *ROpen {
msg := new(ROpen)
- msg.tag = gbit16(buf[5:7])
- msg.qid = unmarshalQid(buf[7:20])
- msg.iounit = gbit32(buf[20:24])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Qid = unmarshalQid(buf[7:20])
+ msg.Iounit = gbit32(buf[20:24])
return msg
}
func (msg *ROpen) Size() uint32 {
return uint32(4 + 1 + 2 + 13 + 4)
}
func (msg *ROpen) Type() MsgType { return Ropen }
-func (msg *ROpen) Tag() uint16 { return msg.tag }
-func (msg *ROpen) SetTag(t uint16) { msg.tag = t }
-func (msg *ROpen) Qid() Qid { return msg.qid }
-func (msg *ROpen) IoUnit() uint32 { return msg.iounit }
+func (msg *ROpen) GetTag() uint16 { return msg.Tag }
+func (msg *ROpen) SetTag(t uint16) { msg.Tag = t }
func (msg *ROpen) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -794,47 +766,46 @@ func (msg *ROpen) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- for i, bit := range msg.Qid().marshal() {
+ for i, bit := range msg.Qid.marshal() {
buf[cur+i] = bit
}
cur += 13
- pbit32(buf[cur:cur+4], msg.IoUnit())
+ pbit32(buf[cur:cur+4], msg.Iounit)
cur += 4
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
-
return buf
}
func (msg *ROpen) String() string {
- return fmt.Sprintf("Ropen tag %d qid %v iounit %d",
- msg.Tag(), msg.Qid(), msg.IoUnit())
+ return fmt.Sprintf("Ropen Tag %d qid %v iounit %d",
+ msg.Tag, msg.Qid, msg.Iounit)
}
type TCreate struct {
- tag uint16
- fid uint32
- name string
- perm FileMode
- mode OpenMode
+ Tag uint16
+ Fid uint32
+ Name string
+ Perm FileMode
+ Mode OpenMode
}
func newTCreate(buf []byte) *TCreate {
msg := new(TCreate)
cur := 5
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
nameSize := int(gbit16(buf[cur : cur+2]))
cur += 2
- msg.name = string(buf[cur : cur+nameSize])
+ msg.Name = string(buf[cur : cur+nameSize])
cur += nameSize
- msg.perm = FileMode(gbit32(buf[cur : cur+4]))
+ msg.Perm = FileMode(gbit32(buf[cur : cur+4]))
cur += 4
- msg.mode = OpenMode(buf[cur])
+ msg.Mode = OpenMode(buf[cur])
cur += 1
if cur != len(buf) {
panic("length and cursor position don't match")
@@ -843,15 +814,11 @@ func newTCreate(buf []byte) *TCreate {
}
func (msg *TCreate) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + 2 + len(msg.name) + 4 + 1)
+ return uint32(4 + 1 + 2 + 4 + 2 + len(msg.Name) + 4 + 1)
}
func (msg *TCreate) Type() MsgType { return Tcreate }
-func (msg *TCreate) Tag() uint16 { return msg.tag }
-func (msg *TCreate) SetTag(t uint16) { msg.tag = t }
-func (msg *TCreate) Fid() uint32 { return msg.fid }
-func (msg *TCreate) Name() string { return msg.name }
-func (msg *TCreate) Perm() FileMode { return msg.perm }
-func (msg *TCreate) Mode() OpenMode { return msg.mode }
+func (msg *TCreate) GetTag() uint16 { return msg.Tag }
+func (msg *TCreate) SetTag(t uint16) { msg.Tag = t }
func (msg *TCreate) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -859,21 +826,20 @@ func (msg *TCreate) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- nameSize := len(msg.Name())
+ nameSize := len(msg.Name)
pbit16(buf[cur:cur+2], uint16(nameSize))
cur += 2
- name := msg.Name()
for i := 0; i < nameSize; i++ {
- buf[cur+i] = name[i]
+ buf[cur+i] = msg.Name[i]
}
cur += nameSize
- pbit32(buf[cur:cur+4], uint32(msg.Perm()))
+ pbit32(buf[cur:cur+4], uint32(msg.Perm))
cur += 4
- buf[cur] = uint8(msg.Mode())
+ buf[cur] = uint8(msg.Mode)
cur += 1
if cur != len(buf) {
panic("length of buf and cursor position don't match")
@@ -882,31 +848,29 @@ func (msg *TCreate) marshal() []byte {
}
func (msg *TCreate) String() string {
- return fmt.Sprintf("Tcreate tag %d fid %d name %s perm %v mode 0x%x",
- msg.Tag(), msg.Fid(), msg.Name(), permString(msg.Perm()), msg.Mode())
+ return fmt.Sprintf("Tcreate Tag %d fid %d name %s perm %v mode 0x%x",
+ msg.Tag, msg.Fid, msg.Name, permString(msg.Perm), msg.Mode)
}
type RCreate struct {
- tag uint16
- qid Qid
- iounit uint32
+ Tag uint16
+ Qid Qid
+ Iounit uint32
}
func newRCreate(buf []byte) *RCreate {
msg := new(RCreate)
- msg.tag = gbit16(buf[5:7])
- msg.qid = unmarshalQid(buf[7:20])
- msg.iounit = gbit32(buf[20:24])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Qid = unmarshalQid(buf[7:20])
+ msg.Iounit = gbit32(buf[20:24])
return msg
}
func (msg *RCreate) Size() uint32 {
return uint32(4 + 1 + 2 + 13 + 4)
}
func (msg *RCreate) Type() MsgType { return Rcreate }
-func (msg *RCreate) Tag() uint16 { return msg.tag }
-func (msg *RCreate) SetTag(t uint16) { msg.tag = t }
-func (msg *RCreate) Qid() Qid { return msg.qid }
-func (msg *RCreate) IoUnit() uint32 { return msg.iounit }
+func (msg *RCreate) GetTag() uint16 { return msg.Tag }
+func (msg *RCreate) SetTag(t uint16) { msg.Tag = t }
func (msg *RCreate) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -914,30 +878,29 @@ func (msg *RCreate) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- for i, bit := range msg.Qid().marshal() {
+ for i, bit := range msg.Qid.marshal() {
buf[cur+i] = bit
}
cur += 13
- pbit32(buf[cur:cur+4], msg.IoUnit())
+ pbit32(buf[cur:cur+4], msg.Iounit)
cur += 4
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
-
return buf
}
func (msg *RCreate) String() string {
- return fmt.Sprintf("Rcreate tag %d qid %v iounit %d",
- msg.Tag(), msg.Qid(), msg.IoUnit())
+ return fmt.Sprintf("Rcreate Tag %d qid %v iounit %d",
+ msg.Tag, msg.Qid, msg.Iounit)
}
type TRead struct {
- tag uint16
- fid uint32
- offset uint64
- count uint32
+ Tag uint16
+ Fid uint32
+ Offset uint64
+ Count uint32
}
func newTRead(buf []byte) *TRead {
@@ -946,13 +909,13 @@ func newTRead(buf []byte) *TRead {
size := gbit32(buf[cur : cur+4])
cur += 4
cur += 1 // type
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
- msg.offset = gbit64(buf[cur : cur+8])
+ msg.Offset = gbit64(buf[cur : cur+8])
cur += 8
- msg.count = gbit32(buf[cur : cur+4])
+ msg.Count = gbit32(buf[cur : cur+4])
cur += 4
if cur != int(size) {
panic(fmt.Errorf("size %d != cursor position %d", size, cur))
@@ -961,11 +924,8 @@ func newTRead(buf []byte) *TRead {
}
func (msg *TRead) Size() uint32 { return 4 + 1 + 2 + 4 + 8 + 4 }
func (msg *TRead) Type() MsgType { return Tread }
-func (msg *TRead) Tag() uint16 { return msg.tag }
-func (msg *TRead) SetTag(t uint16) { msg.tag = t }
-func (msg *TRead) Fid() uint32 { return msg.fid }
-func (msg *TRead) Offset() uint64 { return msg.offset }
-func (msg *TRead) Count() uint32 { return msg.count }
+func (msg *TRead) GetTag() uint16 { return msg.Tag }
+func (msg *TRead) SetTag(t uint16) { msg.Tag = t }
func (msg *TRead) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -973,13 +933,13 @@ func (msg *TRead) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- pbit64(buf[cur:cur+8], msg.Offset())
+ pbit64(buf[cur:cur+8], msg.Offset)
cur += 8
- pbit32(buf[cur:cur+4], msg.Count())
+ pbit32(buf[cur:cur+4], msg.Count)
cur += 4
if cur != len(buf) {
panic("length of buf and cursor position don't match")
@@ -987,38 +947,36 @@ func (msg *TRead) marshal() []byte {
return buf
}
func (msg *TRead) String() string {
- return fmt.Sprintf("Tread tag %d fid %d offset %d count %d",
- msg.Tag(), msg.Fid(), msg.Offset(), msg.Count())
+ return fmt.Sprintf("Tread Tag %d fid %d offset %d count %d",
+ msg.Tag, msg.Fid, msg.Offset, msg.Count)
}
type RRead struct {
- tag uint16
- count uint32
- data []byte
+ Tag uint16
+ Count uint32
+ Data []byte
}
func newRRead(buf []byte) *RRead {
msg := new(RRead)
- msg.tag = gbit16(buf[5:7])
- msg.count = gbit32(buf[7:11])
- msg.data = make([]byte, msg.count)
- for i := 0; i < int(msg.count); i++ {
- msg.data[i] = buf[11+i]
+ msg.Tag = gbit16(buf[5:7])
+ msg.Count = gbit32(buf[7:11])
+ msg.Data = make([]byte, msg.Count)
+ for i := 0; i < int(msg.Count); i++ {
+ msg.Data[i] = buf[11+i]
}
return msg
}
func (msg *RRead) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + msg.Count())
+ return uint32(4 + 1 + 2 + 4 + msg.Count)
}
func (msg *RRead) Type() MsgType { return Rread }
-func (msg *RRead) Tag() uint16 { return msg.tag }
-func (msg *RRead) SetTag(t uint16) { msg.tag = t }
-func (msg *RRead) Count() uint32 { return msg.count }
-func (msg *RRead) Data() []byte { return msg.data }
+func (msg *RRead) GetTag() uint16 { return msg.Tag }
+func (msg *RRead) SetTag(t uint16) { msg.Tag = t }
func (msg *RRead) marshal() []byte {
- if uint32(len(msg.Data())) != msg.Count() {
+ if uint32(len(msg.Data)) != msg.Count {
panic(fmt.Errorf("data size %d and count %d don't match",
- len(msg.Data()), msg.Count()))
+ len(msg.Data), msg.Count))
}
cur := 0
buf := make([]byte, msg.Size())
@@ -1026,78 +984,73 @@ func (msg *RRead) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Count())
+ pbit32(buf[cur:cur+4], msg.Count)
cur += 4
- data := msg.Data()
- for i := 0; i < len(data); i++ {
- buf[cur+i] = data[i]
+ for i := 0; i < len(msg.Data); i++ {
+ buf[cur+i] = msg.Data[i]
}
- cur += len(data)
+ cur += len(msg.Data)
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
return buf
}
func (msg *RRead) String() string {
- s := fmt.Sprintf("Rread tag %d count %d '",
- msg.Tag(), msg.Count())
- data := msg.Data()
+ s := fmt.Sprintf("Rread Tag %d count %d '",
+ msg.Tag, msg.Count)
i := 0
- for ; i+4 < len(data) && i < 64; i += 4 {
- s += fmt.Sprintf(" %02x%02x%02x%02x", uint8(data[i]), uint8(data[i+1]),
- uint8(data[i+2]), uint8(data[i+3]))
+ for ; i+4 < len(msg.Data) && i < 64; i += 4 {
+ s += fmt.Sprintf(" %02x%02x%02x%02x",
+ uint8(msg.Data[i]), uint8(msg.Data[i+1]),
+ uint8(msg.Data[i+2]), uint8(msg.Data[i+3]))
}
- if i != len(data) && i != 64 {
+ if i != len(msg.Data) && i != 64 {
s += " "
}
- for ; i < len(data) && i < 64; i++ {
- s += fmt.Sprintf("%02x", uint8(data[i]))
+ for ; i < len(msg.Data) && i < 64; i++ {
+ s += fmt.Sprintf("%02x", uint8(msg.Data[i]))
}
s += "'"
return s
}
type TWrite struct {
- tag uint16
- fid uint32
- offset uint64
- count uint32
- data []byte
+ Tag uint16
+ Fid uint32
+ Offset uint64
+ Count uint32
+ Data []byte
}
func newTWrite(buf []byte) *TWrite {
cur := 5
msg := new(TWrite)
- msg.tag = gbit16(buf[cur : cur+2])
+ msg.Tag = gbit16(buf[cur : cur+2])
cur += 2
- msg.fid = gbit32(buf[cur : cur+4])
+ msg.Fid = gbit32(buf[cur : cur+4])
cur += 4
- msg.offset = gbit64(buf[cur : cur+8])
+ msg.Offset = gbit64(buf[cur : cur+8])
cur += 8
- msg.count = gbit32(buf[cur : cur+4])
+ msg.Count = gbit32(buf[cur : cur+4])
cur += 4
- msg.data = make([]byte, msg.count)
- for i := 0; i < int(msg.count); i++ {
- msg.data[i] = buf[cur+i]
+ msg.Data = make([]byte, msg.Count)
+ for i := 0; i < int(msg.Count); i++ {
+ msg.Data[i] = buf[cur+i]
}
- cur += int(msg.count)
+ cur += int(msg.Count)
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
return msg
}
func (msg *TWrite) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + 8 + 4 + len(msg.Data()))
+ return uint32(4 + 1 + 2 + 4 + 8 + 4 + len(msg.Data))
}
func (msg *TWrite) Type() MsgType { return Twrite }
-func (msg *TWrite) Tag() uint16 { return msg.tag }
-func (msg *TWrite) SetTag(t uint16) { msg.tag = t }
-func (msg *TWrite) Fid() uint32 { return msg.fid }
-func (msg *TWrite) Offset() uint64 { return msg.offset }
-func (msg *TWrite) Count() uint32 { return msg.count }
-func (msg *TWrite) Data() []byte { return msg.data }
+func (msg *TWrite) GetTag() uint16 { return msg.Tag }
+func (msg *TWrite) SetTag(t uint16) { msg.Tag = t }
func (msg *TWrite) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -1105,46 +1058,45 @@ func (msg *TWrite) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Fid())
+ pbit32(buf[cur:cur+4], msg.Fid)
cur += 4
- pbit64(buf[cur:cur+8], msg.Offset())
+ pbit64(buf[cur:cur+8], msg.Offset)
cur += 8
- pbit32(buf[cur:cur+4], msg.Count())
+ pbit32(buf[cur:cur+4], msg.Count)
cur += 4
- for i := 0; i < int(msg.Count()); i++ {
- buf[cur+i] = msg.data[i]
+ for i := 0; i < int(msg.Count); i++ {
+ buf[cur+i] = msg.Data[i]
}
- cur += int(msg.Count())
+ cur += int(msg.Count)
if cur != len(buf) {
panic("length of buf and cursor position don't match")
}
return buf
}
func (msg *TWrite) String() string {
- return fmt.Sprintf("Twrite tag %d fid %d offset %d count %d '%s'",
- msg.Tag(), msg.Fid(), msg.Offset(), msg.Count(), msg.Data())
+ return fmt.Sprintf("Twrite Tag %d fid %d offset %d count %d '%s'",
+ msg.Tag, msg.Fid, msg.Offset, msg.Count, msg.Data)
}
type RWrite struct {
- tag uint16
- count uint32
+ Tag uint16
+ Count uint32
}
func newRWrite(buf []byte) *RWrite {
msg := new(RWrite)
- msg.tag = gbit16(buf[5:7])
- msg.count = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Count = gbit32(buf[7:11])
return msg
}
func (msg *RWrite) Size() uint32 {
return uint32(4 + 1 + 2 + 4)
}
func (msg *RWrite) Type() MsgType { return Rwrite }
-func (msg *RWrite) Tag() uint16 { return msg.tag }
-func (msg *RWrite) SetTag(t uint16) { msg.tag = t }
-func (msg *RWrite) Count() uint32 { return msg.count }
+func (msg *RWrite) GetTag() uint16 { return msg.Tag }
+func (msg *RWrite) SetTag(t uint16) { msg.Tag = t }
func (msg *RWrite) marshal() []byte {
cur := 0
buf := make([]byte, msg.Size())
@@ -1152,9 +1104,9 @@ func (msg *RWrite) marshal() []byte {
cur += 4
buf[cur] = uint8(msg.Type())
cur += 1
- pbit16(buf[cur:cur+2], msg.Tag())
+ pbit16(buf[cur:cur+2], msg.Tag)
cur += 2
- pbit32(buf[cur:cur+4], msg.Count())
+ pbit32(buf[cur:cur+4], msg.Count)
cur += 4
if cur != len(buf) {
panic("length of buf and cursor position don't match")
@@ -1163,170 +1115,166 @@ func (msg *RWrite) marshal() []byte {
}
func (msg *RWrite) String() string {
- return fmt.Sprintf("Rwrite tag %d count %d", msg.Tag(), msg.Count())
+ return fmt.Sprintf("Rwrite Tag %d count %d", msg.Tag, msg.Count)
}
type TClunk struct {
- tag uint16
- fid uint32
+ Tag uint16
+ Fid uint32
}
func newTClunk(buf []byte) *TClunk {
msg := new(TClunk)
- msg.tag = gbit16(buf[5:7])
- msg.fid = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Fid = gbit32(buf[7:11])
return msg
}
func (msg *TClunk) Size() uint32 { return 4 + 1 + 2 + 4 }
func (msg *TClunk) Type() MsgType { return Tclunk }
-func (msg *TClunk) Tag() uint16 { return msg.tag }
-func (msg *TClunk) SetTag(t uint16) { msg.tag = t }
-func (msg *TClunk) Fid() uint32 { return msg.fid }
+func (msg *TClunk) GetTag() uint16 { return msg.Tag }
+func (msg *TClunk) SetTag(t uint16) { msg.Tag = t }
func (msg *TClunk) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(Tclunk)
- pbit16(m[5:7], msg.Tag())
- pbit32(m[7:11], msg.Fid())
+ pbit16(m[5:7], msg.Tag)
+ pbit32(m[7:11], msg.Fid)
return m
}
func (msg *TClunk) String() string {
- return fmt.Sprintf("Tclunk tag %d fid %d",
- msg.Tag(), msg.Fid())
+ return fmt.Sprintf("Tclunk Tag %d fid %d",
+ msg.Tag, msg.Fid)
}
type RClunk struct {
- tag uint16
+ Tag uint16
}
func newRClunk(buf []byte) *RClunk {
msg := new(RClunk)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
return msg
}
func (msg *RClunk) Size() uint32 { return 7 }
func (msg *RClunk) Type() MsgType { return Rclunk }
-func (msg *RClunk) Tag() uint16 { return msg.tag }
-func (msg *RClunk) SetTag(t uint16) { msg.tag = t }
+func (msg *RClunk) GetTag() uint16 { return msg.Tag }
+func (msg *RClunk) SetTag(t uint16) { msg.Tag = t }
func (msg *RClunk) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(Rclunk)
- pbit16(m[5:7], msg.Tag())
+ pbit16(m[5:7], msg.Tag)
return m
}
func (msg *RClunk) String() string {
- return fmt.Sprintf("Rclunk tag %d", msg.Tag())
+ return fmt.Sprintf("Rclunk Tag %d", msg.Tag)
}
type TRemove struct {
- tag uint16
- fid uint32
+ Tag uint16
+ Fid uint32
}
func newTRemove(buf []byte) *TRemove {
msg := new(TRemove)
- msg.tag = gbit16(buf[5:7])
- msg.fid = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Fid = gbit32(buf[7:11])
return msg
}
func (msg *TRemove) Size() uint32 { return 4 + 1 + 2 + 4 }
func (msg *TRemove) Type() MsgType { return Tremove }
-func (msg *TRemove) Tag() uint16 { return msg.tag }
-func (msg *TRemove) SetTag(t uint16) { msg.tag = t }
-func (msg *TRemove) Fid() uint32 { return msg.fid }
+func (msg *TRemove) GetTag() uint16 { return msg.Tag }
+func (msg *TRemove) SetTag(t uint16) { msg.Tag = t }
func (msg *TRemove) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(msg.Type())
- pbit16(m[5:7], msg.Tag())
- pbit32(m[7:11], msg.Fid())
+ pbit16(m[5:7], msg.Tag)
+ pbit32(m[7:11], msg.Fid)
return m
}
func (msg *TRemove) String() string {
- return fmt.Sprintf("Tremove tag %d fid %d", msg.Tag(), msg.Fid())
+ return fmt.Sprintf("Tremove Tag %d fid %d", msg.Tag, msg.Fid)
}
type RRemove struct {
- tag uint16
+ Tag uint16
}
func newRRemove(buf []byte) *RRemove {
msg := new(RRemove)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
return msg
}
func (msg *RRemove) Size() uint32 { return 4 + 1 + 2 }
func (msg *RRemove) Type() MsgType { return Rremove }
-func (msg *RRemove) Tag() uint16 { return msg.tag }
-func (msg *RRemove) SetTag(t uint16) { msg.tag = t }
+func (msg *RRemove) GetTag() uint16 { return msg.Tag }
+func (msg *RRemove) SetTag(t uint16) { msg.Tag = t }
func (msg *RRemove) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(msg.Type())
- pbit16(m[5:7], msg.Tag())
+ pbit16(m[5:7], msg.Tag)
return m
}
func (msg *RRemove) String() string {
- return fmt.Sprintf("Rremove tag %d", msg.Tag())
+ return fmt.Sprintf("Rremove Tag %d", msg.Tag)
}
type TStat struct {
- tag uint16
- fid uint32
+ Tag uint16
+ Fid uint32
}
func newTStat(buf []byte) *TStat {
msg := new(TStat)
- msg.tag = gbit16(buf[5:7])
- msg.fid = gbit32(buf[7:11])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Fid = gbit32(buf[7:11])
return msg
}
func (msg *TStat) Size() uint32 { return 4 + 1 + 2 + 4 }
func (msg *TStat) Type() MsgType { return Tstat }
-func (msg *TStat) Tag() uint16 { return msg.tag }
-func (msg *TStat) SetTag(t uint16) { msg.tag = t }
-func (msg *TStat) Fid() uint32 { return msg.fid }
+func (msg *TStat) GetTag() uint16 { return msg.Tag }
+func (msg *TStat) SetTag(t uint16) { msg.Tag = t }
func (msg *TStat) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(Tstat)
- pbit16(m[5:7], msg.Tag())
- pbit32(m[7:11], msg.Fid())
+ pbit16(m[5:7], msg.Tag)
+ pbit32(m[7:11], msg.Fid)
return m
}
func (msg *TStat) String() string {
- return fmt.Sprintf("Tstat tag %d fid %d",
- msg.Tag(), msg.Fid())
+ return fmt.Sprintf("Tstat Tag %d fid %d",
+ msg.Tag, msg.Fid)
}
type RStat struct {
- tag uint16
- stat *Stat
+ Tag uint16
+ Stat *Stat
}
func newRStat(buf []byte) *RStat {
msg := new(RStat)
size := gbit32(buf[:4])
- msg.tag = gbit16(buf[5:7])
- msg.stat = newStat(buf[9:size])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Stat = newStat(buf[9:size])
return msg
}
func (msg *RStat) Size() uint32 {
- return uint32(4 + 1 + 2 + 2 + 2 + msg.stat.size())
+ return uint32(4 + 1 + 2 + 2 + 2 + msg.Stat.size())
}
func (msg *RStat) Type() MsgType { return Rstat }
-func (msg *RStat) Tag() uint16 { return msg.tag }
-func (msg *RStat) SetTag(t uint16) { msg.tag = t }
+func (msg *RStat) GetTag() uint16 { return msg.Tag }
+func (msg *RStat) SetTag(t uint16) { msg.Tag = t }
func (msg *RStat) marshal() []byte {
buf := make([]byte, msg.Size())
pbit32(buf[0:4], msg.Size())
buf[4] = uint8(Rstat)
- pbit16(buf[5:7], msg.Tag())
-
- fiBuf := msg.stat.marshal()
+ pbit16(buf[5:7], msg.Tag)
+ fiBuf := msg.Stat.marshal()
pbit16(buf[7:9], uint16(len(fiBuf)))
for i := 0; i < len(fiBuf); i++ {
buf[9+i] = fiBuf[i]
@@ -1335,38 +1283,35 @@ func (msg *RStat) marshal() []byte {
}
func (msg *RStat) String() string {
- return fmt.Sprintf("Rstat tag %d stat %s", msg.Tag(), msg.stat)
+ return fmt.Sprintf("Rstat Tag %d stat %s", msg.Tag, msg.Stat)
}
type TWStat struct {
- tag uint16
- fid uint32
- stat *Stat
+ Tag uint16
+ Fid uint32
+ Stat *Stat
}
func newTWStat(buf []byte) *TWStat {
msg := new(TWStat)
- msg.tag = gbit16(buf[5:7])
- msg.fid = gbit32(buf[7:11])
- msg.stat = newStat(buf[13:])
+ msg.Tag = gbit16(buf[5:7])
+ msg.Fid = gbit32(buf[7:11])
+ msg.Stat = newStat(buf[13:])
return msg
}
func (msg *TWStat) Size() uint32 {
- return uint32(4 + 1 + 2 + 4 + 2 + 2 + msg.stat.size())
+ return uint32(4 + 1 + 2 + 4 + 2 + 2 + msg.Stat.size())
}
func (msg *TWStat) Type() MsgType { return Twstat }
-func (msg *TWStat) Tag() uint16 { return msg.tag }
-func (msg *TWStat) SetTag(t uint16) { msg.tag = t }
-func (msg *TWStat) Fid() uint32 { return msg.fid }
-func (msg *TWStat) Stat() *Stat { return msg.stat }
+func (msg *TWStat) GetTag() uint16 { return msg.Tag }
+func (msg *TWStat) SetTag(t uint16) { msg.Tag = t }
func (msg *TWStat) marshal() []byte {
buf := make([]byte, msg.Size())
pbit32(buf[0:4], msg.Size())
buf[4] = uint8(msg.Type())
- pbit16(buf[5:7], msg.Tag())
- pbit32(buf[7:11], msg.Fid())
-
- fiBuf := msg.stat.marshal()
+ pbit16(buf[5:7], msg.Tag)
+ pbit32(buf[7:11], msg.Fid)
+ fiBuf := msg.Stat.marshal()
pbit16(buf[11:13], uint16(len(fiBuf)))
for i := 0; i < len(fiBuf); i++ {
buf[13+i] = fiBuf[i]
@@ -1375,29 +1320,29 @@ func (msg *TWStat) marshal() []byte {
}
func (msg *TWStat) String() string {
- return fmt.Sprintf("Twstat tag %d fid %d stat %s", msg.Tag(), msg.Fid(), msg.stat)
+ return fmt.Sprintf("Twstat Tag %d fid %d stat %s", msg.Tag, msg.Fid, msg.Stat)
}
type RWStat struct {
- tag uint16
+ Tag uint16
}
func newRWStat(buf []byte) *RWStat {
msg := new(RWStat)
- msg.tag = gbit16(buf[5:7])
+ msg.Tag = gbit16(buf[5:7])
return msg
}
func (msg *RWStat) Size() uint32 { return 4 + 1 + 2 }
func (msg *RWStat) Type() MsgType { return Rwstat }
-func (msg *RWStat) Tag() uint16 { return msg.tag }
-func (msg *RWStat) SetTag(t uint16) { msg.tag = t }
+func (msg *RWStat) GetTag() uint16 { return msg.Tag }
+func (msg *RWStat) SetTag(t uint16) { msg.Tag = t }
func (msg *RWStat) marshal() []byte {
m := make([]byte, msg.Size())
pbit32(m[0:4], msg.Size())
m[4] = uint8(msg.Type())
- pbit16(m[5:7], msg.Tag())
+ pbit16(m[5:7], msg.Tag)
return m
}
func (msg *RWStat) String() string {
- return fmt.Sprintf("Rwstat tag %d", msg.Tag())
+ return fmt.Sprintf("Rwstat Tag %d", msg.Tag)
}
diff --git a/server.go b/server.go
@@ -24,7 +24,7 @@ var (
func setError(r *Req, err error) {
r.ofcall = &RError{
- ename: err,
+ Ename: err,
}
}
@@ -157,7 +157,7 @@ func getReq(r io.Reader, s *Server) (*Req, error) {
}
return nil, fmt.Errorf("recv: %v", err)
}
- req, err := s.rPool.add(bufMsg(buf).Tag())
+ req, err := s.rPool.add(bufMsg(buf).GetTag())
if err != nil {
// duplicate tag: cons up a fake Req
req := new(Req)
@@ -173,7 +173,7 @@ func getReq(r io.Reader, s *Server) (*Req, error) {
return req, ErrDupTag
}
req.srv = s
- req.tag = bufMsg(buf).Tag()
+ req.tag = bufMsg(buf).GetTag()
req.ifcall, err = unmarshal(buf)
if err != nil {
log.Printf("unmarshal: %v", err)
@@ -184,7 +184,7 @@ func getReq(r io.Reader, s *Server) (*Req, error) {
return req, err
}
if ifcall, ok := req.ifcall.(*TFlush); ok {
- req.oldReq, _ = req.srv.rPool.lookup(ifcall.OldTag())
+ req.oldReq, _ = req.srv.rPool.lookup(ifcall.Oldtag)
}
if s.chatty9P {
fmt.Fprintf(os.Stderr, "<-- %v\n", req.ifcall)
@@ -202,19 +202,19 @@ func getReq(r io.Reader, s *Server) (*Req, error) {
// serving new Tversion.
func sVersion(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TVersion)
- version := ifcall.Version()
+ version := ifcall.Version
if ok := strings.HasPrefix(version, "9P2000"); !ok {
version = "unknown"
} else {
version = "9P2000"
}
- msize := ifcall.MSize()
+ msize := ifcall.Msize
if msize > s.mSize() {
msize = s.mSize()
}
r.ofcall = &RVersion{
- mSize: msize,
- version: version,
+ Msize: msize,
+ Version: version,
}
respond(ctx, r, nil)
}
@@ -225,14 +225,14 @@ func rVersion(r *Req, err error) {
if err != nil {
panic(fmt.Errorf("rVersion err: %w", err))
}
- r.srv.setMSize(r.ofcall.(*RVersion).MSize())
+ r.srv.setMSize(r.ofcall.(*RVersion).Msize)
}
// sAuth serves Tauth message.
func sAuth(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TAuth)
var err error
- r.afid, err = s.fPool.add(ifcall.AFid())
+ r.afid, err = s.fPool.add(ifcall.Afid)
if err != nil {
respond(ctx, r, ErrDupFid)
}
@@ -244,32 +244,32 @@ func sAuth(ctx context.Context, s *Server, r *Req) {
}
}
-// rAuth checks if err is nil, and if not, it deletes the
+// rAuth checks if err is nil, and if not, it deletes the
// allocated fid from fPool.
func rAuth(r *Req, err error) {
if err != nil {
- r.srv.fPool.delete(r.ifcall.(*TAuth).AFid())
+ r.srv.fPool.delete(r.ifcall.(*TAuth).Afid)
setError(r, err)
}
}
func sAttach(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TAttach)
- fid, err := s.fPool.add(ifcall.Fid())
+ fid, err := s.fPool.add(ifcall.Fid)
if err != nil {
respond(ctx, r, ErrDupFid)
return
}
switch {
- case s.Auth == nil && ifcall.AFid() == NOFID:
- case s.Auth == nil && ifcall.AFid() != NOFID:
+ case s.Auth == nil && ifcall.Afid == NOFID:
+ case s.Auth == nil && ifcall.Afid != NOFID:
respond(ctx, r, ErrBotch)
return
- case s.Auth != nil && ifcall.AFid() == NOFID:
+ case s.Auth != nil && ifcall.Afid == NOFID:
respond(ctx, r, fmt.Errorf("authentication required"))
return
- case s.Auth != nil && ifcall.AFid() != NOFID:
- afid, ok := s.fPool.lookup(ifcall.AFid())
+ case s.Auth != nil && ifcall.Afid != NOFID:
+ afid, ok := s.fPool.lookup(ifcall.Afid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -289,7 +289,7 @@ func sAttach(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, fmt.Errorf("open root: %v", err))
return
}
- fid.Uid = ifcall.UName()
+ fid.Uid = ifcall.Uname
fid.OMode = -1 // TODO: right?
st, err := fid.File.Stat()
if err != nil {
@@ -297,14 +297,14 @@ func sAttach(ctx context.Context, s *Server, r *Req) {
return
}
r.ofcall = &RAttach{
- qid: st.Sys().(*Stat).Qid,
+ Qid: st.Sys().(*Stat).Qid,
}
respond(ctx, r, nil)
}
func rAttach(r *Req, err error) {
if err != nil {
- r.srv.fPool.delete(r.ifcall.(*TAttach).Fid())
+ r.srv.fPool.delete(r.ifcall.(*TAttach).Fid)
setError(r, err)
}
}
@@ -325,7 +325,7 @@ func rFlush(r *Req, err error) {
func sWalk(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TWalk)
- oldFid, ok := s.fPool.lookup(ifcall.Fid())
+ oldFid, ok := s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -339,28 +339,28 @@ func sWalk(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, fmt.Errorf("stat: %v", err))
return
}
- if ifcall.NWName() > 0 && oldst.Sys().(*Stat).Qid.Type&QTDIR == 0 {
+ if len(ifcall.Wnames) > 0 && oldst.Sys().(*Stat).Qid.Type&QTDIR == 0 {
respond(ctx, r, fmt.Errorf("walk on non-dir"))
return
}
var newFid *Fid
- if ifcall.Fid() == ifcall.NewFid() {
+ if ifcall.Fid == ifcall.Newfid {
newFid = oldFid
} else {
var err error
- newFid, err = s.fPool.add(ifcall.NewFid())
+ newFid, err = s.fPool.add(ifcall.Newfid)
if err != nil {
log.Printf("alloc: %v", err)
respond(ctx, r, fmt.Errorf("internal error"))
return
}
}
- wqids := make([]Qid, ifcall.NWName())
+ wqids := make([]Qid, len(ifcall.Wnames))
cwdp := oldFid.path
cwdf := oldFid.File
err = nil
var n int
- for i, name := range ifcall.WName() {
+ for i, name := range ifcall.Wnames {
cwdp = path.Join(cwdp, name)
cwdf, err = s.fs.OpenFile(cwdp, OREAD, 0)
if err != nil {
@@ -379,7 +379,7 @@ func sWalk(ctx context.Context, s *Server, r *Req) {
newFid.Uid = oldFid.Uid
newFid.path = cwdp
r.ofcall = &RWalk{
- qid: wqids[:n],
+ Qids: wqids[:n],
}
respond(ctx, r, nil)
}
@@ -387,12 +387,12 @@ func sWalk(ctx context.Context, s *Server, r *Req) {
func rWalk(r *Req, err error) {
ifcall := r.ifcall.(*TWalk)
ofcall := r.ofcall.(*RWalk)
- if err != nil || len(ofcall.Qid()) < int(ifcall.NWName()) {
- if ifcall.Fid() != ifcall.NewFid() {
- r.srv.fPool.delete(ifcall.NewFid())
+ if err != nil || len(ofcall.Qids) < len(ifcall.Wnames) {
+ if ifcall.Fid != ifcall.Newfid {
+ r.srv.fPool.delete(ifcall.Newfid)
}
- if len(ofcall.Qid()) == 0 {
- if err == nil && ifcall.NWName() != 0 {
+ if len(ofcall.Qids) == 0 {
+ if err == nil && len(ifcall.Wnames) != 0 {
setError(r, ErrNotFound)
return
}
@@ -403,7 +403,7 @@ func rWalk(r *Req, err error) {
func sOpen(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TOpen)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -422,12 +422,12 @@ func sOpen(ctx context.Context, s *Server, r *Req) {
return
}
qid := st.Sys().(*Stat).Qid
- if qid.Type == QTDIR && ifcall.Mode() != OREAD {
+ if qid.Type == QTDIR && ifcall.Mode != OREAD {
respond(ctx, r, fmt.Errorf("is a directory"))
return
}
var p fs.FileMode
- switch ifcall.Mode() & 3 {
+ switch ifcall.Mode & 3 {
default:
panic("invalid mode")
case OREAD:
@@ -439,7 +439,7 @@ func sOpen(ctx context.Context, s *Server, r *Req) {
case OEXEC:
p = AEXEC
}
- if ifcall.Mode()&OTRUNC != 0 {
+ if ifcall.Mode&OTRUNC != 0 {
p |= AWRITE
}
if qid.Type&QTDIR != 0 && p != AREAD {
@@ -450,7 +450,7 @@ func sOpen(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, ErrPerm)
return
}
- if ifcall.Mode()&ORCLOSE != 0 {
+ if ifcall.Mode&ORCLOSE != 0 {
parentPath := path.Dir(r.fid.path)
parent, err := s.fs.OpenFile(parentPath, OREAD, 0)
defer parent.Close()
@@ -464,8 +464,8 @@ func sOpen(ctx context.Context, s *Server, r *Req) {
}
}
r.ofcall = &ROpen{
- qid: qid,
- iounit: s.mSize() - IOHDRSZ,
+ Qid: qid,
+ Iounit: s.mSize() - IOHDRSZ,
}
respond(ctx, r, nil)
}
@@ -475,7 +475,7 @@ func rOpen(r *Req, err error) {
setError(r, err)
return
}
- r.fid.OMode = r.ifcall.(*TOpen).Mode()
+ r.fid.OMode = r.ifcall.(*TOpen).Mode
f, err := r.srv.fs.OpenFile(r.fid.path, r.fid.OMode, 0)
if err != nil {
setError(r, err)
@@ -487,7 +487,7 @@ func rOpen(r *Req, err error) {
func sCreate(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TCreate)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -511,14 +511,14 @@ func sCreate(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, ErrOperation)
return
}
- perm := ifcall.Perm()
+ perm := ifcall.Perm
dirperm := dirstat.Mode()
if perm&fs.ModeDir == 0 {
perm &= ^FileMode(0666) | (dirperm & FileMode(0666))
} else {
perm &= ^FileMode(0777) | (dirperm & FileMode(0777))
}
- file, err := cfdir.Create(ifcall.Name(), r.fid.Uid, ifcall.Mode(), perm)
+ file, err := cfdir.Create(ifcall.Name, r.fid.Uid, ifcall.Mode, perm)
if err != nil {
respond(ctx, r, fmt.Errorf("create: %v", err))
return
@@ -528,15 +528,15 @@ func sCreate(ctx context.Context, s *Server, r *Req) {
return
}
r.fid.File = file
- r.fid.path = path.Join(r.fid.path, ifcall.Name())
+ r.fid.path = path.Join(r.fid.path, ifcall.Name)
st, err := r.fid.File.Stat()
if err != nil {
respond(ctx, r, fmt.Errorf("stat: %v", err))
return
}
r.ofcall = &RCreate{
- qid: st.Sys().(*Stat).Qid,
- iounit: s.mSize() - IOHDRSZ,
+ Qid: st.Sys().(*Stat).Qid,
+ Iounit: s.mSize() - IOHDRSZ,
}
respond(ctx, r, nil)
}
@@ -545,7 +545,7 @@ func rCreate(r *Req, err error) {
setError(r, err)
return
}
- r.fid.OMode = r.ifcall.(*TCreate).Mode()
+ r.fid.OMode = r.ifcall.(*TCreate).Mode
// TODO: pass OCREATE with non 0 perm.
f, err := r.srv.fs.OpenFile(r.fid.path, r.fid.OMode, 0)
if err != nil {
@@ -558,7 +558,7 @@ func rCreate(r *Req, err error) {
func sRead(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TRead)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -571,7 +571,7 @@ func sRead(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, ErrPerm)
return
}
- data := make([]byte, ifcall.Count())
+ data := make([]byte, ifcall.Count)
done := make(chan struct{})
var (
n int
@@ -597,11 +597,11 @@ func sRead(ctx context.Context, s *Server, r *Req) {
log.Printf("get children: %v", err)
}
- if ifcall.Offset() != 0 && ifcall.Offset() != r.fid.dirOffset {
+ if ifcall.Offset != 0 && ifcall.Offset != r.fid.dirOffset {
respond(ctx, r, fmt.Errorf("invalid dir offset"))
return
}
- if ifcall.Offset() == 0 {
+ if ifcall.Offset == 0 {
r.fid.dirIndex = 0
r.fid.dirOffset = 0
}
@@ -629,7 +629,7 @@ func sRead(ctx context.Context, s *Server, r *Req) {
r.fid.dirIndex = k
} else {
if reader, ok := r.fid.File.(io.ReaderAt); ok {
- n, err = reader.ReadAt(data, int64(ifcall.Offset()))
+ n, err = reader.ReadAt(data, int64(ifcall.Offset))
} else {
n, err = r.fid.File.Read(data)
}
@@ -645,8 +645,8 @@ func sRead(ctx context.Context, s *Server, r *Req) {
case <-ctx.Done():
}
r.ofcall = &RRead{
- count: uint32(n),
- data: data[:n],
+ Count: uint32(n),
+ Data: data[:n],
}
respond(ctx, r, nil)
}
@@ -659,15 +659,13 @@ func rRead(r *Req, err error) {
func sWrite(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TWrite)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
}
- // TODO: should I use exported function instead of directly
- // accessing the struct field?
- if ifcall.count > s.mSize()-IOHDRSZ {
- ifcall.count = s.mSize() - IOHDRSZ
+ if ifcall.Count > s.mSize()-IOHDRSZ {
+ ifcall.Count = s.mSize() - IOHDRSZ
}
if !hasPerm(r.fid.File, r.fid.Uid, AWRITE) {
respond(ctx, r, ErrPerm)
@@ -689,19 +687,19 @@ func sWrite(ctx context.Context, s *Server, r *Req) {
}()
switch file := r.fid.File.(type) {
case io.WriterAt:
- n, err := file.WriteAt(ifcall.data, int64(ifcall.offset))
+ n, err := file.WriteAt(ifcall.Data, int64(ifcall.Offset))
if err != nil {
respond(ctx, r, fmt.Errorf("write: %v", err))
return
}
- ofcall.count = uint32(n)
+ ofcall.Count = uint32(n)
case io.Writer:
- n, err := file.Write(ifcall.data)
+ n, err := file.Write(ifcall.Data)
if err != nil {
respond(ctx, r, fmt.Errorf("write: %v", err))
return
}
- ofcall.count = uint32(n)
+ ofcall.Count = uint32(n)
default:
respond(ctx, r, ErrOperation)
return
@@ -726,12 +724,12 @@ func rWrite(r *Req, err error) {
func sClunk(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TClunk)
- _, ok := s.fPool.lookup(ifcall.Fid())
+ _, ok := s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
}
- s.fPool.delete(ifcall.Fid())
+ s.fPool.delete(ifcall.Fid)
r.ofcall = &RClunk{}
respond(ctx, r, nil)
}
@@ -745,12 +743,12 @@ func rClunk(r *Req, err error) {
func sRemove(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TRemove)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
}
- defer s.fPool.delete(ifcall.Fid())
+ defer s.fPool.delete(ifcall.Fid)
parentPath := path.Dir(r.fid.path)
parent, err := s.fs.OpenFile(parentPath, OREAD, 0)
if err != nil {
@@ -783,7 +781,7 @@ func rRemove(r *Req, err error) {
func sStat(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TStat)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -795,7 +793,7 @@ func sStat(ctx context.Context, s *Server, r *Req) {
return
}
r.ofcall = &RStat{
- stat: fileInfo.Sys().(*Stat),
+ Stat: fileInfo.Sys().(*Stat),
}
respond(ctx, r, nil)
}
@@ -809,7 +807,7 @@ func rStat(r *Req, err error) {
func sWStat(ctx context.Context, s *Server, r *Req) {
ifcall := r.ifcall.(*TWStat)
var ok bool
- r.fid, ok = s.fPool.lookup(ifcall.Fid())
+ r.fid, ok = s.fPool.lookup(ifcall.Fid)
if !ok {
respond(ctx, r, ErrUnknownFid)
return
@@ -819,7 +817,7 @@ func sWStat(ctx context.Context, s *Server, r *Req) {
respond(ctx, r, ErrOperation)
return
}
- wstat := ifcall.Stat()
+ wstat := ifcall.Stat
fi, err := r.fid.File.Stat()
if err != nil {
respond(ctx, r, fmt.Errorf("stat: %v", err))
