lib/bedrock.js

@@ -1,60 +1,96 @@
 /**
  * Implementation of the RakNet ping/pong protocol.
- * @see https://wiki.vg/Raknet_Protocol
+ * @see https://wiki.vg/Raknet_Protocol#Unconnected_Ping
+ *
+ * Data types:
+ * @see https://wiki.vg/Raknet_Protocol#Data_types
  */
 
 'use strict';
 
 import dgram from 'dgram';
 
-const MAGIC = "00ffff00fefefefefdfdfdfd12345678";
 const START_TIME = new Date().getTime();
 
 /**
- * Creates an Unconnected Ping packet.
+ * Reads a BigInt value from the buffer at the specified offset using big-endian byte order.
- * @param {number} pingId
+ * @param {Buffer} buffer - The buffer to read from.
- * @returns {Buffer}
+ * @param {number} offset - The offset in the buffer to read the value.
+ * @returns {BigInt} - The read BigInt value.
+ */
+const readBigInt64BE = (buffer, offset) => {
+    return buffer.readBigInt64BE(offset);
+};
+
+/**
+ * Reads a string from the buffer at the specified offset.
+ * @param {Buffer} buffer - The buffer to read from.
+ * @param {number} offset - The offset in the buffer to read the string.
+ * @returns {string} - The read string.
+ */
+const readStringFromBuffer = (buffer, offset) => {
+    const length = buffer.readUInt16BE(offset);
+    return buffer.toString('utf8', offset + 2, offset + 2 + length);
+};
+
+/**
+ * Parses the advertise string into an object with properties.
+ * @param {string} advertiseStr - The advertise string to parse.
+ * @returns {Object} - The parsed object with properties.
+ */
+const parseAdvertiseString = (advertiseStr) => {
+    const parts = advertiseStr.split(';');
+    const parsedParts = {
+        gameId: parts[0],
+        description: parts[1],
+        protocolVersion: parts[2],
+        gameVersion: parts[3],
+        currentPlayers: parts[4],
+        maxPlayers: parts[5],
+        name: parts[7],
+        mode: parts[8]
+    };
+
+    return parsedParts;
+};
+
+/**
+ * Creates an Unconnected Ping buffer.
+ * @param {number} pingId - The ping ID.
+ * @returns {Buffer} - The Unconnected Ping buffer.
  * @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Ping}
  */
-const createUnconnectedPingFrame = (timestamp) => {
+const UNCONNECTED_PING = (pingId) => {
     const buffer = Buffer.alloc(33);
-    buffer.writeUInt8(0x01, 0); // Packet ID
+    buffer.writeUInt8(0x01, 0);
-    buffer.writeBigInt64LE(BigInt(timestamp), 1); // Timestamp
+    buffer.writeBigInt64LE(BigInt(pingId), 1);
-    Buffer.from(MAGIC, "hex").copy(buffer, 9); // OFFLINE_MESSAGE_DATA_ID (Magic)
+    Buffer.from("00ffff00fefefefefdfdfdfd12345678", "hex").copy(buffer, 9);
-    buffer.writeBigInt64LE(BigInt(0), 25); // Client GUID
+    buffer.writeBigInt64LE(BigInt(0), 25);
     return buffer;
 };
 
 /**
- * Extract Modt from Unconnected Pong Packet and convert to an object
+ * Decodes an Unconnected Pong buffer and returns the parsed data.
- * @param {Buffer} unconnectedPongPacket
+ * @param {Buffer} buffer - The Unconnected Pong buffer.
- * @returns {Object}
+ * @returns {Object} - The parsed Unconnected Pong data.
  * @see {@link https://wiki.vg/Raknet_Protocol#Unconnected_Pong}
  */
-const extractModt = (unconnectedPongPacket) => {
+const UNCONNECTED_PONG = (buffer) => {
-    // Skip everything to Modt
+    const pingId = readBigInt64BE(buffer, 1);
-    const offset = 33;
+    const serverId = readBigInt64BE(buffer, 9);
-    const length = unconnectedPongPacket.readUInt16BE(offset);
+    let offset = 25;
-    let modt = unconnectedPongPacket.toString("utf-8", offset + 2, offset + 2 + length);
+    let advertiseStr;
 
-    const components = modt.split(';');
+    try {
-    const parsedComponents = {
+        advertiseStr = readStringFromBuffer(buffer, offset);
-        edition: components[0],
+    } catch (err) {
-        name: components[1],
+        const length = parseInt(err.message.substr(err.message.indexOf(',') + 2, 3));
-        version: {
+        advertiseStr = buffer.toString('utf8', offset, offset + length);
-            protocolVersion: Number(components[2]),
+    }
-            minecraftVersion: components[3],
-        },
-        players: {
-            online: Number(components[4]),
-            max: Number(components[5])
-        },
-        serverId: components[6],
-        mapName: components[7],
-        gameMode: components[8]
-    };
 
-    return parsedComponents;
+    const parsedAdvertiseStr = parseAdvertiseString(advertiseStr);
+
+    return { pingId, advertiseStr, serverId, offset, ...parsedAdvertiseStr };
 };
 
 /**
@@ -97,20 +133,34 @@ const ping = (host, port = 19132, cb, timeout = 5000) => {
     };
 
     try {
-        const ping = createUnconnectedPingFrame(new Date().getTime() - START_TIME);
+        const ping = UNCONNECTED_PING(new Date().getTime() - START_TIME);
         socket.send(ping, 0, ping.length, port, host);
     } catch (err) {
         handleError(err);
     }
 
-    socket.on('message', (pongPacket) => {
+    socket.on('message', (msg) => {
-        const id = pongPacket[0];
+        const id = msg[0];
 
         switch (id) {
             case 0x1c: {
-                const modtObject = extractModt(pongPacket);
+                const pong = UNCONNECTED_PONG(msg);
+                const clientData = {
+                    name: pong.name,
+                    version: {
+                        gameVersion: pong.gameVersion,
+                        protocol: pong.protocolVersion
+                    },
+                    players: {
+                        max: pong.maxPlayers,
+                        online: pong.currentPlayers
+                    },
+                    description: pong.description.replace(/\xA7[0-9A-FK-OR]/ig, ''),
+                    gamemode: pong.mode
+                };
+
                 closeSocket();
-                cb(modtObject, null);
+                cb(clientData, null);
                 break;
             }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minescope/mineping",
-  "version": "1.4.1",
+  "version": "1.3.0",
   "description": "Ping both Minecraft Bedrock and Java servers.",
   "main": "index.js",
   "types": "types/index.d.ts",

types/lib/bedrock.d.ts

@@ -3,24 +3,22 @@
  * @param timeout The read/write socket timeout.
  */
 export type BedrockPingOptions = {
-    port?: number;
+    port?: number | undefined,
-    timeout?: number;
+    timeout?: number | undefined;
 };
 
 export type BedrockPingResponse = {
-    edition: string;
     name: string;
     version: {
-        protocolVersion: number;
+        gameVersion: string;
-        minecraftVersion: string;
+        protocol: string;
     };
     players: {
-        online: number;
+        max: string;
-        max: number;
+        online: string;
     };
-    serverId: string;
+    description: string;
-    mapName: string;
+    gamemode: string;
-    gameMode: string;
 };
 
 /**