From 3ddf830d3153c14333ef32016ba91f4df9b2abdb Mon Sep 17 00:00:00 2001 From: adman Date: Sat, 27 Dec 2025 19:34:27 +0100 Subject: [PATCH] Refactor void handling: add specialized encoder/decoder/type logic, update void-based operations for clarity and correctness --- nbt/nbt.go | 5 ++--- proto_base/base_types.go | 21 ++++++-------------- proto_generated/v1_21_8/helpers.go | 5 ++--- proto_generator/main.go | 6 +++--- proto_generator/native_decoder.go | 8 ++++++-- proto_generator/native_encoder.go | 12 +++++++++-- proto_generator/native_type.go | 7 ++++++- proto_generator/printer.go | 4 ++-- tools/uncodeable_packet_hunter_proxy/main.go | 17 ++++++++-------- 9 files changed, 46 insertions(+), 39 deletions(-) diff --git a/nbt/nbt.go b/nbt/nbt.go index 6257889..b6e372a 100644 --- a/nbt/nbt.go +++ b/nbt/nbt.go @@ -34,7 +34,7 @@ type Anon struct { Value any } -func (s Anon) Decode(r io.Reader) (ret Anon, err error) { +func (s *Anon) Decode(r io.Reader) (err error) { id := int8(0) err = binary.Read(r, Order, &id) if err != nil { @@ -44,11 +44,10 @@ func (s Anon) Decode(r io.Reader) (ret Anon, err error) { if err != nil { return } - ret = s return } -func (s Anon) Encode(w io.Writer) (err error) { +func (s *Anon) Encode(w io.Writer) (err error) { id, err := getId(s.Value) if err != nil { return diff --git a/proto_base/base_types.go b/proto_base/base_types.go index 4407a11..d1611c0 100644 --- a/proto_base/base_types.go +++ b/proto_base/base_types.go @@ -75,29 +75,20 @@ type PacketIdentifier struct { type ( ToDo struct{} - Void struct{} RestBuffer []byte ) -func (v Void) Encode(_ io.Writer) (err error) { - return -} - -func (v Void) Decode(_ io.Reader) (ret Void, err error) { - return -} - var ToDoError = errors.New("to do") var BadTypeError = errors.New("bad type") -func (r RestBuffer) Encode(w io.Writer) (err error) { - _, err = w.Write(r) +func (r *RestBuffer) Encode(w io.Writer) (err error) { + _, err = w.Write(*r) return } -func (RestBuffer) Decode(r io.Reader) (ret RestBuffer, err error) { +func (ret *RestBuffer) Decode(r io.Reader) (err error) { b, err := io.ReadAll(r) - ret = b + *ret = b return } @@ -215,7 +206,7 @@ func ErroringIndex[K comparable, V any, M map[K]V](m M, i K) (v V, err error) { return } -type EncodeDecodeAble[Self any] interface { +type EncodeDecodeAble interface { Encode(w io.Writer) (err error) - Decode(r io.Reader) (ret Self, err error) + Decode(r io.Reader) (err error) } diff --git a/proto_generated/v1_21_8/helpers.go b/proto_generated/v1_21_8/helpers.go index 13bc4a1..788d3fc 100644 --- a/proto_generated/v1_21_8/helpers.go +++ b/proto_generated/v1_21_8/helpers.go @@ -1,9 +1,8 @@ package v1_21_8 import ( - "io" - "github.com/admin-else/strom/proto_base" + "io" ) func HandshakingToServerPacketIdentifierToType(s string) (t any) { @@ -1205,7 +1204,7 @@ func DecodePacket(d proto_base.Direction, s proto_base.State, r io.Reader) (para params = packet.Params case proto_base.Play: var packet PlayToServerPacket - packet, err = PlayToServerPacket{}.Decode(r) + packet, err = packet.Decode(r) if err != nil { return } diff --git a/proto_generator/main.go b/proto_generator/main.go index b8e330e..3895d56 100644 --- a/proto_generator/main.go +++ b/proto_generator/main.go @@ -226,8 +226,8 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error { AppendDecl(g.File, TypeDecl(tName, e)) args := []NameAndType{{"r", Ident("io.Reader")}} - rets := []NameAndType{{"ret", Ident(tName)}, {"err", Ident("error")}} - decodeFunction := NewFuncWithReceiver("Decode", "_", tName, args, rets) + rets := []NameAndType{{"err", Ident("error")}} + decodeFunction := NewFuncWithReceiver("Decode", "ret", Pointer(Ident(tName)), args, rets) g.Depth = 0 s, err := g.VisitDecoder(retExpr, v, tName) if err != nil { @@ -241,7 +241,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error { args = []NameAndType{{"w", Ident("io.Writer")}} rets = []NameAndType{{"err", Ident("error")}} - encodeFunction := NewFuncWithReceiver("Encode", "ret", tName, args, rets) + encodeFunction := NewFuncWithReceiver("Encode", "ret", Pointer(Ident(tName)), args, rets) g.Depth = 0 s, err = g.VisitEncoder(retExpr, v, tName) if err != nil { diff --git a/proto_generator/native_decoder.go b/proto_generator/native_decoder.go index eaf0f54..ad861bc 100644 --- a/proto_generator/native_decoder.go +++ b/proto_generator/native_decoder.go @@ -12,7 +12,7 @@ import ( func DefaultDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) { s = Stmts( Assign( - Exprs(varToSet, Ident("err")), + Exprs(Ident("err")), Exprs(Call(SelectorExprAndStr(varToSet, "Decode"), Ident("r"))), ), IfErrNil(), @@ -511,6 +511,10 @@ func VarLongDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) ( return } +func VoidDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) { + return +} + func (g *Generator) RegisterDecoderNatives() { g.DecoderNatives = map[string]FunctionGeneratorFunc{ "container": ContainerDecoder, @@ -523,7 +527,7 @@ func (g *Generator) RegisterDecoderNatives() { "bitfield": BitFieldDecoder, "string": StringDecoder, - "void": DefaultDecoder, + "void": VoidDecoder, "varint": VarIntDecoder, "varlong": VarLongDecoder, "anonymousNbt": DefaultDecoder, diff --git a/proto_generator/native_encoder.go b/proto_generator/native_encoder.go index 128c3c5..ce5a600 100644 --- a/proto_generator/native_encoder.go +++ b/proto_generator/native_encoder.go @@ -192,7 +192,11 @@ func SwitchEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s if err != nil { return } - s1 := Define(Exprs(Ident(name), Ident("ok")), Exprs(TypeAssert(varToSet, tType))) + varName := name + if fType == "void" { + varName = "_" + } + s1 := Define(Exprs(Ident(varName), Ident("ok")), Exprs(TypeAssert(varToSet, tType))) s2 := If(Not(Ident("ok")), NewBlockEllipsis(Assign121(Ident("err"), Selector("proto_base", "BadTypeError")), Return())) var caseDecodeValueStmts []ast.Stmt caseDecodeValueStmts, err = g.VisitEncoder(Ident(name), fType, name) @@ -333,6 +337,10 @@ func VarLongEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) ( return } +func VoidEncoder(_ *Generator, _ ast.Expr, _ any, _ string) (s []ast.Stmt, err error) { + return +} + func (g *Generator) RegisterEncoderNatives() { g.EncoderNatives = map[string]FunctionGeneratorFunc{ "container": ContainerEncoder, @@ -344,7 +352,7 @@ func (g *Generator) RegisterEncoderNatives() { "buffer": BufferEncoder, "bitfield": BitFieldEncoder, - "void": DefaultEncoder, + "void": VoidEncoder, "varint": VarIntEncoder, "varlong": VarLongEncoder, "anonymousNbt": DefaultEncoder, diff --git a/proto_generator/native_type.go b/proto_generator/native_type.go index eeb6fc0..f97faca 100644 --- a/proto_generator/native_type.go +++ b/proto_generator/native_type.go @@ -153,6 +153,11 @@ func MakeSelectorVisitor(x, sel string) func(g *Generator, dataRaw any) (e ast.E } } +func VoidType(_ *Generator, _ any) (e ast.Expr, err error) { + e = NewStruct() + return +} + func (g *Generator) RegisterNatives() { g.Natives = map[string]ExprGeneratorFunc{ "container": VisitContainerType, @@ -164,7 +169,7 @@ func (g *Generator) RegisterNatives() { "native": VisitDontGenerateType, "anonymousNbt": MakeSelectorVisitor("nbt", "Anon"), "anonOptionalNbt": MakeSelectorVisitor("nbt", "Anon"), // I have no idea what the difference is between these two - "void": MakeSelectorVisitor("proto_base", "Void"), + "void": VoidType, "bool": MakeIdentVisitor("bool"), "u8": MakeIdentVisitor("uint8"), "u16": MakeIdentVisitor("uint16"), diff --git a/proto_generator/printer.go b/proto_generator/printer.go index 20d4d18..32e533d 100644 --- a/proto_generator/printer.go +++ b/proto_generator/printer.go @@ -269,13 +269,13 @@ func NewFunc(name string, arguments []NameAndType, returns []NameAndType) *ast.F } } -func NewFuncWithReceiver(name, receiverName, receiver string, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl { +func NewFuncWithReceiver(name, receiverName string, receiver ast.Expr, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl { f := NewFunc(name, arguments, returns) f.Recv = &ast.FieldList{ List: []*ast.Field{ { Names: []*ast.Ident{{Name: receiverName}}, - Type: &ast.Ident{Name: receiver}, + Type: receiver, }, }, } diff --git a/tools/uncodeable_packet_hunter_proxy/main.go b/tools/uncodeable_packet_hunter_proxy/main.go index e10b368..1dd9e83 100644 --- a/tools/uncodeable_packet_hunter_proxy/main.go +++ b/tools/uncodeable_packet_hunter_proxy/main.go @@ -11,6 +11,7 @@ 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" @@ -21,8 +22,8 @@ type ProxyClient struct { Server *Proxy } -func (p *ProxyClient) Default(event any) (err error) { - err = p.Server.Send(event) +func (p *ProxyClient) OnDefault(event event.Default) (err error) { + err = p.Server.Send(event.Val) return } @@ -34,8 +35,8 @@ func (p *ProxyClient) OnStart(_ event.OnStart) (err error) { return } -func (p *ProxyClient) OnUncodeable(packet proto.UnCodablePacket) (err error) { - err = p.Default(packet) +func (p *ProxyClient) OnUnCodeAble(packet proto.UnCodablePacket) (err error) { + err = p.OnDefault(event.Default{Val: packet}) if err != nil { return } @@ -71,7 +72,7 @@ func (p *Proxy) OnFinishConfiguration(packet v1_21_8.ConfigurationToServerPacket return } -func (p *Proxy) OnUncodeable(packet proto.UnCodablePacket) (err error) { +func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) { err = p.Default(packet) if err != nil { return @@ -117,7 +118,7 @@ func SaveUnCodeAbleAsTest(d proto_base.Direction, packet proto.UnCodablePacket) var StatusResponse = server_modules.StatusResponse{Description: struct { Text string `json:"text"` -}{Text: "Uncodeable packet hunter proxy"}, Version: struct { +}{Text: "Un-code-able packet hunter proxy"}, Version: struct { Name string `json:"name"` Protocol int `json:"protocol"` }{Name: "STROM", Protocol: 772}} @@ -143,10 +144,10 @@ func main() { defer pc.Close() defer p.Close() go func() { - errChan <- pc.Start(pc) + errChan <- pc.StartOne(pc) }() go func() { - errChan <- p.Start(p) + errChan <- p.StartOne(p) }() err = <-errChan return