fix proxy

event/event_bus.go

@@ -125,6 +125,10 @@ func (l *Loop) RegisterDirect(k reflect.Type, h reflect.Value) {
 	l.HandlerFunctions[k] = append(l.HandlerFunctions[k], h)
 }
 
+func (l *Loop) RegisterIgnore(t any) {
+	l.RegisterDirect(reflect.TypeOf(t), reflect.ValueOf(func(any) error { return nil }))
+}
+
 // FireFound triggers all handlers registered for the specified event type and returns if handlers were found or an error occurred.
 func (l *Loop) FireFound(event any) (found bool, err error) {
 	var handlers []reflect.Value

server/login_server.go

@@ -63,6 +63,7 @@ func (l *LoginServer) OnHandshake(packet *v1_21_8.HandshakingToServerPacketSetPr
 		return
 	}
 
+	err = l.SetProtocolVersion(packet.ProtocolVersion)
 	return
 }
 
@@ -159,6 +160,7 @@ func WithCompatibleVersions(versions ...int32) LoginServerSetting {
 func ServeLogin(c *proto.Conn, settings ...LoginServerSetting) (ret *LoginServer, err error) {
 	ret = &LoginServer{Conn: c}
 	ret.RegisterCritical(ret.OnDefault)
+	ret.RegisterIgnore(event.Close{})
 	ret.RegisterUntilLatest(ret.OnHandshake)
 	ret.RegisterUntilLatest(ret.OnLoginStart)
 	ret.RegisterUntilLatest(ret.OnLoginAcknowledged)
@@ -168,6 +170,6 @@ func ServeLogin(c *proto.Conn, settings ...LoginServerSetting) (ret *LoginServer
 		s(ret)
 	}
 	ret.CompressionThreshold = 256
-	err = ret.StartLoop()
+	err = ret.StartConn()
 	return
 }

server/server.go

@@ -5,6 +5,7 @@ import (
 	"log/slog"
 	"net"
 
+	"github.com/admin-else/strom/event"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
 	"github.com/admin-else/strom/text"
@@ -19,6 +20,7 @@ func Servee(c net.Conn) (ret *proto.Conn) {
 	ret.Conn = c
 	ret.R = c
 	ret.W = c
+	ret.Loop = event.NewLoop()
 	return
 }
 

tools/uncodeable_packet_hunter_proxy/failed_packet.go.tmpl

@@ -0,0 +1,18 @@
+package failed_packets_test
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/admin-else/strom/proto_generated/v1_21_8"
+)
+
+// Error: %v
+func TestFailedPacket%10X(t *testing.T) {
+	p := v1_21_8.Play%vPacket{}
+	b := bytes.NewBuffer(%#v)
+	err := p.Decode(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

tools/uncodeable_packet_hunter_proxy/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"crypto/sha256"
+	_ "embed"
 	"fmt"
 	"log/slog"
 	"os"
@@ -9,105 +10,76 @@ import (
 	"github.com/admin-else/strom/api"
 	"github.com/admin-else/strom/client"
 	"github.com/admin-else/strom/event"
+	"github.com/admin-else/strom/nbt"
 	"github.com/admin-else/strom/proto"
 	"github.com/admin-else/strom/proto_base"
-	"github.com/admin-else/strom/proto_generated/v1_21_8"
+	"github.com/admin-else/strom/proto_generated/v1_21_11"
 	"github.com/admin-else/strom/server"
 	"github.com/admin-else/strom/text"
 )
 
-type ProxyClient struct {
+//go:embed failed_packet.go.tmpl
-	*proto.Conn
+var TestSrcF string
-	Server *Proxy
-}
-
-func (p *ProxyClient) OnDefault(event event.Unhandled) (err error) {
-	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
-	if !isPacket {
-		return
-	}
-	err = p.Server.Send(packet)
-	return
-}
-
-func (p *ProxyClient) OnCycle(_ event.Tick) (err error) {
-	return
-}
-
-func (p *ProxyClient) OnStart() (err error) {
-	return
-}
-
-func (p *ProxyClient) OnUnCodeAble(packet *proto.UnCodablePacket) (err error) {
-	err = p.OnDefault(event.Unhandled{Val: packet})
-	if err != nil {
-		return
-	}
-	SaveUnCodeAbleAsTest(proto_base.ToServer, packet)
-	return
-}
 
 type Proxy struct {
-	*proto.Conn
+	Client, Servee *proto.Conn
-	Client *ProxyClient
+	Data           nbt.Tag
 }
 
-func (p *Proxy) OnDefault(event event.Unhandled) (err error) {
+func (p *Proxy) Start() (err error) {
-	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
+	p.Client.RegisterCritical(p.OnAnything)
-	if !isPacket {
+	p.Servee.RegisterCritical(p.OnAnything)
+
+	p.Servee.Register(p.OnUnCodeAble)
+	p.Client.Register(p.OnUnCodeAble)
+
+	p.Servee.RegisterCriticalUntilLatest(p.OnFinishConfiguration)
+
+	errChan := make(chan error)
+	go func() {
+		errChan <- p.Client.StartConn()
+	}()
+	go func() {
+		errChan <- p.Servee.StartConn()
+	}()
+	err = <-errChan
+	return
+}
+
+func (p *Proxy) OnAnything(e event.Anything) (err error) {
+	packet, ok := e.Val.(proto_base.EncodeDecodeAble)
+	if !ok {
 		return
 	}
+	packetInfo, ok := proto.LookupPacketInfoByType(packet)
+	if !ok {
+		return
+	}
+	switch packetInfo.Direction {
+	case proto_base.ToServer:
+		err = p.Client.Send(packet)
+	case proto_base.ToClient:
+		err = p.Servee.Send(packet)
+	}
+	return
+}
+
+func (p *Proxy) OnFinishConfiguration(packet *v1_21_11.ConfigurationToServerPacketFinishConfiguration) (err error) {
 	err = p.Client.Send(packet)
-	return
-}
-
-func (p *Proxy) OnCycle(_ event.Tick) (err error) {
-	return
-}
-
-func (p *Proxy) OnStart() (err error) {
-	return
-}
-
-func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
-	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
 	}
-	p.SetState(proto_base.Play)
+	p.Servee.SetState(proto_base.Play)
 	p.Client.SetState(proto_base.Play)
+	err = event.DontForwardErr
 	return
 }
 
 func (p *Proxy) OnUnCodeAble(packet *proto.UnCodablePacket) (err error) {
-	err = p.OnDefault(event.Unhandled{Val: packet})
+	SaveUnCodeAbleAsTest(packet.Direction, packet)
-	if err != nil {
-		return
-	}
-	SaveUnCodeAbleAsTest(proto_base.ToClient, packet)
 	return
 }
 
-const TestSrcF = `package failed_packets_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/admin-else/strom/proto_generated/v1_21_8"
-)
-
-// Error: %v
-func TestFailedPacket%10X(t *testing.T) {
-	p := v1_21_8.Play%vPacket{}
-	b := bytes.NewBuffer(%#v)
-	err := p.Decode(b)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-`
-
 func SaveUnCodeAbleAsTest(d proto_base.Direction, packet *proto.UnCodablePacket) {
 	hUntrimmed := sha256.Sum256(packet.Data)
 	h := hUntrimmed[:8]
@@ -138,28 +110,20 @@ var StatusResponse = server.StatusResponse{
 
 func main() {
 	slog.SetLogLoggerLevel(slog.LevelDebug)
-	err := server.StartServerWithOnConn(":25565", func(serveeConn *proto.Conn) (err error) {
+	err := server.StartServerWithOnConn(":25566", func(serveeConn *proto.Conn) (err error) {
-		p := &Proxy{Conn: serveeConn, Client: nil}
+		p := &Proxy{Servee: serveeConn, Client: nil}
 		acc := api.NewOfflineAccount("sigma")
 		_, err = server.ServeLogin(serveeConn, server.WithOtherAccount(acc), server.WithStatus(StatusResponse))
 		if err != nil {
 			return
 		}
-		c, err := client.ConnectAndLogin("127.0.0.1:25566", acc)
+		c, err := client.ConnectAndLogin("127.0.0.1:25565", acc)
 		if err != nil {
 			return
 		}
-		pc := &ProxyClient{Conn: c, Server: p}
+		defer c.Close()
-		p.Client = pc
+		p.Client = c
-		errChan := make(chan error)
+		err = p.Start()
-		defer pc.Close()
-		go func() {
-			errChan <- pc.StartConn()
-		}()
-		go func() {
-			errChan <- p.StartConn()
-		}()
-		err = <-errChan
 		return
 	})
 	if err != nil {