From 8400d8f5dc5eed24ac812dac2846bb90a62e58e1 Mon Sep 17 00:00:00 2001 From: adman Date: Tue, 30 Dec 2025 14:15:43 +0100 Subject: [PATCH] me when i dont use vcs properly --- api/account.go | 2 +- client/modules/config_ignorer.go | 14 ++-- client/modules/login.go | 23 +++--- client/modules/status.go | 4 +- .../data/pc/1.21.8/protocol.json | 7 +- event/event_bus.go | 2 +- proto/connection.go | 69 +++++++++++++----- proto/packet_lookup.go | 71 +++++++++++++++++++ proto_base/base_types.go | 7 +- proto_generator/helper_generator.go | 9 ++- proto_generator/main.go | 23 +----- server/server.go | 8 +-- server/server_modules/login_server.go | 16 ++--- server/server_modules/status.go | 10 +-- tools/uncodeable_packet_hunter_proxy/main.go | 21 ++++-- 15 files changed, 192 insertions(+), 94 deletions(-) create mode 100644 proto/packet_lookup.go diff --git a/api/account.go b/api/account.go index d86bd7a..f820543 100644 --- a/api/account.go +++ b/api/account.go @@ -40,7 +40,7 @@ func (a *Account) doMcApiRequest(method string, url string, from any, to any) (e r.Header.Set("Content-Type", "application/json") r.Header.Set("Accept", "application/json") r.Header.Set("x-xbl-contract-version", "1") - r.Header.Set("Authorization", fmt.Sprintf("Bearer %s", a.Ygg)) + r.Header.Set("Authorization", "Bearer "+a.Ygg) resp, err := http.DefaultClient.Do(r) if err != nil { diff --git a/client/modules/config_ignorer.go b/client/modules/config_ignorer.go index 18a468a..856e418 100644 --- a/client/modules/config_ignorer.go +++ b/client/modules/config_ignorer.go @@ -19,12 +19,12 @@ func (c *ConfigIgnorer) Default(event any) (err error) { return } -func (c *ConfigIgnorer) OnKnownPacks(packet v1_21_8.PacketCommonSelectKnownPacks) (err error) { +func (c *ConfigIgnorer) OnKnownPacks(packet *v1_21_8.PacketCommonSelectKnownPacks) (err error) { return c.Send(packet) } func (c *ConfigIgnorer) OnFinish(_ v1_21_8.ConfigurationToClientPacketFinishConfiguration) (err error) { - err = c.Send(v1_21_8.ConfigurationToServerPacketFinishConfiguration{}) + err = c.Send(&v1_21_8.ConfigurationToServerPacketFinishConfiguration{}) if err != nil { return } @@ -33,18 +33,18 @@ func (c *ConfigIgnorer) OnFinish(_ v1_21_8.ConfigurationToClientPacketFinishConf return } -func (c *ConfigIgnorer) OnPing(packet v1_21_8.ConfigurationToClientPacketPing) (err error) { - err = c.Send(v1_21_8.ConfigurationToServerPacketPong(packet)) +func (c *ConfigIgnorer) OnPing(packet *v1_21_8.ConfigurationToClientPacketPing) (err error) { + err = c.Send(&v1_21_8.ConfigurationToServerPacketPong{Id: packet.Id}) return } -func (c *ConfigIgnorer) OnKeepAlive(packet v1_21_8.ConfigurationToClientPacketKeepAlive) (err error) { - err = c.Send(v1_21_8.ConfigurationToServerPacketKeepAlive(packet)) +func (c *ConfigIgnorer) OnKeepAlive(packet *v1_21_8.ConfigurationToClientPacketKeepAlive) (err error) { + err = c.Send(&v1_21_8.ConfigurationToServerPacketKeepAlive{KeepAliveId: packet.KeepAliveId}) return } func IgnoreConfig(c *proto.Conn) (err error) { - err = c.Start(&ConfigIgnorer{c}) + err = c.StartOne(&ConfigIgnorer{c}) if err != nil { err = errors.Join(err, errors.New("failed to ignore config")) } diff --git a/client/modules/login.go b/client/modules/login.go index f2b0961..a5220f8 100644 --- a/client/modules/login.go +++ b/client/modules/login.go @@ -26,10 +26,10 @@ type LoginClient struct { *proto.Conn Account *api.Account - GivenAccount v1_21_8.LoginToClientPacketSuccess + GivenAccount *v1_21_8.LoginToClientPacketSuccess } -func (s *LoginClient) Default(event any) (err error) { +func (s *LoginClient) Default(event event.Default) (err error) { err = fmt.Errorf("unexpected event: %#v", event) return } @@ -47,12 +47,13 @@ func (s *LoginClient) OnStart(_ event.OnStart) (err error) { if err != nil { return } + s.ProtocolVersion = int32(versionData.Version) port, err := strconv.Atoi(portStr) if err != nil { return } - err = s.Send(v1_21_8.HandshakingToServerPacketSetProtocol{ - ProtocolVersion: int32(versionData.Version), + err = s.Send(&v1_21_8.HandshakingToServerPacketSetProtocol{ + ProtocolVersion: s.ProtocolVersion, ServerHost: host, ServerPort: uint16(port), NextState: int32(proto_base.Login), @@ -61,11 +62,11 @@ func (s *LoginClient) OnStart(_ event.OnStart) (err error) { return } s.State = proto_base.Login - err = s.Send(v1_21_8.LoginToServerPacketLoginStart{Username: s.Account.Name, PlayerUUID: s.Account.Uuid}) + err = s.Send(&v1_21_8.LoginToServerPacketLoginStart{Username: s.Account.Name, PlayerUUID: s.Account.Uuid}) return } -func (s *LoginClient) OnCompress(compress v1_21_8.LoginToClientPacketCompress) (err error) { +func (s *LoginClient) OnCompress(compress *v1_21_8.LoginToClientPacketCompress) (err error) { s.CompressionThreshold = int32(compress.Threshold) return } @@ -104,7 +105,7 @@ func (s *LoginClient) OnEncrypt(packet v1_21_8.LoginToClientPacketEncryptionBegi if err != nil { return } - err = s.Send(v1_21_8.LoginToServerPacketEncryptionBegin{SharedSecret: sharedSecretEnc, VerifyToken: verifyTokenEnc}) + err = s.Send(&v1_21_8.LoginToServerPacketEncryptionBegin{SharedSecret: sharedSecretEnc, VerifyToken: verifyTokenEnc}) if err != nil { return } @@ -126,9 +127,9 @@ func (s *LoginClient) OnEncrypt(packet v1_21_8.LoginToClientPacketEncryptionBegi } -func (s *LoginClient) OnSuccess(success v1_21_8.LoginToClientPacketSuccess) (err error) { +func (s *LoginClient) OnSuccess(success *v1_21_8.LoginToClientPacketSuccess) (err error) { s.GivenAccount = success - err = s.Send(v1_21_8.LoginToServerPacketLoginAcknowledged{}) + err = s.Send(&v1_21_8.LoginToServerPacketLoginAcknowledged{}) if err != nil { return } @@ -138,7 +139,7 @@ func (s *LoginClient) OnSuccess(success v1_21_8.LoginToClientPacketSuccess) (err } func Login(c *proto.Conn, account *api.Account) (err error) { - err = c.Start(&LoginClient{ + err = c.StartOne(&LoginClient{ Conn: c, Account: account, }) @@ -153,7 +154,7 @@ func ConnectAndLogin(connectTo string, account *api.Account) (c *proto.Conn, err if err != nil { return } - err = c.Start(&LoginClient{ + err = c.StartOne(&LoginClient{ Conn: c, Account: account, }) diff --git a/client/modules/status.go b/client/modules/status.go index 3f4c034..96cc253 100644 --- a/client/modules/status.go +++ b/client/modules/status.go @@ -33,7 +33,7 @@ func (s *StatusClient) OnStart(_ event.OnStart) (err error) { if err != nil { return } - err = s.Send(v1_21_8.HandshakingToServerPacketSetProtocol{ + err = s.Send(&v1_21_8.HandshakingToServerPacketSetProtocol{ ProtocolVersion: int32(versionData.Version), ServerHost: parts[0], ServerPort: uint16(port), @@ -43,7 +43,7 @@ func (s *StatusClient) OnStart(_ event.OnStart) (err error) { return } s.State = proto_base.Status - err = s.Send(v1_21_8.StatusToServerPacketPingStart{}) + err = s.Send(&v1_21_8.StatusToServerPacketPingStart{}) return } diff --git a/data/minecraft-data/data/pc/1.21.8/protocol.json b/data/minecraft-data/data/pc/1.21.8/protocol.json index ee96ff7..07b5277 100644 --- a/data/minecraft-data/data/pc/1.21.8/protocol.json +++ b/data/minecraft-data/data/pc/1.21.8/protocol.json @@ -8541,6 +8541,11 @@ } ] ], + "packet_bundle_delimiter": [ + "container", + [ + ] + ], "packet": [ "container", [ @@ -8696,7 +8701,7 @@ { "compareTo": "name", "fields": { - "bundle_delimiter": "void", + "bundle_delimiter": "packet_bundle_delimiter", "spawn_entity": "packet_spawn_entity", "animation": "packet_animation", "statistics": "packet_statistics", diff --git a/event/event_bus.go b/event/event_bus.go index 5b55b14..62b9d51 100644 --- a/event/event_bus.go +++ b/event/event_bus.go @@ -25,7 +25,7 @@ func FindHandlers(insts []any) (handlers map[reflect.Type][]reflect.Value) { method := t.Method(i) if strings.HasPrefix(method.Name, "On") { if method.Type.NumIn() != 2 || method.Type.NumOut() != 1 || method.Type.Out(0) != reflect.TypeFor[error]() { - fmt.Println("Invalid event handler signature:", method.Name) + fmt.Println("Invalid event handler signature:", t.String(), ".", method.Name) continue } } else { diff --git a/proto/connection.go b/proto/connection.go index 9c635b4..0819254 100644 --- a/proto/connection.go +++ b/proto/connection.go @@ -9,15 +9,26 @@ import ( "github.com/admin-else/strom/event" "github.com/admin-else/strom/proto_base" - "github.com/admin-else/strom/proto_generated" ) var BadPacketTypeError = errors.New("bad packet type") +var BadPacketIdError = errors.New("bad packet id") // UnCodablePacket represents a packet that could not be decoded due to proto_generated not supporting all packets. type UnCodablePacket struct { - Err error - Data []byte + Err error + Data []byte + Direction proto_base.Direction +} + +func (u *UnCodablePacket) Encode(w io.Writer) (err error) { + _, err = w.Write(u.Data) + return +} + +func (u *UnCodablePacket) Decode(r io.Reader) (err error) { + err = errors.New("how did you even get here") + return } type Conn struct { @@ -28,27 +39,33 @@ type Conn struct { State proto_base.State Actor proto_base.Actor Version string + ProtocolVersion int32 DontDecodePacketsWithoutHandlers bool } -func (c *Conn) Send(packet any) (err error) { - var rawPacketBytes []byte +func (c *Conn) Send(packet proto_base.EncodeDecodeAble) (err error) { switch packet := packet.(type) { - case UnCodablePacket: - rawPacketBytes = packet.Data + case *UnCodablePacket: + err = c.SendRaw(packet.Data) default: - packetIdentifier := proto_generated.TypeToPacketIdentifier(c.Version, c.Actor.SendDirection(), c.State, packet) - if packetIdentifier == "" { + i, ok := LookupPacketInfoByTypeAndMore(packet, c.State) + if !ok { err = BadPacketTypeError - return } - rawPacketBuffer := bytes.NewBuffer(nil) - err = proto_generated.EncodePacket(c.Version, c.Actor.SendDirection(), c.State, packetIdentifier, packet, rawPacketBuffer) + var packetBuff = bytes.NewBuffer(nil) + err = proto_base.EncodeVarInt(packetBuff, i.PacketId) if err != nil { return } - rawPacketBytes = rawPacketBuffer.Bytes() + err = packet.Encode(packetBuff) + if err != nil { + return + } + err = c.SendRaw(packetBuff.Bytes()) } + return +} +func (c *Conn) SendRaw(rawPacketBytes []byte) (err error) { var packetBytes []byte if c.CompressionThreshold > 0 { packetBuffer := bytes.NewBuffer(nil) @@ -83,7 +100,7 @@ func (c *Conn) Send(packet any) (err error) { return } -func (c *Conn) Receive() (packet any, err error) { +func (c *Conn) ReceiveRaw() (packetBytes []byte, err error) { rawPacketLen, err := proto_base.DecodeVarInt(c.R) if err != nil { return @@ -93,7 +110,6 @@ func (c *Conn) Receive() (packet any, err error) { return } rawPacketBuffer := bytes.NewBuffer(rawPacketBytes) - var packetBytes []byte if c.CompressionThreshold > 0 { var packetLen int32 packetLen, err = proto_base.DecodeVarInt(rawPacketBuffer) @@ -120,10 +136,27 @@ func (c *Conn) Receive() (packet any, err error) { } else { packetBytes = rawPacketBytes } - packetBuff := bytes.NewBuffer(packetBytes) - packet, err = proto_generated.DecodePacket(c.Version, c.Actor.ReceiveDirection(), c.State, packetBuff) + return +} + +func (c *Conn) Receive() (packet proto_base.EncodeDecodeAble, err error) { + packetBytes, err := c.ReceiveRaw() if err != nil { - packet = UnCodablePacket{Err: err, Data: packetBytes} + return + } + b := bytes.NewBuffer(packetBytes) + id, err := proto_base.DecodeVarInt(b) + if err != nil { + return + } + packet, ok := LookUpTypeByPacketInfoAndCopyType(c.Actor.ReceiveDirection(), c.State, id, c.ProtocolVersion) + if !ok { + packet = &UnCodablePacket{Err: BadPacketIdError, Data: packetBytes, Direction: c.Actor.ReceiveDirection()} + return + } + err = packet.Decode(b) + if err != nil { + packet = &UnCodablePacket{Err: err, Data: packetBytes, Direction: c.Actor.ReceiveDirection()} err = nil } return diff --git a/proto/packet_lookup.go b/proto/packet_lookup.go new file mode 100644 index 0000000..c9859d6 --- /dev/null +++ b/proto/packet_lookup.go @@ -0,0 +1,71 @@ +package proto + +import ( + "reflect" + + "github.com/admin-else/strom/proto_base" + "github.com/admin-else/strom/proto_generated" +) + +// I know this is in-performant and i dont care until it becomes a problem for somebody it will stay like this and it is pretty easy to make caches or simular to speed this up so yeah + +func LookUpTypeByPacketInfo(direction proto_base.Direction, state proto_base.State, pid, version int32) (p proto_base.PacketInfo, ok bool) { + for _, pin := range proto_generated.Packets { + if pin.Direction != direction || pin.State != state || pin.ProtocolVersion != version || pin.PacketId != pid { + continue + } + return pin, true + } + return +} + +func LookUpTypeByPacketInfoAndCopyType(direction proto_base.Direction, state proto_base.State, pid, version int32) (p proto_base.EncodeDecodeAble, ok bool) { + i, ok := LookUpTypeByPacketInfo(direction, state, pid, version) + if !ok { + return + } + p = reflect.New(reflect.TypeOf(i.Type).Elem()).Interface().(proto_base.EncodeDecodeAble) + return +} + +func LookupPacketInfoByType(packet proto_base.EncodeDecodeAble) (p proto_base.PacketInfo, ok bool) { + switch packet := packet.(type) { + case *UnCodablePacket: + p = proto_base.PacketInfo{ + Type: &UnCodablePacket{}, + Name: "undecodeable", + Direction: packet.Direction, + State: -1, + PacketId: -1, + ProtocolVersion: -1, + } + default: + for _, p := range proto_generated.Packets { + if reflect.TypeOf(p.Type) == reflect.TypeOf(packet) { + return p, true + } + } + } + return +} + +func LookupPacketInfoByTypeAndMore(packet proto_base.EncodeDecodeAble, state proto_base.State) (p proto_base.PacketInfo, ok bool) { + switch packet := packet.(type) { + case *UnCodablePacket: + p = proto_base.PacketInfo{ + Type: &UnCodablePacket{}, + Name: "undecodeable", + Direction: packet.Direction, + State: -1, + PacketId: -1, + ProtocolVersion: -1, + } + default: + for _, p := range proto_generated.Packets { + if state == p.State && reflect.TypeOf(p.Type) == reflect.TypeOf(packet) { + return p, true + } + } + } + return +} diff --git a/proto_base/base_types.go b/proto_base/base_types.go index 356f4e5..b065240 100644 --- a/proto_base/base_types.go +++ b/proto_base/base_types.go @@ -4,7 +4,6 @@ import ( "encoding/binary" "errors" "io" - "reflect" ) type Direction int @@ -213,10 +212,10 @@ type EncodeDecodeAble interface { } type PacketInfo struct { - Type reflect.Type + Type EncodeDecodeAble Name string Direction Direction State State - PacketId int - ProtocolVersion int + PacketId int32 + ProtocolVersion int32 } diff --git a/proto_generator/helper_generator.go b/proto_generator/helper_generator.go index d3ce754..7922c02 100644 --- a/proto_generator/helper_generator.go +++ b/proto_generator/helper_generator.go @@ -79,14 +79,13 @@ func CollectPacketInfo(versions []string) (packetInfos []PacketInfo, err error) } func GeneratePacketInfoFile(versions []string) (err error) { - var packetInfos []PacketInfo - packetInfos, err = CollectPacketInfo(versions) + packetInfos, err := CollectPacketInfo(versions) if err != nil { return } f := NewFile("proto_generated") - imports := []string{"reflect", "github.com/admin-else/strom/proto_base"} + imports := []string{"github.com/admin-else/strom/proto_base"} for _, v := range versions { vUnderscore := strings.ReplaceAll(v, ".", "_") imports = append(imports, "github.com/admin-else/strom/proto_generated/v"+vUnderscore) @@ -109,8 +108,8 @@ func GeneratePacketInfoFile(versions []string) (err error) { packetId, _ := strconv.ParseInt(p.PacketId, 0, 32) protocolVersion, _ := strconv.Atoi(p.ProtocolVersion) - packetInfoExprs = append(packetInfoExprs, CompLit(Selector("proto_base", "PacketInfo"), []ast.Expr{ - KeyValueExpr(Ident("Type"), Call(Selector("reflect", "TypeOf"), CompLit(typeExpr, nil))), + packetInfoExprs = append(packetInfoExprs, CompLit(nil, []ast.Expr{ + KeyValueExpr(Ident("Type"), AddrOf(CompLit(typeExpr, nil))), KeyValueExpr(Ident("Name"), StrLit(p.Name)), KeyValueExpr(Ident("Direction"), Selector("proto_base", p.Direction)), KeyValueExpr(Ident("State"), Selector("proto_base", p.State)), diff --git a/proto_generator/main.go b/proto_generator/main.go index 4911f23..48dbed5 100644 --- a/proto_generator/main.go +++ b/proto_generator/main.go @@ -28,10 +28,6 @@ type Protocol struct { Handshaking, Status, Login, Configuration, Play State } -type Settings struct { - ReplaceWithTodoNames []string -} - type ContainerStackEntry struct { Data []struct { Name string @@ -43,7 +39,6 @@ type ContainerStackEntry struct { type Generator struct { // These persist the entire generate-call - Settings Settings Natives map[string]ExprGeneratorFunc DecoderNatives map[string]FunctionGeneratorFunc EncoderNatives map[string]FunctionGeneratorFunc @@ -202,10 +197,6 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) { g.CurrentlyGeneratingTypesPrefix = prefix for _, k := range OrderedKeys(types.Types) { v := types.Types[k] - if slices.Contains(g.Settings.ReplaceWithTodoNames, k) { - v = "todo" - } - g.Depth = 0 e, err2 := g.VisitType(v) if errors.Is(err2, ToDoError) { @@ -232,9 +223,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) { s, err2 := g.VisitDecoder(retExpr, v, tName) if err2 != nil { s = ToDoStmts - if !errors.Is(err2, ToDoError) { - fmt.Println("failed to make decoder for", k, err2) - } + fmt.Println("failed to make decoder for", k, err2) } decodeFunction.Body = NewBlock(append(s, Return())) AppendDecl(g.File, decodeFunction) @@ -246,13 +235,10 @@ func (g *Generator) GenerateTypes(prefix string, types Types) (err error) { s, err2 = g.VisitEncoder(retExpr, v, tName) if err2 != nil { s = ToDoStmts - if !errors.Is(err2, ToDoError) { - fmt.Println("failed to make encoder for", k, err2) - } + fmt.Println("failed to make encoder for", k, err2) } encodeFunction.Body = NewBlock(append(s, Return())) AppendDecl(g.File, encodeFunction) - } return } @@ -300,9 +286,6 @@ func Generate(version string, w io.Writer) (err error) { g := &Generator{Protocol: protocol} - // These have annoying edge cases that would require me to implement a whole new compareTo parser - g.Settings.ReplaceWithTodoNames = []string{} - g.File = NewFile("v" + strings.ReplaceAll(version, ".", "_")) AppendDecl(g.File, Import("encoding/binary", "io", "github.com/admin-else/strom/proto_base", "github.com/admin-else/strom/nbt", "github.com/google/uuid")) g.RegisterNatives() @@ -322,7 +305,7 @@ func generateVersion(v string) (err error) { if err != nil { return } - f, err := os.Create("proto_generated/v" + vUnderscore + "/proto_base.go") + f, err := os.Create("proto_generated/v" + vUnderscore + "/proto.go") if err != nil { return } diff --git a/server/server.go b/server/server.go index e9a6d8c..6cd9127 100644 --- a/server/server.go +++ b/server/server.go @@ -4,7 +4,6 @@ import ( "log" "net" - "github.com/admin-else/strom/event" "github.com/admin-else/strom/proto" "github.com/admin-else/strom/proto_base" ) @@ -12,6 +11,7 @@ import ( func Servee(c net.Conn) (ret *proto.Conn) { ret = &proto.Conn{} ret.Version = "1.21.8" + ret.ProtocolVersion = 772 ret.State = proto_base.Handshaking ret.CompressionThreshold = -1 ret.Actor = proto_base.Server @@ -21,17 +21,17 @@ func Servee(c net.Conn) (ret *proto.Conn) { return } -func ServeClient(cNet net.Conn, factory func(c *proto.Conn) (h event.HandlerInst, err error)) (err error) { +func ServeClient(cNet net.Conn, factory func(c *proto.Conn) (h any, err error)) (err error) { c := Servee(cNet) h, err := factory(c) if err != nil { return } - err = c.Start(h) + err = c.StartOne(h) return } -func StartServerWithFactory(listenAddr string, factory func(c *proto.Conn) (h event.HandlerInst, err error)) (err error) { +func StartServerWithFactory(listenAddr string, factory func(c *proto.Conn) (h any, err error)) (err error) { l, err := net.Listen("tcp", listenAddr) if err != nil { return diff --git a/server/server_modules/login_server.go b/server/server_modules/login_server.go index 789e58e..69af5d0 100644 --- a/server/server_modules/login_server.go +++ b/server/server_modules/login_server.go @@ -34,7 +34,7 @@ type LoginServer struct { CompressionThreshold int32 } -func (l *LoginServer) OnHandshake(packet v1_21_8.HandshakingToServerPacketSetProtocol) (err error) { +func (l *LoginServer) OnHandshake(packet *v1_21_8.HandshakingToServerPacketSetProtocol) (err error) { l.State = proto_base.State(packet.NextState) if packet.NextState != int32(proto_base.Login) { err = UnexpectedNextStateError{proto_base.State(packet.NextState)} @@ -44,7 +44,7 @@ func (l *LoginServer) OnHandshake(packet v1_21_8.HandshakingToServerPacketSetPro } func (l *LoginServer) SetCompressionThreshold(threshold int32) (err error) { - err = l.Send(v1_21_8.LoginToClientPacketCompress{Threshold: threshold}) + err = l.Send(&v1_21_8.LoginToClientPacketCompress{Threshold: threshold}) if err != nil { return } @@ -52,7 +52,7 @@ func (l *LoginServer) SetCompressionThreshold(threshold int32) (err error) { return } -func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart) (err error) { +func (l *LoginServer) OnLoginStart(packet *v1_21_8.LoginToServerPacketLoginStart) (err error) { l.Requested = NameAndUUID{packet.Username, packet.PlayerUUID} //err = l.SetCompressionThreshold(l.CompressionThreshold) //if err != nil { @@ -61,7 +61,7 @@ func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart) if l.Given == nil { l.Given = &l.Requested } - err = l.Send(v1_21_8.LoginToClientPacketSuccess{ + err = l.Send(&v1_21_8.LoginToClientPacketSuccess{ Uuid: l.Given.UUID, Username: l.Given.Name, Properties: nil, @@ -69,13 +69,13 @@ func (l *LoginServer) OnLoginStart(packet v1_21_8.LoginToServerPacketLoginStart) return } -func (l *LoginServer) OnLoginAcknowledged(_ v1_21_8.LoginToServerPacketLoginAcknowledged) (err error) { +func (l *LoginServer) OnLoginAcknowledged(_ *v1_21_8.LoginToServerPacketLoginAcknowledged) (err error) { l.State = proto_base.Configuration err = event.HandlerDone return } -func (l *LoginServer) Default(event any) (err error) { +func (l *LoginServer) OnDefault(event event.Default) (err error) { err = fmt.Errorf("unexpected event during login: %#v", event) fmt.Println(err) return @@ -92,7 +92,7 @@ func (l *LoginServer) OnCycle(_ event.OnLoopCycle) (err error) { func ServeLogin(c *proto.Conn) (ret *LoginServer, err error) { ret = &LoginServer{Conn: c} ret.CompressionThreshold = 256 - err = ret.Start(ret) + err = ret.StartOne(ret) return } @@ -102,6 +102,6 @@ func ServeLoginWithOtherAccount(c *proto.Conn, a *api.Account) (ret *LoginServer UUID: a.Uuid, }} ret.CompressionThreshold = 256 - err = ret.Start(ret) + err = ret.StartOne(ret) return } diff --git a/server/server_modules/status.go b/server/server_modules/status.go index 986fe09..cb367c8 100644 --- a/server/server_modules/status.go +++ b/server/server_modules/status.go @@ -37,12 +37,12 @@ func (p *StatusServer) Default(_ any) (err error) { return } -func (p *StatusServer) OnStatusRequest(_ v1_21_8.StatusToServerPacketPingStart) (err error) { - return p.Send(v1_21_8.StatusToClientPacketServerInfo{Response: p.Status}) +func (p *StatusServer) OnStatusRequest(_ *v1_21_8.StatusToServerPacketPingStart) (err error) { + return p.Send(&v1_21_8.StatusToClientPacketServerInfo{Response: p.Status}) } -func (p *StatusServer) OnStatusPing(packet v1_21_8.StatusToServerPacketPing) (err error) { - return p.Send(v1_21_8.StatusToClientPacketPing(packet)) +func (p *StatusServer) OnStatusPing(packet *v1_21_8.StatusToServerPacketPing) (err error) { + return p.Send(&v1_21_8.StatusToClientPacketPing{Time: packet.Time}) } func ServeStatus(c *proto.Conn, s StatusResponse) (err error) { @@ -54,6 +54,6 @@ func ServeStatus(c *proto.Conn, s StatusResponse) (err error) { Conn: c, Status: string(status), } - err = server.Start(server) + err = server.StartOne(server) return } diff --git a/tools/uncodeable_packet_hunter_proxy/main.go b/tools/uncodeable_packet_hunter_proxy/main.go index 1dd9e83..3bb1648 100644 --- a/tools/uncodeable_packet_hunter_proxy/main.go +++ b/tools/uncodeable_packet_hunter_proxy/main.go @@ -11,7 +11,6 @@ import ( "github.com/admin-else/strom/event" "github.com/admin-else/strom/proto" "github.com/admin-else/strom/proto_base" - "github.com/admin-else/strom/proto_generated" "github.com/admin-else/strom/proto_generated/v1_21_8" "github.com/admin-else/strom/server" "github.com/admin-else/strom/server/server_modules" @@ -23,7 +22,11 @@ type ProxyClient struct { } func (p *ProxyClient) OnDefault(event event.Default) (err error) { - err = p.Server.Send(event.Val) + packet, isPacket := event.Val.(proto_base.EncodeDecodeAble) + if !isPacket { + return + } + err = p.Server.Send(packet) return } @@ -49,8 +52,12 @@ type Proxy struct { Client *ProxyClient } -func (p *Proxy) Default(event any) (err error) { - err = p.Client.Send(event) +func (p *Proxy) OnDefault(event event.Default) (err error) { + packet, isPacket := event.Val.(proto_base.EncodeDecodeAble) + if !isPacket { + return + } + err = p.Client.Send(packet) return } @@ -62,8 +69,8 @@ func (p *Proxy) OnStart(_ event.OnStart) (err error) { return } -func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) { - err = p.Default(packet) +func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) { + err = p.OnDefault(event.Default{Val: packet}) if err != nil { return } @@ -73,7 +80,7 @@ func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacket } func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) { - err = p.Default(packet) + err = p.OnDefault(event.Default{Val: packet}) if err != nil { return }