mc-router/server/connector.go

253 lines
7.1 KiB
Go
Raw Normal View History

2018-05-08 05:16:01 +02:00
package server
import (
"bytes"
2018-05-08 05:16:01 +02:00
"context"
"github.com/go-kit/kit/metrics"
"github.com/itzg/mc-router/mcproto"
"github.com/juju/ratelimit"
"github.com/sirupsen/logrus"
2018-05-08 05:16:01 +02:00
"io"
"net"
"time"
2018-05-08 05:16:01 +02:00
)
const (
handshakeTimeout = 5 * time.Second
)
var noDeadline time.Time
type Connector interface {
StartAcceptingConnections(ctx context.Context, listenAddress string, connRateLimit int) error
2018-05-08 05:16:01 +02:00
}
2019-07-14 23:00:57 +02:00
type ConnectorMetrics struct {
Errors metrics.Counter
2019-07-14 23:00:57 +02:00
BytesTransmitted metrics.Counter
Connections metrics.Counter
ActiveConnections metrics.Gauge
}
func NewConnector(metrics *ConnectorMetrics) Connector {
return &connectorImpl{
metrics: metrics,
}
}
2018-05-08 05:16:01 +02:00
type connectorImpl struct {
2019-07-14 23:00:57 +02:00
state mcproto.State
metrics *ConnectorMetrics
2018-05-08 05:16:01 +02:00
}
func (c *connectorImpl) StartAcceptingConnections(ctx context.Context, listenAddress string, connRateLimit int) error {
2018-05-08 05:16:01 +02:00
ln, err := net.Listen("tcp", listenAddress)
if err != nil {
logrus.WithError(err).Fatal("Unable to start listening")
return err
}
logrus.WithField("listenAddress", listenAddress).Info("Listening for Minecraft client connections")
go c.acceptConnections(ctx, ln, connRateLimit)
2018-05-08 05:16:01 +02:00
return nil
}
func (c *connectorImpl) acceptConnections(ctx context.Context, ln net.Listener, connRateLimit int) {
//noinspection GoUnhandledErrorResult
2018-05-08 05:16:01 +02:00
defer ln.Close()
bucket := ratelimit.NewBucketWithRate(float64(connRateLimit), int64(connRateLimit*2))
2018-05-08 05:16:01 +02:00
for {
select {
case <-ctx.Done():
return
case <-time.After(bucket.Take(1)):
2018-05-08 05:16:01 +02:00
conn, err := ln.Accept()
if err != nil {
logrus.WithError(err).Error("Failed to accept connection")
} else {
go c.HandleConnection(ctx, conn)
}
}
}
}
func (c *connectorImpl) HandleConnection(ctx context.Context, frontendConn net.Conn) {
2020-01-04 21:52:07 +01:00
c.metrics.Connections.With("side", "frontend").Add(1)
//noinspection GoUnhandledErrorResult
2018-05-08 05:16:01 +02:00
defer frontendConn.Close()
clientAddr := frontendConn.RemoteAddr()
logrus.
WithField("client", clientAddr).
Info("Got connection")
defer logrus.WithField("client", clientAddr).Debug("Closing frontend connection")
2018-05-08 05:16:01 +02:00
inspectionBuffer := new(bytes.Buffer)
inspectionReader := io.TeeReader(frontendConn, inspectionBuffer)
2019-07-14 23:00:57 +02:00
if err := frontendConn.SetReadDeadline(time.Now().Add(handshakeTimeout)); err != nil {
logrus.
WithError(err).
WithField("client", clientAddr).
Error("Failed to set read deadline")
c.metrics.Errors.With("type", "read_deadline").Add(1)
2019-07-14 23:00:57 +02:00
return
}
packet, err := mcproto.ReadPacket(inspectionReader, clientAddr, c.state)
2018-05-08 05:16:01 +02:00
if err != nil {
logrus.WithError(err).WithField("clientAddr", clientAddr).Error("Failed to read packet")
c.metrics.Errors.With("type", "read").Add(1)
2018-05-08 05:16:01 +02:00
return
}
logrus.
WithField("client", clientAddr).
WithField("length", packet.Length).
WithField("packetID", packet.PacketID).
Debug("Got packet")
2018-05-08 05:16:01 +02:00
if packet.PacketID == mcproto.PacketIdHandshake {
handshake, err := mcproto.ReadHandshake(packet.Data)
if err != nil {
logrus.WithError(err).WithField("clientAddr", clientAddr).
Error("Failed to read handshake")
c.metrics.Errors.With("type", "read").Add(1)
2018-05-08 05:16:01 +02:00
return
}
logrus.
WithField("client", clientAddr).
WithField("handshake", handshake).
Debug("Got handshake")
2018-05-08 05:16:01 +02:00
serverAddress := handshake.ServerAddress
2018-05-08 05:16:01 +02:00
c.findAndConnectBackend(ctx, frontendConn, clientAddr, inspectionBuffer, serverAddress)
} else if packet.PacketID == mcproto.PacketIdLegacyServerListPing {
handshake, ok := packet.Data.(*mcproto.LegacyServerListPing)
if !ok {
logrus.
WithField("client", clientAddr).
WithField("packet", packet).
Warn("Unexpected data type for PacketIdLegacyServerListPing")
c.metrics.Errors.With("type", "unexpected_content").Add(1)
return
}
logrus.
WithField("client", clientAddr).
WithField("handshake", handshake).
Debug("Got legacy server list ping")
serverAddress := handshake.ServerAddress
c.findAndConnectBackend(ctx, frontendConn, clientAddr, inspectionBuffer, serverAddress)
2018-05-08 05:16:01 +02:00
} else {
logrus.
WithField("client", clientAddr).
WithField("packetID", packet.PacketID).
Error("Unexpected packetID, expected handshake")
c.metrics.Errors.With("type", "unexpected_content").Add(1)
return
2018-05-08 05:16:01 +02:00
}
}
func (c *connectorImpl) findAndConnectBackend(ctx context.Context, frontendConn net.Conn,
clientAddr net.Addr, preReadContent io.Reader, serverAddress string) {
backendHostPort, resolvedHost := Routes.FindBackendForServerAddress(serverAddress)
if backendHostPort == "" {
logrus.WithField("serverAddress", serverAddress).Warn("Unable to find registered backend")
c.metrics.Errors.With("type", "missing_backend").Add(1)
return
}
logrus.
WithField("client", clientAddr).
WithField("server", serverAddress).
WithField("backendHostPort", backendHostPort).
Info("Connecting to backend")
backendConn, err := net.Dial("tcp", backendHostPort)
if err != nil {
logrus.
WithError(err).
WithField("client", clientAddr).
WithField("serverAddress", serverAddress).
WithField("backend", backendHostPort).
Warn("Unable to connect to backend")
c.metrics.Errors.With("type", "backend_failed").Add(1)
return
}
2020-01-04 21:52:07 +01:00
c.metrics.Connections.With("side", "backend", "host", resolvedHost).Add(1)
c.metrics.ActiveConnections.Add(1)
defer c.metrics.ActiveConnections.Add(-1)
amount, err := io.Copy(backendConn, preReadContent)
if err != nil {
logrus.WithError(err).Error("Failed to write handshake to backend connection")
c.metrics.Errors.With("type", "backend_failed").Add(1)
return
}
logrus.WithField("amount", amount).Debug("Relayed handshake to backend")
if err = frontendConn.SetReadDeadline(noDeadline); err != nil {
logrus.
WithError(err).
WithField("client", clientAddr).
Error("Failed to clear read deadline")
c.metrics.Errors.With("type", "read_deadline").Add(1)
return
}
c.pumpConnections(ctx, frontendConn, backendConn)
return
}
func (c *connectorImpl) pumpConnections(ctx context.Context, frontendConn, backendConn net.Conn) {
//noinspection GoUnhandledErrorResult
2018-05-08 05:16:01 +02:00
defer backendConn.Close()
clientAddr := frontendConn.RemoteAddr()
defer logrus.WithField("client", clientAddr).Debug("Closing backend connection")
2018-05-08 05:16:01 +02:00
errors := make(chan error, 2)
go c.pumpFrames(backendConn, frontendConn, errors, "backend", "frontend", clientAddr)
go c.pumpFrames(frontendConn, backendConn, errors, "frontend", "backend", clientAddr)
2018-05-08 05:16:01 +02:00
select {
case err := <-errors:
if err != io.EOF {
logrus.WithError(err).
WithField("client", clientAddr).
Error("Error observed on connection relay")
c.metrics.Errors.With("type", "relay").Add(1)
2018-05-08 05:16:01 +02:00
}
case <-ctx.Done():
logrus.Debug("Observed context cancellation")
2018-05-08 05:16:01 +02:00
}
}
func (c *connectorImpl) pumpFrames(incoming io.Reader, outgoing io.Writer, errors chan<- error, from, to string, clientAddr net.Addr) {
2018-05-08 05:16:01 +02:00
amount, err := io.Copy(outgoing, incoming)
logrus.
WithField("client", clientAddr).
WithField("amount", amount).
Infof("Finished relay %s->%s", from, to)
c.metrics.BytesTransmitted.Add(float64(amount))
if err != nil {
errors <- err
} else {
// successful io.Copy return nil error, not EOF...to simulate that to trigger outer handling
errors <- io.EOF
}
2018-05-08 05:16:01 +02:00
}