me when i dont use vcs properly v2

proto/connection.go

@@ -7,12 +7,14 @@ import (
 	"io"
 	"net"
 
+	"github.com/admin-else/strom/data"
 	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto_base"
 )
 
 var BadPacketTypeError = errors.New("bad packet type")
 var BadPacketIdError = errors.New("bad packet id")
+var PacketNotFullyDecodedError = errors.New("packet not fully decoded")
 
 // UnCodablePacket represents a packet that could not be decoded due to proto_generated not supporting all packets.
 type UnCodablePacket struct {
@@ -33,14 +35,23 @@ func (u *UnCodablePacket) Decode(r io.Reader) (err error) {
 
 type Conn struct {
 	net.Conn
-	R                                io.Reader
-	W                                io.Writer
-	CompressionThreshold             int32
-	State                            proto_base.State
-	Actor                            proto_base.Actor
-	Version                          string
-	ProtocolVersion                  int32
-	DontDecodePacketsWithoutHandlers bool
+	R                    io.Reader
+	W                    io.Writer
+	CompressionThreshold int32
+	State                proto_base.State
+	Actor                proto_base.Actor
+	Version              string
+	ProtocolVersion      int32
+}
+
+func (c *Conn) SetVersion(version string) (err error) {
+	c.Version = version
+	versionData, err := data.LookUpProtocolVersionByName(c.Version)
+	if err != nil {
+		return
+	}
+	c.ProtocolVersion = int32(versionData.Version)
+	return
 }
 
 func (c *Conn) Send(packet proto_base.EncodeDecodeAble) (err error) {
@@ -48,7 +59,7 @@ func (c *Conn) Send(packet proto_base.EncodeDecodeAble) (err error) {
 	case *UnCodablePacket:
 		err = c.SendRaw(packet.Data)
 	default:
-		i, ok := LookupPacketInfoByTypeAndMore(packet, c.State)
+		i, ok := LookupPacketInfoByTypeLookupPacketInfoByTypeAndMore(packet, c.State)
 		if !ok {
 			err = BadPacketTypeError
 		}
@@ -109,6 +120,10 @@ func (c *Conn) ReceiveRaw() (packetBytes []byte, err error) {
 	if err != nil {
 		return
 	}
+	if len(rawPacketBytes) != int(rawPacketLen) {
+		err = errors.New("bad packet length")
+		return
+	}
 	rawPacketBuffer := bytes.NewBuffer(rawPacketBytes)
 	if c.CompressionThreshold > 0 {
 		var packetLen int32
@@ -159,6 +174,11 @@ func (c *Conn) Receive() (packet proto_base.EncodeDecodeAble, err error) {
 		packet = &UnCodablePacket{Err: err, Data: packetBytes, Direction: c.Actor.ReceiveDirection()}
 		err = nil
 	}
+	if b.Len() != 0 {
+		err = nil
+		packet = &UnCodablePacket{Err: PacketNotFullyDecodedError, Data: packetBytes, Direction: c.Actor.ReceiveDirection()}
+		return
+	}
 	return
 }
 
@@ -174,7 +194,7 @@ func (c *Conn) Start(insts []any) (err error) {
 		var packet any
 		packet, err = c.Receive()
 		if err != nil {
-			return
+			break
 		}
 		err = event.Fire(packet, handlers)
 		if err != nil {

proto/connection_test.go

@@ -0,0 +1,59 @@
+package proto_test
+
+import (
+	"bytes"
+	"math"
+	"testing"
+
+	"github.com/admin-else/strom/proto"
+	"github.com/admin-else/strom/server"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+)
+
+var nanIgnorer32 = cmp.Comparer(func(x, y float32) bool {
+	return (math.IsNaN(float64(x)) && math.IsNaN(float64(y))) || x == y
+})
+
+var nanIgnorer64 = cmp.Comparer(func(x, y float64) bool {
+	return (math.IsNaN(x) && math.IsNaN(y)) || x == y
+})
+
+func FuzzConn(f *testing.F) {
+	f.Fuzz(func(t *testing.T, inbytes []byte) {
+		b1 := bytes.NewBuffer(inbytes)
+		b2 := bytes.NewBuffer(nil)
+		conn := server.Servee(nil)
+		conn.R = b1
+		conn.W = b2
+		_ = conn.SetVersion("1.21.8") // cant fail
+		p, err := conn.Receive()
+		if err != nil {
+			t.Skip(err)
+			return
+		}
+		if b1.Len() != 0 {
+			t.Skip("not all bytes read")
+			return
+		}
+		err = conn.Send(p)
+		if err != nil {
+			t.Fatal(err)
+			return
+		}
+		b1.Reset()
+		conn.R = b2
+		conn.W = b1
+		p2, err := conn.Receive()
+		if err != nil {
+			t.Fatal(err)
+			return
+		}
+		if !cmp.Equal(p, p2, nanIgnorer32, nanIgnorer64, cmpopts.IgnoreFields(proto.UnCodablePacket{}, "Err")) {
+			t.Error("decoded and encoded decoded data are not equal",
+				cmp.Diff(p, p2, nanIgnorer32, nanIgnorer64, cmpopts.IgnoreFields(proto.UnCodablePacket{}, "Err")),
+			)
+		}
+		return
+	})
+}

proto/packet_lookup.go

@@ -39,6 +39,7 @@ func LookupPacketInfoByType(packet proto_base.EncodeDecodeAble) (p proto_base.Pa
 			PacketId:        -1,
 			ProtocolVersion: -1,
 		}
+		ok = true
 	default:
 		for _, p := range proto_generated.Packets {
 			if reflect.TypeOf(p.Type) == reflect.TypeOf(packet) {
@@ -49,7 +50,7 @@ func LookupPacketInfoByType(packet proto_base.EncodeDecodeAble) (p proto_base.Pa
 	return
 }
 
-func LookupPacketInfoByTypeAndMore(packet proto_base.EncodeDecodeAble, state proto_base.State) (p proto_base.PacketInfo, ok bool) {
+func LookupPacketInfoByTypeLookupPacketInfoByTypeAndMore(packet proto_base.EncodeDecodeAble, state proto_base.State) (p proto_base.PacketInfo, ok bool) {
 	switch packet := packet.(type) {
 	case *UnCodablePacket:
 		p = proto_base.PacketInfo{

proto/packet_test.go

@@ -1,5 +1,6 @@
 package proto_test
 
+/*
 import (
 	"bytes"
 	"math"
@@ -51,3 +52,4 @@ func FuzzPlayPackets(f *testing.F) {
 		}
 	})
 }
+*/