maybe

packet.go

@@ -2,112 +2,54 @@ package main
 
 import (
 	"encoding/binary"
-	"encoding/json"
-	"fmt"
 	"io"
 )
 
 const (
-	RemoteGetState           = uint16(0x01)
-	RemoteHandleMessage      = uint16(0x02)
-	ResponseBody             = uint16(0x03)
-	RemoteGetStateReply      = uint16(0x04)
-	RemoteHandleMessageReply = uint16(0x05)
+	RemoteGetState            = uint32(0x01)
+	RemoteHandleMutation      = uint32(0x02)
+	ResponseBody              = uint32(0x03)
+	RemoteGetStateReply       = uint32(0x04)
+	RemoteHandleMutationReply = uint32(0x05)
 )
 
 type CartPacket struct {
-	Version     uint16
-	MessageType uint16
-	DataLength  uint16
+	Version     uint32
+	MessageType uint32
+	DataLength  uint64
 	Id          CartId
 }
 
 type Packet struct {
-	Version     uint16
-	MessageType uint16
-	DataLength  uint16
+	Version     uint32
+	MessageType uint32
+	DataLength  uint64
 }
 
-func SendCartPacket(conn io.Writer, id CartId, messageType uint16, datafn func(w io.Writer) error) error {
-	data, err := GetData(datafn)
-	if err != nil {
-		return err
-	}
-	if conn == nil {
-		return fmt.Errorf("no connection to send to")
-	}
-	binary.Write(conn, binary.LittleEndian, CartPacket{
-		Version:     2,
-		MessageType: messageType,
-		DataLength:  uint16(len(data)),
-		Id:          id,
-	})
-	_, err = conn.Write(data)
-	return err
-}
-
-func SendPacket(conn io.Writer, messageType uint16, datafn func(w io.Writer) error) error {
-	data, err := GetData(datafn)
-	if err != nil {
-		return err
-	}
-	err = binary.Write(conn, binary.LittleEndian, Packet{
-		Version:     1,
-		MessageType: messageType,
-		DataLength:  uint16(len(data)),
-	})
-	if err != nil {
-		return err
-	}
-	packetsSent.Inc()
-	_, err = conn.Write(data)
-	return err
-}
-
-func SendRawResponse(conn io.Writer, data []byte) error {
-	err := binary.Write(conn, binary.LittleEndian, Packet{
-		Version:     1,
-		MessageType: ResponseBody,
-		DataLength:  uint16(len(data)),
-	})
-	if err != nil {
-		return err
-	}
-	_, err = conn.Write(data)
-	return err
-}
-
-func SendProxyResponse(conn io.Writer, data any) error {
-	return SendPacket(conn, ResponseBody, func(w io.Writer) error {
-		data, err := json.Marshal(data)
-		if err != nil {
-			return err
-		}
-		w.Write(data)
-		return nil
-	})
-}
-
-func ReadPacket[V Packet | CartPacket](conn io.Reader, packet *V) error {
+func ReadPacket(conn io.Reader, packet *Packet) error {
 	return binary.Read(conn, binary.LittleEndian, packet)
 }
 
-func GetPacketData(conn io.Reader, len uint16) ([]byte, error) {
+func ReadCartPacket(conn io.Reader, packet *CartPacket) error {
+	return binary.Read(conn, binary.LittleEndian, packet)
+}
+
+func GetPacketData(conn io.Reader, len uint64) ([]byte, error) {
 	data := make([]byte, len)
 	_, err := conn.Read(data)
 	return data, err
 }
 
-func ReceivePacket(conn io.Reader) (uint16, []byte, error) {
+func ReceivePacket(conn io.Reader) (uint32, []byte, error) {
 	var packet Packet
 	err := ReadPacket(conn, &packet)
 	if err != nil {
-		return packet.MessageType, nil, err
+		return 0, nil, err
 	}
 
 	data, err := GetPacketData(conn, packet.DataLength)
 	if err != nil {
-		return packet.MessageType, nil, err
+		return 0, nil, err
 	}
 	return packet.MessageType, data, nil
 }