commit c906244a1cb98a8524fe21e7f6b7c0de3cec5ac3
parent 51da7e87bad29b7c3983eb9cf3e32db331d1daa0
Author: Matsuda Kenji <info@mtkn.jp>
Date: Fri, 28 Jul 2023 15:45:54 +0900
change RVersion to struct
Diffstat:
| M | fcall.go | | | 56 | ++++++++++++++++++++++++++++++++++++-------------------- |
| M | parse.go | | | 29 | +++++++++++++++++++++++++++++ |
| M | req.go | | | 29 | ----------------------------- |
| M | server.go | | | 18 | ++++++++++-------- |
4 files changed, 75 insertions(+), 57 deletions(-)
diff --git a/fcall.go b/fcall.go
@@ -125,28 +125,44 @@ func (msg *TVersion) String() string {
msg.Tag(), msg.MSize(), msg.Version())
}
-type RVersion []byte
-
-func (msg RVersion) Size() uint32 { return gbit32(msg[0:4]) }
-func (msg RVersion) SetSize(s uint32) { pbit32(msg[0:4], s) }
-func (msg RVersion) Type() MsgType { return MsgType(msg[4]) }
-func (msg RVersion) SetType(t MsgType) { msg[4] = byte(t) }
-func (msg RVersion) Tag() uint16 { return gbit16(msg[5:7]) }
-func (msg RVersion) SetTag(t uint16) { pbit16(msg[5:7], t) }
-func (msg RVersion) MSize() uint32 { return gbit32(msg[7:11]) }
-func (msg RVersion) SetMSize(s uint32) { pbit32(msg[7:11], s) }
-func (msg RVersion) Version() string {
- vsize := gbit16(msg[11:13])
- return string(msg[13 : 13+vsize])
-}
-func (msg RVersion) SetVersion(v string) {
- pbit16(msg[4+1+2+4:4+1+2+4+2], uint16(len(v)))
- for i := 0; i < len(v); i++ {
- msg[4+1+2+4+2+i] = byte(v[i])
+type RVersion struct {
+ tag uint16
+ mSize uint32
+ version string
+}
+
+func newRVersion(buf []byte) *RVersion { panic("not implemented") }
+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) conv2M() []byte {
+ cur := 0
+ buf := make([]byte, msg.Size())
+ pbit32(buf[cur:cur+4], msg.Size())
+ cur += 4
+ buf[cur] = uint8(Rversion)
+ cur += 1
+ pbit16(buf[cur:cur+2], msg.Tag())
+ cur += 2
+ pbit32(buf[cur:cur+4], msg.MSize())
+ cur += 4
+ pbit16(buf[cur:cur+2], uint16(len(msg.Version())))
+ cur += 2
+ for i, b := range []byte(msg.Version()) {
+ buf[cur+i] = b
}
+ cur += len(msg.Version())
+ if cur != len(buf) {
+ panic("length of buf and cursor not match")
+ }
+ return buf
}
-func (msg RVersion) conv2M() []byte { return []byte(msg)[:msg.Size()] }
-func (msg RVersion) String() string {
+func (msg *RVersion) String() string {
return fmt.Sprintf("Rversion tag %d msize %d version '%s'",
msg.Tag(), msg.MSize(), msg.Version())
}
diff --git a/parse.go b/parse.go
@@ -31,3 +31,32 @@ func read9PMsg(r io.Reader) ([]byte, error) {
}
return buf, nil
}
+
+func unmarshal(buf []byte) (Msg, error) {
+ switch t := bufMsg(buf).Type(); t {
+ case Tversion:
+ return newTVersion(buf), nil
+ case Rversion:
+ return newRVersion(buf), nil
+ case Tauth:
+ return TAuth(buf), nil
+ case Rauth:
+ return RAuth(buf), nil
+ case Tattach:
+ return TAttach(buf), nil
+ case Rattach:
+ return RAttach(buf), nil
+ case Rerror:
+ return RError(buf), nil
+ case Twalk:
+ return newTWalk(buf), nil
+ case Rwalk:
+ return newRWalk(buf), nil
+ case Tstat:
+ return newTStat(buf), nil
+ case Rstat:
+ return newRStat(buf), nil
+ default:
+ return nil, fmt.Errorf("unknown message type %v", t)
+ }
+}
diff --git a/req.go b/req.go
@@ -11,35 +11,6 @@ type Req struct {
pool *ReqPool
}
-func unmarshal(buf []byte) (Msg, error) {
- switch t := bufMsg(buf).Type(); t {
- case Tversion:
- return newTVersion(buf), nil
- case Rversion:
- return RVersion(buf), nil
- case Tauth:
- return TAuth(buf), nil
- case Rauth:
- return RAuth(buf), nil
- case Tattach:
- return TAttach(buf), nil
- case Rattach:
- return RAttach(buf), nil
- case Rerror:
- return RError(buf), nil
- case Twalk:
- return newTWalk(buf), nil
- case Rwalk:
- return newRWalk(buf), nil
- case Tstat:
- return newTStat(buf), nil
- case Rstat:
- return newRStat(buf), nil
- default:
- return nil, fmt.Errorf("unknown message type %v", t)
- }
-}
-
type ReqPool struct {
m map[uint16]*Req
}
diff --git a/server.go b/server.go
@@ -10,6 +10,7 @@ import (
)
var chatty9P = false
+
func Chatty() {
chatty9P = true
}
@@ -97,13 +98,11 @@ func sVersion(s *Server, r *Req) {
msize = s.MSize
}
- size := uint32(4 + 1 + 2 + 4 + 2 + len(version))
- ofcall := RVersion(make([]byte, size))
- ofcall.SetSize(size)
- ofcall.SetType(Rversion)
- ofcall.SetTag(ifcall.Tag())
- ofcall.SetMSize(msize)
- ofcall.SetVersion(version)
+ ofcall := &RVersion{
+ tag: ifcall.Tag(),
+ mSize: msize,
+ version: version,
+ }
r.ofcall = ofcall
respond(r, nil)
@@ -170,6 +169,9 @@ func sWalk(s *Server, r *Req) {
func rWalk(r *Req, err error) {}
+func sOpen(s *Server, r *Req) {}
+func rOpen(r *Req, err error) {}
+
func rError(r *Req, err error) {
size := uint32(4 + 1 + 2 + 2 + len(err.Error()))
ofcall := RError(make([]byte, size))
@@ -258,7 +260,7 @@ func respond(r *Req, err error) {
} else {
rError(r, fmt.Errorf("unknown message type: %d", r.ofcall.Type()))
}
- case RVersion:
+ case *RVersion:
rVersion(r, err)
case RAuth:
rAuth(r, err)
