Big changes

main.go

@@ -56,6 +56,11 @@ type Reader struct {
 	cursor int
 }
 
+type ClientState struct {
+	conn      net.Conn
+	nextState int
+}
+
 func main() {
 	listener, err := net.Listen("tcp", "localhost:25565")
 	if err != nil {
@@ -73,62 +78,84 @@ func main() {
 			continue
 		}
 
-		go handleConnection(conn)
+		client := &ClientState{conn: conn, nextState: 0}
+
+		go handleConnection(client)
 	}
 }
 
-func handleConnection(conn net.Conn) {
+func handleConnection(client *ClientState) {
-	r := &Reader{data: make([]byte, 1024)}
+	defer client.conn.Close()
+	fmt.Println("New connection from:", client.conn.RemoteAddr())
+
+	r := &Reader{data: make([]byte, 0)}
 
-	// Print the whole packet
 	buf := make([]byte, 1024)
-	n, _ := conn.Read(buf)
-	r.data = buf[:n]
 
-	fmt.Println("Packet: ", r.data)
+	for {
-
+		n, err := client.conn.Read(buf)
-	_, err := r.readVarInt()
 		if err != nil {
-		fmt.Println("Error reading first number:", err)
+			fmt.Println("Error reading from connection or connection closed:", err)
-		return
+			break
+		}
+
+		// Append new data to the reader buffer
+		r.data = append(r.data, buf[:n]...)
+
+		// Process packets as long as there is data
+		for len(r.data) > 0 {
+			startCursor := r.cursor
+
+			packetLength, err := r.readVarInt()
+			if err != nil {
+				r.cursor = startCursor // Reset if incomplete packet
+				break
+			}
+
+			if len(r.data[r.cursor:]) < packetLength {
+				r.cursor = startCursor // Reset if incomplete packet
+				break
 			}
 
 			packetID, err := r.readVarInt()
 			if err != nil {
 				fmt.Println("Error reading packet ID:", err)
-		return
+				break
 			}
 
-	fmt.Println("Packet ID: ", packetID)
+			fmt.Println("Packet ID:", packetID)
 
-	switch packetID {
+			if packetID == StatusRequestID && client.nextState == 1 {
-	case HandshakePacketID:
+				handleStatusRequest(client.conn)
-		handleHandshake(r)
+			} else {
-	default:
+				if packetID == HandshakePacketID {
-		fmt.Println("Unknown packet ID:", packetID)
+					handshake, err := handleHandshake(r)
+					if err != nil {
+						fmt.Println("Error processing handshake:", err)
+						return
+					}
+					client.nextState = handshake.NextState
+				}
+			}
+
+			// Remove processed data
+			r.data = r.data[r.cursor:]
+			r.cursor = 0
+		}
 	}
 }
 
-func handleHandshake(r *Reader) {
+func handleHandshake(r *Reader) (HandshakePacket, error) {
 	var handshake HandshakePacket
 	if err := readHandshakePacket(r, &handshake); err != nil {
 		fmt.Println("Error reading handshake packet:", err)
-		return
+		return handshake, err
 	}
 
-	if handshake.NextState == 1 {
+	return handshake, nil
-		handleStatusRequest(r)
-	}
 }
 
-func handleStatusRequest(r *Reader) {
+func handleStatusRequest(conn net.Conn) {
-	packetID, err := r.readVarInt()
-	if err != nil {
-		fmt.Println("Error reading packet ID:", err)
-		return
-	}
-
-	if packetID == StatusRequestID {
 	status := StatusResponse{
 		Version: VersionInfo{
 			Name:     "1.17.1",
@@ -166,6 +193,11 @@ func handleStatusRequest(r *Reader) {
 		fmt.Println("Error writing response:", err)
 		return
 	}
+
+	// Send response to client
+	_, err = conn.Write(w.data[:w.cursor])
+	if err != nil {
+		fmt.Println("Error sending response:", err)
 	}
 }
 
@@ -218,6 +250,20 @@ func (r *Reader) readString() (string, error) {
 	return str, nil
 }
 
+func (r *Reader) readUnsignedShort() (uint16, error) {
+	b1, err := r.readByte()
+	if err != nil {
+		return 0, err
+	}
+
+	b2, err := r.readByte()
+	if err != nil {
+		return 0, err
+	}
+
+	return uint16(b1)<<8 | uint16(b2), nil
+}
+
 type Writer struct {
 	data   []byte
 	cursor int
@@ -304,11 +350,12 @@ func readHandshakePacket(r *Reader, packet *HandshakePacket) error {
 		return err
 	}
 
-	port, err := r.readByte()
+	port, err := r.readUnsignedShort()
 	if err != nil {
 		return err
 	}
-	packet.ServerPort = uint16(port)
+	packet.ServerPort = port
+	fmt.Println("Port: ", packet.ServerPort)
 
 	packet.NextState, err = r.readVarInt()
 	fmt.Println("Next state: ", packet.NextState)