various updates (May 2023)

Author: raqbit

connection.go

@@ -5,45 +5,62 @@ import (
 	"errors"
 	"fmt"
 	enc "github.com/Raqbit/mcproto/encoding"
-	"github.com/Raqbit/mcproto/game"
-	"github.com/Raqbit/mcproto/packet"
 	"io"
 	"net"
 	"time"
 )
 
+const MaxPacketLength = 1048576
+const (
+	clientBound PacketDirection = iota
+	serverBound PacketDirection = iota
+)
+
 var (
-	ErrConnectionState  = errors.New("connection has invalid state for packet type")
-	ErrDirection        = errors.New("packet being sent in wrong direction")
-	ErrLegacyServerPing = errors.New("not implemented: legacy server ping")
+	ErrInvalidPacketLength = errors.New("packet has a malformed length")
+	ErrLegacyServerPing    = errors.New("legacy server ping not supported")
 )
 
-// Connection represents a connection
-// to a Minecraft server or client.
-type Connection interface {
-	ReadPacket() (packet.Packet, error)
-	WritePacket(packet.Packet) error
-	SetReadDeadline(time.Time) error
-	SetWriteDeadline(time.Time) error
-	Close() error
-	SetState(state game.ConnectionState)
-}
+type (
+	// Packet is a packet with side-bound ID
+	Packet interface {
+		fmt.Stringer
+		enc.MinecraftEncodable
+		enc.MinecraftDecodable
 
-type connection struct {
-	conn     net.Conn
-	state    game.ConnectionState
-	side     Side
-	packets  map[packet.Info]packet.Packet
-	writeBuf *bytes.Buffer
-	readBuf  *bytes.Buffer
-	logger   Logger
-}
+		ID() int32
+	}
+
+	// Connection represents a connection
+	// to a Minecraft server or client.
+	Connection interface {
+		Read() (Packet, error)
+		Write(Packet) error
+		SetReadDeadline(time.Time) error
+		SetWriteDeadline(time.Time) error
+		Close() error
+		SetState(state ConnectionState)
+	}
+
+	// packetKey uniquely identifies a packet
+	packetKey struct {
+		id        int32
+		direction PacketDirection
+		state     ConnectionState
+	}
+
+	connection struct {
+		conn     net.Conn
+		state    ConnectionState
+		side     Side
+		packets  map[packetKey]Packet
+		writeBuf *bytes.Buffer
+		readBuf  *bytes.Buffer
+		logger   Logger
+	}
+)
 
-// ReadPacket reads a Minecraft protocol packet from the connection.
-// ReadPacket will also try to parse the contents of this packet and return
-// an error if the given packet ID is unknown or if the known packet format
-// did not decode correctly.
-func (c *connection) ReadPacket() (packet.Packet, error) {
+func (c *connection) Read() (Packet, error) {
 	var err error
 
 	// Read packet length
@@ -58,8 +75,8 @@ func (c *connection) ReadPacket() (packet.Packet, error) {
 	}
 
 	// Catch invalid packet lengths
-	if length < 1 || length > packet.MaxPacketLength {
-		return nil, packet.ErrInvalidPacketLength
+	if length < 1 || length > MaxPacketLength {
+		return nil, ErrInvalidPacketLength
 	}
 
 	// Read complete packet into read buffer
@@ -74,7 +91,7 @@ func (c *connection) ReadPacket() (packet.Packet, error) {
 	}
 
 	// Lookup packet type
-	pkt, err := c.getPacketTypeByID(int32(pID))
+	pkt, err := c.packetTypeFromID(int32(pID))
 
 	if err != nil {
 		return nil, err
@@ -98,15 +115,7 @@ func (c *connection) ReadPacket() (packet.Packet, error) {
 // If the provided deadline expires before a packet could be written,
 // an error is returned. Providing a zero value for the deadline will
 // make the read not time out.
-func (c *connection) WritePacket(packetToWrite packet.Packet) error {
-	if packetToWrite.State() != c.state {
-		return ErrConnectionState
-	}
-
-	if packetToWrite.Direction() != c.side.WriteDirection() {
-		return ErrDirection
-	}
-
+func (c *connection) Write(packetToWrite Packet) error {
 	c.logger.Debugf("[Send] %s, %d: %s\n", c.state, packetToWrite.ID(), packetToWrite.String())
 
 	packetId := enc.VarInt(packetToWrite.ID())
@@ -156,7 +165,7 @@ func (c *connection) SetWriteDeadline(t time.Time) error {
 
 // SetState switches the protocol to a different state,
 // which changes the meaning of packet IDs.
-func (c *connection) SetState(state game.ConnectionState) {
+func (c *connection) SetState(state ConnectionState) {
 	c.state = state
 }
 
@@ -166,35 +175,31 @@ func (c *connection) Close() error {
 	return c.conn.Close()
 }
 
-func (c *connection) registerPacket(pkt packet.Packet) {
-	c.packets[packet.Info{
-		ID:              pkt.ID(),
-		ConnectionState: pkt.State(),
-		Direction:       pkt.Direction(),
-	}] = pkt
+func (c *connection) registerPacket(pkt Packet, dir PacketDirection, state ConnectionState) {
+	c.packets[packetKey{id: pkt.ID(), direction: dir, state: state}] = pkt
 }
 
 type UnknownPacketError struct {
 	id        int32
-	direction packet.Direction
-	state     game.ConnectionState
+	direction PacketDirection
+	state     ConnectionState
 }
 
 func (u UnknownPacketError) Error() string {
-	return fmt.Sprintf("unknown packet ID, direction: %s, state: %s, ID: %#x", u.direction, u.state, u.id)
+	return fmt.Sprintf("unknown packet id, direction: %s, state: %s, id: %#x", u.direction, u.state, u.id)
 }
 
-func (c *connection) getPacketTypeByID(id int32) (packet.Packet, error) {
-	p, ok := c.packets[packet.Info{
-		ID:              id,
-		Direction:       c.side.ReadDirection(),
-		ConnectionState: c.state,
+func (c *connection) packetTypeFromID(id int32) (Packet, error) {
+	p, ok := c.packets[packetKey{
+		id:        id,
+		direction: c.side.readDirection(),
+		state:     c.state,
 	}]
 
 	if !ok {
 		return nil, UnknownPacketError{
 			id:        id,
-			direction: c.side.WriteDirection(),
+			direction: c.side.writeDirection(),
 			state:     c.state,
 		}
 	}

dial.go

@@ -3,7 +3,6 @@ package mcproto
 import (
 	"bytes"
 	"context"
-	"github.com/Raqbit/mcproto/game"
 	"github.com/Raqbit/mcproto/packet"
 	"net"
 )
@@ -43,7 +42,7 @@ func DialContext(ctx context.Context, address string, opts ...Option) (Connectio
 
 	// TODO: separate add timeout to SRV lookup
 	// Resolve server address from host & port, by checking SRV record & joining host & port
-	resolvedAddress := ResolveServerAddress(ctx, address)
+	resolvedAddress := resolveServerAddress(ctx, address)
 
 	// Make TCP connection
 	tcpConn, err := dialer.DialContext(ctx, "tcp", resolvedAddress)
@@ -52,10 +51,10 @@ func DialContext(ctx context.Context, address string, opts ...Option) (Connectio
 		return nil, resolvedAddress, err
 	}
 
-	// Set options
+	// Combine default options with given options
 	opts = append([]Option{
 		WithSide(ClientSide),
-		WithState(game.HandshakeState),
+		WithState(HandshakeState),
 	}, opts...)
 
 	// Wrap TCP connection in a wrapper for sending/receiving Minecraft packets
@@ -78,29 +77,29 @@ func Wrap(conn net.Conn, opts ...Option) Connection {
 	mcConn := &connection{
 		conn:     conn,
 		side:     ServerSide,
-		state:    game.HandshakeState,
-		packets:  make(map[packet.Info]packet.Packet),
+		state:    HandshakeState,
+		packets:  make(map[packetKey]Packet),
 		readBuf:  new(bytes.Buffer),
 		writeBuf: new(bytes.Buffer),
 		logger:   noopLogger{},
 	}
 
 	// Server bound packets
-	mcConn.registerPacket(&packet.HandshakePacket{})
-	mcConn.registerPacket(&packet.ServerQueryPacket{})
-	mcConn.registerPacket(&packet.PingPacket{})
-	mcConn.registerPacket(&packet.LoginStartPacket{})
-	mcConn.registerPacket(&packet.ClientSettingsPacket{})
+	mcConn.registerPacket(new(packet.HandshakePacket), serverBound, HandshakeState)
+	mcConn.registerPacket(new(packet.ServerQueryPacket), serverBound, StatusState)
+	mcConn.registerPacket(new(packet.PingPacket), serverBound, StatusState)
+	mcConn.registerPacket(new(packet.LoginStartPacket), serverBound, LoginState)
+	mcConn.registerPacket(new(packet.ClientSettingsPacket), serverBound, PlayState)
 
 	// Client bound packets
-	mcConn.registerPacket(&packet.PongPacket{})
-	mcConn.registerPacket(&packet.LoginSuccessPacket{})
-	mcConn.registerPacket(&packet.ChatMessagePacket{})
-	mcConn.registerPacket(&packet.ServerInfoPacket{})
-	mcConn.registerPacket(&packet.LoginDisconnectPacket{})
-	mcConn.registerPacket(&packet.JoinGamePacket{})
-	mcConn.registerPacket(&packet.PlayerPositionLookPacket{})
-	mcConn.registerPacket(&packet.PluginMessagePacket{})
+	mcConn.registerPacket(new(packet.PongPacket), clientBound, StatusState)
+	mcConn.registerPacket(new(packet.LoginSuccessPacket), clientBound, LoginState)
+	mcConn.registerPacket(new(packet.ChatMessagePacket), clientBound, PlayState)
+	mcConn.registerPacket(new(packet.ServerInfoPacket), clientBound, StatusState)
+	mcConn.registerPacket(new(packet.LoginDisconnectPacket), clientBound, LoginState)
+	mcConn.registerPacket(new(packet.JoinGamePacket), clientBound, PlayState)
+	mcConn.registerPacket(new(packet.PlayerPositionLookPacket), clientBound, PlayState)
+	mcConn.registerPacket(new(packet.PluginMessagePacket), clientBound, PlayState)
 
 	// Apply options
 	for _, opt := range opts {

direction.go

@@ -0,0 +1,11 @@
+package mcproto
+
+//go:generate stringer -type=PacketDirection -output direction_string.go -linecomment
+
+// PacketDirection is the direction of a packet
+type PacketDirection byte
+
+const (
+	ClientBound PacketDirection = iota // client-bound
+	ServerBound                        // server-bound
+)

direction_string.go

@@ -0,0 +1,13 @@
+package encoding
+
+import "io"
+
+// MinecraftEncodable types can be encoded for the Minecraft protocol
+type MinecraftEncodable interface {
+	Write(w io.Writer) error
+}
+
+// MinecraftDecodable types can be decoded for the Minecraft protocol
+type MinecraftDecodable interface {
+	Read(r io.Reader) error
+}

encoding/codec.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"github.com/Raqbit/mcproto"
 	enc "github.com/Raqbit/mcproto/encoding"
-	"github.com/Raqbit/mcproto/game"
 	"github.com/Raqbit/mcproto/packet"
 	"log"
 	"net"
@@ -43,27 +42,27 @@ func main() {
 		log.Fatal(err)
 	}
 
-	err = conn.WritePacket(&packet.HandshakePacket{
+	err = conn.Write(&packet.HandshakePacket{
 		ProtoVer:   ProtocolVersion,
 		ServerAddr: enc.String(host),
 		ServerPort: enc.UnsignedShort(port),
-		NextState:  game.StatusState,
+		NextState:  mcproto.StatusState.ID(),
 	})
 
 	// Actually update our connection as well
-	conn.SetState(game.StatusState)
+	conn.SetState(mcproto.StatusState)
 
 	if err != nil {
 		log.Fatalf("could not write handshake packet: %s", err)
 	}
 
-	err = conn.WritePacket(&packet.ServerQueryPacket{})
+	err = conn.Write(&packet.ServerQueryPacket{})
 
 	if err != nil {
 		log.Fatalf("could not write request packet: %s", err)
 	}
 
-	resp, err := conn.ReadPacket()
+	resp, err := conn.Read()
 
 	if err != nil {
 		log.Fatalf("could not read response packet: %s", err)