mirror of
https://github.com/itzg/mc-router.git
synced 2024-11-25 12:05:14 +01:00
309 lines
6.3 KiB
Go
309 lines
6.3 KiB
Go
package mcproto
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/binary"
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
"golang.org/x/text/encoding/unicode"
|
|
"golang.org/x/text/transform"
|
|
"io"
|
|
"net"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func ReadPacket(reader io.Reader, addr net.Addr, state State) (*Packet, error) {
|
|
logrus.
|
|
WithField("client", addr).
|
|
Debug("Reading packet")
|
|
|
|
if state == StateHandshaking {
|
|
bufReader := bufio.NewReader(reader)
|
|
data, err := bufReader.Peek(1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if data[0] == PacketIdLegacyServerListPing {
|
|
return ReadLegacyServerListPing(bufReader, addr)
|
|
} else {
|
|
reader = bufReader
|
|
}
|
|
}
|
|
|
|
frame, err := ReadFrame(reader, addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
packet := &Packet{Length: frame.Length}
|
|
|
|
remainder := bytes.NewBuffer(frame.Payload)
|
|
|
|
packet.PacketID, err = ReadVarInt(remainder)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
packet.Data = remainder.Bytes()
|
|
|
|
logrus.
|
|
WithField("client", addr).
|
|
WithField("packet", packet).
|
|
Debug("Read packet")
|
|
return packet, nil
|
|
}
|
|
|
|
func ReadLegacyServerListPing(reader *bufio.Reader, addr net.Addr) (*Packet, error) {
|
|
logrus.
|
|
WithField("client", addr).
|
|
Debug("Reading legacy server list ping")
|
|
|
|
packetId, err := reader.ReadByte()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if packetId != PacketIdLegacyServerListPing {
|
|
return nil, errors.Errorf("expected legacy server listing ping packet ID, got %x", packetId)
|
|
}
|
|
|
|
payload, err := reader.ReadByte()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if payload != 0x01 {
|
|
return nil, errors.Errorf("expected payload=1 from legacy server listing ping, got %x", payload)
|
|
}
|
|
|
|
packetIdForPluginMsg, err := reader.ReadByte()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if packetIdForPluginMsg != 0xFA {
|
|
return nil, errors.Errorf("expected packetIdForPluginMsg=0xFA from legacy server listing ping, got %x", packetIdForPluginMsg)
|
|
}
|
|
|
|
messageNameShortLen, err := ReadUnsignedShort(reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if messageNameShortLen != 11 {
|
|
return nil, errors.Errorf("expected messageNameShortLen=11 from legacy server listing ping, got %d", messageNameShortLen)
|
|
}
|
|
|
|
messageName, err := ReadUTF16BEString(reader, messageNameShortLen)
|
|
if messageName != "MC|PingHost" {
|
|
return nil, errors.Errorf("expected messageName=MC|PingHost, got %s", messageName)
|
|
}
|
|
|
|
remainingLen, err := ReadUnsignedShort(reader)
|
|
remainingReader := io.LimitReader(reader, int64(remainingLen))
|
|
|
|
protocolVersion, err := ReadByte(remainingReader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
hostnameLen, err := ReadUnsignedShort(remainingReader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
hostname, err := ReadUTF16BEString(remainingReader, hostnameLen)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
port, err := ReadUnsignedInt(remainingReader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Packet{
|
|
PacketID: PacketIdLegacyServerListPing,
|
|
Length: 0,
|
|
Data: &LegacyServerListPing{
|
|
ProtocolVersion: int(protocolVersion),
|
|
ServerAddress: hostname,
|
|
ServerPort: uint16(port),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func ReadUTF16BEString(reader io.Reader, symbolLen uint16) (string, error) {
|
|
bsUtf16be := make([]byte, symbolLen*2)
|
|
|
|
_, err := io.ReadFull(reader, bsUtf16be)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
result, _, err := transform.Bytes(unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM).NewDecoder(), bsUtf16be)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return string(result), nil
|
|
}
|
|
|
|
func ReadFrame(reader io.Reader, addr net.Addr) (*Frame, error) {
|
|
logrus.
|
|
WithField("client", addr).
|
|
Debug("Reading frame")
|
|
|
|
var err error
|
|
frame := &Frame{}
|
|
|
|
frame.Length, err = ReadVarInt(reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
logrus.
|
|
WithField("client", addr).
|
|
WithField("length", frame.Length).
|
|
Debug("Read frame length")
|
|
|
|
frame.Payload = make([]byte, frame.Length)
|
|
total := 0
|
|
for total < frame.Length {
|
|
readIntoThis := frame.Payload[total:]
|
|
n, err := reader.Read(readIntoThis)
|
|
if err != nil {
|
|
if err != io.EOF {
|
|
return nil, err
|
|
}
|
|
}
|
|
total += n
|
|
logrus.
|
|
WithField("client", addr).
|
|
WithField("total", total).
|
|
WithField("length", frame.Length).
|
|
Debug("Reading frame content")
|
|
|
|
if n == 0 {
|
|
logrus.
|
|
WithField("client", addr).
|
|
WithField("frame", frame).
|
|
Debug("No progress on frame reading")
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
logrus.
|
|
WithField("client", addr).
|
|
WithField("frame", frame).
|
|
Debug("Read frame")
|
|
return frame, nil
|
|
}
|
|
|
|
func ReadVarInt(reader io.Reader) (int, error) {
|
|
b := make([]byte, 1)
|
|
var numRead uint = 0
|
|
result := 0
|
|
for numRead <= 5 {
|
|
n, err := reader.Read(b)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
value := b[0] & 0x7F
|
|
result |= int(value) << (7 * numRead)
|
|
|
|
numRead++
|
|
|
|
if b[0]&0x80 == 0 {
|
|
return result, nil
|
|
}
|
|
}
|
|
|
|
return 0, errors.New("VarInt is too big")
|
|
}
|
|
|
|
func ReadString(reader io.Reader) (string, error) {
|
|
length, err := ReadVarInt(reader)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
b := make([]byte, 1)
|
|
var strBuilder strings.Builder
|
|
for i := 0; i < length; i++ {
|
|
n, err := reader.Read(b)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
strBuilder.WriteByte(b[0])
|
|
}
|
|
|
|
return strBuilder.String(), nil
|
|
}
|
|
|
|
func ReadByte(reader io.Reader) (byte, error) {
|
|
buf := make([]byte, 1)
|
|
_, err := reader.Read(buf)
|
|
if err != nil {
|
|
return 0, err
|
|
} else {
|
|
return buf[0], nil
|
|
}
|
|
}
|
|
|
|
func ReadUnsignedShort(reader io.Reader) (uint16, error) {
|
|
var value uint16
|
|
err := binary.Read(reader, binary.BigEndian, &value)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func ReadUnsignedInt(reader io.Reader) (uint32, error) {
|
|
var value uint32
|
|
err := binary.Read(reader, binary.BigEndian, &value)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func ReadHandshake(data interface{}) (*Handshake, error) {
|
|
|
|
dataBytes, ok := data.([]byte)
|
|
if !ok {
|
|
return nil, errors.New("data is not expected byte slice")
|
|
}
|
|
|
|
handshake := &Handshake{}
|
|
buffer := bytes.NewBuffer(dataBytes)
|
|
var err error
|
|
|
|
handshake.ProtocolVersion, err = ReadVarInt(buffer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
handshake.ServerAddress, err = ReadString(buffer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
handshake.ServerPort, err = ReadUnsignedShort(buffer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
nextState, err := ReadVarInt(buffer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
handshake.NextState = nextState
|
|
return handshake, nil
|
|
}
|