Add TCP alternative to RakNet

server/server.go

@@ -6,17 +6,20 @@ import (
 
 // Server represents a server connected to the proxy which players can join and play on.
 type Server struct {
-	name    string
-	address string
+	name      string
+	address   string
+	useRakNet bool
 
 	playerCount atomic.Int64
 }
 
-// New creates a new Server with the provided name, group and address.
-func New(name, address string) *Server {
+// New creates a new Server with the provided name, group and address as well as if the connection should use the RakNet
+// protocol or not.
+func New(name, address string, useRakNet bool) *Server {
 	s := &Server{
-		name:    name,
-		address: address,
+		name:      name,
+		address:   address,
+		useRakNet: useRakNet,
 	}
 
 	return s
@@ -33,6 +36,11 @@ func (s *Server) Address() string {
 	return s.address
 }
 
+// UseRakNet returns if a connection should use the RakNet protocol when connecting to the server.
+func (s *Server) UseRakNet() bool {
+	return s.useRakNet
+}
+
 // IncrementPlayerCount increments the player count of the server.
 func (s *Server) IncrementPlayerCount() {
 	s.playerCount.Add(1)

session/server_conn.go

@@ -0,0 +1,225 @@
+package session
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"github.com/klauspost/compress/snappy"
+	"github.com/paroxity/portal/session/tcpprotocol"
+	"github.com/sandertv/gophertunnel/minecraft"
+	"github.com/sandertv/gophertunnel/minecraft/protocol"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/login"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+	"go.uber.org/atomic"
+	"io"
+	"net"
+	"sync"
+	"time"
+)
+
+// ServerConn represents a connection that can be used between the proxy and a server to communicate on behalf of a client.
+type ServerConn interface {
+	io.Closer
+	// GameData returns specific game data set to the connection for the player to be initialised with. This data is
+	// obtained from the server during the login process.
+	GameData() minecraft.GameData
+	// DoSpawnTimeout starts the game for the client in the server with a timeout after which an error is returned if the
+	// client has not yet spawned by that time. DoSpawnTimeout will start the spawning sequence using the game data found
+	// in conn.GameData(), which was sent earlier by the server.
+	DoSpawnTimeout(timeout time.Duration) error
+	// ReadPacket reads a packet from the Conn, depending on the packet ID that is found in front of the packet data. If
+	// a read deadline is set, an error is returned if the deadline is reached before any packet is received. ReadPacket
+	// must not be called on multiple goroutines simultaneously. If the packet read was not implemented, a *packet.Unknown
+	// is returned, containing the raw payload of the packet read.
+	ReadPacket() (packet.Packet, error)
+	// WritePacket encodes the packet passed and writes it to the Conn. The encoded data is buffered until the next 20th
+	// of a second, after which the data is flushed and sent over the connection.
+	WritePacket(packet.Packet) error
+}
+
+// TCPConn represents a player's connection to a server that is using the TCP protocol instead of RakNet.
+type TCPConn struct {
+	conn net.Conn
+	pool packet.Pool
+
+	identityData login.IdentityData
+	clientData   login.ClientData
+	gameData     minecraft.GameData
+
+	sendMu   sync.Mutex
+	hdr      *packet.Header
+	buf      *bytes.Buffer
+	shieldID atomic.Int32
+
+	spawn chan struct{}
+}
+
+// NewTCPConn attempts to create a new TCP-based connection to the provided server using the provided client data. If
+// successful the connection will be returned, otherwise an error will be returned instead.
+func NewTCPConn(address, playerAddress string, identityData login.IdentityData, clientData login.ClientData) (*TCPConn, error) {
+	conn := &TCPConn{
+		identityData: identityData,
+		clientData:   clientData,
+		pool:         packet.NewPool(),
+		buf:          bytes.NewBuffer(make([]byte, 0, 4096)),
+		hdr:          &packet.Header{},
+		spawn:        make(chan struct{}, 1),
+	}
+	err := conn.dial(address, playerAddress)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+// dial attempts to dial a connection to the provided address for the player. An error is returned if it failed to dial.
+func (conn *TCPConn) dial(address, playerAddress string) error {
+	tcpConn, err := net.Dial("tcp", address)
+	if err != nil {
+		return err
+	}
+	conn.conn = tcpConn
+	err = conn.WritePacket(&tcpprotocol.PlayerIdentity{
+		IdentityData: conn.identityData,
+		ClientData:   conn.clientData,
+		Address:      playerAddress,
+	})
+	if err != nil {
+		return err
+	}
+	pk, err := conn.ReadPacket()
+	if err != nil {
+		return err
+	}
+	startGame, ok := pk.(*packet.StartGame)
+	if !ok {
+		return fmt.Errorf("expected start game packet, got %T (%d)", pk, pk.ID())
+	}
+	conn.gameData = minecraft.GameData{
+		Difficulty:                   startGame.Difficulty,
+		WorldName:                    startGame.WorldName,
+		EntityUniqueID:               startGame.EntityUniqueID,
+		EntityRuntimeID:              startGame.EntityRuntimeID,
+		PlayerGameMode:               startGame.PlayerGameMode,
+		BaseGameVersion:              startGame.BaseGameVersion,
+		PlayerPosition:               startGame.PlayerPosition,
+		Pitch:                        startGame.Pitch,
+		Yaw:                          startGame.Yaw,
+		Dimension:                    startGame.Dimension,
+		WorldSpawn:                   startGame.WorldSpawn,
+		EditorWorld:                  startGame.EditorWorld,
+		GameRules:                    startGame.GameRules,
+		Time:                         startGame.Time,
+		ServerBlockStateChecksum:     startGame.ServerBlockStateChecksum,
+		CustomBlocks:                 startGame.Blocks,
+		Items:                        startGame.Items,
+		PlayerMovementSettings:       startGame.PlayerMovementSettings,
+		WorldGameMode:                startGame.WorldGameMode,
+		ServerAuthoritativeInventory: startGame.ServerAuthoritativeInventory,
+		Experiments:                  startGame.Experiments,
+	}
+	return nil
+}
+
+// Close ...
+func (conn *TCPConn) Close() error {
+	return conn.conn.Close()
+}
+
+// GameData ...
+func (conn *TCPConn) GameData() minecraft.GameData {
+	return conn.gameData
+}
+
+// DoSpawnTimeout ...
+func (conn *TCPConn) DoSpawnTimeout(timeout time.Duration) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("spawn timeout")
+	case <-conn.spawn:
+		return nil
+	}
+}
+
+// ReadPacket ...
+func (conn *TCPConn) ReadPacket() (pk packet.Packet, err error) {
+	var l uint32
+	if err := binary.Read(conn.conn, binary.LittleEndian, &l); err != nil {
+		return nil, err
+	}
+
+	data := make([]byte, l)
+	read, err := conn.conn.Read(data)
+	if err != nil {
+		return nil, err
+	}
+	if read != int(l) {
+		return nil, fmt.Errorf("expected %v bytes, got %v", l, read)
+	}
+
+	decoded, err := snappy.Decode(nil, data)
+	if err != nil {
+		return nil, err
+	}
+
+	buf := bytes.NewBuffer(decoded)
+	header := &packet.Header{}
+	if err := header.Read(buf); err != nil {
+		return nil, err
+	}
+
+	pkFunc, ok := conn.pool[header.PacketID]
+	if !ok {
+		return nil, fmt.Errorf("unknown packet %v", header.PacketID)
+	}
+
+	defer func() {
+		if recoveredErr := recover(); recoveredErr != nil {
+			err = fmt.Errorf("%T: %w", pk, recoveredErr.(error))
+		}
+	}()
+	pk = pkFunc()
+	pk.Unmarshal(protocol.NewReader(buf, 0))
+	if buf.Len() > 0 {
+		return nil, fmt.Errorf("still have %v bytes unread", buf.Len())
+	}
+
+	if _, ok := pk.(*packet.StartGame); ok {
+		close(conn.spawn)
+	}
+
+	return pk, nil
+}
+
+// WritePacket ...
+func (conn *TCPConn) WritePacket(pk packet.Packet) error {
+	conn.sendMu.Lock()
+	conn.hdr.PacketID = pk.ID()
+	_ = conn.hdr.Write(conn.buf)
+
+	pk.Marshal(protocol.NewWriter(conn.buf, conn.shieldID.Load()))
+
+	data := conn.buf.Bytes()
+	conn.buf.Reset()
+	conn.sendMu.Unlock()
+
+	encoded := snappy.Encode(nil, data)
+
+	buf := bytes.NewBuffer(make([]byte, 0, 4+len(encoded)))
+
+	if err := binary.Write(buf, binary.LittleEndian, int32(len(encoded))); err != nil {
+		return err
+	}
+	if _, err := buf.Write(encoded); err != nil {
+		return err
+	}
+
+	if _, err := conn.conn.Write(buf.Bytes()); err != nil {
+		return err
+	}
+
+	return nil
+}

session/session.go

@@ -33,8 +33,8 @@ type Session struct {
 	loginMu        sync.RWMutex
 	serverMu       sync.RWMutex
 	server         *server.Server
-	serverConn     *minecraft.Conn
-	tempServerConn *minecraft.Conn
+	serverConn     ServerConn
+	tempServerConn ServerConn
 
 	entities    *i64set.Set
 	playerList  *b16set.Set
@@ -105,13 +105,16 @@ func New(conn *minecraft.Conn, store *Store, loadBalancer LoadBalancer, log inte
 
 // dial dials a new connection to the provided server. It then returns the connection between the proxy and
 // that server, along with any error that may have occurred.
-func (s *Session) dial(srv *server.Server) (*minecraft.Conn, error) {
+func (s *Session) dial(srv *server.Server) (ServerConn, error) {
 	i := s.conn.IdentityData()
 	i.XUID = ""
-	return minecraft.Dialer{
-		ClientData:   s.conn.ClientData(),
-		IdentityData: i,
-	}.Dial("raknet", srv.Address())
+	if srv.UseRakNet() {
+		return minecraft.Dialer{
+			ClientData:   s.conn.ClientData(),
+			IdentityData: i,
+		}.Dial("raknet", srv.Address())
+	}
+	return NewTCPConn(srv.Address(), s.conn.RemoteAddr().String(), i, s.conn.ClientData())
 }
 
 // login performs the initial login sequence for the session.
@@ -152,7 +155,7 @@ func (s *Session) Server() *server.Server {
 }
 
 // ServerConn returns the connection for the session's current server.
-func (s *Session) ServerConn() *minecraft.Conn {
+func (s *Session) ServerConn() ServerConn {
 	s.waitForLogin()
 	s.serverMu.RLock()
 	defer s.serverMu.RUnlock()

session/tcpprotocol/connection_request.go

@@ -0,0 +1,26 @@
+package tcpprotocol
+
+import (
+	"github.com/sandertv/gophertunnel/minecraft/protocol"
+)
+
+// ConnectionRequest is sent by the proxy to request a connection for a player who is attempting to join the server.
+type ConnectionRequest struct {
+	// ProtocolVersion is the protocol version of the TCP protocol used by the proxy.
+	ProtocolVersion uint32
+}
+
+// ID ...
+func (pk *ConnectionRequest) ID() uint32 {
+	return IDConnectionRequest
+}
+
+// Marshal ...
+func (pk *ConnectionRequest) Marshal(w *protocol.Writer) {
+	w.Uint32(&pk.ProtocolVersion)
+}
+
+// Unmarshal ...
+func (pk *ConnectionRequest) Unmarshal(r *protocol.Reader) {
+	r.Uint32(&pk.ProtocolVersion)
+}

session/tcpprotocol/connection_response.go

@@ -0,0 +1,32 @@
+package tcpprotocol
+
+import (
+	"github.com/sandertv/gophertunnel/minecraft/protocol"
+)
+
+const (
+	ConnectionResponseSuccess byte = iota
+	ConnectionResponseInvalidProtocol
+)
+
+// ConnectionResponse is sent by the server in response to a ConnectionRequest packet. It contains the response and if
+// the player was able to connect to the server successfully.
+type ConnectionResponse struct {
+	// Response is the response from the server. This can be one of the constants above.
+	Response byte
+}
+
+// ID ...
+func (pk *ConnectionResponse) ID() uint32 {
+	return IDConnectionResponse
+}
+
+// Marshal ...
+func (pk *ConnectionResponse) Marshal(w *protocol.Writer) {
+	w.Uint8(&pk.Response)
+}
+
+// Unmarshal ...
+func (pk *ConnectionResponse) Unmarshal(r *protocol.Reader) {
+	r.Uint8(&pk.Response)
+}

session/tcpprotocol/id.go

@@ -0,0 +1,22 @@
+package tcpprotocol
+
+import (
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+	"math"
+)
+
+// ProtocolVersion is the current supported version of the protocol. If a server is using an outdated version of the
+// protocol, players will be unable to connect. This constant gets updated every time the protocol is changed.
+const ProtocolVersion = 1
+
+const (
+	IDConnectionRequest uint32 = math.MaxUint32 - iota
+	IDConnectionResponse
+	IDPlayerIdentity
+)
+
+func init() {
+	packet.Register(IDPlayerIdentity, func() packet.Packet { return &PlayerIdentity{} })
+	packet.Register(IDConnectionRequest, func() packet.Packet { return &ConnectionRequest{} })
+	packet.Register(IDConnectionResponse, func() packet.Packet { return &ConnectionResponse{} })
+}