conn.go: Fixed non-raknet packets not retaining their first byte.

Author: Sandertv

conn.go

@@ -15,9 +15,9 @@ import (
 )
 
 const (
-	// currentProtocol is the current RakNet protocol version. This is Minecraft
+	// protocolVersion is the current RakNet protocol version. This is Minecraft
 	// specific.
-	currentProtocol byte = 11
+	protocolVersion byte = 11
 
 	minMTUSize    = 576
 	maxMTUSize    = 1492
@@ -352,11 +352,11 @@ func (conn *Conn) Close() error {
 func (conn *Conn) closeImmediately() {
 	conn.once.Do(func() {
 		_, _ = conn.Write([]byte{message.IDDisconnectNotification})
-		close(conn.closed)
 		if conn.close != nil {
 			conn.close()
 			conn.close = nil
 		}
+		close(conn.closed)
 	})
 }
 
@@ -472,18 +472,14 @@ func (conn *Conn) receive(b *bytes.Buffer) error {
 	if err != nil {
 		return fmt.Errorf("error reading datagram header flags: %v", err)
 	}
-	if headerFlags&bitFlagDatagram == 0 {
-		// Ignore packets that do not have the datagram bitflag.
-		return nil
-	}
 	t := time.Now()
 	conn.lastActivity.Store(&t)
 	switch {
 	case headerFlags&bitFlagACK != 0:
 		return conn.handleACK(b)
 	case headerFlags&bitFlagNACK != 0:
 		return conn.handleNACK(b)
-	default:
+	case headerFlags&bitFlagDatagram != 0:
 		return conn.receiveDatagram(b)
 	}
 }
@@ -599,7 +595,7 @@ func (conn *Conn) handlePacket(b []byte) error {
 		// try to escape if the connection was closed.
 		select {
 		case <-conn.closed:
-		case conn.packets <- bytes.NewBuffer(b[1:]):
+		case conn.packets <- bytes.NewBuffer(b):
 		}
 	}
 	return nil

dial.go

@@ -332,7 +332,7 @@ func (state *connState) discoverMTU(ctx context.Context) error {
 			if err := response.UnmarshalBinary(b[1:n]); err != nil {
 				return fmt.Errorf("read incompatible protocol version: %w", err)
 			}
-			return fmt.Errorf("mismatched protocol: client protocol = %v, server protocol = %v", currentProtocol, response.ServerProtocol)
+			return fmt.Errorf("mismatched protocol: client protocol = %v, server protocol = %v", protocolVersion, response.ServerProtocol)
 		}
 	}
 }
@@ -404,7 +404,7 @@ func (state *connState) request2(ctx context.Context) {
 // openConnectionRequest1 sends an open connection request 1 packet to the
 // server. If not successful, an error is returned.
 func (state *connState) openConnectionRequest1(mtu uint16) {
-	data, _ := (&message.OpenConnectionRequest1{Protocol: currentProtocol, MaximumSizeNotDropped: mtu}).MarshalBinary()
+	data, _ := (&message.OpenConnectionRequest1{Protocol: protocolVersion, MaximumSizeNotDropped: mtu}).MarshalBinary()
 	_, _ = state.conn.Write(data)
 }
 

listener.go

@@ -185,11 +185,11 @@ func (listener *Listener) handle(b *bytes.Buffer, addr net.Addr) error {
 	if !found {
 		// If there was no session yet, it means the packet is an offline
 		// message. It is not contained in a datagram.
-		packetID, err := b.ReadByte()
+		id, err := b.ReadByte()
 		if err != nil {
 			return fmt.Errorf("error reading packet ID byte: %v", err)
 		}
-		switch packetID {
+		switch id {
 		case message.IDUnconnectedPing, message.IDUnconnectedPingOpenConnections:
 			return listener.handleUnconnectedPing(b, addr)
 		case message.IDOpenConnectionRequest1:
@@ -200,8 +200,8 @@ func (listener *Listener) handle(b *bytes.Buffer, addr net.Addr) error {
 			// In some cases, the client will keep trying to send datagrams
 			// while it has already timed out. In this case, we should not print
 			// an error.
-			if packetID&bitFlagDatagram == 0 {
-				return fmt.Errorf("unknown packet received (len=%v, id=%x): %x", b.Len(), packetID, b.Bytes())
+			if id&bitFlagDatagram == 0 {
+				return fmt.Errorf("unknown packet received (len=%v, id=%x): %x", b.Len(), id, b.Bytes())
 			}
 		}
 		return nil
@@ -212,11 +212,11 @@ func (listener *Listener) handle(b *bytes.Buffer, addr net.Addr) error {
 		// Connection was closed already.
 		return nil
 	default:
-		err := conn.receive(b)
-		if err != nil {
+		if err := conn.receive(b); err != nil {
 			conn.closeImmediately()
+			return err
 		}
-		return err
+		return nil
 	}
 }
 
@@ -274,10 +274,10 @@ func (listener *Listener) handleOpenConnectionRequest1(b *bytes.Buffer, addr net
 	b.Reset()
 	mtuSize := min(pk.MaximumSizeNotDropped, maxMTUSize)
 
-	if pk.Protocol != currentProtocol {
-		data, _ := (&message.IncompatibleProtocolVersion{ServerGUID: listener.id, ServerProtocol: currentProtocol}).MarshalBinary()
+	if pk.Protocol != protocolVersion {
+		data, _ := (&message.IncompatibleProtocolVersion{ServerGUID: listener.id, ServerProtocol: protocolVersion}).MarshalBinary()
 		_, _ = listener.conn.WriteTo(data, addr)
-		return fmt.Errorf("error handling open connection request 1: incompatible protocol version %v (listener protocol = %v)", pk.Protocol, currentProtocol)
+		return fmt.Errorf("error handling open connection request 1: incompatible protocol version %v (listener protocol = %v)", pk.Protocol, protocolVersion)
 	}
 
 	data, _ := (&message.OpenConnectionReply1{ServerGUID: listener.id, Secure: false, ServerPreferredMTUSize: mtuSize}).MarshalBinary()

packet.go

@@ -49,7 +49,7 @@ const (
 )
 
 // packet is an encapsulation around every packet sent after the connection is
-// established. It is
+// established.
 type packet struct {
 	reliability byte