support old ping

.github/workflows/build.yml

@@ -25,7 +25,7 @@ jobs:
         name: Build
         run: |
           mkdir output
-          bash ./cmds/liter-server/build.sh
+          bash ./cmds/liter-server/build.sh -ldflags="-X 'main.version=${GITHUB_REF#refs/*/}'"
           cp ./cmds/liter-server/litermc.service ./output/litermc.service
       -
         name: Create Release

cmds/liter-server/globals.go

@@ -94,7 +94,12 @@ func readConfig()(cfg Config){
 			cfg.ServerIP   = ""
 			cfg.ServerPort = 25565
 			cfg.Servers = []*ServerIns{
-				{ Id: "main", Target: "127.0.0.1:25665", ServerNames: []string{ "minecraft.example.com", "anotherdomain.example.com" } },
+				{
+					Id: "main",
+					Target: "127.0.0.1:25665",
+					ServerNames: []string{ "minecraft.example.com", "anotherdomain.example.com" },
+					MotdFailed: "Server is closed",
+				},
 			}
 			if data, err = yaml.Marshal(cfg); err != nil {
 				loger.Fatalf("Cannot encode config data: %v", err)

cmds/liter-server/main.go

@@ -114,6 +114,8 @@ func initBeforeLoad()(_ bool){
 }
 
 func main(){
+	loger.Infof("Liter Server %s", version)
+
 	scriptpath := filepath.Join(configDir, "plugins")
 	var (
 		err error
@@ -296,45 +298,16 @@ func handler(c *liter.Conn){
 	ploger.Infof("Connected with address [%s:%d], passing to server '%s'", hp.Addr, hp.Port, svr.Id)
 
 	if hp.NextState == liter.NextPingState && svr.HandlePing {
-		ploger.Debugf("Handle ping connection [%v] for server '%s'", svr.Id)
-		var srp liter.StatusRequestPkt
-		if err = c.RecvPkt(0x00, &srp); err != nil {
-			ploger.Errorf("Read status request packet error: %v", err)
-			return
-		}
-		if err = c.SendPkt(0x00, liter.StatusResponsePkt{
-			Payload: liter.Object{
-				"version": liter.Object{
-					"name": "Idle",
-					"protocol": 0,
-				},
-				"players": liter.Object{
-					"max": 1,
-					"online": 0,
-				},
-				"description": liter.Object{
-					"text": svr.Motd,
-				},
-			},
-		}); err != nil {
-			ploger.Errorf("Send packet error: %v", err)
-			return
-		}
-		var prp liter.PingRequestPkt
-		if err = c.RecvPkt(0x01, &prp); err != nil {
-			ploger.Errorf("Read ping request packet error: %v", err)
-			return
-		}
-		if err = c.SendPkt(0x01, (liter.PingResponsePkt)(prp)); err != nil {
-			ploger.Errorf("Send ping response packet error: %v", err)
-			return
-		}
+		ploger.Debugf("Handle ping connection for server '%s'", svr.Id)
+		handleServerStatus(ploger, c, "Idle", svr.Motd)
 		return
 	}
 
 	var conn *liter.Conn
 	if conn, err = liter.Dial(svr.Target); err != nil {
 		ploger.Errorf("Cannot dial to %q: %v", svr.Target, err)
+		ploger.Debugf("Handle ping connection for server '%s'", svr.Id)
+		handleServerStatus(ploger, c, "Closed", svr.MotdFailed)
 		return
 	}
 	if err = conn.SendHandshakePkt(hp); err != nil {
@@ -345,3 +318,39 @@ func handler(c *liter.Conn){
 	go io.Copy(rc, conn.RawConn())
 	io.Copy(conn.RawConn(), rc)
 }
+
+func handleServerStatus(loger logger.Logger, c *liter.Conn, version string, motd string){
+	var srp liter.StatusRequestPkt
+	var err error
+	if err = c.RecvPkt(0x00, &srp); err != nil {
+		loger.Errorf("Read status request packet error: %v", err)
+		return
+	}
+	if err = c.SendPkt(0x00, liter.StatusResponsePkt{
+		Payload: liter.Object{
+			"version": liter.Object{
+				"name": "Idle",
+				"protocol": 0,
+			},
+			"players": liter.Object{
+				"max": 1,
+				"online": 0,
+			},
+			"description": liter.Object{
+				"text": motd,
+			},
+		},
+	}); err != nil {
+		loger.Errorf("Send packet error: %v", err)
+		return
+	}
+	var prp liter.PingRequestPkt
+	if err = c.RecvPkt(0x01, &prp); err != nil {
+		loger.Errorf("Read ping request packet error: %v", err)
+		return
+	}
+	if err = c.SendPkt(0x01, (liter.PingResponsePkt)(prp)); err != nil {
+		loger.Errorf("Send ping response packet error: %v", err)
+		return
+	}
+}

cmds/liter-server/version.go

@@ -0,0 +1,10 @@
+
+package main
+
+var version string
+
+func init(){
+	if version == "" {
+		version = "dev"
+	}
+}

conn.go

@@ -3,13 +3,19 @@ package liter
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"io"
 	"net"
 	"strings"
 )
 
 const DefaultPort = 25565
 
+var (
+	ErrOldHandshake = errors.New("Old client(<=1.6) handshake received") // The handshake packet <= 1.6 which first byte is 0xFE
+)
+
 type PktIdAssertError struct {
 	Require int32
 	Got     int32
@@ -149,18 +155,62 @@ func (c *Conn)RecvHandshakePkt()(pkt *HandshakePkt, err error){
 	if c.protocol != V_UNSET {
 		panic("The first handshake packet is already has been received or sent")
 	}
-	var r *PacketReader
-	var p HandshakePkt
-	if r, err = c.Recv(); err != nil {
+
+	if pkt, err = readHandshakePacket(c.conn); err != nil {
 		return
 	}
-	if r.Id() != 0x00 {
-		return nil, &PktIdAssertError{ Require: 0x00, Got: (int32)(r.Id()) }
+	c.protocol = pkt.Protocol
+	return
+}
+
+func readHandshakePacket(r io.Reader)(p *HandshakePkt, err error){
+	var (
+		n int
+		size int32 = 0
+	)
+	{ // read varint
+		var (
+			i int = 0
+			b [1]byte
+			v0 uint32
+		)
+		for {
+			if _, err = r.Read(b[:]); err != nil {
+				return
+			}
+			if size == 0 && b[0] == 0xfe {
+				return nil, ErrOldHandshake
+			}
+			size++
+			v0 |= (uint32)(b[0] & 0x7f) << i
+			if b[0] & 0x80 == 0 {
+				n = (int)(v0)
+				break
+			}
+			if i += 7; i >= 32 {
+				return nil, VarIntTooBig
+			}
+		}
+	}
+	pr := &PacketReader{
+		protocol: V_UNSET, // we don't know the protocol before handshake
+		buf: make([]byte, (int32)(n) + size),
+		off: n,
+	}
+	encodeVarInt(pr.buf[:n], size)
+	if _, err = io.ReadFull(r, pr.buf[pr.off:]); err != nil {
+		return nil, err
 	}
-	if err = p.Decode(r); err != nil {
+	var ok bool
+	if pr.id, ok = pr.VarInt(); !ok {
+		return nil, io.EOF
+	}
+	if pr.id != 0x00 {
+		return nil, &PktIdAssertError{ Require: 0x00, Got: (int32)(pr.id) }
+	}
+	p = new(HandshakePkt)
+	if err = p.Decode(pr); err != nil {
 		return
 	}
-	c.protocol = p.Protocol
-	return &p, nil
+	return
 }
-

packets.go

@@ -359,17 +359,16 @@ func ReadPacket(protocol int, r io.Reader)(p *PacketReader, err error){
 	p = &PacketReader{
 		protocol: protocol,
 		buf: make([]byte, (int32)(n) + size),
-		off: (int)(n),
+		off: n,
 	}
 	encodeVarInt(p.buf[:n], size)
 	if _, err = io.ReadFull(r, p.buf[p.off:]); err != nil {
 		return nil, err
 	}
-	id, ok := p.VarInt()
-	if !ok {
+	var ok bool
+	if p.id, ok = p.VarInt(); !ok {
 		return nil, io.EOF
 	}
-	p.id = (VarInt)(id)
 	return
 }